diff --git a/.gitignore b/.gitignore
index d82c2f66db..6fceaf13ac 100644
--- a/.gitignore
+++ b/.gitignore
@@ -17,6 +17,7 @@ nbactions.xml
 /preferences.*
 .DS_Store
 /test-backend/
+.mvn/
 /nbproject/
 dependency-reduced-pom.xml
 
diff --git a/checkstyle.xml b/checkstyle.xml
index d6ed128d52..ecad32c6b8 100644
--- a/checkstyle.xml
+++ b/checkstyle.xml
@@ -31,6 +31,12 @@
 			<property name="message" value="Javadoc comment at column [\d]+ has parse error\. Details: no viable alternative at input '[\\t]+ \*' while parsing JAVADOC_TAG"/>
 		</module>
 
+		<!-- Allow braceless else when it directly contains a switch expression -->
+		<module name="SuppressionXpathSingleFilter">
+			<property name="checks" value="NeedBraces"/>
+			<property name="query" value="//LITERAL_ELSE[./EXPR/ASSIGN/LITERAL_SWITCH]"/>
+		</module>
+
 		<!-- Indent must use tab characters -->
 		<module name="RegexpSinglelineJava">
 			<property name="format" value="^\t* ([^\*]|$)"/> <!-- Javadoc and multiline comments have a single leading whitespace, so allow " *" -->
diff --git a/pom.xml b/pom.xml
index 193873153d..0a76f93b08 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>
@@ -227,7 +227,7 @@
 			<!-- GPL -->
 			<groupId>com.mysql</groupId>
 			<artifactId>mysql-connector-j</artifactId>
-			<version>8.3.0</version>
+			<version>9.4.0</version>
 			<type>jar</type>
 			<scope>compile</scope>
 		</dependency>
@@ -248,7 +248,7 @@
 			<!-- NOTE: If you change this version, you also have to change the install-mssql-auth command to
 			download the corresponding version of the mssql-auth dll. This will also require users to re-install
 			it, so an upgrade routine will need to be released as well. -->
-			<version>12.6.1.jre11</version>
+			<version>12.8.0.jre8</version>
 		</dependency>
 
 		<!-- Yaml parsing -->
@@ -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>
@@ -394,7 +399,7 @@
 		<dependency>
 			<groupId>com.squareup.okio</groupId>
 			<artifactId>okio-jvm</artifactId>
-			<version>3.10.0</version>
+			<version>3.16.0</version>
 		</dependency>
 		<dependency>
 			<groupId>com.google.code.gson</groupId>
@@ -489,10 +494,12 @@
 				<version>3.12.1</version>
 				<configuration>
 					<showDeprecation>true</showDeprecation>
-					<release>16</release>
+					<release>21</release>
 					<compilerArgs>
 						<arg>-XDignore.symbol.file</arg>
 						<arg>-parameters</arg>
+						<arg>-Xmaxwarns</arg>
+						<arg>9999</arg>
 					</compilerArgs>
 				</configuration>
 			</plugin>
@@ -567,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
@@ -840,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
deleted file mode 100644
index 4c8dd5f76e..0000000000
--- a/src/main/java/com/laytonsmith/PureUtilities/Common/RSAEncrypt.java
+++ /dev/null
@@ -1,249 +0,0 @@
-package com.laytonsmith.PureUtilities.Common;
-
-import java.io.ByteArrayInputStream;
-import java.io.ByteArrayOutputStream;
-import java.io.IOException;
-import java.io.ObjectInputStream;
-import java.io.ObjectOutputStream;
-import java.security.InvalidKeyException;
-import java.security.Key;
-import java.security.KeyPair;
-import java.security.KeyPairGenerator;
-import java.security.NoSuchAlgorithmException;
-import java.security.PrivateKey;
-import java.security.PublicKey;
-import java.util.Objects;
-import javax.crypto.BadPaddingException;
-import javax.crypto.Cipher;
-import javax.crypto.IllegalBlockSizeException;
-import javax.crypto.NoSuchPaddingException;
-import org.apache.commons.codec.binary.Base64;
-
-/**
- * Given a public/private key pair, this class uses RSA to encrypt/decrypt data.
- */
-public class RSAEncrypt {
-
-	/**
-	 * The RSA algorithm key.
-	 */
-	private static final String ALGORITHM = "RSA";
-
-	/**
-	 * Generates a new key, and stores the value in the RSA
-	 *
-	 * @param label The label that will be associated with the public key
-	 * @return
-	 */
-	public static RSAEncrypt generateKey(String label) {
-		KeyPairGenerator keyGen;
-		try {
-			keyGen = KeyPairGenerator.getInstance(ALGORITHM);
-		} catch (NoSuchAlgorithmException ex) {
-			throw new RuntimeException(ex);
-		}
-		keyGen.initialize(1024);
-		KeyPair key = keyGen.generateKeyPair();
-		RSAEncrypt enc = new RSAEncrypt(toString(key.getPrivate()), toString(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
-	 */
-	public static String toString(PublicKey key, String label) {
-		Objects.requireNonNull(label);
-		ByteArrayOutputStream pubBOS = new ByteArrayOutputStream();
-		try {
-			ObjectOutputStream publicKeyOS = new ObjectOutputStream(pubBOS);
-			publicKeyOS.writeObject(key);
-		} 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
-	 */
-	private static String toString(PrivateKey key) {
-		ByteArrayOutputStream privBOS = new ByteArrayOutputStream();
-		ObjectOutputStream privateKeyOS;
-		try {
-			privateKeyOS = new ObjectOutputStream(privBOS);
-			privateKeyOS.writeObject(key);
-		} catch (IOException 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;
-	private PrivateKey privateKey;
-	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.
-	 *
-	 * @param privateKey
-	 * @param publicKey
-	 * @throws IllegalArgumentException If the keys are not the correct type. They must be ssh compatible.
-	 */
-	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 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);
-			}
-		}
-
-		if(publicKey != null) {
-			//public key processing
-			String[] split = publicKey.split(" ");
-			if(split.length != 3) {
-				throw new IllegalArgumentException("Invalid public key passed in.");
-			}
-			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);
-			}
-		}
-	}
-
-	/**
-	 * 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
-	 */
-	public byte[] encryptWithPublic(byte[] data) {
-		Objects.requireNonNull(publicKey);
-		return crypt(data, publicKey, Cipher.ENCRYPT_MODE);
-	}
-
-	/**
-	 * 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
-	 */
-	public byte[] encryptWithPrivate(byte[] data) throws InvalidKeyException {
-		Objects.requireNonNull(privateKey);
-		return crypt(data, privateKey, Cipher.ENCRYPT_MODE);
-	}
-
-	/**
-	 * 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
-	 */
-	public byte[] decryptWithPublic(byte[] data) {
-		Objects.requireNonNull(publicKey);
-		return crypt(data, publicKey, Cipher.DECRYPT_MODE);
-	}
-
-	/**
-	 * 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
-	 */
-	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.init(cryptMode, key);
-			cipherValue = cipher.doFinal(data);
-		} catch (InvalidKeyException | IllegalBlockSizeException | BadPaddingException | NoSuchAlgorithmException | NoSuchPaddingException ex) {
-			throw new RuntimeException(ex);
-		}
-		return cipherValue;
-	}
-
-	/**
-	 * Returns the private key string.
-	 *
-	 * @return
-	 */
-	public String getPrivateKey() {
-		return toString(privateKey);
-	}
-
-	/**
-	 * Returns the public key string.
-	 *
-	 * @return
-	 */
-	public String getPublicKey() {
-		return toString(publicKey, label);
-	}
-
-	/**
-	 * Returns the label on the public key.
-	 *
-	 * @return
-	 */
-	public String getLabel() {
-		return label;
-	}
-
-}
diff --git a/src/main/java/com/laytonsmith/PureUtilities/Common/SSHKeyPair.java b/src/main/java/com/laytonsmith/PureUtilities/Common/SSHKeyPair.java
new file mode 100644
index 0000000000..3a47c81664
--- /dev/null
+++ b/src/main/java/com/laytonsmith/PureUtilities/Common/SSHKeyPair.java
@@ -0,0 +1,466 @@
+package com.laytonsmith.PureUtilities.Common;
+
+import java.io.ByteArrayOutputStream;
+import java.io.DataOutputStream;
+import java.io.IOException;
+import java.math.BigInteger;
+import java.nio.ByteBuffer;
+import java.security.InvalidKeyException;
+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.Signature;
+import java.security.SignatureException;
+import java.security.interfaces.ECPublicKey;
+import java.security.interfaces.RSAPublicKey;
+import java.security.spec.ECGenParameterSpec;
+import java.security.spec.InvalidKeySpecException;
+import java.security.spec.NamedParameterSpec;
+import java.security.spec.PKCS8EncodedKeySpec;
+import java.security.spec.X509EncodedKeySpec;
+import java.util.Objects;
+import org.apache.commons.codec.binary.Base64;
+
+/**
+ * Handles SSH key pair operations for multiple key types: RSA, Ed25519, and ECDSA.
+ *
+ * <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/ssh-ed25519/ecdsa-sha2-nistp256 <base64> <label>})</li>
+ * </ul>
+ * These formats are interoperable with OpenSSH, Node.js crypto, and other standard tools.
+ */
+public class SSHKeyPair {
+
+	/**
+	 * Supported SSH key types.
+	 */
+	public enum KeyType {
+		RSA("ssh-rsa", "RSA", "SHA256withRSA", 2048),
+		ED25519("ssh-ed25519", "Ed25519", "Ed25519", 0),
+		ECDSA_256("ecdsa-sha2-nistp256", "EC", "SHA256withECDSA", 256);
+
+		private final String sshName;
+		private final String jcaAlgorithm;
+		private final String signatureAlgorithm;
+		private final int keySize;
+
+		KeyType(String sshName, String jcaAlgorithm, String signatureAlgorithm, int keySize) {
+			this.sshName = sshName;
+			this.jcaAlgorithm = jcaAlgorithm;
+			this.signatureAlgorithm = signatureAlgorithm;
+			this.keySize = keySize;
+		}
+
+		public String getSshName() {
+			return sshName;
+		}
+
+		public String getJcaAlgorithm() {
+			return jcaAlgorithm;
+		}
+
+		public String getSignatureAlgorithm() {
+			return signatureAlgorithm;
+		}
+
+		/**
+		 * Returns the KeyType for the given SSH key type name.
+		 * @param sshName The SSH key type name (e.g. "ssh-rsa", "ssh-ed25519")
+		 * @return The matching KeyType
+		 * @throws IllegalArgumentException If the key type is not supported
+		 */
+		public static KeyType fromSshName(String sshName) {
+			for(KeyType type : values()) {
+				if(type.sshName.equals(sshName)) {
+					return type;
+				}
+			}
+			throw new IllegalArgumentException("Unsupported SSH key type: " + sshName);
+		}
+	}
+
+	private PublicKey publicKey;
+	private PrivateKey privateKey;
+	private KeyType keyType;
+	private String label;
+
+	/**
+	 * Generates a new key pair of the given type.
+	 *
+	 * @param type The key type to generate
+	 * @param label The label for the public key (e.g. "user@host")
+	 * @return A new SSHKeyPair instance with both keys
+	 */
+	public static SSHKeyPair generateKey(KeyType type, String label) {
+		try {
+			KeyPairGenerator keyGen = KeyPairGenerator.getInstance(type.jcaAlgorithm);
+			switch(type) {
+				case RSA:
+					keyGen.initialize(type.keySize);
+					break;
+				case ED25519:
+					keyGen.initialize(new NamedParameterSpec("Ed25519"));
+					break;
+				case ECDSA_256:
+					keyGen.initialize(new ECGenParameterSpec("secp256r1"));
+					break;
+				default:
+					throw new UnsupportedOperationException("Unknown key type: " + type);
+			}
+			KeyPair pair = keyGen.generateKeyPair();
+			SSHKeyPair result = new SSHKeyPair();
+			result.keyType = type;
+			result.privateKey = pair.getPrivate();
+			result.publicKey = pair.getPublic();
+			result.label = label;
+			return result;
+		} catch(NoSuchAlgorithmException | java.security.InvalidAlgorithmParameterException ex) {
+			throw new RuntimeException(ex);
+		}
+	}
+
+	/**
+	 * Creates an SSHKeyPair from PEM/SSH key strings. Either key may be null,
+	 * but at least one must be provided. The key type is auto-detected from
+	 * the key data.
+	 *
+	 * <p>The private key should be PKCS#8 PEM format ({@code -----BEGIN PRIVATE KEY-----}).
+	 * The public key should be OpenSSH format ({@code type base64 label}).
+	 *
+	 * @param privateKeyPem The private key PEM string, or null
+	 * @param publicKeySsh The public key OpenSSH string, or null
+	 * @throws IllegalArgumentException If a key string cannot be parsed
+	 */
+	public SSHKeyPair(String privateKeyPem, String publicKeySsh) throws IllegalArgumentException {
+		if(publicKeySsh != null) {
+			String[] split = publicKeySsh.trim().split("\\s+");
+			if(split.length < 2) {
+				throw new IllegalArgumentException("Invalid public key format.");
+			}
+			this.keyType = KeyType.fromSshName(split[0]);
+			this.label = split.length >= 3 ? split[2] : "";
+			this.publicKey = sshToPublicKey(keyType, split[1]);
+		}
+
+		if(privateKeyPem != null) {
+			this.privateKey = parsePrivateKey(privateKeyPem);
+			if(this.keyType == null) {
+				this.keyType = detectKeyType(privateKey);
+			}
+		}
+	}
+
+	private SSHKeyPair() {
+		// Used by generateKey
+	}
+
+	/**
+	 * Signs the given data with the private key.
+	 *
+	 * @param data The data to sign
+	 * @return The signature bytes
+	 */
+	public byte[] sign(byte[] data) {
+		Objects.requireNonNull(privateKey, "Private key is required for signing");
+		try {
+			Signature sig = Signature.getInstance(keyType.signatureAlgorithm);
+			sig.initSign(privateKey);
+			sig.update(data);
+			return sig.sign();
+		} catch(NoSuchAlgorithmException | InvalidKeyException | SignatureException ex) {
+			throw new RuntimeException(ex);
+		}
+	}
+
+	/**
+	 * Verifies a signature against the given data using the public key.
+	 *
+	 * @param data The original data that was signed
+	 * @param signature The signature to verify
+	 * @return true if the signature is valid
+	 */
+	public boolean verify(byte[] data, byte[] signature) {
+		Objects.requireNonNull(publicKey, "Public key is required for verification");
+		try {
+			Signature sig = Signature.getInstance(keyType.signatureAlgorithm);
+			sig.initVerify(publicKey);
+			sig.update(data);
+			return sig.verify(signature);
+		} catch(NoSuchAlgorithmException | InvalidKeyException | SignatureException ex) {
+			throw new RuntimeException(ex);
+		}
+	}
+
+	/**
+	 * Returns the private key as a PKCS#8 PEM string.
+	 */
+	public String getPrivateKeyPem() {
+		Objects.requireNonNull(privateKey);
+		String base64 = Base64.encodeBase64String(privateKey.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();
+	}
+
+	/**
+	 * Returns the public key as an OpenSSH format string.
+	 */
+	public String getPublicKeySsh() {
+		Objects.requireNonNull(publicKey);
+		return publicKeyToSsh(keyType, publicKey, label);
+	}
+
+	/**
+	 * Returns the key type.
+	 */
+	public KeyType getKeyType() {
+		return keyType;
+	}
+
+	/**
+	 * Returns the label on the public key.
+	 */
+	public String getLabel() {
+		return label;
+	}
+
+	// --- Private key parsing ---
+
+	private static PrivateKey parsePrivateKey(String pem) {
+		pem = pem.replaceAll("\r", "").replaceAll("\n", "");
+		// Strip all known PEM headers
+		pem = pem.replace("-----BEGIN PRIVATE KEY-----", "");
+		pem = pem.replace("-----END PRIVATE KEY-----", "");
+		pem = pem.replace("-----BEGIN RSA PRIVATE KEY-----", "");
+		pem = pem.replace("-----END RSA PRIVATE KEY-----", "");
+		pem = pem.replace("-----BEGIN EC PRIVATE KEY-----", "");
+		pem = pem.replace("-----END EC PRIVATE KEY-----", "");
+		pem = pem.trim();
+		byte[] keyBytes = Base64.decodeBase64(pem);
+		PKCS8EncodedKeySpec spec = new PKCS8EncodedKeySpec(keyBytes);
+
+		// Try each algorithm until one works
+		String[] algorithms = {"Ed25519", "EC", "RSA"};
+		for(String alg : algorithms) {
+			try {
+				KeyFactory kf = KeyFactory.getInstance(alg);
+				return kf.generatePrivate(spec);
+			} catch(NoSuchAlgorithmException | InvalidKeySpecException ex) {
+				// Try next
+			}
+		}
+		throw new IllegalArgumentException("Failed to parse private key. "
+				+ "Supported types: RSA, Ed25519, ECDSA (PKCS#8 format).");
+	}
+
+	private static KeyType detectKeyType(PrivateKey key) {
+		return switch(key.getAlgorithm()) {
+			case "RSA" -> KeyType.RSA;
+			case "Ed25519", "EdDSA" -> KeyType.ED25519;
+			case "EC" -> KeyType.ECDSA_256;
+			default -> throw new IllegalArgumentException(
+					"Unsupported private key algorithm: " + key.getAlgorithm());
+		};
+	}
+
+	// --- OpenSSH public key encoding/decoding ---
+
+	private static String publicKeyToSsh(KeyType type, PublicKey key, String label) {
+		Objects.requireNonNull(label);
+		try {
+			byte[] wireBytes = encodePublicKeyWire(type, key);
+			return type.sshName + " " + Base64.encodeBase64String(wireBytes) + " " + label;
+		} catch(IOException ex) {
+			throw new RuntimeException(ex);
+		}
+	}
+
+	private static byte[] encodePublicKeyWire(KeyType type, PublicKey key) throws IOException {
+		ByteArrayOutputStream buf = new ByteArrayOutputStream();
+		DataOutputStream dos = new DataOutputStream(buf);
+		byte[] typeBytes = type.sshName.getBytes("UTF-8");
+		dos.writeInt(typeBytes.length);
+		dos.write(typeBytes);
+
+		switch(type) {
+			case RSA: {
+				RSAPublicKey rsaKey = (RSAPublicKey) key;
+				byte[] eBytes = rsaKey.getPublicExponent().toByteArray();
+				dos.writeInt(eBytes.length);
+				dos.write(eBytes);
+				byte[] nBytes = rsaKey.getModulus().toByteArray();
+				dos.writeInt(nBytes.length);
+				dos.write(nBytes);
+				break;
+			}
+			case ED25519: {
+				// Ed25519 public key is the raw 32-byte key from X.509 encoding
+				byte[] rawKey = extractEd25519RawPublicKey(key);
+				dos.writeInt(rawKey.length);
+				dos.write(rawKey);
+				break;
+			}
+			case ECDSA_256: {
+				ECPublicKey ecKey = (ECPublicKey) key;
+				// Write curve identifier
+				byte[] curveBytes = "nistp256".getBytes("UTF-8");
+				dos.writeInt(curveBytes.length);
+				dos.write(curveBytes);
+				// Write uncompressed point (04 || x || y)
+				byte[] point = encodeEcPoint(ecKey);
+				dos.writeInt(point.length);
+				dos.write(point);
+				break;
+			}
+			default:
+				throw new UnsupportedOperationException("Unknown key type: " + type);
+		}
+		dos.flush();
+		return buf.toByteArray();
+	}
+
+	private static PublicKey sshToPublicKey(KeyType type, String base64Part) {
+		byte[] decoded = Base64.decodeBase64(base64Part);
+		ByteBuffer bb = ByteBuffer.wrap(decoded);
+		// Skip key type string
+		int typeLen = bb.getInt();
+		byte[] typeBytes = new byte[typeLen];
+		bb.get(typeBytes);
+
+		try {
+			return switch(type) {
+				case RSA -> decodeRsaPublicKey(bb);
+				case ED25519 -> decodeEd25519PublicKey(bb);
+				case ECDSA_256 -> decodeEcdsaPublicKey(bb);
+			};
+		} catch(NoSuchAlgorithmException | InvalidKeySpecException ex) {
+			throw new RuntimeException("Failed to parse " + type.sshName + " public key", ex);
+		}
+	}
+
+	private static PublicKey decodeRsaPublicKey(ByteBuffer bb)
+			throws NoSuchAlgorithmException, InvalidKeySpecException {
+		int eLen = bb.getInt();
+		byte[] eBytes = new byte[eLen];
+		bb.get(eBytes);
+		BigInteger e = new BigInteger(eBytes);
+		int nLen = bb.getInt();
+		byte[] nBytes = new byte[nLen];
+		bb.get(nBytes);
+		BigInteger n = new BigInteger(nBytes);
+		java.security.spec.RSAPublicKeySpec spec = new java.security.spec.RSAPublicKeySpec(n, e);
+		KeyFactory kf = KeyFactory.getInstance("RSA");
+		return kf.generatePublic(spec);
+	}
+
+	private static PublicKey decodeEd25519PublicKey(ByteBuffer bb)
+			throws NoSuchAlgorithmException, InvalidKeySpecException {
+		int keyLen = bb.getInt();
+		byte[] rawKey = new byte[keyLen];
+		bb.get(rawKey);
+		// Wrap raw 32 bytes into X.509 SubjectPublicKeyInfo for Ed25519
+		// The X.509 prefix for Ed25519 is fixed: 30 2a 30 05 06 03 2b 65 70 03 21 00
+		byte[] x509Prefix = {
+			0x30, 0x2a, 0x30, 0x05, 0x06, 0x03, 0x2b, 0x65, 0x70, 0x03, 0x21, 0x00
+		};
+		byte[] x509Key = new byte[x509Prefix.length + rawKey.length];
+		System.arraycopy(x509Prefix, 0, x509Key, 0, x509Prefix.length);
+		System.arraycopy(rawKey, 0, x509Key, x509Prefix.length, rawKey.length);
+		X509EncodedKeySpec spec = new X509EncodedKeySpec(x509Key);
+		KeyFactory kf = KeyFactory.getInstance("Ed25519");
+		return kf.generatePublic(spec);
+	}
+
+	private static PublicKey decodeEcdsaPublicKey(ByteBuffer bb)
+			throws NoSuchAlgorithmException, InvalidKeySpecException {
+		// Skip curve identifier string
+		int curveLen = bb.getInt();
+		byte[] curveBytes = new byte[curveLen];
+		bb.get(curveBytes);
+		// Read uncompressed EC point
+		int pointLen = bb.getInt();
+		byte[] pointBytes = new byte[pointLen];
+		bb.get(pointBytes);
+		java.security.spec.ECPoint point = decodeEcPoint(pointBytes);
+		java.security.spec.ECPublicKeySpec spec = new java.security.spec.ECPublicKeySpec(
+				point, getP256Params());
+		KeyFactory kf = KeyFactory.getInstance("EC");
+		return kf.generatePublic(spec);
+	}
+
+	// --- EC point encoding/decoding helpers ---
+
+	private static byte[] encodeEcPoint(ECPublicKey key) {
+		byte[] x = key.getW().getAffineX().toByteArray();
+		byte[] y = key.getW().getAffineY().toByteArray();
+		// Pad/trim to 32 bytes each for P-256
+		x = padOrTrimTo(x, 32);
+		y = padOrTrimTo(y, 32);
+		byte[] result = new byte[1 + 32 + 32];
+		result[0] = 0x04; // uncompressed
+		System.arraycopy(x, 0, result, 1, 32);
+		System.arraycopy(y, 0, result, 33, 32);
+		return result;
+	}
+
+	private static java.security.spec.ECPoint decodeEcPoint(byte[] data) {
+		if(data[0] != 0x04) {
+			throw new IllegalArgumentException("Only uncompressed EC points are supported");
+		}
+		int coordLen = (data.length - 1) / 2;
+		byte[] xBytes = new byte[coordLen];
+		byte[] yBytes = new byte[coordLen];
+		System.arraycopy(data, 1, xBytes, 0, coordLen);
+		System.arraycopy(data, 1 + coordLen, yBytes, 0, coordLen);
+		return new java.security.spec.ECPoint(new BigInteger(1, xBytes), new BigInteger(1, yBytes));
+	}
+
+	private static java.security.spec.ECParameterSpec getP256Params() {
+		try {
+			java.security.AlgorithmParameters params =
+					java.security.AlgorithmParameters.getInstance("EC");
+			params.init(new ECGenParameterSpec("secp256r1"));
+			return params.getParameterSpec(java.security.spec.ECParameterSpec.class);
+		} catch(Exception ex) {
+			throw new RuntimeException(ex);
+		}
+	}
+
+	private static byte[] padOrTrimTo(byte[] input, int length) {
+		if(input.length == length) {
+			return input;
+		}
+		byte[] result = new byte[length];
+		if(input.length > length) {
+			// Trim leading bytes (BigInteger may have a leading zero for sign)
+			System.arraycopy(input, input.length - length, result, 0, length);
+		} else {
+			// Pad with leading zeros
+			System.arraycopy(input, 0, result, length - input.length, input.length);
+		}
+		return result;
+	}
+
+	/**
+	 * Extracts the raw 32-byte Ed25519 public key from the X.509 encoding.
+	 */
+	private static byte[] extractEd25519RawPublicKey(PublicKey key) {
+		byte[] x509 = key.getEncoded();
+		// X.509 for Ed25519: 12-byte prefix + 32-byte raw key
+		byte[] raw = new byte[32];
+		System.arraycopy(x509, x509.length - 32, raw, 0, 32);
+		return raw;
+	}
+}
diff --git a/src/main/java/com/laytonsmith/PureUtilities/DaemonManager.java b/src/main/java/com/laytonsmith/PureUtilities/DaemonManager.java
index a54fd71829..9a0db3c239 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/abstraction/MCCommand.java b/src/main/java/com/laytonsmith/abstraction/MCCommand.java
index 13caa3d422..e998581e18 100644
--- a/src/main/java/com/laytonsmith/abstraction/MCCommand.java
+++ b/src/main/java/com/laytonsmith/abstraction/MCCommand.java
@@ -1,5 +1,6 @@
 package com.laytonsmith.abstraction;
 
+import com.laytonsmith.core.environments.Environment;
 import java.util.List;
 
 public interface MCCommand extends AbstractionObject {
@@ -52,7 +53,7 @@ public interface MCCommand extends AbstractionObject {
 
 	List<String> tabComplete(MCCommandSender sender, String alias, String[] args);
 
-	List<String> handleTabComplete(MCCommandSender sender, String alias, String[] args);
+	List<String> handleTabComplete(MCCommandSender sender, String alias, String[] args, Environment env);
 
 	boolean handleCustomCommand(MCCommandSender sender, String label, String[] args);
 }
diff --git a/src/main/java/com/laytonsmith/abstraction/bukkit/BukkitMCCommand.java b/src/main/java/com/laytonsmith/abstraction/bukkit/BukkitMCCommand.java
index 9ce6045e67..a320515791 100644
--- a/src/main/java/com/laytonsmith/abstraction/bukkit/BukkitMCCommand.java
+++ b/src/main/java/com/laytonsmith/abstraction/bukkit/BukkitMCCommand.java
@@ -13,6 +13,7 @@
 import com.laytonsmith.core.constructs.CString;
 import com.laytonsmith.core.constructs.Target;
 import com.laytonsmith.core.environments.CommandHelperEnvironment;
+import com.laytonsmith.core.environments.Environment;
 import com.laytonsmith.core.events.Driver;
 import com.laytonsmith.core.events.EventUtils;
 import com.laytonsmith.core.exceptions.CRE.CREPluginInternalException;
@@ -208,7 +209,7 @@ public String toString() {
 	}
 
 	@Override
-	public List<String> handleTabComplete(MCCommandSender sender, String alias, String[] args) {
+	public List<String> handleTabComplete(MCCommandSender sender, String alias, String[] args, Environment env) {
 		if(Commands.onTabComplete.containsKey(cmd.getName().toLowerCase())) {
 			Target t = Target.UNKNOWN;
 			CArray cargs = new CArray(t);
@@ -221,7 +222,7 @@ public List<String> handleTabComplete(MCCommandSender sender, String alias, Stri
 				Mixed fret = closure.executeCallable(null, t, new CString(alias, t), new CString(sender.getName(), t), cargs,
 						new CArray(t) // reserved for an obgen style command array
 				);
-				if(fret.isInstanceOf(CArray.TYPE)) {
+				if(fret.isInstanceOf(CArray.TYPE, null, env)) {
 					List<String> ret = new ArrayList<>();
 					if(((CArray) fret).inAssociativeMode()) {
 						for(Mixed key : ((CArray) fret).keySet()) {
@@ -262,7 +263,7 @@ public boolean handleCustomCommand(MCCommandSender sender, String label, String[
 				Mixed fret = closure.executeCallable(null, t, new CString(label, t), new CString(sender.getName(), t), cargs,
 						new CArray(t) // reserved for an obgen style command array
 				);
-				if(fret.isInstanceOf(CBoolean.TYPE)) {
+				if(fret instanceof CBoolean) {
 					return ((CBoolean) fret).getBoolean();
 				}
 			} catch (ConfigRuntimeException cre) {
diff --git a/src/main/java/com/laytonsmith/abstraction/bukkit/events/BukkitBlockEvents.java b/src/main/java/com/laytonsmith/abstraction/bukkit/events/BukkitBlockEvents.java
index bf78a93a58..a4db3b6aaf 100644
--- a/src/main/java/com/laytonsmith/abstraction/bukkit/events/BukkitBlockEvents.java
+++ b/src/main/java/com/laytonsmith/abstraction/bukkit/events/BukkitBlockEvents.java
@@ -379,15 +379,6 @@ public BukkitMCSignChangeEvent(SignChangeEvent e) {
 			pie = e;
 		}
 
-		public static BukkitMCSignChangeEvent _instantiate(MCBlock sign, MCPlayer player, CArray signtext) {
-			String[] text = new String[4];
-			for(int i = 0; i < signtext.size(); i++) {
-				text[i] = signtext.get(i, Target.UNKNOWN).toString();
-			}
-			return new BukkitMCSignChangeEvent(new SignChangeEvent(((BukkitMCBlock) sign).__Block(), ((BukkitMCPlayer) player)._Player(),
-					text));
-		}
-
 		@Override
 		public MCPlayer getPlayer() {
 			return new BukkitMCPlayer(pie.getPlayer());
@@ -403,7 +394,7 @@ public CArray getLines() {
 			CArray retn = new CArray(Target.UNKNOWN);
 
 			for(int i = 0; i < 4; i++) {
-				retn.push(new CString(pie.getLine(i), Target.UNKNOWN), Target.UNKNOWN);
+				retn.push(new CString(pie.getLine(i), Target.UNKNOWN), Target.UNKNOWN, null);
 			}
 
 			return retn;
diff --git a/src/main/java/com/laytonsmith/abstraction/enums/MCTagType.java b/src/main/java/com/laytonsmith/abstraction/enums/MCTagType.java
index 6d27e95ff6..dc338e3ec7 100644
--- a/src/main/java/com/laytonsmith/abstraction/enums/MCTagType.java
+++ b/src/main/java/com/laytonsmith/abstraction/enums/MCTagType.java
@@ -9,10 +9,13 @@
 import com.laytonsmith.core.constructs.CInt;
 import com.laytonsmith.core.constructs.CString;
 import com.laytonsmith.core.constructs.Target;
+import com.laytonsmith.core.constructs.generics.GenericParameters;
+import com.laytonsmith.core.environments.Environment;
 import com.laytonsmith.core.exceptions.CRE.CRECastException;
 import com.laytonsmith.core.exceptions.CRE.CREFormatException;
 import com.laytonsmith.core.natives.interfaces.Mixed;
 
+import java.util.function.BiFunction;
 import java.util.function.Function;
 
 /**
@@ -20,119 +23,126 @@
  */
 public enum MCTagType {
 	BYTE(
-			(Mixed v) -> ArgumentValidation.getInt8(v, v.getTarget()),
+			(Mixed v, Environment env) -> ArgumentValidation.getInt8(v, v.getTarget(), env),
 			(Byte v) -> new CInt(((Number) v).longValue(), Target.UNKNOWN)),
 	BYTE_ARRAY(
-			(Mixed v) -> {
-				CArray array = ArgumentValidation.getArray(v, v.getTarget());
+			(Mixed v, Environment env) -> {
+				CArray array = ArgumentValidation.getArray(v, v.getTarget(), env);
 				if(array.isAssociative()) {
 					throw new CRECastException("Expected byte array to not be associative.", v.getTarget());
 				}
-				byte[] bytes = new byte[(int) array.size()];
+				byte[] bytes = new byte[(int) array.size(env)];
 				int i = 0;
 				for(Mixed m : array) {
-					bytes[i++] = ArgumentValidation.getInt8(m, m.getTarget());
+					bytes[i++] = ArgumentValidation.getInt8(m, m.getTarget(), env);
 				}
 				return bytes;
 			},
 			(byte[] array) -> {
-				CArray r = new CArray(Target.UNKNOWN);
+				CArray r = new CArray(Target.UNKNOWN, null, null);
 				for(int i : array) {
-					r.push(new CInt(i, Target.UNKNOWN), Target.UNKNOWN);
+					r.push(new CInt(i, Target.UNKNOWN), Target.UNKNOWN, null);
 				}
 				return r;
 			}),
 	DOUBLE(
-			(Mixed v) -> ArgumentValidation.getDouble(v, v.getTarget()),
+			(Mixed v, Environment env) -> ArgumentValidation.getDouble(v, v.getTarget(), env),
 			(Double v) -> new CDouble(v, Target.UNKNOWN)),
 	FLOAT(
-			(Mixed v) -> ArgumentValidation.getDouble32(v, v.getTarget()),
+			(Mixed v, Environment env) -> ArgumentValidation.getDouble32(v, v.getTarget(), env),
 			(Float v) -> new CDouble(v.doubleValue(), Target.UNKNOWN)),
 	INTEGER(
-			(Mixed v) -> ArgumentValidation.getInt32(v, v.getTarget()),
+			(Mixed v, Environment env) -> ArgumentValidation.getInt32(v, v.getTarget(), env),
 			(Integer v) -> new CInt(((Number) v).longValue(), Target.UNKNOWN)),
 	INTEGER_ARRAY(
-			(Mixed v) -> {
-				CArray array = ArgumentValidation.getArray(v, v.getTarget());
+			(Mixed v, Environment env) -> {
+				CArray array = ArgumentValidation.getArray(v, v.getTarget(), env);
 				if(array.isAssociative()) {
 					throw new CRECastException("Expected integer array to not be associative.", v.getTarget());
 				}
-				int[] ints = new int[(int) array.size()];
+				int[] ints = new int[(int) array.size(env)];
 				int i = 0;
 				for(Mixed m : array) {
-					ints[i++] = ArgumentValidation.getInt32(m, m.getTarget());
+					ints[i++] = ArgumentValidation.getInt32(m, m.getTarget(), env);
 				}
 				return ints;
 			},
 			(int[] array) -> {
-				CArray r = new CArray(Target.UNKNOWN);
+				CArray r = new CArray(Target.UNKNOWN, null, null);
 				for(int i : array) {
-					r.push(new CInt(i, Target.UNKNOWN), Target.UNKNOWN);
+					r.push(new CInt(i, Target.UNKNOWN), Target.UNKNOWN, null);
 				}
 				return r;
 			}),
 	LONG(
-			(Mixed v) -> ArgumentValidation.getInt(v, v.getTarget()),
+			(Mixed v, Environment env) -> ArgumentValidation.getInt(v, v.getTarget(), env),
 			(Long v) -> new CInt(((Number) v).longValue(), Target.UNKNOWN)),
 	LONG_ARRAY(
-			(Mixed v) -> {
-				CArray array = ArgumentValidation.getArray(v, v.getTarget());
+			(Mixed v, Environment env) -> {
+				CArray array = ArgumentValidation.getArray(v, v.getTarget(), env);
 				if(array.isAssociative()) {
 					throw new CRECastException("Expected long array to not be associative.", v.getTarget());
 				}
-				long[] longs = new long[(int) array.size()];
+				long[] longs = new long[(int) array.size(env)];
 				int i = 0;
 				for(Mixed m : array) {
-					longs[i++] = ArgumentValidation.getInt(m, m.getTarget());
+					longs[i++] = ArgumentValidation.getInt(m, m.getTarget(), env);
 				}
 				return longs;
 			},
 			(long[] array) -> {
-				CArray ret = new CArray(Target.UNKNOWN);
+				CArray ret = new CArray(Target.UNKNOWN, null, null);
 				for(long i : array) {
-					ret.push(new CInt(i, Target.UNKNOWN), Target.UNKNOWN);
+					ret.push(new CInt(i, Target.UNKNOWN), Target.UNKNOWN, null);
 				}
 				return ret;
 			}),
 	SHORT(
-			(Mixed v) -> ArgumentValidation.getInt16(v, v.getTarget()),
+			(Mixed v, Environment env) -> ArgumentValidation.getInt16(v, v.getTarget(), env),
 			(Short v) -> new CInt(((Number) v).longValue(), Target.UNKNOWN)),
 	STRING(
-			(Mixed v) -> v.val(),
+			(Mixed v, Environment env) -> v.val(),
 			(String v) -> new CString(v, Target.UNKNOWN)),
 	TAG_CONTAINER(
-			(Mixed v) -> {
+			(Mixed v, Environment env) -> {
 				throw new UnsupportedOperationException();
 			},
 			(MCTagContainer v) -> {
 				throw new UnsupportedOperationException();
 			}),
 	TAG_CONTAINER_ARRAY(
-			(Mixed v) -> {
+			(Mixed v, Environment env) -> {
 				throw new UnsupportedOperationException();
 			},
 			(MCTagContainer[] v) -> {
 				throw new UnsupportedOperationException();
 			});
 
-	private final Function conversion;
+	private final BiFunction conversion;
 	private final Function construction;
 
-	<T extends Mixed, Z> MCTagType(Function<T, Z> conversion, Function<Z, T> construction) {
+	<T extends Mixed, Z> MCTagType(BiFunction<T, Environment, Z> conversion, Function<Z, T> construction) {
 		this.conversion = conversion;
 		this.construction = construction;
 	}
 
+	/** @deprecated Use {@link #convert(MCTagContainer, Mixed, Environment)} instead. */
+	@Deprecated
+	public Object convert(MCTagContainer container, Mixed value) {
+		return convert(container, value, null);
+	}
+
 	/**
 	 * Returns a Java object from a MethodScript construct.
 	 * Throws a ConfigRuntimeException if the value is not valid for this tag type.
 	 * @param container the tag container context
 	 * @param value MethodScript construct
+	 * @param env
 	 * @return a Java object
 	 */
-	public Object convert(MCTagContainer container, Mixed value) {
+	public Object convert(MCTagContainer container, Mixed value, Environment env) {
 		if(this == TAG_CONTAINER) {
-			if(!value.isInstanceOf(CArray.TYPE)) {
+			if(!value.isInstanceOf(CArray.TYPE, null, env)) {
 				throw new CREFormatException("Expected tag container to be an array.", value.getTarget());
 			}
 			CArray containerArray = (CArray) value;
@@ -140,16 +150,16 @@ public Object convert(MCTagContainer container, Mixed value) {
 				throw new CREFormatException("Expected tag container array to be associative.", value.getTarget());
 			}
 			for(String key : containerArray.stringKeySet()) {
-				Mixed possibleArray = containerArray.get(key, value.getTarget());
-				if(!possibleArray.isInstanceOf(CArray.TYPE)) {
+				Mixed possibleArray = containerArray.get(key, value.getTarget(), env);
+				if(!possibleArray.isInstanceOf(CArray.TYPE, null, env)) {
 					throw new CREFormatException("Expected tag entry to be an array.", possibleArray.getTarget());
 				}
 				CArray entryArray = (CArray) possibleArray;
 				if(!entryArray.isAssociative()) {
 					throw new CREFormatException("Expected tag array to be associative.", entryArray.getTarget());
 				}
-				Mixed entryType = entryArray.get("type", entryArray.getTarget());
-				Mixed entryValue = entryArray.get("value", entryArray.getTarget());
+				Mixed entryType = entryArray.get("type", entryArray.getTarget(), env);
+				Mixed entryValue = entryArray.get("value", entryArray.getTarget(), env);
 				MCTagType tagType;
 				try {
 					tagType = MCTagType.valueOf(entryType.val());
@@ -157,13 +167,13 @@ public Object convert(MCTagContainer container, Mixed value) {
 					throw new CREFormatException("Tag type is not valid: " + entryType.val(), entryType.getTarget());
 				}
 				Object tagValue;
-				if(tagType == MCTagType.TAG_CONTAINER) {
-					tagValue = tagType.convert(container.newContainer(), entryValue);
-				} else if(tagType == TAG_CONTAINER_ARRAY) {
-					tagValue = tagType.convert(container, entryValue);
-				} else {
-					tagValue = tagType.convert(container, entryValue);
-				}
+				if(null == tagType) {
+					tagValue = tagType.convert(container, entryValue, env);
+				} else tagValue = switch(tagType) {
+					case TAG_CONTAINER -> tagType.convert(container.newContainer(), entryValue, env);
+					case TAG_CONTAINER_ARRAY -> tagType.convert(container, entryValue, env);
+					default -> tagType.convert(container, entryValue, env);
+				};
 				try {
 					container.set(StaticLayer.GetConvertor().GetNamespacedKey(key), tagType, tagValue);
 				} catch (ClassCastException ex) {
@@ -174,21 +184,21 @@ public Object convert(MCTagContainer container, Mixed value) {
 			}
 			return container;
 		} else if(this == TAG_CONTAINER_ARRAY) {
-			if(!value.isInstanceOf(CArray.TYPE)) {
+			if(!value.isInstanceOf(CArray.TYPE, null, env)) {
 				throw new CREFormatException("Expected tag container to be an array.", value.getTarget());
 			}
 			CArray array = (CArray) value;
 			if(array.isAssociative()) {
 				throw new CREFormatException("Expected tag container array to not be associative.", array.getTarget());
 			}
-			MCTagContainer[] containers = new MCTagContainer[(int) array.size()];
+			MCTagContainer[] containers = new MCTagContainer[(int) array.size(env)];
 			int i = 0;
 			for(Mixed possibleContainer : array) {
-				containers[i++] = (MCTagContainer) TAG_CONTAINER.convert(container.newContainer(), possibleContainer);
+				containers[i++] = (MCTagContainer) TAG_CONTAINER.convert(container.newContainer(), possibleContainer, env);
 			}
 			return containers;
 		}
-		return conversion.apply(value);
+		return conversion.apply(value, env);
 	}
 
 	/**
@@ -200,20 +210,20 @@ public Object convert(MCTagContainer container, Mixed value) {
 	public Mixed construct(Object value) throws ClassCastException {
 		if(this == TAG_CONTAINER) {
 			MCTagContainer container = (MCTagContainer) value;
-			CArray containerArray = CArray.GetAssociativeArray(Target.UNKNOWN);
+			CArray containerArray = CArray.GetAssociativeArray(Target.UNKNOWN, null, null);
 			for(MCNamespacedKey key : container.getKeys()) {
-				CArray entry = CArray.GetAssociativeArray(Target.UNKNOWN);
+				CArray entry = CArray.GetAssociativeArray(Target.UNKNOWN, null, null);
 				MCTagType type = container.getType(key);
-				entry.set("type", type.name(), Target.UNKNOWN);
-				entry.set("value", type.construct(container.get(key, type)), Target.UNKNOWN);
-				containerArray.set(key.toString(), entry, Target.UNKNOWN);
+				entry.set("type", type.name(), Target.UNKNOWN, null);
+				entry.set("value", type.construct(container.get(key, type)), Target.UNKNOWN, null);
+				containerArray.set(key.toString(), entry, Target.UNKNOWN, null);
 			}
 			return containerArray;
 		} else if(this == TAG_CONTAINER_ARRAY) {
 			MCTagContainer[] containers = (MCTagContainer[]) value;
-			CArray array = new CArray(Target.UNKNOWN, containers.length);
+			CArray array = new CArray(Target.UNKNOWN, containers.length, (GenericParameters) null, (Environment) null);
 			for(MCTagContainer container : containers) {
-				array.push(TAG_CONTAINER.construct(container), Target.UNKNOWN);
+				array.push(TAG_CONTAINER.construct(container), Target.UNKNOWN, null);
 			}
 			return array;
 		}
diff --git a/src/main/java/com/laytonsmith/commandhelper/CommandHelperFileLocations.java b/src/main/java/com/laytonsmith/commandhelper/CommandHelperFileLocations.java
index c1fdb789bc..16d65c5840 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 176ca46fee..63b76a2505 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) {
@@ -536,7 +557,8 @@ public void registerEventsDynamic(Listener listener) {
 	public List<String> onTabComplete(CommandSender sender, Command command, String alias, String[] args) {
 		MCCommandSender mcsender = BukkitConvertor.BukkitGetCorrectSender(sender);
 		MCCommand cmd = new BukkitMCCommand(command);
-		return cmd.handleTabComplete(mcsender, alias, args);
+		// TODO: Figure out how to get an env here
+		return cmd.handleTabComplete(mcsender, alias, args, null);
 	}
 
 	/**
@@ -614,10 +636,151 @@ 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();
+		debugServer.setManagedExecution(true);
+		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 c355db85ec..91b70ca43a 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/ArgumentValidation.java b/src/main/java/com/laytonsmith/core/ArgumentValidation.java
index f03bd479cb..d00967cad2 100644
--- a/src/main/java/com/laytonsmith/core/ArgumentValidation.java
+++ b/src/main/java/com/laytonsmith/core/ArgumentValidation.java
@@ -4,6 +4,7 @@
 import com.laytonsmith.PureUtilities.Common.StringUtils;
 import com.laytonsmith.annotations.MEnum;
 import com.laytonsmith.annotations.typeof;
+import com.laytonsmith.core.environments.Environment;
 import com.laytonsmith.core.exceptions.CRE.CRECastException;
 import com.laytonsmith.core.exceptions.CRE.CREFormatException;
 import com.laytonsmith.core.exceptions.CRE.CRERangeException;
@@ -19,6 +20,7 @@
 import com.laytonsmith.core.constructs.CNumber;
 import com.laytonsmith.core.constructs.CString;
 import com.laytonsmith.core.constructs.CVoid;
+import com.laytonsmith.core.constructs.InstanceofUtil;
 import com.laytonsmith.core.constructs.Target;
 import com.laytonsmith.core.exceptions.ConfigRuntimeException;
 import com.laytonsmith.core.natives.interfaces.Booleanish;
@@ -39,6 +41,14 @@ private ArgumentValidation() {
 		//
 	}
 
+	/**
+	 * @deprecated Use {@link #getItemFromArray(CArray, String, Target, Mixed, Environment)} instead.
+	 */
+	@Deprecated
+	public static Mixed getItemFromArray(CArray object, String key, Target t, Mixed defaultItem) throws ConfigRuntimeException {
+		return getItemFromArray(object, key, t, defaultItem, null);
+	}
+
 	/**
 	 * Returns an item from an array, as a generic construct. This provides a standard way of returning an item from an
 	 * array. If defaultItem is null, then it is required that the item be present in the object. If it is not, a
@@ -49,11 +59,12 @@ private ArgumentValidation() {
 	 * @param t The code target
 	 * @param defaultItem The default item to return if the specified key isn't present in the array. If this is a java
 	 * null, and the key isn't present, a standard error message is thrown.
+	 * @param env The environment
 	 * @return The item in the array, or the defaultItem.
 	 * @throws ConfigRuntimeException A FormatException is thrown if it doesn't contain the appropriate value and the
 	 * defaultItem is null.
 	 */
-	public static Mixed getItemFromArray(CArray object, String key, Target t, Mixed defaultItem) throws ConfigRuntimeException {
+	public static Mixed getItemFromArray(CArray object, String key, Target t, Mixed defaultItem, Environment env) throws ConfigRuntimeException {
 		if(object.containsKey(key)) {
 			return object.get(key, t);
 		} else if(defaultItem == null) {
@@ -63,15 +74,24 @@ public static Mixed getItemFromArray(CArray object, String key, Target t, Mixed
 		}
 	}
 
+	/**
+	 * @deprecated Use {@link #getArray(Mixed, Target, Environment)} instead.
+	 */
+	@Deprecated
+	public static CArray getArray(Mixed construct, Target t) {
+		return getArray(construct, t, null);
+	}
+
 	/**
 	 * Returns a CArray object from a given construct, throwing a common error message if not.
 	 *
 	 * @param construct
 	 * @param t
+	 * @param env
 	 * @return
 	 */
-	public static CArray getArray(Mixed construct, Target t) {
-		if(construct.isInstanceOf(CArray.TYPE)) {
+	public static CArray getArray(Mixed construct, Target t, Environment env) {
+		if(construct.isInstanceOf(CArray.TYPE, null, env)) {
 			return ((CArray) construct);
 		} else {
 			throw new CRECastException("Expecting array, but received " + construct.val(), t);
@@ -106,6 +126,14 @@ public static <T extends Mixed> T getObject(Mixed construct, Target t, Class<T>
 		}
 	}
 
+	/**
+	 * @deprecated Use {@link #getNumber(Mixed, Target, Environment)} instead.
+	 */
+	@Deprecated
+	public static double getNumber(Mixed c, Target t) {
+		return getNumber(c, t, null);
+	}
+
 	/**
 	 * This function pulls a numerical equivalent from any given construct. It throws a ConfigRuntimeException if it
 	 * cannot be converted, for instance the string "s" cannot be cast to a number. The number returned will always be a
@@ -113,9 +141,10 @@ public static <T extends Mixed> T getObject(Mixed construct, Target t, Class<T>
 	 *
 	 * @param c
 	 * @param t
+	 * @param env
 	 * @return
 	 */
-	public static double getNumber(Mixed c, Target t) {
+	public static double getNumber(Mixed c, Target t, Environment env) {
 		// TODO: Formalize this in the same way that Booleanish is formalized.
 		if(c instanceof CMutablePrimitive) {
 			c = ((CMutablePrimitive) c).get();
@@ -124,9 +153,9 @@ public static double getNumber(Mixed c, Target t) {
 		if(c == null || c instanceof CNull) {
 			return 0.0;
 		}
-		if(c instanceof CNumber) {
+		if(InstanceofUtil.isInstanceof(c, CNumber.class, env)) {
 			d = ((CNumber) c).getNumber();
-		} else if(c instanceof CString) {
+		} else if(InstanceofUtil.isInstanceof(c, CString.class, env)) {
 			try {
 				d = Double.parseDouble(c.val());
 			} catch (NumberFormatException e) {
@@ -138,7 +167,7 @@ public static double getNumber(Mixed c, Target t) {
 			} else {
 				d = 0;
 			}
-		} else if(c instanceof CDecimal) {
+		} else if(InstanceofUtil.isInstanceof(c, CDecimal.class, env)) {
 			throw new CRECastException("Expecting a number, but received a decimal value instead. This cannot be"
 					+ " automatically cast, please use double(@decimal) to manually cast down to a double.", t);
 		} else {
@@ -168,14 +197,31 @@ public static double getNumber(Mixed c, Target t) {
 			+ ")[\\x00-\\x20]*" // trailing whitespace
 	);
 
+	/**
+	 * @deprecated Use {@link #isNumber(Mixed, Environment)} instead.
+	 */
+	@Deprecated
+	public static boolean isNumber(Mixed c) {
+		return isNumber(c, null);
+	}
+
 	/**
 	 * Validates that a construct's value is a number or string that can be returned by GetNumber()
 	 *
 	 * @param c Mixed
+	 * @param env
 	 * @return boolean
 	 */
-	public static boolean isNumber(Mixed c) {
-		return c instanceof CNumber || VALID_DOUBLE.matcher(c.val()).matches();
+	public static boolean isNumber(Mixed c, Environment env) {
+		return InstanceofUtil.isInstanceof(c, CNumber.class, env) || VALID_DOUBLE.matcher(c.val()).matches();
+	}
+
+	/**
+	 * @deprecated Use {@link #getDouble(Mixed, Target, Environment)} instead.
+	 */
+	@Deprecated
+	public static double getDouble(Mixed c, Target t) {
+		return getDouble(c, t, null);
 	}
 
 	/**
@@ -183,19 +229,28 @@ public static boolean isNumber(Mixed c) {
 	 *
 	 * @param c
 	 * @param t
+	 * @param env
 	 * @return
 	 */
-	public static double getDouble(Mixed c, Target t) {
+	public static double getDouble(Mixed c, Target t, Environment env) {
 		if(c instanceof CMutablePrimitive) {
 			c = ((CMutablePrimitive) c).get();
 		}
 		try {
-			return getNumber(c, t);
+			return getNumber(c, t, env);
 		} catch (ConfigRuntimeException e) {
 			throw new CRECastException("Expecting a double, but received " + c.val() + " instead", t);
 		}
 	}
 
+	/**
+	 * @deprecated Use {@link #getDouble32(Mixed, Target, Environment)} instead.
+	 */
+	@Deprecated
+	public static float getDouble32(Mixed c, Target t) {
+		return getDouble32(c, t, null);
+	}
+
 	/**
 	 * Returns a 32-bit float from the construct. Since the backing value is actually a double, if the number contained
 	 * in the construct is not within range after truncating, an exception is thrown (fail fast). When needing a float
@@ -203,25 +258,35 @@ public static double getDouble(Mixed c, Target t) {
 	 *
 	 * @param c
 	 * @param t
+	 * @param env
 	 * @return
 	 */
-	public static float getDouble32(Mixed c, Target t) {
-		double l = getDouble(c, t);
+	public static float getDouble32(Mixed c, Target t, Environment env) {
+		double l = getDouble(c, t, env);
 		if(Math.abs(l) > Float.MAX_VALUE) {
 			throw new CRERangeException("Expecting a 32 bit float, but a larger value was found: " + l, t);
 		}
 		return (float) l;
 	}
 
+	/**
+	 * @deprecated Use {@link #getInt(Mixed, Target, Environment)} instead.
+	 */
+	@Deprecated
+	public static long getInt(Mixed c, Target t) {
+		return getInt(c, t, null);
+	}
+
 	/**
 	 * Returns a long from any given construct.
 	 *
 	 * @param c
 	 * @param t
+	 * @param env
 	 * @throws CRECastException If the value cannot be converted to a long
 	 * @return
 	 */
-	public static long getInt(Mixed c, Target t) {
+	public static long getInt(Mixed c, Target t, Environment env) {
 		if(c instanceof CMutablePrimitive) {
 			c = ((CMutablePrimitive) c).get();
 		}
@@ -229,9 +294,9 @@ public static long getInt(Mixed c, Target t) {
 		if(c == null || c instanceof CNull) {
 			return 0;
 		}
-		if(c.isInstanceOf(CInt.TYPE)) {
+		if(c.isInstanceOf(CInt.TYPE, null, env)) {
 			i = getObject(c, t, CInt.class).getInt();
-		} else if(c.isInstanceOf(CBoolean.TYPE)) {
+		} else if(c instanceof CBoolean) {
 			if(getObject(c, t, CBoolean.class).getBoolean()) {
 				i = 1;
 			} else {
@@ -247,6 +312,14 @@ public static long getInt(Mixed c, Target t) {
 		return i;
 	}
 
+	/**
+	 * @deprecated Use {@link #getInt32(Mixed, Target, Environment)} instead.
+	 */
+	@Deprecated
+	public static int getInt32(Mixed c, Target t) {
+		return getInt32(c, t, null);
+	}
+
 	/**
 	 * Returns a 32 bit int from the construct. Since the backing value is actually a long, if the number contained in
 	 * the construct is not the same after truncating, an exception is thrown (fail fast). When needing an int from a
@@ -254,15 +327,16 @@ public static long getInt(Mixed c, Target t) {
 	 *
 	 * @param c
 	 * @param t
+	 * @param env
 	 * @throws CRERangeException If the value would be truncated
 	 * @throws CRECastException If the value cannot be cast to an int
 	 * @return
 	 */
-	public static int getInt32(Mixed c, Target t) {
+	public static int getInt32(Mixed c, Target t, Environment env) {
 		if(c instanceof CMutablePrimitive) {
 			c = ((CMutablePrimitive) c).get();
 		}
-		long l = getInt(c, t);
+		long l = getInt(c, t, env);
 		int i = (int) l;
 		if(i != l) {
 			throw new CRERangeException("Expecting a 32 bit integer, but a larger value was found: " + l, t);
@@ -270,6 +344,14 @@ public static int getInt32(Mixed c, Target t) {
 		return i;
 	}
 
+	/**
+	 * @deprecated Use {@link #getInt16(Mixed, Target, Environment)} instead.
+	 */
+	@Deprecated
+	public static short getInt16(Mixed c, Target t) {
+		return getInt16(c, t, null);
+	}
+
 	/**
 	 * Returns a 16 bit int from the construct (a short). Since the backing value is actually a long, if the number
 	 * contained in the construct is not the same after truncating, an exception is thrown (fail fast). When needing an
@@ -277,15 +359,16 @@ public static int getInt32(Mixed c, Target t) {
 	 *
 	 * @param c
 	 * @param t
+	 * @param env
 	 * @throws CRERangeException If the value would be truncated
 	 * @throws CRECastException If the value cannot be cast to an int
 	 * @return
 	 */
-	public static short getInt16(Mixed c, Target t) {
+	public static short getInt16(Mixed c, Target t, Environment env) {
 		if(c instanceof CMutablePrimitive) {
 			c = ((CMutablePrimitive) c).get();
 		}
-		long l = getInt(c, t);
+		long l = getInt(c, t, env);
 		short s = (short) l;
 		if(s != l) {
 			throw new CRERangeException("Expecting a 16 bit integer, but a larger value was found: " + l, t);
@@ -293,6 +376,14 @@ public static short getInt16(Mixed c, Target t) {
 		return s;
 	}
 
+	/**
+	 * @deprecated Use {@link #getInt8(Mixed, Target, Environment)} instead.
+	 */
+	@Deprecated
+	public static byte getInt8(Mixed c, Target t) {
+		return getInt8(c, t, null);
+	}
+
 	/**
 	 * Returns an 8 bit int from the construct (a byte). Since the backing value is actually a long, if the number
 	 * contained in the construct is not the same after truncating, an exception is thrown (fail fast). When needing a
@@ -300,15 +391,16 @@ public static short getInt16(Mixed c, Target t) {
 	 *
 	 * @param c
 	 * @param t
+	 * @param env
 	 * @throws CRERangeException If the value would be truncated
 	 * @throws CRECastException If the value cannot be cast to an int
 	 * @return
 	 */
-	public static byte getInt8(Mixed c, Target t) {
+	public static byte getInt8(Mixed c, Target t, Environment env) {
 		if(c instanceof CMutablePrimitive) {
 			c = ((CMutablePrimitive) c).get();
 		}
-		long l = getInt(c, t);
+		long l = getInt(c, t, env);
 		byte b = (byte) l;
 		if(b != l) {
 			throw new CRERangeException("Expecting an 8 bit integer, but a larger value was found: " + l, t);
@@ -316,6 +408,14 @@ public static byte getInt8(Mixed c, Target t) {
 		return b;
 	}
 
+	/**
+	 * @deprecated Use {@link #getBooleanObject(Mixed, Target, Environment)} instead.
+	 */
+	@Deprecated
+	public static boolean getBooleanObject(Mixed c, Target t) {
+		return getBooleanObject(c, t, null);
+	}
+
 	/**
 	 * <s>Returns a the boolean value from the underlying CBoolean, or throws a CastException if the underlying type is
 	 * not a CBoolean.</s>
@@ -325,10 +425,19 @@ public static byte getInt8(Mixed c, Target t) {
 	 * to validate the type, use {@link #getObject(Mixed, Target, Class)}
 	 * @param c
 	 * @param t
+	 * @param env
 	 * @return
 	 */
-	public static boolean getBooleanObject(Mixed c, Target t) {
-		return getBooleanish(c, t);
+	public static boolean getBooleanObject(Mixed c, Target t, Environment env) {
+		return getBooleanish(c, t, env);
+	}
+
+	/**
+	 * @deprecated Use {@link #getBoolean(Mixed, Target, Environment)} instead.
+	 */
+	@Deprecated
+	public static boolean getBoolean(Mixed c, Target t) {
+		return getBoolean(c, t, null);
 	}
 
 	/**
@@ -338,14 +447,23 @@ public static boolean getBooleanObject(Mixed c, Target t) {
 	 * {@link #getBooleanish} or {@link #getBooleanObject}.
 	 * @param c
 	 * @param t
+	 * @param env
 	 * @return
 	 * @deprecated Use {@link #getBooleanish} for current behavior, or {@link #getBooleanObject} for strict behavior.
 	 * Generally speaking, if it seems reasonable for the user to send a non-boolean data type in this parameter, then
 	 * getBooleanish should be used. If it indicates a probable error, getBooleanObject should be used.
 	 */
 	@Deprecated
-	public static boolean getBoolean(Mixed c, Target t) {
-		return getBooleanish(c, t);
+	public static boolean getBoolean(Mixed c, Target t, Environment env) {
+		return getBooleanish(c, t, env);
+	}
+
+	/**
+	 * @deprecated Use {@link #getBooleanish(Mixed, Target, Environment)} instead.
+	 */
+	@Deprecated
+	public static boolean getBooleanish(Mixed c, Target t) {
+		return getBooleanish(c, t, null);
 	}
 
 	/**
@@ -355,9 +473,10 @@ public static boolean getBoolean(Mixed c, Target t) {
 	 *
 	 * @param c The value to convert
 	 * @param t The code target
+	 * @param env
 	 * @return
 	 */
-	public static boolean getBooleanish(Mixed c, Target t) {
+	public static boolean getBooleanish(Mixed c, Target t, Environment env) {
 		if(c instanceof CVoid) {
 			// Eventually, we may want to turn this into a warning, maybe even a compiler error, but for now,
 			// to keep backwards compatibility, we want to keep this as is.
@@ -369,10 +488,18 @@ public static boolean getBooleanish(Mixed c, Target t) {
 		if(c == null) {
 			return false;
 		}
-		if(c instanceof Booleanish) {
+		if(InstanceofUtil.isInstanceof(c, Booleanish.class, env)) {
 			return ((Booleanish) c).getBooleanValue(t);
 		}
-		throw new CRECastException("Could not convert value of type " + c.typeof() + " to a " + Booleanish.TYPE, t);
+		throw new CRECastException("Could not convert value of type " + c.typeof(env) + " to a " + Booleanish.TYPE, t);
+	}
+
+	/**
+	 * @deprecated Use {@link #getByteArray(Mixed, Target, Environment)} instead.
+	 */
+	@Deprecated
+	public static CByteArray getByteArray(Mixed c, Target t) {
+		return getByteArray(c, t, null);
 	}
 
 	/**
@@ -380,23 +507,30 @@ public static boolean getBooleanish(Mixed c, Target t) {
 	 *
 	 * @param c
 	 * @param t
+	 * @param env
 	 * @return
 	 */
-	public static CByteArray getByteArray(Mixed c, Target t) {
+	public static CByteArray getByteArray(Mixed c, Target t, Environment env) {
 		if(c instanceof CByteArray) {
 			return (CByteArray) c;
 		} else if(c instanceof CNull) {
 			return new CByteArray(t, 0);
 		} else {
-			throw new CRECastException("Expecting byte array, but found " + c.typeof() + " instead.", t);
+			throw new CRECastException("Expecting byte array, but found " + c.typeof(env) + " instead.", t);
 		}
 	}
 
+	/** @deprecated Use {@link #getClassType(Mixed, Target, Environment)} instead. */
+	@Deprecated
 	public static CClassType getClassType(Mixed c, Target t) {
+		return getClassType(c, t, null);
+	}
+
+	public static CClassType getClassType(Mixed c, Target t, Environment env) {
 		if(c instanceof CClassType) {
 			return (CClassType) c;
 		} else {
-			throw new CRECastException("Expecting a ClassType, but found " + c.typeof() + " instead.", t);
+			throw new CRECastException("Expecting a ClassType, but found " + c.typeof(env) + " instead.", t);
 		}
 	}
 
@@ -412,58 +546,94 @@ public static String getString(Mixed c, Target t) {
 		return c.val();
 	}
 
+	/**
+	 * @deprecated Use {@link #getStringObject(Mixed, Target, Environment)} instead.
+	 */
+	@Deprecated
+	public static String getStringObject(Mixed c, Target t) {
+		return getStringObject(c, t, null);
+	}
+
 	/**
 	 * Returns a String object from the given construct. Note that unlike {@link #getString}, this strictly expects a
 	 * string object, and will throw a CRECastException if it is not a string.
 	 *
 	 * @param c
 	 * @param t
+	 * @param env
 	 * @return
 	 */
-	public static String getStringObject(Mixed c, Target t) {
+	public static String getStringObject(Mixed c, Target t, Environment env) {
 		if(!c.isInstanceOf(CString.class)) {
-			throw new CRECastException("Expected a string, but found " + c.typeof() + " instead.", t);
+			throw new CRECastException("Expected a string, but found " + c.typeof(env) + " instead.", t);
 		}
 		return c.val();
 	}
 
+	/**
+	 * @deprecated Use {@link #anyDoubles(Environment, Mixed...)} instead.
+	 */
+	@Deprecated
+	public static boolean anyDoubles(Mixed... c) {
+		return anyDoubles(null, c);
+	}
+
 	/**
 	 * Returns true if any of the constructs are a CDouble, false otherwise.
 	 *
+	 * @param env
 	 * @param c
 	 * @return
 	 */
-	public static boolean anyDoubles(Mixed... c) {
+	public static boolean anyDoubles(Environment env, Mixed... c) {
 		for(Mixed c1 : c) {
-			if(c1 instanceof CDouble || c1 instanceof CString && c1.val().indexOf(".", 1) > -1) {
+			if(InstanceofUtil.isInstanceof(c1, CDouble.class, env) || InstanceofUtil.isInstanceof(c1, CString.class, env) && c1.val().indexOf(".", 1) > -1) {
 				return true;
 			}
 		}
 		return false;
 	}
 
+	/**
+	 * @deprecated Use {@link #anyStrings(Environment, Mixed...)} instead.
+	 */
+	@Deprecated
+	public static boolean anyStrings(Mixed... c) {
+		return anyStrings(null, c);
+	}
+
 	/**
 	 * Return true if any of the constructs are CStrings, false otherwise.
 	 *
+	 * @param env
 	 * @param c
 	 * @return
 	 */
-	public static boolean anyStrings(Mixed... c) {
+	public static boolean anyStrings(Environment env, Mixed... c) {
 		for(Mixed c1 : c) {
-			if(c1 instanceof CString) {
+			if(InstanceofUtil.isInstanceof(c1, CString.class, env)) {
 				return true;
 			}
 		}
 		return false;
 	}
 
+	/**
+	 * @deprecated Use {@link #anyNulls(Environment, Mixed...)} instead.
+	 */
+	@Deprecated
+	public static boolean anyNulls(Mixed... c) {
+		return anyNulls(null, c);
+	}
+
 	/**
 	 * Returns true if any of the constructs are null
 	 *
+	 * @param env
 	 * @param c
 	 * @return
 	 */
-	public static boolean anyNulls(Mixed... c) {
+	public static boolean anyNulls(Environment env, Mixed... c) {
 		for(Mixed c1 : c) {
 			if(c1 instanceof CNull) {
 				return true;
@@ -472,13 +642,22 @@ public static boolean anyNulls(Mixed... c) {
 		return false;
 	}
 
+	/**
+	 * @deprecated Use {@link #anyBooleans(Environment, Mixed...)} instead.
+	 */
+	@Deprecated
+	public static boolean anyBooleans(Mixed... c) {
+		return anyBooleans(null, c);
+	}
+
 	/**
 	 * Returns true if any of the constructs are CBooleans, false otherwise.
 	 *
+	 * @param env
 	 * @param c
 	 * @return
 	 */
-	public static boolean anyBooleans(Mixed... c) {
+	public static boolean anyBooleans(Environment env, Mixed... c) {
 		for(Mixed c1 : c) {
 			if(c1 instanceof CBoolean) {
 				return true;
@@ -515,6 +694,14 @@ public static <T extends Enum<T>> T getEnum(Mixed c, Class<T> enumClass, Target
 		}
 	}
 
+	/**
+	 * @deprecated Use {@link #getEnumSet(Mixed, Class, Target, Environment)} instead.
+	 */
+	@Deprecated
+	public static <T extends Enum<T>> Set<T> getEnumSet(Mixed c, Class<T> enumClass, Target t) {
+		return getEnumSet(c, enumClass, t, null);
+	}
+
 	/**
 	 * Returns a set of the given enum value. The input value may be either a single value or an array. If
 	 * it is a single value, the set will be of size 1. Null is also supported, and will return a set of size
@@ -523,13 +710,14 @@ public static <T extends Enum<T>> T getEnum(Mixed c, Class<T> enumClass, Target
 	 * @param c
 	 * @param enumClass
 	 * @param t
+	 * @param env
 	 * @return
 	 */
-	public static <T extends Enum<T>> Set<T> getEnumSet(Mixed c, Class<T> enumClass, Target t) {
+	public static <T extends Enum<T>> Set<T> getEnumSet(Mixed c, Class<T> enumClass, Target t, Environment env) {
 		if(c instanceof CNull) {
 			return EnumSet.noneOf(enumClass);
 		}
-		if(!c.isInstanceOf(CArray.TYPE)) {
+		if(!c.isInstanceOf(CArray.TYPE, null, env)) {
 			Mixed val = c;
 			c = new CArray(t);
 			((CArray) c).push(val, t);
diff --git a/src/main/java/com/laytonsmith/core/CallbackYield.java b/src/main/java/com/laytonsmith/core/CallbackYield.java
new file mode 100644
index 0000000000..800915abde
--- /dev/null
+++ b/src/main/java/com/laytonsmith/core/CallbackYield.java
@@ -0,0 +1,357 @@
+package com.laytonsmith.core;
+
+import com.laytonsmith.core.constructs.CVoid;
+import com.laytonsmith.core.constructs.Target;
+import com.laytonsmith.core.constructs.generics.GenericParameters;
+import com.laytonsmith.core.environments.Environment;
+import com.laytonsmith.core.environments.GlobalEnv;
+import com.laytonsmith.core.exceptions.ConfigRuntimeException;
+import com.laytonsmith.core.functions.AbstractFunction;
+import com.laytonsmith.core.functions.ControlFlow;
+import com.laytonsmith.core.natives.interfaces.Callable;
+import com.laytonsmith.core.natives.interfaces.Mixed;
+
+import java.util.ArrayDeque;
+import java.util.Arrays;
+import java.util.Queue;
+import java.util.function.BiConsumer;
+import java.util.function.Supplier;
+
+/**
+ * Base class for functions that need to call closures/callables without re-entering
+ * {@code eval()}. Subclasses implement {@link #execWithYield} instead of {@code exec()}.
+ * The callback-style exec builds a chain of deferred steps via a {@link Yield} object,
+ * which this class then drives as a {@link FlowFunction}.
+ *
+ * <p>The interpreter loop sees this as a FlowFunction and drives it via
+ * begin/childCompleted/childInterrupted. The subclass never deals with those
+ * methods — it just uses the Yield API.</p>
+ *
+ * <p>Example (array_map):</p>
+ * <pre>
+ * protected void execCallback(Target t, Environment env, Mixed[] args, Yield yield) {
+ *     CArray array = ArgumentValidation.getArray(args[0], t, env);
+ *     CClosure closure = ArgumentValidation.getObject(args[1], t, CClosure.class);
+ *     CArray newArray = new CArray(t, (int) array.size(env));
+ *
+ *     for(Mixed key : array.keySet(env)) {
+ *         yield.call(closure, env, t, array.get(key, t, env))
+ *              .then((result, y) -&gt; {
+ *                  newArray.set(key, result, t, env);
+ *              });
+ *     }
+ *     yield.done(() -&gt; newArray);
+ * }
+ * </pre>
+ */
+public abstract class CallbackYield extends AbstractFunction implements FlowFunction<CallbackYield.CallbackState> {
+
+	/**
+	 * Implement this instead of {@code exec()}. Use the {@link Yield} object to queue
+	 * closure calls and set the final result.
+	 *
+	 * @param t The code target
+	 * @param env The environment
+	 * @param args The evaluated arguments (same as what exec() would receive)
+	 * @param yield The yield object for queuing closure calls
+	 */
+	protected abstract void execWithYield(Target t, Environment env, Mixed[] args, Yield yield);
+
+	/**
+	 * Bridges the standard exec() interface to the callback mechanism. This is called by the
+	 * interpreter loop's simple-exec path, but since CallbackYield is also a FlowFunction,
+	 * the loop will use the FlowFunction path instead. This implementation exists only as a
+	 * fallback for external callers that invoke exec() directly (e.g. compile-time optimization).
+	 * In that case, closures are executed synchronously via executeCallable() as before.
+	 */
+	@Override
+	public final Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args)
+			throws ConfigRuntimeException {
+		// Fallback: build the yield chain but execute closures synchronously.
+		// This only runs when called outside the iterative interpreter loop.
+		Yield yield = new Yield();
+		execWithYield(t, env, args, yield);
+		yield.executeSynchronously(env, t);
+		return yield.getResult();
+	}
+
+	@Override
+	public StepAction.StepResult<CallbackState> begin(Target t, ParseTree[] children, Environment env) {
+		// The interpreter has already evaluated all children (args) before recognizing
+		// this as a FlowFunction. But actually — since CallbackYield extends AbstractFunction
+		// AND implements FlowFunction, the loop will see instanceof FlowFunction and route
+		// to the FlowFunction path. We need to evaluate args ourselves.
+		// Start by evaluating the first child.
+		CallbackState state = new CallbackState();
+		if(children.length > 0) {
+			state.children = children;
+			state.argIndex = 0;
+			return new StepAction.StepResult<>(new StepAction.Evaluate(children[0]), state);
+		}
+		// No args — run the callback immediately
+		return runCallback(t, env, new Mixed[0], state);
+	}
+
+	@Override
+	public StepAction.StepResult<CallbackState> childCompleted(Target t, CallbackState state,
+			Mixed result, Environment env) {
+		// Phase 1: collecting args
+		if(!state.yieldStarted) {
+			state.addArg(result);
+			state.argIndex++;
+			if(state.argIndex < state.children.length) {
+				return new StepAction.StepResult<>(
+						new StepAction.Evaluate(state.children[state.argIndex]), state);
+			}
+			// All args collected — run the callback
+			return runCallback(t, env, state.getArgs(), state);
+		}
+
+		// Phase 2: draining yield steps — a closure just completed
+		YieldStep step = state.currentStep;
+		if(step != null && step.callback != null) {
+			step.callback.accept(result, state.yield);
+		}
+		return drainNext(t, state, env);
+	}
+
+	@Override
+	public StepAction.StepResult<CallbackState> childInterrupted(Target t, CallbackState state,
+			StepAction.FlowControl action, Environment env) {
+		StepAction.FlowControlAction fca = action.getAction();
+		// A return() inside a closure is how it produces its result.
+		if(fca instanceof ControlFlow.ReturnAction ret) {
+			YieldStep step = state.currentStep;
+			cleanupCurrentStep(state, env);
+			if(step != null && step.callback != null) {
+				step.callback.accept(ret.getValue(), state.yield);
+			}
+			return drainNext(t, state, env);
+		}
+
+		cleanupCurrentStep(state, env);
+
+		// break/continue cannot escape a closure — this is a script error.
+		if(fca instanceof ControlFlow.BreakAction || fca instanceof ControlFlow.ContinueAction) {
+			throw ConfigRuntimeException.CreateUncatchableException(
+					"Loop manipulation operations (e.g. break() or continue()) cannot"
+					+ " bubble up past closures.", fca.getTarget());
+		}
+
+		// ThrowAction and anything else — propagate
+		return null;
+	}
+
+	@Override
+	public void cleanup(Target t, CallbackState state, Environment env) {
+		if(state != null && state.currentStep != null) {
+			cleanupCurrentStep(state, env);
+		}
+	}
+
+	private StepAction.StepResult<CallbackState> runCallback(Target t, Environment env,
+			Mixed[] args, CallbackState state) {
+		Yield yield = new Yield();
+		state.yield = yield;
+		state.yieldStarted = true;
+		execWithYield(t, env, args, yield);
+		return drainNext(t, state, env);
+	}
+
+	private StepAction.StepResult<CallbackState> drainNext(Target t, CallbackState state,
+			Environment env) {
+		Yield yield = state.yield;
+		if(!yield.steps.isEmpty()) {
+			YieldStep step = yield.steps.poll();
+			state.currentStep = step;
+
+			// Try stack-based execution first (closures, procedures)
+			Callable.PreparedCallable prep = step.callable.prepareForStack(env, t, step.args);
+			if(prep != null) {
+				step.preparedEnv = prep.env();
+				return new StepAction.StepResult<>(
+						new StepAction.Evaluate(prep.node(), prep.env()), state);
+			} else {
+				// Sync-only Callable (e.g. CNativeClosure) — execute inline
+				Mixed result = step.callable.executeCallable(env, t, step.args);
+				if(step.callback != null) {
+					step.callback.accept(result, yield);
+				}
+				return drainNext(t, state, env);
+			}
+		}
+
+		// All steps drained
+		return new StepAction.StepResult<>(
+				new StepAction.Complete(yield.getResult()), state);
+	}
+
+	private void cleanupCurrentStep(CallbackState state, Environment env) {
+		YieldStep step = state.currentStep;
+		if(step != null) {
+			if(step.preparedEnv != null) {
+				// Pop the stack trace element that prepareExecution pushed
+				step.preparedEnv.getEnv(GlobalEnv.class).GetStackTraceManager().popStackTraceFrame();
+				step.preparedEnv = null;
+			}
+			if(step.cleanupAction != null) {
+				step.cleanupAction.run();
+			}
+		}
+		state.currentStep = null;
+	}
+
+	/**
+	 * Per-call state for the FlowFunction. Tracks argument collection and yield step draining.
+	 */
+	protected static class CallbackState {
+		ParseTree[] children;
+		int argIndex;
+		private Mixed[] args;
+		private int argCount;
+		boolean yieldStarted;
+		Yield yield;
+		YieldStep currentStep;
+
+		void addArg(Mixed arg) {
+			if(args == null) {
+				args = new Mixed[children.length];
+			}
+			args[argCount++] = arg;
+		}
+
+		Mixed[] getArgs() {
+			if(args == null) {
+				return new Mixed[0];
+			}
+			if(argCount < args.length) {
+				Mixed[] trimmed = new Mixed[argCount];
+				System.arraycopy(args, 0, trimmed, 0, argCount);
+				return trimmed;
+			}
+			return args;
+		}
+
+		@Override
+		public String toString() {
+			if(!yieldStarted) {
+				return "CallbackState{collecting args: " + argCount + "/" + (children != null ? children.length : 0) + "}";
+			}
+			return "CallbackState{draining yields: " + (yield != null ? yield.steps.size() : 0) + " remaining}";
+		}
+	}
+
+	/**
+	 * The object passed to {@link #execWithYield}. Functions use this to queue closure calls
+	 * and declare the final result.
+	 */
+	public static class Yield {
+		private final Queue<YieldStep> steps = new ArrayDeque<>();
+		private Supplier<Mixed> resultSupplier = () -> CVoid.VOID;
+		private boolean doneSet = false;
+
+		/**
+		 * Queue a closure/callable invocation.
+		 *
+		 * @param callable The closure or callable to invoke
+		 * @param env The environment (unused for closures, which capture their own)
+		 * @param t The target
+		 * @param args The arguments to pass to the callable
+		 * @return A {@link YieldStep} for chaining a {@code .then()} callback
+		 */
+		public YieldStep call(Callable callable, Environment env, Target t, Mixed... args) {
+			YieldStep step = new YieldStep(callable, args);
+			steps.add(step);
+			return step;
+		}
+
+		/**
+		 * Set the final result of this function via a supplier. The supplier is evaluated
+		 * after all yield steps have completed. This must be called exactly once.
+		 *
+		 * @param resultSupplier A supplier that returns the result value
+		 */
+		public void done(Supplier<Mixed> resultSupplier) {
+			this.resultSupplier = resultSupplier;
+			this.doneSet = true;
+		}
+
+		Mixed getResult() {
+			return resultSupplier.get();
+		}
+
+		/**
+		 * Clears all remaining queued steps. Used for short-circuiting (e.g. array_every,
+		 * array_some) where the final result is known before all steps have been processed.
+		 */
+		public void clear() {
+			steps.clear();
+		}
+
+		/**
+		 * Fallback for when CallbackYield functions are called outside the iterative
+		 * interpreter (e.g. during compile-time optimization). Drains all steps synchronously
+		 * by calling executeCallable directly.
+		 */
+		void executeSynchronously(Environment env, Target t) {
+			while(!steps.isEmpty()) {
+				YieldStep step = steps.poll();
+				Mixed r = step.callable.executeCallable(env, t, step.args);
+				if(step.callback != null) {
+					step.callback.accept(r, this);
+				}
+			}
+		}
+
+		@Override
+		public String toString() {
+			return "Yield{steps=" + steps.size() + ", doneSet=" + doneSet + "}";
+		}
+	}
+
+	/**
+	 * A single queued closure call with an optional continuation.
+	 */
+	public static class YieldStep {
+		final Callable callable;
+		final Mixed[] args;
+		BiConsumer<Mixed, Yield> callback;
+		Runnable cleanupAction;
+		Environment preparedEnv;
+
+		YieldStep(Callable callable, Mixed[] args) {
+			this.callable = callable;
+			this.args = args;
+		}
+
+		/**
+		 * Register a callback to run after the closure completes.
+		 *
+		 * @param callback Receives the closure's return value and the Yield object
+		 *     (for queuing additional steps or calling done())
+		 * @return This step, for fluent chaining
+		 */
+		public YieldStep then(BiConsumer<Mixed, Yield> callback) {
+			this.callback = callback;
+			return this;
+		}
+
+		/**
+		 * Register a cleanup action that runs after this step completes, whether
+		 * normally or due to an exception. This is analogous to a {@code finally} block.
+		 *
+		 * @param cleanup The cleanup action to run
+		 * @return This step, for fluent chaining
+		 */
+		public YieldStep cleanup(Runnable cleanup) {
+			this.cleanupAction = cleanup;
+			return this;
+		}
+
+		@Override
+		public String toString() {
+			return "YieldStep{callable=" + callable.getClass().getSimpleName()
+					+ ", args=" + Arrays.toString(args) + ", hasCallback=" + (callback != null) + "}";
+		}
+	}
+}
diff --git a/src/main/java/com/laytonsmith/core/EvalStack.java b/src/main/java/com/laytonsmith/core/EvalStack.java
new file mode 100644
index 0000000000..4ef65d42d4
--- /dev/null
+++ b/src/main/java/com/laytonsmith/core/EvalStack.java
@@ -0,0 +1,60 @@
+package com.laytonsmith.core;
+
+import java.util.ArrayDeque;
+import java.util.Iterator;
+
+/**
+ * A wrapper around an {@link ArrayDeque} of {@link StackFrame}s that provides a debugger-friendly
+ * {@link #toString()} showing the current execution stack in the style of MethodScript stack traces.
+ */
+public class EvalStack implements Iterable<StackFrame> {
+
+	private final ArrayDeque<StackFrame> stack;
+
+	public EvalStack() {
+		this.stack = new ArrayDeque<>();
+	}
+
+	public void push(StackFrame frame) {
+		stack.push(frame);
+	}
+
+	public StackFrame pop() {
+		return stack.pop();
+	}
+
+	public StackFrame peek() {
+		return stack.peek();
+	}
+
+	public boolean isEmpty() {
+		return stack.isEmpty();
+	}
+
+	public int size() {
+		return stack.size();
+	}
+
+	@Override
+	public Iterator<StackFrame> iterator() {
+		return stack.iterator();
+	}
+
+	@Override
+	public String toString() {
+		if(stack.isEmpty()) {
+			return "<empty stack>";
+		}
+		StringBuilder sb = new StringBuilder();
+		boolean first = true;
+		Iterator<StackFrame> it = stack.descendingIterator();
+		while(it.hasNext()) {
+			if(!first) {
+				sb.append("\n");
+			}
+			sb.append("at ").append(it.next().toString());
+			first = false;
+		}
+		return sb.toString();
+	}
+}
diff --git a/src/main/java/com/laytonsmith/core/FlowFunction.java b/src/main/java/com/laytonsmith/core/FlowFunction.java
new file mode 100644
index 0000000000..1888a57f32
--- /dev/null
+++ b/src/main/java/com/laytonsmith/core/FlowFunction.java
@@ -0,0 +1,115 @@
+package com.laytonsmith.core;
+
+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;
+
+/**
+ * Interface for functions that need to control how their children are evaluated.
+ * This replaces the old {@code execs()} mechanism. Instead of a function calling
+ * {@code parent.eval()} recursively, the interpreter loop calls the FlowFunction methods
+ * and the function returns {@link StepAction} values to direct evaluation.
+ *
+ * <p>Functions that don't need special child evaluation (the majority) don't implement
+ * this interface — the interpreter loop evaluates all their children left-to-right,
+ * then calls {@code exec()} with the results.</p>
+ *
+ * <p>Functions that DO need it (if, for, and, try, etc.) implement this interface
+ * and are driven by the interpreter loop via begin/childCompleted/childInterrupted.</p>
+ *
+ * <p>Functions that execute Callables MUST use this mechanism, however,
+ * in most cases, it is sufficient to implement {@link CallbackYield} instead, which
+ * is a specialized overload of this class, which hides most of the complexity
+ * in the case where the only complexity is calling Callables.</p>
+ *
+ * <p>The type parameter {@code S} is the per-call state type. Since function instances
+ * are singletons, per-call mutable state cannot be stored on the function itself.
+ * Instead, methods receive and return state via {@link StepAction.StepResult}.
+ * The interpreter stores this state on the {@link StackFrame} as {@code Object} and
+ * passes it back (with an unchecked cast) on subsequent calls. Functions that need
+ * no per-call state should use {@code Void} and pass {@code null}.</p>
+ */
+public interface FlowFunction<S> {
+
+	/**
+	 * Called when this function frame is first entered. The function should return
+	 * a {@link StepAction.StepResult} containing the first action (typically
+	 * {@link StepAction.Evaluate}) and the initial per-call state.
+	 *
+	 * @param t The code target of the function call
+	 * @param children The unevaluated child parse trees (same as what execs() received)
+	 * @param env The current environment
+	 * @return The first step action paired with initial state
+	 */
+	StepResult<S> begin(Target t, ParseTree[] children, Environment env);
+
+	/**
+	 * Called each time a child evaluation (requested via {@link StepAction.Evaluate})
+	 * completes successfully. The function receives the result and its per-call state,
+	 * and returns the next action paired with updated state.
+	 *
+	 * @param t The code target of the function call
+	 * @param state The per-call state from the previous step
+	 * @param result The result of the child evaluation
+	 * @param env The current environment
+	 * @return The next step action paired with updated state
+	 */
+	StepResult<S> childCompleted(Target t, S state, Mixed result, Environment env);
+
+	/**
+	 * Called when a child evaluation produced a {@link StepAction.FlowControl} action
+	 * that is propagating up the stack. The function can choose to handle it (e.g.,
+	 * a loop handling a break action) or let it propagate by returning {@code null}.
+	 *
+	 * <p>For example, {@code _for}'s implementation handles {@code BreakAction} by completing
+	 * the loop, and handles {@code ContinueAction} by jumping to the increment step.
+	 * {@code _try}'s implementation handles {@code ThrowAction} by switching to the catch branch.</p>
+	 *
+	 * <p>The default implementation returns {@code null}, propagating the action up.</p>
+	 *
+	 * @param t The code target of the function call
+	 * @param state The per-call state from the previous step
+	 * @param action The flow control action propagating through this frame
+	 * @param env The current environment
+	 * @return A {@link StepAction.StepResult} to handle it, or {@code null} to propagate
+	 */
+	default StepResult<S> childInterrupted(Target t, S state, StepAction.FlowControl action, Environment env) {
+		return null;
+	}
+
+	/**
+	 * Called when this function's frame is being removed from the stack, regardless of
+	 * the reason (normal completion, flow control propagation, or exception). This is
+	 * the FlowFunction equivalent of a {@code finally} block — use it to restore
+	 * environment state that was modified in {@code begin()} (e.g., command sender,
+	 * dynamic scripting mode, stack trace elements).
+	 *
+	 * <p>This is called exactly once per frame, after the final action has been determined
+	 * but before the frame is actually popped. The default implementation is a no-op.</p>
+	 *
+	 * @param t The code target of the function call
+	 * @param state The per-call state (may be null if begin() hasn't been called)
+	 * @param env The current environment
+	 */
+	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/FullyQualifiedClassName.java b/src/main/java/com/laytonsmith/core/FullyQualifiedClassName.java
index b66f6918c6..3a891d56ea 100644
--- a/src/main/java/com/laytonsmith/core/FullyQualifiedClassName.java
+++ b/src/main/java/com/laytonsmith/core/FullyQualifiedClassName.java
@@ -88,7 +88,7 @@ public static FullyQualifiedClassName forNativeEnum(Class<? extends Enum> clazz)
 		String fqcn = m.value();
 		FullyQualifiedClassName f = new FullyQualifiedClassName(fqcn);
 		try {
-			f.nativeClass = NativeTypeList.getNativeEnumType(f).typeof().getNativeType();
+			f.nativeClass = NativeTypeList.getNativeEnumType(f).typeof(null).getNativeType();
 		} catch (ClassNotFoundException ex) {
 			// This can't happen, it would have already been the above error.
 			throw new Error(ex);
diff --git a/src/main/java/com/laytonsmith/core/Installer.java b/src/main/java/com/laytonsmith/core/Installer.java
index d6fbef1a40..7f90be5480 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/LocalPackages.java b/src/main/java/com/laytonsmith/core/LocalPackages.java
index 59a04bb91b..2d626db405 100644
--- a/src/main/java/com/laytonsmith/core/LocalPackages.java
+++ b/src/main/java/com/laytonsmith/core/LocalPackages.java
@@ -9,7 +9,6 @@
 import com.laytonsmith.core.exceptions.ConfigCompileException;
 import com.laytonsmith.core.exceptions.ConfigCompileGroupException;
 import com.laytonsmith.core.exceptions.ConfigRuntimeException;
-import com.laytonsmith.core.exceptions.ProgramFlowManipulationException;
 import com.laytonsmith.core.functions.IncludeCache;
 import com.laytonsmith.core.profiler.ProfilePoint;
 
@@ -223,9 +222,6 @@ public void executeMS(Environment env) {
 				if(e.getMessage() != null && !e.getMessage().trim().isEmpty()) {
 					Static.getLogger().log(Level.INFO, e.getMessage());
 				}
-			} catch (ProgramFlowManipulationException e) {
-				ConfigRuntimeException.HandleUncaughtException(ConfigRuntimeException.CreateUncatchableException(
-						"Cannot break program flow in main files.", e.getTarget()), env);
 			}
 		}
 	}
diff --git a/src/main/java/com/laytonsmith/core/Main.java b/src/main/java/com/laytonsmith/core/Main.java
index cced2bcd21..49ea66ffcf 100644
--- a/src/main/java/com/laytonsmith/core/Main.java
+++ b/src/main/java/com/laytonsmith/core/Main.java
@@ -9,7 +9,7 @@
 import com.laytonsmith.PureUtilities.Common.ArrayUtils;
 import com.laytonsmith.PureUtilities.Common.FileUtil;
 import com.laytonsmith.PureUtilities.Common.OSUtils;
-import com.laytonsmith.PureUtilities.Common.RSAEncrypt;
+import com.laytonsmith.PureUtilities.Common.SSHKeyPair;
 import com.laytonsmith.PureUtilities.Common.StreamUtils;
 import com.laytonsmith.PureUtilities.Common.StringUtils;
 import com.laytonsmith.PureUtilities.Common.UIUtils;
@@ -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;
@@ -335,9 +338,9 @@ public ArgumentParser getArgumentParser() {
 
 		@Override
 		public void execute(ArgumentParser.ArgumentParserResults parsedArgs) throws Exception {
-			String buildYear = new Scheduling.simple_date().exec(Target.UNKNOWN, null,
+			String buildYear = new Scheduling.simple_date().exec(Target.UNKNOWN, null, null,
 					new CString("yyyy", Target.UNKNOWN),
-					new Meta.engine_build_date().exec(Target.UNKNOWN, null)).val();
+					new Meta.engine_build_date().exec(Target.UNKNOWN, null, null)).val();
 			StreamUtils.GetSystemOut().println("The MIT License (MIT)\n"
 					+ "\n"
 					+ "Copyright (c) 2012-" + buildYear + " Methodscript Contributors\n"
@@ -594,7 +597,7 @@ public static void CreateNewFiles(List<String> files, boolean force) throws IOEx
 						+ "\tstrict;" + li
 						+ "\tname: " + f.getName() + ";" + li
 						+ "\tauthor: " + System.getProperty("user.name") + ";" + li
-						+ "\tcreated: " + new Scheduling.simple_date().exec(Target.UNKNOWN, null, new CString("yyyy-MM-dd", Target.UNKNOWN)).val() + ";" + li
+						+ "\tcreated: " + new Scheduling.simple_date().exec(Target.UNKNOWN, null, null, new CString("yyyy-MM-dd", Target.UNKNOWN)).val() + ";" + li
 						+ "\tdescription: " + ";" + li
 						+ ">" + li + li, f, true);
 			}
@@ -641,7 +644,7 @@ public void execute(ArgumentParser.ArgumentParserResults parsedArgs) throws Exce
 			classSimpleName = split[split.length - 1];
 
 			String author = System.getProperty("user.name");
-			String created = new Scheduling.simple_date().exec(Target.UNKNOWN, null,
+			String created = new Scheduling.simple_date().exec(Target.UNKNOWN, null, null,
 					new CString("yyyy-MM-dd", Target.UNKNOWN)).val();
 			File file = new File(clazz.replace(".", "/") + ".ms");
 			if(file.exists()) {
@@ -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()
@@ -1319,26 +1524,41 @@ public void execute(ArgumentParser.ArgumentParserResults parsedArgs) throws Exce
 	}
 
 	@tool("key-gen")
-	public static class RSAKeyGenMode extends AbstractCommandLineTool {
+	public static class KeyGenMode 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 key pair, suitable for use with the"
+						+ " MethodScript debugger's KEYPAIR security mode, or other tools that"
+						+ " require key authentication. Supports "
+						+ StringUtils.Join(SSHKeyPair.KeyType.values(), ", ",
+								", or ", " or ", null, (kt) -> kt.name())
+						+ " key types.")
 				.addArgument(new ArgumentBuilder()
-						.setDescription("Output file for the keys. For instance, \"/home/user/.ssh/id_rsa\"."
+						.setDescription("Output file for the keys. For instance,"
+							+ " \"/home/user/.ssh/id_ed25519\"."
 							+ " The public key will have the same name, with \".pub\" appended.")
 						.setUsageName("file")
 						.setRequired()
 						.setName('o', "output-file")
 						.setArgType(ArgumentBuilder.BuilderTypeNonFlag.STRING))
 				.addArgument(new ArgumentBuilder()
-						.setDescription("Label for the public key. For instance, \"user@localhost\" or an email"
-								+ " address.")
+						.setDescription("Label for the public key. For instance,"
+								+ " \"user@localhost\" or an email address.")
 						.setUsageName("label")
 						.setRequired()
 						.setName('l', "label")
+						.setArgType(ArgumentBuilder.BuilderTypeNonFlag.STRING))
+				.addArgument(new ArgumentBuilder()
+						.setDescription("Key type to generate. Options: "
+								+ StringUtils.Join(SSHKeyPair.KeyType.values(), ", ",
+										", or ", " or ", null, (kt) -> kt.name())
+								+ ". Default: ED25519.")
+						.setUsageName("type")
+						.setOptional()
+						.setName('t', "type")
+						.setDefaultVal("ED25519")
 						.setArgType(ArgumentBuilder.BuilderTypeNonFlag.STRING));
 		}
 
@@ -1348,13 +1568,30 @@ public void execute(ArgumentParser.ArgumentParserResults parsedArgs) throws Exce
 			File privOutputFile = new File(outputFileString);
 			File pubOutputFile = new File(outputFileString + ".pub");
 			String label = parsedArgs.getStringArgument('l');
+			String typeStr = parsedArgs.getStringArgument('t');
+			if(typeStr == null || typeStr.isEmpty()) {
+				typeStr = "ED25519";
+			}
+			SSHKeyPair.KeyType keyType;
+			try {
+				keyType = SSHKeyPair.KeyType.valueOf(typeStr.toUpperCase());
+			} catch(IllegalArgumentException e) {
+				StreamUtils.GetSystemErr().println("Unknown key type: " + typeStr
+						+ ". Supported types: "
+						+ StringUtils.Join(SSHKeyPair.KeyType.values(), ", ",
+								", or ", " or ", null, (kt) -> kt.name()));
+				System.exit(1);
+				return;
+			}
 			if(privOutputFile.exists() || pubOutputFile.exists()) {
-				StreamUtils.GetSystemErr().println("Either the public key or private key file already exists. This utility will not overwrite any existing files.");
+				StreamUtils.GetSystemErr().println("Either the public key or private key"
+						+ " file already exists. This utility will not overwrite any"
+						+ " existing files.");
 				System.exit(1);
 			}
-			RSAEncrypt enc = RSAEncrypt.generateKey(label);
-			FileUtil.write(enc.getPrivateKey(), privOutputFile);
-			FileUtil.write(enc.getPublicKey(), pubOutputFile);
+			SSHKeyPair keyPair = SSHKeyPair.generateKey(keyType, label);
+			FileUtil.write(keyPair.getPrivateKeyPem(), privOutputFile);
+			FileUtil.write(keyPair.getPublicKeySsh(), pubOutputFile);
 			System.exit(0);
 		}
 	}
diff --git a/src/main/java/com/laytonsmith/core/Method.java b/src/main/java/com/laytonsmith/core/Method.java
index cac125930b..00610ebbf6 100644
--- a/src/main/java/com/laytonsmith/core/Method.java
+++ b/src/main/java/com/laytonsmith/core/Method.java
@@ -9,7 +9,6 @@
 import com.laytonsmith.core.environments.Environment;
 import com.laytonsmith.core.exceptions.CancelCommandException;
 import com.laytonsmith.core.exceptions.ConfigRuntimeException;
-import com.laytonsmith.core.exceptions.ProgramFlowManipulationException;
 import com.laytonsmith.core.natives.interfaces.Mixed;
 import java.util.Arrays;
 
@@ -40,7 +39,7 @@ public Method(Target t, Environment env, CClassType returnType, String name, CCl
 
 	@Override
 	public Mixed executeCallable(Environment env, Target t, Mixed... values)
-			throws ConfigRuntimeException, ProgramFlowManipulationException, CancelCommandException {
+			throws ConfigRuntimeException, CancelCommandException {
 		throw new UnsupportedOperationException("Not supported yet."); //To change body of generated methods, choose Tools | Templates.
 	}
 
diff --git a/src/main/java/com/laytonsmith/core/MethodScriptCompiler.java b/src/main/java/com/laytonsmith/core/MethodScriptCompiler.java
index 8858208ec7..a2e68b739b 100644
--- a/src/main/java/com/laytonsmith/core/MethodScriptCompiler.java
+++ b/src/main/java/com/laytonsmith/core/MethodScriptCompiler.java
@@ -77,6 +77,7 @@
 import java.util.EmptyStackException;
 import java.util.EnumSet;
 import java.util.HashMap;
+import java.util.IdentityHashMap;
 import java.util.HashSet;
 import java.util.Iterator;
 import java.util.LinkedList;
@@ -1265,10 +1266,10 @@ public static List<Script> preprocess(TokenStream tokenStream,
 	 * Compiles the token stream into a valid ParseTree. This also includes optimization and reduction.
 	 *
 	 * @param stream The token stream, as generated by {@link #lex(String, Environment, File, boolean) lex}
-	 * @param environment If an environment is already set up, it can be passed in here. The code will tolerate a null
+	 * @param env If an environment is already set up, it can be passed in here. The code will tolerate a null
 	 * value, but if present, should be passed in. If the value is null, a standalone environment will be generated
 	 * and used.
-	 * @param envs The environments that are going to be present at runtime. Even if the {@code environment} parameter
+	 * @param envs The environments that are going to be present at runtime. Even if the {@code env} parameter
 	 * is null, this still must be non-null and populated with one or more values.
 	 * @return A fully compiled, optimized, and reduced parse tree. If {@code stream} is null or empty, null is
 	 * returned.
@@ -1278,20 +1279,20 @@ public static List<Script> preprocess(TokenStream tokenStream,
 	 * @throws com.laytonsmith.core.exceptions.ConfigCompileGroupException A ConfigCompileGroupException is just
 	 * a collection of single {@link ConfigCompileException}s.
 	 */
-	public static ParseTree compile(TokenStream stream, Environment environment,
+	public static ParseTree compile(TokenStream stream, Environment env,
 			Set<Class<? extends Environment.EnvironmentImpl>> envs) throws ConfigCompileException,
 			ConfigCompileGroupException {
-		return compile(stream, environment, envs, new StaticAnalysis(true));
+		return compile(stream, env, envs, new StaticAnalysis(true));
 	}
 
 	/**
 	 * Compiles the token stream into a valid ParseTree. This also includes optimization and reduction.
 	 *
 	 * @param stream The token stream, as generated by {@link #lex(String, Environment, File, boolean) lex}
-	 * @param environment If an environment is already set up, it can be passed in here. The code will tolerate a null
+	 * @param env If an environment is already set up, it can be passed in here. The code will tolerate a null
 	 * value, but if present, should be passed in. If the value is null, a standalone environment will be generated
 	 * and used.
-	 * @param envs The environments that are going to be present at runtime. Even if the {@code environment} parameter
+	 * @param envs The environments that are going to be present at runtime. Even if the {@code env} parameter
 	 * is null, this still must be non-null and populated with one or more values.
 	 * @param staticAnalysis The static analysis object, or {@code null} to not perform static analysis. This object
 	 * is used to perform static analysis on the AST that results from parsing, before any AST optimizations.
@@ -1304,22 +1305,22 @@ public static ParseTree compile(TokenStream stream, Environment environment,
 	 * @throws com.laytonsmith.core.exceptions.ConfigCompileGroupException A ConfigCompileGroupException is just
 	 * a collection of single {@link ConfigCompileException}s.
 	 */
-	public static ParseTree compile(TokenStream stream, Environment environment,
+	public static ParseTree compile(TokenStream stream, Environment env,
 			Set<Class<? extends Environment.EnvironmentImpl>> envs, StaticAnalysis staticAnalysis)
 			throws ConfigCompileException, ConfigCompileGroupException {
 		Objects.requireNonNull(envs, "envs parameter must not be null");
 		Objects.requireNonNull(staticAnalysis, "Static Analysis may be disabled, but cannot be null.");
 		try {
-			if(environment == null) {
+			if(env == null) {
 					// We MUST have a CompilerEnvironment. It doesn't need to be used, but we have to create it at
 					// this stage.
-					environment = Static.GenerateStandaloneEnvironment(false);
+					env = Static.GenerateStandaloneEnvironment(false);
 			}
-			if(!environment.hasEnv(CompilerEnvironment.class)) {
+			if(!env.hasEnv(CompilerEnvironment.class)) {
 				Environment e = Static.GenerateStandaloneEnvironment(false);
-				environment = environment.cloneAndAdd(e.getEnv(CompilerEnvironment.class));
+				env = env.cloneAndAdd(e.getEnv(CompilerEnvironment.class));
 			}
-			environment.getEnv(CompilerEnvironment.class).setStaticAnalysis(staticAnalysis);
+			env.getEnv(CompilerEnvironment.class).setStaticAnalysis(staticAnalysis);
 		} catch (IOException | DataSourceException | URISyntaxException | Profiles.InvalidProfileException ex) {
 			throw new RuntimeException(ex);
 		}
@@ -1328,7 +1329,7 @@ public static ParseTree compile(TokenStream stream, Environment environment,
 		// Return a null AST when the program is empty.
 		// Do run static analysis to allow for including this empty file in another file.
 		if(stream == null || stream.isEmpty()) {
-			staticAnalysis.analyze(null, environment, envs, compilerErrors);
+			staticAnalysis.analyze(null, env, envs, compilerErrors);
 			return null;
 		}
 
@@ -1348,7 +1349,7 @@ public static ParseTree compile(TokenStream stream, Environment environment,
 			}
 		}
 
-		processEarlyKeywords(stream, environment, compilerErrors);
+		processEarlyKeywords(stream, env, compilerErrors);
 		// All early keyword errors are handled, but then we halt compilation at this stage, since most
 		// further errors are likley meaningless.
 		if(!compilerErrors.isEmpty()) {
@@ -1547,7 +1548,7 @@ public static ParseTree compile(TokenStream stream, Environment environment,
 									+ " usage.";
 							CompilerWarning warning = new CompilerWarning(msg, t.target,
 									FileOptions.SuppressWarning.CodeUpgradeNotices);
-							environment.getEnv(CompilerEnvironment.class).addCodeUpgradeNotice(fileOptions, warning);
+							env.getEnv(CompilerEnvironment.class).addCodeUpgradeNotice(fileOptions, warning);
 						}
 					} catch (ConfigCompileException ex) {
 						// The function doesn't exist. It may be a compile error later (or maybe not, if it's
@@ -1576,7 +1577,7 @@ public static ParseTree compile(TokenStream stream, Environment environment,
 								+ " this warning will go away. If it is intended, move this parenthesis up to the same"
 								+ " line to actually execute it.", t.target,
 								SuppressWarning.PossibleUnexpectedExecution);
-						environment.getEnv(CompilerEnvironment.class).addCompilerWarning(fileOptions, warning);
+						env.getEnv(CompilerEnvironment.class).addCompilerWarning(fileOptions, warning);
 						f = new ParseTree(new CFunction(Compiler.__autoconcat__.NAME, unknown), fileOptions);
 					} else {
 						f = new ParseTree(new CFunction(Compiler.p.NAME, t.getTarget()), fileOptions);
@@ -1922,21 +1923,21 @@ public static ParseTree compile(TokenStream stream, Environment environment,
 		// Process the AST.
 		Stack<List<Procedure>> procs = new Stack<>();
 		procs.add(new ArrayList<>());
-		processKeywords(tree, environment, compilerErrors);
-		addSelfStatements(tree, environment, envs, compilerErrors);
-		rewriteAutoconcats(tree, environment, envs, compilerErrors, true);
-		processLateKeywords(tree, environment, compilerErrors);
-		checkLinearComponents(tree, environment, compilerErrors);
-		postParseRewrite(rootNode, environment, envs, compilerErrors, true); // Pass rootNode since this might rewrite 'tree'.
+		processKeywords(tree, env, compilerErrors);
+		addSelfStatements(tree, env, envs, compilerErrors);
+		rewriteAutoconcats(tree, env, envs, compilerErrors, true);
+		processLateKeywords(tree, env, compilerErrors);
+		checkLinearComponents(tree, env, compilerErrors);
+		postParseRewrite(rootNode, env, envs, compilerErrors, true); // Pass rootNode since this might rewrite 'tree'.
 		tree = rootNode.getChildAt(0);
 		moveNodeModifiersOffSyntheticNodes(tree);
-		staticAnalysis.analyze(tree, environment, envs, compilerErrors);
-		optimize(tree, environment, envs, procs, compilerErrors);
+		staticAnalysis.analyze(tree, env, envs, compilerErrors);
+		optimize(tree, env, envs, procs, compilerErrors);
 		link(tree, compilerErrors);
 		checkFunctionsExist(tree, compilerErrors, envs);
 		checkBreaks(tree, compilerErrors);
 		if(!staticAnalysis.isLocalEnabled()) {
-			checkUnhandledCompilerConstructs(tree, environment, compilerErrors);
+			checkUnhandledCompilerConstructs(tree, env, compilerErrors);
 		}
 		if(!compilerErrors.isEmpty()) {
 			if(compilerErrors.size() == 1) {
@@ -1946,7 +1947,7 @@ public static ParseTree compile(TokenStream stream, Environment environment,
 				throw new ConfigCompileGroupException(compilerErrors);
 			}
 		}
-		eliminateDeadCode(tree, environment, envs);
+		eliminateDeadCode(tree, env, envs);
 		return rootNode;
 	}
 
@@ -2699,7 +2700,7 @@ private static void optimize(ParseTree tree, Environment env,
 									+ tree.getData().val(), tree.getData().getTarget()));
 							result = null;
 						} else {
-							result = func.exec(tree.getData().getTarget(), env, constructs);
+							result = Function.ExecuteFunction(func, tree.getData().getTarget(), env, constructs);
 						}
 					} else if(isValidNumArgs(func, constructs.length)) {
 						result = ((Optimizable) func).optimize(tree.getData().getTarget(), env, constructs);
@@ -3053,12 +3054,27 @@ public static Mixed execute(String script, File file, boolean inPureMScript, Env
 	 * @return
 	 */
 	public static Mixed execute(ParseTree root, Environment env, MethodScriptComplete done, Script script) {
-		return execute(root, env, done, script, null);
+		Mixed result;
+		if(root == null) {
+			result = CVoid.VOID;
+		} else {
+			if(script == null) {
+				script = new Script(null, null, env.getEnv(GlobalEnv.class).GetLabel(), env.getEnvClasses(),
+						root.getFileOptions(), null);
+			}
+			result = script.eval(root, env);
+		}
+		if(done != null && !Script.isDebuggerPaused(result)) {
+			done.done(result.val().trim());
+		}
+		return result;
 	}
 
 	/**
 	 * Executes a pre-compiled MethodScript, given the specified Script environment, but also provides a method to set
-	 * the constants in the script.
+	 * the constants in the script. The $variable bindings are resolved by walking the tree and mapping each Variable
+	 * node's identity to its resolved value, then storing the map in the environment. See
+	 * {@link GlobalEnv#SetDollarVarBindings} for details on why identity-based lookup is used.
 	 *
 	 * @param root
 	 * @param env
@@ -3068,53 +3084,23 @@ public static Mixed execute(ParseTree root, Environment env, MethodScriptComplet
 	 * @return
 	 */
 	public static Mixed execute(ParseTree root, Environment env, MethodScriptComplete done, Script script, List<Variable> vars) {
-		if(root == null) {
-			return CVoid.VOID;
-		}
-		if(script == null) {
-			script = new Script(null, null, env.getEnv(GlobalEnv.class).GetLabel(), env.getEnvClasses(),
-					root.getFileOptions(), null);
-		}
-		if(vars != null) {
-			Map<String, Variable> varMap = new HashMap<>();
+		if(root != null && vars != null && !vars.isEmpty()) {
+			Map<String, String> varValues = new HashMap<>();
 			for(Variable v : vars) {
-				varMap.put(v.getVariableName(), v);
+				varValues.put(v.getVariableName(), v.getDefault());
 			}
+			IdentityHashMap<Mixed, String> dollarBindings = new IdentityHashMap<>();
 			for(Mixed tempNode : root.getAllData()) {
 				if(tempNode instanceof Variable variable) {
-					Variable vv = varMap.get(variable.getVariableName());
-					if(vv != null) {
-						variable.setVal(vv.getDefault());
-					} else {
-						//The variable is unset. I'm not quite sure what cases would cause this
-						variable.setVal("");
+					String val = varValues.get(variable.getVariableName());
+					if(val != null) {
+						dollarBindings.put(tempNode, val);
 					}
 				}
 			}
+			env.getEnv(GlobalEnv.class).SetDollarVarBindings(dollarBindings);
 		}
-		StringBuilder b = new StringBuilder();
-		Mixed returnable = null;
-		for(ParseTree gg : root.getChildren()) {
-			Mixed retc = script.eval(gg, env);
-			if(root.numberOfChildren() == 1) {
-				returnable = retc;
-				if(done == null) {
-					// string builder is not needed, so return immediately
-					return returnable;
-				}
-			}
-			String ret = retc.val();
-			if(!ret.trim().isEmpty()) {
-				b.append(ret).append(" ");
-			}
-		}
-		if(done != null) {
-			done.done(b.toString().trim());
-		}
-		if(returnable != null) {
-			return returnable;
-		}
-		return Static.resolveConstruct(b.toString().trim(), Target.UNKNOWN);
+		return execute(root, env, done, script);
 	}
 
 	private static final List<Character> PDF_STACK = Arrays.asList(
diff --git a/src/main/java/com/laytonsmith/core/MethodScriptFileLocations.java b/src/main/java/com/laytonsmith/core/MethodScriptFileLocations.java
index 4d446d92f9..10bcea6020 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/ObjectGenerator.java b/src/main/java/com/laytonsmith/core/ObjectGenerator.java
index fc683e1fbb..43575d344e 100644
--- a/src/main/java/com/laytonsmith/core/ObjectGenerator.java
+++ b/src/main/java/com/laytonsmith/core/ObjectGenerator.java
@@ -107,6 +107,7 @@
 import com.laytonsmith.core.exceptions.CRE.CRERangeException;
 import com.laytonsmith.core.exceptions.ConfigRuntimeException;
 import com.laytonsmith.core.natives.interfaces.Mixed;
+import com.laytonsmith.core.constructs.generics.GenericParameters;
 
 import java.util.ArrayList;
 import java.util.Collection;
@@ -118,6 +119,7 @@
 import java.util.Random;
 import java.util.Set;
 import java.util.UUID;
+import java.util.Objects;
 import java.util.regex.MatchResult;
 
 /**
@@ -152,19 +154,19 @@ public CArray location(MCLocation l) {
 	 * @return
 	 */
 	public CArray location(MCLocation l, boolean includeYawAndPitch) {
-		CArray ca = CArray.GetAssociativeArray(Target.UNKNOWN);
+		CArray ca = CArray.GetAssociativeArray(Target.UNKNOWN, null, null);
 		Construct x = new CDouble(l.getX(), Target.UNKNOWN);
 		Construct y = new CDouble(l.getY(), Target.UNKNOWN);
 		Construct z = new CDouble(l.getZ(), Target.UNKNOWN);
 		Construct world = (l.getWorld() != null ? new CString(l.getWorld().getName(), Target.UNKNOWN) : CNull.NULL);
-		ca.set("0", x, Target.UNKNOWN);
-		ca.set("1", y, Target.UNKNOWN);
-		ca.set("2", z, Target.UNKNOWN);
-		ca.set("3", world, Target.UNKNOWN);
-		ca.set("x", x, Target.UNKNOWN);
-		ca.set("y", y, Target.UNKNOWN);
-		ca.set("z", z, Target.UNKNOWN);
-		ca.set("world", world, Target.UNKNOWN);
+		ca.set("0", x, Target.UNKNOWN, null);
+		ca.set("1", y, Target.UNKNOWN, null);
+		ca.set("2", z, Target.UNKNOWN, null);
+		ca.set("3", world, Target.UNKNOWN, null);
+		ca.set("x", x, Target.UNKNOWN, null);
+		ca.set("y", y, Target.UNKNOWN, null);
+		ca.set("z", z, Target.UNKNOWN, null);
+		ca.set("world", world, Target.UNKNOWN, null);
 		if(includeYawAndPitch) {
 			// guarantee yaw in the 0 - 359.9~ range
 			float yawRaw = l.getYaw() % 360.0f;
@@ -173,24 +175,42 @@ public CArray location(MCLocation l, boolean includeYawAndPitch) {
 			}
 			Construct yaw = new CDouble(yawRaw, Target.UNKNOWN);
 			Construct pitch = new CDouble(l.getPitch(), Target.UNKNOWN);
-			ca.set("4", yaw, Target.UNKNOWN);
-			ca.set("5", pitch, Target.UNKNOWN);
-			ca.set("yaw", yaw, Target.UNKNOWN);
-			ca.set("pitch", pitch, Target.UNKNOWN);
+			ca.set("4", yaw, Target.UNKNOWN, null);
+			ca.set("5", pitch, Target.UNKNOWN, null);
+			ca.set("yaw", yaw, Target.UNKNOWN, null);
+			ca.set("pitch", pitch, Target.UNKNOWN, null);
 		}
 		return ca;
 	}
 
+	/**
+	 * @param c
+	 * @param w
+	 * @param t
+	 * @return
+	 * @deprecated Use {@link #location(Mixed, MCWorld, Target, Environment)} instead.
+	 */
+	@Deprecated
+	public MCLocation location(Mixed c, MCWorld w, Target t) {
+		return location(c, w, t, null);
+	}
+
 	/**
 	 * Given a Location Object, returns a MCLocation. If the optional world is not specified in the object, the world
 	 * provided is used instead. Location "objects" are MethodScript arrays that represent a location in game. There are
 	 * 4 usages: <ul> <li>(x, y, z)</li> <li>(x, y, z, world)</li> <li>(x, y, z, yaw, pitch)</li> <li>(x, y, z, world,
 	 * yaw, pitch)</li> </ul> In all cases, the pitch and yaw default to 0, and the world defaults to the specified
 	 * world. <em>More conveniently: ([world], x, y, z, [yaw, pitch])</em>
+	 *
+	 * @param c
+	 * @param w
+	 * @param t
+	 * @param env
+	 * @return
 	 */
-	public MCLocation location(Mixed c, MCWorld w, Target t) {
-		if(!(c.isInstanceOf(CArray.TYPE))) {
-			throw new CREFormatException("Expecting an array, received " + c.typeof().getSimpleName(), t);
+	public MCLocation location(Mixed c, MCWorld w, Target t, Environment env) {
+		if(!(c.isInstanceOf(CArray.TYPE, null, env))) {
+			throw new CREFormatException("Expecting an array, received " + c.typeof(env).getSimpleName(), t);
 		}
 		CArray array = (CArray) c;
 		MCWorld world = w;
@@ -200,53 +220,53 @@ public MCLocation location(Mixed c, MCWorld w, Target t) {
 		float yaw = 0;
 		float pitch = 0;
 		if(!array.inAssociativeMode()) {
-			if(array.size() == 3) {
+			if(array.size(env) == 3) {
 				//Just the xyz, with default yaw and pitch, and given world
-				x = ArgumentValidation.getNumber(array.get(0, t), t);
-				y = ArgumentValidation.getNumber(array.get(1, t), t);
-				z = ArgumentValidation.getNumber(array.get(2, t), t);
-			} else if(array.size() == 4) {
+				x = ArgumentValidation.getNumber(array.get(0, t, env), t, env);
+				y = ArgumentValidation.getNumber(array.get(1, t, env), t, env);
+				z = ArgumentValidation.getNumber(array.get(2, t, env), t, env);
+			} else if(array.size(env) == 4) {
 				//x, y, z, world
-				x = ArgumentValidation.getNumber(array.get(0, t), t);
-				y = ArgumentValidation.getNumber(array.get(1, t), t);
-				z = ArgumentValidation.getNumber(array.get(2, t), t);
-				world = Static.getServer().getWorld(array.get(3, t).val());
-			} else if(array.size() == 5) {
+				x = ArgumentValidation.getNumber(array.get(0, t, env), t, env);
+				y = ArgumentValidation.getNumber(array.get(1, t, env), t, env);
+				z = ArgumentValidation.getNumber(array.get(2, t, env), t, env);
+				world = Static.getServer().getWorld(array.get(3, t, env).val());
+			} else if(array.size(env) == 5) {
 				//x, y, z, yaw, pitch, with given world
-				x = ArgumentValidation.getNumber(array.get(0, t), t);
-				y = ArgumentValidation.getNumber(array.get(1, t), t);
-				z = ArgumentValidation.getNumber(array.get(2, t), t);
-				yaw = (float) ArgumentValidation.getNumber(array.get(3, t), t);
-				pitch = (float) ArgumentValidation.getNumber(array.get(4, t), t);
-			} else if(array.size() == 6) {
+				x = ArgumentValidation.getNumber(array.get(0, t, env), t, env);
+				y = ArgumentValidation.getNumber(array.get(1, t, env), t, env);
+				z = ArgumentValidation.getNumber(array.get(2, t, env), t, env);
+				yaw = (float) ArgumentValidation.getNumber(array.get(3, t, env), t, env);
+				pitch = (float) ArgumentValidation.getNumber(array.get(4, t, env), t, env);
+			} else if(array.size(env) == 6) {
 				//All have been given
-				x = ArgumentValidation.getNumber(array.get(0, t), t);
-				y = ArgumentValidation.getNumber(array.get(1, t), t);
-				z = ArgumentValidation.getNumber(array.get(2, t), t);
-				world = Static.getServer().getWorld(array.get(3, t).val());
-				yaw = (float) ArgumentValidation.getNumber(array.get(4, t), t);
-				pitch = (float) ArgumentValidation.getNumber(array.get(5, t), t);
+				x = ArgumentValidation.getNumber(array.get(0, t, env), t, env);
+				y = ArgumentValidation.getNumber(array.get(1, t, env), t, env);
+				z = ArgumentValidation.getNumber(array.get(2, t, env), t, env);
+				world = Static.getServer().getWorld(array.get(3, t, env).val());
+				yaw = (float) ArgumentValidation.getNumber(array.get(4, t, env), t, env);
+				pitch = (float) ArgumentValidation.getNumber(array.get(5, t, env), t, env);
 			} else {
 				throw new CREFormatException("Expecting a Location array, but the array did not meet the format specifications", t);
 			}
 		} else {
 			if(array.containsKey("x")) {
-				x = ArgumentValidation.getNumber(array.get("x", t), t);
+				x = ArgumentValidation.getNumber(array.get("x", t, env), t, env);
 			}
 			if(array.containsKey("y")) {
-				y = ArgumentValidation.getNumber(array.get("y", t), t);
+				y = ArgumentValidation.getNumber(array.get("y", t, env), t, env);
 			}
 			if(array.containsKey("z")) {
-				z = ArgumentValidation.getNumber(array.get("z", t), t);
+				z = ArgumentValidation.getNumber(array.get("z", t, env), t, env);
 			}
 			if(array.containsKey("world")) {
-				world = Static.getServer().getWorld(array.get("world", t).val());
+				world = Static.getServer().getWorld(array.get("world", t, env).val());
 			}
 			if(array.containsKey("yaw")) {
-				yaw = (float) ArgumentValidation.getDouble(array.get("yaw", t), t);
+				yaw = (float) ArgumentValidation.getDouble(array.get("yaw", t, env), t, env);
 			}
 			if(array.containsKey("pitch")) {
-				pitch = (float) ArgumentValidation.getDouble(array.get("pitch", t), t);
+				pitch = (float) ArgumentValidation.getDouble(array.get("pitch", t, env), t, env);
 			}
 		}
 		//If world is still null at this point, it's an error
@@ -263,6 +283,7 @@ public MCLocation location(Mixed c, MCWorld w, Target t) {
 	 * associative slots. If the MCItemStack is null, or the underlying item is nonexistant (or air) CNull is returned.
 	 *
 	 * @param is
+	 * @param t
 	 * @return An item array or CNull
 	 */
 	public Construct item(MCItemStack is, Target t) {
@@ -270,10 +291,10 @@ public Construct item(MCItemStack is, Target t) {
 			return CNull.NULL;
 		}
 
-		CArray ret = CArray.GetAssociativeArray(t);
-		ret.set("name", new CString(is.getType().getName(), t), t);
-		ret.set("qty", new CInt(is.getAmount(), t), t);
-		ret.set("meta", itemMeta(is, t), t);
+		CArray ret = CArray.GetAssociativeArray(t, null, null);
+		ret.set("name", new CString(is.getType().getName(), t), t, null);
+		ret.set("qty", new CInt(is.getAmount(), t), t, null);
+		ret.set("meta", itemMeta(is, t), t, null);
 		return ret;
 	}
 
@@ -283,16 +304,36 @@ public Construct item(MCItemStack is, Target t) {
 	 * @param i
 	 * @param t
 	 * @return An abstract item stack
+	 * @deprecated Use {@link #item(Mixed, Target, Environment)} instead.
 	 */
+	@Deprecated
 	public MCItemStack item(Mixed i, Target t) {
-		return item(i, t, false);
+		return item(i, t, false, null);
 	}
 
+	public MCItemStack item(Mixed i, Target t, Environment env) {
+		return item(i, t, false, env);
+	}
+
+	/**
+	 * @param i
+	 * @param t
+	 * @param legacy
+	 * @return
+	 * @deprecated Use {@link #item(Mixed, Target, boolean, Environment)} instead.
+	 */
+	@Deprecated
 	public MCItemStack item(Mixed i, Target t, boolean legacy) {
+		return item(i, t, legacy, null);
+	}
+
+	@SuppressWarnings("null")
+	public MCItemStack item(Mixed i, Target t, boolean legacy, Environment env) {
+		Objects.requireNonNull(i);
 		if(i instanceof CNull) {
 			return EmptyItem();
 		}
-		if(!(i.isInstanceOf(CArray.TYPE))) {
+		if(!(i.isInstanceOf(CArray.TYPE, null, env))) {
 			throw new CREFormatException("Expected an array!", t);
 		}
 		CArray item = (CArray) i;
@@ -305,7 +346,7 @@ public MCItemStack item(Mixed i, Target t, boolean legacy) {
 		int qty = 1;
 
 		if(item.containsKey("qty")) {
-			qty = ArgumentValidation.getInt32(item.get("qty", t), t);
+			qty = ArgumentValidation.getInt32(item.get("qty", t, env), t, env);
 			if(qty <= 0) {
 				return EmptyItem();
 			}
@@ -316,11 +357,11 @@ public MCItemStack item(Mixed i, Target t, boolean legacy) {
 		if(legacy) {
 			// Do legacy item conversion
 			if(item.containsKey("data")) {
-				data = ArgumentValidation.getInt32(item.get("data", t), t);
+				data = ArgumentValidation.getInt32(item.get("data", t, env), t, env);
 			}
 			MCMaterial material;
 			if(item.containsKey("name")) {
-				mat = item.get("name", t).val();
+				mat = item.get("name", t, env).val();
 				if(mat.equals("MAP") || mat.equals("POTION")) {
 					// special handling, ignore data here
 					material = StaticLayer.GetMaterialFromLegacy(mat, 0);
@@ -328,13 +369,13 @@ public MCItemStack item(Mixed i, Target t, boolean legacy) {
 					material = StaticLayer.GetMaterialFromLegacy(mat, data);
 				}
 			} else {
-				Mixed type = item.get("type", t);
-				if(type.isInstanceOf(CString.TYPE)) {
+				Mixed type = item.get("type", t, env);
+				if(type.isInstanceOf(CString.TYPE, null, env)) {
 					int seperatorIndex = type.val().indexOf(':');
 					if(seperatorIndex != -1) {
 						try {
 							data = Integer.parseInt(type.val().substring(seperatorIndex + 1));
-						} catch (NumberFormatException e) {
+						} catch(NumberFormatException e) {
 							throw new CRERangeException("The item data \"" + type.val().substring(seperatorIndex + 1)
 									+ "\" is not a valid integer.", t);
 						}
@@ -342,7 +383,7 @@ public MCItemStack item(Mixed i, Target t, boolean legacy) {
 					}
 				}
 				mat = type.val();
-				int id = ArgumentValidation.getInt32(type, t);
+				int id = ArgumentValidation.getInt32(type, t, env);
 				if(id == 358 || id == 373) {
 					// special map handling, ignore data here
 					material = StaticLayer.GetMaterialFromLegacy(id, 0);
@@ -360,19 +401,21 @@ public MCItemStack item(Mixed i, Target t, boolean legacy) {
 
 			// convert legacy meta to material
 			if(material.getName().equals("PIG_SPAWN_EGG") && item.containsKey("meta")) {
-				Mixed meta = item.get("meta", t);
-				if(meta.isInstanceOf(CArray.TYPE) && ((CArray) meta).containsKey("spawntype")) {
-					Mixed spawntype = ((CArray) meta).get("spawntype", t);
+				Mixed meta = item.get("meta", t, env);
+				if(meta.isInstanceOf(CArray.TYPE, null, env)
+						&& ((CArray) meta).containsKey("spawntype")) {
+					Mixed spawntype = ((CArray) meta).get("spawntype", t, env);
 					if(!(spawntype instanceof CNull)) {
 						MCMaterial newmaterial;
 						String entityName = spawntype.val().toUpperCase();
-						if(entityName.equals("MUSHROOM_COW")) {
-							newmaterial = StaticLayer.GetMaterial("MOOSHROOM_SPAWN_EGG");
-						} else if(entityName.equals("PIG_ZOMBIE")) {
-							newmaterial = StaticLayer.GetMaterial("ZOMBIE_PIGMAN_SPAWN_EGG");
-						} else {
-							newmaterial = StaticLayer.GetMaterial(entityName + "_SPAWN_EGG");
-						}
+						newmaterial = switch(entityName) {
+							case "MUSHROOM_COW" ->
+								StaticLayer.GetMaterial("MOOSHROOM_SPAWN_EGG");
+							case "PIG_ZOMBIE" ->
+								StaticLayer.GetMaterial("ZOMBIE_PIGMAN_SPAWN_EGG");
+							default ->
+								StaticLayer.GetMaterial(entityName + "_SPAWN_EGG");
+						};
 						if(newmaterial != null) {
 							material = newmaterial;
 						}
@@ -388,7 +431,7 @@ public MCItemStack item(Mixed i, Target t, boolean legacy) {
 					+ data + "\" to " + material.getName(), t);
 
 		} else {
-			mat = item.get("name", t).val();
+			mat = item.get("name", t, env).val();
 			ret = StaticLayer.GetItemStack(mat, qty);
 		}
 
@@ -401,7 +444,7 @@ public MCItemStack item(Mixed i, Target t, boolean legacy) {
 		}
 
 		if(item.containsKey("meta")) {
-			ret.setItemMeta(itemMeta(item.get("meta", t), ret.getType(), t));
+			ret.setItemMeta(itemMeta(item.get("meta", t, env), ret.getType(), t, env));
 		}
 
 		if(legacy) {
@@ -420,12 +463,12 @@ public MCItemStack item(Mixed i, Target t, boolean legacy) {
 		// Deprecated fallback to enchants in item array if not in meta
 		if(item.containsKey("enchants")) {
 			try {
-				Map<MCEnchantment, Integer> enchants = enchants((CArray) item.get("enchants", t), t);
+				Map<MCEnchantment, Integer> enchants = enchants((CArray) item.get("enchants", t, env), t, env);
 				for(Map.Entry<MCEnchantment, Integer> entry : enchants.entrySet()) {
 					ret.addUnsafeEnchantment(entry.getKey(), entry.getValue());
 				}
 				MSLog.GetLogger().w(MSLog.Tags.DEPRECATION, "Converted legacy enchants array not in meta.", t);
-			} catch (ClassCastException ex) {
+			} catch(ClassCastException ex) {
 				throw new CREFormatException("Enchants must be an array of enchantment arrays.", t);
 			}
 		}
@@ -443,7 +486,7 @@ public Construct itemMeta(MCItemStack is, Target t) {
 		} else {
 			Construct display;
 			Construct lore;
-			CArray ma = CArray.GetAssociativeArray(t);
+			CArray ma = CArray.GetAssociativeArray(t, null, null);
 			MCItemMeta meta = is.getItemMeta();
 			MCMaterial material = is.getType();
 			if(meta.hasDisplayName()) {
@@ -452,332 +495,326 @@ public Construct itemMeta(MCItemStack is, Target t) {
 				display = CNull.NULL;
 			}
 			if(meta.hasLore()) {
-				lore = new CArray(t);
+				lore = new CArray(t, null, null);
 				for(String l : meta.getLore()) {
-					((CArray) lore).push(new CString(l, t), t);
+					((CArray) lore).push(new CString(l, t), t, null);
 				}
 			} else {
 				lore = CNull.NULL;
 			}
-			ma.set("display", display, t);
-			ma.set("lore", lore, t);
-			ma.set("enchants", enchants(meta.getEnchants(), t), t);
-			ma.set("repair", new CInt(meta.getRepairCost(), t), t);
+			ma.set("display", display, t, null);
+			ma.set("lore", lore, t, null);
+			ma.set("enchants", enchants(meta.getEnchants(), t), t, null);
+			ma.set("repair", new CInt(meta.getRepairCost(), t), t, null);
 
 			if(meta.hasCustomModelData()) {
-				ma.set("model", new CInt(meta.getCustomModelData(), t), t);
+				ma.set("model", new CInt(meta.getCustomModelData(), t), t, null);
 			} else {
-				ma.set("model", CNull.NULL, t);
+				ma.set("model", CNull.NULL, t, null);
 			}
 
 			Set<MCItemFlag> itemFlags = meta.getItemFlags();
-			CArray flagArray = new CArray(t);
+			CArray flagArray = new CArray(t, null, null);
 			if(!itemFlags.isEmpty()) {
 				for(MCItemFlag flag : itemFlags) {
-					flagArray.push(new CString(flag.name(), t), t);
+					flagArray.push(new CString(flag.name(), t), t, null);
 				}
 			}
-			ma.set("flags", flagArray, t);
+			ma.set("flags", flagArray, t, null);
 
 			List<MCAttributeModifier> modifierList = meta.getAttributeModifiers();
 			if(modifierList == null) {
-				ma.set("modifiers", CNull.NULL, t);
+				ma.set("modifiers", CNull.NULL, t, null);
 			} else {
-				CArray modifiers = new CArray(t);
+				CArray modifiers = new CArray(t, null, null);
 				for(MCAttributeModifier m : modifierList) {
-					modifiers.push(attributeModifier(m, t), t);
+					modifiers.push(attributeModifier(m, t), t, null);
 				}
-				ma.set("modifiers", modifiers, t);
+				ma.set("modifiers", modifiers, t, null);
 			}
 
 			if(meta.hasCustomTags()) {
-				ma.set("tags", MCTagType.TAG_CONTAINER.construct(meta.getCustomTags()), t);
+				ma.set("tags", MCTagType.TAG_CONTAINER.construct(meta.getCustomTags()), t, null);
 			} else {
-				ma.set("tags", CNull.NULL, t);
+				ma.set("tags", CNull.NULL, t, null);
 			}
 
 			if(Static.getServer().getMinecraftVersion().gte(MCVersion.MC1_20_6)) {
 				if(meta.hasMaxStackSize()) {
-					ma.set("maxstacksize", new CInt(meta.getMaxStackSize(), t), t);
+					ma.set("maxstacksize", new CInt(meta.getMaxStackSize(), t), t, null);
 				}
 				if(meta.hasEnchantmentGlintOverride()) {
-					ma.set("glint", CBoolean.get(meta.getEnchantmentGlintOverride()), t);
+					ma.set("glint", CBoolean.get(meta.getEnchantmentGlintOverride()), t, null);
 				}
 				if(meta.hasRarity()) {
-					ma.set("rarity", new CString(meta.getRarity().name(), t), t);
+					ma.set("rarity", new CString(meta.getRarity().name(), t), t, null);
 				}
 				if(meta.hasMaxDamage()) {
-					ma.set("maxdamage", new CInt(meta.getMaxDamage(), t), t);
+					ma.set("maxdamage", new CInt(meta.getMaxDamage(), t), t, null);
 				}
 				if(meta.hasDamage() || material.getMaxDurability() > 0) {
-					ma.set("damage", new CInt(meta.getDamage(), t), t);
-					ma.set("unbreakable", CBoolean.get(meta.isUnbreakable()), t);
+					ma.set("damage", new CInt(meta.getDamage(), t), t, null);
+					ma.set("unbreakable", CBoolean.get(meta.isUnbreakable()), t, null);
 				} else if(meta.isUnbreakable()) {
-					ma.set("unbreakable", CBoolean.TRUE, t);
+					ma.set("unbreakable", CBoolean.TRUE, t, null);
 				}
 				if(material.isBlock()) {
 					if(meta.hasBlockData()) {
 						Map<String, String> blockData = meta.getExistingBlockData();
 						if(blockData != null) {
-							ma.set("blockdata", blockData(material, blockData, t), t);
+							ma.set("blockdata", blockData(material, blockData, t), t, null);
 						} else {
-							ma.set("blockdata", CNull.NULL, t);
+							ma.set("blockdata", CNull.NULL, t, null);
 						}
 					} else {
-						ma.set("blockdata", CNull.NULL, t);
+						ma.set("blockdata", CNull.NULL, t, null);
 					}
 				}
 				if(meta.hasFood()) {
 					MCFoodComponent foodComponent = meta.getFood();
-					CArray food = CArray.GetAssociativeArray(t);
-					food.set("nutrition", new CInt(foodComponent.getNutrition(), t), t);
-					food.set("saturation", new CDouble(foodComponent.getSaturation(), t), t);
-					food.set("always", CBoolean.get(foodComponent.getCanAlwaysEat()), t);
-					ma.set("food", food, t);
+					CArray food = CArray.GetAssociativeArray(t, null, null);
+					food.set("nutrition", new CInt(foodComponent.getNutrition(), t), t, null);
+					food.set("saturation", new CDouble(foodComponent.getSaturation(), t), t, null);
+					food.set("always", CBoolean.get(foodComponent.getCanAlwaysEat()), t, null);
+					ma.set("food", food, t, null);
 				}
 
 				if(Static.getServer().getMinecraftVersion().gte(MCVersion.MC1_21)) {
 					if(meta.hasJukeboxPlayable()) {
-						ma.set("jukeboxsong", new CString(meta.getJukeboxPlayable(), t), t);
+						ma.set("jukeboxsong", new CString(meta.getJukeboxPlayable(), t), t, null);
 					}
 				}
 
 				if(Static.getServer().getMinecraftVersion().gte(MCVersion.MC1_21_3)) {
 					if(meta.hasEnchantable()) {
-						ma.set("enchantability", new CInt(meta.getEnchantable(), t), t);
+						ma.set("enchantability", new CInt(meta.getEnchantable(), t), t, null);
 					}
 					if(meta.isGlider()) {
-						ma.set("glider", CBoolean.TRUE, t);
+						ma.set("glider", CBoolean.TRUE, t, null);
 					}
 					if(meta.hasUseRemainder()) {
-						ma.set("remainder", item(meta.getUseRemainder(), t), t);
+						ma.set("remainder", item(meta.getUseRemainder(), t), t, null);
 					}
 					if(meta.hasUseCooldown()) {
 						MCCooldownComponent cooldownComponent = meta.getUseCooldown();
-						CArray cooldown = CArray.GetAssociativeArray(t);
-						cooldown.set("seconds", new CDouble(cooldownComponent.getSeconds(), t), t);
+						CArray cooldown = CArray.GetAssociativeArray(t, null, null);
+						cooldown.set("seconds", new CDouble(cooldownComponent.getSeconds(), t), t, null);
 						String group = cooldownComponent.getCooldownGroup();
 						if(group != null) {
-							cooldown.set("group", new CString(group, t), t);
+							cooldown.set("group", new CString(group, t), t, null);
 						}
-						ma.set("cooldown", cooldown, t);
+						ma.set("cooldown", cooldown, t, null);
 					}
 					if(meta.hasItemModel()) {
-						ma.set("itemmodel", new CString(meta.getItemModel(), t), t);
+						ma.set("itemmodel", new CString(meta.getItemModel(), t), t, null);
 					}
 					if(meta.hasTooltipStyle()) {
-						ma.set("tooltipstyle", new CString(meta.getTooltipStyle(), t), t);
+						ma.set("tooltipstyle", new CString(meta.getTooltipStyle(), t), t, null);
 					}
 					if(meta.hasEquippable()) {
 						MCEquippableComponent equippableComponent = meta.getEquippable();
-						CArray equippable = CArray.GetAssociativeArray(t);
+						CArray equippable = CArray.GetAssociativeArray(t, null, null);
 						MCEquipmentSlot slot = equippableComponent.getSlot();
-						equippable.set("slot", new CString(slot.name(), t), t);
+						equippable.set("slot", new CString(slot.name(), t), t, null);
 						String asset = equippableComponent.getAssetId();
 						if(asset != null) {
-							equippable.set("asset", new CString(asset, t), t);
+							equippable.set("asset", new CString(asset, t), t, null);
 						}
 						String cameraOverlay = equippableComponent.getCameraOverlay();
 						if(cameraOverlay != null) {
-							equippable.set("overlay", new CString(cameraOverlay, t), t);
+							equippable.set("overlay", new CString(cameraOverlay, t), t, null);
 						}
 						Collection<MCEntityType> allowedEntities = equippableComponent.getAllowedEntities();
 						if(allowedEntities != null) {
-							CArray entities = new CArray(t);
+							CArray entities = new CArray(t, null, null);
 							for(MCEntityType type : allowedEntities) {
-								entities.push(new CString(type.name(), t), t);
+								entities.push(new CString(type.name(), t), t, null);
 							}
-							equippable.set("entities", entities, t);
+							equippable.set("entities", entities, t, null);
 						}
 						String sound = equippableComponent.getEquipSound();
 						if(sound != null) {
-							equippable.set("sound", new CString(sound, t), t);
+							equippable.set("sound", new CString(sound, t), t, null);
 						}
-						equippable.set("dispensable", CBoolean.get(equippableComponent.isDispensable()), t);
-						equippable.set("swappable", CBoolean.get(equippableComponent.isSwappable()), t);
-						equippable.set("damageable", CBoolean.get(equippableComponent.isDamageOnHurt()), t);
+						equippable.set("dispensable", CBoolean.get(equippableComponent.isDispensable()), t, null);
+						equippable.set("swappable", CBoolean.get(equippableComponent.isSwappable()), t, null);
+						equippable.set("damageable", CBoolean.get(equippableComponent.isDamageOnHurt()), t, null);
 						if(Static.getServer().getMinecraftVersion().gte(MCVersion.MC1_21_5)) {
-							equippable.set("interactable", CBoolean.get(equippableComponent.isEquipOnInteract()), t);
+							equippable.set("interactable", CBoolean.get(equippableComponent.isEquipOnInteract()), t, null);
 						}
-						ma.set("equippable", equippable, t);
+						ma.set("equippable", equippable, t, null);
 					}
 				}
 
 			} else { // versions before 1.20.6
 				if(material.getMaxDurability() > 0) {
 					// Damageable items only
-					ma.set("damage", new CInt(meta.getDamage(), t), t);
-					ma.set("unbreakable", CBoolean.get(meta.isUnbreakable()), t);
+					ma.set("damage", new CInt(meta.getDamage(), t), t, null);
+					ma.set("unbreakable", CBoolean.get(meta.isUnbreakable()), t, null);
 				} else if(material.isBlock()) {
 					if(meta.hasBlockData()) {
-						ma.set("blockdata", blockData(meta.getBlockData(material), t), t);
+						ma.set("blockdata", blockData(meta.getBlockData(material), t), t, null);
 					} else {
-						ma.set("blockdata", CNull.NULL, t);
+						ma.set("blockdata", CNull.NULL, t, null);
 					}
 				}
 			}
 
 			// Specific ItemMeta
-			if(meta instanceof MCBlockStateMeta) {
-				MCBlockState bs = ((MCBlockStateMeta) meta).getBlockState(true);
-				if(bs instanceof MCBanner) {
+			if(meta instanceof MCBlockStateMeta mCBlockStateMeta) {
+				MCBlockState bs = mCBlockStateMeta.getBlockState(true);
+				if(bs instanceof MCBanner banner) {
 					// This is a shield that may or may not have a banner attached, but if we get the BlockState when
 					// no banner exists, it gives us a default one. By first checking hasBlockState(),
 					// we can ensure we don't populate this meta array with the default banner data.
-					if(((MCBlockStateMeta) meta).hasBlockState()) {
-						MCBanner banner = (MCBanner) bs;
-						ma.set("basecolor", banner.getBaseColor().name(), t);
-						CArray patterns = new CArray(t, banner.numberOfPatterns());
+					if(mCBlockStateMeta.hasBlockState()) {
+						ma.set("basecolor", banner.getBaseColor().name(), t, null);
+						CArray patterns = new CArray(t, banner.numberOfPatterns(), (GenericParameters) null, (Environment) null);
 						for(MCPattern p : banner.getPatterns()) {
-							CArray pattern = CArray.GetAssociativeArray(t);
-							pattern.set("shape", new CString(p.getShape().toString(), t), t);
-							pattern.set("color", new CString(p.getColor().toString(), t), t);
-							patterns.push(pattern, t);
+							CArray pattern = CArray.GetAssociativeArray(t, null, null);
+							pattern.set("shape", new CString(p.getShape().toString(), t), t, null);
+							pattern.set("color", new CString(p.getColor().toString(), t), t, null);
+							patterns.push(pattern, t, null);
 						}
-						ma.set("patterns", patterns, t);
+						ma.set("patterns", patterns, t, null);
 					}
-				} else if(bs instanceof MCCreatureSpawner) {
-					MCCreatureSpawner mccs = (MCCreatureSpawner) bs;
+				} else if(bs instanceof MCCreatureSpawner mccs) {
 					MCEntityType type = mccs.getSpawnedType();
 					if(type == null) {
-						ma.set("spawntype", CNull.NULL, t);
+						ma.set("spawntype", CNull.NULL, t, null);
 					} else {
-						ma.set("spawntype", type.name());
-					}
-					ma.set("delay", new CInt(mccs.getDelay(), t), t);
-					ma.set("mindelay", new CInt(mccs.getMinDelay(), t), t);
-					ma.set("maxdelay", new CInt(mccs.getMaxDelay(), t), t);
-					ma.set("spawncount", new CInt(mccs.getSpawnCount(), t), t);
-					ma.set("maxnearbyentities", new CInt(mccs.getMaxNearbyEntities(), t), t);
-					ma.set("playerrange", new CInt(mccs.getPlayerRange(), t), t);
-					ma.set("spawnrange", new CInt(mccs.getSpawnRange(), t), t);
-				} else if(bs instanceof MCBrewingStand) {
-					MCBrewingStand brewStand = (MCBrewingStand) bs;
-					ma.set("brewtime", new CInt(brewStand.getBrewingTime(), t), t);
-					ma.set("fuel", new CInt(brewStand.getFuelLevel(), t), t);
+						ma.set("spawntype", type.name(), t, null);
+					}
+					ma.set("delay", new CInt(mccs.getDelay(), t), t, null);
+					ma.set("mindelay", new CInt(mccs.getMinDelay(), t), t, null);
+					ma.set("maxdelay", new CInt(mccs.getMaxDelay(), t), t, null);
+					ma.set("spawncount", new CInt(mccs.getSpawnCount(), t), t, null);
+					ma.set("maxnearbyentities", new CInt(mccs.getMaxNearbyEntities(), t), t, null);
+					ma.set("playerrange", new CInt(mccs.getPlayerRange(), t), t, null);
+					ma.set("spawnrange", new CInt(mccs.getSpawnRange(), t), t, null);
+				} else if(bs instanceof MCBrewingStand brewStand) {
+					ma.set("brewtime", new CInt(brewStand.getBrewingTime(), t), t, null);
+					ma.set("fuel", new CInt(brewStand.getFuelLevel(), t), t, null);
 					MCBrewerInventory inv = brewStand.getInventory();
-					CArray invData = CArray.GetAssociativeArray(t);
+					CArray invData = CArray.GetAssociativeArray(t, null, null);
 					if(inv.getFuel().getAmount() != 0) {
-						invData.set("fuel", ObjectGenerator.GetGenerator().item(inv.getFuel(), t), t);
+						invData.set("fuel", ObjectGenerator.GetGenerator().item(inv.getFuel(), t), t, null);
 					}
 					if(inv.getIngredient().getAmount() != 0) {
-						invData.set("ingredient", ObjectGenerator.GetGenerator().item(inv.getIngredient(), t), t);
+						invData.set("ingredient", ObjectGenerator.GetGenerator().item(inv.getIngredient(), t), t, null);
 					}
 					if(inv.getLeftBottle().getAmount() != 0) {
-						invData.set("leftbottle", ObjectGenerator.GetGenerator().item(inv.getLeftBottle(), t), t);
+						invData.set("leftbottle", ObjectGenerator.GetGenerator().item(inv.getLeftBottle(), t), t, null);
 					}
 					if(inv.getMiddleBottle().getAmount() != 0) {
-						invData.set("middlebottle", ObjectGenerator.GetGenerator().item(inv.getMiddleBottle(), t), t);
+						invData.set("middlebottle", ObjectGenerator.GetGenerator().item(inv.getMiddleBottle(), t), t, null);
 					}
 					if(inv.getRightBottle().getAmount() != 0) {
-						invData.set("rightbottle", ObjectGenerator.GetGenerator().item(inv.getRightBottle(), t), t);
+						invData.set("rightbottle", ObjectGenerator.GetGenerator().item(inv.getRightBottle(), t), t, null);
 					}
-					ma.set("inventory", invData, t);
-				} else if(bs instanceof MCFurnace) {
-					MCFurnace furnace = (MCFurnace) bs;
-					ma.set("burntime", new CInt(furnace.getBurnTime(), t), t);
-					ma.set("cooktime", new CInt(furnace.getCookTime(), t), t);
+					ma.set("inventory", invData, t, null);
+				} else if(bs instanceof MCFurnace furnace) {
+					ma.set("burntime", new CInt(furnace.getBurnTime(), t), t, null);
+					ma.set("cooktime", new CInt(furnace.getCookTime(), t), t, null);
 					MCFurnaceInventory inv = furnace.getInventory();
-					CArray invData = CArray.GetAssociativeArray(t);
+					CArray invData = CArray.GetAssociativeArray(t, null, null);
 					if(inv.getResult().getAmount() != 0) {
-						invData.set("result", ObjectGenerator.GetGenerator().item(inv.getResult(), t), t);
+						invData.set("result", ObjectGenerator.GetGenerator().item(inv.getResult(), t), t, null);
 					}
 					if(inv.getFuel().getAmount() != 0) {
-						invData.set("fuel", ObjectGenerator.GetGenerator().item(inv.getFuel(), t), t);
+						invData.set("fuel", ObjectGenerator.GetGenerator().item(inv.getFuel(), t), t, null);
 					}
 					if(inv.getSmelting().getAmount() != 0) {
-						invData.set("smelting", ObjectGenerator.GetGenerator().item(inv.getSmelting(), t), t);
+						invData.set("smelting", ObjectGenerator.GetGenerator().item(inv.getSmelting(), t), t, null);
 					}
-					ma.set("inventory", invData, t);
+					ma.set("inventory", invData, t, null);
 				} else if(bs instanceof MCDecoratedPot decoratedPot) {
-					CArray sherds = CArray.GetAssociativeArray(t);
+					CArray sherds = CArray.GetAssociativeArray(t, null, null);
 					Map<MCDecoratedPot.Side, MCMaterial> potSherds = decoratedPot.getSherds();
 					for(Map.Entry<MCDecoratedPot.Side, MCMaterial> side : potSherds.entrySet()) {
-						sherds.set(side.getKey().name().toLowerCase(), side.getValue().name());
+						sherds.set(side.getKey().name().toLowerCase(), side.getValue().name(), t, null);
 					}
-					ma.set("sherds", sherds, t);
+					ma.set("sherds", sherds, t, null);
 					if(Static.getServer().getMinecraftVersion().gte(MCVersion.MC1_20_4)) {
-						ma.set("item", item(decoratedPot.getItemStack(), t), t);
+						ma.set("item", item(decoratedPot.getItemStack(), t), t, null);
 					}
-				} else if(bs instanceof MCInventoryHolder) {
+				} else if(bs instanceof MCInventoryHolder mCInventoryHolder) {
 					// Finally, handle InventoryHolders with inventory slots that do not have a special meaning.
-					MCInventory inv = ((MCInventoryHolder) bs).getInventory();
-					CArray box = CArray.GetAssociativeArray(t);
+					MCInventory inv = mCInventoryHolder.getInventory();
+					CArray box = CArray.GetAssociativeArray(t, null, null);
 					for(int i = 0; i < inv.getSize(); i++) {
 						Construct item = ObjectGenerator.GetGenerator().item(inv.getItem(i), t);
 						if(!(item instanceof CNull)) {
-							box.set(i, item, t);
+							box.set(i, item, t, null);
 						}
 					}
-					ma.set("inventory", box, t);
+					ma.set("inventory", box, t, null);
 				} else if(bs instanceof MCSign sign) {
-					ma.set("waxed", CBoolean.get(sign.isWaxed()), t);
-					CArray lines = new CArray(t);
+					ma.set("waxed", CBoolean.get(sign.isWaxed()), t, null);
+					CArray lines = new CArray(t, null, null);
 					for(String line : sign.getLines()) {
-						lines.push(new CString(line, t), t);
+						lines.push(new CString(line, t), t, null);
 					}
-					ma.set("signtext", lines, t);
-					ma.set("glowing", CBoolean.get(sign.isGlowingText()), t);
+					ma.set("signtext", lines, t, null);
+					ma.set("glowing", CBoolean.get(sign.isGlowingText()), t, null);
 					MCDyeColor color = sign.getDyeColor();
 					if(color == null) {
-						ma.set("color", CNull.NULL, t);
+						ma.set("color", CNull.NULL, t, null);
 					} else {
-						ma.set("color", color.name(), t);
+						ma.set("color", color.name(), t, null);
 					}
 					MCSignText backText = sign.getBackText();
 					if(backText != null) {
-						CArray back = new CArray(t);
+						CArray back = new CArray(t, null, null);
 						for(String line : backText.getLines()) {
-							back.push(new CString(line, t), t);
+							back.push(new CString(line, t), t, null);
 						}
-						ma.set("backtext", back, t);
-						ma.set("backglowing", CBoolean.get(backText.isGlowingText()), t);
+						ma.set("backtext", back, t, null);
+						ma.set("backglowing", CBoolean.get(backText.isGlowingText()), t, null);
 						MCDyeColor backColor = backText.getDyeColor();
 						if(backColor == null) {
-							ma.set("backcolor", CNull.NULL, t);
+							ma.set("backcolor", CNull.NULL, t, null);
 						} else {
-							ma.set("backcolor", backColor.name(), t);
+							ma.set("backcolor", backColor.name(), t, null);
 						}
 					}
 				} else if(bs instanceof MCCommandBlock cmdBlock) {
-					ma.set("command", cmdBlock.getCommand());
-					ma.set("customname", cmdBlock.getName());
+					ma.set("command", cmdBlock.getCommand(), t, null);
+					ma.set("customname", cmdBlock.getName(), t, null);
 				} else if(bs instanceof MCBeehive beehive) {
-					ma.set("beecount", new CInt(beehive.getEntityCount(), t), t);
+					ma.set("beecount", new CInt(beehive.getEntityCount(), t), t, null);
 				}
 			} else if(meta instanceof MCArmorMeta armorMeta) { // Must be before MCLeatherArmorMeta
 				if(armorMeta.hasTrim()) {
-					CArray trim = CArray.GetAssociativeArray(t);
-					trim.set("material", armorMeta.getTrimMaterial().name());
-					trim.set("pattern", armorMeta.getTrimPattern().name());
-					ma.set("trim", trim, t);
+					CArray trim = CArray.GetAssociativeArray(t, null, null);
+					trim.set("material", armorMeta.getTrimMaterial().name(), t, null);
+					trim.set("pattern", armorMeta.getTrimPattern().name(), t, null);
+					ma.set("trim", trim, t, null);
 				} else {
-					ma.set("trim", CNull.NULL, t);
+					ma.set("trim", CNull.NULL, t, null);
 				}
-				if(armorMeta instanceof MCColorableArmorMeta) {
-					ma.set("color", color(((MCColorableArmorMeta) armorMeta).getColor(), t), t);
+				if(armorMeta instanceof MCColorableArmorMeta mCColorableArmorMeta) {
+					ma.set("color", color(mCColorableArmorMeta.getColor(), t), t, null);
 				}
-			} else if(meta instanceof MCFireworkEffectMeta) {
-				MCFireworkEffectMeta mcfem = (MCFireworkEffectMeta) meta;
+			} else if(meta instanceof MCFireworkEffectMeta mcfem) {
 				MCFireworkEffect effect = mcfem.getEffect();
 				if(effect == null) {
-					ma.set("effect", CNull.NULL, t);
+					ma.set("effect", CNull.NULL, t, null);
 				} else {
-					ma.set("effect", fireworkEffect(effect, t), t);
+					ma.set("effect", fireworkEffect(effect, t), t, null);
 				}
-			} else if(meta instanceof MCFireworkMeta) {
-				MCFireworkMeta mcfm = (MCFireworkMeta) meta;
-				CArray firework = CArray.GetAssociativeArray(t);
-				firework.set("strength", new CInt(mcfm.getStrength(), t), t);
-				CArray fe = new CArray(t);
+			} else if(meta instanceof MCFireworkMeta mcfm) {
+				CArray firework = CArray.GetAssociativeArray(t, null, null);
+				firework.set("strength", new CInt(mcfm.getStrength(), t), t, null);
+				CArray fe = new CArray(t, null, null);
 				for(MCFireworkEffect effect : mcfm.getEffects()) {
-					fe.push(fireworkEffect(effect, t), t);
+					fe.push(fireworkEffect(effect, t), t, null);
 				}
-				firework.set("effects", fe, t);
-				ma.set("firework", firework, t);
-			} else if(meta instanceof MCLeatherArmorMeta) {
-				CArray color = color(((MCLeatherArmorMeta) meta).getColor(), t);
-				ma.set("color", color, t);
+				firework.set("effects", fe, t, null);
+				ma.set("firework", firework, t, null);
+			} else if(meta instanceof MCLeatherArmorMeta mCLeatherArmorMeta) {
+				CArray color = color(mCLeatherArmorMeta.getColor(), t);
+				ma.set("color", color, t, null);
 			} else if(meta instanceof MCBookMeta bookMeta) {
 				if(material.getAbstracted() == MCVanillaMaterial.WRITTEN_BOOK) {
 					Construct title;
@@ -792,181 +829,175 @@ public Construct itemMeta(MCItemStack is, Target t) {
 					} else {
 						author = CNull.NULL;
 					}
-					ma.set("title", title, t);
-					ma.set("author", author, t);
-					ma.set("generation", bookMeta.getGeneration().name(), t);
+					ma.set("title", title, t, null);
+					ma.set("author", author, t, null);
+					ma.set("generation", bookMeta.getGeneration().name(), t, null);
 				}
 				Construct pages;
 				if(bookMeta.hasPages()) {
-					pages = new CArray(t);
+					pages = new CArray(t, null, null);
 					for(String p : bookMeta.getPages()) {
-						((CArray) pages).push(new CString(p, t), t);
+						((CArray) pages).push(new CString(p, t), t, null);
 					}
 				} else {
 					pages = CNull.NULL;
 				}
-				ma.set("pages", pages, t);
-			} else if(meta instanceof MCSkullMeta) {
-				MCPlayerProfile profile = ((MCSkullMeta) meta).getProfile();
+				ma.set("pages", pages, t, null);
+			} else if(meta instanceof MCSkullMeta mCSkullMeta) {
+				MCPlayerProfile profile = mCSkullMeta.getProfile();
 				// If a profile doesn't exist, it either doesn't have one (plain head) or it's not supported by server.
 				// Either way we fall back to old behavior.
 				if(profile != null) {
 					if(profile.getName() != null) {
-						ma.set("owner", new CString(profile.getName(), t), t);
+						ma.set("owner", new CString(profile.getName(), t), t, null);
 					} else {
-						ma.set("owner", CNull.NULL, t);
+						ma.set("owner", CNull.NULL, t, null);
 					}
 					if(profile.getId() != null) {
-						ma.set("owneruuid", new CString(profile.getId().toString(), t), t);
+						ma.set("owneruuid", new CString(profile.getId().toString(), t), t, null);
 					} else {
-						ma.set("owneruuid", CNull.NULL, t);
+						ma.set("owneruuid", CNull.NULL, t, null);
 					}
 					MCProfileProperty texture = profile.getProperty("textures");
 					if(texture != null) {
-						ma.set("texture", new CString(texture.getValue(), t), t);
+						ma.set("texture", new CString(texture.getValue(), t), t, null);
 					} else {
-						ma.set("texture", CNull.NULL, t);
+						ma.set("texture", CNull.NULL, t, null);
 					}
 				} else {
-					if(((MCSkullMeta) meta).hasOwner()) {
-						ma.set("owner", new CString(((MCSkullMeta) meta).getOwner(), t), t);
-						MCOfflinePlayer ofp = ((MCSkullMeta) meta).getOwningPlayer();
+					if(mCSkullMeta.hasOwner()) {
+						ma.set("owner", new CString(mCSkullMeta.getOwner(), t), t, null);
+						MCOfflinePlayer ofp = mCSkullMeta.getOwningPlayer();
 						if(ofp != null) {
-							ma.set("owneruuid", new CString(ofp.getUniqueID().toString(), t), t);
+							ma.set("owneruuid", new CString(ofp.getUniqueID().toString(), t), t, null);
 						} else {
-							ma.set("owneruuid", CNull.NULL, t);
+							ma.set("owneruuid", CNull.NULL, t, null);
 						}
 					} else {
-						ma.set("owner", CNull.NULL, t);
-						ma.set("owneruuid", CNull.NULL, t);
+						ma.set("owner", CNull.NULL, t, null);
+						ma.set("owneruuid", CNull.NULL, t, null);
 					}
 				}
 				if(Static.getServer().getMinecraftVersion().gte(MCVersion.MC1_19_3)) {
-					String sound = ((MCSkullMeta) meta).getNoteBlockSound();
+					String sound = mCSkullMeta.getNoteBlockSound();
 					if(sound == null) {
-						ma.set("noteblocksound", CNull.NULL, t);
+						ma.set("noteblocksound", CNull.NULL, t, null);
 					} else {
-						ma.set("noteblocksound", new CString(sound, t), t);
+						ma.set("noteblocksound", new CString(sound, t), t, null);
 					}
 				}
-			} else if(meta instanceof MCEnchantmentStorageMeta) {
+			} else if(meta instanceof MCEnchantmentStorageMeta mCEnchantmentStorageMeta) {
 				Construct stored;
-				if(((MCEnchantmentStorageMeta) meta).hasStoredEnchants()) {
-					stored = enchants(((MCEnchantmentStorageMeta) meta).getStoredEnchants(), t);
+				if(mCEnchantmentStorageMeta.hasStoredEnchants()) {
+					stored = enchants(mCEnchantmentStorageMeta.getStoredEnchants(), t);
 				} else {
 					stored = CNull.NULL;
 				}
-				ma.set("stored", stored, t);
-			} else if(meta instanceof MCPotionMeta) {
-				MCPotionMeta potionmeta = (MCPotionMeta) meta;
+				ma.set("stored", stored, t, null);
+			} else if(meta instanceof MCPotionMeta potionmeta) {
 				CArray effects = potions(potionmeta.getCustomEffects(), t);
-				ma.set("potions", effects, t);
+				ma.set("potions", effects, t, null);
 				if(Static.getServer().getMinecraftVersion().gte(MCVersion.MC1_20_6)) {
 					MCPotionType potionType = potionmeta.getBasePotionType();
 					if(potionType == null) {
-						ma.set("potiontype", CNull.NULL, t);
+						ma.set("potiontype", CNull.NULL, t, null);
 					} else {
-						ma.set("potiontype", potionType.name());
+						ma.set("potiontype", potionType.name(), t, null);
 					}
 				} else {
 					MCPotionData potiondata = potionmeta.getBasePotionData();
 					if(potiondata != null) {
-						ma.set("base", potionData(potiondata, t), t);
+						ma.set("base", potionData(potiondata, t), t, null);
 					}
 				}
 				if(potionmeta.hasColor()) {
-					ma.set("color", color(potionmeta.getColor(), t), t);
+					ma.set("color", color(potionmeta.getColor(), t), t, null);
 				} else {
-					ma.set("color", CNull.NULL, t);
+					ma.set("color", CNull.NULL, t, null);
 				}
 			} else if(meta instanceof MCSuspiciousStewMeta susstew) {
 				CArray effects = potions(susstew.getCustomEffects(), t);
-				ma.set("potions", effects, t);
-			} else if(meta instanceof MCBannerMeta) {
-				MCBannerMeta bannermeta = (MCBannerMeta) meta;
-				CArray patterns = new CArray(t, bannermeta.numberOfPatterns());
+				ma.set("potions", effects, t, null);
+			} else if(meta instanceof MCBannerMeta bannermeta) {
+				CArray patterns = new CArray(t, bannermeta.numberOfPatterns(), (GenericParameters) null, (Environment) null);
 				for(MCPattern p : bannermeta.getPatterns()) {
-					CArray pattern = CArray.GetAssociativeArray(t);
-					pattern.set("shape", new CString(p.getShape().toString(), t), t);
-					pattern.set("color", new CString(p.getColor().toString(), t), t);
-					patterns.push(pattern, t);
-				}
-				ma.set("patterns", patterns, t);
-			} else if(meta instanceof MCMapMeta) {
-				MCMapMeta mm = ((MCMapMeta) meta);
+					CArray pattern = CArray.GetAssociativeArray(t, null, null);
+					pattern.set("shape", new CString(p.getShape().toString(), t), t, null);
+					pattern.set("color", new CString(p.getColor().toString(), t), t, null);
+					patterns.push(pattern, t, null);
+				}
+				ma.set("patterns", patterns, t, null);
+			} else if(meta instanceof MCMapMeta mCMapMeta) {
+				MCMapMeta mm = mCMapMeta;
 				MCColor mapcolor = mm.getColor();
 				if(mapcolor == null) {
-					ma.set("color", CNull.NULL, t);
+					ma.set("color", CNull.NULL, t, null);
 				} else {
-					ma.set("color", color(mapcolor, t), t);
+					ma.set("color", color(mapcolor, t), t, null);
 				}
 				if(mm.hasMapId()) {
-					ma.set("mapid", new CInt(mm.getMapId(), t), t);
+					ma.set("mapid", new CInt(mm.getMapId(), t), t, null);
 				} else {
-					ma.set("mapid", CNull.NULL, t);
+					ma.set("mapid", CNull.NULL, t, null);
 				}
-			} else if(meta instanceof MCTropicalFishBucketMeta) {
-				MCTropicalFishBucketMeta fm = (MCTropicalFishBucketMeta) meta;
+			} else if(meta instanceof MCTropicalFishBucketMeta fm) {
 				if(fm.hasVariant()) {
-					ma.set("fishcolor", new CString(fm.getBodyColor().name(), t), t);
-					ma.set("fishpatterncolor", new CString(fm.getPatternColor().name(), t), t);
-					ma.set("fishpattern", new CString(fm.getPattern().name(), t), t);
+					ma.set("fishcolor", new CString(fm.getBodyColor().name(), t), t, null);
+					ma.set("fishpatterncolor", new CString(fm.getPatternColor().name(), t), t, null);
+					ma.set("fishpattern", new CString(fm.getPattern().name(), t), t, null);
 				} else {
-					ma.set("fishcolor", CNull.NULL, t);
-					ma.set("fishpatterncolor", CNull.NULL, t);
-					ma.set("fishpattern", CNull.NULL, t);
+					ma.set("fishcolor", CNull.NULL, t, null);
+					ma.set("fishpatterncolor", CNull.NULL, t, null);
+					ma.set("fishpattern", CNull.NULL, t, null);
 				}
-			} else if(meta instanceof MCCrossbowMeta) {
-				MCCrossbowMeta cbm = (MCCrossbowMeta) meta;
+			} else if(meta instanceof MCCrossbowMeta cbm) {
 				if(cbm.hasChargedProjectiles()) {
-					CArray projectiles = new CArray(t);
+					CArray projectiles = new CArray(t, null, null);
 					for(MCItemStack projectile : cbm.getChargedProjectiles()) {
-						projectiles.push(item(projectile, t), t);
+						projectiles.push(item(projectile, t), t, null);
 					}
-					ma.set("projectiles", projectiles, t);
+					ma.set("projectiles", projectiles, t, null);
 				} else {
-					ma.set("projectiles", CNull.NULL, t);
+					ma.set("projectiles", CNull.NULL, t, null);
 				}
-			} else if(meta instanceof MCCompassMeta) {
-				MCCompassMeta cm = (MCCompassMeta) meta;
+			} else if(meta instanceof MCCompassMeta cm) {
 				if(cm.getTargetLocation() == null) {
-					ma.set("target", CNull.NULL, t);
+					ma.set("target", CNull.NULL, t, null);
 				} else {
-					ma.set("target", location(cm.getTargetLocation(), false), t);
+					ma.set("target", location(cm.getTargetLocation(), false), t, null);
 				}
-				ma.set("lodestone", CBoolean.get(cm.isLodestoneTracked()), t);
-			} else if(meta instanceof MCBundleMeta) {
-				MCBundleMeta bm = (MCBundleMeta) meta;
+				ma.set("lodestone", CBoolean.get(cm.isLodestoneTracked()), t, null);
+			} else if(meta instanceof MCBundleMeta bm) {
 				List<MCItemStack> items = bm.getItems();
-				CArray arrayItems = new CArray(t);
+				CArray arrayItems = new CArray(t, null, null);
 				for(MCItemStack item : items) {
-					arrayItems.push(ObjectGenerator.GetGenerator().item(item, t), t);
+					arrayItems.push(ObjectGenerator.GetGenerator().item(item, t), t, null);
 				}
-				ma.set("items", arrayItems, t);
-			} else if(meta instanceof MCAxolotlBucketMeta) {
-				ma.set("variant", ((MCAxolotlBucketMeta) meta).getAxolotlType().name());
-			} else if(meta instanceof MCMusicInstrumentMeta) {
-				String instrumentKey = ((MCMusicInstrumentMeta) meta).getInstrument();
+				ma.set("items", arrayItems, t, null);
+			} else if(meta instanceof MCAxolotlBucketMeta mCAxolotlBucketMeta) {
+				ma.set("variant", mCAxolotlBucketMeta.getAxolotlType().name(), t, null);
+			} else if(meta instanceof MCMusicInstrumentMeta mCMusicInstrumentMeta) {
+				String instrumentKey = mCMusicInstrumentMeta.getInstrument();
 				if(instrumentKey == null) {
-					ma.set("instrument", CNull.NULL, t);
+					ma.set("instrument", CNull.NULL, t, null);
 				} else {
-					ma.set("instrument", instrumentKey);
+					ma.set("instrument", instrumentKey, t, null);
 				}
 			} else if(meta instanceof MCKnowledgeBookMeta knowledgeBookMeta) {
 				if(knowledgeBookMeta.hasRecipes()) {
-					CArray recipes = new CArray(t);
+					CArray recipes = new CArray(t, null, null);
 					for(MCNamespacedKey key : knowledgeBookMeta.getRecipes()) {
-						recipes.push(new CString(key.toString(), t), t);
+						recipes.push(new CString(key.toString(), t), t, null);
 					}
-					ma.set("recipes", recipes, t);
+					ma.set("recipes", recipes, t, null);
 				} else {
-					ma.set("recipes", CNull.NULL, t);
+					ma.set("recipes", CNull.NULL, t, null);
 				}
 			} else if(meta instanceof MCOminousBottleMeta ominousBottleMeta) {
 				if(ominousBottleMeta.hasAmplifier()) {
-					ma.set("ominousamplifier", new CInt(ominousBottleMeta.getAmplifier(), t), t);
+					ma.set("ominousamplifier", new CInt(ominousBottleMeta.getAmplifier(), t), t, null);
 				} else {
-					ma.set("ominousamplifier", CNull.NULL, t);
+					ma.set("ominousamplifier", CNull.NULL, t, null);
 				}
 			}
 			return ma;
@@ -974,19 +1005,38 @@ public Construct itemMeta(MCItemStack is, Target t) {
 	}
 
 	/**
-	 * Generates item meta from the provided item material before applying the data from the specified fields
-	 * in the provided array. Returns null when given null data.
+	 * Generates item meta from the provided item material before applying the data from the specified fields in the
+	 * provided array. Returns null when given null data.
+	 *
 	 * @param c an associative CArray representation of item meta
 	 * @param mat the item material from which to generate the item meta
 	 * @param t
 	 * @return abstract item meta
 	 * @throws ConfigRuntimeException
+	 * @deprecated Use {@link #itemMeta(Mixed, MCMaterial, Target, Environment)} instead.
 	 */
+	@Deprecated
 	public MCItemMeta itemMeta(Mixed c, MCMaterial mat, Target t) throws ConfigRuntimeException {
+		return itemMeta(c, mat, t, null);
+	}
+
+	/**
+	 * Generates item meta from the provided item material before applying the data from the specified fields in the
+	 * provided array. Returns null when given null data.
+	 *
+	 * @param c an associative CArray representation of item meta
+	 * @param mat the item material from which to generate the item meta
+	 * @param t
+	 * @param env
+	 * @return abstract item meta
+	 * @throws ConfigRuntimeException
+	 */
+	@SuppressWarnings({"null", "UseSpecificCatch"})
+	public MCItemMeta itemMeta(Mixed c, MCMaterial mat, Target t, Environment env) throws ConfigRuntimeException {
 		if(c instanceof CNull) {
 			return null;
 		}
-		if(!c.isInstanceOf(CArray.TYPE)) {
+		if(!c.isInstanceOf(CArray.TYPE, null, env)) {
 			throw new CREFormatException("An array was expected but received " + c + " instead.", t);
 		} else {
 			MCItemFactory itemFactory = Static.getServer().getItemFactory();
@@ -1000,24 +1050,24 @@ public MCItemMeta itemMeta(Mixed c, MCMaterial mat, Target t) throws ConfigRunti
 			}
 			try {
 				if(ma.containsKey("display")) {
-					Mixed dni = ma.get("display", t);
+					Mixed dni = ma.get("display", t, env);
 					if(!(dni instanceof CNull)) {
 						meta.setDisplayName(dni.val());
 					}
 				}
 				if(ma.containsKey("lore")) {
-					Mixed li = ma.get("lore", t);
+					Mixed li = ma.get("lore", t, env);
 					if(li instanceof CNull) {
 						//do nothing
-					} else if(li.isInstanceOf(CString.TYPE)) {
+					} else if(li.isInstanceOf(CString.TYPE, null, env)) {
 						List<String> ll = new ArrayList<>();
 						ll.add(li.val());
 						meta.setLore(ll);
-					} else if(li.isInstanceOf(CArray.TYPE)) {
+					} else if(li.isInstanceOf(CArray.TYPE, null, env)) {
 						CArray la = (CArray) li;
 						List<String> ll = new ArrayList<>();
-						for(int j = 0; j < la.size(); j++) {
-							ll.add(la.get(j, t).val());
+						for(int j = 0; j < la.size(env); j++) {
+							ll.add(la.get(j, t, env).val());
 						}
 						meta.setLore(ll);
 					} else {
@@ -1025,9 +1075,9 @@ public MCItemMeta itemMeta(Mixed c, MCMaterial mat, Target t) throws ConfigRunti
 					}
 				}
 				if(ma.containsKey("enchants")) {
-					Mixed enchants = ma.get("enchants", t);
-					if(enchants.isInstanceOf(CArray.TYPE)) {
-						for(Map.Entry<MCEnchantment, Integer> ench : enchants((CArray) enchants, t).entrySet()) {
+					Mixed enchants = ma.get("enchants", t, env);
+					if(enchants.isInstanceOf(CArray.TYPE, null, env)) {
+						for(Map.Entry<MCEnchantment, Integer> ench : enchants((CArray) enchants, t, env).entrySet()) {
 							meta.addEnchant(ench.getKey(), ench.getValue(), true);
 						}
 					} else {
@@ -1035,23 +1085,23 @@ public MCItemMeta itemMeta(Mixed c, MCMaterial mat, Target t) throws ConfigRunti
 					}
 				}
 				if(ma.containsKey("repair")) {
-					Mixed r = ma.get("repair", t);
+					Mixed r = ma.get("repair", t, env);
 					if(!(r instanceof CNull)) {
-						meta.setRepairCost(ArgumentValidation.getInt32(r, t));
+						meta.setRepairCost(ArgumentValidation.getInt32(r, t, env));
 					}
 				}
 				if(ma.containsKey("model")) {
-					Mixed m = ma.get("model", t);
+					Mixed m = ma.get("model", t, env);
 					if(!(m instanceof CNull)) {
-						meta.setCustomModelData(ArgumentValidation.getInt32(m, t));
+						meta.setCustomModelData(ArgumentValidation.getInt32(m, t, env));
 					}
 				}
 				if(ma.containsKey("flags")) {
-					Mixed flags = ma.get("flags", t);
-					if(flags.isInstanceOf(CArray.TYPE)) {
+					Mixed flags = ma.get("flags", t, env);
+					if(flags.isInstanceOf(CArray.TYPE, null, env)) {
 						CArray flagArray = (CArray) flags;
-						for(int i = 0; i < flagArray.size(); i++) {
-							Mixed flag = flagArray.get(i, t);
+						for(int i = 0; i < flagArray.size(env); i++) {
+							Mixed flag = flagArray.get(i, t, env);
 							meta.addItemFlags(MCItemFlag.valueOf(flag.val().toUpperCase()));
 						}
 					} else {
@@ -1060,17 +1110,17 @@ public MCItemMeta itemMeta(Mixed c, MCMaterial mat, Target t) throws ConfigRunti
 				}
 
 				if(ma.containsKey("modifiers")) {
-					Mixed modifiers = ma.get("modifiers", t);
+					Mixed modifiers = ma.get("modifiers", t, env);
 					if(modifiers instanceof CNull) {
 						// no modifiers
-					} else if(modifiers.isInstanceOf(CArray.TYPE)) {
+					} else if(modifiers.isInstanceOf(CArray.TYPE, null, env)) {
 						CArray modifierArray = (CArray) modifiers;
 						if(modifierArray.isAssociative()) {
 							throw new CREFormatException("Array of attribute modifiers cannot be associative.", t);
 						}
 						List<MCAttributeModifier> modifierList = new ArrayList<>();
 						for(String key : modifierArray.stringKeySet()) {
-							modifierList.add(attributeModifier(ArgumentValidation.getArray(modifierArray.get(key, t), t), t));
+							modifierList.add(attributeModifier(ArgumentValidation.getArray(modifierArray.get(key, t, env), t, env), t, env));
 						}
 						meta.setAttributeModifiers(modifierList);
 					} else {
@@ -1079,70 +1129,70 @@ public MCItemMeta itemMeta(Mixed c, MCMaterial mat, Target t) throws ConfigRunti
 				}
 
 				if(ma.containsKey("tags")) {
-					Mixed tagArray = ma.get("tags", t);
+					Mixed tagArray = ma.get("tags", t, env);
 					if(tagArray instanceof CNull) {
 						// no custom tags
 					} else {
-						MCTagType.TAG_CONTAINER.convert(meta.getCustomTags(), tagArray);
+						MCTagType.TAG_CONTAINER.convert(meta.getCustomTags(), tagArray, env);
 					}
 				}
 
 				if(Static.getServer().getMinecraftVersion().gte(MCVersion.MC1_20_6)) {
 					// Item data components
 					if(ma.containsKey("maxstacksize")) {
-						Mixed maxstacksize = ma.get("maxstacksize", t);
+						Mixed maxstacksize = ma.get("maxstacksize", t, env);
 						if(maxstacksize instanceof CNull) {
 							// not yet supported
 						} else {
-							meta.setMaxStackSize(ArgumentValidation.getInt32(maxstacksize, t));
+							meta.setMaxStackSize(ArgumentValidation.getInt32(maxstacksize, t, env));
 						}
 					}
 					if(ma.containsKey("glint")) {
-						Mixed glint = ma.get("glint", t);
+						Mixed glint = ma.get("glint", t, env);
 						if(glint instanceof CNull) {
 							// not yet supported
 						} else {
-							meta.setEnchantmentGlintOverride(ArgumentValidation.getBooleanObject(glint, t));
+							meta.setEnchantmentGlintOverride(ArgumentValidation.getBooleanObject(glint, t, env));
 						}
 					}
 					if(ma.containsKey("maxdamage")) {
-						Mixed maxdamage = ma.get("maxdamage", t);
+						Mixed maxdamage = ma.get("maxdamage", t, env);
 						if(maxdamage instanceof CNull) {
 							// not yet supported
 						} else {
-							meta.setMaxDamage(ArgumentValidation.getInt32(maxdamage, t));
+							meta.setMaxDamage(ArgumentValidation.getInt32(maxdamage, t, env));
 						}
 					}
 					if(ma.containsKey("rarity")) {
-						Mixed rarity = ma.get("rarity", t);
+						Mixed rarity = ma.get("rarity", t, env);
 						if(rarity instanceof CNull) {
 							// not yet supported
 						} else {
 							try {
 								meta.setRarity(MCItemRarity.valueOf(rarity.val()));
-							} catch (IllegalArgumentException ex) {
+							} catch(IllegalArgumentException ex) {
 								throw new CREFormatException("Rarity does not exist: " + rarity.val(), t);
 							}
 						}
 					}
 					if(ma.containsKey("food")) {
-						Mixed mixedFood = ma.get("food", t);
+						Mixed mixedFood = ma.get("food", t, env);
 						if(mixedFood instanceof CNull) {
 							// not supported yet
-						} else if(mixedFood.isInstanceOf(CArray.TYPE)) {
+						} else if(mixedFood.isInstanceOf(CArray.TYPE, null, env)) {
 							CArray foodArray = (CArray) mixedFood;
 							if(!foodArray.isAssociative()) {
 								throw new CREFormatException("Food array must be associative.", t);
 							}
 							MCFoodComponent food = meta.getFood();
 							if(foodArray.containsKey("nutrition")) {
-								food.setNutrition(ArgumentValidation.getInt32(foodArray.get("nutrition", t), t));
+								food.setNutrition(ArgumentValidation.getInt32(foodArray.get("nutrition", t, env), t, env));
 							}
 							if(foodArray.containsKey("saturation")) {
-								food.setSaturation(ArgumentValidation.getDouble32(foodArray.get("saturation", t), t));
+								food.setSaturation(ArgumentValidation.getDouble32(foodArray.get("saturation", t, env), t, env));
 							}
 							if(foodArray.containsKey("always")) {
-								food.setCanAlwaysEat(ArgumentValidation.getBooleanObject(foodArray.get("always", t), t));
+								food.setCanAlwaysEat(ArgumentValidation.getBooleanObject(foodArray.get("always", t, env), t, env));
 							}
 							meta.setFood(food);
 						} else {
@@ -1152,7 +1202,7 @@ public MCItemMeta itemMeta(Mixed c, MCMaterial mat, Target t) throws ConfigRunti
 				}
 				if(Static.getServer().getMinecraftVersion().gte(MCVersion.MC1_21)) {
 					if(ma.containsKey("jukeboxsong")) {
-						Mixed playable = ma.get("jukeboxsong", t);
+						Mixed playable = ma.get("jukeboxsong", t, env);
 						if(playable instanceof CNull) {
 							// not yet supported
 						} else {
@@ -1162,44 +1212,44 @@ public MCItemMeta itemMeta(Mixed c, MCMaterial mat, Target t) throws ConfigRunti
 				}
 				if(Static.getServer().getMinecraftVersion().gte(MCVersion.MC1_21_3)) {
 					if(ma.containsKey("enchantability")) {
-						Mixed enchantability = ma.get("enchantability", t);
+						Mixed enchantability = ma.get("enchantability", t, env);
 						if(enchantability instanceof CNull) {
 							// not yet supported
 						} else {
-							meta.setEnchantable(ArgumentValidation.getInt32(enchantability, t));
+							meta.setEnchantable(ArgumentValidation.getInt32(enchantability, t, env));
 						}
 					}
 					if(ma.containsKey("glider")) {
-						Mixed glider = ma.get("glider", t);
+						Mixed glider = ma.get("glider", t, env);
 						if(glider instanceof CNull) {
 							meta.setGlider(false);
 						} else {
-							meta.setGlider(ArgumentValidation.getBooleanObject(glider, t));
+							meta.setGlider(ArgumentValidation.getBooleanObject(glider, t, env));
 						}
 					}
 					if(ma.containsKey("remainder")) {
-						Mixed remainder = ma.get("remainder", t);
+						Mixed remainder = ma.get("remainder", t, env);
 						if(remainder instanceof CNull) {
 							// not yet supported
 						} else {
-							meta.setUseRemainder(item(remainder, t));
+							meta.setUseRemainder(item(remainder, t, env));
 						}
 					}
 					if(ma.containsKey("cooldown")) {
-						Mixed mixedCooldown =  ma.get("cooldown", t);
+						Mixed mixedCooldown = ma.get("cooldown", t, env);
 						if(mixedCooldown instanceof CNull) {
 							// not yet supported
-						} else if(mixedCooldown.isInstanceOf(CArray.TYPE)) {
+						} else if(mixedCooldown.isInstanceOf(CArray.TYPE, null, env)) {
 							CArray cooldownArray = (CArray) mixedCooldown;
 							if(!cooldownArray.isAssociative()) {
 								throw new CREFormatException("Cooldown array must be associative.", t);
 							}
 							MCCooldownComponent cooldown = meta.getUseCooldown();
 							if(cooldownArray.containsKey("seconds")) {
-								cooldown.setSeconds(ArgumentValidation.getDouble32(cooldownArray.get("seconds", t), t));
+								cooldown.setSeconds(ArgumentValidation.getDouble32(cooldownArray.get("seconds", t, env), t, env));
 							}
 							if(cooldownArray.containsKey("group")) {
-								Mixed group = cooldownArray.get("group", t);
+								Mixed group = cooldownArray.get("group", t, env);
 								if(!(group instanceof CNull)) {
 									cooldown.setCooldownGroup(group.val());
 								}
@@ -1210,7 +1260,7 @@ public MCItemMeta itemMeta(Mixed c, MCMaterial mat, Target t) throws ConfigRunti
 						}
 					}
 					if(ma.containsKey("itemmodel")) {
-						Mixed itemmodel = ma.get("itemmodel", t);
+						Mixed itemmodel = ma.get("itemmodel", t, env);
 						if(itemmodel instanceof CNull) {
 							// not yet supported
 						} else {
@@ -1218,7 +1268,7 @@ public MCItemMeta itemMeta(Mixed c, MCMaterial mat, Target t) throws ConfigRunti
 						}
 					}
 					if(ma.containsKey("tooltipstyle")) {
-						Mixed tooltipstyle = ma.get("tooltipstyle", t);
+						Mixed tooltipstyle = ma.get("tooltipstyle", t, env);
 						if(tooltipstyle instanceof CNull) {
 							// not yet supported
 						} else {
@@ -1226,27 +1276,27 @@ public MCItemMeta itemMeta(Mixed c, MCMaterial mat, Target t) throws ConfigRunti
 						}
 					}
 					if(ma.containsKey("equippable")) {
-						Mixed equippableMixed = ma.get("equippable", t);
+						Mixed equippableMixed = ma.get("equippable", t, env);
 						if(equippableMixed instanceof CNull) {
 							// not yet supported
-						} else if(equippableMixed.isInstanceOf(CArray.TYPE)) {
+						} else if(equippableMixed.isInstanceOf(CArray.TYPE, null, env)) {
 							CArray equippableArray = (CArray) equippableMixed;
 							if(!equippableArray.isAssociative()) {
 								throw new CREFormatException("Equippable array must be associative.", t);
 							}
 							MCEquippableComponent equippable = meta.getEquippable();
 							try {
-								String slotName = equippableArray.get("slot", t).val().toUpperCase();
+								String slotName = equippableArray.get("slot", t, env).val().toUpperCase();
 								equippable.setSlot(MCEquipmentSlot.valueOf(slotName));
-							} catch (IllegalArgumentException ex) {
+							} catch(IllegalArgumentException ex) {
 								throw new CREFormatException("Not a valid equipment slot: "
-										+ equippableArray.get("slot", t).val(), t);
+										+ equippableArray.get("slot", t, env).val(), t);
 							}
 							if(equippableArray.containsKey("entities")) {
-								Mixed entitiesMixed = equippableArray.get("entities", t);
+								Mixed entitiesMixed = equippableArray.get("entities", t, env);
 								if(entitiesMixed instanceof CNull) {
 									// ignored
-								} else if(entitiesMixed.isInstanceOf(CArray.TYPE)) {
+								} else if(entitiesMixed.isInstanceOf(CArray.TYPE, null, env)) {
 									CArray entitiesArray = (CArray) entitiesMixed;
 									if(entitiesArray.isAssociative()) {
 										throw new CREFormatException("Allowed entities array must not be associative.", t);
@@ -1259,37 +1309,37 @@ public MCItemMeta itemMeta(Mixed c, MCMaterial mat, Target t) throws ConfigRunti
 								}
 							}
 							if(equippableArray.containsKey("overlay")) {
-								Mixed cameraOverlayMixed = equippableArray.get("overlay", t);
+								Mixed cameraOverlayMixed = equippableArray.get("overlay", t, env);
 								if(!(cameraOverlayMixed instanceof CNull)) {
 									equippable.setCameraOverlay(cameraOverlayMixed.val());
 								}
 							}
 							if(equippableArray.containsKey("damageable")) {
 								equippable.setDamageOnHurt(ArgumentValidation.getBooleanObject(
-										equippableArray.get("damageable", t), t));
+										equippableArray.get("damageable", t, env), t, env));
 							}
 							if(equippableArray.containsKey("dispensable")) {
 								equippable.setDispensable(ArgumentValidation.getBooleanObject(
-										equippableArray.get("dispensable", t), t));
+										equippableArray.get("dispensable", t, env), t, env));
 							}
 							if(equippableArray.containsKey("asset")) {
-								Mixed assetMixed = equippableArray.get("asset", t);
+								Mixed assetMixed = equippableArray.get("asset", t, env);
 								if(!(assetMixed instanceof CNull)) {
 									equippable.setAssetId(assetMixed.val());
 								}
 							}
 							if(equippableArray.containsKey("sound")) {
-								Mixed soundMixed = equippableArray.get("sound", t);
+								Mixed soundMixed = equippableArray.get("sound", t, env);
 								if(!(soundMixed instanceof CNull)) {
 									equippable.setEquipSound(soundMixed.val());
 								}
 							}
 							if(equippableArray.containsKey("swappable")) {
-								equippable.setSwappable(ArgumentValidation.getBooleanObject(equippableArray.get("swappable", t), t));
+								equippable.setSwappable(ArgumentValidation.getBooleanObject(equippableArray.get("swappable", t, env), t, env));
 							}
 							if(Static.getServer().getMinecraftVersion().gte(MCVersion.MC1_21_5)) {
 								if(equippableArray.containsKey("interactable")) {
-									equippable.setEquipOnInteract(ArgumentValidation.getBooleanObject(equippableArray.get("interactable", t), t));
+									equippable.setEquipOnInteract(ArgumentValidation.getBooleanObject(equippableArray.get("interactable", t, env), t, env));
 								}
 							}
 							meta.setEquippable(equippable);
@@ -1299,34 +1349,32 @@ public MCItemMeta itemMeta(Mixed c, MCMaterial mat, Target t) throws ConfigRunti
 					}
 				}
 				if(ma.containsKey("damage")) {
-					Mixed damage = ma.get("damage", t);
+					Mixed damage = ma.get("damage", t, env);
 					if(damage instanceof CNull) {
 						// not yet supported
 					} else {
-						meta.setDamage(ArgumentValidation.getInt32(damage, t));
+						meta.setDamage(ArgumentValidation.getInt32(damage, t, env));
 					}
 				}
 				if(ma.containsKey("unbreakable")) {
-					meta.setUnbreakable(ArgumentValidation.getBooleanish(ma.get("unbreakable", t), t));
+					meta.setUnbreakable(ArgumentValidation.getBooleanish(ma.get("unbreakable", t, env), t, env));
 				}
 				if(ma.containsKey("blockdata")) {
-					Mixed mBlockData = ma.get("blockdata", t);
-					if(mBlockData instanceof CArray) {
-						meta.setBlockData(blockData((CArray) mBlockData, mat, t));
+					Mixed mBlockData = ma.get("blockdata", t, env);
+					if(mBlockData instanceof CArray cArray) {
+						meta.setBlockData(blockData(cArray, mat, t, env));
 					}
 				}
 
 				// Specific ItemMeta
-				if(meta instanceof MCBlockStateMeta) {
-					MCBlockStateMeta bsm = (MCBlockStateMeta) meta;
+				if(meta instanceof MCBlockStateMeta bsm) {
 					MCBlockState bs = bsm.getBlockState();
-					if(bs instanceof MCBanner) {
-						MCBanner banner = (MCBanner) bs;
+					if(bs instanceof MCBanner banner) {
 						if(ma.containsKey("basecolor")) {
-							String baseString = ma.get("basecolor", t).val().toUpperCase();
+							String baseString = ma.get("basecolor", t, env).val().toUpperCase();
 							try {
 								banner.setBaseColor(MCDyeColor.valueOf(baseString));
-							} catch (IllegalArgumentException ex) {
+							} catch(IllegalArgumentException ex) {
 								if(baseString.equals("SILVER")) {
 									// convert old DyeColor
 									banner.setBaseColor(MCDyeColor.LIGHT_GRAY);
@@ -1335,15 +1383,15 @@ public MCItemMeta itemMeta(Mixed c, MCMaterial mat, Target t) throws ConfigRunti
 								}
 							}
 							if(ma.containsKey("patterns")) {
-								CArray array = ArgumentValidation.getArray(ma.get("patterns", t), t);
+								CArray array = ArgumentValidation.getArray(ma.get("patterns", t, env), t, env);
 								for(String key : array.stringKeySet()) {
-									CArray pattern = ArgumentValidation.getArray(array.get(key, t), t);
-									MCPatternShape shape = MCPatternShape.valueOf(pattern.get("shape", t).val().toUpperCase());
-									String color = pattern.get("color", t).val().toUpperCase();
+									CArray pattern = ArgumentValidation.getArray(array.get(key, t, env), t, env);
+									MCPatternShape shape = MCPatternShape.valueOf(pattern.get("shape", t, env).val().toUpperCase());
+									String color = pattern.get("color", t, env).val().toUpperCase();
 									try {
 										MCDyeColor dyecolor = MCDyeColor.valueOf(color);
 										banner.addPattern(StaticLayer.GetConvertor().GetPattern(dyecolor, shape));
-									} catch (IllegalArgumentException ex) {
+									} catch(IllegalArgumentException ex) {
 										if(color.equals("SILVER")) {
 											// convert old DyeColor
 											banner.addPattern(StaticLayer.GetConvertor().GetPattern(MCDyeColor.LIGHT_GRAY, shape));
@@ -1355,105 +1403,102 @@ public MCItemMeta itemMeta(Mixed c, MCMaterial mat, Target t) throws ConfigRunti
 							}
 							bsm.setBlockState(banner);
 						}
-					} else if(bs instanceof MCCreatureSpawner) {
-						MCCreatureSpawner mccs = (MCCreatureSpawner) bs;
+					} else if(bs instanceof MCCreatureSpawner mccs) {
 						if(ma.containsKey("spawntype")) {
-							Mixed m = ma.get("spawntype", t);
+							Mixed m = ma.get("spawntype", t, env);
 							if(m != CNull.NULL) {
 								MCEntityType type = MCEntityType.valueOf(m.val().toUpperCase());
 								mccs.setSpawnedType(type);
 							}
 						}
 						if(ma.containsKey("delay")) {
-							int delay = ArgumentValidation.getInt32(ma.get("delay", t), t);
+							int delay = ArgumentValidation.getInt32(ma.get("delay", t, env), t, env);
 							mccs.setDelay(delay);
 						}
 						if(ma.containsKey("mindelay")) {
-							int delay = ArgumentValidation.getInt32(ma.get("mindelay", t), t);
+							int delay = ArgumentValidation.getInt32(ma.get("mindelay", t, env), t, env);
 							mccs.setMinDelay(delay);
 						}
 						if(ma.containsKey("maxdelay")) {
-							int delay = ArgumentValidation.getInt32(ma.get("maxdelay", t), t);
+							int delay = ArgumentValidation.getInt32(ma.get("maxdelay", t, env), t, env);
 							mccs.setMaxDelay(delay);
 						}
 						if(ma.containsKey("spawncount")) {
-							int count = ArgumentValidation.getInt32(ma.get("spawncount", t), t);
+							int count = ArgumentValidation.getInt32(ma.get("spawncount", t, env), t, env);
 							mccs.setSpawnCount(count);
 						}
 						if(ma.containsKey("maxnearbyentities")) {
-							int max = ArgumentValidation.getInt32(ma.get("maxnearbyentities", t), t);
+							int max = ArgumentValidation.getInt32(ma.get("maxnearbyentities", t, env), t, env);
 							mccs.setMaxNearbyEntities(max);
 						}
 						if(ma.containsKey("spawnrange")) {
-							int range = ArgumentValidation.getInt32(ma.get("spawnrange", t), t);
+							int range = ArgumentValidation.getInt32(ma.get("spawnrange", t, env), t, env);
 							mccs.setSpawnRange(range);
 						}
 						if(ma.containsKey("playerrange")) {
-							int range = ArgumentValidation.getInt32(ma.get("playerrange", t), t);
+							int range = ArgumentValidation.getInt32(ma.get("playerrange", t, env), t, env);
 							mccs.setPlayerRange(range);
 						}
 						bsm.setBlockState(bs);
-					} else if(bs instanceof MCBrewingStand) {
-						MCBrewingStand brewStand = (MCBrewingStand) bs;
+					} else if(bs instanceof MCBrewingStand brewStand) {
 						if(ma.containsKey("brewtime")) {
-							brewStand.setBrewingTime(ArgumentValidation.getInt32(ma.get("brewtime", t), t));
+							brewStand.setBrewingTime(ArgumentValidation.getInt32(ma.get("brewtime", t, env), t, env));
 						}
 						if(ma.containsKey("fuel")) {
-							brewStand.setFuelLevel(ArgumentValidation.getInt32(ma.get("fuel", t), t));
+							brewStand.setFuelLevel(ArgumentValidation.getInt32(ma.get("fuel", t, env), t, env));
 						}
 						if(ma.containsKey("inventory")) {
-							CArray invData = ArgumentValidation.getArray(ma.get("inventory", t), t);
+							CArray invData = ArgumentValidation.getArray(ma.get("inventory", t, env), t, env);
 							MCBrewerInventory inv = brewStand.getInventory();
 							if(invData.containsKey("fuel")) {
-								inv.setFuel(ObjectGenerator.GetGenerator().item(invData.get("fuel", t), t));
+								inv.setFuel(ObjectGenerator.GetGenerator().item(invData.get("fuel", t, env), t, env));
 							}
 							if(invData.containsKey("ingredient")) {
-								inv.setIngredient(ObjectGenerator.GetGenerator().item(invData.get("ingredient", t), t));
+								inv.setIngredient(ObjectGenerator.GetGenerator().item(invData.get("ingredient", t, env), t, env));
 							}
 							if(invData.containsKey("leftbottle")) {
-								inv.setLeftBottle(ObjectGenerator.GetGenerator().item(invData.get("leftbottle", t), t));
+								inv.setLeftBottle(ObjectGenerator.GetGenerator().item(invData.get("leftbottle", t, env), t, env));
 							}
 							if(invData.containsKey("middlebottle")) {
-								inv.setMiddleBottle(ObjectGenerator.GetGenerator().item(invData.get("middlebottle", t), t));
+								inv.setMiddleBottle(ObjectGenerator.GetGenerator().item(invData.get("middlebottle", t, env), t, env));
 							}
 							if(invData.containsKey("rightbottle")) {
-								inv.setRightBottle(ObjectGenerator.GetGenerator().item(invData.get("rightbottle", t), t));
+								inv.setRightBottle(ObjectGenerator.GetGenerator().item(invData.get("rightbottle", t, env), t, env));
 							}
 						}
 						bsm.setBlockState(bs);
-					} else if(bs instanceof MCFurnace) {
-						MCFurnace furnace = (MCFurnace) bs;
+					} else if(bs instanceof MCFurnace furnace) {
 						if(ma.containsKey("burntime")) {
-							furnace.setBurnTime(ArgumentValidation.getInt16(ma.get("burntime", t), t));
+							furnace.setBurnTime(ArgumentValidation.getInt16(ma.get("burntime", t, env), t, env));
 						}
 						if(ma.containsKey("cooktime")) {
-							furnace.setCookTime(ArgumentValidation.getInt16(ma.get("cooktime", t), t));
+							furnace.setCookTime(ArgumentValidation.getInt16(ma.get("cooktime", t, env), t, env));
 						}
 						if(ma.containsKey("inventory")) {
-							CArray invData = ArgumentValidation.getArray(ma.get("inventory", t), t);
+							CArray invData = ArgumentValidation.getArray(ma.get("inventory", t, env), t, env);
 							MCFurnaceInventory inv = furnace.getInventory();
 							if(invData.containsKey("result")) {
-								inv.setResult(ObjectGenerator.GetGenerator().item(invData.get("result", t), t));
+								inv.setResult(ObjectGenerator.GetGenerator().item(invData.get("result", t, env), t, env));
 							}
 							if(invData.containsKey("fuel")) {
-								inv.setFuel(ObjectGenerator.GetGenerator().item(invData.get("fuel", t), t));
+								inv.setFuel(ObjectGenerator.GetGenerator().item(invData.get("fuel", t, env), t, env));
 							}
 							if(invData.containsKey("smelting")) {
-								inv.setSmelting(ObjectGenerator.GetGenerator().item(invData.get("smelting", t), t));
+								inv.setSmelting(ObjectGenerator.GetGenerator().item(invData.get("smelting", t, env), t, env));
 							}
 						}
 						bsm.setBlockState(bs);
 					} else if(bs instanceof MCDecoratedPot decoratedPot) {
 						if(ma.containsKey("sherds")) {
-							Mixed sherds = ma.get("sherds", t);
-							if(sherds.isInstanceOf(CArray.TYPE)) {
+							Mixed sherds = ma.get("sherds", t, env);
+							if(sherds.isInstanceOf(CArray.TYPE, null, env)) {
 								CArray sherdArray = (CArray) sherds;
 								if(!sherdArray.isAssociative()) {
 									throw new CREFormatException("Expected associative array for decorated pot meta.", t);
 								}
 								for(String key : sherdArray.stringKeySet()) {
 									decoratedPot.setSherd(MCDecoratedPot.Side.valueOf(key.toUpperCase()),
-											MCMaterial.valueOf(sherdArray.get(key, t).val()));
+											MCMaterial.valueOf(sherdArray.get(key, t, env).val()));
 								}
 							} else {
 								throw new CREFormatException("Expected associative array for decorated pot meta.", t);
@@ -1461,16 +1506,16 @@ public MCItemMeta itemMeta(Mixed c, MCMaterial mat, Target t) throws ConfigRunti
 						}
 						if(Static.getServer().getMinecraftVersion().gte(MCVersion.MC1_20_4)) {
 							if(ma.containsKey("item")) {
-								decoratedPot.setItemStack(item(ma.get("item", t), t));
+								decoratedPot.setItemStack(item(ma.get("item", t, env), t, env));
 							}
 						}
 						bsm.setBlockState(bs);
-					} else if(bs instanceof MCInventoryHolder) {
+					} else if(bs instanceof MCInventoryHolder mCInventoryHolder) {
 						// Finally, handle InventoryHolders with inventory slots that do not have a special meaning.
 						if(ma.containsKey("inventory")) {
-							MCInventory inv = ((MCInventoryHolder) bs).getInventory();
-							Mixed cInvRaw = ma.get("inventory", t);
-							if(cInvRaw.isInstanceOf(CArray.TYPE)) {
+							MCInventory inv = mCInventoryHolder.getInventory();
+							Mixed cInvRaw = ma.get("inventory", t, env);
+							if(cInvRaw.isInstanceOf(CArray.TYPE, null, env)) {
 								CArray cinv = (CArray) cInvRaw;
 								for(String key : cinv.stringKeySet()) {
 									try {
@@ -1480,8 +1525,8 @@ public MCItemMeta itemMeta(Mixed c, MCMaterial mat, Target t) throws ConfigRunti
 													+ " in " + bs.getClass().getSimpleName().replaceFirst("MC", "")
 													+ " inventory array, so ignoring.");
 										}
-										inv.setItem(index, ObjectGenerator.GetGenerator().item(cinv.get(key, t), t));
-									} catch (NumberFormatException ex) {
+										inv.setItem(index, ObjectGenerator.GetGenerator().item(cinv.get(key, t, env), t, env));
+									} catch(NumberFormatException ex) {
 										ConfigRuntimeException.DoWarning("Expecting integer value for key in "
 												+ bs.getClass().getSimpleName().replaceFirst("MC", "")
 												+ " inventory array, but \"" + key + "\" was found. Ignoring.");
@@ -1495,24 +1540,24 @@ public MCItemMeta itemMeta(Mixed c, MCMaterial mat, Target t) throws ConfigRunti
 						}
 					} else if(bs instanceof MCSign sign) {
 						if(ma.containsKey("waxed")) {
-							sign.setWaxed(ArgumentValidation.getBooleanObject(ma.get("waxed", t), t));
+							sign.setWaxed(ArgumentValidation.getBooleanObject(ma.get("waxed", t, env), t, env));
 						}
 						if(ma.containsKey("signtext")) {
-							Mixed possibleLines = ma.get("signtext", t);
-							if(possibleLines.isInstanceOf(CArray.TYPE)) {
+							Mixed possibleLines = ma.get("signtext", t, env);
+							if(possibleLines.isInstanceOf(CArray.TYPE, null, env)) {
 								CArray lines = (CArray) possibleLines;
-								for(int i = 0; i < lines.size(); i++) {
-									sign.setLine(i, lines.get(i, t).val());
+								for(int i = 0; i < lines.size(env); i++) {
+									sign.setLine(i, lines.get(i, t, env).val());
 								}
 							} else {
 								throw new CREFormatException("Expected array for sign text", t);
 							}
 						}
 						if(ma.containsKey("glowing")) {
-							sign.setGlowingText(ArgumentValidation.getBooleanObject(ma.get("glowing", t), t));
+							sign.setGlowingText(ArgumentValidation.getBooleanObject(ma.get("glowing", t, env), t, env));
 						}
 						if(ma.containsKey("color")) {
-							Mixed dye = ma.get("color", t);
+							Mixed dye = ma.get("color", t, env);
 							if(!(dye instanceof CNull)) {
 								sign.setDyeColor(MCDyeColor.valueOf(dye.val()));
 							}
@@ -1520,21 +1565,21 @@ public MCItemMeta itemMeta(Mixed c, MCMaterial mat, Target t) throws ConfigRunti
 						MCSignText backText = sign.getBackText();
 						if(backText != null) {
 							if(ma.containsKey("backtext")) {
-								Mixed possibleLines = ma.get("backtext", t);
-								if(possibleLines.isInstanceOf(CArray.TYPE)) {
+								Mixed possibleLines = ma.get("backtext", t, env);
+								if(possibleLines.isInstanceOf(CArray.TYPE, null, env)) {
 									CArray lines = (CArray) possibleLines;
-									for(int i = 0; i < lines.size(); i++) {
-										backText.setLine(i, lines.get(i, t).val());
+									for(int i = 0; i < lines.size(env); i++) {
+										backText.setLine(i, lines.get(i, t, env).val());
 									}
 								} else {
 									throw new CREFormatException("Expected array for sign back text", t);
 								}
 							}
 							if(ma.containsKey("backglowing")) {
-								backText.setGlowingText(ArgumentValidation.getBooleanObject(ma.get("backglowing", t), t));
+								backText.setGlowingText(ArgumentValidation.getBooleanObject(ma.get("backglowing", t, env), t, env));
 							}
 							if(ma.containsKey("backcolor")) {
-								Mixed dye = ma.get("backcolor", t);
+								Mixed dye = ma.get("backcolor", t, env);
 								if(!(dye instanceof CNull)) {
 									backText.setDyeColor(MCDyeColor.valueOf(dye.val()));
 								}
@@ -1543,75 +1588,73 @@ public MCItemMeta itemMeta(Mixed c, MCMaterial mat, Target t) throws ConfigRunti
 						bsm.setBlockState(bs);
 					} else if(bs instanceof MCCommandBlock cmdBlock) {
 						if(ma.containsKey("command")) {
-							cmdBlock.setCommand(ma.get("command", t).val());
+							cmdBlock.setCommand(ma.get("command", t, env).val());
 						}
 						if(ma.containsKey("customname")) {
-							cmdBlock.setName(ma.get("customname", t).val());
+							cmdBlock.setName(ma.get("customname", t, env).val());
 						}
 						bsm.setBlockState(bs);
 					} else if(bs instanceof MCBeehive beehive
 							&& Static.getServer().getMinecraftVersion().gte(MCVersion.MC1_20_6)) {
 						if(ma.containsKey("beecount")) {
-							int beeCount = ArgumentValidation.getInt32(ma.get("beecount", t), t);
+							int beeCount = ArgumentValidation.getInt32(ma.get("beecount", t, env), t, env);
 							beehive.addBees(beeCount);
 						}
 						bsm.setBlockState(bs);
 					}
 				} else if(meta instanceof MCArmorMeta armorMeta) { // Must be before MCLeatherArmorMeta
 					if(ma.containsKey("trim")) {
-						Mixed mtrim = ma.get("trim", t);
+						Mixed mtrim = ma.get("trim", t, env);
 						if(mtrim instanceof CNull) {
 							// nothing
-						} else if(mtrim.isInstanceOf(CArray.TYPE)) {
+						} else if(mtrim.isInstanceOf(CArray.TYPE, null, env)) {
 							CArray trim = (CArray) mtrim;
 							if(!trim.isAssociative()) {
 								throw new CREFormatException("Expected associative array for armor trim meta.", t);
 							}
-							MCTrimPattern pattern = MCTrimPattern.valueOf(trim.get("pattern", t).val());
-							MCTrimMaterial material = MCTrimMaterial.valueOf(trim.get("material", t).val());
+							MCTrimPattern pattern = MCTrimPattern.valueOf(trim.get("pattern", t, env).val());
+							MCTrimMaterial material = MCTrimMaterial.valueOf(trim.get("material", t, env).val());
 							armorMeta.setTrim(pattern, material);
 						} else {
 							throw new CREFormatException("Expected an array or null for armor trim meta.", t);
 						}
 					}
-					if(armorMeta instanceof MCColorableArmorMeta) {
+					if(armorMeta instanceof MCColorableArmorMeta mCColorableArmorMeta) {
 						if(ma.containsKey("color")) {
-							Mixed ci = ma.get("color", t);
+							Mixed ci = ma.get("color", t, env);
 							if(ci instanceof CNull) {
 								//nothing
-							} else if(ci.isInstanceOf(CArray.TYPE)) {
-								((MCColorableArmorMeta) armorMeta).setColor(color((CArray) ci, t));
+							} else if(ci.isInstanceOf(CArray.TYPE, null, env)) {
+								mCColorableArmorMeta.setColor(color((CArray) ci, t, env));
 							} else {
 								throw new CREFormatException("Color was expected to be an array.", t);
 							}
 						}
 					}
-				} else if(meta instanceof MCFireworkEffectMeta) {
-					MCFireworkEffectMeta femeta = (MCFireworkEffectMeta) meta;
+				} else if(meta instanceof MCFireworkEffectMeta femeta) {
 					if(ma.containsKey("effect")) {
-						Mixed cfem = ma.get("effect", t);
-						if(cfem.isInstanceOf(CArray.TYPE)) {
-							femeta.setEffect(fireworkEffect((CArray) cfem, t));
+						Mixed cfem = ma.get("effect", t, env);
+						if(cfem.isInstanceOf(CArray.TYPE, null, env)) {
+							femeta.setEffect(fireworkEffect((CArray) cfem, t, env));
 						} else if(!(cfem instanceof CNull)) {
 							throw new CREFormatException("FireworkCharge effect was expected to be an array or null.", t);
 						}
 					}
-				} else if(meta instanceof MCFireworkMeta) {
-					MCFireworkMeta fmeta = (MCFireworkMeta) meta;
+				} else if(meta instanceof MCFireworkMeta fmeta) {
 					if(ma.containsKey("firework")) {
-						Mixed construct = ma.get("firework", t);
-						if(construct.isInstanceOf(CArray.TYPE)) {
+						Mixed construct = ma.get("firework", t, env);
+						if(construct.isInstanceOf(CArray.TYPE, null, env)) {
 							CArray firework = (CArray) construct;
 							if(firework.containsKey("strength")) {
-								fmeta.setStrength(ArgumentValidation.getInt32(firework.get("strength", t), t));
+								fmeta.setStrength(ArgumentValidation.getInt32(firework.get("strength", t, env), t, env));
 							}
 							if(firework.containsKey("effects")) {
 								// New style (supports multiple effects)
-								Mixed effects = firework.get("effects", t);
-								if(effects.isInstanceOf(CArray.TYPE)) {
-									for(Mixed effect : ((CArray) effects).asList()) {
-										if(effect.isInstanceOf(CArray.TYPE)) {
-											fmeta.addEffect(fireworkEffect((CArray) effect, t));
+								Mixed effects = firework.get("effects", t, env);
+								if(effects.isInstanceOf(CArray.TYPE, null, env)) {
+									for(Mixed effect : ((CArray) effects).asList(env)) {
+										if(effect.isInstanceOf(CArray.TYPE, null, env)) {
+											fmeta.addEffect(fireworkEffect((CArray) effect, t, env));
 										} else {
 											throw new CREFormatException("Firework effect was expected to be an array.", t);
 										}
@@ -1621,19 +1664,19 @@ public MCItemMeta itemMeta(Mixed c, MCMaterial mat, Target t) throws ConfigRunti
 								}
 							} else {
 								// Old style (supports only one effect)
-								fmeta.addEffect(fireworkEffect(firework, t));
+								fmeta.addEffect(fireworkEffect(firework, t, env));
 							}
 						} else {
 							throw new CREFormatException("Firework was expected to be an array.", t);
 						}
 					}
-				} else if(meta instanceof MCLeatherArmorMeta) {
+				} else if(meta instanceof MCLeatherArmorMeta mCLeatherArmorMeta) {
 					if(ma.containsKey("color")) {
-						Mixed ci = ma.get("color", t);
+						Mixed ci = ma.get("color", t, env);
 						if(ci instanceof CNull) {
 							//nothing
-						} else if(ci.isInstanceOf(CArray.TYPE)) {
-							((MCLeatherArmorMeta) meta).setColor(color((CArray) ci, t));
+						} else if(ci.isInstanceOf(CArray.TYPE, null, env)) {
+							mCLeatherArmorMeta.setColor(color((CArray) ci, t, env));
 						} else {
 							throw new CREFormatException("Color was expected to be an array.", t);
 						}
@@ -1644,45 +1687,45 @@ public MCItemMeta itemMeta(Mixed c, MCMaterial mat, Target t) throws ConfigRunti
 						bookMeta.setTitle("");
 						bookMeta.setAuthor("");
 						if(ma.containsKey("title")) {
-							Mixed title = ma.get("title", t);
+							Mixed title = ma.get("title", t, env);
 							if(!(title instanceof CNull)) {
 								bookMeta.setTitle(title.val());
 							}
 						}
 						if(ma.containsKey("author")) {
-							Mixed author = ma.get("author", t);
+							Mixed author = ma.get("author", t, env);
 							if(!(author instanceof CNull)) {
 								bookMeta.setAuthor(author.val());
 							}
 						}
 						if(ma.containsKey("generation")) {
-							Mixed generation = ma.get("generation", t);
+							Mixed generation = ma.get("generation", t, env);
 							bookMeta.setGeneration(MCBookMeta.Generation.valueOf(generation.val()));
 						}
 					}
 					if(ma.containsKey("pages")) {
-						Mixed pages = ma.get("pages", t);
+						Mixed pages = ma.get("pages", t, env);
 						if(pages instanceof CNull) {
 							//nothing
-						} else if(pages.isInstanceOf(CArray.TYPE)) {
+						} else if(pages.isInstanceOf(CArray.TYPE, null, env)) {
 							CArray pa = (CArray) pages;
 							List<String> pl = new ArrayList<>();
-							for(int j = 0; j < pa.size(); j++) {
-								pl.add(pa.get(j, t).val());
+							for(int j = 0; j < pa.size(env); j++) {
+								pl.add(pa.get(j, t, env).val());
 							}
 							bookMeta.setPages(pl);
 						} else {
 							throw new CREFormatException("Pages field was expected to be an array.", t);
 						}
 					}
-				} else if(meta instanceof MCSkullMeta) {
+				} else if(meta instanceof MCSkullMeta mCSkullMeta) {
 					String name = null;
 					UUID id = null;
 					if(ma.containsKey("owner")) {
-						name = Construct.nval(ma.get("owner", t));
+						name = Construct.nval(ma.get("owner", t, env));
 					}
 					if(ma.containsKey("owneruuid")) {
-						Mixed uuid = ma.get("owneruuid", t);
+						Mixed uuid = ma.get("owneruuid", t, env);
 						if(uuid instanceof CString) {
 							id = Static.GetUUID(uuid, t);
 						}
@@ -1691,12 +1734,12 @@ public MCItemMeta itemMeta(Mixed c, MCMaterial mat, Target t) throws ConfigRunti
 						MCPlayerProfile profile = Static.getServer().getPlayerProfile(id, name);
 						if(profile != null) {
 							if(ma.containsKey("texture")) {
-								Mixed texture = ma.get("texture", t);
+								Mixed texture = ma.get("texture", t, env);
 								if(texture instanceof CString) {
 									profile.setProperty(new MCProfileProperty("textures", texture.val(), null));
 								}
 							}
-							((MCSkullMeta) meta).setProfile(profile);
+							mCSkullMeta.setProfile(profile);
 						} else {
 							// No profile, but we might still be able to set the owner.
 							MCOfflinePlayer ofp = null;
@@ -1704,40 +1747,40 @@ public MCItemMeta itemMeta(Mixed c, MCMaterial mat, Target t) throws ConfigRunti
 								ofp = Static.getServer().getOfflinePlayer(id);
 							}
 							if(ofp != null) {
-								((MCSkullMeta) meta).setOwningPlayer(ofp);
+								mCSkullMeta.setOwningPlayer(ofp);
 							} else if(name != null && !name.isEmpty()) {
 								// No offline player found by UUID, but we can fallback to owner by name.
-								((MCSkullMeta) meta).setOwner(name);
+								mCSkullMeta.setOwner(name);
 							}
 						}
 					}
 					if(Static.getServer().getMinecraftVersion().gte(MCVersion.MC1_19_3)) {
 						if(ma.containsKey("noteblocksound")) {
-							Mixed sound = ma.get("noteblocksound", t);
+							Mixed sound = ma.get("noteblocksound", t, env);
 							if(!(sound instanceof CNull)) {
-								((MCSkullMeta) meta).setNoteBlockSound(sound.val());
+								mCSkullMeta.setNoteBlockSound(sound.val());
 							}
 						}
 					}
-				} else if(meta instanceof MCEnchantmentStorageMeta) {
+				} else if(meta instanceof MCEnchantmentStorageMeta mCEnchantmentStorageMeta) {
 					if(ma.containsKey("stored")) {
-						Mixed stored = ma.get("stored", t);
+						Mixed stored = ma.get("stored", t, env);
 						if(stored instanceof CNull) {
 							//Still doing nothing
-						} else if(stored.isInstanceOf(CArray.TYPE)) {
-							for(Map.Entry<MCEnchantment, Integer> ench : enchants((CArray) stored, t).entrySet()) {
-								((MCEnchantmentStorageMeta) meta).addStoredEnchant(ench.getKey(), ench.getValue(), true);
+						} else if(stored.isInstanceOf(CArray.TYPE, null, env)) {
+							for(Map.Entry<MCEnchantment, Integer> ench : enchants((CArray) stored, t, env).entrySet()) {
+								mCEnchantmentStorageMeta.addStoredEnchant(ench.getKey(), ench.getValue(), true);
 							}
 						} else {
 							throw new CREFormatException("Stored field was expected to be an array of Enchantment arrays", t);
 						}
 					}
-				} else if(meta instanceof MCPotionMeta) {
+				} else if(meta instanceof MCPotionMeta mCPotionMeta) {
 					if(ma.containsKey("potions")) {
-						Mixed effects = ma.get("potions", t);
-						if(effects.isInstanceOf(CArray.TYPE)) {
-							for(MCLivingEntity.MCEffect e : potions((CArray) effects, t)) {
-								((MCPotionMeta) meta).addCustomEffect(e.getPotionEffectType(), e.getStrength(),
+						Mixed effects = ma.get("potions", t, env);
+						if(effects.isInstanceOf(CArray.TYPE, null, env)) {
+							for(MCLivingEntity.MCEffect e : potions((CArray) effects, t, env)) {
+								mCPotionMeta.addCustomEffect(e.getPotionEffectType(), e.getStrength(),
 										e.getTicksRemaining(), e.isAmbient(), e.hasParticles(), e.showIcon(), true, t);
 							}
 						} else {
@@ -1745,156 +1788,155 @@ public MCItemMeta itemMeta(Mixed c, MCMaterial mat, Target t) throws ConfigRunti
 						}
 					}
 					if(ma.containsKey("potiontype") && Static.getServer().getMinecraftVersion().gte(MCVersion.MC1_20_2)) {
-						Mixed potiontype = ma.get("potiontype", t);
+						Mixed potiontype = ma.get("potiontype", t, env);
 						if(!(potiontype instanceof CNull)) {
-							((MCPotionMeta) meta).setBasePotionType(MCPotionType.valueOf(potiontype.val()));
+							mCPotionMeta.setBasePotionType(MCPotionType.valueOf(potiontype.val()));
 						}
 					} else if(ma.containsKey("base")) {
-						Mixed potiondata = ma.get("base", t);
-						if(potiondata.isInstanceOf(CArray.TYPE)) {
+						Mixed potiondata = ma.get("base", t, env);
+						if(potiondata.isInstanceOf(CArray.TYPE, null, env)) {
 							if(Static.getServer().getMinecraftVersion().gte(MCVersion.MC1_20_6)) {
-								((MCPotionMeta) meta).setBasePotionType(legacyPotionData((CArray) potiondata, t));
+								mCPotionMeta.setBasePotionType(legacyPotionData((CArray) potiondata, t, env));
 							} else {
-								((MCPotionMeta) meta).setBasePotionData(potionData((CArray) potiondata, t));
+								mCPotionMeta.setBasePotionData(potionData((CArray) potiondata, t, env));
 							}
 						}
 					}
 					if(ma.containsKey("color")) {
-						Mixed color = ma.get("color", t);
-						if(color.isInstanceOf(CArray.TYPE)) {
-							((MCPotionMeta) meta).setColor(color((CArray) color, t));
-						} else if(color.isInstanceOf(CString.TYPE)) {
-							((MCPotionMeta) meta).setColor(StaticLayer.GetConvertor().GetColor(color.val(), t));
+						Mixed color = ma.get("color", t, env);
+						if(color.isInstanceOf(CArray.TYPE, null, env)) {
+							mCPotionMeta.setColor(color((CArray) color, t, env));
+						} else if(color.isInstanceOf(CString.TYPE, null, env)) {
+							mCPotionMeta.setColor(StaticLayer.GetConvertor().GetColor(color.val(), t));
 						}
 					}
-				} else if(meta instanceof MCSuspiciousStewMeta) {
+				} else if(meta instanceof MCSuspiciousStewMeta mCSuspiciousStewMeta) {
 					if(ma.containsKey("potions")) {
-						Mixed effects = ma.get("potions", t);
-						if(effects.isInstanceOf(CArray.TYPE)) {
-							for(MCLivingEntity.MCEffect e : potions((CArray) effects, t)) {
-								((MCSuspiciousStewMeta) meta).addCustomEffect(e.getPotionEffectType(), e.getStrength(),
+						Mixed effects = ma.get("potions", t, env);
+						if(effects.isInstanceOf(CArray.TYPE, null, env)) {
+							for(MCLivingEntity.MCEffect e : potions((CArray) effects, t, env)) {
+								mCSuspiciousStewMeta.addCustomEffect(e.getPotionEffectType(), e.getStrength(),
 										e.getTicksRemaining(), e.isAmbient(), e.hasParticles(), e.showIcon(), true, t);
 							}
 						} else {
 							throw new CREFormatException("Expected an array of potion arrays.", t);
 						}
 					}
-				} else if(meta instanceof MCBannerMeta) {
+				} else if(meta instanceof MCBannerMeta mCBannerMeta) {
 					if(ma.containsKey("patterns")) {
-						CArray array = ArgumentValidation.getArray(ma.get("patterns", t), t);
+						CArray array = ArgumentValidation.getArray(ma.get("patterns", t, env), t, env);
 						for(String key : array.stringKeySet()) {
-							CArray pattern = ArgumentValidation.getArray(array.get(key, t), t);
-							MCPatternShape shape = MCPatternShape.valueOf(pattern.get("shape", t).val().toUpperCase());
-							String color = pattern.get("color", t).val().toUpperCase();
+							CArray pattern = ArgumentValidation.getArray(array.get(key, t, env), t, env);
+							MCPatternShape shape = MCPatternShape.valueOf(pattern.get("shape", t, env).val().toUpperCase());
+							String color = pattern.get("color", t, env).val().toUpperCase();
 							try {
 								MCDyeColor dyecolor = MCDyeColor.valueOf(color);
-								((MCBannerMeta) meta).addPattern(StaticLayer.GetConvertor().GetPattern(dyecolor, shape));
-							} catch (IllegalArgumentException ex) {
+								mCBannerMeta.addPattern(StaticLayer.GetConvertor().GetPattern(dyecolor, shape));
+							} catch(IllegalArgumentException ex) {
 								if(color.equals("SILVER")) {
 									// convert old DyeColor
-									((MCBannerMeta) meta).addPattern(StaticLayer.GetConvertor().GetPattern(MCDyeColor.LIGHT_GRAY, shape));
+									mCBannerMeta.addPattern(StaticLayer.GetConvertor().GetPattern(MCDyeColor.LIGHT_GRAY, shape));
 								} else {
 									throw ex;
 								}
 							}
 						}
 					}
-				} else if(meta instanceof MCMapMeta) {
+				} else if(meta instanceof MCMapMeta mCMapMeta) {
 					if(ma.containsKey("color")) {
-						Mixed ci = ma.get("color", t);
-						if(ci.isInstanceOf(CArray.TYPE)) {
-							((MCMapMeta) meta).setColor(color((CArray) ci, t));
+						Mixed ci = ma.get("color", t, env);
+						if(ci.isInstanceOf(CArray.TYPE, null, env)) {
+							mCMapMeta.setColor(color((CArray) ci, t, env));
 						} else if(!(ci instanceof CNull)) {
 							throw new CREFormatException("Color was expected to be an array.", t);
 						}
 					}
 					if(ma.containsKey("mapid")) {
-						Mixed cid = ma.get("mapid", t);
+						Mixed cid = ma.get("mapid", t, env);
 						if(!(cid instanceof CNull)) {
-							((MCMapMeta) meta).setMapId(ArgumentValidation.getInt32(cid, t));
+							mCMapMeta.setMapId(ArgumentValidation.getInt32(cid, t, env));
 						}
 					}
-				} else if(meta instanceof MCTropicalFishBucketMeta) {
+				} else if(meta instanceof MCTropicalFishBucketMeta mCTropicalFishBucketMeta) {
 					if(ma.containsKey("fishpatterncolor")) {
-						Mixed patterncolor = ma.get("fishpatterncolor", t);
+						Mixed patterncolor = ma.get("fishpatterncolor", t, env);
 						if(!(patterncolor instanceof CNull)) {
 							MCDyeColor color = MCDyeColor.valueOf(patterncolor.val().toUpperCase());
-							((MCTropicalFishBucketMeta) meta).setPatternColor(color);
+							mCTropicalFishBucketMeta.setPatternColor(color);
 						}
 					}
 					if(ma.containsKey("fishcolor")) {
-						Mixed fishcolor = ma.get("fishcolor", t);
+						Mixed fishcolor = ma.get("fishcolor", t, env);
 						if(!(fishcolor instanceof CNull)) {
 							MCDyeColor color = MCDyeColor.valueOf(fishcolor.val().toUpperCase());
-							((MCTropicalFishBucketMeta) meta).setBodyColor(color);
+							mCTropicalFishBucketMeta.setBodyColor(color);
 						}
 					}
 					if(ma.containsKey("fishpattern")) {
-						Mixed pa = ma.get("fishpattern", t);
+						Mixed pa = ma.get("fishpattern", t, env);
 						if(!(pa instanceof CNull)) {
 							MCTropicalFish.MCPattern pattern = MCTropicalFish.MCPattern.valueOf(pa.val().toUpperCase());
-							((MCTropicalFishBucketMeta) meta).setPattern(pattern);
+							mCTropicalFishBucketMeta.setPattern(pattern);
 						}
 					}
-				} else if(meta instanceof MCCrossbowMeta) {
+				} else if(meta instanceof MCCrossbowMeta mCCrossbowMeta) {
 					if(ma.containsKey("projectiles")) {
-						Mixed value = ma.get("projectiles", t);
+						Mixed value = ma.get("projectiles", t, env);
 						if(!(value instanceof CNull)) {
 							List<MCItemStack> projectiles = new ArrayList<>();
-							for(Mixed m : ArgumentValidation.getArray(value, t).asList()) {
-								projectiles.add(item(m, t));
+							for(Mixed m : ArgumentValidation.getArray(value, t, env).asList(env)) {
+								projectiles.add(item(m, t, env));
 							}
-							((MCCrossbowMeta) meta).setChargedProjectiles(projectiles);
+							mCCrossbowMeta.setChargedProjectiles(projectiles);
 						}
 					}
-				} else if(meta instanceof MCCompassMeta) {
+				} else if(meta instanceof MCCompassMeta mCCompassMeta) {
 					if(ma.containsKey("target")) {
-						Mixed loc = ma.get("target", t);
+						Mixed loc = ma.get("target", t, env);
 						if(!(loc instanceof CNull)) {
-							((MCCompassMeta) meta).setTargetLocation(location(loc, null, t));
+							mCCompassMeta.setTargetLocation(location(loc, null, t, env));
 						}
 					}
 					if(ma.containsKey("lodestone")) {
-						((MCCompassMeta) meta).setLodestoneTracked(
-								ArgumentValidation.getBooleanObject(ma.get("lodestone", t), t));
+						mCCompassMeta.setLodestoneTracked(
+								ArgumentValidation.getBooleanObject(ma.get("lodestone", t, env), t, env));
 					}
-				} else if(meta instanceof MCBundleMeta) {
+				} else if(meta instanceof MCBundleMeta mCBundleMeta) {
 					if(ma.containsKey("items")) {
-						Mixed value = ma.get("items", t);
-						if(value instanceof CArray) {
-							MCBundleMeta bm = (MCBundleMeta) meta;
-							CArray items = (CArray) value;
+						Mixed value = ma.get("items", t, env);
+						if(value instanceof CArray cArray) {
+							CArray items = cArray;
 							for(String key : items.stringKeySet()) {
-								Mixed entry = items.get(key, t);
+								Mixed entry = items.get(key, t, env);
 								if(!(entry instanceof CNull)) {
-									bm.addItem(ObjectGenerator.GetGenerator().item(entry, t));
+									mCBundleMeta.addItem(ObjectGenerator.GetGenerator().item(entry, t, env));
 								}
 							}
 						} else if(!(value instanceof CNull)) {
 							throw new CREFormatException("Items was expected to be an array or null.", t);
 						}
 					}
-				} else if(meta instanceof MCAxolotlBucketMeta) {
+				} else if(meta instanceof MCAxolotlBucketMeta mCAxolotlBucketMeta) {
 					if(ma.containsKey("variant")) {
-						Mixed value = ma.get("variant", t);
+						Mixed value = ma.get("variant", t, env);
 						if(!(value instanceof CNull)) {
-							((MCAxolotlBucketMeta) meta).setAxolotlType(MCAxolotlType.valueOf(value.val().toUpperCase()));
+							mCAxolotlBucketMeta.setAxolotlType(MCAxolotlType.valueOf(value.val().toUpperCase()));
 						}
 					}
-				} else if(meta instanceof MCMusicInstrumentMeta) {
+				} else if(meta instanceof MCMusicInstrumentMeta mCMusicInstrumentMeta) {
 					if(ma.containsKey("instrument")) {
-						Mixed value = ma.get("instrument", t);
+						Mixed value = ma.get("instrument", t, env);
 						if(!(value instanceof CNull)) {
-							((MCMusicInstrumentMeta) meta).setInstrument(value.val());
+							mCMusicInstrumentMeta.setInstrument(value.val());
 						}
 					}
 				} else if(meta instanceof MCKnowledgeBookMeta knowledgeBookMeta) {
 					if(ma.containsKey("recipes")) {
-						Mixed value = ma.get("recipes", t);
-						if(value.isInstanceOf(CArray.TYPE)) {
+						Mixed value = ma.get("recipes", t, env);
+						if(value.isInstanceOf(CArray.TYPE, null, env)) {
 							CArray array = ((CArray) value);
-							List<MCNamespacedKey> keys = new ArrayList<>((int) array.size());
-							for(Mixed entry : ((CArray) value).asList()) {
+							List<MCNamespacedKey> keys = new ArrayList<>((int) array.size(env));
+							for(Mixed entry : ((CArray) value).asList(env)) {
 								keys.add(StaticLayer.GetConvertor().GetNamespacedKey(entry.val()));
 							}
 							knowledgeBookMeta.setRecipes(keys);
@@ -1902,15 +1944,15 @@ public MCItemMeta itemMeta(Mixed c, MCMaterial mat, Target t) throws ConfigRunti
 							throw new CREFormatException("Expected array or null for recipes but got " + value.val(), t);
 						}
 					}
-				} else if(meta instanceof MCOminousBottleMeta) {
+				} else if(meta instanceof MCOminousBottleMeta mCOminousBottleMeta) {
 					if(ma.containsKey("ominousamplifier")) {
-						Mixed value = ma.get("ominousamplifier", t);
+						Mixed value = ma.get("ominousamplifier", t, env);
 						if(!(value instanceof CNull)) {
-							((MCOminousBottleMeta) meta).setAmplifier(ArgumentValidation.getInt32(value, t));
+							mCOminousBottleMeta.setAmplifier(ArgumentValidation.getInt32(value, t, env));
 						}
 					}
 				}
-			} catch (Exception ex) {
+			} catch(Exception ex) {
 				throw new CREFormatException(ex.getMessage(), t, ex);
 			}
 			return meta;
@@ -1934,82 +1976,99 @@ public AbstractCREException exception(CArray exception, Target t, Environment en
 	 * @return
 	 */
 	public CArray color(MCColor color, Target t) {
-		CArray ca = CArray.GetAssociativeArray(t);
-		ca.set("r", new CInt(color.getRed(), t), t);
-		ca.set("g", new CInt(color.getGreen(), t), t);
-		ca.set("b", new CInt(color.getBlue(), t), t);
+		CArray ca = CArray.GetAssociativeArray(t, null, null);
+		ca.set("r", new CInt(color.getRed(), t), t, null);
+		ca.set("g", new CInt(color.getGreen(), t), t, null);
+		ca.set("b", new CInt(color.getBlue(), t), t, null);
 		return ca;
 	}
 
 	/**
 	 * Returns an MCColor given a colorArray, which supports the following three format recipeTypes (in this order of
-	 * priority) array(r: 0, g: 0, b: 0) array(red: 0, green: 0, blue: 0) array(0, 0, 0).
-	 * Optionally accepts an alpha channel for the keys: 'a', 'alpha', and 3 respectively.
+	 * priority) array(r: 0, g: 0, b: 0) array(red: 0, green: 0, blue: 0) array(0, 0, 0). Optionally accepts an alpha
+	 * channel for the keys: 'a', 'alpha', and 3 respectively.
 	 *
 	 * @param color
 	 * @param t
 	 * @return
+	 * @deprecated Use {@link #color(CArray, Target, Environment)} instead.
 	 */
+	@Deprecated
 	public MCColor color(CArray color, Target t) {
+		return color(color, t, null);
+	}
+
+	/**
+	 * Returns an MCColor given a colorArray, which supports the following three format recipeTypes (in this order of
+	 * priority) array(r: 0, g: 0, b: 0) array(red: 0, green: 0, blue: 0) array(0, 0, 0). Optionally accepts an alpha
+	 * channel for the keys: 'a', 'alpha', and 3 respectively.
+	 *
+	 * @param color
+	 * @param t
+	 * @param env
+	 * @return
+	 */
+	public MCColor color(CArray color, Target t, Environment env) {
 		int red;
 		int green;
 		int blue;
 		if(color.containsKey("r")) {
-			red = ArgumentValidation.getInt32(color.get("r", t), t);
+			red = ArgumentValidation.getInt32(color.get("r", t, env), t, env);
 		} else if(color.containsKey("red")) {
-			red = ArgumentValidation.getInt32(color.get("red", t), t);
+			red = ArgumentValidation.getInt32(color.get("red", t, env), t, env);
 		} else {
-			red = ArgumentValidation.getInt32(color.get(0, t), t);
+			red = ArgumentValidation.getInt32(color.get(0, t, env), t, env);
 		}
 		if(color.containsKey("g")) {
-			green = ArgumentValidation.getInt32(color.get("g", t), t);
+			green = ArgumentValidation.getInt32(color.get("g", t, env), t, env);
 		} else if(color.containsKey("green")) {
-			green = ArgumentValidation.getInt32(color.get("green", t), t);
+			green = ArgumentValidation.getInt32(color.get("green", t, env), t, env);
 		} else {
-			green = ArgumentValidation.getInt32(color.get(1, t), t);
+			green = ArgumentValidation.getInt32(color.get(1, t, env), t, env);
 		}
 		if(color.containsKey("b")) {
-			blue = ArgumentValidation.getInt32(color.get("b", t), t);
+			blue = ArgumentValidation.getInt32(color.get("b", t, env), t, env);
 		} else if(color.containsKey("blue")) {
-			blue = ArgumentValidation.getInt32(color.get("blue", t), t);
+			blue = ArgumentValidation.getInt32(color.get("blue", t, env), t, env);
 		} else {
-			blue = ArgumentValidation.getInt32(color.get(2, t), t);
+			blue = ArgumentValidation.getInt32(color.get(2, t, env), t, env);
 		}
-		if(color.size() > 3) {
+		if(color.size(env) > 3) {
 			int alpha;
 			if(color.containsKey("a")) {
-				alpha = ArgumentValidation.getInt32(color.get("a", t), t);
+				alpha = ArgumentValidation.getInt32(color.get("a", t, env), t, env);
 			} else if(color.containsKey("alpha")) {
-				alpha = ArgumentValidation.getInt32(color.get("alpha", t), t);
+				alpha = ArgumentValidation.getInt32(color.get("alpha", t, env), t, env);
 			} else {
-				alpha = ArgumentValidation.getInt32(color.get(3, t), t);
+				alpha = ArgumentValidation.getInt32(color.get(3, t, env), t, env);
 			}
 			try {
 				return StaticLayer.GetConvertor().GetColor(red, green, blue, alpha);
-			} catch (IllegalArgumentException ex) {
+			} catch(IllegalArgumentException ex) {
 				throw new CRERangeException(ex.getMessage(), t, ex);
 			}
 		}
 		try {
 			return StaticLayer.GetConvertor().GetColor(red, green, blue);
-		} catch (IllegalArgumentException ex) {
+		} catch(IllegalArgumentException ex) {
 			throw new CRERangeException(ex.getMessage(), t, ex);
 		}
 	}
 
 	/**
-	 * Returns a CArray with an alpha channel from a given MCColor. It will be in the format array(a: 0, r: 0, g: 0, b: 0)
+	 * Returns a CArray with an alpha channel from a given MCColor. It will be in the format array(a: 0, r: 0, g: 0, b:
+	 * 0)
 	 *
 	 * @param color
 	 * @param t
 	 * @return
 	 */
 	public CArray transparentColor(MCColor color, Target t) {
-		CArray ca = CArray.GetAssociativeArray(t);
-		ca.set("r", new CInt(color.getRed(), t), t);
-		ca.set("g", new CInt(color.getGreen(), t), t);
-		ca.set("b", new CInt(color.getBlue(), t), t);
-		ca.set("a", new CInt(color.getAlpha(), t), t);
+		CArray ca = CArray.GetAssociativeArray(t, null, null);
+		ca.set("r", new CInt(color.getRed(), t), t, null);
+		ca.set("g", new CInt(color.getGreen(), t), t, null);
+		ca.set("b", new CInt(color.getBlue(), t), t, null);
+		ca.set("a", new CInt(color.getAlpha(), t), t, null);
 		return ca;
 	}
 
@@ -2031,18 +2090,40 @@ public CArray vector(Vector3D vector) {
 	 * @return the vector array
 	 */
 	public CArray vector(Vector3D vector, Target t) {
-		CArray ca = CArray.GetAssociativeArray(t);
+		CArray ca = CArray.GetAssociativeArray(t, null, null);
 		//Integral keys first
-		ca.set(0, new CDouble(vector.X(), t), t);
-		ca.set(1, new CDouble(vector.Y(), t), t);
-		ca.set(2, new CDouble(vector.Z(), t), t);
+		ca.set(0, new CDouble(vector.X(), t), t, null);
+		ca.set(1, new CDouble(vector.Y(), t), t, null);
+		ca.set(2, new CDouble(vector.Z(), t), t, null);
 		//Then string keys
-		ca.set("x", new CDouble(vector.X(), t), t);
-		ca.set("y", new CDouble(vector.Y(), t), t);
-		ca.set("z", new CDouble(vector.Z(), t), t);
+		ca.set("x", new CDouble(vector.X(), t), t, null);
+		ca.set("y", new CDouble(vector.Y(), t), t, null);
+		ca.set("z", new CDouble(vector.Z(), t), t, null);
 		return ca;
 	}
 
+	/**
+	 * Gets a Vector, given a vector object. A vector has three parts: the X, Y, and Z.
+	 *
+	 * If the vector object is missing the Z part, then we will assume it is zero. If the vector object is missing the X
+	 * and/or Y part, then we will assume it is not a vector.
+	 *
+	 * Furthermore, the string keys ("x", "y" and "z") take precedence over the integral ones. For example, in a case of
+	 * <code>array(0, 1, 2, x: 3, y: 4, z: 5)</code>, the resultant Vector will be of the value
+	 * <code>Vector(3, 4, 5)</code>.
+	 *
+	 * For consistency, the method will accept any Construct, but it requires a CArray.
+	 *
+	 * @param c the vector array
+	 * @param t the target
+	 * @return the Vector
+	 * @deprecated Use {@link #vector(Mixed, Target, Environment)} instead.
+	 */
+	@Deprecated
+	public Vector3D vector(Mixed c, Target t) {
+		return vector(Vector3D.ZERO, c, t, null);
+	}
+
 	/**
 	 * Gets a Vector, given a vector object.
 	 *
@@ -2057,10 +2138,22 @@ public CArray vector(Vector3D vector, Target t) {
 	 *
 	 * @param c the vector array
 	 * @param t the target
+	 * @param env
 	 * @return the Vector
 	 */
-	public Vector3D vector(Mixed c, Target t) {
-		return vector(Vector3D.ZERO, c, t);
+	public Vector3D vector(Mixed c, Target t, Environment env) {
+		return vector(Vector3D.ZERO, c, t, env);
+	}
+
+	/**
+	 * @param v the original vector
+	 * @param c the vector array
+	 * @param t the target
+	 * @deprecated Use {@link #vector(Vector3D, Mixed, Target, Environment)} instead.
+	 */
+	@Deprecated
+	public Vector3D vector(Vector3D v, Mixed c, Target t) {
+		return vector(v, c, t, null);
 	}
 
 	/**
@@ -2070,69 +2163,87 @@ public Vector3D vector(Mixed c, Target t) {
 	 * @param v the original vector
 	 * @param c the vector array
 	 * @param t the target
+	 * @param env
 	 * @return the Vector
 	 */
-	public Vector3D vector(Vector3D v, Mixed c, Target t) {
-		if(c.isInstanceOf(CArray.TYPE)) {
-			CArray va = (CArray) c;
+	public Vector3D vector(Vector3D v, Mixed c, Target t, Environment env) {
+		if(c.isInstanceOf(CArray.TYPE, null, env)) {
+			CArray va  = (CArray) c;
 			double x = v.X();
 			double y = v.Y();
 			double z = v.Z();
 
 			if(!va.isAssociative()) {
-				if(va.size() == 3) { // 3rd dimension vector
-					x = ArgumentValidation.getNumber(va.get(0, t), t);
-					y = ArgumentValidation.getNumber(va.get(1, t), t);
-					z = ArgumentValidation.getNumber(va.get(2, t), t);
-				} else if(va.size() == 2) { // 2nd dimension vector
-					x = ArgumentValidation.getNumber(va.get(0, t), t);
-					y = ArgumentValidation.getNumber(va.get(1, t), t);
-				} else if(va.size() == 1) {
-					x = ArgumentValidation.getNumber(va.get(0, t), t);
+				switch((int) va.size(env)) {
+					case 3 -> {
+						// 3rd dimension vector
+						x = ArgumentValidation.getNumber(va.get(0, t, env), t, env);
+						y = ArgumentValidation.getNumber(va.get(1, t, env), t, env);
+						z = ArgumentValidation.getNumber(va.get(2, t, env), t, env);
+					}
+					case 2 -> {
+						// 2nd dimension vector
+						x = ArgumentValidation.getNumber(va.get(0, t, env), t, env);
+						y = ArgumentValidation.getNumber(va.get(1, t, env), t, env);
+					}
+					case 1 ->
+						x = ArgumentValidation.getNumber(va.get(0, t, env), t, env);
+					default -> {
+					}
 				}
 			} else {
 				if(va.containsKey("x")) {
-					x = ArgumentValidation.getNumber(va.get("x", t), t);
+					x = ArgumentValidation.getNumber(va.get("x", t, env), t, env);
 				}
 				if(va.containsKey("y")) {
-					y = ArgumentValidation.getNumber(va.get("y", t), t);
+					y = ArgumentValidation.getNumber(va.get("y", t, env), t, env);
 				}
 				if(va.containsKey("z")) {
-					z = ArgumentValidation.getNumber(va.get("z", t), t);
+					z = ArgumentValidation.getNumber(va.get("z", t, env), t, env);
 				}
 			}
 
 			return new Vector3D(x, y, z);
 		} else if(c instanceof CNull) {
-			// fulfilling the todo?
 			return v;
 		} else {
-			throw new CREFormatException("Expecting an array, received " + c.typeof().getSimpleName(), t);
+			throw new CREFormatException("Expecting an array, received " + c.typeof(env).getSimpleName(), t);
 		}
 	}
 
 	public CArray enchants(Map<MCEnchantment, Integer> map, Target t) {
-		CArray ret = CArray.GetAssociativeArray(t);
+		CArray ret = CArray.GetAssociativeArray(t, null, null);
 		for(Map.Entry<MCEnchantment, Integer> entry : map.entrySet()) {
-			CArray enchant = CArray.GetAssociativeArray(t);
-			enchant.set("elevel", new CInt(entry.getValue(), t), t);
-			ret.set(entry.getKey().name().toLowerCase(), enchant, t);
+			CArray enchant = CArray.GetAssociativeArray(t, null, null);
+			enchant.set("elevel", new CInt(entry.getValue(), t), t, null);
+			ret.set(entry.getKey().name().toLowerCase(), enchant, t, null);
 		}
 		return ret;
 	}
 
+	/**
+	 * @param enchantArray
+	 * @param t
+	 * @return
+	 * @deprecated Use {@link #enchants(CArray, Target, Environment)} instead.
+	 */
+	@Deprecated
 	public Map<MCEnchantment, Integer> enchants(CArray enchantArray, Target t) {
+		return enchants(enchantArray, t, null);
+	}
+
+	public Map<MCEnchantment, Integer> enchants(CArray enchantArray, Target t, Environment env) {
 		Map<MCEnchantment, Integer> ret = new HashMap<>();
 		for(String key : enchantArray.stringKeySet()) {
 			MCEnchantment etype = null;
 			int elevel;
 
-			Mixed value = enchantArray.get(key, t);
+			Mixed value = enchantArray.get(key, t, env);
 			if(enchantArray.isAssociative()) {
 				try {
 					etype = MCEnchantment.valueOf(key.toUpperCase());
-					if(value.isInstanceOf(CInt.TYPE)) {
-						ret.put(etype, ArgumentValidation.getInt32(value, t));
+					if(value.isInstanceOf(CInt.TYPE, null, env)) {
+						ret.put(etype, ArgumentValidation.getInt32(value, t, env));
 						continue;
 					}
 				} catch(IllegalArgumentException ex) {
@@ -2141,16 +2252,16 @@ public Map<MCEnchantment, Integer> enchants(CArray enchantArray, Target t) {
 			}
 
 			// legacy format
-			if(value.isInstanceOf(CArray.TYPE)) {
+			if(value.isInstanceOf(CArray.TYPE, null, env)) {
 				CArray ea = (CArray) value;
 				if(etype == null) {
-					String setype = ea.get("etype", t).val();
+					String setype = ea.get("etype", t, env).val();
 					etype = MCEnchantment.valueOf(setype);
 					if(etype == null) {
 						throw new CREEnchantmentException("Unknown enchantment type: " + setype, t);
 					}
 				}
-				elevel = ArgumentValidation.getInt32(ea.get("elevel", t), t);
+				elevel = ArgumentValidation.getInt32(ea.get("elevel", t, env), t, env);
 				ret.put(etype, elevel);
 			}
 		}
@@ -2158,18 +2269,18 @@ public Map<MCEnchantment, Integer> enchants(CArray enchantArray, Target t) {
 	}
 
 	public CArray attributeModifier(MCAttributeModifier m, Target t) {
-		CArray modifier = CArray.GetAssociativeArray(t);
+		CArray modifier = CArray.GetAssociativeArray(t, null, null);
 
 		if(Static.getServer().getMinecraftVersion().gte(MCVersion.MC1_21)) {
-			modifier.set("id", m.getKey().toString());
+			modifier.set("id", m.getKey().toString(), t, null);
 		} else {
-			modifier.set("name", m.getAttributeName());
-			modifier.set("uuid", m.getUniqueId().toString());
+			modifier.set("name", m.getAttributeName(), t, null);
+			modifier.set("uuid", m.getUniqueId().toString(), t, null);
 		}
 
-		modifier.set("attribute", m.getAttribute().name());
-		modifier.set("operation", m.getOperation().name());
-		modifier.set("amount", new CDouble(m.getAmount(), t), t);
+		modifier.set("attribute", m.getAttribute().name(), t, null);
+		modifier.set("operation", m.getOperation().name(), t, null);
+		modifier.set("amount", new CDouble(m.getAmount(), t), t, null);
 
 		Mixed slot = CNull.NULL;
 		if(Static.getServer().getMinecraftVersion().gte(MCVersion.MC1_20_6)) {
@@ -2184,11 +2295,22 @@ public CArray attributeModifier(MCAttributeModifier m, Target t) {
 				slot = new CString(equipmentSlot.name(), t);
 			}
 		}
-		modifier.set("slot", slot, t);
+		modifier.set("slot", slot, t, null);
 		return modifier;
 	}
 
+	/**
+	 * @param m
+	 * @param t
+	 * @return
+	 * @deprecated Use {@link #attributeModifier(CArray, Target, Environment)} instead.
+	 */
+	@Deprecated
 	public MCAttributeModifier attributeModifier(CArray m, Target t) {
+		return attributeModifier(m, t, null);
+	}
+
+	public MCAttributeModifier attributeModifier(CArray m, Target t, Environment env) {
 		if(!m.isAssociative()) {
 			throw new CREFormatException("Attribute modifier array must be associative.", t);
 		}
@@ -2203,53 +2325,59 @@ public MCAttributeModifier attributeModifier(CArray m, Target t) {
 		MCEquipmentSlot slot = null;
 
 		try {
-			attribute = MCAttribute.valueOf(m.get("attribute", t).val());
-		} catch (IllegalArgumentException ex) {
-			throw new CREFormatException("Invalid attribute name: " + m.get("attribute", t), t);
+			attribute = MCAttribute.valueOf(m.get("attribute", t, env).val());
+		} catch(IllegalArgumentException ex) {
+			throw new CREFormatException("Invalid attribute name: " + m.get("attribute", t, env), t);
 		}
 
 		try {
-			operation = MCAttributeModifier.Operation.valueOf(m.get("operation", t).val());
-		} catch (IllegalArgumentException ex) {
-			throw new CREFormatException("Invalid operation name: " + m.get("operation", t), t);
+			operation = MCAttributeModifier.Operation.valueOf(m.get("operation", t, env).val());
+		} catch(IllegalArgumentException ex) {
+			throw new CREFormatException("Invalid operation name: " + m.get("operation", t, env), t);
 		}
 
-		amount = ArgumentValidation.getDouble(m.get("amount", t), t);
+		amount = ArgumentValidation.getDouble(m.get("amount", t, env), t, env);
 
 		if(Static.getServer().getMinecraftVersion().gte(MCVersion.MC1_21) && m.containsKey("id")) {
-			id = StaticLayer.GetConvertor().GetNamespacedKey(m.get("id", t).val());
+			id = StaticLayer.GetConvertor().GetNamespacedKey(m.get("id", t, env).val());
 		} else {
 			if(m.containsKey("name")) {
-				name = m.get("name", t).val();
+				name = m.get("name", t, env).val();
 			}
 			if(m.containsKey("uuid")) {
 				try {
-					uuid = UUID.fromString(m.get("uuid", t).val());
-				} catch (IllegalArgumentException ex) {
-					throw new CREFormatException("Invalid UUID format: " + m.get("uuid", t), t);
+					uuid = UUID.fromString(m.get("uuid", t, env).val());
+				} catch(IllegalArgumentException ex) {
+					throw new CREFormatException("Invalid UUID format: " + m.get("uuid", t, env), t);
 				}
 			}
 		}
 
 		if(m.containsKey("slot")) {
-			Mixed s = m.get("slot", t);
+			Mixed s = m.get("slot", t, env);
 			if(!(s instanceof CNull)) {
 				if(Static.getServer().getMinecraftVersion().gte(MCVersion.MC1_20_6)) {
 					// check new slots groups first
 					slotGroup = switch(s.val()) {
-						case "ANY" -> MCEquipmentSlotGroup.ANY;
-						case "HAND" -> MCEquipmentSlotGroup.HAND;
-						case "ARMOR" -> MCEquipmentSlotGroup.ARMOR;
-						case "BODY" -> MCEquipmentSlotGroup.BODY;
-						case "SADDLE" -> MCEquipmentSlotGroup.SADDLE;
-						default -> null;
+						case "ANY" ->
+							MCEquipmentSlotGroup.ANY;
+						case "HAND" ->
+							MCEquipmentSlotGroup.HAND;
+						case "ARMOR" ->
+							MCEquipmentSlotGroup.ARMOR;
+						case "BODY" ->
+							MCEquipmentSlotGroup.BODY;
+						case "SADDLE" ->
+							MCEquipmentSlotGroup.SADDLE;
+						default ->
+							null;
 					};
 				}
 				if(slotGroup == null) {
 					try {
 						slot = MCEquipmentSlot.valueOf(s.val());
-					} catch (IllegalArgumentException ex) {
-						throw new CREFormatException("Invalid equipment slot name: " + m.get("slot", t), t);
+					} catch(IllegalArgumentException ex) {
+						throw new CREFormatException("Invalid equipment slot name: " + m.get("slot", t, env), t);
 					}
 				}
 			}
@@ -2268,31 +2396,42 @@ public MCAttributeModifier attributeModifier(CArray m, Target t) {
 	}
 
 	public CArray potion(MCLivingEntity.MCEffect eff, Target t) {
-		CArray effect = CArray.GetAssociativeArray(t);
-		effect.set("id", new CInt(eff.getPotionEffectType().getId(), t), t);
-		effect.set("strength", new CInt(eff.getStrength(), t), t);
-		effect.set("seconds", new CDouble(eff.getTicksRemaining() / 20.0, t), t);
-		effect.set("ambient", CBoolean.get(eff.isAmbient()), t);
-		effect.set("particles", CBoolean.get(eff.hasParticles()), t);
-		effect.set("icon", CBoolean.get(eff.showIcon()), t);
+		CArray effect = CArray.GetAssociativeArray(t, null, null);
+		effect.set("id", new CInt(eff.getPotionEffectType().getId(), t), t, null);
+		effect.set("strength", new CInt(eff.getStrength(), t), t, null);
+		effect.set("seconds", new CDouble(eff.getTicksRemaining() / 20.0, t), t, null);
+		effect.set("ambient", CBoolean.get(eff.isAmbient()), t, null);
+		effect.set("particles", CBoolean.get(eff.hasParticles()), t, null);
+		effect.set("icon", CBoolean.get(eff.showIcon()), t, null);
 
 		return effect;
 	}
 
 	public CArray potions(List<MCLivingEntity.MCEffect> effectList, Target t) {
-		CArray ea = CArray.GetAssociativeArray(t);
+		CArray ea = CArray.GetAssociativeArray(t, null, null);
 		for(MCLivingEntity.MCEffect eff : effectList) {
 			CArray effect = potion(eff, t);
-			ea.set(eff.getPotionEffectType().name().toLowerCase(), effect, t);
+			ea.set(eff.getPotionEffectType().name().toLowerCase(), effect, t, null);
 		}
 		return ea;
 	}
 
+	/**
+	 * @param ea
+	 * @param t
+	 * @return
+	 * @deprecated Use {@link #potions(CArray, Target, Environment)} instead.
+	 */
+	@Deprecated
 	public List<MCLivingEntity.MCEffect> potions(CArray ea, Target t) {
+		return potions(ea, t, null);
+	}
+
+	public List<MCLivingEntity.MCEffect> potions(CArray ea, Target t, Environment env) {
 		List<MCLivingEntity.MCEffect> ret = new ArrayList<>();
 		for(String key : ea.stringKeySet()) {
-			if(ea.get(key, t).isInstanceOf(CArray.TYPE)) {
-				CArray effect = (CArray) ea.get(key, t);
+			if(ea.get(key, t, env).isInstanceOf(CArray.TYPE, null, env)) {
+				CArray effect = (CArray) ea.get(key, t, env);
 				MCPotionEffectType type;
 				int strength = 0;
 				double seconds = 30.0;
@@ -2304,31 +2443,31 @@ public List<MCLivingEntity.MCEffect> potions(CArray ea, Target t) {
 					if(ea.isAssociative()) {
 						type = MCPotionEffectType.valueOf(key.toUpperCase());
 					} else if(effect.containsKey("id")) {
-						type = MCPotionEffectType.getById(ArgumentValidation.getInt32(effect.get("id", t), t));
+						type = MCPotionEffectType.getById(ArgumentValidation.getInt32(effect.get("id", t, env), t, env));
 					} else {
 						throw new CREFormatException("No potion type was given.", t);
 					}
-				} catch (IllegalArgumentException ex) {
+				} catch(IllegalArgumentException ex) {
 					throw new CREFormatException(ex.getMessage(), t);
 				}
 
 				if(effect.containsKey("strength")) {
-					strength = ArgumentValidation.getInt32(effect.get("strength", t), t);
+					strength = ArgumentValidation.getInt32(effect.get("strength", t, env), t, env);
 				}
 				if(effect.containsKey("seconds")) {
-					seconds = ArgumentValidation.getDouble(effect.get("seconds", t), t);
+					seconds = ArgumentValidation.getDouble(effect.get("seconds", t, env), t, env);
 					if(seconds * 20 > Integer.MAX_VALUE) {
 						throw new CRERangeException("Seconds cannot be greater than 107374182", t);
 					}
 				}
 				if(effect.containsKey("ambient")) {
-					ambient = ArgumentValidation.getBoolean(effect.get("ambient", t), t);
+					ambient = ArgumentValidation.getBooleanObject(effect.get("ambient", t, env), t, env);
 				}
 				if(effect.containsKey("particles")) {
-					particles = ArgumentValidation.getBoolean(effect.get("particles", t), t);
+					particles = ArgumentValidation.getBooleanObject(effect.get("particles", t, env), t, env);
 				}
 				if(effect.containsKey("icon")) {
-					icon = ArgumentValidation.getBoolean(effect.get("icon", t), t);
+					icon = ArgumentValidation.getBooleanObject(effect.get("icon", t, env), t, env);
 				}
 				ret.add(new MCLivingEntity.MCEffect(type, strength, (int) (seconds * 20), ambient, particles, icon));
 			} else {
@@ -2339,35 +2478,46 @@ public List<MCLivingEntity.MCEffect> potions(CArray ea, Target t) {
 	}
 
 	public CArray potionData(MCPotionData mcpd, Target t) {
-		CArray base = CArray.GetAssociativeArray(t);
-		base.set("type", mcpd.getType().name(), t);
-		base.set("extended", CBoolean.get(mcpd.isExtended()), t);
-		base.set("upgraded", CBoolean.get(mcpd.isUpgraded()), t);
+		CArray base = CArray.GetAssociativeArray(t, null, null);
+		base.set("type", mcpd.getType().name(), t, null);
+		base.set("extended", CBoolean.get(mcpd.isExtended()), t, null);
+		base.set("upgraded", CBoolean.get(mcpd.isUpgraded()), t, null);
 		return base;
 	}
 
+	/**
+	 * @param pd
+	 * @param t
+	 * @return
+	 * @deprecated Use {@link #potionData(CArray, Target, Environment)} instead.
+	 */
+	@Deprecated
 	public MCPotionData potionData(CArray pd, Target t) {
+		return potionData(pd, t, null);
+	}
+
+	public MCPotionData potionData(CArray pd, Target t, Environment env) {
 		MCPotionType type;
 		try {
-			type = MCPotionType.valueOf(pd.get("type", t).val().toUpperCase());
-		} catch (IllegalArgumentException ex) {
-			throw new CREFormatException("Invalid potion type: " + pd.get("type", t).val(), t);
+			type = MCPotionType.valueOf(pd.get("type", t, env).val().toUpperCase());
+		} catch(IllegalArgumentException ex) {
+			throw new CREFormatException("Invalid potion type: " + pd.get("type", t, env).val(), t);
 		}
 		boolean extended = false;
 		boolean upgraded = false;
 		if(pd.containsKey("extended")) {
-			Mixed cext = pd.get("extended", t);
-			if(cext.isInstanceOf(CBoolean.TYPE)) {
-				extended = ((CBoolean) cext).getBoolean();
+			Mixed cext = pd.get("extended", t, env);
+			if(cext instanceof CBoolean cBoolean) {
+				extended = cBoolean.getBoolean();
 			} else {
 				throw new CREFormatException(
 						"Expected potion value for key \"extended\" to be a boolean", t);
 			}
 		}
 		if(pd.containsKey("upgraded")) {
-			Mixed cupg = pd.get("upgraded", t);
-			if(cupg.isInstanceOf(CBoolean.TYPE)) {
-				upgraded = ((CBoolean) cupg).getBoolean();
+			Mixed cupg = pd.get("upgraded", t, env);
+			if(cupg instanceof CBoolean cBoolean) {
+				upgraded = cBoolean.getBoolean();
 			} else {
 				throw new CREFormatException(
 						"Expected potion value for key \"upgraded\" to be a boolean", t);
@@ -2375,18 +2525,29 @@ public MCPotionData potionData(CArray pd, Target t) {
 		}
 		try {
 			return StaticLayer.GetPotionData(type, extended, upgraded);
-		} catch (IllegalArgumentException ex) {
+		} catch(IllegalArgumentException ex) {
 			throw new CREFormatException(ex.getMessage(), t, ex);
 		}
 	}
 
+	/**
+	 * @param potionArray
+	 * @param t
+	 * @return
+	 * @deprecated Use {@link #legacyPotionData(CArray, Target, Environment)} instead.
+	 */
+	@Deprecated
 	public MCPotionType legacyPotionData(CArray potionArray, Target t) {
+		return legacyPotionData(potionArray, t, null);
+	}
+
+	public MCPotionType legacyPotionData(CArray potionArray, Target t, Environment env) {
 		MCPotionType type;
 		try {
 			// need to get converted type first before extending/upgrading
-			type = MCPotionType.valueOf(potionArray.get("type", t).val().toUpperCase());
-		} catch (IllegalArgumentException ex) {
-			throw new CREFormatException("Invalid potion type: " + potionArray.get("type", t).val(), t);
+			type = MCPotionType.valueOf(potionArray.get("type", t, env).val().toUpperCase());
+		} catch(IllegalArgumentException ex) {
+			throw new CREFormatException("Invalid potion type: " + potionArray.get("type", t, env).val(), t);
 		}
 		if(type == null) {
 			return null;
@@ -2394,91 +2555,102 @@ public MCPotionType legacyPotionData(CArray potionArray, Target t) {
 		boolean extended = false;
 		boolean upgraded = false;
 		if(potionArray.containsKey("extended")) {
-			Mixed cext = potionArray.get("extended", t);
-			if(cext.isInstanceOf(CBoolean.TYPE)) {
-				extended = ((CBoolean) cext).getBoolean();
+			Mixed cext = potionArray.get("extended", t, env);
+			if(cext instanceof CBoolean cBoolean) {
+				extended = cBoolean.getBoolean();
 			}
 		}
 		if(potionArray.containsKey("upgraded")) {
-			Mixed cupg = potionArray.get("upgraded", t);
-			if(cupg.isInstanceOf(CBoolean.TYPE)) {
-				upgraded = ((CBoolean) cupg).getBoolean();
+			Mixed cupg = potionArray.get("upgraded", t, env);
+			if(cupg instanceof CBoolean cBoolean) {
+				upgraded = cBoolean.getBoolean();
 			}
 		}
 		if(extended) {
 			try {
 				type = MCPotionType.valueOf("LONG_" + type.name());
-			} catch (IllegalArgumentException ex) {
+			} catch(IllegalArgumentException ex) {
 				throw new CREFormatException("Could not find extended potion type for: "
-						+ potionArray.get("type", t).val(), t);
+						+ potionArray.get("type", t, env).val(), t);
 			}
 		} else if(upgraded) {
 			try {
 				type = MCPotionType.valueOf("STRONG_" + type.name());
-			} catch (IllegalArgumentException ex) {
+			} catch(IllegalArgumentException ex) {
 				throw new CREFormatException("Could not find upgraded potion type for: "
-						+ potionArray.get("type", t).val(), t);
+						+ potionArray.get("type", t, env).val(), t);
 			}
 		}
 		return type;
 	}
 
 	public CArray fireworkEffect(MCFireworkEffect mcfe, Target t) {
-		CArray fe = CArray.GetAssociativeArray(t);
-		fe.set("flicker", CBoolean.get(mcfe.hasFlicker()), t);
-		fe.set("trail", CBoolean.get(mcfe.hasTrail()), t);
+		CArray fe = CArray.GetAssociativeArray(t, null, null);
+		fe.set("flicker", CBoolean.get(mcfe.hasFlicker()), t, null);
+		fe.set("trail", CBoolean.get(mcfe.hasTrail()), t, null);
 		MCFireworkType type = mcfe.getType();
 		if(type != null) {
-			fe.set("type", new CString(mcfe.getType().name(), t), t);
+			fe.set("type", new CString(mcfe.getType().name(), t), t, null);
 		} else {
-			fe.set("type", CNull.NULL, t);
+			fe.set("type", CNull.NULL, t, null);
 		}
-		CArray colors = new CArray(t);
+		CArray colors = new CArray(t, null, null);
 		for(MCColor c : mcfe.getColors()) {
-			colors.push(ObjectGenerator.GetGenerator().color(c, t), t);
+			colors.push(ObjectGenerator.GetGenerator().color(c, t), t, null);
 		}
-		fe.set("colors", colors, t);
-		CArray fadeColors = new CArray(t);
+		fe.set("colors", colors, t, null);
+		CArray fadeColors = new CArray(t, null, null);
 		for(MCColor c : mcfe.getFadeColors()) {
-			fadeColors.push(ObjectGenerator.GetGenerator().color(c, t), t);
+			fadeColors.push(ObjectGenerator.GetGenerator().color(c, t), t, null);
 		}
-		fe.set("fade", fadeColors, t);
+		fe.set("fade", fadeColors, t, null);
 		return fe;
 	}
 
+	/**
+	 * @param fe
+	 * @param t
+	 * @return
+	 * @deprecated Use {@link #fireworkEffect(CArray, Target, Environment)} instead.
+	 */
+	@Deprecated
 	public MCFireworkEffect fireworkEffect(CArray fe, Target t) {
+		return fireworkEffect(fe, t, null);
+	}
+
+	public MCFireworkEffect fireworkEffect(CArray fe, Target t, Environment env) {
 		MCFireworkBuilder builder = StaticLayer.GetConvertor().GetFireworkBuilder();
 		if(fe.containsKey("flicker")) {
-			builder.setFlicker(ArgumentValidation.getBoolean(fe.get("flicker", t), t));
+			builder.setFlicker(ArgumentValidation.getBooleanObject(fe.get("flicker", t, env), t, env));
 		}
 		if(fe.containsKey("trail")) {
-			builder.setTrail(ArgumentValidation.getBoolean(fe.get("trail", t), t));
+			builder.setTrail(ArgumentValidation.getBooleanObject(fe.get("trail", t, env), t, env));
 		}
 		if(fe.containsKey("colors")) {
-			Mixed colors = fe.get("colors", t);
-			if(colors.isInstanceOf(CArray.TYPE)) {
+			Mixed colors = fe.get("colors", t, env);
+			if(colors.isInstanceOf(CArray.TYPE, null, env)) {
 				CArray ccolors = (CArray) colors;
-				if(ccolors.size() == 0) {
+				if(ccolors.size(env) == 0) {
 					builder.addColor(MCColor.WHITE);
 				} else {
-					for(Mixed color : ccolors.asList()) {
+					for(Mixed color : ccolors.asList(env)) {
 						MCColor mccolor;
-						if(color.isInstanceOf(CString.TYPE)) {
+						if(color.isInstanceOf(CString.TYPE, null, env)) {
 							mccolor = StaticLayer.GetConvertor().GetColor(color.val(), t);
-						} else if(color.isInstanceOf(CArray.TYPE)) {
-							mccolor = color((CArray) color, t);
-						} else if(color.isInstanceOf(CInt.TYPE) && ccolors.size() == 3) {
+						} else if(color.isInstanceOf(CArray.TYPE, null, env)) {
+							mccolor = color((CArray) color, t, env);
+						} else if(color.isInstanceOf(CInt.TYPE, null, env) && ccolors.size(env) == 3) {
 							// Appears to be a single color
-							builder.addColor(color(ccolors, t));
+							builder.addColor(color(ccolors, t, env));
 							break;
 						} else {
 							throw new CREFormatException("Expecting individual color to be an array or string, but found "
-									+ color.typeof(), t);
+									+ color.typeof(env), t);
 						}
 						builder.addColor(mccolor);
 					}
 				}
-			} else if(colors.isInstanceOf(CString.TYPE)) {
+			} else if(colors.isInstanceOf(CString.TYPE, null, env)) {
 				String[] split = colors.val().split("\\|");
 				if(split.length == 0) {
 					builder.addColor(MCColor.WHITE);
@@ -2489,45 +2661,45 @@ public MCFireworkEffect fireworkEffect(CArray fe, Target t) {
 				}
 			} else {
 				throw new CREFormatException("Expecting an array or string for colors parameter, but found "
-						+ colors.typeof(), t);
+						+ colors.typeof(env), t);
 			}
 		} else {
 			builder.addColor(MCColor.WHITE);
 		}
 		if(fe.containsKey("fade")) {
-			Mixed colors = fe.get("fade", t);
-			if(colors.isInstanceOf(CArray.TYPE)) {
+			Mixed colors = fe.get("fade", t, env);
+			if(colors.isInstanceOf(CArray.TYPE, null, env)) {
 				CArray ccolors = (CArray) colors;
-				for(Mixed color : ccolors.asList()) {
+				for(Mixed color : ccolors.asList(env)) {
 					MCColor mccolor;
-					if(color.isInstanceOf(CArray.TYPE)) {
-						mccolor = color((CArray) color, t);
-					} else if(color.isInstanceOf(CString.TYPE)) {
+					if(color.isInstanceOf(CArray.TYPE, null, env)) {
+						mccolor = color((CArray) color, t, env);
+					} else if(color.isInstanceOf(CString.TYPE, null, env)) {
 						mccolor = StaticLayer.GetConvertor().GetColor(color.val(), t);
-					} else if(color.isInstanceOf(CInt.TYPE) && ccolors.size() == 3) {
+					} else if(color.isInstanceOf(CInt.TYPE, null, env) && ccolors.size(env) == 3) {
 						// Appears to be a single color
-						builder.addFadeColor(color(ccolors, t));
+						builder.addFadeColor(color(ccolors, t, env));
 						break;
 					} else {
 						throw new CREFormatException("Expecting individual color to be an array or string, but found "
-								+ color.typeof(), t);
+								+ color.typeof(env), t);
 					}
 					builder.addFadeColor(mccolor);
 				}
-			} else if(colors.isInstanceOf(CString.TYPE)) {
+			} else if(colors.isInstanceOf(CString.TYPE, null, env)) {
 				String[] split = colors.val().split("\\|");
 				for(String s : split) {
 					builder.addFadeColor(StaticLayer.GetConvertor().GetColor(s, t));
 				}
 			} else {
 				throw new CREFormatException("Expecting an array or string for fade parameter, but found "
-						+ colors.typeof(), t);
+						+ colors.typeof(env), t);
 			}
 		}
 		if(fe.containsKey("type")) {
 			try {
-				builder.setType(MCFireworkType.valueOf(fe.get("type", t).val().toUpperCase()));
-			} catch (IllegalArgumentException ex) {
+				builder.setType(MCFireworkType.valueOf(fe.get("type", t, env).val().toUpperCase()));
+			} catch(IllegalArgumentException ex) {
 				throw new CREFormatException(ex.getMessage(), t, ex);
 			}
 		}
@@ -2538,101 +2710,112 @@ public Construct recipe(MCRecipe r, Target t) {
 		if(r == null) {
 			return CNull.NULL;
 		}
-		CArray ret = CArray.GetAssociativeArray(t);
-		ret.set("type", new CString(r.getRecipeType().name(), t), t);
-		ret.set("result", item(r.getResult(), t), t);
-		ret.set("key", r.getKey(), t);
-		ret.set("group", r.getGroup(), t);
+		CArray ret = CArray.GetAssociativeArray(t, null, null);
+		ret.set("type", new CString(r.getRecipeType().name(), t), t, null);
+		ret.set("result", item(r.getResult(), t), t, null);
+		ret.set("key", r.getKey(), t, null);
+		ret.set("group", r.getGroup(), t, null);
 		if(r instanceof MCCookingRecipe recipe) {
-			ret.set("input", recipeChoice(recipe.getInput()), t);
-			ret.set("experience", new CDouble(recipe.getExperience(), t), t);
-			ret.set("cookingtime", new CInt(recipe.getCookingTime(), t), t);
+			ret.set("input", recipeChoice(recipe.getInput()), t, null);
+			ret.set("experience", new CDouble(recipe.getExperience(), t), t, null);
+			ret.set("cookingtime", new CInt(recipe.getCookingTime(), t), t, null);
 		} else if(r instanceof MCShapelessRecipe shapeless) {
-			CArray il = new CArray(t);
+			CArray il = new CArray(t, null, null);
 			for(MCRecipeChoice choice : shapeless.getIngredients()) {
-				il.push(recipeChoice(choice), t);
+				il.push(recipeChoice(choice), t, null);
 			}
-			ret.set("ingredients", il, t);
+			ret.set("ingredients", il, t, null);
 		} else if(r instanceof MCShapedRecipe shaped) {
-			CArray shape = new CArray(t);
+			CArray shape = new CArray(t, null, null);
 			for(String line : shaped.getShape()) {
-				shape.push(new CString(line, t), t);
+				shape.push(new CString(line, t), t, null);
 			}
-			ret.set("shape", shape, t);
-			CArray imap = CArray.GetAssociativeArray(t);
+			ret.set("shape", shape, t, null);
+			CArray imap = CArray.GetAssociativeArray(t, null, null);
 			for(Map.Entry<Character, MCRecipeChoice> entry : shaped.getIngredientMap().entrySet()) {
 				if(entry.getValue() == null) {
-					imap.set(entry.getKey().toString(), CNull.NULL, t);
+					imap.set(entry.getKey().toString(), CNull.NULL, t, null);
 				} else {
-					imap.set(entry.getKey().toString(), recipeChoice(entry.getValue()), t);
+					imap.set(entry.getKey().toString(), recipeChoice(entry.getValue()), t, null);
 				}
 			}
-			ret.set("ingredients", imap, t);
+			ret.set("ingredients", imap, t, null);
 		} else if(r instanceof MCStonecuttingRecipe recipe) {
-			ret.set("input", recipeChoice(recipe.getInput()), t);
+			ret.set("input", recipeChoice(recipe.getInput()), t, null);
 		} else if(r instanceof MCSmithingRecipe recipe) {
 			MCMaterial[] base = recipe.getBase();
 			if(base.length == 1) {
-				ret.set("base", new CString(base[0].getName(), t), t);
+				ret.set("base", new CString(base[0].getName(), t), t, null);
 			} else {
 				CArray mats = new CArray(t);
 				for(MCMaterial mat : base) {
-					mats.push(new CString(mat.getName(), t), t);
+					mats.push(new CString(mat.getName(), t), t, null);
 				}
-				ret.set("base", mats, t);
+				ret.set("base", mats, t, null);
 			}
 			MCMaterial[] additions = recipe.getAddition();
 			if(additions.length == 1) {
-				ret.set("addition", new CString(additions[0].getName(), t), t);
+				ret.set("addition", new CString(additions[0].getName(), t), t, null);
 			} else {
 				CArray mats = new CArray(t);
 				for(MCMaterial mat : additions) {
-					mats.push(new CString(mat.getName(), t), t);
+					mats.push(new CString(mat.getName(), t), t, null);
 				}
-				ret.set("addition", mats, t);
+				ret.set("addition", mats, t, null);
 			}
 		}
 		return ret;
 	}
 
+	/**
+	 * @param c
+	 * @param t
+	 * @return
+	 * @deprecated Use {@link #recipe(Mixed, Target, Environment)} instead.
+	 */
+	@Deprecated
 	public MCRecipe recipe(Mixed c, Target t) {
-		if(!(c.isInstanceOf(CArray.TYPE))) {
-			throw new CRECastException("Expected array but received " + c.typeof().getSimpleName(), t);
+		return recipe(c, t, null);
+	}
+
+	public MCRecipe recipe(Mixed c, Target t, Environment env) {
+		if(!(c.isInstanceOf(CArray.TYPE, null, env))) {
+			throw new CRECastException("Expected array but received " + c.typeof(env).getSimpleName(), t);
 		}
 		CArray recipe = (CArray) c;
 
-		String recipeKey = recipe.get("key", t).val();
+		String recipeKey = recipe.get("key", t, env).val();
 
 		MCRecipeType recipeType;
 		try {
-			recipeType = MCRecipeType.valueOf(recipe.get("type", t).val());
-		} catch (IllegalArgumentException e) {
+			recipeType = MCRecipeType.valueOf(recipe.get("type", t, env).val());
+		} catch(IllegalArgumentException e) {
 			throw new CREIllegalArgumentException("Invalid recipe type.", t);
 		}
 
-		MCItemStack result = item(recipe.get("result", t), t);
+		MCItemStack result = item(recipe.get("result", t, env), t, env);
 
 		MCRecipe ret;
 		try {
 			ret = StaticLayer.GetNewRecipe(recipeKey, recipeType, result);
-		} catch (IllegalArgumentException ex) {
+		} catch(IllegalArgumentException ex) {
 			throw new CREIllegalArgumentException(ex.getMessage(), t);
 		}
 
 		if(recipe.containsKey("group")) {
-			ret.setGroup(recipe.get("group", t).val());
+			ret.setGroup(recipe.get("group", t, env).val());
 		}
 
 		switch(recipeType) {
-			case SHAPED:
-				CArray shaped = ArgumentValidation.getArray(recipe.get("shape", t), t);
-				String[] shape = new String[(int) shaped.size()];
-				if(shaped.size() < 1 || shaped.size() > 3 || shaped.inAssociativeMode()) {
+			case SHAPED -> {
+				CArray shaped = ArgumentValidation.getArray(recipe.get("shape", t, env), t, env);
+				String[] shape = new String[(int) shaped.size(env)];
+				if(shaped.size(env) < 1 || shaped.size(env) > 3 || shaped.inAssociativeMode()) {
 					throw new CREFormatException("Shape array is invalid.", t);
 				}
 				int i = 0;
-				for(Mixed row : shaped.asList()) {
-					if(row.isInstanceOf(CString.TYPE) && row.val().length() >= 1 && row.val().length() <= 3) {
+				for(Mixed row : shaped.asList(env)) {
+					if(row.isInstanceOf(CString.TYPE, null, env) && row.val().length() >= 1 && row.val().length() <= 3) {
 						shape[i] = row.val();
 						i++;
 					} else {
@@ -2641,19 +2824,19 @@ public MCRecipe recipe(Mixed c, Target t) {
 				}
 				((MCShapedRecipe) ret).setShape(shape);
 
-				CArray shapedIngredients = ArgumentValidation.getArray(recipe.get("ingredients", t), t);
+				CArray shapedIngredients = ArgumentValidation.getArray(recipe.get("ingredients", t, env), t, env);
 				if(!shapedIngredients.inAssociativeMode()) {
 					throw new CREIllegalArgumentException("Ingredients array is invalid.", t);
 				}
 				for(String key : shapedIngredients.stringKeySet()) {
-					Mixed ingredient = shapedIngredients.get(key, t);
-					if(ingredient.isInstanceOf(CArray.TYPE)) {
+					Mixed ingredient = shapedIngredients.get(key, t, env);
+					if(ingredient.isInstanceOf(CArray.TYPE, null, env)) {
 						if(((CArray) ingredient).isAssociative()) {
 							// Single exact item ingredient
-							((MCShapedRecipe) ret).setIngredient(key.charAt(0), recipeItem(ingredient, t));
+							((MCShapedRecipe) ret).setIngredient(key.charAt(0), recipeItem(ingredient, t, env));
 						} else {
 							// Multiple ingredient choices
-							((MCShapedRecipe) ret).setIngredient(key.charAt(0), recipeChoice((CArray) ingredient, t));
+							((MCShapedRecipe) ret).setIngredient(key.charAt(0), recipeChoice((CArray) ingredient, t, env));
 						}
 					} else if(ingredient instanceof CNull) {
 						// empty
@@ -2662,29 +2845,30 @@ public MCRecipe recipe(Mixed c, Target t) {
 					}
 				}
 				return ret;
+			}
 
-			case SHAPELESS:
-				CArray ingredients = ArgumentValidation.getArray(recipe.get("ingredients", t), t);
+			case SHAPELESS -> {
+				CArray ingredients = ArgumentValidation.getArray(recipe.get("ingredients", t, env), t, env);
 				if(ingredients.inAssociativeMode()) {
 					throw new CREIllegalArgumentException("Ingredients array is invalid.", t);
 				}
-				for(Mixed ingredient : ingredients.asList()) {
-					if(ingredient.isInstanceOf(CArray.TYPE)) {
+				for(Mixed ingredient : ingredients.asList(env)) {
+					if(ingredient.isInstanceOf(CArray.TYPE, null, env)) {
 						if(((CArray) ingredient).isAssociative()) {
 							// Single ingredient item array
 							if(((CArray) ingredient).containsKey("meta")) {
 								// Single exact ingredient item choice
 								MCRecipeChoice.ExactChoice exactChoice = new MCRecipeChoice.ExactChoice();
-								exactChoice.addItem(recipeItem(ingredient, t));
+								exactChoice.addItem(recipeItem(ingredient, t, env));
 								((MCShapelessRecipe) ret).addIngredient(exactChoice);
 							} else {
 								// Single ingredient material with optional qty
-								MCItemStack stack = recipeItem(ingredient, t);
+								MCItemStack stack = recipeItem(ingredient, t, env);
 								((MCShapelessRecipe) ret).addIngredient(stack.getType(), stack.getAmount());
 							}
 						} else {
 							// Multiple ingredient choices
-							((MCShapelessRecipe) ret).addIngredient(recipeChoice((CArray) ingredient, t));
+							((MCShapelessRecipe) ret).addIngredient(recipeChoice((CArray) ingredient, t, env));
 						}
 					} else {
 						// single ingredient material
@@ -2692,50 +2876,48 @@ public MCRecipe recipe(Mixed c, Target t) {
 					}
 				}
 				return ret;
+			}
 
-			case BLASTING:
-			case CAMPFIRE:
-			case FURNACE:
-			case SMOKING:
-				Mixed input = recipe.get("input", t);
-				if(input.isInstanceOf(CArray.TYPE)) {
+			case BLASTING, CAMPFIRE, FURNACE, SMOKING -> {
+				Mixed input = recipe.get("input", t, env);
+				if(input.isInstanceOf(CArray.TYPE, null, env)) {
 					if(((CArray) input).isAssociative()) {
-						((MCCookingRecipe) ret).setInput(recipeItem(input, t));
+						((MCCookingRecipe) ret).setInput(recipeItem(input, t, env));
 					} else {
-						((MCCookingRecipe) ret).setInput(recipeChoice((CArray) input, t));
+						((MCCookingRecipe) ret).setInput(recipeChoice((CArray) input, t, env));
 					}
 				} else {
 					((MCCookingRecipe) ret).setInput(recipeMaterial(input, t));
 				}
 				if(recipe.containsKey("experience")) {
-					((MCCookingRecipe) ret).setExperience(ArgumentValidation.getDouble32(recipe.get("experience", t), t));
+					((MCCookingRecipe) ret).setExperience(ArgumentValidation.getDouble32(recipe.get("experience", t, env), t, env));
 				}
 				if(recipe.containsKey("cookingtime")) {
-					((MCCookingRecipe) ret).setCookingTime(ArgumentValidation.getInt32(recipe.get("cookingtime", t), t));
+					((MCCookingRecipe) ret).setCookingTime(ArgumentValidation.getInt32(recipe.get("cookingtime", t, env), t, env));
 				}
 				return ret;
-
-			case STONECUTTING:
-				Mixed stoneCutterInput = recipe.get("input", t);
-				if(stoneCutterInput.isInstanceOf(CArray.TYPE)) {
+			}
+			case STONECUTTING -> {
+				Mixed stoneCutterInput = recipe.get("input", t, env);
+				if(stoneCutterInput.isInstanceOf(CArray.TYPE, null, env)) {
 					if(((CArray) stoneCutterInput).isAssociative()) {
-						((MCStonecuttingRecipe) ret).setInput(recipeItem(stoneCutterInput, t));
+						((MCStonecuttingRecipe) ret).setInput(recipeItem(stoneCutterInput, t, env));
 					} else {
-						((MCStonecuttingRecipe) ret).setInput(recipeChoice((CArray) stoneCutterInput, t));
+						((MCStonecuttingRecipe) ret).setInput(recipeChoice((CArray) stoneCutterInput, t, env));
 					}
 				} else {
 					((MCStonecuttingRecipe) ret).setInput(recipeMaterial(stoneCutterInput, t));
 				}
 				return ret;
-
-			default:
+			}
+			default ->
 				throw new CREIllegalArgumentException("Could not find valid recipe type.", t);
 		}
 	}
 
 	/**
-	 * Returns a recipe ingredient material from a material name,
-	 * or throws an exception if invalid. Ingredient material must exist and cannot be air.
+	 * Returns a recipe ingredient material from a material name, or throws an exception if invalid. Ingredient material
+	 * must exist and cannot be air.
 	 *
 	 * @param arg material name
 	 * @param t
@@ -2751,22 +2933,21 @@ private MCMaterial recipeMaterial(Mixed arg, Target t) {
 	}
 
 	/**
-	 * Returns an MCRecipeChoice from an array of exact items or material names,
-	 * or throws an exception if invalid. Item array must not be empty.
-	 * Ingredient material must exist and cannot be air.
+	 * Returns an MCRecipeChoice from an array of exact items or material names, or throws an exception if invalid. Item
+	 * array must not be empty. Ingredient material must exist and cannot be air.
 	 *
 	 * @param ingredient a CArray of material names or item arrays
 	 * @param t
 	 * @return
 	 * @throws CREIllegalArgumentException
 	 */
-	private MCRecipeChoice recipeChoice(CArray ingredient, Target t) {
+	private MCRecipeChoice recipeChoice(CArray ingredient, Target t, Environment env) {
 		// Multiple ingredient choices
 		MCRecipeChoice.MaterialChoice materialChoice = new MCRecipeChoice.MaterialChoice();
 		MCRecipeChoice.ExactChoice exactChoice = new MCRecipeChoice.ExactChoice();
-		for(Mixed choice : ingredient.asList()) {
-			if(choice.isInstanceOf(CArray.TYPE)) {
-				exactChoice.addItem(recipeItem(choice, t));
+		for(Mixed choice : ingredient.asList(env)) {
+			if(choice.isInstanceOf(CArray.TYPE, null, env)) {
+				exactChoice.addItem(recipeItem(choice, t, env));
 			} else {
 				materialChoice.addMaterial(recipeMaterial(choice, t));
 			}
@@ -2793,9 +2974,9 @@ private Mixed recipeChoice(MCRecipeChoice ingredient) {
 			if(materialChoice.getMaterials().size() == 1) {
 				return new CString(materialChoice.getMaterials().get(0).getName(), Target.UNKNOWN);
 			} else {
-				CArray materialArray = new CArray(Target.UNKNOWN);
+				CArray materialArray = new CArray(Target.UNKNOWN, null, null);
 				for(MCMaterial mat : materialChoice.getMaterials()) {
-					materialArray.push(new CString(mat.getName(), Target.UNKNOWN), Target.UNKNOWN);
+					materialArray.push(new CString(mat.getName(), Target.UNKNOWN), Target.UNKNOWN, null);
 				}
 				return materialArray;
 			}
@@ -2803,9 +2984,9 @@ private Mixed recipeChoice(MCRecipeChoice ingredient) {
 			if(exactChoice.getItems().size() == 1) {
 				return item(exactChoice.getItems().get(0), Target.UNKNOWN);
 			} else {
-				CArray itemArray = new CArray(Target.UNKNOWN);
+				CArray itemArray = new CArray(Target.UNKNOWN, null, null);
 				for(MCItemStack itemStack : exactChoice.getItems()) {
-					itemArray.push(item(itemStack, Target.UNKNOWN), Target.UNKNOWN);
+					itemArray.push(item(itemStack, Target.UNKNOWN), Target.UNKNOWN, null);
 				}
 				return itemArray;
 			}
@@ -2815,16 +2996,16 @@ private Mixed recipeChoice(MCRecipeChoice ingredient) {
 	}
 
 	/**
-	 * Returns a recipe ingredient item stack, or throws an exception if invalid.
-	 * Argument cannot be null; the material must exist and cannot be air; and quantity cannot be zero.
+	 * Returns a recipe ingredient item stack, or throws an exception if invalid. Argument cannot be null; the material
+	 * must exist and cannot be air; and quantity cannot be zero.
 	 *
 	 * @param arg
 	 * @param t
 	 * @return
 	 * @throws CREIllegalArgumentException
 	 */
-	private MCItemStack recipeItem(Mixed arg, Target t) {
-		MCItemStack item = item(arg, t);
+	private MCItemStack recipeItem(Mixed arg, Target t, Environment env) {
+		MCItemStack item = item(arg, t, env);
 		if(item.isEmpty()) {
 			throw new CREIllegalArgumentException("Recipe input ingredient is invalid: " + arg.val(), t);
 		}
@@ -2843,17 +3024,40 @@ public MCMaterial material(Mixed name, Target t) {
 		return material(name.val(), t);
 	}
 
+	/**
+	 * @param ca
+	 * @param t
+	 * @return
+	 * @deprecated Use {@link #blockData(CArray, Target, Environment)} instead.
+	 */
+	@Deprecated
 	public MCBlockData blockData(CArray ca, Target t) {
-		return blockData(ca, null, t);
+		return blockData(ca, null, t, null);
 	}
 
+	public MCBlockData blockData(CArray ca, Target t, Environment env) {
+		return blockData(ca, null, t, env);
+	}
+
+	/**
+	 * @param ca
+	 * @param blockType
+	 * @param t
+	 * @return
+	 * @deprecated Use {@link #blockData(CArray, MCMaterial, Target, Environment)} instead.
+	 */
+	@Deprecated
 	public MCBlockData blockData(CArray ca, MCMaterial blockType, Target t) {
+		return blockData(ca, blockType, t, null);
+	}
+
+	public MCBlockData blockData(CArray ca, MCMaterial blockType, Target t, Environment env) {
 		StringBuilder b = new StringBuilder().append("[");
 		boolean first = true;
 		String block = null;
 		for(String key : ca.stringKeySet()) {
 			if(key.equals("block")) {
-				block = ca.get("block", t).val();
+				block = ca.get("block", t, env).val();
 				if(Character.isUpperCase(block.charAt(0))) {
 					// support material enum input
 					block = block.toLowerCase();
@@ -2864,7 +3068,7 @@ public MCBlockData blockData(CArray ca, MCMaterial blockType, Target t) {
 				} else {
 					b.append(',');
 				}
-				b.append(key).append('=').append(ca.get(key, t).val());
+				b.append(key).append('=').append(ca.get(key, t, env).val());
 			}
 		}
 		b.append("]");
@@ -2879,27 +3083,27 @@ public MCBlockData blockData(CArray ca, MCMaterial blockType, Target t) {
 	}
 
 	public CArray blockData(MCBlockData blockdata, Target t) {
-		CArray ca = CArray.GetAssociativeArray(t);
+		CArray ca = CArray.GetAssociativeArray(t, null, null);
 		String full = blockdata.getAsString().substring(10); // ignore "minecraft:"
 		int bracketPos = full.indexOf('[', 3);
 		if(bracketPos != -1) {
-			ca.set("block", new CString(full.substring(0, bracketPos), t), t);
+			ca.set("block", new CString(full.substring(0, bracketPos), t), t, null);
 			String[] states = full.substring(bracketPos + 1, full.length() - 1).split(",");
 			for(String s : states) {
 				int equalsPos = s.indexOf('=');
-				ca.set(s.substring(0, equalsPos), blockState(s.substring(equalsPos + 1)), t);
+				ca.set(s.substring(0, equalsPos), blockState(s.substring(equalsPos + 1)), t, null);
 			}
 		} else {
-			ca.set("block", new CString(full, t), t);
+			ca.set("block", new CString(full, t), t, null);
 		}
 		return ca;
 	}
 
 	public CArray blockData(MCMaterial mat, Map<String, String> blockData, Target t) {
-		CArray ca = CArray.GetAssociativeArray(t);
-		ca.set("block", new CString(mat.getName().toLowerCase(Locale.ROOT), t), t);
+		CArray ca = CArray.GetAssociativeArray(t, null, null);
+		ca.set("block", new CString(mat.getName().toLowerCase(Locale.ROOT), t), t, null);
 		for(Entry<String, String> entry : blockData.entrySet()) {
-			ca.set(entry.getKey(), blockState(entry.getValue()), t);
+			ca.set(entry.getKey(), blockState(entry.getValue()), t, null);
 		}
 		return ca;
 	}
@@ -2909,7 +3113,7 @@ private Construct blockState(String value) {
 		if(ch >= '0' && ch <= '9') {
 			try {
 				return new CInt(Long.parseLong(value), Target.UNKNOWN);
-			} catch (NumberFormatException e) {
+			} catch(NumberFormatException e) {
 			}
 		} else if(value.equals("true")) {
 			return CBoolean.TRUE;
@@ -2919,33 +3123,41 @@ private Construct blockState(String value) {
 		return new CString(value, Target.UNKNOWN);
 	}
 
+	/**
+	 * @param particleType
+	 * @param l
+	 * @param pa
+	 * @param t
+	 * @return
+	 * @deprecated Use {@link #particleData(MCParticle, MCLocation, CArray, Target, Environment)} instead.
+	 */
+	@Deprecated
 	public Object particleData(MCParticle particleType, MCLocation l, CArray pa, Target t) {
+		return particleData(particleType, l, pa, t, null);
+	}
+
+	public Object particleData(MCParticle particleType, MCLocation l, CArray pa, Target t, Environment env) {
 		switch(particleType.getAbstracted()) {
-			case BLOCK_DUST:
-			case BLOCK_CRACK:
-			case BLOCK_CRUMBLE:
-			case BLOCK_MARKER:
-			case DUST_PILLAR:
-			case FALLING_DUST:
+			case BLOCK_DUST, BLOCK_CRACK, BLOCK_CRUMBLE, BLOCK_MARKER, DUST_PILLAR, FALLING_DUST -> {
 				if(pa.containsKey("block")) {
-					String value = pa.get("block", t).val();
+					String value = pa.get("block", t, env).val();
 					MCMaterial mat = StaticLayer.GetMaterial(value);
 					if(mat != null) {
 						try {
 							return mat.createBlockData();
-						} catch (IllegalArgumentException ex) {
+						} catch(IllegalArgumentException ex) {
 							throw new CREIllegalArgumentException(value + " is not a block.", t);
 						}
 					} else {
 						throw new CREIllegalArgumentException("Could not find material from " + value, t);
 					}
 				}
-				break;
-			case ITEM_CRACK:
+			}
+			case ITEM_CRACK -> {
 				if(pa.containsKey("item")) {
-					Mixed value = pa.get("item", t);
-					if(value.isInstanceOf(CArray.TYPE)) {
-						return item(pa.get("item", t), t);
+					Mixed value = pa.get("item", t, env);
+					if(value.isInstanceOf(CArray.TYPE, null, env)) {
+						return item(pa.get("item", t, env), t, env);
 					} else {
 						MCMaterial mat = StaticLayer.GetMaterial(value.val());
 						if(mat != null) {
@@ -2959,63 +3171,61 @@ public Object particleData(MCParticle particleType, MCLocation l, CArray pa, Tar
 						}
 					}
 				}
-				break;
-			case SPELL_MOB:
-			case REDSTONE:
-			case FLASH:
+			}
+			case SPELL_MOB, REDSTONE, FLASH -> {
 				if(pa.containsKey("color")) {
-					Mixed c = pa.get("color", t);
-					if(c.isInstanceOf(CArray.TYPE)) {
-						return color((CArray) c, t);
+					Mixed c = pa.get("color", t, env);
+					if(c.isInstanceOf(CArray.TYPE, null, env)) {
+						return color((CArray) c, t, env);
 					} else {
 						return StaticLayer.GetConvertor().GetColor(c.val(), t);
 					}
 				}
-				break;
-			case DRAGON_BREATH:
+			}
+			case DRAGON_BREATH -> {
 				if(pa.containsKey("power")) {
-					Mixed d = pa.get("power", t);
-					if(d.isInstanceOf(CDouble.TYPE)) {
+					Mixed d = pa.get("power", t, env);
+					if(d.isInstanceOf(CDouble.TYPE, null, env)) {
 						return (float) ((CDouble) d).getDouble();
 					} else if(!(d instanceof CNull)) {
 						throw new CREIllegalArgumentException("Expected double for power but found " + d, t);
 					}
 				}
-				break;
-			case SPELL:
-			case SPELL_INSTANT:
+			}
+			case SPELL, SPELL_INSTANT -> {
 				MCColor spellColor = MCColor.WHITE;
 				if(pa.containsKey("color")) {
-					Mixed c = pa.get("color", t);
-					if(c.isInstanceOf(CArray.TYPE)) {
-						spellColor = color((CArray) c, t);
+					Mixed c = pa.get("color", t, env);
+					if(c.isInstanceOf(CArray.TYPE, null, env)) {
+						spellColor = color((CArray) c, t, env);
 					} else {
 						spellColor = StaticLayer.GetConvertor().GetColor(c.val(), t);
 					}
 				}
 				float power = 1.0F;
 				if(pa.containsKey("power")) {
-					Mixed d = pa.get("power", t);
-					if(d.isInstanceOf(CDouble.TYPE)) {
+					Mixed d = pa.get("power", t, env);
+					if(d.isInstanceOf(CDouble.TYPE, null, env)) {
 						power = (float) ((CDouble) d).getDouble();
 					} else if(!(d instanceof CNull)) {
 						throw new CREIllegalArgumentException("Expected double for power but found " + d, t);
 					}
 				}
 				return new MCParticleData.Spell(spellColor, power);
-			case DUST_COLOR_TRANSITION:
+			}
+			case DUST_COLOR_TRANSITION -> {
 				if(pa.containsKey("color")) {
-					Mixed c = pa.get("color", t);
+					Mixed c = pa.get("color", t, env);
 					MCColor fromColor;
-					if(c.isInstanceOf(CArray.TYPE)) {
-						fromColor = color((CArray) c, t);
+					if(c.isInstanceOf(CArray.TYPE, null, env)) {
+						fromColor = color((CArray) c, t, env);
 					} else {
 						fromColor = StaticLayer.GetConvertor().GetColor(c.val(), t);
 					}
 					if(pa.containsKey("tocolor")) {
-						Mixed sc = pa.get("tocolor", t);
-						if(sc.isInstanceOf(CArray.TYPE)) {
-							return new MCParticleData.DustTransition(fromColor, color((CArray) sc, t));
+						Mixed sc = pa.get("tocolor", t, env);
+						if(sc.isInstanceOf(CArray.TYPE, null, env)) {
+							return new MCParticleData.DustTransition(fromColor, color((CArray) sc, t, env));
 						} else {
 							return new MCParticleData.DustTransition(fromColor,
 									StaticLayer.GetConvertor().GetColor(sc.val(), t));
@@ -3023,58 +3233,58 @@ public Object particleData(MCParticle particleType, MCLocation l, CArray pa, Tar
 					}
 					return new MCParticleData.DustTransition(fromColor, MCColor.WHITE);
 				} else if(pa.containsKey("tocolor")) {
-					Mixed sc = pa.get("tocolor", t);
-					if(sc.isInstanceOf(CArray.TYPE)) {
-						return new MCParticleData.DustTransition(MCColor.WHITE, color((CArray) sc, t));
+					Mixed sc = pa.get("tocolor", t, env);
+					if(sc.isInstanceOf(CArray.TYPE, null, env)) {
+						return new MCParticleData.DustTransition(MCColor.WHITE, color((CArray) sc, t, env));
 					} else {
 						return new MCParticleData.DustTransition(MCColor.WHITE,
 								StaticLayer.GetConvertor().GetColor(sc.val(), t));
 					}
 				}
-				break;
-			case VIBRATION:
+			}
+			case VIBRATION -> {
 				if(pa.containsKey("destination")) {
-					Mixed d = pa.get("destination", t);
-					if(d.isInstanceOf(CArray.TYPE)) {
-						return new MCParticleData.VibrationBlockDestination(location(d, l.getWorld(), t), 5);
+					Mixed d = pa.get("destination", t, env);
+					if(d.isInstanceOf(CArray.TYPE, null, env)) {
+						return new MCParticleData.VibrationBlockDestination(location(d, l.getWorld(), t, env), 5);
 					} else {
 						return new MCParticleData.VibrationEntityDestination(Static.getEntity(d, t), 5);
 					}
 				}
-				break;
-			case SHRIEK:
+			}
+			case SHRIEK -> {
 				if(pa.containsKey("delay")) {
-					Mixed d = pa.get("delay", t);
-					if(d.isInstanceOf(CInt.TYPE)) {
+					Mixed d = pa.get("delay", t, env);
+					if(d.isInstanceOf(CInt.TYPE, null, env)) {
 						return (int) ((CInt) d).getInt();
 					} else if(!(d instanceof CNull)) {
 						throw new CREIllegalArgumentException("Expected integer for delay but found " + d, t);
 					}
 				}
-				break;
-			case SCULK_CHARGE:
+			}
+			case SCULK_CHARGE -> {
 				if(pa.containsKey("angle")) {
-					Mixed d = pa.get("angle", t);
-					if(d.isInstanceOf(CDouble.TYPE)) {
+					Mixed d = pa.get("angle", t, env);
+					if(d.isInstanceOf(CDouble.TYPE, null, env)) {
 						return (float) ((CDouble) d).getDouble();
 					} else if(!(d instanceof CNull)) {
 						throw new CREIllegalArgumentException("Expected double for angle but found " + d, t);
 					}
 				}
-				break;
-			case TRAIL:
+			}
+			case TRAIL -> {
 				MCLocation target = l;
 				if(pa.containsKey("target")) {
-					Mixed d = pa.get("target", t);
-					if(d.isInstanceOf(CArray.TYPE)) {
-						target = location(d, l.getWorld(), t);
+					Mixed d = pa.get("target", t, env);
+					if(d.isInstanceOf(CArray.TYPE, null, env)) {
+						target = location(d, l.getWorld(), t, env);
 					}
 				}
 				MCColor color;
 				if(pa.containsKey("color")) {
-					Mixed c = pa.get("color", t);
-					if(c.isInstanceOf(CArray.TYPE)) {
-						color = color((CArray) c, t);
+					Mixed c = pa.get("color", t, env);
+					if(c.isInstanceOf(CArray.TYPE, null, env)) {
+						color = color((CArray) c, t, env);
 					} else {
 						color = StaticLayer.GetConvertor().GetColor(c.val(), t);
 					}
@@ -3085,12 +3295,13 @@ public Object particleData(MCParticle particleType, MCLocation l, CArray pa, Tar
 				}
 				int duration;
 				if(pa.containsKey("duration")) {
-					duration = ArgumentValidation.getInt32(pa.get("duration", t), t);
+					duration = ArgumentValidation.getInt32(pa.get("duration", t, env), t, env);
 				} else {
 					// Default duration is a random value from 0.5 to 2.5 seconds
 					duration = new Random().nextInt(40) + 10;
 				}
 				return new MCParticleData.Trail(target, color, duration);
+			}
 		}
 		return null;
 	}
@@ -3101,9 +3312,15 @@ public Object particleData(MCParticle particleType, MCLocation l, CArray pa, Tar
 	 * @param value
 	 * @param plugin
 	 * @return
+	 * @deprecated Use {@link #metadataValue(Mixed, MCPlugin, Environment)} instead.
 	 */
+	@Deprecated
 	public MCMetadataValue metadataValue(Mixed value, MCPlugin plugin) {
-		return metadataValue(Static.getJavaObject(value), plugin);
+		return metadataValue(value, plugin, null);
+	}
+
+	public MCMetadataValue metadataValue(Mixed value, MCPlugin plugin, Environment env) {
+		return metadataValue(Static.getJavaObject(value, env), plugin);
 	}
 
 	/**
@@ -3119,19 +3336,19 @@ public MCMetadataValue metadataValue(Object value, MCPlugin plugin) {
 
 	/**
 	 * Return match result in MethodScript variable value presentation
-	 * 
+	 *
 	 * @param matchResult match result
 	 * @param t the target
 	 * @return match array
 	 */
 	public CArray regMatchValue(MatchResult matchResult, Target t) {
-		CArray ret = CArray.GetAssociativeArray(t);
-		ret.set(0, new CString(matchResult.group(0), t), t);
+		CArray ret = CArray.GetAssociativeArray(t, null, null);
+		ret.set(0, new CString(matchResult.group(0), t), t, null);
 		for(int i = 1; i <= matchResult.groupCount(); i++) {
 			if(matchResult.group(i) == null) {
-				ret.set(i, CNull.NULL, t);
+				ret.set(i, CNull.NULL, t, null);
 			} else {
-				ret.set(i, new CString(matchResult.group(i), t), t);
+				ret.set(i, new CString(matchResult.group(i), t), t, null);
 			}
 		}
 
diff --git a/src/main/java/com/laytonsmith/core/ParseTree.java b/src/main/java/com/laytonsmith/core/ParseTree.java
index 7920ae9ad9..669a4dfccb 100644
--- a/src/main/java/com/laytonsmith/core/ParseTree.java
+++ b/src/main/java/com/laytonsmith/core/ParseTree.java
@@ -441,7 +441,7 @@ public Target getTarget() {
 	 */
 	public CClassType getDeclaredType(Environment env) {
 		if(isConst()) {
-			return getData().typeof();
+			return getData().typeof(env);
 		} else if(getData() instanceof IVariable ivar) {
 			StaticAnalysis sa = env.getEnv(CompilerEnvironment.class).getStaticAnalysis();
 			if(sa.isLocalEnabled()) {
diff --git a/src/main/java/com/laytonsmith/core/Prefs.java b/src/main/java/com/laytonsmith/core/Prefs.java
index ca7bc7341b..8cdbdc201c 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 8e62f139c3..1faf47c9d4 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,14 +21,15 @@
 import com.laytonsmith.core.exceptions.CRE.CREStackOverflowError;
 import com.laytonsmith.core.exceptions.ConfigCompileException;
 import com.laytonsmith.core.exceptions.ConfigRuntimeException;
-import com.laytonsmith.core.exceptions.FunctionReturnException;
-import com.laytonsmith.core.exceptions.LoopManipulationException;
+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.functions.FunctionBase;
 import com.laytonsmith.core.functions.FunctionList;
-import com.laytonsmith.core.functions.StringHandling;
+import com.laytonsmith.core.natives.interfaces.Callable;
 import com.laytonsmith.core.natives.interfaces.Mixed;
 
 import java.util.ArrayList;
@@ -194,46 +196,124 @@ public Mixed cexecute(List<ParseTree> args, Environment env, Target t) {
 	 * @return
 	 */
 	public Mixed execute(List<Mixed> args, Environment oldEnv, Target t) {
+		Environment env = prepareEnvironment(args, oldEnv, t);
+
+		Script fakeScript = Script.GenerateScript(tree, env.getEnv(GlobalEnv.class).GetLabel(), null);
+		StackTraceManager stManager = env.getEnv(GlobalEnv.class).GetStackTraceManager();
+		stManager.addStackTraceFrame(new StackTraceFrame("proc " + name, getTarget()));
+		try {
+			Mixed result = fakeScript.eval(tree, env);
+			if(result == null) {
+				result = CVoid.VOID;
+			}
+			return typeCheckReturn(result, env);
+		} catch(UnhandledFlowControlException e) {
+			if(e.getAction() instanceof ControlFlow.BreakAction
+					|| e.getAction() instanceof ControlFlow.ContinueAction) {
+				throw ConfigRuntimeException.CreateUncatchableException(
+						"Loop manipulation operations (e.g. break() or continue()) cannot"
+						+ " bubble up past procedures.", t);
+			}
+			if(e.getAction() instanceof Exceptions.ThrowAction ta) {
+				ConfigRuntimeException ex = ta.getException();
+				if(ex instanceof AbstractCREException ace) {
+					ace.freezeStackTraceElements(stManager);
+				}
+				throw ex;
+			}
+			throw e;
+		} catch(StackOverflowError e) {
+			throw new CREStackOverflowError(null, t, e);
+		} finally {
+			stManager.popStackTraceFrame();
+		}
+	}
+
+	public Target getTarget() {
+		return definedAt;
+	}
+
+	@Override
+	public Procedure clone() throws CloneNotSupportedException {
+		Procedure clone = (Procedure) super.clone();
+		if(this.varList != null) {
+			clone.varList = new HashMap<>(this.varList);
+		}
+		if(this.tree != null) {
+			clone.tree = this.tree.clone();
+		}
+		return clone;
+	}
+
+	public void definitelyNotConstant() {
+		possiblyConstant = false;
+	}
+
+	/**
+	 * Prepares this procedure for stack-based execution without re-entering eval().
+	 * Clones the environment, binds arguments, and pushes a stack trace element.
+	 * The caller is responsible for evaluating the returned tree in the returned
+	 * environment, and for popping the stack trace element when done.
+	 *
+	 * @param args The evaluated argument values
+	 * @param callerEnv The caller's environment (will be cloned)
+	 * @param callTarget The target of the procedure call site
+	 * @return The prepared call containing the procedure body tree and environment
+	 */
+	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.addStackTraceFrame(
+				new StackTraceFrame("proc " + name, getTarget()));
+		return new Callable.PreparedCallable(tree, env);
+	}
+
+	/**
+	 * Clones the environment and assigns procedure arguments (with type checking).
+	 * Used by both {@link #execute} and {@link ProcedureFlow}.
+	 *
+	 * @param args The evaluated argument values
+	 * @param oldEnv The caller's environment (will be cloned)
+	 * @param callTarget The target of the procedure call site
+	 * @return The prepared environment for the procedure body
+	 */
+	private Environment prepareEnvironment(List<Mixed> args, Environment oldEnv, Target callTarget) {
 		boolean prev = oldEnv.getEnv(GlobalEnv.class).getCloneVars();
 		oldEnv.getEnv(GlobalEnv.class).setCloneVars(false);
 		Environment env;
 		try {
 			env = oldEnv.clone();
 			env.getEnv(GlobalEnv.class).setCloneVars(true);
-		} catch (CloneNotSupportedException ex) {
+		} catch(CloneNotSupportedException ex) {
 			throw new RuntimeException(ex);
 		}
 		oldEnv.getEnv(GlobalEnv.class).setCloneVars(prev);
 
-		Script fakeScript = Script.GenerateScript(tree, env.getEnv(GlobalEnv.class).GetLabel(), null);
-
-		// Create container for the @arguments variable.
+		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);
 
-		// Handle passed procedure arguments.
 		int varInd;
 		CArray vararg = null;
 		for(varInd = 0; varInd < args.size(); varInd++) {
 			Mixed c = args.get(varInd);
-			arguments.push(c, t);
+			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) {
-						// TODO: Once generics are added, add the type
-						vararg = new CArray(t);
-						env.getEnv(GlobalEnv.class).GetVarList().set(new IVariable(CArray.TYPE,
+						vararg = new CArray(callTarget);
+						varList.set(new IVariable(CArray.TYPE,
 								var.getVariableName(), vararg, c.getTarget()));
 					}
 				}
 
-				// Type check "void" value.
 				if(c instanceof CVoid
 						&& !(var.getDefinedType().equals(Auto.TYPE) || var.getDefinedType().equals(CVoid.TYPE))) {
 					throw new CRECastException("Procedure \"" + name + "\" expects a value of type "
@@ -241,116 +321,167 @@ public Mixed execute(List<Mixed> args, Environment oldEnv, Target t) {
 							+ " a void value was found instead.", c.getTarget());
 				}
 
-				// Type check vararg parameter.
 				if(var.getDefinedType().isVariadicType()) {
-					if(InstanceofUtil.isInstanceof(c.typeof(), var.getDefinedType().getVarargsBaseType(), env)) {
-						vararg.push(c, t);
+					if(InstanceofUtil.isInstanceof(c.typeof(env), var.getDefinedType().getVarargsBaseType(), env)) {
+						vararg.push(c, callTarget);
 						continue;
 					} else {
 						throw new CRECastException("Procedure \"" + name + "\" expects a value of type "
 								+ var.getDefinedType().val() + " in argument " + (varInd + 1) + ", but"
-								+ " a value of type " + c.typeof() + " was found instead.", c.getTarget());
+								+ " a value of type " + c.typeof(env) + " was found instead.", c.getTarget());
 					}
 				}
 
-				// Type check non-vararg parameter.
-				if(InstanceofUtil.isInstanceof(c.typeof(), var.getDefinedType(), env)) {
-					env.getEnv(GlobalEnv.class).GetVarList().set(new IVariable(var.getDefinedType(),
+				if(InstanceofUtil.isInstanceof(c.typeof(env), var.getDefinedType(), env)) {
+					varList.set(new IVariable(var.getDefinedType(),
 							var.getVariableName(), c, c.getTarget()));
 					continue;
 				} else {
 					throw new CRECastException("Procedure \"" + name + "\" expects a value of type "
 							+ var.getDefinedType().val() + " in argument " + (varInd + 1) + ", but"
-							+ " a value of type " + c.typeof() + " was found instead.", c.getTarget());
+							+ " a value of type " + c.typeof(env) + " was found instead.", c.getTarget());
 				}
 			}
 		}
 
-		// Assign default values to remaining proc arguments.
 		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()));
-			arguments.push(defVal, t);
+			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, t));
-		StackTraceManager stManager = env.getEnv(GlobalEnv.class).GetStackTraceManager();
-		stManager.addStackTraceElement(new ConfigRuntimeException.StackTraceElement("proc " + name, getTarget()));
-		try {
-			if(tree.getData() instanceof CFunction
-					&& tree.getData().val().equals(StringHandling.sconcat.NAME)) {
-				//If the inner tree is just an sconcat, we can optimize by
-				//simply running the arguments to the sconcat. We're not going
-				//to use the results, after all, and this is a common occurrence,
-				//because the compiler will often put it there automatically.
-				//We *could* optimize this by removing it from the compiled code,
-				//and we still should do that, but this check is quick enough,
-				//and so can remain even once we do add the optimization to the
-				//compiler proper.
-				for(ParseTree child : tree.getChildren()) {
-					fakeScript.eval(child, env);
-				}
-			} else {
-				fakeScript.eval(tree, env);
-			}
-		} catch (FunctionReturnException e) {
-			// Normal exit
-			Mixed ret = e.getReturn();
-			if(returnType.equals(Auto.TYPE)) {
-				return ret;
-			}
-			if(returnType.equals(CVoid.TYPE) != ret.equals(CVoid.VOID)
-					|| !ret.equals(CNull.NULL) && !ret.equals(CVoid.VOID)
-					&& !InstanceofUtil.isInstanceof(ret.typeof(), returnType, env)) {
-				throw new CRECastException("Expected procedure \"" + name + "\" to return a value of type "
-						+ returnType.val() + " but a value of type " + ret.typeof() + " was returned instead",
-						ret.getTarget());
-			}
+		varList.set(new IVariable(CArray.TYPE, "@arguments", arguments, callTarget));
+		return env;
+	}
+
+	/**
+	 * Type-checks a return value against this procedure's declared return type.
+	 */
+	private Mixed typeCheckReturn(Mixed ret, Environment env) {
+		if(returnType.equals(Auto.TYPE)) {
 			return ret;
-		} catch (LoopManipulationException ex) {
-			// These cannot bubble up past procedure calls. This will eventually be
-			// a compile error.
-			throw ConfigRuntimeException.CreateUncatchableException("Loop manipulation operations (e.g. break() or continue()) cannot"
-					+ " bubble up past procedures.", t);
-		} catch (ConfigRuntimeException e) {
-			if(e instanceof AbstractCREException) {
-				((AbstractCREException) e).freezeStackTraceElements(stManager);
-			}
-			throw e;
-		} catch (StackOverflowError e) {
-			throw new CREStackOverflowError(null, t, e);
-		} finally {
-			stManager.popStackTraceElement();
 		}
-		// Normal exit, but no return.
-		// If we got here, then there was no return value. This is fine, but only for returnType void or auto.
-		// TODO: Once strong typing is implemented at a compiler level, this should be removed to increase runtime
-		// performance.
+		if(returnType.equals(CVoid.TYPE) != ret.equals(CVoid.VOID)
+				|| !ret.equals(CNull.NULL) && !ret.equals(CVoid.VOID)
+				&& !InstanceofUtil.isInstanceof(ret.typeof(env), returnType, env)) {
+			throw new CRECastException("Expected procedure \"" + name + "\" to return a value of type "
+					+ returnType.val() + " but a value of type " + ret.typeof(env) + " was returned instead",
+					ret.getTarget());
+		}
+		return ret;
+	}
+
+	/**
+	 * Checks that this procedure's return type allows a void return (no explicit return statement).
+	 */
+	private Mixed typeCheckVoidReturn() {
 		if(!(returnType.equals(Auto.TYPE) || returnType.equals(CVoid.TYPE))) {
-			throw new CRECastException("Expecting procedure \"" + name + "\" to return a value of type " + returnType.val() + ","
-					+ " but no value was returned.", tree.getTarget());
+			throw new CRECastException("Expecting procedure \"" + name + "\" to return a value of type "
+					+ returnType.val() + ", but no value was returned.", tree.getTarget());
 		}
 		return CVoid.VOID;
 	}
 
-	public Target getTarget() {
-		return definedAt;
+	/**
+	 * Creates a {@link FlowFunction} for this procedure call, for use with the iterative
+	 * interpreter. The flow function manages the procedure call lifecycle:
+	 * <ol>
+	 *   <li>Evaluates argument expressions (with IVariable resolution)</li>
+	 *   <li>Prepares the procedure environment (clones env, assigns parameters)</li>
+	 *   <li>Evaluates the procedure body in the new environment</li>
+	 *   <li>Handles Return (type-checks and completes), blocks Break/Continue</li>
+	 * </ol>
+	 *
+	 * @param callTarget The target of the procedure call site
+	 * @return A per-call FlowFunction for this procedure
+	 */
+	public FlowFunction<?> createProcedureFlow(Target callTarget) {
+		return new ProcedureFlow(callTarget);
 	}
 
-	@Override
-	public Procedure clone() throws CloneNotSupportedException {
-		Procedure clone = (Procedure) super.clone();
-		if(this.varList != null) {
-			clone.varList = new HashMap<>(this.varList);
+	/**
+	 * Per-call flow function for procedure execution in the iterative interpreter.
+	 * Manages the two-phase lifecycle: arg evaluation then body evaluation.
+	 * Since this is created per-call, it stores state in its own fields
+	 * rather than using the generic S type parameter.
+	 */
+	private class ProcedureFlow implements FlowFunction<Void> {
+		private final Target callTarget;
+		private final List<Mixed> evaluatedArgs = new ArrayList<>();
+		private ParseTree[] children;
+		private int argIndex = 0;
+		private boolean bodyStarted = false;
+		private Environment procEnv;
+
+		ProcedureFlow(Target callTarget) {
+			this.callTarget = callTarget;
 		}
-		if(this.tree != null) {
-			clone.tree = this.tree.clone();
+
+		@Override
+		public StepAction.StepResult<Void> begin(Target t, ParseTree[] children, Environment env) {
+			this.children = children;
+			if(children.length == 0) {
+				return new StepAction.StepResult<>(startBody(env), null);
+			}
+			return new StepAction.StepResult<>(new StepAction.Evaluate(children[0]), null);
 		}
-		return clone;
-	}
 
-	public void definitelyNotConstant() {
-		possiblyConstant = false;
+		@Override
+		public StepAction.StepResult<Void> childCompleted(Target t, Void state, Mixed result, Environment env) {
+			if(!bodyStarted) {
+				// Resolve IVariables (seval semantics for proc arguments)
+				Mixed resolved = result;
+				while(resolved instanceof IVariable cur) {
+					resolved = env.getEnv(GlobalEnv.class).GetVarList()
+							.get(cur.getVariableName(), cur.getTarget(), env).ival();
+				}
+				evaluatedArgs.add(resolved);
+				argIndex++;
+				if(argIndex < children.length) {
+					return new StepAction.StepResult<>(new StepAction.Evaluate(children[argIndex]), null);
+				}
+				return new StepAction.StepResult<>(startBody(env), null);
+			}
+			// Body completed normally (no explicit return)
+			return new StepAction.StepResult<>(new StepAction.Complete(typeCheckVoidReturn()), null);
+		}
+
+		@Override
+		public StepAction.StepResult<Void> childInterrupted(Target t, Void state,
+				StepAction.FlowControl action, Environment env) {
+			StepAction.FlowControlAction fca = action.getAction();
+			if(fca instanceof ControlFlow.ReturnAction ret) {
+				return new StepAction.StepResult<>(
+						new StepAction.Complete(typeCheckReturn(ret.getValue(), procEnv)), null);
+			}
+			if(fca instanceof ControlFlow.BreakAction || fca instanceof ControlFlow.ContinueAction) {
+				throw ConfigRuntimeException.CreateUncatchableException(
+						"Loop manipulation operations (e.g. break() or continue()) cannot"
+						+ " bubble up past procedures.", callTarget);
+			}
+			// Unknown flow control — propagate
+			return null;
+		}
+
+		@Override
+		public void cleanup(Target t, Void state, Environment env) {
+			popStackTrace();
+		}
+
+		private StepAction startBody(Environment callerEnv) {
+			bodyStarted = true;
+			procEnv = prepareEnvironment(evaluatedArgs, callerEnv, callTarget);
+			StackTraceManager stManager = procEnv.getEnv(GlobalEnv.class).GetStackTraceManager();
+			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().popStackTraceFrame();
+			}
+		}
 	}
 }
diff --git a/src/main/java/com/laytonsmith/core/Script.java b/src/main/java/com/laytonsmith/core/Script.java
index e57f6af57d..e8d6b8ea05 100644
--- a/src/main/java/com/laytonsmith/core/Script.java
+++ b/src/main/java/com/laytonsmith/core/Script.java
@@ -5,54 +5,58 @@
 import com.laytonsmith.PureUtilities.SimpleVersion;
 import com.laytonsmith.PureUtilities.SmartComment;
 import com.laytonsmith.PureUtilities.TermColors;
-import com.laytonsmith.abstraction.Implementation;
+import com.laytonsmith.PureUtilities.Version;
 import com.laytonsmith.abstraction.MCCommandSender;
 import com.laytonsmith.abstraction.MCPlayer;
-import com.laytonsmith.abstraction.StaticLayer;
 import com.laytonsmith.core.compiler.FileOptions;
 import com.laytonsmith.core.compiler.TokenStream;
 import com.laytonsmith.core.compiler.analysis.StaticAnalysis;
-import com.laytonsmith.core.constructs.CClosure;
+import com.laytonsmith.core.constructs.CClassType;
 import com.laytonsmith.core.constructs.CFunction;
 import com.laytonsmith.core.constructs.CString;
+import com.laytonsmith.core.constructs.CVoid;
 import com.laytonsmith.core.constructs.Command;
 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.InvalidEnvironmentException;
+import com.laytonsmith.core.environments.LivePausedState;
+import com.laytonsmith.core.environments.PausedState;
 import com.laytonsmith.core.environments.StaticRuntimeEnv;
-import com.laytonsmith.core.exceptions.CRE.AbstractCREException;
 import com.laytonsmith.core.exceptions.CRE.CREInsufficientPermissionException;
 import com.laytonsmith.core.exceptions.CRE.CREInvalidProcedureException;
-import com.laytonsmith.core.exceptions.CRE.CREStackOverflowError;
 import com.laytonsmith.core.exceptions.CancelCommandException;
 import com.laytonsmith.core.exceptions.ConfigCompileException;
 import com.laytonsmith.core.exceptions.ConfigCompileGroupException;
 import com.laytonsmith.core.exceptions.ConfigRuntimeException;
-import com.laytonsmith.core.exceptions.FunctionReturnException;
-import com.laytonsmith.core.exceptions.LoopBreakException;
-import com.laytonsmith.core.exceptions.LoopContinueException;
-import com.laytonsmith.core.exceptions.ProgramFlowManipulationException;
+import com.laytonsmith.core.exceptions.StackTraceFrame;
 import com.laytonsmith.core.exceptions.StackTraceManager;
-import com.laytonsmith.core.extensions.Extension;
-import com.laytonsmith.core.extensions.ExtensionManager;
-import com.laytonsmith.core.extensions.ExtensionTracker;
+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.functions.FunctionBase;
 import com.laytonsmith.core.natives.interfaces.Mixed;
-import com.laytonsmith.core.profiler.ProfilePoint;
-import com.laytonsmith.core.profiler.Profiler;
+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;
@@ -71,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;
 
@@ -227,15 +356,20 @@ public void run(final List<Variable> vars, Environment myEnv, final MethodScript
 				if(rootNode == null) {
 					continue;
 				}
-				for(Mixed tempNode : rootNode.getAllData()) {
-					if(tempNode instanceof Variable) {
-						if(leftVars == null) {
-							throw ConfigRuntimeException.CreateUncatchableException("$variables may not be used in this context."
-									+ " Only @variables may be.", tempNode.getTarget());
+				if(leftVars != null) {
+					IdentityHashMap<Mixed, String> dollarBindings = new IdentityHashMap<>();
+					for(Mixed tempNode : rootNode.getAllData()) {
+						if(tempNode instanceof Variable variable) {
+							Construct leftVar = leftVars.get(variable.getVariableName());
+							if(leftVar == null) {
+								throw ConfigRuntimeException.CreateUncatchableException("$variables may not be used in this context."
+										+ " Only @variables may be.", tempNode.getTarget());
+							}
+							Construct c = Static.resolveDollarVar(leftVar, vars);
+							dollarBindings.put(tempNode, c.toString());
 						}
-						Construct c = Static.resolveDollarVar(leftVars.get(((Variable) tempNode).getVariableName()), vars);
-						((Variable) tempNode).setVal(new CString(c.toString(), tempNode.getTarget()));
 					}
+					myEnv.getEnv(GlobalEnv.class).SetDollarVarBindings(dollarBindings);
 				}
 
 				myEnv.getEnv(StaticRuntimeEnv.class).getIncludeCache().executeAutoIncludes(myEnv, this);
@@ -247,25 +381,6 @@ public void run(final List<Variable> vars, Environment myEnv, final MethodScript
 		} catch (CancelCommandException e) {
 			//p.sendMessage(e.getMessage());
 			//The message in the exception is actually empty
-		} catch (LoopBreakException e) {
-			if(p != null) {
-				p.sendMessage("The break() function must be used inside a for() or foreach() loop");
-			}
-			StreamUtils.GetSystemOut().println("The break() function must be used inside a for() or foreach() loop");
-		} catch (LoopContinueException e) {
-			if(p != null) {
-				p.sendMessage("The continue() function must be used inside a for() or foreach() loop");
-			}
-			StreamUtils.GetSystemOut().println("The continue() function must be used inside a for() or foreach() loop");
-		} catch (FunctionReturnException e) {
-			if(myEnv.getEnv(GlobalEnv.class).GetEvent() != null) {
-				//Oh, we're running in an event handler. Those know how to catch it too.
-				throw e;
-			}
-			if(p != null) {
-				p.sendMessage("The return() function must be used inside a procedure.");
-			}
-			StreamUtils.GetSystemOut().println("The return() function must be used inside a procedure.");
 		} catch (Throwable t) {
 			StreamUtils.GetSystemOut().println("An unexpected exception occurred during the execution of a script.");
 			t.printStackTrace();
@@ -295,267 +410,419 @@ public Mixed seval(ParseTree c, final Environment env) {
 	}
 
 	/**
-	 * Given the parse tree and environment, executes the tree.
+	 * Iterative interpreter loop. Evaluates a parse tree using an explicit stack instead of
+	 * recursive Java calls. This enables:
+	 * <ul>
+	 *   <li>Control flow (break/continue/return) as first-class FlowControl actions, not exceptions</li>
+	 *   <li>Save/restore of execution state (for debugger, async/await)</li>
+	 *   <li>1:1 MethodScript-to-stack-frame mapping</li>
+	 * </ul>
 	 *
-	 * @param c
-	 * @param env
-	 * @return
-	 * @throws CancelCommandException
+	 * <p>Two execution paths exist for function calls:</p>
+	 * <ol>
+	 *   <li><b>FlowFunction</b> — Function implements {@link FlowFunction}. The loop drives it
+	 *       via begin/childCompleted/childInterrupted. (This replaces the old execs mechanism.)</li>
+	 *   <li><b>Simple exec</b> — Normal functions. Children are evaluated left-to-right,
+	 *       then {@code exec()} is called with the results.</li>
+	 * </ol>
+	 *
+	 * @param root The parse tree to evaluate
+	 * @param env The environment
+	 * @return The result of evaluation
 	 */
-	@SuppressWarnings("UseSpecificCatch")
-	public Mixed eval(ParseTree c, final Environment env) throws CancelCommandException {
-		GlobalEnv globalEnv = env.getEnv(GlobalEnv.class);
-		if(globalEnv.IsInterrupted()) {
-			//First things first, if we're interrupted, kill the script unconditionally.
-			throw new CancelCommandException("", Target.UNKNOWN);
+	private Mixed iterativeEval(ParseTree root, Environment env) {
+		EvalStack stack = new EvalStack();
+		stack.push(new StackFrame(root, env, null, 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;
+	}
 
-		final Mixed m = c.getData();
-		if(m instanceof Construct co) {
-			if(co.getCType() != ConstructType.FUNCTION) {
-				if(co.getCType() == ConstructType.VARIABLE) {
-					return new CString(m.val(), m.getTarget());
-				} else {
-					return m;
-				}
-			}
+	/**
+	 * 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();
 		}
-
-		final CFunction possibleFunction;
-		try {
-			possibleFunction = (CFunction) m;
-		} catch (ClassCastException e) {
-			throw ConfigRuntimeException.CreateUncatchableException("Expected to find CFunction at runtime but found: "
-					+ m.val(), m.getTarget());
+		// 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;
+	}
 
-		StackTraceManager stManager = globalEnv.GetStackTraceManager();
-		boolean addedRootStackElement = false;
-		try {
-			// If it's an unknown target, this is not user generated code, and we want to skip adding the element here.
-			if(stManager.isStackEmpty() && m.getTarget() != Target.UNKNOWN) {
-				stManager.addStackTraceElement(new ConfigRuntimeException.StackTraceElement("<<main code>>", m.getTarget()));
-				addedRootStackElement = true;
-			}
-			stManager.setCurrentTarget(c.getTarget());
-			globalEnv.SetScript(this);
-
-			if(possibleFunction.hasProcedure()) {
-				//Not really a function, so we can't put it in Function.
-				Procedure p = globalEnv.GetProcs().get(m.val());
-				if(p == null) {
-					throw new CREInvalidProcedureException("Unknown procedure \"" + m.val() + "\"", m.getTarget());
-				}
-				ProfilePoint pp = null;
-				Profiler profiler = env.getEnv(StaticRuntimeEnv.class).GetProfiler();
-				if(profiler.isLoggable(LogLevel.INFO)) {
-					pp = profiler.start(m.val() + " execution", LogLevel.INFO);
-				}
-				Mixed ret;
-				try {
-					if(debugOutput) {
-						doDebugOutput(p.getName(), c.getChildren());
+	@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);
+
+			if(gEnv.IsInterrupted()) {
+				throw new CancelCommandException("", Target.UNKNOWN);
+			}
+
+			// Propagate pending flow control
+			StackFrame frame = stack.peek();
+			if(pendingFlowControl != null) {
+				if(frame.hasFlowFunction() && frame.hasBegun()) {
+					Target t = frame.getNode().getTarget();
+					StepAction.StepResult<?> response =
+							((FlowFunction<Object>) frame.getFlowFunction()).childInterrupted(
+							t, frame.getFunctionState(), pendingFlowControl, frame.getEnv());
+					if(response != null) {
+						pendingFlowControl = null;
+						frame.setFunctionState(response.getState());
+						StepAction action = response.getAction();
+						if(action instanceof StepAction.Evaluate e) {
+							frame.setKeepIVariable(e.keepIVariable());
+							Environment evalEnv = e.getEnv() != null ? e.getEnv() : frame.getEnv();
+							stack.push(new StackFrame(e.getNode(), evalEnv, null, null));
+						} else if(action instanceof StepAction.Complete c) {
+							lastResult = c.getResult();
+							hasResult = true;
+							cleanupAndPop(stack, frame);
+						} else if(action instanceof StepAction.FlowControl fc) {
+							pendingFlowControl = fc;
+							cleanupAndPop(stack, frame);
+						}
+						continue;
 					}
-					ret = p.cexecute(c.getChildren(), env, m.getTarget());
-				} finally {
-					if(pp != null) {
-						pp.stop();
+				}
+				cleanupAndPop(stack, frame);
+				if(stack.isEmpty()) {
+					if(pendingFlowControl.getAction()
+							instanceof ControlFlow.ReturnAction ret) {
+						return ret.getValue();
+					}
+					if(pendingFlowControl.getAction()
+							instanceof Exceptions.ThrowAction ta) {
+						throw ta.getException();
 					}
+					throw new UnhandledFlowControlException(pendingFlowControl.getAction());
 				}
-				return ret;
+				continue;
 			}
 
-			final Function f;
-			try {
-				f = possibleFunction.getFunction();
-			} catch (ConfigCompileException e) {
-				//Turn it into a config runtime exception. This shouldn't ever happen though.
-				throw ConfigRuntimeException.CreateUncatchableException("Unable to find function at runtime: "
-						+ m.val(), m.getTarget());
+			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;
+					}
+				}
 			}
 
-			globalEnv.SetFileOptions(c.getFileOptions());
-
-			Mixed[] args = new Mixed[c.numberOfChildren()];
-			try {
-				if(f.isRestricted() && !Static.hasCHPermission(f.getName(), env)) {
-					throw new CREInsufficientPermissionException("You do not have permission to use the "
-							+ f.getName() + " function.", m.getTarget());
+			// Literal / variable nodes (no children)
+			if(data instanceof Construct co && co.getCType() != Construct.ConstructType.FUNCTION
+					&& node.numberOfChildren() == 0) {
+				if(co.getCType() == Construct.ConstructType.VARIABLE) {
+					String val = gEnv.GetDollarVarBinding(data);
+					if(val == null) {
+						val = "";
+					}
+					lastResult = new CString(val, data.getTarget());
+				} else {
+					lastResult = data;
 				}
+				hasResult = true;
+				stack.pop();
+				continue;
+			}
 
-				if(debugOutput) {
-					doDebugOutput(f.getName(), c.getChildren());
-				}
-				if(f.useSpecialExec()) {
-					ProfilePoint p = null;
-					if(f.shouldProfile()) {
-						Profiler profiler = env.getEnv(StaticRuntimeEnv.class).GetProfiler();
-						if(profiler.isLoggable(f.profileAt())) {
-							p = profiler.start(f.profileMessageS(c.getChildren()), f.profileAt());
+			// Sequence nodes (non-function with children, e.g. root node) skip
+			// function resolution and use simple exec with function=null
+			if(data instanceof CFunction cfunc) {
+				// First visit: resolve function or procedure
+				if(frame.getFunction() == null && !frame.hasFlowFunction()) {
+					if(cfunc.hasProcedure()) {
+						Procedure p = frame.getEnv().getEnv(GlobalEnv.class)
+								.GetProcs().get(data.val());
+						if(p == null) {
+							throw new CREInvalidProcedureException(
+									"Unknown procedure \"" + data.val() + "\"", data.getTarget());
 						}
+						FlowFunction<?> procedureFlow = p.createProcedureFlow(data.getTarget());
+						stack.pop();
+						stack.push(new StackFrame(node, frame.getEnv(), null, procedureFlow));
+						hasResult = false;
+						continue;
 					}
-					Mixed ret;
-					try {
-						ret = f.execs(m.getTarget(), env, this, c.getChildren().toArray(new ParseTree[args.length]));
-					} finally {
-						if(p != null) {
-							p.stop();
+
+					Function f = cfunc.getCachedFunction();
+					if(f == null) {
+						try {
+							f = cfunc.getFunction();
+						} catch(ConfigCompileException ex) {
+							throw ConfigRuntimeException.CreateUncatchableException(
+									"Unknown function \"" + cfunc.val() + "\"", cfunc.getTarget());
 						}
 					}
-					return ret;
-				}
 
-				for(int i = 0; i < args.length; i++) {
-					args[i] = eval(c.getChildAt(i), env);
-					while(f.preResolveVariables() && args[i] instanceof IVariable cur) {
-						args[i] = globalEnv.GetVarList().get(cur.getVariableName(), cur.getTarget(), env).ival();
-					}
+					FlowFunction<?> flowFunction = (f instanceof FlowFunction<?>) ? (FlowFunction<?>) f : null;
+
+					stack.pop();
+					StackFrame newFrame = new StackFrame(node, frame.getEnv(), f, flowFunction);
+					stack.push(newFrame);
+					frame = newFrame;
+					hasResult = false;
 				}
+			}
 
-				// Reset stacktrace manager to current function (argument evaluation might have changed this).
-				stManager.setCurrentTarget(c.getTarget());
+			Function f = frame.getFunction();
 
-				{
-					//It takes a moment to generate the toString of some things, so lets not do it
-					//if we actually aren't going to profile
-					ProfilePoint p = null;
-					if(f.shouldProfile()) {
-						Profiler profiler = env.getEnv(StaticRuntimeEnv.class).GetProfiler();
-						if(profiler.isLoggable(f.profileAt())) {
-							p = profiler.start(f.profileMessage(args), f.profileAt());
-						}
-					}
-					Mixed ret;
-					try {
-						ret = f.exec(m.getTarget(), env, args);
-					} finally {
-						if(p != null) {
-							p.stop();
-						}
-					}
-					return ret;
-				}
-				//We want to catch and rethrow the ones we know how to catch, and then
-				//catch and report anything else.
-			} catch (ConfigRuntimeException | ProgramFlowManipulationException e) {
-				if(e instanceof AbstractCREException) {
-					((AbstractCREException) e).freezeStackTraceElements(stManager);
-				}
-				throw e;
-			} catch (InvalidEnvironmentException e) {
-				if(!e.isDataSet()) {
-					e.setData(f.getName());
-				}
-				throw e;
-			} catch (StackOverflowError e) {
-				// This handles this in all cases that weren't previously considered. But it still should
-				// be individually handled by other cases to ensure that the stack trace is more correct
-				throw new CREStackOverflowError(null, c.getTarget(), e);
-			} catch (Throwable e) {
-				if(e instanceof ThreadDeath) {
-					// Bail quickly in this case
-					throw e;
-				}
-				String brand = Implementation.GetServerType().getBranding();
-				SimpleVersion version;
+			// Permission check on first visit
+			if(!frame.hasBegun() && f != null && f.isRestricted()
+					&& !Static.hasCHPermission(f.getName(), frame.getEnv())) {
+				throw new CREInsufficientPermissionException(
+						"You do not have permission to use the " + f.getName() + " function.",
+						data.getTarget());
+			}
 
-				try {
-					version = Static.getVersion();
-				} catch (Throwable ex) {
-					// This failing should not be a dealbreaker, so fill it with default data
-					version = GARBAGE_VERSION;
-				}
-
-				String culprit = brand;
-				outer:
-				for(ExtensionTracker tracker : ExtensionManager.getTrackers().values()) {
-					for(FunctionBase b : tracker.getFunctions()) {
-						if(b.getName().equals(f.getName())) {
-							//This extension provided the function, so its the culprit. Report this
-							//name instead of the core plugin's name.
-							for(Extension extension : tracker.getExtensions()) {
-								culprit = extension.getName();
-								break outer;
-							}
+			// Flow function mode
+			if(frame.hasFlowFunction()) {
+				Target t = node.getTarget();
+				StepAction.StepResult<?> result;
+				if(!frame.hasBegun()) {
+					frame.markBegun();
+					result = ((FlowFunction<Object>) frame.getFlowFunction()).begin(
+							t, frame.getChildren(), frame.getEnv());
+				} else if(hasResult) {
+					// Resolve IVariables unless the parent explicitly asked to keep them
+					if(!frame.keepIVariable()) {
+						while(lastResult instanceof IVariable cur) {
+							GlobalEnv frameGEnv = frame.getEnv().getEnv(GlobalEnv.class);
+							lastResult = frameGEnv.GetVarList()
+									.get(cur.getVariableName(), cur.getTarget(),
+											frame.getEnv()).ival();
 						}
 					}
+					frame.setKeepIVariable(false);
+					result = ((FlowFunction<Object>) frame.getFlowFunction()).childCompleted(
+							t, frame.getFunctionState(), lastResult, frame.getEnv());
+					hasResult = false;
+				} else {
+					throw ConfigRuntimeException.CreateUncatchableException(
+							"Flow function in invalid state for " + data.val(), data.getTarget());
 				}
 
-				String emsg = TermColors.RED + "Uh oh! You've found an error in " + TermColors.CYAN + culprit + TermColors.RED + ".\n"
-						+ "This happened while running your code, so you may be able to find a workaround,"
-						+ (!(e instanceof Exception) ? " (though since this is an Error, maybe not)" : "")
-						+ " but is ultimately an issue in " + culprit + ".\n"
-						+ "The following code caused the error:\n" + TermColors.WHITE;
-
-				List<String> args2 = new ArrayList<>();
-				Map<String, String> vars = new HashMap<>();
-				for(int i = 0; i < args.length; i++) {
-					Mixed cc = args[i];
-					if(c.getChildAt(i).getData() instanceof IVariable ivar) {
-						String vval = cc.val();
-						if(cc instanceof CString) {
-							vval = ((CString) cc).getQuote();
+				frame.setFunctionState(result.getState());
+				StepAction action = result.getAction();
+				if(action instanceof StepAction.Evaluate e) {
+					frame.setKeepIVariable(e.keepIVariable());
+					Environment evalEnv = e.getEnv() != null ? e.getEnv() : frame.getEnv();
+					stack.push(new StackFrame(e.getNode(), evalEnv, null, null));
+				} else if(action instanceof StepAction.Complete c) {
+					lastResult = c.getResult();
+					hasResult = true;
+					cleanupAndPop(stack, frame);
+				} 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;
 						}
-						vars.put(ivar.getVariableName(), vval);
-						args2.add(ivar.getVariableName());
-					} else if(cc == null) {
-						args2.add("java-null");
-					} else if(cc instanceof CString) {
-						args2.add(new CString(cc.val(), Target.UNKNOWN).getQuote());
-					} else if(cc instanceof CClosure) {
-						args2.add("<closure>");
-					} else {
-						args2.add(cc.val());
 					}
 				}
-				if(!vars.isEmpty()) {
-					emsg += StringUtils.Join(vars, " = ", "\n") + "\n";
-				}
-				emsg += f.getName() + "(";
-				emsg += StringUtils.Join(args2, ", ");
-				emsg += ")\n";
-
-				emsg += TermColors.RED + "on or around "
-						+ TermColors.YELLOW + m.getTarget().file() + TermColors.WHITE + ":" + TermColors.CYAN
-						+ m.getTarget().line() + TermColors.RED + ".\n";
+				continue;
+			}
 
-				//Server might not be available in this platform, so let's be sure to ignore those exceptions
-				String modVersion;
-				try {
-					modVersion = StaticLayer.GetConvertor().GetServer().getAPIVersion();
-				} catch (Exception ex) {
-					modVersion = Implementation.GetServerType().name();
+			// Simple exec mode
+			if(hasResult) {
+				Mixed arg = lastResult;
+				while(f != null && f.preResolveVariables() && arg instanceof IVariable cur) {
+					GlobalEnv frameGEnv = frame.getEnv().getEnv(GlobalEnv.class);
+					arg = frameGEnv.GetVarList().get(cur.getVariableName(), cur.getTarget(),
+							frame.getEnv()).ival();
 				}
+				frame.addArg(arg);
+				hasResult = false;
+			}
 
-				String extensionData = "";
-				for(ExtensionTracker tracker : ExtensionManager.getTrackers().values()) {
-					for(Extension extension : tracker.getExtensions()) {
-						try {
-							extensionData += TermColors.CYAN + extension.getName() + TermColors.RED
-									+ " (" + TermColors.RESET + extension.getVersion() + TermColors.RED + ")\n";
-						} catch (AbstractMethodError ex) {
-							// This happens with an old style extensions. Just skip it.
-							extensionData += TermColors.CYAN + "Unknown Extension" + TermColors.RED + "\n";
+			if(frame.hasMoreChildren()) {
+				if(!frame.hasBegun()) {
+					frame.markBegun();
+				}
+				stack.push(new StackFrame(frame.nextChild(), frame.getEnv(), null, null));
+			} else {
+				if(!frame.hasBegun()) {
+					frame.markBegun();
+				}
+				if(f == null) {
+					// Sequence node — return last child's result
+					Mixed[] args = frame.getArgs();
+					lastResult = args.length > 0 ? args[args.length - 1] : CVoid.VOID;
+					hasResult = true;
+					stack.pop();
+				} else {
+					try {
+						lastResult = Function.ExecuteFunction(f, data.getTarget(),
+								frame.getEnv(), frame.getArgs());
+						hasResult = true;
+						stack.pop();
+					} catch(ConfigRuntimeException e) {
+						// Convert MethodScript exceptions to FlowControl(ThrowAction)
+						stack.pop();
+						pendingFlowControl = new StepAction.FlowControl(
+								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;
+							}
 						}
 					}
 				}
-				if(extensionData.isEmpty()) {
-					extensionData = "NONE\n";
-				}
+			}
+		}
+
+		return lastResult;
+	}
+
+	/**
+	 * Calls {@link FlowFunction#cleanup} if the frame has a FlowFunction that has begun,
+	 * then pops the frame from the stack.
+	 */
+	@SuppressWarnings("unchecked")
+	private static void cleanupAndPop(EvalStack stack, StackFrame frame) {
+		if(frame.hasFlowFunction() && frame.hasBegun()) {
+			((FlowFunction<Object>) frame.getFlowFunction()).cleanup(
+					frame.getNode().getTarget(), frame.getFunctionState(), frame.getEnv());
+		}
+		stack.pop();
+	}
 
-				emsg += "Please report this to the developers, and be sure to include the version numbers:\n"
-						+ TermColors.CYAN + "Server" + TermColors.RED + " version: " + TermColors.RESET + modVersion + TermColors.RED + ";\n"
-						+ TermColors.CYAN + brand + TermColors.RED + " version: " + TermColors.RESET + version + TermColors.RED + ";\n"
-						+ "Loaded extensions and versions:\n" + extensionData
-						+ "Here's the stacktrace:\n" + TermColors.RESET + Static.GetStacktraceString(e);
-				StreamUtils.GetSystemErr().println(emsg);
-				throw new CancelCommandException(null, Target.UNKNOWN);
+	/**
+	 * 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();
 			}
-		} finally {
-			if(addedRootStackElement && stManager.isStackSingle()) {
-				stManager.popStackTraceElement();
+			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.
+	 *
+	 * @param c
+	 * @param env
+	 * @return
+	 * @throws CancelCommandException
+	 */
+	public Mixed eval(ParseTree c, final Environment env) throws CancelCommandException {
+		return iterativeEval(c, env);
 	}
 
 	private void doDebugOutput(String nodeName, List<ParseTree> children) {
@@ -1008,4 +1275,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/StackFrame.java b/src/main/java/com/laytonsmith/core/StackFrame.java
new file mode 100644
index 0000000000..09d952c7d3
--- /dev/null
+++ b/src/main/java/com/laytonsmith/core/StackFrame.java
@@ -0,0 +1,213 @@
+package com.laytonsmith.core;
+
+import com.laytonsmith.core.constructs.IVariable;
+import com.laytonsmith.core.constructs.Target;
+import com.laytonsmith.core.natives.interfaces.Mixed;
+import com.laytonsmith.core.environments.Environment;
+import com.laytonsmith.core.functions.Function;
+
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * Represents one frame on the interpreter's explicit evaluation stack. Each frame corresponds
+ * to a function call or node being evaluated.
+ *
+ * <p>There are two modes:</p>
+ * <ul>
+ *   <li><b>Simple mode</b> ({@code flowFunction == null}): The interpreter evaluates children
+ *       left-to-right, accumulates results in {@code args}, then calls {@code exec()}.
+ *       This is used for normal (non-special-exec) functions.</li>
+ *   <li><b>Flow function mode</b> ({@code flowFunction != null}): The interpreter delegates to the
+ *       {@link FlowFunction} to decide which children to evaluate and when.
+ *       This is used for control flow functions (if, for, and, try, etc.).</li>
+ * </ul>
+ */
+public class StackFrame {
+
+	private final ParseTree node;
+	private final Environment env;
+	private final Function function;
+	private final FlowFunction<?> flowFunction;
+	private final List<Mixed> args;
+	private int childIndex;
+	private boolean begun;
+	private Object functionState;
+	private boolean keepIVariable;
+
+	/**
+	 * Creates a stack frame for evaluating the given node.
+	 *
+	 * @param node The parse tree node being evaluated
+	 * @param env The environment at this frame's scope
+	 * @param function The function being called (may be null for literal nodes or procedure calls)
+	 * @param flowFunction The flow function for special-exec functions (null for simple exec)
+	 */
+	public StackFrame(ParseTree node, Environment env, Function function, FlowFunction<?> flowFunction) {
+		this.node = node;
+		this.env = env;
+		this.function = function;
+		this.flowFunction = flowFunction;
+		this.args = new ArrayList<>();
+		this.childIndex = 0;
+		this.begun = false;
+		this.functionState = null;
+	}
+
+	/**
+	 * Returns the parse tree node this frame is evaluating.
+	 */
+	public ParseTree getNode() {
+		return node;
+	}
+
+	/**
+	 * Returns the environment at this frame's scope.
+	 */
+	public Environment getEnv() {
+		return env;
+	}
+
+	/**
+	 * Returns the function being called, or null for literal nodes or procedure calls.
+	 */
+	public Function getFunction() {
+		return function;
+	}
+
+	/**
+	 * Returns the flow functionr for special-exec functions, or null for simple exec.
+	 */
+	public FlowFunction<?> getFlowFunction() {
+		return flowFunction;
+	}
+
+	/**
+	 * Returns whether this frame uses a flow function (special-exec) or simple child evaluation.
+	 */
+	public boolean hasFlowFunction() {
+		return flowFunction != null;
+	}
+
+	/**
+	 * Returns the per-call flow function state. The interpreter stores this opaquely and
+	 * passes it back to flow function methods via unchecked cast to the flow function's type parameter.
+	 */
+	public Object getFunctionState() {
+		return functionState;
+	}
+
+	/**
+	 * Sets the per-call flow function state.
+	 */
+	public void setFunctionState(Object state) {
+		this.functionState = state;
+	}
+
+	/**
+	 * Sets whether the next child result should keep IVariable as-is (not resolve to value).
+	 */
+	public void setKeepIVariable(boolean keepIVariable) {
+		this.keepIVariable = keepIVariable;
+	}
+
+	/**
+	 * Returns true if the next child result should keep IVariable as-is.
+	 */
+	public boolean keepIVariable() {
+		return keepIVariable;
+	}
+
+	/**
+	 * Returns the children of the parse tree node as an array.
+	 */
+	public ParseTree[] getChildren() {
+		List<ParseTree> children = node.getChildren();
+		return children.toArray(new ParseTree[0]);
+	}
+
+	/**
+	 * Returns the number of children of this node.
+	 */
+	public int getChildCount() {
+		return node.numberOfChildren();
+	}
+
+	/**
+	 * Returns the next child index to evaluate (for simple mode).
+	 */
+	public int getChildIndex() {
+		return childIndex;
+	}
+
+	/**
+	 * Returns true if there are more children to evaluate (for simple mode).
+	 */
+	public boolean hasMoreChildren() {
+		return childIndex < getChildCount();
+	}
+
+	/**
+	 * Returns the next child to evaluate and advances the index (for simple mode).
+	 */
+	public ParseTree nextChild() {
+		return node.getChildAt(childIndex++);
+	}
+
+	/**
+	 * Adds an evaluated child result to the args list (for simple mode).
+	 */
+	public void addArg(Mixed result) {
+		args.add(result);
+	}
+
+	/**
+	 * Returns the accumulated evaluated arguments (for simple mode).
+	 */
+	public Mixed[] getArgs() {
+		return args.toArray(new Mixed[0]);
+	}
+
+	/**
+	 * Returns whether begin() has been called on the flow function yet.
+	 */
+	public boolean hasBegun() {
+		return begun;
+	}
+
+	/**
+	 * Marks this frame's flow function as having been started.
+	 */
+	public void markBegun() {
+		this.begun = true;
+	}
+
+	@Override
+	public String toString() {
+		String name;
+		if(function != null) {
+			name = function.getName();
+		} else if(node.getData() instanceof IVariable iv) {
+			name = iv.getVariableName();
+		} else {
+			name = node.getData().val();
+		}
+		Target t = node.getTarget();
+		String location = t.file() + ":" + t.line() + "." + t.col();
+		String mode = flowFunction != null ? "flow" : "simple";
+		String state = begun ? "begun" : "pending";
+		String detail;
+		if(flowFunction != null) {
+			String stateStr = functionState != null ? functionState.toString() : "null";
+			detail = ", state=" + stateStr;
+		} else {
+			detail = ", child " + childIndex + "/" + getChildCount();
+		}
+		String inner = name + ":" + location + " (" + mode + ", " + state + detail + ")";
+		// Proc calls are user-visible stack frames
+		if(function == null && flowFunction != null) {
+			return "[" + inner + "]";
+		}
+		return inner;
+	}
+}
diff --git a/src/main/java/com/laytonsmith/core/Static.java b/src/main/java/com/laytonsmith/core/Static.java
index e07f9c7278..c6d0936d06 100644
--- a/src/main/java/com/laytonsmith/core/Static.java
+++ b/src/main/java/com/laytonsmith/core/Static.java
@@ -43,6 +43,7 @@
 import com.laytonsmith.core.constructs.CString;
 import com.laytonsmith.core.constructs.CVoid;
 import com.laytonsmith.core.constructs.Construct;
+import com.laytonsmith.core.constructs.InstanceofUtil;
 import com.laytonsmith.core.constructs.NativeTypeList;
 import com.laytonsmith.core.constructs.Target;
 import com.laytonsmith.core.constructs.Variable;
@@ -829,8 +830,24 @@ public static UUID GetUUID(Mixed subject, Target t) {
 		return GetUUID(subject.val(), t);
 	}
 
+	/**
+	 * @deprecated Use {@link #GetUser(Mixed, Target, Environment)} instead.
+	 */
+	@Deprecated
 	public static MCOfflinePlayer GetUser(Mixed search, Target t) {
-		return GetUser(search.val(), t);
+		return GetUser(search.val(), t, null);
+	}
+
+	public static MCOfflinePlayer GetUser(Mixed search, Target t, Environment env) {
+		return GetUser(search.val(), t, env);
+	}
+
+	/**
+	 * @deprecated Use {@link #GetUser(String, Target, Environment)} instead.
+	 */
+	@Deprecated
+	public static MCOfflinePlayer GetUser(String search, Target t) {
+		return GetUser(search, t, null);
 	}
 
 	/**
@@ -840,9 +857,10 @@ public static MCOfflinePlayer GetUser(Mixed search, Target t) {
 	 *
 	 * @param search The text to be searched, can be between 1 and 16 characters, or 32 or 36 characters
 	 * @param t
+	 * @param env
 	 * @return
 	 */
-	public static MCOfflinePlayer GetUser(String search, Target t) {
+	public static MCOfflinePlayer GetUser(String search, Target t, Environment env) {
 		MCOfflinePlayer ofp;
 		if(search.length() > 0 && search.length() <= 16) {
 			if(CONSOLE_NAME.equals(search)) {
@@ -854,7 +872,7 @@ public static MCOfflinePlayer GetUser(String search, Target t) {
 			try {
 				ofp = getServer().getOfflinePlayer(GetUUID(search, t));
 			} catch(ConfigRuntimeException cre) {
-				if(cre instanceof CREThrowable && ((CREThrowable) cre).isInstanceOf(CRELengthException.TYPE)) {
+				if(cre instanceof CREThrowable && ((CREThrowable) cre).isInstanceOf(CRELengthException.TYPE, null, env)) {
 					throw new CRELengthException("The given string was the wrong size to identify a player."
 							+ " A player name is expected to be between 1 and 16 characters. " + cre.getMessage(), t);
 				} else {
@@ -875,7 +893,26 @@ public static MCOfflinePlayer GetUser(String search, Target t) {
 	 * @return
 	 * @throws ConfigRuntimeException
 	 */
+	/**
+	 * @deprecated Use {@link #GetPlayer(String, Target, Environment)} instead.
+	 */
+	@Deprecated
 	public static MCPlayer GetPlayer(String player, Target t) throws ConfigRuntimeException {
+		return GetPlayer(player, t, null);
+	}
+
+	/**
+	 * Returns the player specified by name or UUID. Injected players are also returned in this list. If provided a string
+	 * between 1 and 16 characters, the lookup will be name-based. If provided a string that is 32 or 36 characters, the
+	 * lookup will be UUID-based. Throws CREPlayerOfflineException if the player is not online.
+	 *
+	 * @param player
+	 * @param t
+	 * @param env
+	 * @return
+	 * @throws ConfigRuntimeException
+	 */
+	public static MCPlayer GetPlayer(String player, Target t, Environment env) throws ConfigRuntimeException {
 		if(player == null) {
 			throw new CREPlayerOfflineException("No player was specified!", t);
 		}
@@ -897,7 +934,7 @@ public static MCPlayer GetPlayer(String player, Target t) throws ConfigRuntimeEx
 					throw new CREPlayerOfflineException("The specified player (" + player + ") is not online", t);
 				}
 			} catch(CREThrowable ex) {
-				if(ex.isInstanceOf(CRELengthException.TYPE)) {
+				if(ex.isInstanceOf(CRELengthException.TYPE, null, env)) {
 					throw new CRELengthException("The given string was the wrong size to identify a player."
 							+ " A player name is expected to be between 1 and 16 characters. " + ex.getMessage(), t);
 				} else {
@@ -908,8 +945,16 @@ public static MCPlayer GetPlayer(String player, Target t) throws ConfigRuntimeEx
 		return p;
 	}
 
+	/**
+	 * @deprecated Use {@link #GetPlayer(Mixed, Target, Environment)} instead.
+	 */
+	@Deprecated
 	public static MCPlayer GetPlayer(Mixed player, Target t) throws ConfigRuntimeException {
-		return GetPlayer(player.val(), t);
+		return GetPlayer(player.val(), t, null);
+	}
+
+	public static MCPlayer GetPlayer(Mixed player, Target t, Environment env) throws ConfigRuntimeException {
+		return GetPlayer(player.val(), t, env);
 	}
 
 	/**
@@ -939,12 +984,12 @@ public static MCCommandSender GetCommandSender(String name, Target t) throws Con
 	/**
 	 * If the sender is a player, it is returned, otherwise a ConfigRuntimeException is thrown.
 	 *
-	 * @param environment
+	 * @param env
 	 * @param t
 	 * @return
 	 */
-	public static MCPlayer getPlayer(Environment environment, Target t) {
-		MCPlayer player = environment.getEnv(CommandHelperEnvironment.class).GetPlayer();
+	public static MCPlayer getPlayer(Environment env, Target t) {
+		MCPlayer player = env.getEnv(CommandHelperEnvironment.class).GetPlayer();
 		if(player != null) {
 			return player;
 		} else {
@@ -1473,16 +1518,22 @@ public static File GetFileFromArgument(String arg, Environment env, Target t, Fi
 	 * Returns true if currently running in cmdline mode. If the environment is null, or the GlobalEnv is not available,
 	 * then defaultValue is returned.
 	 *
-	 * @param environment
+	 * @param env
 	 * @param defaultValue What should be returned if the environment is null or GlobalEnv is not present. (Happens
 	 * during compile time.)
 	 * @return
 	 */
-	public static boolean InCmdLine(Environment environment, boolean defaultValue) {
-		if(environment == null || !environment.hasEnv(GlobalEnv.class)) {
+	public static boolean InCmdLine(Environment env, boolean defaultValue) {
+		if(env == null || !env.hasEnv(GlobalEnv.class)) {
 			return defaultValue;
 		}
-		return environment.getEnv(GlobalEnv.class).inCmdlineMode();
+		return env.getEnv(GlobalEnv.class).inCmdlineMode();
+	}
+
+	/** @deprecated Use {@link #AssertType(Class, Mixed[], int, Function, Target, Environment)} instead. */
+	@Deprecated
+	public static <T extends Mixed> T AssertType(Class<T> type, Mixed[] args, int argNumber, Function func, Target t) {
+		return AssertType(type, args, argNumber, func, t, null);
 	}
 
 	/**
@@ -1497,15 +1548,16 @@ public static boolean InCmdLine(Environment environment, boolean defaultValue) {
 	 * @param args The array of arguments.
 	 * @param argNumber The argument number, used both for grabbing the correct argument from args, and building the
 	 * error message if the cast cannot occur.
-	 * @param func The function, in case this errors out, to build the error message.
+	 * @param func The function, in case this errors out,
+	 * @param envto build the error message.
 	 * @param t The code target
 	 * @return The value, cast to the desired type.
 	 */
-	public static <T extends Mixed> T AssertType(Class<T> type, Mixed[] args, int argNumber, Function func, Target t) {
+	public static <T extends Mixed> T AssertType(Class<T> type, Mixed[] args, int argNumber, Function func, Target t, Environment env) {
 		Mixed value = args[argNumber];
 		if(!type.isAssignableFrom(value.getClass())) {
 			typeof todesired = ClassDiscovery.GetClassAnnotation(type, typeof.class);
-			CClassType toactual = value.typeof();
+			CClassType toactual = value.typeof(env);
 			if(todesired != null) {
 				throw new CRECastException("Argument " + (argNumber + 1) + " of " + func.getName() + " was expected to be a "
 						+ todesired.value() + ", but " + toactual + " \"" + value.val() + "\" was found.", t);
@@ -1562,7 +1614,7 @@ public String getString(CResource res) {
 			boolean[] array = (boolean[]) object;
 			CArray r = new CArray(t);
 			for(boolean b : array) {
-				r.push(CBoolean.get(b), t);
+				r.push(CBoolean.get(b), t, null);
 			}
 			return r;
 		} else if(object instanceof byte[]) {
@@ -1578,51 +1630,51 @@ public String getString(CResource res) {
 			short[] array = (short[]) object;
 			CArray r = new CArray(t);
 			for(short s : array) {
-				r.push(new CInt(s, t), t);
+				r.push(new CInt(s, t), t, null);
 			}
 			return r;
 		} else if(object instanceof int[]) {
 			int[] array = (int[]) object;
 			CArray r = new CArray(t);
 			for(int i : array) {
-				r.push(new CInt(i, t), t);
+				r.push(new CInt(i, t), t, null);
 			}
 			return r;
 		} else if(object instanceof long[]) {
 			long[] array = (long[]) object;
 			CArray r = new CArray(t);
 			for(long l : array) {
-				r.push(new CInt(l, t), t);
+				r.push(new CInt(l, t), t, null);
 			}
 			return r;
 		} else if(object instanceof float[]) {
 			float[] array = (float[]) object;
 			CArray r = new CArray(t);
 			for(float f : array) {
-				r.push(new CDouble(f, t), t);
+				r.push(new CDouble(f, t), t, null);
 			}
 			return r;
 		} else if(object instanceof double[]) {
 			double[] array = (double[]) object;
 			CArray r = new CArray(t);
 			for(double d : array) {
-				r.push(new CDouble(d, t), t);
+				r.push(new CDouble(d, t), t, null);
 			}
 			return r;
 		} else if(object instanceof Object[]) {
 			CArray r = new CArray(t);
 			for(Object o : (Object[]) object) {
-				r.push((o == object) ? r : getMSObject(o, t), t);
+				r.push((o == object) ? r : getMSObject(o, t), t, null);
 			}
 			return r;
 		} else if(object instanceof Collection) {
 			return getMSObject(((Collection) object).toArray(), t);
 		} else if(object instanceof Map) {
 			Map map = ((Map) object);
-			CArray r = CArray.GetAssociativeArray(t);
+			CArray r = CArray.GetAssociativeArray(t, null, null);
 			for(Object key : map.keySet()) {
 				Object o = map.get(key);
-				r.set(key.toString(), (o == object) ? r : getMSObject(o, t), t);
+				r.set(key.toString(), (o == object) ? r : getMSObject(o, t), t, null);
 			}
 			return r;
 		} else {
@@ -1630,13 +1682,21 @@ public String getString(CResource res) {
 		}
 	}
 
+	/**
+	 * @deprecated Use {@link #getJavaObject(Mixed, Environment)} instead.
+	 */
+	@Deprecated
+	public static Object getJavaObject(Mixed construct) {
+		return getJavaObject(construct, null);
+	}
+
 	/**
 	 * Given a MethodScript object, returns a java object.
 	 *
 	 * @param construct
 	 * @return
 	 */
-	public static Object getJavaObject(Mixed construct) {
+	public static Object getJavaObject(Mixed construct, Environment env) {
 		if((construct == null) || (construct instanceof CNull)) {
 			return null;
 		} else if(construct instanceof CVoid) {
@@ -1647,19 +1707,19 @@ public static Object getJavaObject(Mixed construct) {
 			return ((CInt) construct).getInt();
 		} else if(construct instanceof CDouble) {
 			return ((CDouble) construct).getDouble();
-		} else if(construct instanceof CString) {
+		} else if(InstanceofUtil.isInstanceof(construct, CString.class, env)) {
 			return construct.val();
 		} else if(construct instanceof CByteArray) {
 			return ((CByteArray) construct).asByteArrayCopy();
 		} else if(construct instanceof CResource) {
 			return ((CResource) construct).getResource();
-		} else if(construct.isInstanceOf(CArray.TYPE)) {
+		} else if(construct.isInstanceOf(CArray.TYPE, null, env)) {
 			CArray array = (CArray) construct;
 			if(array.isAssociative()) {
 				HashMap<String, Object> map = new HashMap<>();
 				for(Mixed key : array.keySet()) {
 					Mixed c = array.get(key.val(), Target.UNKNOWN);
-					map.put(key.val(), (c == array) ? map : getJavaObject(c));
+					map.put(key.val(), (c == array) ? map : getJavaObject(c, env));
 				}
 				return map;
 			} else {
@@ -1671,7 +1731,7 @@ public static Object getJavaObject(Mixed construct) {
 					if(c == array) {
 						a[i] = a;
 					} else {
-						a[i] = getJavaObject(array.get(i, Target.UNKNOWN));
+						a[i] = getJavaObject(array.get(i, Target.UNKNOWN), env);
 					}
 					if(a[i] != null) {
 						if(clazz == null) {
@@ -1717,7 +1777,7 @@ public static Object getJavaObject(Mixed construct) {
 				}
 			}
 		} else {
-			return construct;
+			throw new ClassCastException(construct.getClass().getName() + " cannot be cast to a POJO");
 		}
 	}
 
diff --git a/src/main/java/com/laytonsmith/core/StepAction.java b/src/main/java/com/laytonsmith/core/StepAction.java
new file mode 100644
index 0000000000..8c9681701f
--- /dev/null
+++ b/src/main/java/com/laytonsmith/core/StepAction.java
@@ -0,0 +1,156 @@
+package com.laytonsmith.core;
+
+import com.laytonsmith.core.constructs.Target;
+import com.laytonsmith.core.environments.Environment;
+import com.laytonsmith.core.natives.interfaces.Mixed;
+
+/**
+ * Represents an action that a function returns to the interpreter loop, telling it what to do next.
+ * The interpreter loop understands three kinds of actions:
+ * <ul>
+ *   <li>{@link Evaluate} — evaluate a child node, then call back with the result</li>
+ *   <li>{@link Complete} — this function is done, here's the result</li>
+ *   <li>{@link FlowControl} — a control flow action is propagating up the stack</li>
+ * </ul>
+ *
+ * <p>The interpreter loop does not know about specific flow control types (break, continue, return, etc.).
+ * Those are defined by the functions that produce and consume them, via {@link FlowControlAction}.</p>
+ */
+public abstract class StepAction {
+
+	private StepAction() {
+	}
+
+	/**
+	 * Tells the interpreter loop to evaluate the given parse tree node. Once evaluation completes,
+	 * the result is passed back to the current frame's {@link FlowFunction#childCompleted}.
+	 *
+	 * <p>If an environment is provided, the child frame will use that environment instead of
+	 * inheriting the parent frame's environment. This is used by procedure calls, which evaluate
+	 * their body in a cloned environment.</p>
+	 */
+	public static final class Evaluate extends StepAction {
+		private final ParseTree node;
+		private final Environment env;
+		private final boolean keepIVariable;
+
+		public Evaluate(ParseTree node) {
+			this(node, null, false);
+		}
+
+		/**
+		 * @param node The node to evaluate
+		 * @param env The environment to evaluate in, or null to use the parent frame's environment
+		 */
+		public Evaluate(ParseTree node, Environment env) {
+			this(node, env, false);
+		}
+
+		/**
+		 * @param node The node to evaluate
+		 * @param env The environment to evaluate in, or null to use the parent frame's environment
+		 * @param keepIVariable If true, the result is returned as-is even if it's an IVariable.
+		 *     If false (default), IVariables are resolved to their values before being passed
+		 *     to childCompleted.
+		 */
+		public Evaluate(ParseTree node, Environment env, boolean keepIVariable) {
+			this.node = node;
+			this.env = env;
+			this.keepIVariable = keepIVariable;
+		}
+
+		public ParseTree getNode() {
+			return node;
+		}
+
+		/**
+		 * Returns the environment to evaluate in, or null to use the parent frame's environment.
+		 */
+		public Environment getEnv() {
+			return env;
+		}
+
+		/**
+		 * Returns true if IVariable results should be kept as-is rather than resolved.
+		 */
+		public boolean keepIVariable() {
+			return keepIVariable;
+		}
+	}
+
+	/**
+	 * Tells the interpreter loop that the current function is done, and provides its result value.
+	 */
+	public static final class Complete extends StepAction {
+		private final Mixed result;
+
+		public Complete(Mixed result) {
+			this.result = result;
+		}
+
+		public Mixed getResult() {
+			return result;
+		}
+	}
+
+	/**
+	 * Tells the interpreter loop that a control flow action is propagating up the stack.
+	 * The loop will pass this to each frame's {@link FlowFunction#childInterrupted} as it
+	 * unwinds, until a frame handles it or it reaches the top of the stack.
+	 *
+	 * <p>The interpreter loop does not inspect the {@link FlowControlAction} — specific flow control
+	 * types (break, continue, return, throw, etc.) are defined alongside the functions that
+	 * produce and consume them.</p>
+	 */
+	public static final class FlowControl extends StepAction {
+		private final FlowControlAction action;
+
+		public FlowControl(FlowControlAction action) {
+			this.action = action;
+		}
+
+		public FlowControlAction getAction() {
+			return action;
+		}
+	}
+
+	/**
+	 * Marker interface for control flow actions that propagate up the interpreter stack.
+	 * Concrete implementations are defined alongside the functions that produce/consume them
+	 * (e.g., BreakAction lives near _break in ControlFlow.java).
+	 *
+	 * <p>The interpreter loop treats all FlowControlActions generically — it does not know about
+	 * specific types. This allows extensions to define custom control flow without modifying core.</p>
+	 */
+	public interface FlowControlAction {
+		/**
+		 * Returns the code location where this action originated.
+		 */
+		Target getTarget();
+	}
+
+	/**
+	 * Pairs a {@link StepAction} with the flow function's per-call state. Returned by
+	 * {@link FlowFunction} methods so the interpreter loop can store the state
+	 * on the {@link StackFrame} without knowing its type.
+	 *
+	 * @param <S> The flow function's state type
+	 */
+	public static final class StepResult<S> {
+		private final StepAction action;
+		private final S state;
+
+		public StepResult(StepAction action, S state) {
+			this.action = action;
+			this.state = state;
+		}
+
+		public StepAction getAction() {
+			return action;
+		}
+
+		public S getState() {
+			return state;
+		}
+	}
+}
diff --git a/src/main/java/com/laytonsmith/core/StrictMode.java b/src/main/java/com/laytonsmith/core/StrictMode.java
index da29341bea..d4d45cd609 100644
--- a/src/main/java/com/laytonsmith/core/StrictMode.java
+++ b/src/main/java/com/laytonsmith/core/StrictMode.java
@@ -14,16 +14,16 @@ public class StrictMode {
 	 * There are a couple of factors that go into determining if strict mode is enabled or not. This method
 	 * combines all the reasons into a single function call.
 	 * @param fileOptions This parameter is mandatory, and should be provided by the compiler or other source object.
-	 * @param environment This parameter is optional, and may be set to null. This is going to be the case on the first
+	 * @param env This parameter is optional, and may be set to null. This is going to be the case on the first
 	 * compiler pass, but in dynamic code instances, may be present.
 	 * @param t The code target, for error messages
 	 * @return True if strict mode rules should be followed for this object.
 	 */
-	public static boolean isStrictMode(FileOptions fileOptions, Environment environment, Target t) {
+	public static boolean isStrictMode(FileOptions fileOptions, Environment env, Target t) {
 		boolean runtimeSetting = false;
-		if(environment != null) {
-			GlobalEnv env = environment.getEnv(GlobalEnv.class);
-			runtimeSetting = env.GetRuntimeSetting("system.strict_mode.enabled", false, t);
+		if(env != null) {
+			GlobalEnv gEnv = env.getEnv(GlobalEnv.class);
+			runtimeSetting = gEnv.GetRuntimeSetting("system.strict_mode.enabled", false, t);
 		}
 		return fileOptions.isStrict() || runtimeSetting;
 	}
diff --git a/src/main/java/com/laytonsmith/core/Updater.java b/src/main/java/com/laytonsmith/core/Updater.java
index a4f07111de..9c58fbbf40 100644
--- a/src/main/java/com/laytonsmith/core/Updater.java
+++ b/src/main/java/com/laytonsmith/core/Updater.java
@@ -43,7 +43,7 @@ public static BuildArtifact getLatestVersionInfo() throws ApiException, ParseExc
 	}
 
 	public static Boolean isUpdateAvailable() {
-		Mixed buildDate = new Meta.engine_build_date().exec(null, null, (Mixed[]) null);
+		Mixed buildDate = new Meta.engine_build_date().exec(null, null, null, (Mixed[]) null);
 		if(buildDate instanceof CNull) {
 			return null;
 		}
diff --git a/src/main/java/com/laytonsmith/core/asm/AsmCompiler.java b/src/main/java/com/laytonsmith/core/asm/AsmCompiler.java
index 5595fbe768..891f8be1ed 100644
--- a/src/main/java/com/laytonsmith/core/asm/AsmCompiler.java
+++ b/src/main/java/com/laytonsmith/core/asm/AsmCompiler.java
@@ -554,7 +554,7 @@ public static IRData getIR(IRBuilder builder, ParseTree node, Environment env) t
 			if(fb instanceof LLVMFunction f) {
 				builder.functionsUsed.add(f);
 				return f.buildIR(builder, node.getTarget(), env,
-						node.getChildren().toArray(new ParseTree[node.getChildren().size()]));
+						null, node.getChildren().toArray(new ParseTree[node.getChildren().size()]));
 			} else {
 				throw new Error("Unexpected function type");
 			}
diff --git a/src/main/java/com/laytonsmith/core/asm/LLVMArgumentValidation.java b/src/main/java/com/laytonsmith/core/asm/LLVMArgumentValidation.java
index 64eec0c93c..36cbe066fa 100644
--- a/src/main/java/com/laytonsmith/core/asm/LLVMArgumentValidation.java
+++ b/src/main/java/com/laytonsmith/core/asm/LLVMArgumentValidation.java
@@ -200,7 +200,7 @@ public static String getValueFromConstant(IRBuilder builder, ParseTree data, Env
 	public static IRData getAny(IRBuilder builder, Environment env, ParseTree c, Target t) throws ConfigCompileException {
 		LLVMEnvironment e = env.getEnv(LLVMEnvironment.class);
 		if(c.isConst()) {
-			IRType datatype = convertCClassTypeToIRType(c.getData().typeof());
+			IRType datatype = convertCClassTypeToIRType(c.getData().typeof(env));
 			String data = getValueFromConstant(builder, c, env);
 			int alloca = e.getNewLocalVariableReference(datatype);
 			int load = e.getNewLocalVariableReference(datatype);
diff --git a/src/main/java/com/laytonsmith/core/asm/LLVMFunction.java b/src/main/java/com/laytonsmith/core/asm/LLVMFunction.java
index bf25a3f810..05cc39ef60 100644
--- a/src/main/java/com/laytonsmith/core/asm/LLVMFunction.java
+++ b/src/main/java/com/laytonsmith/core/asm/LLVMFunction.java
@@ -7,7 +7,6 @@
 import com.laytonsmith.core.Documentation;
 import com.laytonsmith.core.LogLevel;
 import com.laytonsmith.core.ParseTree;
-import com.laytonsmith.core.Script;
 import com.laytonsmith.core.compiler.SelfStatement;
 import com.laytonsmith.core.compiler.analysis.Scope;
 import com.laytonsmith.core.compiler.analysis.StaticAnalysis;
@@ -15,6 +14,7 @@
 import com.laytonsmith.core.constructs.CClassType;
 import com.laytonsmith.core.constructs.CFunction;
 import com.laytonsmith.core.constructs.Target;
+import com.laytonsmith.core.constructs.generics.GenericParameters;
 import com.laytonsmith.core.environments.Environment;
 import com.laytonsmith.core.exceptions.ConfigCompileException;
 import com.laytonsmith.core.exceptions.ConfigRuntimeException;
@@ -106,7 +106,7 @@ public Boolean runAsync() {
 	}
 
 	@Override
-	public final Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
+	public final Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 		throw new UnsupportedOperationException("Not supported.");
 	}
 
@@ -193,7 +193,7 @@ public LogLevel profileAt() {
 	}
 
 	@Override
-	public String profileMessage(Mixed... args) {
+	public String profileMessage(Environment env, Mixed... args) {
 		throw new UnsupportedOperationException("Not supported.");
 	}
 
@@ -228,22 +228,13 @@ public int compareTo(Function o) {
 	 * @param builder The ongoing builder. Functions should append to this as needed.
 	 * @param t The code target this node comes from.
 	 * @param env The Environment
+	 * @param parameters Generic parameters passed to this function call.
 	 * @param nodes The children passed to this function, could be empty array.
 	 * @return Information on the returned value, including things like type (if known) and how to reference the
 	 * output value.
 	 * @throws com.laytonsmith.core.exceptions.ConfigCompileException If there is a compilation error.
 	 */
-	public abstract IRData buildIR(IRBuilder builder, Target t, Environment env, ParseTree... nodes) throws ConfigCompileException;
-
-	@Override
-	public final boolean useSpecialExec() {
-		throw new UnsupportedOperationException("Not supported.");
-	}
-
-	@Override
-	public final Mixed execs(Target t, Environment env, Script parent, ParseTree... nodes) {
-		throw new UnsupportedOperationException("Not supported.");
-	}
+	public abstract IRData buildIR(IRBuilder builder, Target t, Environment env, GenericParameters parameters, ParseTree... nodes) throws ConfigCompileException;
 
 	/**
 	 * If this function is used, and it needs to do startup configuration, that configuration goes here.
diff --git a/src/main/java/com/laytonsmith/core/asm/LLVMPlatformResolver.java b/src/main/java/com/laytonsmith/core/asm/LLVMPlatformResolver.java
index 68d1f2b973..33026372d5 100644
--- a/src/main/java/com/laytonsmith/core/asm/LLVMPlatformResolver.java
+++ b/src/main/java/com/laytonsmith/core/asm/LLVMPlatformResolver.java
@@ -40,6 +40,6 @@ public static IRData outputConstant(IRBuilder builder, Mixed c, Environment env)
 			builder.appendLine(c.getTarget(), "%" + gep + " = getelementptr inbounds [" + length + " x i8], [" + length + " x i8]* %" + alloca + ", i64 0, i64 0");
 			return IRDataBuilder.setReturnVariable(gep, IRType.STRING);
 		}
-		throw new UnsupportedOperationException("Unsupported data type " + c.typeof().getName());
+		throw new UnsupportedOperationException("Unsupported data type " + c.typeof(env).getName());
 	}
 }
diff --git a/src/main/java/com/laytonsmith/core/compiler/OptimizationUtilities.java b/src/main/java/com/laytonsmith/core/compiler/OptimizationUtilities.java
index 561d407c3d..96c6ff7531 100644
--- a/src/main/java/com/laytonsmith/core/compiler/OptimizationUtilities.java
+++ b/src/main/java/com/laytonsmith/core/compiler/OptimizationUtilities.java
@@ -81,22 +81,22 @@ public static String optimize(String script, Environment env,
 		StringBuilder b = new StringBuilder();
 		//The root always contains null.
 		for(ParseTree child : tree.getChildren()) {
-			b.append(optimize0(child));
+			b.append(optimize0(child, env));
 		}
 		return b.toString();
 	}
 
-	private static String optimize0(ParseTree node) {
-		if(node.getData() instanceof CFunction) {
+	private static String optimize0(ParseTree node, Environment env) {
+		if(node.getData() instanceof CFunction cFunction) {
 			StringBuilder b = new StringBuilder();
 			boolean first = true;
-			b.append(((CFunction) node.getData()).val()).append("(");
+			b.append(cFunction.val()).append("(");
 			for(ParseTree child : node.getChildren()) {
 				if(!first) {
 					b.append(",");
 				}
 				first = false;
-				b.append(optimize0(child));
+				b.append(optimize0(child, env));
 			}
 			b.append(")");
 			return b.toString();
@@ -105,26 +105,26 @@ private static String optimize0(ParseTree node) {
 			return new StringBuilder().append("'").append(node.getData().val()
 					.replace("\\", "\\\\").replace("\t", "\\t").replace("\n", "\\n")
 					.replace("'", "\\'")).append("'").toString();
-		} else if(node.getData() instanceof IVariable) {
-			return ((IVariable) node.getData()).getVariableName();
-		} else if(node.getData() instanceof Variable) {
-			return ((Variable) node.getData()).getVariableName();
+		} else if(node.getData() instanceof IVariable iVariable) {
+			return iVariable.getVariableName();
+		} else if(node.getData() instanceof Variable variable) {
+			return variable.getVariableName();
 		} else if(node.getData() instanceof CSlice) {
 			return node.getData().val();
-		} else if(node.getData().isInstanceOf(CArray.TYPE)) {
+		} else if(node.getData() instanceof CArray cArray) {
 			//It's a hardcoded array. This only happens in the course of optimization, if
 			//the optimizer adds a new array. We still need to handle it appropriately though.
 			//The values in the array will be constant, guaranteed.
 			StringBuilder b = new StringBuilder();
 			b.append("array(");
 			boolean first = true;
-			CArray n = (CArray) node.getData();
+			CArray n = cArray;
 			for(String key : n.stringKeySet()) {
 				if(!first) {
 					b.append(",");
 				}
 				first = false;
-				b.append(optimize0(new ParseTree(n.get(key, Target.UNKNOWN), node.getFileOptions(), true)));
+				b.append(optimize0(new ParseTree(n.get(key, Target.UNKNOWN, null), node.getFileOptions(), true), env));
 			}
 			b.append(")");
 			return b.toString();
diff --git a/src/main/java/com/laytonsmith/core/compiler/ProcedureDefinition.java b/src/main/java/com/laytonsmith/core/compiler/ProcedureDefinition.java
index 5068bf33c5..4a4bf4234a 100644
--- a/src/main/java/com/laytonsmith/core/compiler/ProcedureDefinition.java
+++ b/src/main/java/com/laytonsmith/core/compiler/ProcedureDefinition.java
@@ -6,6 +6,7 @@
 import com.laytonsmith.core.constructs.Construct;
 import com.laytonsmith.core.constructs.DocComment;
 import com.laytonsmith.core.constructs.Target;
+import com.laytonsmith.core.constructs.generics.GenericParameters;
 import com.laytonsmith.core.environments.Environment;
 import com.laytonsmith.core.natives.interfaces.Mixed;
 import com.laytonsmith.core.objects.ObjectType;
@@ -68,4 +69,9 @@ public ObjectType getObjectType() {
 		return super.getObjectType();
 	}
 
+	@Override
+	public GenericParameters getGenericParameters() {
+		return null;
+	}
+
 }
diff --git a/src/main/java/com/laytonsmith/core/compiler/analysis/Scope.java b/src/main/java/com/laytonsmith/core/compiler/analysis/Scope.java
index 0e6e20e519..344fdbefa6 100644
--- a/src/main/java/com/laytonsmith/core/compiler/analysis/Scope.java
+++ b/src/main/java/com/laytonsmith/core/compiler/analysis/Scope.java
@@ -6,6 +6,7 @@
 import java.util.HashMap;
 import java.util.HashSet;
 import java.util.Map;
+import java.util.Objects;
 import java.util.Set;
 import java.util.Stack;
 
@@ -43,6 +44,10 @@ private Scope(Scope parent) {
 
 	private Scope(Set<Scope> parents, Map<Namespace, Set<Scope>> specificParents,
 			Map<Namespace, Map<String, Declaration>> declarations, Map<Namespace, Set<Reference>> references) {
+		Objects.requireNonNull(parents);
+		for(Scope s : parents) {
+			Objects.requireNonNull(s, "The set of parent scopes may not contain null values.");
+		}
 		this.parents = parents;
 		this.specificParents = specificParents;
 		this.declarations = declarations;
diff --git a/src/main/java/com/laytonsmith/core/compiler/analysis/StaticAnalysis.java b/src/main/java/com/laytonsmith/core/compiler/analysis/StaticAnalysis.java
index eacf81b141..5dab6016bd 100644
--- a/src/main/java/com/laytonsmith/core/compiler/analysis/StaticAnalysis.java
+++ b/src/main/java/com/laytonsmith/core/compiler/analysis/StaticAnalysis.java
@@ -449,7 +449,7 @@ public CClassType typecheck(ParseTree ast, Environment env, Set<ConfigCompileExc
 			return Auto.TYPE;
 		}
 		try {
-			return node.typeof();
+			return node.typeof(env);
 		} catch(Throwable t) {
 			// Functions that might contain these unsupported objects should make sure that they don't type check them.
 			// In case an unsupported object causes an error here, it likely means that we have a syntax error.
diff --git a/src/main/java/com/laytonsmith/core/constructs/CArray.java b/src/main/java/com/laytonsmith/core/constructs/CArray.java
index 07a05ad31b..c9263ea2f9 100644
--- a/src/main/java/com/laytonsmith/core/constructs/CArray.java
+++ b/src/main/java/com/laytonsmith/core/constructs/CArray.java
@@ -97,7 +97,13 @@ public CArray(Target t, int initialCapacity, Collection<Mixed> items) {
 		this(t, initialCapacity, getArray(items));
 	}
 
+	/** @deprecated Use {@code CArray(Target, int, Environment, Mixed[]} instead. */
+	@Deprecated
 	public CArray(Target t, int initialCapacity, Mixed... items) {
+		this(t, initialCapacity, null, items);
+	}
+
+	public CArray(Target t, int initialCapacity, Environment env, Mixed... items) {
 		super("{}", ConstructType.ARRAY, t);
 		if(initialCapacity == -1) {
 			associativeMode = true;
@@ -117,8 +123,8 @@ public CArray(Target t, int initialCapacity, Mixed... items) {
 				for(Mixed item : items) {
 					if(item instanceof CEntry) {
 						Mixed value = ((CEntry) item).construct;
-						associativeArray.put(normalizeConstruct(((CEntry) item).ckey), value);
-						if(value.isInstanceOf(CArray.TYPE)) {
+						associativeArray.put(normalizeConstruct(((CEntry) item).ckey, env), value);
+						if(value.isInstanceOf(CArray.TYPE, null, env)) {
 							((CArray) value).parent = this;
 						}
 					} else {
@@ -134,7 +140,7 @@ public CArray(Target t, int initialCapacity, Mixed... items) {
 							max = -1; //Special case, there are no integer indexes in here yet.
 						}
 						associativeArray.put(Integer.toString(max + 1), item);
-						if(item.isInstanceOf(CArray.TYPE)) {
+						if(item.isInstanceOf(CArray.TYPE, null, env)) {
 							((CArray) item).parent = this;
 						}
 					}
@@ -144,7 +150,7 @@ public CArray(Target t, int initialCapacity, Mixed... items) {
 			if(items != null) {
 				for(Mixed item : items) {
 					array.add(item);
-					if(item.isInstanceOf(CArray.TYPE)) {
+					if(item.isInstanceOf(CArray.TYPE, null, env)) {
 						((CArray) item).parent = this;
 					}
 				}
@@ -182,12 +188,19 @@ private static Mixed[] getArray(Collection<Mixed> items) {
 		return c;
 	}
 
+	/** @deprecated Use {@link #asList(Environment)} instead. */
+	@Deprecated
+	public List<Mixed> asList() {
+		return asList(null);
+	}
+
 	/**
 	 * Returns a List based on the array. This is only applicable if this is a normal array.
 	 *
+	 * @param env
 	 * @return
 	 */
-	public List<Mixed> asList() {
+	public List<Mixed> asList(Environment env) {
 		if(inAssociativeMode()) {
 			throw new RuntimeException("asList can only be called on a normal array");
 		} else {
@@ -216,13 +229,33 @@ public boolean inAssociativeMode() {
 	 *
 	 * @param t
 	 * @return
+	 * @deprecated Use {@link #GetAssociativeArray(Target, GenericParameters, Environment)} instead.
 	 */
+	@Deprecated
 	public static CArray GetAssociativeArray(Target t) {
-		return new CArray(t, -1);
+		return GetAssociativeArray(t, null, null);
 	}
 
+	/** @deprecated Use {@link #GetAssociativeArray(Target, GenericParameters, Environment, Mixed[])} instead. */
+	@Deprecated
 	public static CArray GetAssociativeArray(Target t, Mixed[] args) {
-		return new CArray(t, -1, args);
+		return GetAssociativeArray(t, null, null, args);
+	}
+
+	/**
+	 * Returns a new empty CArray that is in associative mode.
+	 *
+	 * @param t
+	 * @param genericParameters
+	 * @param env
+	 * @return
+	 */
+	public static CArray GetAssociativeArray(Target t, GenericParameters genericParameters, Environment env) {
+		return new CArray(t, -1, genericParameters, env);
+	}
+
+	public static CArray GetAssociativeArray(Target t, GenericParameters genericParameters, Environment env, Mixed[] args) {
+		return new CArray(t, -1, env, args);
 	}
 
 	/**
@@ -261,18 +294,31 @@ public void reverse(Target t) {
 		}
 	}
 
+	/** @deprecated Use {@link #push(Mixed, Target, Environment)} instead. */
+	@Deprecated
+	public final void push(Mixed c, Target t) {
+		push(c, t, null);
+	}
+
 	/**
 	 * Pushes a new Construct onto the end of the array.
 	 *
 	 * @param c
 	 * @param t
+	 * @param env
 	 */
-	public final void push(Mixed c, Target t) {
-		push(c, null, t);
+	public final void push(Mixed c, Target t, Environment env) {
+		push(c, null, t, env);
 	}
 
 	public final void push(String s) {
-		push(new CString(s, Target.UNKNOWN), Target.UNKNOWN);
+		push(new CString(s, Target.UNKNOWN), Target.UNKNOWN, null);
+	}
+
+	/** @deprecated Use {@link #push(Mixed, Integer, Target, Environment)} instead. */
+	@Deprecated
+	public void push(Mixed c, Integer index, Target t) throws IllegalArgumentException, IndexOutOfBoundsException {
+		push(c, index, t, null);
 	}
 
 	/**
@@ -282,10 +328,13 @@ public final void push(String s) {
 	 * should use {@link #set} anyways for an associative array.
 	 *
 	 * @param c The Construct to add to the array
+	 * @param index The index to push on. May be null.
+	 * @param t The code target
+	 * @param env The environment
 	 * @throws IllegalArgumentException If index is not null, and this is an associative array.
 	 * @throws IndexOutOfBoundsException If the index is not null, and the index specified is out of range.
 	 */
-	public void push(Mixed c, Integer index, Target t) throws IllegalArgumentException, IndexOutOfBoundsException {
+	public void push(Mixed c, Integer index, Target t, Environment env) throws IllegalArgumentException, IndexOutOfBoundsException {
 		if(!associativeMode) {
 			if(index != null) {
 				array.add(index, c);
@@ -311,20 +360,28 @@ public void push(Mixed c, Integer index, Target t) throws IllegalArgumentExcepti
 				associativeArray.put(Integer.toString(max + 1), c);
 			}
 		}
-		if(c.isInstanceOf(CArray.TYPE)) {
+		if(c.isInstanceOf(CArray.TYPE, null, env)) {
 			((CArray) c).parent = this;
 		}
 		setDirty();
 	}
 
+	/** @deprecated Use {@link #keySet(Environment)} instead. */
+	@Deprecated
+	@Override
+	public Set<Mixed> keySet() {
+		return keySet(null);
+	}
+
 	/**
 	 * Returns the key set for this array. If it's an associative array, it simply returns the key set of the map,
 	 * otherwise it generates a set of CInts from 0 to size-1, and returns that.
 	 *
+	 * @param env
 	 * @return
 	 */
 	@Override
-	public Set<Mixed> keySet() {
+	public Set<Mixed> keySet(Environment env) {
 		Set<Mixed> set;
 		if(!associativeMode) {
 			set = new LinkedHashSet<>(array.size());
@@ -367,25 +424,34 @@ private void setAssociative() {
 		array = null; // null out the original array container so it can be GC'd
 	}
 
+	/** @deprecated Use {@link #set(Mixed, Mixed, Target, Environment)} instead. */
+	@Deprecated
+	public void set(Mixed index, Mixed c, Target t) {
+		set(index, c, t, null);
+	}
+
 	/**
+	 * Sets the value at the given index.
 	 *
-	 * @param index
-	 * @param c
+	 * @param index The index. Should be either an int or a string.
+	 * @param c The element to set.
+	 * @param t The code target.
+	 * @param env The environment.
 	 */
 	@Override
-	public void set(Mixed index, Mixed c, Target t) {
+	public void set(Mixed index, Mixed c, Target t, Environment env) {
 		if(!associativeMode) {
 			if(index instanceof CNull) {
 				// Invalid normal array index
 				setAssociative();
 			} else {
 				try {
-					int indx = ArgumentValidation.getInt32(index, t);
+					int indx = ArgumentValidation.getInt32(index, t, env);
 					if(indx > nextIndex || indx < 0) {
 						// Out of range
 						setAssociative();
 					} else if(indx == nextIndex) {
-						this.push(c, t);
+						this.push(c, t, env);
 					} else {
 						array.set(indx, c);
 					}
@@ -396,49 +462,80 @@ public void set(Mixed index, Mixed c, Target t) {
 			}
 		}
 		if(associativeMode) {
-			associativeArray.put(normalizeConstruct(index), c);
+			associativeArray.put(normalizeConstruct(index, env), c);
 		}
-		if(c.isInstanceOf(CArray.TYPE)) {
+		if(c.isInstanceOf(CArray.TYPE, null, env)) {
 			((CArray) c).parent = this;
 		}
 		setDirty();
 	}
 
+	/** @deprecated Use {@link #set(int, Mixed, Target, Environment)} instead. */
+	@Deprecated
 	public final void set(int index, Mixed c, Target t) {
-		this.set(new CInt(index, t), c, t);
+		this.set(index, c, t, null);
+	}
+
+	public final void set(int index, Mixed c, Target t, Environment env) {
+		this.set(new CInt(index, t), c, t, env);
 	}
 
 	/* Shortcuts */
+	/** @deprecated Use {@link #set(String, Mixed, Target, Environment)} instead. */
+	@Deprecated
 	public final void set(String index, Mixed c, Target t) {
-		set(new CString(index, t), c, t);
+		set(index, c, t, null);
 	}
 
+	public final void set(String index, Mixed c, Target t, Environment env) {
+		set(new CString(index, t), c, t, env);
+	}
+
+	/** @deprecated Use {@link #set(String, String, Target, Environment)} instead. */
+	@Deprecated
 	public final void set(String index, String value, Target t) {
-		set(index, new CString(value, t), t);
+		set(index, value, t, null);
+	}
+
+	public final void set(String index, String value, Target t, Environment env) {
+		set(index, new CString(value, t), t, env);
 	}
 
+	/** @deprecated Use {@link #set(String, String, Environment)} instead. */
+	@Deprecated
 	public final void set(String index, String value) {
-		set(index, value, Target.UNKNOWN);
+		set(index, value, (Environment) null);
+	}
+
+	public final void set(String index, String value, Environment env) {
+		set(index, value, Target.UNKNOWN, env);
 	}
 
 	public final void set(String index, double value) {
-		set(index, new CDouble(value, Target.UNKNOWN), Target.UNKNOWN);
+		set(index, new CDouble(value, Target.UNKNOWN), Target.UNKNOWN, null);
 	}
 
 	public final void set(String index, long value) {
-		set(index, new CInt(value, Target.UNKNOWN), Target.UNKNOWN);
+		set(index, new CInt(value, Target.UNKNOWN), Target.UNKNOWN, null);
 	}
 
+	/** @deprecated Use {@link #get(Mixed, Target, Environment)} instead. */
+	@Deprecated
 	@Override
 	public Mixed get(Mixed index, Target t) {
+		return get(index, t, null);
+	}
+
+	@Override
+	public Mixed get(Mixed index, Target t, Environment env) {
 		if(!associativeMode) {
 			try {
-				return array.get(ArgumentValidation.getInt32(index, t));
+				return array.get(ArgumentValidation.getInt32(index, t, env));
 			} catch (IndexOutOfBoundsException e) {
 				throw new CREIndexOverflowException("The element at index \"" + index.val() + "\" does not exist", t, e);
 			}
 		} else {
-			Mixed val = associativeArray.get(normalizeConstruct(index));
+			Mixed val = associativeArray.get(normalizeConstruct(index, env));
 			if(val != null) {
 				if(val instanceof CEntry) {
 					return ((CEntry) val).construct();
@@ -453,18 +550,41 @@ public Mixed get(Mixed index, Target t) {
 		}
 	}
 
+	/** @deprecated Use {@link #get(Mixed, Target, Environment)} instead. */
+	@Deprecated
 	public final Mixed get(long index, Target t) {
-		return this.get(new CInt(index, t), t);
+		return this.get(new CInt(index, t), t, null);
+	}
+
+	public final Mixed get(long index, Target t, Environment env) {
+		if((int) index != index) {
+			throw new CREIndexOverflowException("The element at index \"" + index + "\" does not exist", t);
+		}
+		return this.get(new CInt(index, t), t, env);
 	}
 
+	/** @deprecated Use {@link #get(int, Target, Environment)} instead. */
+	@Deprecated
 	@Override
 	public final Mixed get(int index, Target t) {
-		return this.get(new CInt(index, t), t);
+		return this.get(new CInt(index, t), t, null);
 	}
 
+	@Override
+	public final Mixed get(int index, Target t, Environment env) {
+		return this.get(new CInt(index, t), t, env);
+	}
+
+	/** @deprecated Use {@link #get(String, Target, Environment)} instead. */
+	@Deprecated
 	@Override
 	public final Mixed get(String index, Target t) {
-		return this.get(new CString(index, t), t);
+		return this.get(new CString(index, t), t, null);
+	}
+
+	@Override
+	public final Mixed get(String index, Target t, Environment env) {
+		return this.get(new CString(index, t), t, env);
 	}
 
 	public boolean containsKey(String c) {
@@ -499,13 +619,20 @@ public final boolean contains(int i) {
 		return contains(new CString(Integer.toString(i), Target.UNKNOWN));
 	}
 
+	/** @deprecated Use {@link #indexesOf(Mixed, Environment)} instead. */
+	@Deprecated
+	public CArray indexesOf(Mixed value) {
+		return indexesOf(value, null);
+	}
+
 	/**
 	 * Returns an array of the keys of all the values that are equal to the value specified
 	 *
-	 * @param value
-	 * @return
+	 * @param value The value to find the index(es) of
+	 * @param env The environment
+	 * @return An array of keys where the corresponding value is equal to the value specified.
 	 */
-	public CArray indexesOf(Mixed value) {
+	public CArray indexesOf(Mixed value, Environment env) {
 		CArray ret = new CArray(Target.UNKNOWN);
 		if(associativeMode) {
 			for(String key : associativeArray.keySet()) {
@@ -526,7 +653,8 @@ public CArray indexesOf(Mixed value) {
 	@Override
 	public String val() {
 		if(valueDirty) {
-			getString(new Stack<>(), this.getTarget());
+			// TODO: Hmmmmmm. Might need env here.
+			getString(new Stack<>(), this.getTarget(), null);
 		}
 		return mutVal;
 	}
@@ -544,23 +672,23 @@ public String toString() {
 	 * @param t
 	 * @return
 	 */
-	protected String getString(Stack<CArray> arrays, Target t) {
+	protected String getString(Stack<CArray> arrays, Target t, Environment env) {
 		if(!valueDirty) {
 			return mutVal;
 		}
 		StringBuilder b = new StringBuilder();
 		b.append("{");
 		if(!inAssociativeMode()) {
-			for(int i = 0; i < this.size(); i++) {
-				Mixed value = this.get(i, t);
+			for(int i = 0; i < this.size(env); i++) {
+				Mixed value = this.get(i, t, env);
 				String v;
-				if(value.isInstanceOf(CArray.TYPE)) {
+				if(value.isInstanceOf(CArray.TYPE, null, env)) {
 					if(arrays.contains(value)) {
 						//Check for recursion
 						v = "*recursion*";
 					} else {
 						arrays.add(((CArray) value));
-						v = ((CArray) value).getString(arrays, t);
+						v = ((CArray) value).getString(arrays, t, env);
 						arrays.pop();
 					}
 				} else {
@@ -579,16 +707,16 @@ protected String getString(Stack<CArray> arrays, Target t) {
 				}
 				first = false;
 				String v;
-				if(this.get(key, t) == null) {
+				if(this.get(key, t, env) == null) {
 					v = "null";
 				} else {
-					Mixed value = this.get(key, t);
-					if(value.isInstanceOf(CArray.TYPE)) {
+					Mixed value = this.get(key, t, env);
+					if(value.isInstanceOf(CArray.TYPE, null, env)) {
 						if(arrays.contains(value)) {
 							v = "*recursion*";
 						} else {
 							arrays.add(((CArray) value));
-							v = ((CArray) value).getString(arrays, t);
+							v = ((CArray) value).getString(arrays, t, env);
 						}
 					} else {
 						v = value.val();
@@ -603,8 +731,15 @@ protected String getString(Stack<CArray> arrays, Target t) {
 		return mutVal;
 	}
 
+	/** @deprecated Use {@link #size(Environment)} instead. */
+	@Deprecated
 	@Override
 	public long size() {
+		return size(null);
+	}
+
+	@Override
+	public long size(Environment env) {
 		if(associativeMode) {
 			return associativeArray.size();
 		} else {
@@ -632,11 +767,23 @@ public CArray clone() {
 		return clone;
 	}
 
+	/** @deprecated Use {@link #deepClone(Target, Environment)} instead. */
+	@Deprecated
 	public CArray deepClone(Target t) {
-		return deepClone(this, t, new ArrayList<>());
+		return deepClone(t, null);
+	}
+
+	public CArray deepClone(Target t, Environment env) {
+		return deepClone(this, t, new ArrayList<>(), env);
 	}
 
+	/** @deprecated Use {@link #deepClone(CArray, Target, ArrayList, Environment)} instead. */
+	@Deprecated
 	protected CArray deepClone(CArray array, Target t, ArrayList<CArray[]> cloneRefs) {
+		return deepClone(array, t, cloneRefs, null);
+	}
+
+	protected CArray deepClone(CArray array, Target t, ArrayList<CArray[]> cloneRefs, Environment env) {
 
 		// Return the clone reference if this array has been cloned before (both clones will have the same reference).
 		for(CArray[] refCouple : cloneRefs) {
@@ -646,69 +793,90 @@ protected CArray deepClone(CArray array, Target t, ArrayList<CArray[]> cloneRefs
 		}
 
 		// Create the clone to put array in and add it to the cloneRefs list.
-		CArray clone = new CArray(t, (int) array.size());
+		CArray clone = new CArray(t, (int) array.size(env));
 		clone.associativeMode = array.associativeMode;
 		cloneRefs.add(new CArray[]{array, clone});
 
 		// Iterate over the array, recursively calling this method to perform a deep clone.
-		for(Mixed key : array.keySet()) {
-			Mixed value = array.get(key, t);
-			if(value.isInstanceOf(CArray.TYPE)) {
-				value = deepClone((CArray) value, t, cloneRefs);
+		for(Mixed key : array.keySet(env)) {
+			Mixed value = array.get(key, t, env);
+			if(value.isInstanceOf(CArray.TYPE, null, env)) {
+				value = deepClone((CArray) value, t, cloneRefs, env);
 			}
-			clone.set(key, value, t);
+			clone.set(key, value, t, env);
 		}
 		return clone;
 	}
 
-	private String normalizeConstruct(Mixed c) {
-		if(c.isInstanceOf(CArray.TYPE)) {
+	private String normalizeConstruct(Mixed c, Environment env) {
+		if(c.isInstanceOf(CArray.TYPE, null, env)) {
 			throw new CRECastException("Arrays cannot be used as the key in an associative array", c.getTarget());
-		} else if(c.isInstanceOf(CString.TYPE) || c.isInstanceOf(CInt.TYPE)) {
+		} else if(c.isInstanceOf(CString.TYPE, null, env) || c.isInstanceOf(CInt.TYPE, null, env)) {
 			return c.val();
 		} else if(c instanceof CNull) {
 			return "";
-		} else if(c.isInstanceOf(CBoolean.TYPE)) {
+		} else if(c instanceof CBoolean) {
 			if(((CBoolean) c).getBoolean()) {
 				return "1";
 			} else {
 				return "0";
 			}
 		} else if(c instanceof CLabel) {
-			return normalizeConstruct(((CLabel) c).cVal());
+			return normalizeConstruct(((CLabel) c).cVal(), env);
 		} else {
 			return c.val();
 		}
 	}
 
+	/** @deprecated Use {@link #remove(int, Environment)} instead. */
+	@Deprecated
+	public Mixed remove(int i) {
+		return remove(i, null);
+	}
+
 	/**
 	 * Removes the value at the specified integer key.
 	 *
-	 * @param i
-	 * @return
+	 * @param i The index to remove at
+	 * @param env The environment
+	 * @return The value that was removed
 	 */
-	public Mixed remove(int i) {
-		return remove(new CInt(i, Target.UNKNOWN));
+	public Mixed remove(int i, Environment env) {
+		return remove(new CInt(i, Target.UNKNOWN), env);
+	}
+
+	/** @deprecated Use {@link #remove(String, Environment)} instead. */
+	@Deprecated
+	public Mixed remove(String s) {
+		return remove(s, null);
 	}
 
 	/**
 	 * Removes the value at the specified string key.
 	 *
-	 * @param s
-	 * @return
+	 * @param s The index to remove at
+	 * @param env The environment
+	 * @return The value that was removed
 	 */
-	public Mixed remove(String s) {
-		return remove(new CString(s, Target.UNKNOWN));
+	public Mixed remove(String s, Environment env) {
+		return remove(new CString(s, Target.UNKNOWN), env);
+	}
+
+	/** @deprecated Use {@link #remove(Mixed, Environment)} instead. */
+	@Deprecated
+	public Mixed remove(Mixed construct) {
+		return remove(construct, null);
 	}
 
 	/**
 	 * Removes the value at the specified key
 	 *
 	 * @param construct The value to remove
+	 * @param env The environment
 	 * @return The removed value, or CNull if nothing was removed.
 	 */
-	public Mixed remove(Mixed construct) {
-		String c = normalizeConstruct(construct);
+	public Mixed remove(Mixed construct, Environment env) {
+		String c = normalizeConstruct(construct, env);
 		Mixed ret;
 		if(!associativeMode) {
 			try {
@@ -757,14 +925,21 @@ public void removeValues(Mixed construct) {
 		setDirty();
 	}
 
+	/** @deprecated Use {@link #createNew(Target, Environment)} instead. */
+	@Deprecated
+	public CArray createNew(Target t) {
+		return createNew(t, null);
+	}
+
 	/**
 	 * Creates a new, empty array, with the same type. Note to subclasses: By default, this method expects a constructor
 	 * that accepts a {@link Target}. If this assumption is not valid, you may override this method as needed.
 	 *
-	 * @param t
-	 * @return
+	 * @param t The code target
+	 * @param env The environment
+	 * @return A new empty array
 	 */
-	public CArray createNew(Target t) {
+	public CArray createNew(Target t, Environment env) {
 		try {
 			Constructor<CArray> con = (Constructor<CArray>) this.getClass().getConstructor(Target.class);
 			try {
@@ -773,7 +948,7 @@ public CArray createNew(Target t) {
 				throw new RuntimeException(ex);
 			}
 		} catch (NoSuchMethodException ex) {
-			throw new RuntimeException(this.typeof() + " does not support creating a new value.");
+			throw new RuntimeException(this.typeof(env) + " does not support creating a new value.");
 		} catch (SecurityException ex) {
 			throw new RuntimeException(ex);
 		}
@@ -821,9 +996,16 @@ public boolean canBeAssociative() {
 		return true;
 	}
 
+	/** @deprecated Use {@link #slice(int, int, Target, Environment)} instead. */
+	@Deprecated
 	@Override
 	public Mixed slice(int begin, int end, Target t) {
-		return new ArrayHandling.array_get().exec(t, null, new CSlice(begin, end, t));
+		return slice(begin, end, t, null);
+	}
+
+	@Override
+	public Mixed slice(int begin, int end, Target t, Environment env) {
+		return new ArrayHandling.array_get().exec(t, env, null, new CSlice(begin, end, t));
 	}
 
 	@Override
@@ -866,7 +1048,13 @@ public enum ArraySortType {
 		STRING_IC
 	}
 
+	/** @deprecated Use {@link #sort(ArraySortType, Environment)} instead. */
+	@Deprecated
 	public void sort(final ArraySortType sort) {
+		sort(sort, null);
+	}
+
+	public void sort(final ArraySortType sort, Environment env) {
 		if(this.associativeMode) {
 			array = new ArrayList<>(associativeArray.values());
 			this.associativeArray.clear();
@@ -887,12 +1075,12 @@ public int compare(Mixed o1, Mixed o2) {
 					} else {
 						c = o2;
 					}
-					if(c.isInstanceOf(CArray.TYPE)) {
+					if(c.isInstanceOf(CArray.TYPE, null, env)) {
 						throw new CRECastException("Cannot sort an array of arrays.", CArray.this.getTarget());
 					}
-					if(!(c.isInstanceOf(CBoolean.TYPE) || c.isInstanceOf(CString.TYPE) || c.isInstanceOf(CInt.TYPE)
-							|| c.isInstanceOf(CDouble.TYPE) || c instanceof CNull || c.isInstanceOf(CClassType.TYPE))) {
-						throw new CREFormatException("Unsupported type being sorted: " + c.typeof(), CArray.this.getTarget());
+					if(!(c instanceof CBoolean || c.isInstanceOf(CString.TYPE, null, env) || c.isInstanceOf(CInt.TYPE, null, env)
+							|| c.isInstanceOf(CDouble.TYPE, null, env) || c instanceof CNull || c instanceof CClassType)) {
+						throw new CREFormatException("Unsupported type being sorted: " + c.typeof(env), CArray.this.getTarget());
 					}
 				}
 				if(o1 instanceof CNull || o2 instanceof CNull) {
@@ -904,12 +1092,12 @@ public int compare(Mixed o1, Mixed o2) {
 						return o1.val().compareTo("");
 					}
 				}
-				if(o1.isInstanceOf(CBoolean.TYPE) || o2.isInstanceOf(CBoolean.TYPE)) {
-					if(ArgumentValidation.getBooleanish(o1, Target.UNKNOWN) == ArgumentValidation.getBooleanish(o2, Target.UNKNOWN)) {
+				if(o1 instanceof CBoolean || o2 instanceof CBoolean) {
+					if(ArgumentValidation.getBooleanish(o1, Target.UNKNOWN, env) == ArgumentValidation.getBooleanish(o2, Target.UNKNOWN, env)) {
 						return 0;
 					} else {
-						int oo1 = ArgumentValidation.getBooleanish(o1, Target.UNKNOWN) ? 1 : 0;
-						int oo2 = ArgumentValidation.getBooleanish(o2, Target.UNKNOWN) ? 1 : 0;
+						int oo1 = ArgumentValidation.getBooleanish(o1, Target.UNKNOWN, env) ? 1 : 0;
+						int oo2 = ArgumentValidation.getBooleanish(o2, Target.UNKNOWN, env) ? 1 : 0;
 						return (oo1 < oo2) ? -1 : 1;
 					}
 				}
@@ -923,13 +1111,13 @@ public int compare(Mixed o1, Mixed o2) {
 			}
 
 			public int compareRegular(Mixed o1, Mixed o2) {
-				if(ArgumentValidation.getBooleanObject(new DataHandling.is_numeric().exec(Target.UNKNOWN, null, o1), Target.UNKNOWN)
-						&& ArgumentValidation.getBooleanObject(new DataHandling.is_numeric().exec(Target.UNKNOWN, null, o2), Target.UNKNOWN)) {
+				if(ArgumentValidation.getBooleanObject(new DataHandling.is_numeric().exec(Target.UNKNOWN, null, null, o1), Target.UNKNOWN, env)
+						&& ArgumentValidation.getBooleanObject(new DataHandling.is_numeric().exec(Target.UNKNOWN, null, null, o2), Target.UNKNOWN, env)) {
 					return compareNumeric(o1, o2);
-				} else if(ArgumentValidation.getBooleanObject(new DataHandling.is_numeric().exec(Target.UNKNOWN, null, o1), Target.UNKNOWN)) {
+				} else if(ArgumentValidation.getBooleanObject(new DataHandling.is_numeric().exec(Target.UNKNOWN, null, null, o1), Target.UNKNOWN, env)) {
 					//The first is a number, the second is a string
 					return -1;
-				} else if(ArgumentValidation.getBooleanObject(new DataHandling.is_numeric().exec(Target.UNKNOWN, null, o2), Target.UNKNOWN)) {
+				} else if(ArgumentValidation.getBooleanObject(new DataHandling.is_numeric().exec(Target.UNKNOWN, null, null, o2), Target.UNKNOWN, env)) {
 					//The second is a number, the first is a string
 					return 1;
 				} else {
@@ -939,8 +1127,8 @@ public int compareRegular(Mixed o1, Mixed o2) {
 			}
 
 			public int compareNumeric(Mixed o1, Mixed o2) {
-				double d1 = ArgumentValidation.getNumber(o1, o1.getTarget());
-				double d2 = ArgumentValidation.getNumber(o2, o2.getTarget());
+				double d1 = ArgumentValidation.getNumber(o1, o1.getTarget(), env);
+				double d2 = ArgumentValidation.getNumber(o2, o2.getTarget(), env);
 				return Double.compare(d1, d2);
 			}
 
@@ -951,8 +1139,14 @@ public int compareString(String o1, String o2) {
 		this.setDirty();
 	}
 
+	/** @deprecated Use {@link #isEmpty(Environment)} instead. */
+	@Deprecated
 	public boolean isEmpty() {
-		return size() == 0;
+		return isEmpty(null);
+	}
+
+	public boolean isEmpty(Environment env) {
+		return size(env) == 0;
 	}
 
 	/**
@@ -986,9 +1180,16 @@ public CClassType[] getInterfaces() {
 			ArrayAccessSet.TYPE};
 	}
 
+	/** @deprecated Use {@link #getBooleanValue(Target, Environment)} instead. */
+	@Deprecated
 	@Override
 	public boolean getBooleanValue(Target t) {
-		return size() > 0;
+		return getBooleanValue(t, null);
+	}
+
+	@Override
+	public boolean getBooleanValue(Target t, Environment env) {
+		return size(env) > 0;
 	}
 
 }
diff --git a/src/main/java/com/laytonsmith/core/constructs/CBareString.java b/src/main/java/com/laytonsmith/core/constructs/CBareString.java
index 5c4446a933..dcd5c1cea7 100644
--- a/src/main/java/com/laytonsmith/core/constructs/CBareString.java
+++ b/src/main/java/com/laytonsmith/core/constructs/CBareString.java
@@ -2,6 +2,7 @@
 
 import com.laytonsmith.PureUtilities.Version;
 import com.laytonsmith.annotations.typeof;
+import com.laytonsmith.core.constructs.generics.GenericParameters;
 
 /**
  *
@@ -44,4 +45,9 @@ public CClassType[] getInterfaces() {
 	public CBareString duplicate() {
 		return new CBareString(val(), getTarget());
 	}
+
+	@Override
+	public GenericParameters getGenericParameters() {
+		return null;
+	}
 }
diff --git a/src/main/java/com/laytonsmith/core/constructs/CBoolean.java b/src/main/java/com/laytonsmith/core/constructs/CBoolean.java
index f4f079863f..8fe73d2a0c 100644
--- a/src/main/java/com/laytonsmith/core/constructs/CBoolean.java
+++ b/src/main/java/com/laytonsmith/core/constructs/CBoolean.java
@@ -3,6 +3,7 @@
 import com.laytonsmith.PureUtilities.Version;
 import com.laytonsmith.annotations.typeof;
 import com.laytonsmith.core.MSVersion;
+import com.laytonsmith.core.environments.Environment;
 import com.laytonsmith.core.objects.ObjectModifier;
 import java.util.EnumSet;
 import java.util.Set;
@@ -89,8 +90,15 @@ public boolean getBoolean() {
 		return val;
 	}
 
+	/** @deprecated Use {@link #getBooleanValue(Target, Environment)} instead. */
+	@Deprecated
 	@Override
 	public boolean getBooleanValue(Target t) {
+		return getBooleanValue(t, null);
+	}
+
+	@Override
+	public boolean getBooleanValue(Target t, Environment env) {
 		return val;
 	}
 
diff --git a/src/main/java/com/laytonsmith/core/constructs/CBrace.java b/src/main/java/com/laytonsmith/core/constructs/CBrace.java
index 63134faf76..9516685c86 100644
--- a/src/main/java/com/laytonsmith/core/constructs/CBrace.java
+++ b/src/main/java/com/laytonsmith/core/constructs/CBrace.java
@@ -2,6 +2,7 @@
 
 import com.laytonsmith.PureUtilities.Version;
 import com.laytonsmith.core.ParseTree;
+import com.laytonsmith.core.constructs.generics.GenericParameters;
 import com.laytonsmith.core.natives.interfaces.Mixed;
 
 /**
@@ -46,4 +47,9 @@ public CClassType[] getInterfaces() {
 		return new CClassType[]{};
 	}
 
+	@Override
+	public GenericParameters getGenericParameters() {
+		return null;
+	}
+
 }
diff --git a/src/main/java/com/laytonsmith/core/constructs/CBracket.java b/src/main/java/com/laytonsmith/core/constructs/CBracket.java
index 08d16ceaf8..b9397a37f2 100644
--- a/src/main/java/com/laytonsmith/core/constructs/CBracket.java
+++ b/src/main/java/com/laytonsmith/core/constructs/CBracket.java
@@ -2,6 +2,7 @@
 
 import com.laytonsmith.PureUtilities.Version;
 import com.laytonsmith.core.ParseTree;
+import com.laytonsmith.core.constructs.generics.GenericParameters;
 import com.laytonsmith.core.natives.interfaces.Mixed;
 
 /**
@@ -46,4 +47,9 @@ public CClassType[] getInterfaces() {
 		return new CClassType[]{};
 	}
 
+	@Override
+	public GenericParameters getGenericParameters() {
+		return null;
+	}
+
 }
diff --git a/src/main/java/com/laytonsmith/core/constructs/CByteArray.java b/src/main/java/com/laytonsmith/core/constructs/CByteArray.java
index a6f93a368f..9aac413bc0 100644
--- a/src/main/java/com/laytonsmith/core/constructs/CByteArray.java
+++ b/src/main/java/com/laytonsmith/core/constructs/CByteArray.java
@@ -5,6 +5,7 @@
 import com.laytonsmith.annotations.typeof;
 import com.laytonsmith.core.ArgumentValidation;
 import com.laytonsmith.core.MSVersion;
+import com.laytonsmith.core.environments.Environment;
 import com.laytonsmith.core.exceptions.CRE.CRERangeException;
 import com.laytonsmith.core.exceptions.CRE.CREReadOnlyException;
 import com.laytonsmith.core.exceptions.CRE.CREUnsupportedOperationException;
@@ -28,7 +29,7 @@
  *
  */
 @typeof("ms.lang.byte_array")
-public class CByteArray extends CArray implements Sizeable, ArrayAccess {
+public final class CByteArray extends CArray implements Sizeable, ArrayAccess {
 
 	@SuppressWarnings("FieldNameHidesFieldInSuperclass")
 	public static final CClassType TYPE = CClassType.get(CByteArray.class);
@@ -389,9 +390,16 @@ public CByteArray getBytes(int size, Integer pos) {
 	 * Returns the current size of the byte array. This is not to be confused with the capacity.
 	 *
 	 * @return
+	 * @deprecated Use {@link #size(Environment)} instead.
 	 */
+	@Deprecated
 	@Override
 	public long size() {
+		return size(null);
+	}
+
+	@Override
+	public long size(Environment env) {
 		return maxValue;
 	}
 
@@ -485,8 +493,15 @@ public boolean canBeAssociative() {
 		return false;
 	}
 
+	/** @deprecated Use {@link #slice(int, int, Target, Environment)} instead. */
+	@Deprecated
 	@Override
 	public Mixed slice(int begin, int end, Target t) {
+		return slice(begin, end, t, null);
+	}
+
+	@Override
+	public Mixed slice(int begin, int end, Target t, Environment env) {
 		return getBytes(end - begin, begin);
 	}
 
@@ -525,8 +540,15 @@ public void push(Mixed c, Integer index, Target t) throws IllegalArgumentExcepti
 		throw new CREUnsupportedOperationException("Modifying a byte array using array_push() is not supported.", t);
 	}
 
+	/** @deprecated Use {@link #keySet(Environment)} instead. */
+	@Deprecated
 	@Override
 	public Set<Mixed> keySet() {
+		return keySet(null);
+	}
+
+	@Override
+	public Set<Mixed> keySet(Environment env) {
 		throw new CREUnsupportedOperationException("Getting a key set from a byte array is not supported.", getTarget());
 	}
 
@@ -535,8 +557,15 @@ public Set<String> stringKeySet() {
 		throw new CREUnsupportedOperationException("Getting a string key set from a byte array is not supported.", getTarget());
 	}
 
+	/** @deprecated Use {@link #set(Mixed, Mixed, Target, Environment)} instead. */
+	@Deprecated
 	@Override
 	public void set(Mixed index, Mixed c, Target t) throws ConfigRuntimeException {
+		set(index, c, t, null);
+	}
+
+	@Override
+	public void set(Mixed index, Mixed c, Target t, Environment env) throws ConfigRuntimeException {
 		throw new CREUnsupportedOperationException("Modifying a byte array using array_set() is not supported.", t);
 	}
 
@@ -549,9 +578,16 @@ protected CArray deepClone(CArray array, Target t, ArrayList<CArray[]> cloneRefs
 		return CByteArray.wrap(newArray, t);
 	}
 
+	/** @deprecated Use {@link #get(Mixed, Target, Environment)} instead. */
+	@Deprecated
 	@Override
 	public Mixed get(Mixed index, Target t) throws ConfigRuntimeException {
-		int i = ArgumentValidation.getInt32(index, t);
+		return get(index, t, null);
+	}
+
+	@Override
+	public Mixed get(Mixed index, Target t, Environment env) throws ConfigRuntimeException {
+		int i = ArgumentValidation.getInt32(index, t, env);
 		byte b = getByte(i);
 		return new CInt(b, t);
 	}
@@ -647,14 +683,28 @@ public void push(Mixed c, Integer i, Target t) {
 			throw new CREByteArrayReadOnlyException("Arrays copied from ByteArrays are read only", t);
 		}
 
+		/** @deprecated Use {@link #set(Mixed, Mixed, Target, Environment)} instead. */
+		@Deprecated
 		@Override
 		public void set(Mixed index, Mixed c, Target t) {
+			set(index, c, t, null);
+		}
+
+		@Override
+		public void set(Mixed index, Mixed c, Target t, Environment env) {
 			throw new CREByteArrayReadOnlyException("Arrays copied from ByteArrays are read only", t);
 		}
 
+		/** @deprecated Use {@link #get(Mixed, Target, Environment)} instead. */
+		@Deprecated
 		@Override
 		public Mixed get(Mixed index, Target t) {
-			int i = ArgumentValidation.getInt32(index, t);
+			return get(index, t, null);
+		}
+
+		@Override
+		public Mixed get(Mixed index, Target t, Environment env) {
+			int i = ArgumentValidation.getInt32(index, t, env);
 			try {
 				return new CInt(backing[i], t);
 			} catch (ArrayIndexOutOfBoundsException e) {
@@ -662,8 +712,15 @@ public Mixed get(Mixed index, Target t) {
 			}
 		}
 
+		/** @deprecated Use {@link #size(Environment)} instead. */
+		@Deprecated
 		@Override
 		public long size() {
+			return size(null);
+		}
+
+		@Override
+		public long size(Environment env) {
 			return backing.length;
 		}
 
@@ -718,7 +775,7 @@ public CClassType[] getSuperclasses() {
 
 		@Override
 		public Set<ObjectModifier> getObjectModifiers() {
-			return EnumSet.of(ObjectModifier.STATIC);
+			return EnumSet.of(ObjectModifier.STATIC, ObjectModifier.FINAL);
 		}
 
 		@Override
diff --git a/src/main/java/com/laytonsmith/core/constructs/CClassType.java b/src/main/java/com/laytonsmith/core/constructs/CClassType.java
index 554e3d1996..99e2378d54 100644
--- a/src/main/java/com/laytonsmith/core/constructs/CClassType.java
+++ b/src/main/java/com/laytonsmith/core/constructs/CClassType.java
@@ -592,11 +592,18 @@ public CClassType typeof() {
 
 	// TODO: These getters will eventually be re-done to support static methods, but for now that is out of scope,
 	// so we just specifically support enums for now.
+	/** @deprecated Use {@link #get(String, Target, Environment)} instead. */
+	@Deprecated
 	@Override
 	public Mixed get(String index, Target t) throws ConfigRuntimeException {
+		return get(index, t, null);
+	}
+
+	@Override
+	public Mixed get(String index, Target t, Environment env) throws ConfigRuntimeException {
 		if(isEnum()) {
 			try {
-				return NativeTypeList.getNativeEnumType(fqcn).get(index, t);
+				return NativeTypeList.getNativeEnumType(fqcn).get(index, t, env);
 			} catch (ClassNotFoundException ex) {
 				throw new RuntimeException(ex);
 			}
@@ -604,11 +611,18 @@ public Mixed get(String index, Target t) throws ConfigRuntimeException {
 		throw new CREUnsupportedOperationException("Unsupported operation", t);
 	}
 
+	/** @deprecated Use {@link #get(int, Target, Environment)} instead. */
+	@Deprecated
 	@Override
 	public Mixed get(int index, Target t) throws ConfigRuntimeException {
+		return get(index, t, null);
+	}
+
+	@Override
+	public Mixed get(int index, Target t, Environment env) throws ConfigRuntimeException {
 		if(isEnum()) {
 			try {
-				return NativeTypeList.getNativeEnumType(fqcn).get(index, t);
+				return NativeTypeList.getNativeEnumType(fqcn).get(index, t, env);
 			} catch (ClassNotFoundException ex) {
 				throw new RuntimeException(ex);
 			}
@@ -616,11 +630,18 @@ public Mixed get(int index, Target t) throws ConfigRuntimeException {
 		throw new CREUnsupportedOperationException("Unsupported operation", t);
 	}
 
+	/** @deprecated Use {@link #get(Mixed, Target, Environment)} instead. */
+	@Deprecated
 	@Override
 	public Mixed get(Mixed index, Target t) throws ConfigRuntimeException {
+		return get(index, t, null);
+	}
+
+	@Override
+	public Mixed get(Mixed index, Target t, Environment env) throws ConfigRuntimeException {
 		if(isEnum()) {
 			try {
-				return NativeTypeList.getNativeEnumType(fqcn).get(index, t);
+				return NativeTypeList.getNativeEnumType(fqcn).get(index, t, env);
 			} catch (ClassNotFoundException ex) {
 				throw new RuntimeException(ex);
 			}
@@ -628,11 +649,18 @@ public Mixed get(Mixed index, Target t) throws ConfigRuntimeException {
 		throw new CREUnsupportedOperationException("Unsupported operation", t);
 	}
 
+	/** @deprecated Use {@link #keySet(Environment)} instead. */
+	@Deprecated
 	@Override
 	public Set<Mixed> keySet() {
+		return keySet(null);
+	}
+
+	@Override
+	public Set<Mixed> keySet(Environment env) {
 		if(isEnum()) {
 			try {
-				return NativeTypeList.getNativeEnumType(fqcn).keySet();
+				return NativeTypeList.getNativeEnumType(fqcn).keySet(env);
 			} catch (ClassNotFoundException ex) {
 				throw new RuntimeException(ex);
 			}
@@ -640,11 +668,18 @@ public Set<Mixed> keySet() {
 		return new HashSet<>();
 	}
 
+	/** @deprecated Use {@link #size(Environment)} instead. */
+	@Deprecated
 	@Override
 	public long size() {
+		return size(null);
+	}
+
+	@Override
+	public long size(Environment env) {
 		if(isEnum()) {
 			try {
-				return NativeTypeList.getNativeEnumType(fqcn).size();
+				return NativeTypeList.getNativeEnumType(fqcn).size(env);
 			} catch (ClassNotFoundException ex) {
 				throw new RuntimeException(ex);
 			}
@@ -662,8 +697,15 @@ public boolean canBeAssociative() {
 		return true;
 	}
 
+	/** @deprecated Use {@link #slice(int, int, Target, Environment)} instead. */
+	@Deprecated
 	@Override
 	public Mixed slice(int begin, int end, Target t) {
+		return slice(begin, end, t, null);
+	}
+
+	@Override
+	public Mixed slice(int begin, int end, Target t, Environment env) {
 		throw new CREUnsupportedOperationException("Unsupported operation", t);
 	}
 
@@ -677,8 +719,15 @@ public Class<? extends Mixed> getNativeType() {
 		return nativeClass;
 	}
 
+	/** @deprecated Use {@link #getBooleanValue(Target, Environment)} instead. */
+	@Deprecated
 	@Override
 	public boolean getBooleanValue(Target t) {
+		return getBooleanValue(t, null);
+	}
+
+	@Override
+	public boolean getBooleanValue(Target t, Environment env) {
 		return true;
 	}
 
@@ -741,6 +790,7 @@ public GenericTypeParameters getTypeGenericParameters() {
 	/**
 	 * Stub for generics support — not yet implemented.
 	 */
+	@Override
 	public GenericParameters getGenericParameters() {
 		throw new UnsupportedOperationException("Not yet implemented");
 	}
diff --git a/src/main/java/com/laytonsmith/core/constructs/CClosure.java b/src/main/java/com/laytonsmith/core/constructs/CClosure.java
index ae8d0131c4..a9a1afbdb4 100644
--- a/src/main/java/com/laytonsmith/core/constructs/CClosure.java
+++ b/src/main/java/com/laytonsmith/core/constructs/CClosure.java
@@ -3,12 +3,14 @@
 import com.laytonsmith.PureUtilities.Version;
 import com.laytonsmith.annotations.typeof;
 import com.laytonsmith.core.ArgumentValidation;
+import com.laytonsmith.core.CallbackYield;
 import com.laytonsmith.core.functions.Compiler;
 import com.laytonsmith.core.natives.interfaces.Booleanish;
 import com.laytonsmith.core.natives.interfaces.Callable;
 import com.laytonsmith.core.MSVersion;
-import com.laytonsmith.core.MethodScriptCompiler;
 import com.laytonsmith.core.ParseTree;
+import com.laytonsmith.core.Script;
+import com.laytonsmith.core.StepAction;
 import com.laytonsmith.core.compiler.CompilerEnvironment;
 import com.laytonsmith.core.compiler.CompilerWarning;
 import com.laytonsmith.core.compiler.FileOptions;
@@ -20,14 +22,11 @@
 import com.laytonsmith.core.exceptions.CRE.CREStackOverflowError;
 import com.laytonsmith.core.exceptions.CancelCommandException;
 import com.laytonsmith.core.exceptions.ConfigRuntimeException;
-import com.laytonsmith.core.exceptions.FunctionReturnException;
-import com.laytonsmith.core.exceptions.LoopManipulationException;
-import com.laytonsmith.core.exceptions.ProgramFlowManipulationException;
+import com.laytonsmith.core.exceptions.StackTraceFrame;
 import com.laytonsmith.core.exceptions.StackTraceManager;
-import com.laytonsmith.core.functions.DataHandling;
+import com.laytonsmith.core.exceptions.UnhandledFlowControlException;
+import com.laytonsmith.core.functions.Exceptions;
 import com.laytonsmith.core.natives.interfaces.Mixed;
-import java.util.ArrayList;
-import java.util.List;
 import java.util.logging.Level;
 import java.util.logging.Logger;
 
@@ -104,7 +103,7 @@ private void condense(ParseTree node, StringBuilder b) {
 				}
 				b.append(")");
 			}
-		} else if(node.getData().isInstanceOf(CString.TYPE)) {
+		} else if(node.getData().isInstanceOf(CString.TYPE, null, env)) {
 			String data = ArgumentValidation.getString(node.getData(), node.getTarget());
 			// Convert: \ -> \\ and ' -> \'
 			b.append("'").append(data.replace("\\", "\\\\").replace("\t", "\\t").replace("\n", "\\n")
@@ -120,6 +119,131 @@ public ParseTree getNode() {
 		return node;
 	}
 
+	/**
+	 * Prepares the closure for execution by cloning the environment, binding arguments,
+	 * and pushing a stack trace element. This extracts the setup logic from {@link #execute}
+	 * so that the iterative interpreter can evaluate the closure body on the shared EvalStack
+	 * 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#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
+	 * @return A {@link PreparedExecution} containing the prepared environment
+	 * @throws ConfigRuntimeException If argument type checking fails
+	 */
+	public PreparedExecution prepareExecution(Mixed... values) throws ConfigRuntimeException {
+		if(node == null) {
+			return null;
+		}
+		Environment env;
+		try {
+			synchronized(this) {
+				env = this.env.clone();
+			}
+		} catch(CloneNotSupportedException ex) {
+			Logger.getLogger(CClosure.class.getName()).log(Level.SEVERE, null, ex);
+			return null;
+		}
+		StackTraceManager stManager = env.getEnv(GlobalEnv.class).GetStackTraceManager();
+		stManager.addStackTraceFrame(new StackTraceFrame("<<closure>>", getTarget()));
+
+		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 {
+					try {
+						value = defaults[i].clone();
+					} catch(CloneNotSupportedException ex) {
+						Logger.getLogger(CClosure.class.getName()).log(Level.SEVERE, null, ex);
+						value = defaults[i];
+					}
+				}
+				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()));
+		}
+
+		return new PreparedExecution(env, returnType);
+	}
+
+	/**
+	 * The result of {@link #prepareExecution}. Contains the cloned environment with arguments
+	 * bound, ready for the closure body to be evaluated.
+	 */
+	public static class PreparedExecution {
+		private final Environment env;
+		private final CClassType returnType;
+
+		PreparedExecution(Environment env, CClassType returnType) {
+			this.env = env;
+			this.returnType = returnType;
+		}
+
+		public Environment getEnv() {
+			return env;
+		}
+
+		public CClassType getReturnType() {
+			return returnType;
+		}
+	}
+
+	@Override
+	public Callable.PreparedCallable prepareForStack(Environment callerEnv, Target t, Mixed... values) {
+		PreparedExecution prep = prepareExecution(values);
+		if(prep == null) {
+			return null;
+		}
+		return new Callable.PreparedCallable(getNode(), prep.getEnv());
+	}
+
 	@Override
 	public CClosure clone() throws CloneNotSupportedException {
 		CClosure clone = (CClosure) super.clone();
@@ -144,14 +268,17 @@ 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 ProgramFlowManipulationException
 	 * @throws CancelCommandException
+	 * @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
 	public Mixed executeCallable(Mixed... values) {
 		return executeCallable(null, Target.UNKNOWN, values);
 	}
@@ -160,17 +287,21 @@ 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.
 	 *
-	 * LoopManipulationExceptions will never bubble up past this point, because they are never allowed, so they are
-	 * handled automatically, but other ProgramFlowManipulationExceptions will, . ConfigRuntimeExceptions will also
-	 * bubble up past this, since an execution mechanism may need to do custom handling.
+	 * <p>ConfigRuntimeExceptions will bubble up past this, since an execution mechanism may need to do custom
+	 * handling.</p>
 	 *
-	 * A typical execution will include the following code:
+	 * <p>Note: This method starts a fresh top-level evaluation, which is correct for callers that run the
+	 * closure on a new thread (e.g., x_new_thread). However, callers that execute the closure on the
+	 * <em>same</em> thread within an already-running eval loop should extend {@link CallbackYield} and use
+	 * {@link #prepareForStack} instead, to avoid re-entering eval() and defeating the iterative interpreter.</p>
+	 *
+	 * <p>A typical execution will include the following code:</p>
 	 * <pre>
 	 * try {
-	 *	closure.execute();
+	 *	closure.executeCallable(env, t);
 	 * } catch (ConfigRuntimeException e){
-	 *	ConfigRuntimeException.HandleUncaughtException(e);
-	 * } catch (ProgramFlowManipulationException e){
+	 *	ConfigRuntimeException.HandleUncaughtException(e, env);
+	 * } catch (CancelCommandException e){
 	 *	// Ignored
 	 * }
 	 * </pre>
@@ -181,145 +312,66 @@ public Mixed executeCallable(Mixed... values) {
 	 * @param values The values to be passed to the closure
 	 * @return The return value of the closure, or VOID if nothing was returned
 	 * @throws ConfigRuntimeException If any call inside the closure causes a CRE
-	 * @throws ProgramFlowManipulationException If any ProgramFlowManipulationException is thrown (other than a
-	 * LoopManipulationException) within the closure
+	 * @throws CancelCommandException If die() is called within the closure
+	 * @deprecated Functions that call closures should extend {@link CallbackYield}
+	 * instead of calling this directly, which re-enters eval() and defeats the iterative interpreter.
 	 */
+	@Deprecated
 	@Override
 	public Mixed executeCallable(Environment env, Target t, Mixed... values)
-			throws ConfigRuntimeException, ProgramFlowManipulationException, CancelCommandException {
-		try {
-			execute(values);
-		} catch (FunctionReturnException e) {
-			return e.getReturn();
-		}
-		return CVoid.VOID;
+			throws ConfigRuntimeException, CancelCommandException {
+		return execute(values);
 	}
 
 	/**
 	 * @param values
 	 * @throws ConfigRuntimeException
-	 * @throws ProgramFlowManipulationException
-	 * @throws FunctionReturnException
 	 * @throws CancelCommandException
 	 */
-	protected void execute(Mixed... values) throws ConfigRuntimeException, ProgramFlowManipulationException,
-			FunctionReturnException, CancelCommandException {
-		if(node == null) {
-			return;
+	protected Mixed execute(Mixed... values) throws ConfigRuntimeException,
+			CancelCommandException {
+		PreparedExecution prep = prepareExecution(values);
+		if(prep == null) {
+			return CVoid.VOID;
 		}
-		Environment environment;
+		Environment env = prep.getEnv();
+		StackTraceManager stManager = env.getEnv(GlobalEnv.class).GetStackTraceManager();
 		try {
-			synchronized(this) {
-				environment = env.clone();
+			Script script = env.getEnv(GlobalEnv.class).GetScript();
+			if(script == null) {
+				script = Script.GenerateScript(node, env.getEnv(GlobalEnv.class).GetLabel(), null);
 			}
-		} catch (CloneNotSupportedException ex) {
-			Logger.getLogger(CClosure.class.getName()).log(Level.SEVERE, null, ex);
-			return;
-		}
-		StackTraceManager stManager = environment.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());
-								environment.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(), varargType.getVarargsBaseType(), env)) {
-								throw new CRECastException("Expected type " + varargType + " but found " + value.typeof(),
-										getTarget());
-							}
-							vararg.push(value, value.getTarget());
-						} else {
-							IVariable var = new IVariable(types[i], name, value, getTarget(), environment);
-							environment.getEnv(GlobalEnv.class).GetVarList().set(var);
-						}
+			Mixed result;
+			try {
+				result = script.eval(node, env);
+			} catch(UnhandledFlowControlException e) {
+				StepAction.FlowControlAction action = e.getAction();
+				if(action instanceof Exceptions.ThrowAction throwAction) {
+					ConfigRuntimeException ex = throwAction.getException();
+					ex.setEnv(env);
+					if(ex instanceof AbstractCREException) {
+						((AbstractCREException) ex).freezeStackTraceElements(stManager);
 					}
+					throw ex;
 				}
-			}
-			boolean hasArgumentsParam = false;
-			for(String pName : this.names) {
-				if(pName.equals("@arguments")) {
-					hasArgumentsParam = true;
-					break;
-				}
-			}
-
-			if(!hasArgumentsParam) {
-				environment.getEnv(GlobalEnv.class).GetVarList().set(new IVariable(CArray.TYPE, "@arguments", arguments,
-						node.getData().getTarget()));
-			}
-
-			ParseTree newNode = new ParseTree(new CFunction(DataHandling.g.NAME, getTarget()), node.getFileOptions());
-			List<ParseTree> children = new ArrayList<>();
-			children.add(node);
-			newNode.setChildren(children);
-			try {
-				MethodScriptCompiler.execute(newNode, environment, null, environment.getEnv(GlobalEnv.class)
-						.GetScript());
-			} catch (LoopManipulationException e) {
-				//This shouldn't ever happen.
-				LoopManipulationException lme = ((LoopManipulationException) e);
-				Target t = lme.getTarget();
+				Target t = action.getTarget();
 				ConfigRuntimeException.HandleUncaughtException(ConfigRuntimeException.CreateUncatchableException("A "
-						+ lme.getName() + "() bubbled up to the top of"
-						+ " a closure, which is unexpected behavior.", t), environment);
-			} catch (FunctionReturnException ex) {
-				// Check the return type of the closure to see if it matches the defined type
-				// Normal execution.
-				Mixed ret = ex.getReturn();
-				if(!InstanceofUtil.isInstanceof(ret.typeof(), returnType, environment)) {
-					throw new CRECastException("Expected closure to return a value of type " + returnType.val()
-							+ " but a value of type " + ret.typeof() + " was returned instead", ret.getTarget());
-				}
-				// Now rethrow it
-				throw ex;
-			} catch (CancelCommandException e) {
-				// die()
-			} catch (ConfigRuntimeException ex) {
-				ex.setEnv(environment);
-				if(ex instanceof AbstractCREException) {
-					((AbstractCREException) ex).freezeStackTraceElements(stManager);
-				}
-				throw ex;
-			} catch (StackOverflowError e) {
+						+ "flow control action bubbled up to the top of"
+						+ " a closure, which is unexpected behavior.", t), env);
+				return CVoid.VOID;
+			} catch(StackOverflowError e) {
 				throw new CREStackOverflowError(null, node.getTarget(), e);
-			} finally {
-				stManager.popStackTraceElement();
 			}
-			// If we got here, then there was no return type. This is fine, but only for returnType void or auto.
-			if(!(returnType.equals(Auto.TYPE) || returnType.equals(CVoid.TYPE))) {
-				throw new CRECastException("Expecting closure to return a value of type " + returnType.val() + ","
-						+ " but no value was returned.", node.getTarget());
+
+			if(!returnType.equals(Auto.TYPE)
+					&& !InstanceofUtil.isInstanceof(result.typeof(env), returnType, env)) {
+				throw new CRECastException("Expected closure to return a value of type " + returnType.val()
+						+ " but a value of type " + result.typeof(env) + " was returned instead",
+						result.getTarget());
 			}
-		} catch (CloneNotSupportedException ex) {
-			Logger.getLogger(CClosure.class.getName()).log(Level.SEVERE, null, ex);
+			return result;
+		} finally {
+			stManager.popStackTraceFrame();
 		}
 	}
 
@@ -350,8 +402,15 @@ public CClassType[] getInterfaces() {
 		return new CClassType[]{Callable.TYPE, Booleanish.TYPE};
 	}
 
+	/** @deprecated Use {@link #getBooleanValue(Target, Environment)} instead. */
+	@Deprecated
 	@Override
 	public boolean getBooleanValue(Target t) {
+		return getBooleanValue(t, null);
+	}
+
+	@Override
+	public boolean getBooleanValue(Target t, Environment env) {
 		return true;
 	}
 }
diff --git a/src/main/java/com/laytonsmith/core/constructs/CDecimal.java b/src/main/java/com/laytonsmith/core/constructs/CDecimal.java
index 640f54f9d8..8bed5efa14 100644
--- a/src/main/java/com/laytonsmith/core/constructs/CDecimal.java
+++ b/src/main/java/com/laytonsmith/core/constructs/CDecimal.java
@@ -3,6 +3,7 @@
 import com.laytonsmith.PureUtilities.Version;
 import com.laytonsmith.annotations.typeof;
 import com.laytonsmith.core.MSVersion;
+import com.laytonsmith.core.environments.Environment;
 import com.laytonsmith.core.exceptions.CRE.CREFormatException;
 import java.math.BigDecimal;
 
@@ -83,8 +84,15 @@ public CDecimal duplicate() {
 		return new CDecimal(val, getTarget());
 	}
 
+	/** @deprecated Use {@link #getBooleanValue(Target, Environment)} instead. */
+	@Deprecated
 	@Override
 	public boolean getBooleanValue(Target t) {
+		return getBooleanValue(t, null);
+	}
+
+	@Override
+	public boolean getBooleanValue(Target t, Environment env) {
 		return val.compareTo(new BigDecimal(0)) != 0;
 	}
 
diff --git a/src/main/java/com/laytonsmith/core/constructs/CDouble.java b/src/main/java/com/laytonsmith/core/constructs/CDouble.java
index 53939ed678..b873010aea 100644
--- a/src/main/java/com/laytonsmith/core/constructs/CDouble.java
+++ b/src/main/java/com/laytonsmith/core/constructs/CDouble.java
@@ -3,6 +3,7 @@
 import com.laytonsmith.PureUtilities.Version;
 import com.laytonsmith.annotations.typeof;
 import com.laytonsmith.core.MSVersion;
+import com.laytonsmith.core.constructs.generics.GenericParameters;
 import com.laytonsmith.core.exceptions.CRE.CREFormatException;
 
 /**
@@ -77,4 +78,9 @@ public double getNumber() {
 		return val;
 	}
 
+	@Override
+	public GenericParameters getGenericParameters() {
+		return null;
+	}
+
 }
diff --git a/src/main/java/com/laytonsmith/core/constructs/CEntry.java b/src/main/java/com/laytonsmith/core/constructs/CEntry.java
index 3f7726a891..9ab5d70ed6 100644
--- a/src/main/java/com/laytonsmith/core/constructs/CEntry.java
+++ b/src/main/java/com/laytonsmith/core/constructs/CEntry.java
@@ -1,6 +1,7 @@
 package com.laytonsmith.core.constructs;
 
 import com.laytonsmith.PureUtilities.Version;
+import com.laytonsmith.core.constructs.generics.GenericParameters;
 import com.laytonsmith.core.natives.interfaces.Mixed;
 
 /**
@@ -61,4 +62,9 @@ public CClassType[] getInterfaces() {
 		return new CClassType[]{};
 	}
 
+	@Override
+	public GenericParameters getGenericParameters() {
+		return null;
+	}
+
 }
diff --git a/src/main/java/com/laytonsmith/core/constructs/CFixedArray.java b/src/main/java/com/laytonsmith/core/constructs/CFixedArray.java
index 6f57ecb57e..3f3c621f2e 100644
--- a/src/main/java/com/laytonsmith/core/constructs/CFixedArray.java
+++ b/src/main/java/com/laytonsmith/core/constructs/CFixedArray.java
@@ -9,6 +9,7 @@
 import com.laytonsmith.core.exceptions.CRE.CREIndexOverflowException;
 import com.laytonsmith.core.exceptions.CRE.CREUnsupportedOperationException;
 import com.laytonsmith.core.exceptions.ConfigRuntimeException;
+import com.laytonsmith.core.environments.Environment;
 import com.laytonsmith.core.natives.interfaces.ArrayAccessSet;
 import com.laytonsmith.core.natives.interfaces.Booleanish;
 import com.laytonsmith.core.natives.interfaces.Mixed;
@@ -43,13 +44,27 @@ public boolean isDynamic() {
 		return true;
 	}
 
+	/** @deprecated Use {@link #get(String, Target, Environment)} instead. */
+	@Deprecated
 	@Override
 	public Mixed get(String index, Target t) throws ConfigRuntimeException {
+		return get(index, t, null);
+	}
+
+	@Override
+	public Mixed get(String index, Target t, Environment env) throws ConfigRuntimeException {
 		return null;
 	}
 
+	/** @deprecated Use {@link #get(int, Target, Environment)} instead. */
+	@Deprecated
 	@Override
 	public Mixed get(int index, Target t) throws ConfigRuntimeException {
+		return get(index, t, null);
+	}
+
+	@Override
+	public Mixed get(int index, Target t, Environment env) throws ConfigRuntimeException {
 		if(index < 0 || index >= data.length) {
 			throw new CREIndexOverflowException("Index overflows array size", t);
 		}
@@ -60,13 +75,27 @@ public Mixed get(int index, Target t) throws ConfigRuntimeException {
 		return d;
 	}
 
+	/** @deprecated Use {@link #get(Mixed, Target, Environment)} instead. */
+	@Deprecated
 	@Override
 	public Mixed get(Mixed index, Target t) throws ConfigRuntimeException {
-		return get(ArgumentValidation.getInt32(index, t), t);
+		return get(index, t, null);
 	}
 
+	@Override
+	public Mixed get(Mixed index, Target t, Environment env) throws ConfigRuntimeException {
+		return get(ArgumentValidation.getInt32(index, t, env), t, env);
+	}
+
+	/** @deprecated Use {@link #keySet(Environment)} instead. */
+	@Deprecated
 	@Override
 	public Set<Mixed> keySet() {
+		return keySet(null);
+	}
+
+	@Override
+	public Set<Mixed> keySet(Environment env) {
 		Set<Mixed> set = new LinkedHashSet<>(data.length);
 		for(int i = 0; i < data.length; i++) {
 			set.add(new CInt(i, Target.UNKNOWN));
@@ -74,20 +103,27 @@ public Set<Mixed> keySet() {
 		return set;
 	}
 
-	private void validateSet(Mixed value, Target t) {
-		if(!value.typeof().doesExtend(allowedType)) {
-			throw new CRECastException("Cannot set value of type " + value.typeof().toString() + " into fixed_array of type " + allowedType.toString(), t);
+	private void validateSet(Mixed value, Target t, Environment env) {
+		if(!value.typeof(env).doesExtend(allowedType)) {
+			throw new CRECastException("Cannot set value of type " + value.typeof(env).toString() + " into fixed_array of type " + allowedType.toString(), t);
 		}
 	}
 
+	/** @deprecated Use {@link #set(Mixed, Mixed, Target, Environment)} instead. */
+	@Deprecated
 	@Override
 	public void set(Mixed index, Mixed value, Target t) {
-		int in = ArgumentValidation.getInt32(index, t);
-		set(in, value, t);
+		set(index, value, t, null);
 	}
 
-	public void set(int index, Mixed value, Target t) {
-		validateSet(value, t);
+	@Override
+	public void set(Mixed index, Mixed value, Target t, Environment env) {
+		int in = ArgumentValidation.getInt32(index, t, env);
+		set(in, value, t, env);
+	}
+
+	public void set(int index, Mixed value, Target t, Environment env) {
+		validateSet(value, t, env);
 		if(index >= data.length || index < 0) {
 			throw new CREIndexOverflowException("Index under/overflow in fixed_array", t);
 		}
@@ -104,23 +140,44 @@ public boolean canBeAssociative() {
 		return false;
 	}
 
+	/** @deprecated Use {@link #slice(int, int, Target, Environment)} instead. */
+	@Deprecated
 	@Override
 	public Mixed slice(int begin, int end, Target t) {
+		return slice(begin, end, t, null);
+	}
+
+	@Override
+	public Mixed slice(int begin, int end, Target t, Environment env) {
 		throw new CREUnsupportedOperationException("slices are not yet implemented on fixed_array", t);
 	}
 
+	/** @deprecated Use {@link #getBooleanValue(Target, Environment)} instead. */
+	@Deprecated
 	@Override
 	public boolean getBooleanValue(Target t) {
-		return size() > 0;
+		return getBooleanValue(t, null);
 	}
 
+	@Override
+	public boolean getBooleanValue(Target t, Environment env) {
+		return size(env) > 0;
+	}
+
+	/** @deprecated Use {@link #size(Environment)} instead. */
+	@Deprecated
 	@Override
 	public long size() {
+		return size(null);
+	}
+
+	@Override
+	public long size(Environment env) {
 		return data.length;
 	}
 
-	public void fill(Mixed value, Target t) {
-		validateSet(value, t);
+	public void fill(Mixed value, Target t, Environment env) {
+		validateSet(value, t, env);
 		ArrayUtils.fill(data, value);
 	}
 
diff --git a/src/main/java/com/laytonsmith/core/constructs/CFunction.java b/src/main/java/com/laytonsmith/core/constructs/CFunction.java
index 6d113a0bc6..0c1610fb7a 100644
--- a/src/main/java/com/laytonsmith/core/constructs/CFunction.java
+++ b/src/main/java/com/laytonsmith/core/constructs/CFunction.java
@@ -7,6 +7,7 @@
 
 import com.laytonsmith.PureUtilities.Version;
 import com.laytonsmith.core.ParseTree;
+import com.laytonsmith.core.constructs.generics.GenericParameters;
 import com.laytonsmith.core.environments.Environment;
 import com.laytonsmith.core.environments.Environment.EnvironmentImpl;
 import com.laytonsmith.core.exceptions.ConfigCompileException;
@@ -165,4 +166,9 @@ public CClassType[] getInterfaces() {
 		return new CClassType[]{};
 	}
 
+	@Override
+	public GenericParameters getGenericParameters() {
+		return null;
+	}
+
 }
diff --git a/src/main/java/com/laytonsmith/core/constructs/CIClosure.java b/src/main/java/com/laytonsmith/core/constructs/CIClosure.java
index 10430dcc3a..5ea84ef78f 100644
--- a/src/main/java/com/laytonsmith/core/constructs/CIClosure.java
+++ b/src/main/java/com/laytonsmith/core/constructs/CIClosure.java
@@ -31,9 +31,9 @@ public CIClosure(ParseTree node, Environment env, CClassType returnType, String[
 //		StackTraceManager stManager = env.getEnv(GlobalEnv.class).GetStackTraceManager();
 //		stManager.addStackTraceElement(new ConfigRuntimeException.StackTraceElement("<<iclosure>>", getTarget()));
 //		try {
-//			Environment environment;
+//			Environment env;
 //			synchronized(this) {
-//				environment = env.clone();
+//				env = env.clone();
 //			}
 //			if(values != null) {
 //				for(int i = 0; i < names.length; i++) {
@@ -44,8 +44,8 @@ public CIClosure(ParseTree node, Environment env, CClassType returnType, String[
 //					} catch (Exception e) {
 //						value = defaults[i].clone();
 //					}
-//					environment.getEnv(GlobalEnv.class).GetVarList().set(new IVariable(types[i], name, value,
-//							getTarget(), environment));
+//					env.getEnv(GlobalEnv.class).GetVarList().set(new IVariable(types[i], name, value,
+//							getTarget(), env));
 //				}
 //			}
 //			boolean hasArgumentsParam = false;
@@ -63,7 +63,7 @@ public CIClosure(ParseTree node, Environment env, CClassType returnType, String[
 //						arguments.push(value, node.getData().getTarget());
 //					}
 //				}
-//				environment.getEnv(GlobalEnv.class).GetVarList().set(new IVariable(CArray.TYPE, "@arguments", arguments,
+//				env.getEnv(GlobalEnv.class).GetVarList().set(new IVariable(CArray.TYPE, "@arguments", arguments,
 //						node.getData().getTarget()));
 //			}
 //
@@ -72,7 +72,7 @@ public CIClosure(ParseTree node, Environment env, CClassType returnType, String[
 //			children.add(node);
 //			newNode.setChildren(children);
 //			try {
-//				MethodScriptCompiler.execute(newNode, environment, null, environment.getEnv(GlobalEnv.class)
+//				MethodScriptCompiler.execute(newNode, env, null, env.getEnv(GlobalEnv.class)
 //						.GetScript());
 //			} catch (LoopManipulationException e) {
 //				//This shouldn't ever happen.
@@ -84,7 +84,7 @@ public CIClosure(ParseTree node, Environment env, CClassType returnType, String[
 //			} catch (FunctionReturnException ex) {
 //				// Check the return type of the closure to see if it matches the defined type
 //				Mixed ret = ex.getReturn();
-//				if(!InstanceofUtil.isInstanceof(ret, returnType, environment)) {
+//				if(!InstanceofUtil.isInstanceof(ret, returnType, env)) {
 //					throw new CRECastException("Expected closure to return a value of type " + returnType.val()
 //							+ " but a value of type " + ret.typeof() + " was returned instead", ret.getTarget());
 //				}
diff --git a/src/main/java/com/laytonsmith/core/constructs/CInt.java b/src/main/java/com/laytonsmith/core/constructs/CInt.java
index b2714cf392..d48ab6708d 100644
--- a/src/main/java/com/laytonsmith/core/constructs/CInt.java
+++ b/src/main/java/com/laytonsmith/core/constructs/CInt.java
@@ -3,6 +3,7 @@
 import com.laytonsmith.PureUtilities.Version;
 import com.laytonsmith.annotations.typeof;
 import com.laytonsmith.core.MSVersion;
+import com.laytonsmith.core.constructs.generics.GenericParameters;
 import com.laytonsmith.core.exceptions.CRE.CREFormatException;
 
 /**
@@ -76,4 +77,9 @@ public double getNumber() {
 		return (double) val;
 	}
 
+	@Override
+	public GenericParameters getGenericParameters() {
+		return null;
+	}
+
 }
diff --git a/src/main/java/com/laytonsmith/core/constructs/CKeyword.java b/src/main/java/com/laytonsmith/core/constructs/CKeyword.java
index 287f15430f..788dbe5b6d 100644
--- a/src/main/java/com/laytonsmith/core/constructs/CKeyword.java
+++ b/src/main/java/com/laytonsmith/core/constructs/CKeyword.java
@@ -4,6 +4,7 @@
 import com.laytonsmith.core.ParseTree;
 import com.laytonsmith.core.compiler.Keyword;
 import com.laytonsmith.core.compiler.KeywordList;
+import com.laytonsmith.core.constructs.generics.GenericParameters;
 import com.laytonsmith.core.natives.interfaces.Mixed;
 
 /**
@@ -58,4 +59,9 @@ public CClassType[] getInterfaces() {
 	public CKeyword duplicate() {
 		throw new UnsupportedOperationException("Should have been removed at compile time");
 	}
+
+	@Override
+	public GenericParameters getGenericParameters() {
+		return null;
+	}
 }
diff --git a/src/main/java/com/laytonsmith/core/constructs/CLabel.java b/src/main/java/com/laytonsmith/core/constructs/CLabel.java
index d66c5373ad..0167308ed9 100644
--- a/src/main/java/com/laytonsmith/core/constructs/CLabel.java
+++ b/src/main/java/com/laytonsmith/core/constructs/CLabel.java
@@ -2,6 +2,7 @@
 
 import com.laytonsmith.PureUtilities.Version;
 import com.laytonsmith.core.constructs.Construct.ConstructType;
+import com.laytonsmith.core.constructs.generics.GenericParameters;
 import com.laytonsmith.core.natives.interfaces.Mixed;
 
 /**
@@ -51,4 +52,9 @@ public CClassType[] getInterfaces() {
 		return new CClassType[]{};
 	}
 
+	@Override
+	public GenericParameters getGenericParameters() {
+		return null;
+	}
+
 }
diff --git a/src/main/java/com/laytonsmith/core/constructs/CLock.java b/src/main/java/com/laytonsmith/core/constructs/CLock.java
index c6f5de4fc4..8559874a34 100644
--- a/src/main/java/com/laytonsmith/core/constructs/CLock.java
+++ b/src/main/java/com/laytonsmith/core/constructs/CLock.java
@@ -1,6 +1,7 @@
 package com.laytonsmith.core.constructs;
 
 import com.laytonsmith.PureUtilities.Version;
+import com.laytonsmith.core.constructs.generics.GenericParameters;
 import com.laytonsmith.core.natives.interfaces.Mixed;
 
 /**
@@ -85,4 +86,9 @@ public CClassType[] getInterfaces() {
 		return new CClassType[]{};
 	}
 
+	@Override
+	public GenericParameters getGenericParameters() {
+		return null;
+	}
+
 }
diff --git a/src/main/java/com/laytonsmith/core/constructs/CMutablePrimitive.java b/src/main/java/com/laytonsmith/core/constructs/CMutablePrimitive.java
index ca2c2e831e..b32896aecf 100644
--- a/src/main/java/com/laytonsmith/core/constructs/CMutablePrimitive.java
+++ b/src/main/java/com/laytonsmith/core/constructs/CMutablePrimitive.java
@@ -4,20 +4,24 @@
 import com.laytonsmith.annotations.typeof;
 import com.laytonsmith.core.ArgumentValidation;
 import com.laytonsmith.core.MSVersion;
+import com.laytonsmith.core.environments.Environment;
 import com.laytonsmith.core.exceptions.CRE.CRECastException;
 import com.laytonsmith.core.exceptions.CRE.CREFormatException;
 import com.laytonsmith.core.natives.interfaces.Mixed;
 import com.laytonsmith.core.natives.interfaces.Sizeable;
 import com.laytonsmith.core.natives.interfaces.ValueType;
+import com.laytonsmith.core.objects.ObjectModifier;
 import java.util.ArrayList;
+import java.util.EnumSet;
 import java.util.List;
+import java.util.Set;
 import java.util.Stack;
 
 /**
  *
  */
 @typeof("ms.lang.mutable_primitive")
-public class CMutablePrimitive extends CArray implements Sizeable {
+public final class CMutablePrimitive extends CArray implements Sizeable {
 
 	@SuppressWarnings("FieldNameHidesFieldInSuperclass")
 	public static final CClassType TYPE = CClassType.get(CMutablePrimitive.class);
@@ -38,21 +42,35 @@ public boolean isDynamic() {
 		return true;
 	}
 
+	/** @deprecated Use {@link #set(Mixed, Target, Environment)} instead. */
+	@Deprecated
+	public void set(Mixed value, Target t) {
+		set(value, t, null);
+	}
+
 	/**
 	 * Sets the value of the underlying primitive. Only primitives (and null) may be stored.
 	 *
 	 * @param value
 	 * @param t
+	 * @param env
 	 */
-	public void set(Mixed value, Target t) {
-		if(!value.isInstanceOf(ValueType.TYPE)) {
+	public void set(Mixed value, Target t, Environment env) {
+		if(!value.isInstanceOf(ValueType.TYPE, null, env)) {
 			throw new CREFormatException("mutable_primitives can only store primitive values.", t);
 		}
 		this.value = value;
 	}
 
+	/** @deprecated Use {@link #set(Mixed, Mixed, Target, Environment)} instead. */
+	@Deprecated
 	@Override
 	public void set(Mixed index, Mixed c, Target t) {
+		set(index, c, t, null);
+	}
+
+	@Override
+	public void set(Mixed index, Mixed c, Target t, Environment env) {
 		throw new CRECastException("mutable_primitives cannot have values set in them", t);
 	}
 
@@ -74,8 +92,15 @@ public Mixed get() {
 		return value;
 	}
 
+	/** @deprecated Use {@link #get(Mixed, Target, Environment)} instead. */
+	@Deprecated
 	@Override
 	public Mixed get(Mixed index, Target t) {
+		return get(index, t, null);
+	}
+
+	@Override
+	public Mixed get(Mixed index, Target t, Environment env) {
 		return value;
 	}
 
@@ -99,10 +124,17 @@ protected String getQuote() {
 		return new CString(value.val(), Target.UNKNOWN).getQuote();
 	}
 
+	/** @deprecated Use {@link #size(Environment)} instead. */
+	@Deprecated
 	@Override
 	public long size() {
-		if(value.isInstanceOf(Sizeable.TYPE)) {
-			return ArgumentValidation.getObject(value, Target.UNKNOWN, Sizeable.class).size();
+		return size(null);
+	}
+
+	@Override
+	public long size(Environment env) {
+		if(value.isInstanceOf(Sizeable.TYPE, null, env)) {
+			return ArgumentValidation.getObject(value, Target.UNKNOWN, Sizeable.class).size(env);
 		} else {
 			return 0;
 		}
@@ -136,7 +168,7 @@ protected List<Mixed> getArray() {
 	}
 
 	@Override
-	protected String getString(Stack<CArray> arrays, Target t) {
+	protected String getString(Stack<CArray> arrays, Target t, Environment env) {
 		return value.val();
 	}
 
@@ -165,4 +197,9 @@ public CClassType[] getInterfaces() {
 		return new CClassType[]{Sizeable.TYPE};
 	}
 
+	@Override
+	public Set<ObjectModifier> getObjectModifiers() {
+		return EnumSet.of(ObjectModifier.FINAL);
+	}
+
 }
diff --git a/src/main/java/com/laytonsmith/core/constructs/CNativeClosure.java b/src/main/java/com/laytonsmith/core/constructs/CNativeClosure.java
index c2ca007bd6..cac4583297 100644
--- a/src/main/java/com/laytonsmith/core/constructs/CNativeClosure.java
+++ b/src/main/java/com/laytonsmith/core/constructs/CNativeClosure.java
@@ -2,11 +2,11 @@
 
 import com.laytonsmith.PureUtilities.Version;
 import com.laytonsmith.annotations.typeof;
+import com.laytonsmith.core.CallbackYield;
 import com.laytonsmith.core.MSVersion;
 import com.laytonsmith.core.environments.Environment;
 import com.laytonsmith.core.exceptions.CancelCommandException;
 import com.laytonsmith.core.exceptions.ConfigRuntimeException;
-import com.laytonsmith.core.exceptions.ProgramFlowManipulationException;
 import com.laytonsmith.core.natives.interfaces.Callable;
 import com.laytonsmith.core.natives.interfaces.Mixed;
 
@@ -38,9 +38,14 @@ public boolean isDynamic() {
 		return true;
 	}
 
+	/**
+	 * @deprecated Functions that call closures should extend {@link CallbackYield}
+	 * instead of calling this directly, which re-enters eval() and defeats the iterative interpreter.
+	 */
+	@Deprecated
 	@Override
-	public Mixed executeCallable(Environment environment, Target t, Mixed... values) throws ConfigRuntimeException, ProgramFlowManipulationException, CancelCommandException {
-		return runnable.execute(t, environment, values);
+	public Mixed executeCallable(Environment env, Target t, Mixed... values) throws ConfigRuntimeException, CancelCommandException {
+		return runnable.execute(t, env, values);
 	}
 
 	@Override
diff --git a/src/main/java/com/laytonsmith/core/constructs/CNull.java b/src/main/java/com/laytonsmith/core/constructs/CNull.java
index 67420cda4f..be684e3e76 100644
--- a/src/main/java/com/laytonsmith/core/constructs/CNull.java
+++ b/src/main/java/com/laytonsmith/core/constructs/CNull.java
@@ -3,6 +3,7 @@
 import com.laytonsmith.PureUtilities.Version;
 import com.laytonsmith.annotations.typeof;
 import com.laytonsmith.core.MSVersion;
+import com.laytonsmith.core.environments.Environment;
 import com.laytonsmith.core.natives.interfaces.Booleanish;
 
 /**
@@ -106,8 +107,15 @@ public CClassType[] getInterfaces() {
 		throw new RuntimeException("Cannot call getInterfaces on null");
 	}
 
+	/** @deprecated Use {@link #getBooleanValue(Target, Environment)} instead. */
+	@Deprecated
 	@Override
 	public boolean getBooleanValue(Target t) {
+		return getBooleanValue(t, null);
+	}
+
+	@Override
+	public boolean getBooleanValue(Target t, Environment env) {
 		return false;
 	}
 
diff --git a/src/main/java/com/laytonsmith/core/constructs/CNumber.java b/src/main/java/com/laytonsmith/core/constructs/CNumber.java
index 4edc77996e..daafac0161 100644
--- a/src/main/java/com/laytonsmith/core/constructs/CNumber.java
+++ b/src/main/java/com/laytonsmith/core/constructs/CNumber.java
@@ -3,6 +3,7 @@
 import com.laytonsmith.PureUtilities.Version;
 import com.laytonsmith.annotations.typeof;
 import com.laytonsmith.core.MSVersion;
+import com.laytonsmith.core.environments.Environment;
 
 /**
  *
@@ -41,8 +42,15 @@ public Version since() {
 
 	public abstract double getNumber();
 
+	/** @deprecated Use {@link #getBooleanValue(Target, Environment)} instead. */
+	@Deprecated
 	@Override
 	public boolean getBooleanValue(Target t) {
+		return getBooleanValue(t, null);
+	}
+
+	@Override
+	public boolean getBooleanValue(Target t, Environment env) {
 		return getNumber() != 0.0;
 	}
 }
diff --git a/src/main/java/com/laytonsmith/core/constructs/CNumberRunner.java b/src/main/java/com/laytonsmith/core/constructs/CNumberRunner.java
index f532c0036d..d3de454825 100644
--- a/src/main/java/com/laytonsmith/core/constructs/CNumberRunner.java
+++ b/src/main/java/com/laytonsmith/core/constructs/CNumberRunner.java
@@ -3,6 +3,7 @@
 import com.laytonsmith.PureUtilities.Common.Annotations.InterfaceRunnerFor;
 import com.laytonsmith.PureUtilities.Version;
 import com.laytonsmith.core.MSVersion;
+import com.laytonsmith.core.constructs.generics.GenericParameters;
 import com.laytonsmith.core.natives.interfaces.AbstractMixedInterfaceRunner;
 import com.laytonsmith.core.objects.ObjectType;
 
@@ -38,6 +39,9 @@ public ObjectType getObjectType() {
 		return ObjectType.ABSTRACT;
 	}
 
-
+	@Override
+	public GenericParameters getGenericParameters() {
+		return null;
+	}
 
 }
diff --git a/src/main/java/com/laytonsmith/core/constructs/CPackage.java b/src/main/java/com/laytonsmith/core/constructs/CPackage.java
index f9532b9696..f5510c818b 100644
--- a/src/main/java/com/laytonsmith/core/constructs/CPackage.java
+++ b/src/main/java/com/laytonsmith/core/constructs/CPackage.java
@@ -9,6 +9,7 @@
 import com.laytonsmith.PureUtilities.Version;
 import com.laytonsmith.annotations.typeof;
 import com.laytonsmith.core.MSVersion;
+import com.laytonsmith.core.constructs.generics.GenericParameters;
 
 /**
  *
@@ -49,4 +50,9 @@ public CClassType[] getInterfaces() {
 		return CClassType.EMPTY_CLASS_ARRAY;
 	}
 
+	@Override
+	public GenericParameters getGenericParameters() {
+		return null;
+	}
+
 }
diff --git a/src/main/java/com/laytonsmith/core/constructs/CPreIdentifier.java b/src/main/java/com/laytonsmith/core/constructs/CPreIdentifier.java
index 30ca2fe845..cc80a48fd3 100644
--- a/src/main/java/com/laytonsmith/core/constructs/CPreIdentifier.java
+++ b/src/main/java/com/laytonsmith/core/constructs/CPreIdentifier.java
@@ -1,6 +1,7 @@
 package com.laytonsmith.core.constructs;
 
 import com.laytonsmith.PureUtilities.Version;
+import com.laytonsmith.core.constructs.generics.GenericParameters;
 import com.laytonsmith.core.natives.interfaces.Mixed;
 
 /**
@@ -38,4 +39,9 @@ public CClassType[] getInterfaces() {
 		return new CClassType[]{};
 	}
 
+	@Override
+	public GenericParameters getGenericParameters() {
+		return null;
+	}
+
 }
diff --git a/src/main/java/com/laytonsmith/core/constructs/CPrimitive.java b/src/main/java/com/laytonsmith/core/constructs/CPrimitive.java
index c09d2eef51..32ad2c69b6 100644
--- a/src/main/java/com/laytonsmith/core/constructs/CPrimitive.java
+++ b/src/main/java/com/laytonsmith/core/constructs/CPrimitive.java
@@ -3,6 +3,7 @@
 import com.laytonsmith.PureUtilities.Version;
 import com.laytonsmith.annotations.typeof;
 import com.laytonsmith.core.MSVersion;
+import com.laytonsmith.core.constructs.generics.GenericParameters;
 import com.laytonsmith.core.natives.interfaces.Booleanish;
 import com.laytonsmith.core.natives.interfaces.ValueType;
 
@@ -41,4 +42,9 @@ public Version since() {
 		return MSVersion.V3_0_1;
 	}
 
+	@Override
+	public GenericParameters getGenericParameters() {
+		return null;
+	}
+
 }
diff --git a/src/main/java/com/laytonsmith/core/constructs/CPrimitiveRunner.java b/src/main/java/com/laytonsmith/core/constructs/CPrimitiveRunner.java
index 74f4ea80b4..108b4d9296 100644
--- a/src/main/java/com/laytonsmith/core/constructs/CPrimitiveRunner.java
+++ b/src/main/java/com/laytonsmith/core/constructs/CPrimitiveRunner.java
@@ -3,6 +3,7 @@
 import com.laytonsmith.PureUtilities.Common.Annotations.InterfaceRunnerFor;
 import com.laytonsmith.PureUtilities.Version;
 import com.laytonsmith.core.MSVersion;
+import com.laytonsmith.core.constructs.generics.GenericParameters;
 import com.laytonsmith.core.natives.interfaces.AbstractMixedInterfaceRunner;
 import com.laytonsmith.core.natives.interfaces.Booleanish;
 import com.laytonsmith.core.natives.interfaces.Mixed;
@@ -42,5 +43,9 @@ public ObjectType getObjectType() {
 		return ObjectType.ABSTRACT;
 	}
 
+	@Override
+	public GenericParameters getGenericParameters() {
+		return null;
+	}
 
 }
diff --git a/src/main/java/com/laytonsmith/core/constructs/CReal2dMatrix.java b/src/main/java/com/laytonsmith/core/constructs/CReal2dMatrix.java
index c395025fca..1a00825377 100644
--- a/src/main/java/com/laytonsmith/core/constructs/CReal2dMatrix.java
+++ b/src/main/java/com/laytonsmith/core/constructs/CReal2dMatrix.java
@@ -4,6 +4,7 @@
 import com.laytonsmith.annotations.typeof;
 import com.laytonsmith.core.ArgumentValidation;
 import com.laytonsmith.core.MSVersion;
+import com.laytonsmith.core.environments.Environment;
 import com.laytonsmith.core.exceptions.CRE.CREIllegalArgumentException;
 import com.laytonsmith.core.exceptions.CRE.CREIndexOverflowException;
 import com.laytonsmith.core.exceptions.CRE.CRELengthException;
@@ -154,26 +155,54 @@ public boolean isAssociative() {
 		return false;
 	}
 
+	/** @deprecated Use {@link #get(Mixed, Target, Environment)} instead. */
+	@Deprecated
 	@Override
 	public CReal2dMatrixRow get(Mixed index, Target t) throws ConfigRuntimeException {
-		return get(ArgumentValidation.getInt32(index, t), t);
+		return (CReal2dMatrixRow) get(index, t, null);
 	}
 
+	@Override
+	public Mixed get(Mixed index, Target t, Environment env) throws ConfigRuntimeException {
+		return get(ArgumentValidation.getInt32(index, t, env), t, env);
+	}
+
+	/** @deprecated Use {@link #get(String, Target, Environment)} instead. */
+	@Deprecated
 	@Override
 	public Mixed get(String index, Target t) throws ConfigRuntimeException {
+		return get(index, t, null);
+	}
+
+	@Override
+	public Mixed get(String index, Target t, Environment env) throws ConfigRuntimeException {
 		throw new CREIllegalArgumentException("Matrices cannot be indexed into with non-numeric values.", t);
 	}
 
+	/** @deprecated Use {@link #get(int, Target, Environment)} instead. */
+	@Deprecated
 	@Override
 	public CReal2dMatrixRow get(int index, Target t) throws ConfigRuntimeException {
+		return (CReal2dMatrixRow) get(index, t, null);
+	}
+
+	@Override
+	public Mixed get(int index, Target t, Environment env) throws ConfigRuntimeException {
 		if(index >= getRowCount() || index < 0) {
 			throw new CRERangeException("Matrix range out of bounds.", t);
 		}
 		return new CReal2dMatrixRow(this, index);
 	}
 
+	/** @deprecated Use {@link #keySet(Environment)} instead. */
+	@Deprecated
 	@Override
 	public Set<Mixed> keySet() {
+		return keySet(null);
+	}
+
+	@Override
+	public Set<Mixed> keySet(Environment env) {
 		Set<Mixed> set = new HashSet<>();
 		for(int i = 0; i < getRowCount(); i++) {
 			set.add(new CInt(i, Target.UNKNOWN));
@@ -181,13 +210,27 @@ public Set<Mixed> keySet() {
 		return set;
 	}
 
+	/** @deprecated Use {@link #getBooleanValue(Target, Environment)} instead. */
+	@Deprecated
 	@Override
 	public boolean getBooleanValue(Target t) {
+		return getBooleanValue(t, null);
+	}
+
+	@Override
+	public boolean getBooleanValue(Target t, Environment env) {
 		return data.length != 0;
 	}
 
+	/** @deprecated Use {@link #slice(int, int, Target, Environment)} instead. */
+	@Deprecated
 	@Override
 	public CArray slice(int begin, int end, Target t) {
+		return (CArray) slice(begin, end, t, null);
+	}
+
+	@Override
+	public Mixed slice(int begin, int end, Target t, Environment env) {
 		CArray ret = new CArray(t);
 		int step = (begin <= end) ? 1 : -1;
 
@@ -204,8 +247,15 @@ public CArray slice(int begin, int end, Target t) {
 		return ret;
 	}
 
+	/** @deprecated Use {@link #size(Environment)} instead. */
+	@Deprecated
 	@Override
 	public long size() {
+		return size(null);
+	}
+
+	@Override
+	public long size(Environment env) {
 		return getRowCount();
 	}
 
diff --git a/src/main/java/com/laytonsmith/core/constructs/CReal2dMatrixRow.java b/src/main/java/com/laytonsmith/core/constructs/CReal2dMatrixRow.java
index 9beb85bd2d..c9487c02ef 100644
--- a/src/main/java/com/laytonsmith/core/constructs/CReal2dMatrixRow.java
+++ b/src/main/java/com/laytonsmith/core/constructs/CReal2dMatrixRow.java
@@ -6,6 +6,7 @@
 import com.laytonsmith.core.MSVersion;
 import com.laytonsmith.core.exceptions.CRE.CRECastException;
 import com.laytonsmith.core.exceptions.ConfigRuntimeException;
+import com.laytonsmith.core.environments.Environment;
 import com.laytonsmith.core.natives.interfaces.AbstractMixedClass;
 import com.laytonsmith.core.natives.interfaces.ArrayAccessSet;
 import com.laytonsmith.core.natives.interfaces.Mixed;
@@ -52,23 +53,51 @@ public CClassType[] getInterfaces() {
 		return new CClassType[]{com.laytonsmith.core.natives.interfaces.Iterable.TYPE, ArrayAccessSet.TYPE};
 	}
 
+	/** @deprecated Use {@link #get(String, Target, Environment)} instead. */
+	@Deprecated
 	@Override
 	public Mixed get(String index, Target t) throws ConfigRuntimeException {
+		return get(index, t, null);
+	}
+
+	@Override
+	public Mixed get(String index, Target t, Environment env) throws ConfigRuntimeException {
 		throw new CRECastException("Real2dMatrix only supports int keys.", t);
 	}
 
+	/** @deprecated Use {@link #get(int, Target, Environment)} instead. */
+	@Deprecated
 	@Override
 	public CDouble get(int index, Target t) throws ConfigRuntimeException {
+		return (CDouble) get(index, t, null);
+	}
+
+	@Override
+	public Mixed get(int index, Target t, Environment env) throws ConfigRuntimeException {
 		return new CDouble(getNative(index, t), t);
 	}
 
+	/** @deprecated Use {@link #get(Mixed, Target, Environment)} instead. */
+	@Deprecated
 	@Override
 	public Mixed get(Mixed index, Target t) throws ConfigRuntimeException {
-		return get(ArgumentValidation.getInt32(index, t), t);
+		return get(index, t, null);
 	}
 
+	@Override
+	public Mixed get(Mixed index, Target t, Environment env) throws ConfigRuntimeException {
+		return get(ArgumentValidation.getInt32(index, t, env), t, env);
+	}
+
+	/** @deprecated Use {@link #keySet(Environment)} instead. */
+	@Deprecated
 	@Override
 	public Set<Mixed> keySet() {
+		return keySet(null);
+	}
+
+	@Override
+	public Set<Mixed> keySet(Environment env) {
 		Set<Mixed> set = new HashSet<>();
 		for(int i = 0; i < parent.columns; i++) {
 			set.add(new CInt(i, Target.UNKNOWN));
@@ -86,37 +115,65 @@ public boolean canBeAssociative() {
 		return false;
 	}
 
+	/** @deprecated Use {@link #slice(int, int, Target, Environment)} instead. */
+	@Deprecated
 	@Override
 	public Mixed slice(int begin, int end, Target t) {
+		return slice(begin, end, t, null);
+	}
+
+	@Override
+	public Mixed slice(int begin, int end, Target t, Environment env) {
 		CArray ret = new CArray(t);
 		int step = (begin <= end) ? 1 : -1;
 
 		// Note: loop includes 'begin', excludes 'end', just like typical slice semantics
 		for(int i = begin; i != end; i += step) {
-			CDouble d = get(i, t);
+			CDouble d = (CDouble) get(i, t, env);
 			ret.push(d, t);
 		}
 
 		return ret;
 	}
 
+	/** @deprecated Use {@link #getBooleanValue(Target, Environment)} instead. */
+	@Deprecated
 	@Override
 	public boolean getBooleanValue(Target t) {
+		return getBooleanValue(t, null);
+	}
+
+	@Override
+	public boolean getBooleanValue(Target t, Environment env) {
 		// 0 dimension matrices are not possible, so this will
 		// always have at least one value in it, thus always
 		// true.
 		return true;
 	}
 
+	/** @deprecated Use {@link #size(Environment)} instead. */
+	@Deprecated
 	@Override
 	public long size() {
+		return size(null);
+	}
+
+	@Override
+	public long size(Environment env) {
 		return parent.columns;
 	}
 
+	/** @deprecated Use {@link #set(Mixed, Mixed, Target, Environment)} instead. */
+	@Deprecated
 	@Override
 	public void set(Mixed index, Mixed value, Target t) {
-		int in = ArgumentValidation.getInt32(index, t);
-		double d = ArgumentValidation.getDouble(value, t);
+		set(index, value, t, null);
+	}
+
+	@Override
+	public void set(Mixed index, Mixed value, Target t, Environment env) {
+		int in = ArgumentValidation.getInt32(index, t, env);
+		double d = ArgumentValidation.getDouble(value, t, env);
 		setNative(in, d, t);
 	}
 
diff --git a/src/main/java/com/laytonsmith/core/constructs/CResource.java b/src/main/java/com/laytonsmith/core/constructs/CResource.java
index 4806972cc8..cbd507a349 100644
--- a/src/main/java/com/laytonsmith/core/constructs/CResource.java
+++ b/src/main/java/com/laytonsmith/core/constructs/CResource.java
@@ -4,10 +4,14 @@
 import com.laytonsmith.annotations.typeof;
 import com.laytonsmith.core.Finalizable;
 import com.laytonsmith.core.MSVersion;
+import com.laytonsmith.core.constructs.generics.GenericParameters;
 import com.laytonsmith.core.functions.ResourceManager.res_free_resource;
 import com.laytonsmith.core.natives.interfaces.Mixed;
+import com.laytonsmith.core.objects.ObjectModifier;
 
 import java.io.File;
+import java.util.EnumSet;
+import java.util.Set;
 import java.util.concurrent.atomic.AtomicLong;
 
 /**
@@ -17,7 +21,7 @@
  * created.
  */
 @typeof("ms.lang.Resource")
-public class CResource<T> extends Construct implements Finalizable {
+public final class CResource<T> extends Construct implements Finalizable {
 
 	@SuppressWarnings("FieldNameHidesFieldInSuperclass")
 	public static final CClassType TYPE = CClassType.get(CResource.class);
@@ -106,7 +110,7 @@ public Version since() {
 
 	@Override
 	public void msFinalize() {
-		new res_free_resource().exec(new Target(0, new File("/Finalizer"), 0), null, this);
+		new res_free_resource().exec(new Target(0, new File("/Finalizer"), 0), null, null, this);
 	}
 
 	public static interface ResourceToString {
@@ -130,4 +134,13 @@ public CClassType[] getInterfaces() {
 		return CClassType.EMPTY_CLASS_ARRAY;
 	}
 
+	@Override
+	public Set<ObjectModifier> getObjectModifiers() {
+		return EnumSet.of(ObjectModifier.FINAL);
+	}
+
+	@Override
+	public GenericParameters getGenericParameters() {
+		return null;
+	}
 }
diff --git a/src/main/java/com/laytonsmith/core/constructs/CSemicolon.java b/src/main/java/com/laytonsmith/core/constructs/CSemicolon.java
index e06149bbcf..e154e658a6 100644
--- a/src/main/java/com/laytonsmith/core/constructs/CSemicolon.java
+++ b/src/main/java/com/laytonsmith/core/constructs/CSemicolon.java
@@ -2,6 +2,7 @@
 
 import com.laytonsmith.PureUtilities.Version;
 import com.laytonsmith.core.MSVersion;
+import com.laytonsmith.core.constructs.generics.GenericParameters;
 
 /**
  * Represents a semicolon at the end of a statement. Forces the statement to close out.
@@ -39,6 +40,9 @@ public CClassType[] getInterfaces() {
 		return CClassType.EMPTY_CLASS_ARRAY;
 	}
 
-
+	@Override
+	public GenericParameters getGenericParameters() {
+		return null;
+	}
 
 }
diff --git a/src/main/java/com/laytonsmith/core/constructs/CSlice.java b/src/main/java/com/laytonsmith/core/constructs/CSlice.java
index 26a539f7b3..37842a2a24 100644
--- a/src/main/java/com/laytonsmith/core/constructs/CSlice.java
+++ b/src/main/java/com/laytonsmith/core/constructs/CSlice.java
@@ -4,6 +4,7 @@
 import com.laytonsmith.annotations.typeof;
 import com.laytonsmith.core.ArgumentValidation;
 import com.laytonsmith.core.MSVersion;
+import com.laytonsmith.core.environments.Environment;
 import com.laytonsmith.core.exceptions.CRE.CRECastException;
 import com.laytonsmith.core.exceptions.CRE.CRERangeException;
 import com.laytonsmith.core.exceptions.ConfigCompileException;
@@ -69,7 +70,7 @@ public CSlice(long from, long to, Target t) {
 
 	@Override
 	public List<Mixed> asList() {
-		CArray ca = new ArrayHandling.range().exec(Target.UNKNOWN, null, new CInt(start, Target.UNKNOWN), new CInt(finish, Target.UNKNOWN));
+		CArray ca = new ArrayHandling.range().exec(Target.UNKNOWN, null, null, new CInt(start, Target.UNKNOWN), new CInt(finish, Target.UNKNOWN));
 		return ca.asList();
 	}
 
@@ -103,7 +104,7 @@ public String toString() {
 	}
 
 	@Override
-	protected String getString(Stack<CArray> arrays, Target t) {
+	protected String getString(Stack<CArray> arrays, Target t, Environment env) {
 		//We don't need to consider arrays, because we can't
 		//get stuck in an infinite loop.
 		return val();
@@ -114,22 +115,43 @@ public boolean inAssociativeMode() {
 		return false;
 	}
 
+	/** @deprecated Use {@link #set(Mixed, Mixed, Target, Environment)} instead. */
+	@Deprecated
 	@Override
 	public void set(Mixed index, Mixed c, Target t) {
+		set(index, c, t, null);
+	}
+
+	@Override
+	public void set(Mixed index, Mixed c, Target t, Environment env) {
 		throw new CRECastException("CSlices cannot set values", t);
 	}
 
+	/** @deprecated Use {@link #get(Mixed, Target, Environment)} instead. */
+	@Deprecated
 	@Override
 	public Mixed get(Mixed index, Target t) {
-		long i = ArgumentValidation.getInt(index, t);
+		return get(index, t, null);
+	}
+
+	@Override
+	public Mixed get(Mixed index, Target t, Environment env) {
+		long i = ArgumentValidation.getInt(index, t, env);
 		if(i > max) {
 			throw new CRERangeException("Index out of bounds. Index: " + i + " Size: " + max, t);
 		}
 		return new CInt(start + (direction * i), t);
 	}
 
+	/** @deprecated Use {@link #keySet(Environment)} instead. */
+	@Deprecated
 	@Override
 	public Set<Mixed> keySet() {
+		return keySet(null);
+	}
+
+	@Override
+	public Set<Mixed> keySet(Environment env) {
 		// To keep our memory footprint down, we create a "fake" keyset here, which doesn't
 		// require actually creating an entire Set. Removing items from the set isn't supported,
 		// but all iteration options are.
@@ -165,8 +187,15 @@ public int size() {
 		};
 	}
 
+	/** @deprecated Use {@link #size(Environment)} instead. */
+	@Deprecated
 	@Override
 	public long size() {
+		return size(null);
+	}
+
+	@Override
+	public long size(Environment env) {
 		return size;
 	}
 
diff --git a/src/main/java/com/laytonsmith/core/constructs/CString.java b/src/main/java/com/laytonsmith/core/constructs/CString.java
index 988f047cc2..b3b3557948 100644
--- a/src/main/java/com/laytonsmith/core/constructs/CString.java
+++ b/src/main/java/com/laytonsmith/core/constructs/CString.java
@@ -60,8 +60,15 @@ public boolean isDynamic() {
 		return false;
 	}
 
+	/** @deprecated Use {@link #size(Environment)} instead. */
+	@Deprecated
 	@Override
 	public long size() {
+		return size(null);
+	}
+
+	@Override
+	public long size(Environment env) {
 		return val().length();
 	}
 
@@ -70,8 +77,15 @@ public boolean canBeAssociative() {
 		return false;
 	}
 
+	/** @deprecated Use {@link #slice(int, int, Target, Environment)} instead. */
+	@Deprecated
 	@Override
 	public Mixed slice(int begin, int end, Target t) {
+		return slice(begin, end, t, null);
+	}
+
+	@Override
+	public Mixed slice(int begin, int end, Target t, Environment env) {
 		if(begin > end) {
 			return new CString("", t);
 		}
@@ -87,8 +101,15 @@ public String getQuote() {
 		return super.getQuote();
 	}
 
+	/** @deprecated Use {@link #get(int, Target, Environment)} instead. */
+	@Deprecated
 	@Override
 	public Mixed get(int index, Target t) throws ConfigRuntimeException {
+		return get(index, t, null);
+	}
+
+	@Override
+	public Mixed get(int index, Target t, Environment env) throws ConfigRuntimeException {
 		try {
 			return new CString(this.val().charAt(index), t);
 		} catch (StringIndexOutOfBoundsException e) {
@@ -96,17 +117,31 @@ public Mixed get(int index, Target t) throws ConfigRuntimeException {
 		}
 	}
 
+	/** @deprecated Use {@link #get(Mixed, Target, Environment)} instead. */
+	@Deprecated
 	@Override
 	public final Mixed get(Mixed index, Target t) throws ConfigRuntimeException {
-		int i = ArgumentValidation.getInt32(index, t);
-		return get(i, t);
+		return get(index, t, null);
 	}
 
+	@Override
+	public final Mixed get(Mixed index, Target t, Environment env) throws ConfigRuntimeException {
+		int i = ArgumentValidation.getInt32(index, t, env);
+		return get(i, t, env);
+	}
+
+	/** @deprecated Use {@link #get(String, Target, Environment)} instead. */
+	@Deprecated
 	@Override
 	public final Mixed get(String index, Target t) {
+		return get(index, t, null);
+	}
+
+	@Override
+	public final Mixed get(String index, Target t, Environment env) {
 		try {
 			int i = Integer.parseInt(index);
-			return get(i, t);
+			return get(i, t, env);
 		} catch (NumberFormatException e) {
 			throw new CREFormatException("Expecting numerical index, but received " + index, t);
 		}
@@ -117,8 +152,15 @@ public boolean isAssociative() {
 		return false;
 	}
 
+	/** @deprecated Use {@link #keySet(Environment)} instead. */
+	@Deprecated
 	@Override
 	public Set<Mixed> keySet() {
+		return keySet(null);
+	}
+
+	@Override
+	public Set<Mixed> keySet(Environment env) {
 		return new AbstractSet<Mixed>() {
 			@Override
 			public int size() {
@@ -175,8 +217,15 @@ public CString duplicate() {
 		return new CString(val(), getTarget());
 	}
 
+	/** @deprecated Use {@link #getBooleanValue(Target, Environment)} instead. */
+	@Deprecated
 	@Override
 	public boolean getBooleanValue(Target t) {
+		return getBooleanValue(t, null);
+	}
+
+	@Override
+	public boolean getBooleanValue(Target t, Environment env) {
 		if(val().equals("false")) {
 			MSLog.GetLogger().e(MSLog.Tags.FALSESTRING, "String \"false\" evaluates as true (non-empty strings are"
 					+ " true). This is most likely not what you meant to do. This warning can globally be disabled"
diff --git a/src/main/java/com/laytonsmith/core/constructs/CSymbol.java b/src/main/java/com/laytonsmith/core/constructs/CSymbol.java
index 29b59685d5..304d9ea731 100644
--- a/src/main/java/com/laytonsmith/core/constructs/CSymbol.java
+++ b/src/main/java/com/laytonsmith/core/constructs/CSymbol.java
@@ -1,6 +1,7 @@
 package com.laytonsmith.core.constructs;
 
 import com.laytonsmith.PureUtilities.Version;
+import com.laytonsmith.core.constructs.generics.GenericParameters;
 import com.laytonsmith.core.natives.interfaces.Mixed;
 
 /**
@@ -212,4 +213,9 @@ public CClassType[] getInterfaces() {
 		return new CClassType[]{};
 	}
 
+	@Override
+	public GenericParameters getGenericParameters() {
+		return null;
+	}
+
 }
diff --git a/src/main/java/com/laytonsmith/core/constructs/CVoid.java b/src/main/java/com/laytonsmith/core/constructs/CVoid.java
index d3970c0cdf..9d29a69292 100644
--- a/src/main/java/com/laytonsmith/core/constructs/CVoid.java
+++ b/src/main/java/com/laytonsmith/core/constructs/CVoid.java
@@ -3,6 +3,7 @@
 import com.laytonsmith.PureUtilities.Version;
 import com.laytonsmith.annotations.typeof;
 import com.laytonsmith.core.MSVersion;
+import com.laytonsmith.core.constructs.generics.GenericParameters;
 import com.laytonsmith.core.objects.ObjectModifier;
 import java.util.EnumSet;
 import java.util.Set;
@@ -79,4 +80,9 @@ public CClassType[] getInterfaces() {
 	public Set<ObjectModifier> getObjectModifiers() {
 		return EnumSet.of(ObjectModifier.FINAL);
 	}
+
+	@Override
+	public GenericParameters getGenericParameters() {
+		return null;
+	}
 }
diff --git a/src/main/java/com/laytonsmith/core/constructs/Command.java b/src/main/java/com/laytonsmith/core/constructs/Command.java
index d8efcc4d85..40c48405e1 100644
--- a/src/main/java/com/laytonsmith/core/constructs/Command.java
+++ b/src/main/java/com/laytonsmith/core/constructs/Command.java
@@ -1,6 +1,7 @@
 package com.laytonsmith.core.constructs;
 
 import com.laytonsmith.PureUtilities.Version;
+import com.laytonsmith.core.constructs.generics.GenericParameters;
 import com.laytonsmith.core.natives.interfaces.Mixed;
 
 /**
@@ -43,4 +44,9 @@ public CClassType[] getInterfaces() {
 		return new CClassType[]{};
 	}
 
+	@Override
+	public GenericParameters getGenericParameters() {
+		return null;
+	}
+
 }
diff --git a/src/main/java/com/laytonsmith/core/constructs/Construct.java b/src/main/java/com/laytonsmith/core/constructs/Construct.java
index b8a8a86104..1d6f96bc3c 100644
--- a/src/main/java/com/laytonsmith/core/constructs/Construct.java
+++ b/src/main/java/com/laytonsmith/core/constructs/Construct.java
@@ -7,6 +7,9 @@
 import com.laytonsmith.core.SimpleDocumentation;
 import com.laytonsmith.core.Static;
 import com.laytonsmith.core.exceptions.MarshalException;
+import com.laytonsmith.core.constructs.generics.GenericParameters;
+import com.laytonsmith.core.constructs.generics.LeftHandGenericUse;
+import com.laytonsmith.core.environments.Environment;
 import com.laytonsmith.core.natives.interfaces.Mixed;
 import com.laytonsmith.core.objects.AccessModifier;
 import com.laytonsmith.core.objects.ObjectModifier;
@@ -23,8 +26,6 @@
 import java.util.Map.Entry;
 import java.util.Objects;
 import java.util.Set;
-import java.util.SortedMap;
-import java.util.TreeMap;
 import java.util.concurrent.atomic.AtomicInteger;
 import org.json.simple.JSONArray;
 import org.json.simple.JSONObject;
@@ -164,6 +165,14 @@ public Construct clone() throws CloneNotSupportedException {
 		return (Construct) super.clone();
 	}
 
+	/**
+	 * @deprecated Use {@link #json_encode(Mixed, Target, Environment)} instead.
+	 */
+	@Deprecated
+	public static String json_encode(Mixed c, Target t) throws MarshalException {
+		return json_encode(c, t, null);
+	}
+
 	/**
 	 * This function takes a Construct, and turns it into a JSON value. If the construct is not one of the following, a
 	 * MarshalException is thrown: CArray, CBoolean, CDouble, CInt, CNull, CString, CVoid, Command. Currently
@@ -180,42 +189,43 @@ public Construct clone() throws CloneNotSupportedException {
 	 *
 	 * @param c
 	 * @param t
+	 * @param env
 	 * @return
 	 * @throws com.laytonsmith.core.exceptions.MarshalException
 	 */
-	public static String json_encode(Mixed c, Target t) throws MarshalException {
-		return JSONValue.toJSONString(json_encode0(c, t));
+	public static String json_encode(Mixed c, Target t, Environment env) throws MarshalException {
+		return JSONValue.toJSONString(json_encode0(c, t, env));
 	}
 
-	private static Object json_encode0(Mixed c, Target t) throws MarshalException {
-		if(c.isInstanceOf(CString.TYPE) || c instanceof Command) {
+	private static Object json_encode0(Mixed c, Target t, Environment env) throws MarshalException {
+		if(c.isInstanceOf(CString.TYPE, null, env) || c instanceof Command) {
 			return c.val();
 		} else if(c instanceof CVoid) {
 			return "";
-		} else if(c instanceof CInt) {
+		} else if(InstanceofUtil.isInstanceof(c, CInt.class, null)) {
 			return ((CInt) c).getInt();
-		} else if(c instanceof CDouble) {
+		} else if(InstanceofUtil.isInstanceof(c, CDouble.class, null)) {
 			return ((CDouble) c).getDouble();
 		} else if(c instanceof CBoolean) {
 			return ((CBoolean) c).getBoolean();
 		} else if(c instanceof CNull) {
 			return null;
-		} else if(c.isInstanceOf(CArray.TYPE)) {
+		} else if(c.isInstanceOf(CArray.TYPE, null, env)) {
 			CArray ca = (CArray) c;
 			if(!ca.inAssociativeMode()) {
 				List<Object> list = new ArrayList<Object>();
 				for(int i = 0; i < ca.size(); i++) {
-					list.add(json_encode0(ca.get(i, t), t));
+					list.add(json_encode0(ca.get(i, t), t, env));
 				}
 				return list;
 			} else {
 				Map<String, Object> map = new HashMap<String, Object>();
 				for(String key : ca.stringKeySet()) {
-					map.put(key, json_encode0(ca.get(key, t), t));
+					map.put(key, json_encode0(ca.get(key, t), t, env));
 				}
 				return map;
 			}
-		} else if(c.isInstanceOf(CClassType.TYPE)) {
+		} else if(c instanceof CClassType) {
 			return c.val();
 		} else {
 			throw new MarshalException("The type of " + c.getClass().getSimpleName() + " is not currently supported", c);
@@ -407,42 +417,11 @@ public static Construct GetConstruct(Object o, boolean allowResources) throws Cl
 	 * @param c
 	 * @return
 	 * @throws ClassCastException
+	 * @deprecated Use {@link Static#getJavaObject(Mixed, Environment)} instead.
 	 */
+	@Deprecated
 	public static Object GetPOJO(Mixed c) throws ClassCastException {
-		if(c instanceof CNull) {
-			return null;
-		} else if(c instanceof CString) {
-			return c.val();
-		} else if(c instanceof CBoolean) {
-			return Boolean.valueOf(((CBoolean) c).getBoolean());
-		} else if(c instanceof CInt) {
-			return Long.valueOf(((CInt) c).getInt());
-		} else if(c instanceof CDouble) {
-			return Double.valueOf(((CDouble) c).getDouble());
-		} else if(c.isInstanceOf(CByteArray.TYPE)) {
-			return ((CByteArray) c).asByteArrayCopy();
-		} else if(c.isInstanceOf(CArray.TYPE)) {
-			CArray ca = (CArray) c;
-			if(ca.inAssociativeMode()) {
-				//SortedMap
-				SortedMap<String, Object> map = new TreeMap<>();
-				for(Entry<String, Mixed> entry : ca.getAssociativeArray().entrySet()) {
-					map.put(entry.getKey(), GetPOJO(entry.getValue()));
-				}
-				return map;
-			} else {
-				//ArrayList
-				ArrayList<Object> list = new ArrayList<Object>((int) ca.size());
-				for(Mixed construct : ca.getArray()) {
-					list.add(GetPOJO(construct));
-				}
-				return list;
-			}
-		} else if(c instanceof CResource) {
-			return ((CResource) c).getResource();
-		} else {
-			throw new ClassCastException(c.getClass().getName() + " cannot be cast to a POJO");
-		}
+		return Static.getJavaObject(c);
 	}
 
 	public CString asString() {
@@ -495,10 +474,12 @@ protected String getQuote() {
 	 * This method may be overridden in special cases, such as dynamic types, but for most types, this
 	 * @return
 	 * @throws IllegalArgumentException If the class isn't public facing.
+	 * @deprecated Use {@link #typeof(Environment)} instead.
 	 */
+	@Deprecated
 	@Override
 	public CClassType typeof() {
-		return typeof(this);
+		return typeof((Environment) null);
 	}
 
 	/**
@@ -511,6 +492,11 @@ public static CClassType typeof(Mixed that) {
 		return CClassType.get(that.getClass());
 	}
 
+	@Override
+	public CClassType typeof(Environment env) {
+		return typeof(this);
+	}
+
 	/**
 	 * Overridden from {@link SimpleDocumentation}. This should just return the value of the typeof annotation,
 	 * unconditionally.
@@ -589,11 +575,27 @@ public CClassType getContainingClass() {
 		return null;
 	}
 
+	/**
+	 * @deprecated Use {@link #isInstanceof(Mixed, CClassType, Environment)} instead.
+	 */
+	@Deprecated
 	public static boolean isInstanceof(Mixed that, CClassType type) {
-		return that.getClass().isAnnotationPresent(typeof.class) && that.typeof().doesExtend(type);
+		return isInstanceof(that, type, null);
 	}
 
+	public static boolean isInstanceof(Mixed that, CClassType type, Environment env) {
+		return that.getClass().isAnnotationPresent(typeof.class) && that.typeof(env).doesExtend(type);
+	}
+
+	/**
+	 * @deprecated Use {@link #isInstanceof(Mixed, Class, Environment)} instead.
+	 */
+	@Deprecated
 	public static boolean isInstanceof(Mixed that, Class<? extends Mixed> type) {
+		return isInstanceof(that, type, null);
+	}
+
+	public static boolean isInstanceof(Mixed that, Class<? extends Mixed> type, Environment env) {
 		if(ClassDiscovery.GetClassAnnotation(that.getClass(), typeof.class) == null) {
 			// This can happen in cases where we are in the middle of optimization.
 			// This can perhaps be improved in the future, when we store the return
@@ -601,21 +603,34 @@ public static boolean isInstanceof(Mixed that, Class<? extends Mixed> type) {
 			// but anyways, for now, just return false.
 			return false;
 		}
-		// TODO: We need the compiler environment here so we can look up custom types.
-		return that.typeof().doesExtend(CClassType.get(type));
+		return that.typeof(env).doesExtend(CClassType.get(type));
 	}
 
+	/**
+	 * @deprecated Use {@link #isInstanceOf(CClassType, LeftHandGenericUse, Environment)} instead.
+	 */
+	@Deprecated
 	@Override
 	public boolean isInstanceOf(CClassType type) {
+		return isInstanceOf(type, null, null);
+	}
+
+	@Override
+	public boolean isInstanceOf(Class<? extends Mixed> type) {
+		return type.isAssignableFrom(this.getClass());
+	}
+
+	@Override
+	public boolean isInstanceOf(CClassType type, LeftHandGenericUse lhsGenericParameters, Environment env) {
 		if(type.getNativeType() != null) {
 			return type.getNativeType().isAssignableFrom(this.getClass());
 		}
-		return isInstanceof(this, type);
+		return isInstanceof(this, type, env);
 	}
 
 	@Override
-	public boolean isInstanceOf(Class<? extends Mixed> type) {
-		return type.isAssignableFrom(this.getClass());
+	public GenericParameters getGenericParameters() {
+		return null;
 	}
 
 	/**
diff --git a/src/main/java/com/laytonsmith/core/constructs/IVariable.java b/src/main/java/com/laytonsmith/core/constructs/IVariable.java
index e1a30dd1c0..c44e085579 100644
--- a/src/main/java/com/laytonsmith/core/constructs/IVariable.java
+++ b/src/main/java/com/laytonsmith/core/constructs/IVariable.java
@@ -49,9 +49,9 @@ public IVariable(CClassType type, String name, Mixed value, Target t, Environmen
 		if(value instanceof CVoid) {
 			throw new CRECastException("Void may not be assigned to a variable", t);
 		}
-		if(!InstanceofUtil.isInstanceof(value.typeof(), type, env)) {
+		if(!InstanceofUtil.isInstanceof(value.typeof(env), type, env)) {
 			throw new CRECastException(name + " is of type " + type.val() + ", but a value of type "
-					+ value.typeof() + " was assigned to it.", t);
+					+ value.typeof(env) + " was assigned to it.", t);
 		}
 		this.type = type;
 		this.varValue = value;
diff --git a/src/main/java/com/laytonsmith/core/constructs/InstanceofUtil.java b/src/main/java/com/laytonsmith/core/constructs/InstanceofUtil.java
index fd1a37c764..c3e18d4ad4 100644
--- a/src/main/java/com/laytonsmith/core/constructs/InstanceofUtil.java
+++ b/src/main/java/com/laytonsmith/core/constructs/InstanceofUtil.java
@@ -39,7 +39,7 @@ public static Set<CClassType> getAllCastableClasses(CClassType c, Environment en
 	 */
 	private static Set<CClassType> getAllCastableClassesWithBlacklist(CClassType c, Set<CClassType> blacklist,
 			Environment env) {
-		if(blacklist.contains(c)) {
+		if(blacklist.contains(c) || CNull.TYPE.equals(c)) {
 			return blacklist;
 		}
 		blacklist.add(c);
@@ -75,7 +75,7 @@ public static boolean isInstanceof(Mixed value, FullyQualifiedClassName instance
 			// TODO: Need to put the return type here, so we can work with this, but for now, just always return false
 			return false;
 		}
-		return isInstanceof(value.typeof(), instanceofThis, env);
+		return isInstanceof(value.typeof(env), instanceofThis, env);
 	}
 
 	/**
@@ -108,6 +108,9 @@ public static boolean isInstanceof(CClassType type, FullyQualifiedClassName inst
 	 * @return
 	 */
 	public static boolean isInstanceof(Mixed value, Class<? extends Mixed> instanceofThis, Environment env) {
+		if(instanceofThis.isAssignableFrom(value.getClass())) {
+			return true;
+		}
 		FullyQualifiedClassName typeof = typeof(instanceofThis);
 		return typeof == null ? false : isInstanceof(value, typeof, env);
 	}
diff --git a/src/main/java/com/laytonsmith/core/constructs/LeftHandSideType.java b/src/main/java/com/laytonsmith/core/constructs/LeftHandSideType.java
index ae7ffc0ec8..676e4a5262 100644
--- a/src/main/java/com/laytonsmith/core/constructs/LeftHandSideType.java
+++ b/src/main/java/com/laytonsmith/core/constructs/LeftHandSideType.java
@@ -748,6 +748,7 @@ public String toString() {
 		return val();
 	}
 
+	@Override
 	public GenericParameters getGenericParameters() {
 		return null;
 	}
diff --git a/src/main/java/com/laytonsmith/core/constructs/NewIVariable.java b/src/main/java/com/laytonsmith/core/constructs/NewIVariable.java
index 4636c763d0..c105018442 100644
--- a/src/main/java/com/laytonsmith/core/constructs/NewIVariable.java
+++ b/src/main/java/com/laytonsmith/core/constructs/NewIVariable.java
@@ -1,6 +1,7 @@
 package com.laytonsmith.core.constructs;
 
 import com.laytonsmith.PureUtilities.Version;
+import com.laytonsmith.core.constructs.generics.GenericParameters;
 import com.laytonsmith.core.natives.interfaces.Mixed;
 
 /**
@@ -45,4 +46,9 @@ public CClassType[] getInterfaces() {
 		return new CClassType[]{};
 	}
 
+	@Override
+	public GenericParameters getGenericParameters() {
+		return null;
+	}
+
 }
diff --git a/src/main/java/com/laytonsmith/core/constructs/ProcedureUsage.java b/src/main/java/com/laytonsmith/core/constructs/ProcedureUsage.java
index 09f433a26a..fbbe96b65e 100644
--- a/src/main/java/com/laytonsmith/core/constructs/ProcedureUsage.java
+++ b/src/main/java/com/laytonsmith/core/constructs/ProcedureUsage.java
@@ -7,7 +7,6 @@
 import com.laytonsmith.core.environments.Environment;
 import com.laytonsmith.core.exceptions.CancelCommandException;
 import com.laytonsmith.core.exceptions.ConfigRuntimeException;
-import com.laytonsmith.core.exceptions.ProgramFlowManipulationException;
 import com.laytonsmith.core.natives.interfaces.Callable;
 import com.laytonsmith.core.natives.interfaces.Mixed;
 import com.laytonsmith.core.objects.ObjectModifier;
@@ -76,9 +75,14 @@ public Set<ObjectModifier> getObjectModifiers() {
 	}
 
 	@Override
-	public Mixed executeCallable(Environment environment, Target t, Mixed... values) throws ConfigRuntimeException,
-			ProgramFlowManipulationException, CancelCommandException {
-		return proc.execute(Arrays.asList(values), environment, t);
+	public Mixed executeCallable(Environment env, Target t, Mixed... values) throws ConfigRuntimeException,
+			CancelCommandException {
+		return proc.execute(Arrays.asList(values), env, t);
+	}
+
+	@Override
+	public Callable.PreparedCallable prepareForStack(Environment callerEnv, Target t, Mixed... values) {
+		return proc.prepareCall(Arrays.asList(values), callerEnv, t);
 	}
 
 	@Override
diff --git a/src/main/java/com/laytonsmith/core/constructs/Variable.java b/src/main/java/com/laytonsmith/core/constructs/Variable.java
index 36cbdb63d7..4c09c9e988 100644
--- a/src/main/java/com/laytonsmith/core/constructs/Variable.java
+++ b/src/main/java/com/laytonsmith/core/constructs/Variable.java
@@ -1,6 +1,7 @@
 package com.laytonsmith.core.constructs;
 
 import com.laytonsmith.PureUtilities.Version;
+import com.laytonsmith.core.constructs.generics.GenericParameters;
 import com.laytonsmith.core.natives.interfaces.Mixed;
 
 /**
@@ -112,4 +113,9 @@ public CClassType[] getInterfaces() {
 		return new CClassType[]{};
 	}
 
+	@Override
+	public GenericParameters getGenericParameters() {
+		return null;
+	}
+
 }
diff --git a/src/main/java/com/laytonsmith/core/constructs/generics/GenericParameters.java b/src/main/java/com/laytonsmith/core/constructs/generics/GenericParameters.java
index d3f5830ad0..baa7678c89 100644
--- a/src/main/java/com/laytonsmith/core/constructs/generics/GenericParameters.java
+++ b/src/main/java/com/laytonsmith/core/constructs/generics/GenericParameters.java
@@ -176,7 +176,7 @@ public GenericParameters buildWithoutValidation() {
 
 	/**
 	 * Begins construction of a new GenericParameters object, which represents the RHS of the generic declaration.The
-	 * actual GenericDeclaration object is passed in in order to validate the types against the constraints.Each
+	 * actual GenericDeclaration object is passed in in order to validate the types against the constraints. Each
 	 * instance of a class which has a GenericDeclaration will have one of these objects in it, associated with that
 	 * particular instance. This data is not lost after compilation, and types are reified for runtime use.
 	 * <p>
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 0000000000..6bae2a3a9e
--- /dev/null
+++ b/src/main/java/com/laytonsmith/core/environments/Breakpoint.java
@@ -0,0 +1,184 @@
+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;
+	}
+
+	/**
+	 * Returns the current hit count without incrementing.
+	 */
+	public int getHitCount() {
+		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 0000000000..0041e7b5c7
--- /dev/null
+++ b/src/main/java/com/laytonsmith/core/environments/DebugContext.java
@@ -0,0 +1,852 @@
+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, source, state, 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, Target source,
+			ThreadDebugState state, Environment env) {
+		// Check hit count first (cheap). Deduplicate per source line visit:
+		// multiple AST nodes on the same line should only increment the hit
+		// count once. We use the column to distinguish "same visit, different
+		// node" (col differs → cache hit) from "new visit, same first node"
+		// (col matches → cache miss, re-evaluate).
+		if(bp.hitCountThreshold() > 0) {
+			if(!state.hasCachedBreakpointResult(source.file(), source.line(), source.col())) {
+				int count = bp.incrementHitCount();
+				boolean hitReached = count >= bp.hitCountThreshold();
+				state.cacheBreakpointResult(source.file(), source.line(), source.col(), hitReached);
+				if(!hitReached) {
+					return false;
+				}
+			} else if(!state.getCachedBreakpointResult()) {
+				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 0000000000..03abb5d9ae
--- /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 704b1a9d72..9539de86e5 100644
--- a/src/main/java/com/laytonsmith/core/environments/GlobalEnv.java
+++ b/src/main/java/com/laytonsmith/core/environments/GlobalEnv.java
@@ -25,6 +25,7 @@
 import java.util.Collections;
 import java.util.EnumSet;
 import java.util.HashMap;
+import java.util.IdentityHashMap;
 import java.util.List;
 import java.util.Map;
 import java.util.concurrent.ConcurrentHashMap;
@@ -60,6 +61,28 @@ public class GlobalEnv implements Environment.EnvironmentImpl, Cloneable {
 	private FileOptions fileOptions;
 	private ScriptProvider scriptProvider = new ScriptProvider.FileSystemScriptProvider();
 
+	// $variable (dollar-variable) bindings for the current execution context.
+	//
+	// $variables are alias command parameters (e.g. /cmd $x = msg($x)), and also
+	// command-line script arguments ($0, $1, $). They are scoped to the compiled
+	// tree in which they appear — the old implementation walked the entire parse tree
+	// and mutated each Variable node in place via setVal(). This was thread-unsafe:
+	// if two threads executed the same alias concurrently, one thread's values would
+	// overwrite the other's, since they shared the same compiled tree.
+	//
+	// The new design avoids tree mutation entirely. Instead, we collect the identity
+	// (object reference) of every Variable node found in the tree via getAllData(),
+	// resolve its value, and store the mapping here using an IdentityHashMap. The
+	// interpreter checks this map when it encounters a Variable node. Because identity
+	// is used (not equals), a $x node that appears in the original alias tree is resolved,
+	// but a $x node in an unrelated tree (e.g. a different alias or a separately compiled
+	// include) is not — preserving the original tree-scoped visibility semantics.
+	//
+	// This map is set once at the start of execution (in Script.run() or
+	// MethodScriptCompiler.execute()) and is carried through the environment into
+	// nested calls (procs defined inline, etc.) without modification.
+	private IdentityHashMap<Mixed, String> dollarVarBindings = null;
+
 	/**
 	 * Creates a new GlobalEnvironment. All fields in the constructor are required, and cannot be null.
 	 *
@@ -377,12 +400,46 @@ public List<Iterator> GetArrayAccessIteratorsFor(ArrayAccess array) {
 	public StackTraceManager GetStackTraceManager() {
 		Thread currentThread = Thread.currentThread();
 		if(this.stackTraceManager == null || currentThread != this.stackTraceManagerThread) {
-			this.stackTraceManager = new StackTraceManager();
+			this.stackTraceManager = new StackTraceManager(this);
 			this.stackTraceManagerThread = currentThread;
 		}
 		return this.stackTraceManager;
 	}
 
+	/**
+	 * Re-associates the existing StackTraceManager with the current thread, without
+	 * creating a new one. This is used by the debugger when resuming execution on a
+	 * new thread after a breakpoint pause — the StackTraceManager state must carry
+	 * over from the previous execution thread.
+	 *
+	 * <p>After calling this method, {@link #GetStackTraceManager()} will return the
+	 * existing StackTraceManager when called from the current thread. Other threads
+	 * (e.g. background threads from x_new_thread) will still get their own fresh
+	 * StackTraceManager, which is the correct behavior — they should not share
+	 * the main thread's call depth tracking.</p>
+	 *
+	 * <p>If no StackTraceManager exists yet, this is a no-op (the next call to
+	 * {@link #GetStackTraceManager()} will create one normally).</p>
+	 */
+	public void adoptStackTraceManager() {
+		if(this.stackTraceManager != null) {
+			this.stackTraceManagerThread = Thread.currentThread();
+		}
+	}
+
+	/**
+	 * Returns the existing StackTraceManager without performing the thread-affinity
+	 * check. Unlike {@link #GetStackTraceManager()}, this will never create a new
+	 * StackTraceManager or change the thread association. Returns null if no
+	 * StackTraceManager has been created yet.
+	 *
+	 * <p>This is intended for read-only access from threads other than the execution
+	 * thread, such as the debugger's DAP handler thread reading a frozen snapshot.</p>
+	 */
+	public StackTraceManager peekStackTraceManager() {
+		return this.stackTraceManager;
+	}
+
 	/**
 	 * Returns the runtime setting for a particular value. Runtime settings are a collection of free settings, which
 	 * individual functions can define setting names and values, though in general, to prevent stepping over each other,
@@ -518,4 +575,24 @@ public ScriptProvider GetScriptProvider() {
 	public void SetScriptProvider(ScriptProvider provider) {
 		this.scriptProvider = provider;
 	}
+
+	/**
+	 * Sets the resolved $variable bindings for this execution. The map uses identity-based
+	 * lookup (IdentityHashMap) so that only the specific Variable nodes from the original
+	 * tree are resolved — this preserves tree-scoped visibility without mutating the tree.
+	 */
+	public void SetDollarVarBindings(IdentityHashMap<Mixed, String> bindings) {
+		this.dollarVarBindings = bindings;
+	}
+
+	/**
+	 * Returns the resolved value for a specific $variable node, or null if the node
+	 * is not in scope.
+	 */
+	public String GetDollarVarBinding(Mixed variableNode) {
+		if(dollarVarBindings == null) {
+			return null;
+		}
+		return dollarVarBindings.get(variableNode);
+	}
 }
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 0000000000..8161e61da8
--- /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 0000000000..b853e6405a
--- /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 0000000000..d29377352f
--- /dev/null
+++ b/src/main/java/com/laytonsmith/core/environments/ThreadDebugState.java
@@ -0,0 +1,149 @@
+package com.laytonsmith.core.environments;
+
+import com.laytonsmith.core.constructs.Target;
+
+import java.io.File;
+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;
+
+	// Breakpoint hit-count deduplication: when shouldPause checks a
+	// hit-count breakpoint, we cache the file+line+col+result so that
+	// subsequent AST nodes on the same source line reuse the cached result
+	// (and don't re-increment the hit count). A "new visit" to the same
+	// line is detected when the same first-node column fires again.
+	private volatile File lastBpFile;
+	private volatile int lastBpLine = -1;
+	private volatile int lastBpCol = -1;
+	private volatile boolean lastBpResult;
+
+	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();
+		}
+	}
+
+	/**
+	 * Returns true if we already evaluated a hit-count breakpoint for this
+	 * file+line on this thread and can reuse the cached result. A cache hit
+	 * occurs when file+line match but col differs (a subsequent AST node on
+	 * the same source line). When file+line+col all match, it means the first
+	 * node is firing again (new loop iteration), so we return false to force
+	 * a fresh evaluation.
+	 */
+	public boolean hasCachedBreakpointResult(File file, int line, int col) {
+		return lastBpLine == line && file != null && file.equals(lastBpFile)
+				&& lastBpCol != col;
+	}
+
+	/**
+	 * Returns the cached breakpoint evaluation result.
+	 */
+	public boolean getCachedBreakpointResult() {
+		return lastBpResult;
+	}
+
+	/**
+	 * Caches the breakpoint evaluation result for the given file+line+col.
+	 */
+	public void cacheBreakpointResult(File file, int line, int col, boolean result) {
+		this.lastBpFile = file;
+		this.lastBpLine = line;
+		this.lastBpCol = col;
+		this.lastBpResult = result;
+	}
+
+	/**
+	 * Clears the breakpoint evaluation cache. Called when execution moves
+	 * to a different source line.
+	 */
+	public void clearBreakpointCache() {
+		this.lastBpFile = null;
+		this.lastBpLine = -1;
+		this.lastBpCol = -1;
+	}
+}
diff --git a/src/main/java/com/laytonsmith/core/events/AbstractGenericEvent.java b/src/main/java/com/laytonsmith/core/events/AbstractGenericEvent.java
index 37c220d0a7..f340d02c04 100644
--- a/src/main/java/com/laytonsmith/core/events/AbstractGenericEvent.java
+++ b/src/main/java/com/laytonsmith/core/events/AbstractGenericEvent.java
@@ -22,15 +22,13 @@
 import com.laytonsmith.core.environments.StaticRuntimeEnv;
 import com.laytonsmith.core.events.prefilters.Prefilter;
 import com.laytonsmith.core.events.prefilters.PrefilterBuilder;
-import com.laytonsmith.core.exceptions.CRE.CREFormatException;
+import com.laytonsmith.core.exceptions.CRE.CREUnsupportedOperationException;
 import com.laytonsmith.core.exceptions.CancelCommandException;
 import com.laytonsmith.core.exceptions.ConfigCompileException;
 import com.laytonsmith.core.exceptions.ConfigCompileGroupException;
 import com.laytonsmith.core.exceptions.ConfigRuntimeException;
 import com.laytonsmith.core.exceptions.EventException;
-import com.laytonsmith.core.exceptions.FunctionReturnException;
 import com.laytonsmith.core.exceptions.PrefilterNonMatchException;
-import com.laytonsmith.core.exceptions.ProgramFlowManipulationException;
 import com.laytonsmith.core.natives.interfaces.Mixed;
 import com.laytonsmith.core.profiler.ProfilePoint;
 
@@ -59,8 +57,8 @@ public final void setAbstractEventMixin(EventMixinInterface mixin) {
 	}
 
 	/**
-	 * This function should return true if the event code should be run, based on implementation specific conditions
-	 * for the BindableEvent.
+	 * This function should return true if the event code should be run, based on implementation specific conditions for
+	 * the BindableEvent.
 	 *
 	 * @param e The bindable event itself
 	 * @return {@code true} if the event code should be run
@@ -152,14 +150,10 @@ public final void execute(ParseTree tree, BoundEvent b, Environment env, BoundEv
 		try {
 			try {
 				MethodScriptCompiler.execute(tree, env, null, null);
-			} catch (CancelCommandException ex) {
+			} catch(CancelCommandException ex) {
 				if(ex.getMessage() != null && !ex.getMessage().isEmpty()) {
 					StreamUtils.GetSystemOut().println(ex.getMessage());
 				}
-			} catch (FunctionReturnException ex) {
-				//We simply allow this to end the event execution
-			} catch (ProgramFlowManipulationException ex) {
-				ConfigRuntimeException.HandleUncaughtException(new CREFormatException("Unexpected control flow operation used.", ex.getTarget()), env);
 			}
 		} finally {
 			if(event != null) {
@@ -325,9 +319,10 @@ public final Map<String, Prefilter<? extends TBindableEvent>> getPrefilters() {
 	}
 
 	/**
-	 * Returns the prefilter builder for this subclass. This is built by AbstractEvent and cached, so that calls
-	 * to getPrefilters will be faster for future calls. Subclasses should implement this in order to provide
-	 * declarative prefilter support, which is more efficient and provides more features to end users.
+	 * Returns the prefilter builder for this subclass. This is built by AbstractEvent and cached, so that calls to
+	 * getPrefilters will be faster for future calls. Subclasses should implement this in order to provide declarative
+	 * prefilter support, which is more efficient and provides more features to end users.
+	 *
 	 * @return
 	 */
 	// TODO: Once everything has this, this should be re-added, since everything should have its own version.
@@ -338,15 +333,19 @@ protected PrefilterBuilder getPrefilterBuilder() {
 
 	/**
 	 * By default, we do nothing.
+	 *
 	 * @param prefilters
 	 * @param env
 	 */
 	@Override
 	public void validatePrefilters(Map<Prefilter<TBindableEvent>, ParseTree> prefilters, Environment env)
-		throws ConfigCompileException, ConfigCompileGroupException {
+			throws ConfigCompileException, ConfigCompileGroupException {
 		//
 	}
 
-
-
+	@Override
+	public TBindableEvent convert(CArray manualObject, Target t, Environment env) {
+		throw new CREUnsupportedOperationException("Manual triggering of the "
+				+ getName() + " event is not supported.", t);
+	}
 }
diff --git a/src/main/java/com/laytonsmith/core/events/Event.java b/src/main/java/com/laytonsmith/core/events/Event.java
index ba363f0628..1d4047b3d5 100644
--- a/src/main/java/com/laytonsmith/core/events/Event.java
+++ b/src/main/java/com/laytonsmith/core/events/Event.java
@@ -13,11 +13,16 @@
 import com.laytonsmith.core.exceptions.EventException;
 import com.laytonsmith.core.exceptions.PrefilterNonMatchException;
 import com.laytonsmith.core.natives.interfaces.Mixed;
+import com.laytonsmith.PureUtilities.Common.ReflectionUtils;
+import java.util.Collections;
 import java.util.Map;
+import java.util.Set;
+import java.util.concurrent.ConcurrentHashMap;
 
 /**
  * This interface should be implemented to allow the bind() function to bind to a particular event type. To be
  * recognized as an event type, it should also tag itself with @api, and it will be included in the EventList.
+ *
  * @param <TBindableEvent> The underlying event type.
  */
 public interface Event<TBindableEvent extends BindableEvent> extends Comparable<Event<TBindableEvent>>, Documentation {
@@ -48,8 +53,8 @@ public interface Event<TBindableEvent extends BindableEvent> extends Comparable<
 	 * parameters.
 	 *
 	 * For subclasses who properly implement {@link #getPrefilters}, this should be changed to throw an
-	 * UnsupportedOperationException until the method is fully removed. For classes that extend AbstractEvent, it
-	 * should simply be removed.
+	 * UnsupportedOperationException until the method is fully removed. For classes that extend AbstractEvent, it should
+	 * simply be removed.
 	 *
 	 * @param prefilter The prefilter map, provided by the script
 	 * @param e The bindable event itself
@@ -72,7 +77,7 @@ public interface Event<TBindableEvent extends BindableEvent> extends Comparable<
 	 * @param t
 	 * @return
 	 */
-	public TBindableEvent convert(CArray manualObject, Target t);
+	public TBindableEvent convert(CArray manualObject, Target t, Environment env);
 
 	/**
 	 * This function is called when an event is triggered. It passes the event, and expects back a Map, which will be
@@ -80,10 +85,11 @@ public interface Event<TBindableEvent extends BindableEvent> extends Comparable<
 	 * is considered a fatal error, and will throw an uncatchable CH exception.
 	 *
 	 * @param e The bindable event
+	 * @param env The environment.
 	 * @return The map build from the event
 	 * @throws com.laytonsmith.core.exceptions.EventException If some exception occurs during map building
 	 */
-	public Map<String, Mixed> evaluate(TBindableEvent e) throws EventException;
+	public Map<String, Mixed> evaluate(TBindableEvent e, Environment env) throws EventException;
 
 	/**
 	 * This is called to determine if an event is cancellable in the first place
@@ -177,9 +183,10 @@ public interface Event<TBindableEvent extends BindableEvent> extends Comparable<
 	 * @param key
 	 * @param value
 	 * @param event
+	 * @param env The environment.
 	 * @return
 	 */
-	public boolean modifyEvent(String key, Mixed value, TBindableEvent event);
+	public boolean modifyEvent(String key, Mixed value, TBindableEvent event, Environment env);
 
 	/**
 	 * Returns if this event is cancelled. If the event is not cancellable, false should be returned, though this case
@@ -235,9 +242,10 @@ public interface Event<TBindableEvent extends BindableEvent> extends Comparable<
 	public Map<String, Prefilter<? extends TBindableEvent>> getPrefilters();
 
 	/**
-	 * Called after prefilters are individually validated, and can be used when there is additional validation
-	 * that can be done across multiple prefilters, i.e. when the value of one prefilter is as such, then
-	 * another prefilter may have different behavior.
+	 * Called after prefilters are individually validated, and can be used when there is additional validation that can
+	 * be done across multiple prefilters, i.e. when the value of one prefilter is as such, then another prefilter may
+	 * have different behavior.
+	 *
 	 * @param prefilters The full set of prefilters.
 	 * @param env The environment.
 	 * @throws com.laytonsmith.core.exceptions.ConfigCompileException
@@ -246,4 +254,51 @@ public interface Event<TBindableEvent extends BindableEvent> extends Comparable<
 	public void validatePrefilters(Map<Prefilter<TBindableEvent>, ParseTree> prefilters, Environment env)
 			throws ConfigCompileException, ConfigCompileGroupException;
 
+	// Reflection bridge for backward compatibility with 3rd-party events
+	// that still implement the old modifyEvent(String, Mixed, BindableEvent) signature.
+	// Added 2026-02-23.
+	Set<Class<?>> OLD_MODIFY_EVENT_CACHE = Collections.newSetFromMap(new ConcurrentHashMap<>());
+
+	@SuppressWarnings({"unchecked", "checkstyle:methodtypeparametername"})
+	static <TBindableEvent extends BindableEvent> boolean ExecuteModifyEvent(Event<TBindableEvent> event,
+			String key, Mixed value,
+			TBindableEvent underlying, Environment env) {
+		if(OLD_MODIFY_EVENT_CACHE.contains(event.getClass())) {
+			return (boolean) ReflectionUtils.invokeMethod(event.getClass(), event, "modifyEvent",
+					new Class[]{String.class, Mixed.class, BindableEvent.class},
+					new Object[]{key, value, underlying});
+		}
+		try {
+			return event.modifyEvent(key, value, underlying, env);
+		} catch(AbstractMethodError e) {
+			OLD_MODIFY_EVENT_CACHE.add(event.getClass());
+			return (boolean) ReflectionUtils.invokeMethod(event.getClass(), event, "modifyEvent",
+					new Class[]{String.class, Mixed.class, BindableEvent.class},
+					new Object[]{key, value, underlying});
+		}
+	}
+
+	// Reflection bridge for backward compatibility with 3rd-party events
+	// that still implement the old evaluate(BindableEvent) signature.
+	// Added 2026-02-23.
+	Set<Class<?>> OLD_EVALUATE_CACHE = Collections.newSetFromMap(new ConcurrentHashMap<>());
+
+	@SuppressWarnings({"unchecked", "checkstyle:methodtypeparametername"})
+	static <TBindableEvent extends BindableEvent> Map<String, Mixed> ExecuteEvaluate(
+			Event<TBindableEvent> event, TBindableEvent e, Environment env) throws EventException {
+		if(OLD_EVALUATE_CACHE.contains(event.getClass())) {
+			return (Map<String, Mixed>) ReflectionUtils.invokeMethod(event.getClass(), event, "evaluate",
+					new Class[]{BindableEvent.class},
+					new Object[]{e});
+		}
+		try {
+			return event.evaluate(e, env);
+		} catch(AbstractMethodError ex) {
+			OLD_EVALUATE_CACHE.add(event.getClass());
+			return (Map<String, Mixed>) ReflectionUtils.invokeMethod(event.getClass(), event, "evaluate",
+					new Class[]{BindableEvent.class},
+					new Object[]{e});
+		}
+	}
+
 }
diff --git a/src/main/java/com/laytonsmith/core/events/EventUtils.java b/src/main/java/com/laytonsmith/core/events/EventUtils.java
index 1058a00711..6695a66bd5 100644
--- a/src/main/java/com/laytonsmith/core/events/EventUtils.java
+++ b/src/main/java/com/laytonsmith/core/events/EventUtils.java
@@ -9,6 +9,7 @@
 import com.laytonsmith.core.constructs.CString;
 import com.laytonsmith.core.constructs.Construct;
 import com.laytonsmith.core.constructs.Target;
+import com.laytonsmith.core.environments.Environment;
 import com.laytonsmith.core.events.BoundEvent.Priority;
 import com.laytonsmith.core.events.prefilters.Prefilter;
 import com.laytonsmith.core.exceptions.CRE.CREBindException;
@@ -18,7 +19,6 @@
 import com.laytonsmith.core.extensions.ExtensionTracker;
 import com.laytonsmith.core.exceptions.ConfigRuntimeException;
 import com.laytonsmith.core.exceptions.EventException;
-import com.laytonsmith.core.exceptions.FunctionReturnException;
 import com.laytonsmith.core.exceptions.PrefilterNonMatchException;
 import com.laytonsmith.core.natives.interfaces.Mixed;
 
@@ -142,7 +142,7 @@ public static SortedSet<BoundEvent> GetEvents(Driver type) {
 		return EVENT_HANDLES.get(type);
 	}
 
-	public static void ManualTrigger(String eventName, CArray object, Target t, boolean serverWide) {
+	public static void ManualTrigger(String eventName, CArray object, Target t, boolean serverWide, Environment env) {
 		for(Driver type : EVENT_HANDLES.keySet()) {
 			SortedSet<BoundEvent> toRun = new TreeSet<>();
 			SortedSet<BoundEvent> bounded = GetEvents(type);
@@ -152,7 +152,7 @@ public static void ManualTrigger(String eventName, CArray object, Target t, bool
 					if(b.getEventName().equalsIgnoreCase(eventName)) {
 						BindableEvent convertedEvent = null;
 						try {
-							convertedEvent = driver.convert(object, t);
+							convertedEvent = driver.convert(object, t, env);
 						} catch (UnsupportedOperationException ex) {
 							// The event will stay null, and be caught below
 						}
@@ -167,10 +167,10 @@ public static void ManualTrigger(String eventName, CArray object, Target t, bool
 			//If it's not a serverwide event, or this event doesn't support external events.
 			if(!toRun.isEmpty()) {
 				if(!serverWide || !driver.supportsExternal()) {
-					FireListeners(toRun, driver, driver.convert(object, t));
+					FireListeners(toRun, driver, driver.convert(object, t, env));
 				} else {
 					//It's serverwide, so we can just trigger it normally with the driver, and it should trickle back down to us
-					driver.manualTrigger(driver.convert(object, t));
+					driver.manualTrigger(driver.convert(object, t, env));
 				}
 			} else {
 				//They have fired a non existent event
@@ -336,10 +336,8 @@ public static void FireListeners(SortedSet<BoundEvent> toRun, Event driver, Bind
 				try {
 					//We must re-set the active event's bound event and parsed event
 					activeEvent.setBoundEvent(b);
-					activeEvent.setParsedEvent(driver.evaluate(e));
+					activeEvent.setParsedEvent(Event.ExecuteEvaluate(driver, e, b.getEnvironment()));
 					b.trigger(activeEvent);
-				} catch (FunctionReturnException ex) {
-					//We also know how to deal with this
 				} catch (EventException ex) {
 					throw new CREEventException(ex.getMessage(), b.getTarget(), ex);
 				} catch (ConfigRuntimeException ex) {
diff --git a/src/main/java/com/laytonsmith/core/events/drivers/BlockEvents.java b/src/main/java/com/laytonsmith/core/events/drivers/BlockEvents.java
index c8712da03e..6a583cc4c9 100644
--- a/src/main/java/com/laytonsmith/core/events/drivers/BlockEvents.java
+++ b/src/main/java/com/laytonsmith/core/events/drivers/BlockEvents.java
@@ -36,6 +36,7 @@
 import com.laytonsmith.core.constructs.CNull;
 import com.laytonsmith.core.constructs.CString;
 import com.laytonsmith.core.constructs.Target;
+import com.laytonsmith.core.environments.Environment;
 import com.laytonsmith.core.events.AbstractEvent;
 import com.laytonsmith.core.events.BindableEvent;
 import com.laytonsmith.core.events.BoundEvent;
@@ -69,17 +70,12 @@ public boolean matches(Map<String, Mixed> prefilter, BindableEvent e) throws Pre
 		}
 
 		@Override
-		public BindableEvent convert(CArray manualObject, Target t) {
-			return null;
-		}
-
-		@Override
-		public boolean modifyEvent(String key, Mixed value, BindableEvent e) {
+		public boolean modifyEvent(String key, Mixed value, BindableEvent e, Environment env) {
 			return false;
 		}
 
 		@Override
-		public Map<String, Mixed> evaluate(BindableEvent e) throws EventException {
+		public Map<String, Mixed> evaluate(BindableEvent e, Environment env) throws EventException {
 			MCBlockPistonEvent event = (MCBlockPistonEvent) e;
 			Target t = Target.UNKNOWN;
 			Map<String, Mixed> map = evaluate_helper(event);
@@ -91,13 +87,13 @@ public Map<String, Mixed> evaluate(BindableEvent e) throws EventException {
 			CArray affected = new CArray(t);
 			for(MCBlock block : event.getAffectedBlocks()) {
 				MCMaterial mat = block.getType();
-				CArray blk = CArray.GetAssociativeArray(t);
-				blk.set("name", mat.getName(), t);
-				blk.set("x", new CInt(block.getX(), t), t);
-				blk.set("y", new CInt(block.getY(), t), t);
-				blk.set("z", new CInt(block.getZ(), t), t);
-				blk.set("world", new CString(block.getWorld().getName(), t), t);
-				affected.push(blk, t);
+				CArray blk = CArray.GetAssociativeArray(t, null, env);
+				blk.set("name", mat.getName(), t, env);
+				blk.set("x", new CInt(block.getX(), t), t, env);
+				blk.set("y", new CInt(block.getY(), t), t, env);
+				blk.set("z", new CInt(block.getZ(), t), t, env);
+				blk.set("world", new CString(block.getWorld().getName(), t), t, env);
+				affected.push(blk, t, env);
 			}
 			map.put("affectedBlocks", affected);
 
@@ -160,8 +156,8 @@ public Driver driver() {
 		}
 
 		@Override
-		public Map<String, Mixed> evaluate(BindableEvent e) throws EventException {
-			return super.evaluate(e);
+		public Map<String, Mixed> evaluate(BindableEvent e, Environment env) throws EventException {
+			return super.evaluate(e, env);
 		}
 
 		@Override
@@ -211,12 +207,12 @@ public void bind(BoundEvent event) {
 						+ " is deprecated for \"block\". Converted to " + mat.getName(), event.getTarget());
 			} else if(prefilter.containsKey("type")) {
 				Mixed cid = prefilter.get("type");
-				if(cid.isInstanceOf(CInt.TYPE)) {
+				if(cid.isInstanceOf(CInt.TYPE, null, event.getEnvironment())) {
 					int id = (int) ((CInt) cid).getInt();
 					int data = 0;
 					if(prefilter.containsKey("data")) {
 						Mixed cdata = prefilter.get("data");
-						if(cdata.isInstanceOf(CInt.TYPE)) {
+						if(cdata.isInstanceOf(CInt.TYPE, null, event.getEnvironment())) {
 							data = (int) ((CInt) cdata).getInt();
 						}
 					}
@@ -253,12 +249,7 @@ public boolean matches(Map<String, Mixed> prefilter, BindableEvent e) throws Pre
 		}
 
 		@Override
-		public BindableEvent convert(CArray manualObject, Target t) {
-			return null;
-		}
-
-		@Override
-		public Map<String, Mixed> evaluate(BindableEvent e) throws EventException {
+		public Map<String, Mixed> evaluate(BindableEvent e, Environment env) throws EventException {
 			MCBlockBreakEvent event = (MCBlockBreakEvent) e;
 			Target t = Target.UNKNOWN;
 			Map<String, Mixed> map = evaluate_helper(event);
@@ -270,7 +261,7 @@ public Map<String, Mixed> evaluate(BindableEvent e) throws EventException {
 
 			CArray drops = new CArray(t);
 			for(MCItemStack stack : event.getDrops()) {
-				drops.push(ObjectGenerator.GetGenerator().item(stack, t), t);
+				drops.push(ObjectGenerator.GetGenerator().item(stack, t), t, env);
 			}
 			map.put("drops", drops);
 
@@ -281,16 +272,16 @@ public Map<String, Mixed> evaluate(BindableEvent e) throws EventException {
 		}
 
 		@Override
-		public boolean modifyEvent(String key, Mixed value, BindableEvent e) {
+		public boolean modifyEvent(String key, Mixed value, BindableEvent e, Environment env) {
 			MCBlockBreakEvent event = (MCBlockBreakEvent) e;
 
 			if(key.equals("drops")) {
 				List<MCItemStack> drops = new ArrayList<>();
-				if(value.isInstanceOf(CArray.TYPE)) {
+				if(value.isInstanceOf(CArray.TYPE, null, env)) {
 					CArray arr = (CArray) value;
-					for(int i = 0; i < arr.size(); i++) {
-						CArray item = ArgumentValidation.getArray(arr.get(i, value.getTarget()), value.getTarget());
-						MCItemStack stack = ObjectGenerator.GetGenerator().item(item, value.getTarget());
+					for(int i = 0; i < arr.size(env); i++) {
+						CArray item = ArgumentValidation.getArray(arr.get(i, value.getTarget(), env), value.getTarget(), env);
+						MCItemStack stack = ObjectGenerator.GetGenerator().item(item, value.getTarget(), env);
 						if(!stack.isEmpty()) {
 							drops.add(stack);
 						}
@@ -301,7 +292,7 @@ public boolean modifyEvent(String key, Mixed value, BindableEvent e) {
 			}
 
 			if(key.equals("xp")) {
-				if(value.isInstanceOf(CInt.TYPE)) {
+				if(value.isInstanceOf(CInt.TYPE, null, env)) {
 					int xp = Integer.parseInt(value.val());
 					event.setExpToDrop(xp);
 					return true;
@@ -355,12 +346,12 @@ public void bind(BoundEvent event) {
 						+ " is deprecated for \"block\". Converted to " + mat.getName(), event.getTarget());
 			} else if(prefilter.containsKey("type")) {
 				Mixed cid = prefilter.get("type");
-				if(cid.isInstanceOf(CInt.TYPE)) {
+				if(cid.isInstanceOf(CInt.TYPE, null, event.getEnvironment())) {
 					int id = (int) ((CInt) cid).getInt();
 					int data = 0;
 					if(prefilter.containsKey("data")) {
 						Mixed cdata = prefilter.get("data");
-						if(cdata.isInstanceOf(CInt.TYPE)) {
+						if(cdata.isInstanceOf(CInt.TYPE, null, event.getEnvironment())) {
 							data = (int) ((CInt) cdata).getInt();
 						}
 					}
@@ -398,12 +389,7 @@ public boolean matches(Map<String, Mixed> prefilter, BindableEvent e) throws Pre
 		}
 
 		@Override
-		public BindableEvent convert(CArray manualObject, Target t) {
-			return null;
-		}
-
-		@Override
-		public Map<String, Mixed> evaluate(BindableEvent e) throws EventException {
+		public Map<String, Mixed> evaluate(BindableEvent e, Environment env) throws EventException {
 			MCBlockPlaceEvent event = (MCBlockPlaceEvent) e;
 			Target t = Target.UNKNOWN;
 			Map<String, Mixed> map = evaluate_helper(e);
@@ -423,11 +409,11 @@ public Map<String, Mixed> evaluate(BindableEvent e) throws EventException {
 
 			MCBlock agstblock = event.getBlockAgainst();
 			MCMaterial agstmat = agstblock.getType();
-			CArray agst = CArray.GetAssociativeArray(t);
-			agst.set("name", agstmat.getName(), t);
-			agst.set("x", new CInt(agstblock.getX(), t), t);
-			agst.set("y", new CInt(agstblock.getY(), t), t);
-			agst.set("z", new CInt(agstblock.getZ(), t), t);
+			CArray agst = CArray.GetAssociativeArray(t, null, env);
+			agst.set("name", agstmat.getName(), t, env);
+			agst.set("x", new CInt(agstblock.getX(), t), t, env);
+			agst.set("y", new CInt(agstblock.getY(), t), t, env);
+			agst.set("z", new CInt(agstblock.getZ(), t), t, env);
 			map.put("against", agst);
 
 			map.put("oldblock", new CString(event.getBlockReplacedState().getType().getName(), t));
@@ -436,7 +422,7 @@ public Map<String, Mixed> evaluate(BindableEvent e) throws EventException {
 		}
 
 		@Override
-		public boolean modifyEvent(String key, Mixed value, BindableEvent e) {
+		public boolean modifyEvent(String key, Mixed value, BindableEvent e, Environment env) {
 			MCBlockPlaceEvent event = (MCBlockPlaceEvent) e;
 
 			if(key.equals("block")) {
@@ -456,7 +442,7 @@ public boolean modifyEvent(String key, Mixed value, BindableEvent e) {
 						+ " is deprecated for \"block\". Converted to " + mat.getName(), value.getTarget());
 				return true;
 			} else if(key.equals("type")) {
-				if(value.isInstanceOf(CInt.TYPE)) {
+				if(value.isInstanceOf(CInt.TYPE, null, env)) {
 					MCMaterial mat = StaticLayer.GetMaterialFromLegacy((int) ((CInt) value).getInt(), 0);
 					event.getBlock().setType(mat);
 					MSLog.GetLogger().w(MSLog.Tags.DEPRECATION, "Mutable data key \"type\" in " + getName()
@@ -511,12 +497,12 @@ public void bind(BoundEvent event) {
 						+ " is deprecated for \"block\". Converted to " + mat.getName(), event.getTarget());
 			} else if(prefilter.containsKey("type")) {
 				Mixed cid = prefilter.get("type");
-				if(cid.isInstanceOf(CInt.TYPE)) {
+				if(cid.isInstanceOf(CInt.TYPE, null, event.getEnvironment())) {
 					int id = (int) ((CInt) cid).getInt();
 					int data = 0;
 					if(prefilter.containsKey("data")) {
 						Mixed cdata = prefilter.get("data");
-						if(cdata.isInstanceOf(CInt.TYPE)) {
+						if(cdata.isInstanceOf(CInt.TYPE, null, event.getEnvironment())) {
 							data = (int) ((CInt) cdata).getInt();
 						}
 					}
@@ -548,12 +534,7 @@ public boolean matches(Map<String, Mixed> prefilter, BindableEvent e) throws Pre
 		}
 
 		@Override
-		public BindableEvent convert(CArray manualObject, Target t) {
-			return null;
-		}
-
-		@Override
-		public Map<String, Mixed> evaluate(BindableEvent e) throws EventException {
+		public Map<String, Mixed> evaluate(BindableEvent e, Environment env) throws EventException {
 			MCBlockBurnEvent event = (MCBlockBurnEvent) e;
 			Target t = Target.UNKNOWN;
 			Map<String, Mixed> map = evaluate_helper(event);
@@ -574,7 +555,7 @@ public Map<String, Mixed> evaluate(BindableEvent e) throws EventException {
 		}
 
 		@Override
-		public boolean modifyEvent(String key, Mixed value, BindableEvent e) {
+		public boolean modifyEvent(String key, Mixed value, BindableEvent e, Environment env) {
 			return false;
 		}
 	}
@@ -627,12 +608,7 @@ public boolean matches(Map<String, Mixed> prefilter, BindableEvent e) throws Pre
 		}
 
 		@Override
-		public BindableEvent convert(CArray manualObject, Target t) {
-			return null;
-		}
-
-		@Override
-		public Map<String, Mixed> evaluate(BindableEvent e) throws EventException {
+		public Map<String, Mixed> evaluate(BindableEvent e, Environment env) throws EventException {
 			if(!(e instanceof MCBlockIgniteEvent)) {
 				throw new EventException("Cannot convert e to MCBlockIgniteEvent");
 			}
@@ -661,7 +637,7 @@ public Map<String, Mixed> evaluate(BindableEvent e) throws EventException {
 		}
 
 		@Override
-		public boolean modifyEvent(String key, Mixed value, BindableEvent event) {
+		public boolean modifyEvent(String key, Mixed value, BindableEvent event, Environment env) {
 			return false;
 		}
 	}
@@ -704,12 +680,12 @@ public void bind(BoundEvent event) {
 						+ " is deprecated for \"block\". Converted to " + mat.getName(), event.getTarget());
 			} else if(prefilter.containsKey("type")) {
 				Mixed cid = prefilter.get("type");
-				if(cid.isInstanceOf(CInt.TYPE)) {
+				if(cid.isInstanceOf(CInt.TYPE, null, event.getEnvironment())) {
 					int id = (int) ((CInt) cid).getInt();
 					int data = 0;
 					if(prefilter.containsKey("data")) {
 						Mixed cdata = prefilter.get("data");
-						if(cdata.isInstanceOf(CInt.TYPE)) {
+						if(cdata.isInstanceOf(CInt.TYPE, null, event.getEnvironment())) {
 							data = (int) ((CInt) cdata).getInt();
 						}
 					}
@@ -729,12 +705,12 @@ public void bind(BoundEvent event) {
 						+ " is deprecated for \"toblock\". Converted to " + mat.getName(), event.getTarget());
 			} else if(prefilter.containsKey("totype")) {
 				Mixed cid = prefilter.get("totype");
-				if(cid.isInstanceOf(CInt.TYPE)) {
+				if(cid.isInstanceOf(CInt.TYPE, null, event.getEnvironment())) {
 					int id = (int) ((CInt) cid).getInt();
 					int data = 0;
 					if(prefilter.containsKey("todata")) {
 						Mixed cdata = prefilter.get("todata");
-						if(cdata.isInstanceOf(CInt.TYPE)) {
+						if(cdata.isInstanceOf(CInt.TYPE, null, event.getEnvironment())) {
 							data = (int) ((CInt) cdata).getInt();
 						}
 					}
@@ -772,12 +748,7 @@ public boolean matches(Map<String, Mixed> prefilter, BindableEvent e) throws Pre
 		}
 
 		@Override
-		public BindableEvent convert(CArray manualObject, Target t) {
-			return null;
-		}
-
-		@Override
-		public Map<String, Mixed> evaluate(BindableEvent e) throws EventException {
+		public Map<String, Mixed> evaluate(BindableEvent e, Environment env) throws EventException {
 			if(!(e instanceof MCBlockFromToEvent)) {
 				throw new EventException("Cannot convert e to MCBlockFromToEvent");
 			}
@@ -805,21 +776,21 @@ public Driver driver() {
 		}
 
 		@Override
-		public boolean modifyEvent(String key, Mixed value, BindableEvent event) {
+		public boolean modifyEvent(String key, Mixed value, BindableEvent event, Environment env) {
 			if(!(event instanceof MCBlockFromToEvent)) {
 				return false;
 			}
 			MCBlockFromToEvent e = (MCBlockFromToEvent) event;
 			if(key.equals("block")) {
 				MCBlock block = e.getBlock();
-				if(value.isInstanceOf(CArray.TYPE)) {
+				if(value.isInstanceOf(CArray.TYPE, null, env)) {
 					CArray blockArray = (CArray) value;
 					if(blockArray.containsKey("name")) {
-						Mixed name = blockArray.get("name", value.getTarget());
+						Mixed name = blockArray.get("name", value.getTarget(), env);
 						int data = 0;
 						if(blockArray.containsKey("data")) {
 							try {
-								data = Integer.parseInt(blockArray.get("data", value.getTarget()).val());
+								data = Integer.parseInt(blockArray.get("data", value.getTarget(), env).val());
 							} catch (Exception ex) {
 								throw new CREFormatException("blockArray is invalid", value.getTarget());
 							}
@@ -837,13 +808,13 @@ public boolean modifyEvent(String key, Mixed value, BindableEvent event) {
 						int type;
 						int data = 0;
 						try {
-							type = Integer.parseInt(blockArray.get("type", value.getTarget()).val());
+							type = Integer.parseInt(blockArray.get("type", value.getTarget(), env).val());
 						} catch (Exception ex) {
 							throw new CREFormatException("blockArray is invalid", value.getTarget());
 						}
 						if(blockArray.containsKey("data")) {
 							try {
-								data = Integer.parseInt(blockArray.get("data", value.getTarget()).val());
+								data = Integer.parseInt(blockArray.get("data", value.getTarget(), env).val());
 							} catch (Exception ex) {
 								throw new CREFormatException("blockArray is invalid", value.getTarget());
 							}
@@ -868,14 +839,14 @@ public boolean modifyEvent(String key, Mixed value, BindableEvent event) {
 			}
 			if(key.equals("toblock")) {
 				MCBlock block = e.getToBlock();
-				if(value.isInstanceOf(CArray.TYPE)) {
+				if(value.isInstanceOf(CArray.TYPE, null, env)) {
 					CArray blockArray = (CArray) value;
 					if(blockArray.containsKey("name")) {
-						Mixed name = blockArray.get("name", value.getTarget());
+						Mixed name = blockArray.get("name", value.getTarget(), env);
 						int data = 0;
 						if(blockArray.containsKey("data")) {
 							try {
-								data = Integer.parseInt(blockArray.get("data", value.getTarget()).val());
+								data = Integer.parseInt(blockArray.get("data", value.getTarget(), env).val());
 							} catch (Exception ex) {
 								throw new CREFormatException("blockArray is invalid", value.getTarget());
 							}
@@ -893,13 +864,13 @@ public boolean modifyEvent(String key, Mixed value, BindableEvent event) {
 						int type;
 						int data = 0;
 						try {
-							type = Integer.parseInt(blockArray.get("type", value.getTarget()).val());
+							type = Integer.parseInt(blockArray.get("type", value.getTarget(), env).val());
 						} catch (Exception ex) {
 							throw new CREFormatException("blockArray is invalid", value.getTarget());
 						}
 						if(blockArray.containsKey("data")) {
 							try {
-								data = Integer.parseInt(blockArray.get("data", value.getTarget()).val());
+								data = Integer.parseInt(blockArray.get("data", value.getTarget(), env).val());
 							} catch (Exception ex) {
 								throw new CREFormatException("blockArray is invalid", value.getTarget());
 							}
@@ -977,7 +948,7 @@ public boolean matches(Map<String, Mixed> prefilter, BindableEvent e) throws Pre
 		}
 
 		@Override
-		public Map<String, Mixed> evaluate(BindableEvent e) throws EventException {
+		public Map<String, Mixed> evaluate(BindableEvent e, Environment env) throws EventException {
 			if(!(e instanceof MCSignChangeEvent)) {
 				throw new EventException("Cannot convert e to MCSignChangeEvent");
 			}
@@ -993,7 +964,7 @@ public Map<String, Mixed> evaluate(BindableEvent e) throws EventException {
 		}
 
 		@Override
-		public boolean modifyEvent(String key, Mixed value, BindableEvent event) {
+		public boolean modifyEvent(String key, Mixed value, BindableEvent event, Environment env) {
 			if(!(event instanceof MCSignChangeEvent)) {
 				return false;
 			}
@@ -1001,19 +972,19 @@ public boolean modifyEvent(String key, Mixed value, BindableEvent event) {
 
 			// Allow changing everything at once.
 			if(key.equals("text")) {
-				if(!(value.isInstanceOf(CArray.TYPE))) {
+				if(!(value.isInstanceOf(CArray.TYPE, null, env))) {
 					return false;
 				}
 
 				CArray val = (CArray) value;
-				if(val.size() != 4) {
+				if(val.size(env) != 4) {
 					return false;
 				}
 
 				String[] lines = {"", "", "", ""};
 
 				for(int i = 0; i < 4; i++) {
-					lines[i] = val.get(i, value.getTarget()).toString();
+					lines[i] = val.get(i, value.getTarget(), env).toString();
 				}
 
 				sce.setLines(lines);
@@ -1045,12 +1016,12 @@ public boolean modifyEvent(String key, Mixed value, BindableEvent event) {
 		}
 
 		@Override
-		public BindableEvent convert(CArray manual, Target t) {
+		public BindableEvent convert(CArray manual, Target t, Environment env) {
 			MCSignChangeEvent e = EventBuilder.instantiate(
 					MCSignChangeEvent.class,
-					Static.GetPlayer(manual.get("player", Target.UNKNOWN).val(), Target.UNKNOWN),
-					manual.get("1", Target.UNKNOWN).val(), manual.get("2", Target.UNKNOWN).val(),
-					manual.get("3", Target.UNKNOWN).val(), manual.get("4", Target.UNKNOWN).val());
+					Static.GetPlayer(manual.get("player", Target.UNKNOWN, env).val(), Target.UNKNOWN, env),
+					manual.get("1", Target.UNKNOWN, env).val(), manual.get("2", Target.UNKNOWN, env).val(),
+					manual.get("3", Target.UNKNOWN, env).val(), manual.get("4", Target.UNKNOWN, env).val());
 			return e;
 		}
 	}
@@ -1110,12 +1081,7 @@ public boolean matches(Map<String, Mixed> prefilter, BindableEvent e) throws Pre
 		}
 
 		@Override
-		public BindableEvent convert(CArray manualObject, Target t) {
-			return null;
-		}
-
-		@Override
-		public Map<String, Mixed> evaluate(BindableEvent e) throws EventException {
+		public Map<String, Mixed> evaluate(BindableEvent e, Environment env) throws EventException {
 			MCBlockDispenseEvent event = (MCBlockDispenseEvent) e;
 			Target t = Target.UNKNOWN;
 			Map<String, Mixed> map = evaluate_helper(e);
@@ -1127,17 +1093,17 @@ public Map<String, Mixed> evaluate(BindableEvent e) throws EventException {
 			map.put("location", ObjectGenerator.GetGenerator().location(block.getLocation(), false));
 
 			CArray velocity = ObjectGenerator.GetGenerator().vector(event.getVelocity(), t);
-			velocity.set("magnitude", new CDouble(event.getVelocity().length(), t), t);
+			velocity.set("magnitude", new CDouble(event.getVelocity().length(), t), t, env);
 			map.put("velocity", velocity);
 
 			return map;
 		}
 
 		@Override
-		public boolean modifyEvent(String key, Mixed value, BindableEvent event) {
+		public boolean modifyEvent(String key, Mixed value, BindableEvent event, Environment env) {
 			if(event instanceof MCBlockDispenseEvent) {
 				if("item".equals(key)) {
-					((MCBlockDispenseEvent) event).setItem(ObjectGenerator.GetGenerator().item(value, value.getTarget()));
+					((MCBlockDispenseEvent) event).setItem(ObjectGenerator.GetGenerator().item(value, value.getTarget(), env));
 					return true;
 				}
 				if("velocity".equals(key)) {
@@ -1173,12 +1139,12 @@ public void bind(BoundEvent event) {
 						+ " is deprecated for \"block\". Converted to " + mat.getName(), event.getTarget());
 			} else if(prefilter.containsKey("oldtype")) {
 				Mixed cid = prefilter.get("oldtype");
-				if(cid.isInstanceOf(CInt.TYPE)) {
+				if(cid.isInstanceOf(CInt.TYPE, null, event.getEnvironment())) {
 					int id = (int) ((CInt) cid).getInt();
 					int data = 0;
 					if(prefilter.containsKey("olddata")) {
 						Mixed cdata = prefilter.get("olddata");
-						if(cdata.isInstanceOf(CInt.TYPE)) {
+						if(cdata.isInstanceOf(CInt.TYPE, null, event.getEnvironment())) {
 							data = (int) ((CInt) cdata).getInt();
 						}
 					}
@@ -1198,12 +1164,12 @@ public void bind(BoundEvent event) {
 						+ " is deprecated for \"newblock\". Converted to " + mat.getName(), event.getTarget());
 			} else if(prefilter.containsKey("newtype")) {
 				Mixed cid = prefilter.get("newtype");
-				if(cid.isInstanceOf(CInt.TYPE)) {
+				if(cid.isInstanceOf(CInt.TYPE, null, event.getEnvironment())) {
 					int id = (int) ((CInt) cid).getInt();
 					int data = 0;
 					if(prefilter.containsKey("newdata")) {
 						Mixed cdata = prefilter.get("newdata");
-						if(cdata.isInstanceOf(CInt.TYPE)) {
+						if(cdata.isInstanceOf(CInt.TYPE, null, event.getEnvironment())) {
 							data = (int) ((CInt) cdata).getInt();
 						}
 					}
@@ -1257,12 +1223,7 @@ public boolean matches(Map<String, Mixed> prefilter, BindableEvent event) throws
 		}
 
 		@Override
-		public BindableEvent convert(CArray manualObject, Target t) {
-			return null;
-		}
-
-		@Override
-		public Map<String, Mixed> evaluate(BindableEvent event) throws EventException {
+		public Map<String, Mixed> evaluate(BindableEvent event, Environment env) throws EventException {
 			if(!(event instanceof MCBlockGrowEvent)) {
 				throw new EventException("Cannot convert event to BlockGrowEvent");
 			}
@@ -1277,7 +1238,7 @@ public Map<String, Mixed> evaluate(BindableEvent event) throws EventException {
 		}
 
 		@Override
-		public boolean modifyEvent(String key, Mixed value, BindableEvent e) {
+		public boolean modifyEvent(String key, Mixed value, BindableEvent e, Environment env) {
 			return false;
 		}
 	}
@@ -1317,12 +1278,7 @@ public boolean matches(Map<String, Mixed> prefilter, BindableEvent event) throws
 		}
 
 		@Override
-		public BindableEvent convert(CArray manualObject, Target t) {
-			return null;
-		}
-
-		@Override
-		public Map<String, Mixed> evaluate(BindableEvent event) throws EventException {
+		public Map<String, Mixed> evaluate(BindableEvent event, Environment env) throws EventException {
 			if(!(event instanceof MCNotePlayEvent)) {
 				throw new EventException("Cannot convert event to NotePlayEvent");
 			}
@@ -1339,7 +1295,7 @@ public Map<String, Mixed> evaluate(BindableEvent event) throws EventException {
 		}
 
 		@Override
-		public boolean modifyEvent(String key, Mixed value, BindableEvent e) {
+		public boolean modifyEvent(String key, Mixed value, BindableEvent e, Environment env) {
 			MSLog.GetLogger().w(MSLog.Tags.DEPRECATION, "Modifying the instrument or note for note_play"
 					+ " events is no longer supported.", value.getTarget());
 			return false;
@@ -1387,7 +1343,7 @@ public void bind(BoundEvent event) {
 						+ " is deprecated for \"block\". Converted to " + mat.getName(), event.getTarget());
 			} else if(prefilter.containsKey("oldtype")) {
 				Mixed cid = prefilter.get("oldtype");
-				if(cid.isInstanceOf(CInt.TYPE)) {
+				if(cid.isInstanceOf(CInt.TYPE, null, event.getEnvironment())) {
 					int id = (int) ((CInt) cid).getInt();
 					MCMaterial mat = StaticLayer.GetMaterialFromLegacy(id, 0);
 					if(mat == null) {
@@ -1420,12 +1376,7 @@ public boolean matches(Map<String, Mixed> prefilter, BindableEvent e) throws Pre
 		}
 
 		@Override
-		public BindableEvent convert(CArray manualObject, Target t) {
-			return null;
-		}
-
-		@Override
-		public Map<String, Mixed> evaluate(BindableEvent e) throws EventException {
+		public Map<String, Mixed> evaluate(BindableEvent e, Environment env) throws EventException {
 			if(!(e instanceof MCBlockFadeEvent)) {
 				throw new EventException("Cannot convert event to BlockFadeEvent");
 			}
@@ -1441,7 +1392,7 @@ public Map<String, Mixed> evaluate(BindableEvent e) throws EventException {
 		}
 
 		@Override
-		public boolean modifyEvent(String key, Mixed value, BindableEvent event) {
+		public boolean modifyEvent(String key, Mixed value, BindableEvent event, Environment env) {
 			return false;
 		}
 	}
@@ -1481,12 +1432,7 @@ public boolean matches(Map<String, Mixed> prefilter, BindableEvent e) throws Pre
 		}
 
 		@Override
-		public BindableEvent convert(CArray manualObject, Target t) {
-			return null;
-		}
-
-		@Override
-		public Map<String, Mixed> evaluate(BindableEvent e) throws EventException {
+		public Map<String, Mixed> evaluate(BindableEvent e, Environment env) throws EventException {
 			if(!(e instanceof MCBlockExplodeEvent)) {
 				throw new EventException("Cannot convert event to BlockExplodeEvent");
 			}
@@ -1498,7 +1444,7 @@ public Map<String, Mixed> evaluate(BindableEvent e) throws EventException {
 			ret.put("location", ObjectGenerator.GetGenerator().location(blk.getLocation(), false));
 			CArray blocks = new CArray(t);
 			for(MCBlock b : event.getBlocks()) {
-				blocks.push(ObjectGenerator.GetGenerator().location(b.getLocation(), false), t);
+				blocks.push(ObjectGenerator.GetGenerator().location(b.getLocation(), false), t, env);
 			}
 			ret.put("blocks", blocks);
 			ret.put("yield", new CDouble(event.getYield(), t));
@@ -1506,19 +1452,19 @@ public Map<String, Mixed> evaluate(BindableEvent e) throws EventException {
 		}
 
 		@Override
-		public boolean modifyEvent(String key, Mixed value, BindableEvent event) {
+		public boolean modifyEvent(String key, Mixed value, BindableEvent event, Environment env) {
 			if(event instanceof MCBlockExplodeEvent) {
 				MCBlockExplodeEvent e = (MCBlockExplodeEvent) event;
 				if(key.equals("yield")) {
-					e.setYield((float) ArgumentValidation.getDouble(value, value.getTarget()));
+					e.setYield((float) ArgumentValidation.getDouble(value, value.getTarget(), env));
 					return true;
 				}
 				if(key.equals("blocks")) {
-					if(value.isInstanceOf(CArray.TYPE)) {
+					if(value.isInstanceOf(CArray.TYPE, null, env)) {
 						CArray ba = (CArray) value;
 						List<MCBlock> blocks = new ArrayList<>();
 						for(Mixed m : ba.asList()) {
-							MCLocation loc = ObjectGenerator.GetGenerator().location(m, null, value.getTarget());
+							MCLocation loc = ObjectGenerator.GetGenerator().location(m, null, value.getTarget(), env);
 							blocks.add(loc.getBlock());
 						}
 						e.setBlocks(blocks);
@@ -1555,11 +1501,6 @@ public Driver driver() {
 			return Driver.BLOCK_FORM;
 		}
 
-		@Override
-		public BindableEvent convert(CArray manualObject, Target t) {
-			return null;
-		}
-
 		@Override
 		public Version since() {
 			return MSVersion.V3_3_4;
@@ -1581,7 +1522,7 @@ public boolean matches(Map<String, Mixed> prefilter, BindableEvent e) throws Pre
 		}
 
 		@Override
-		public Map<String, Mixed> evaluate(BindableEvent e) throws EventException {
+		public Map<String, Mixed> evaluate(BindableEvent e, Environment env) throws EventException {
 			if(!(e instanceof MCBlockFormEvent)) {
 				throw new EventException("Cannot convert event to MCBlockFormEvent");
 			} else {
@@ -1596,7 +1537,7 @@ public Map<String, Mixed> evaluate(BindableEvent e) throws EventException {
 		}
 
 		@Override
-		public boolean modifyEvent(String key, Mixed value, BindableEvent e) {
+		public boolean modifyEvent(String key, Mixed value, BindableEvent e, Environment env) {
 			return false;
 		}
 	}
diff --git a/src/main/java/com/laytonsmith/core/events/drivers/CmdlineEvents.java b/src/main/java/com/laytonsmith/core/events/drivers/CmdlineEvents.java
index 7da7ed47f9..9fd9216acd 100644
--- a/src/main/java/com/laytonsmith/core/events/drivers/CmdlineEvents.java
+++ b/src/main/java/com/laytonsmith/core/events/drivers/CmdlineEvents.java
@@ -12,6 +12,7 @@
 import com.laytonsmith.core.constructs.CInt;
 import com.laytonsmith.core.constructs.CString;
 import com.laytonsmith.core.constructs.Target;
+import com.laytonsmith.core.environments.Environment;
 import com.laytonsmith.core.events.AbstractEvent;
 import com.laytonsmith.core.events.BindableEvent;
 import com.laytonsmith.core.events.BoundEvent;
@@ -100,7 +101,7 @@ protected PrefilterBuilder getPrefilterBuilder() {
 		}
 
 		@Override
-		public BindableEvent convert(CArray manualObject, Target t) {
+		public BindableEvent convert(CArray manualObject, Target t, Environment env) {
 			return new BindableEvent() {
 
 				@Override
@@ -111,7 +112,7 @@ public Object _GetObject() {
 		}
 
 		@Override
-		public Map<String, Mixed> evaluate(BindableEvent e) throws EventException {
+		public Map<String, Mixed> evaluate(BindableEvent e, Environment env) throws EventException {
 			Map<String, Mixed> map = new HashMap<>();
 			map.put("time", new CInt(System.currentTimeMillis(), Target.UNKNOWN));
 			return map;
@@ -123,7 +124,7 @@ public Driver driver() {
 		}
 
 		@Override
-		public boolean modifyEvent(String key, Mixed value, BindableEvent event) {
+		public boolean modifyEvent(String key, Mixed value, BindableEvent event, Environment env) {
 			return false;
 		}
 
@@ -164,14 +165,14 @@ protected PrefilterBuilder getPrefilterBuilder() {
 		}
 
 		@Override
-		public BindableEvent convert(CArray manualObject, Target t) {
-			CmdlinePromptInput cpi = new CmdlinePromptInput(manualObject.get("command", t).val(),
-					ArgumentValidation.getBoolean(manualObject.get("shellMode", t), t));
+		public BindableEvent convert(CArray manualObject, Target t, Environment env) {
+			CmdlinePromptInput cpi = new CmdlinePromptInput(manualObject.get("command", t, env).val(),
+					ArgumentValidation.getBoolean(manualObject.get("shellMode", t, env), t));
 			return cpi;
 		}
 
 		@Override
-		public Map<String, Mixed> evaluate(BindableEvent e) throws EventException {
+		public Map<String, Mixed> evaluate(BindableEvent e, Environment env) throws EventException {
 			CmdlinePromptInput cpi = (CmdlinePromptInput) e;
 			Map<String, Mixed> map = new HashMap<>();
 			map.put("command", new CString(cpi.getCommand(), Target.UNKNOWN));
@@ -185,7 +186,7 @@ public Driver driver() {
 		}
 
 		@Override
-		public boolean modifyEvent(String key, Mixed value, BindableEvent event) {
+		public boolean modifyEvent(String key, Mixed value, BindableEvent event, Environment env) {
 			return false;
 		}
 
@@ -262,12 +263,7 @@ public boolean matches(Map<String, Mixed> prefilter, BindableEvent e) throws Pre
 		}
 
 		@Override
-		public BindableEvent convert(CArray manualObject, Target t) {
-			throw new UnsupportedOperationException("Not supported yet.");
-		}
-
-		@Override
-		public Map<String, Mixed> evaluate(BindableEvent e) throws EventException {
+		public Map<String, Mixed> evaluate(BindableEvent e, Environment env) throws EventException {
 			return Collections.EMPTY_MAP;
 		}
 
@@ -277,7 +273,7 @@ public Driver driver() {
 		}
 
 		@Override
-		public boolean modifyEvent(String key, Mixed value, BindableEvent event) {
+		public boolean modifyEvent(String key, Mixed value, BindableEvent event, Environment env) {
 			return false;
 		}
 
diff --git a/src/main/java/com/laytonsmith/core/events/drivers/EntityEvents.java b/src/main/java/com/laytonsmith/core/events/drivers/EntityEvents.java
index 80c3237765..9e2ec6910e 100644
--- a/src/main/java/com/laytonsmith/core/events/drivers/EntityEvents.java
+++ b/src/main/java/com/laytonsmith/core/events/drivers/EntityEvents.java
@@ -142,12 +142,7 @@ public boolean matches(Map<String, Mixed> prefilter, BindableEvent e) throws Pre
 		}
 
 		@Override
-		public BindableEvent convert(CArray manualObject, Target t) {
-			throw ConfigRuntimeException.CreateUncatchableException("Unsupported Operation", Target.UNKNOWN);
-		}
-
-		@Override
-		public Map<String, Mixed> evaluate(BindableEvent e) throws EventException {
+		public Map<String, Mixed> evaluate(BindableEvent e, Environment env) throws EventException {
 			if(e instanceof MCItemDespawnEvent) {
 				Target t = Target.UNKNOWN;
 				MCItemDespawnEvent event = (MCItemDespawnEvent) e;
@@ -168,7 +163,7 @@ public Driver driver() {
 
 		@Override
 		public boolean modifyEvent(String key, Mixed value,
-				BindableEvent event) {
+				BindableEvent event, Environment env) {
 			return false;
 		}
 
@@ -222,12 +217,7 @@ public boolean matches(Map<String, Mixed> prefilter, BindableEvent e) throws Pre
 		}
 
 		@Override
-		public BindableEvent convert(CArray manualObject, Target t) {
-			throw ConfigRuntimeException.CreateUncatchableException("Unsupported Operation", Target.UNKNOWN);
-		}
-
-		@Override
-		public Map<String, Mixed> evaluate(BindableEvent e) throws EventException {
+		public Map<String, Mixed> evaluate(BindableEvent e, Environment env) throws EventException {
 			if(e instanceof MCItemSpawnEvent) {
 				Target t = Target.UNKNOWN;
 				MCItemSpawnEvent event = (MCItemSpawnEvent) e;
@@ -247,10 +237,10 @@ public Driver driver() {
 		}
 
 		@Override
-		public boolean modifyEvent(String key, Mixed value, BindableEvent event) {
+		public boolean modifyEvent(String key, Mixed value, BindableEvent event, Environment env) {
 			if(event instanceof MCItemSpawnEvent) {
 				if("item".equals(key)) {
-					((MCItemSpawnEvent) event).getEntity().setItemStack(ObjectGenerator.GetGenerator().item(value, value.getTarget()));
+					((MCItemSpawnEvent) event).getEntity().setItemStack(ObjectGenerator.GetGenerator().item(value, value.getTarget(), env));
 					return true;
 				}
 			}
@@ -316,19 +306,14 @@ public boolean matches(Map<String, Mixed> prefilter, BindableEvent event) throws
 		}
 
 		@Override
-		public BindableEvent convert(CArray manualObject, Target t) {
-			throw ConfigRuntimeException.CreateUncatchableException("Unsupported Operation", Target.UNKNOWN);
-		}
-
-		@Override
-		public Map<String, Mixed> evaluate(BindableEvent event) throws EventException {
+		public Map<String, Mixed> evaluate(BindableEvent event, Environment env) throws EventException {
 			if(event instanceof MCEntityExplodeEvent) {
 				Target t = Target.UNKNOWN;
 				MCEntityExplodeEvent e = (MCEntityExplodeEvent) event;
 				Map<String, Mixed> ret = evaluate_helper(e);
 				CArray blocks = new CArray(t);
 				for(MCBlock b : e.getBlocks()) {
-					blocks.push(ObjectGenerator.GetGenerator().location(b.getLocation(), false), t);
+					blocks.push(ObjectGenerator.GetGenerator().location(b.getLocation(), false), t, env);
 				}
 				ret.put("blocks", blocks);
 				MCEntity ent = e.getEntity();
@@ -348,20 +333,20 @@ public Driver driver() {
 		}
 
 		@Override
-		public boolean modifyEvent(String key, Mixed value, BindableEvent event) {
+		public boolean modifyEvent(String key, Mixed value, BindableEvent event, Environment env) {
 			if(event instanceof MCEntityExplodeEvent) {
 				MCEntityExplodeEvent e = (MCEntityExplodeEvent) event;
 				if(key.equals("yield")) {
-					e.setYield(ArgumentValidation.getDouble32(value, value.getTarget()));
+					e.setYield(ArgumentValidation.getDouble32(value, value.getTarget(), env));
 					return true;
 				}
 				if(key.equals("blocks")) {
-					if(value.isInstanceOf(CArray.TYPE)) {
+					if(value.isInstanceOf(CArray.TYPE, null, env)) {
 						CArray ba = (CArray) value;
 						List<MCBlock> blocks = new ArrayList<>();
 						for(String b : ba.stringKeySet()) {
 							MCWorld w = e.getLocation().getWorld();
-							MCLocation loc = ObjectGenerator.GetGenerator().location(ba.get(b, value.getTarget()), w, value.getTarget());
+							MCLocation loc = ObjectGenerator.GetGenerator().location(ba.get(b, value.getTarget(), env), w, value.getTarget(), env);
 							blocks.add(loc.getWorld().getBlockAt(loc.getBlockX(), loc.getBlockY(), loc.getBlockZ()));
 						}
 						e.setBlocks(blocks);
@@ -425,8 +410,8 @@ public boolean matches(Map<String, Mixed> prefilter, BindableEvent event) throws
 		}
 
 		@Override
-		public BindableEvent convert(CArray manualObject, Target t) {
-			MCEntity p = Static.getEntity(manualObject.get("id", Target.UNKNOWN), Target.UNKNOWN);
+		public BindableEvent convert(CArray manualObject, Target t, Environment env) {
+			MCEntity p = Static.getEntity(manualObject.get("id", Target.UNKNOWN, env), Target.UNKNOWN);
 			if(!(p instanceof MCProjectile)) {
 				throw new CREBadEntityException("The id was not a projectile", Target.UNKNOWN);
 			}
@@ -434,7 +419,7 @@ public BindableEvent convert(CArray manualObject, Target t) {
 		}
 
 		@Override
-		public Map<String, Mixed> evaluate(BindableEvent event) throws EventException {
+		public Map<String, Mixed> evaluate(BindableEvent event, Environment env) throws EventException {
 			Target t = Target.UNKNOWN;
 			MCProjectileHitEvent e = (MCProjectileHitEvent) event;
 			Map<String, Mixed> ret = evaluate_helper(e);
@@ -473,7 +458,7 @@ public Driver driver() {
 		}
 
 		@Override
-		public boolean modifyEvent(String key, Mixed value, BindableEvent event) {
+		public boolean modifyEvent(String key, Mixed value, BindableEvent event, Environment env) {
 			if(event instanceof MCProjectileHitEvent) {
 				MCProjectileHitEvent e = (MCProjectileHitEvent) event;
 				if(key.equalsIgnoreCase("shooter")) {
@@ -554,12 +539,7 @@ public boolean matches(Map<String, Mixed> prefilter, BindableEvent event) throws
 		}
 
 		@Override
-		public BindableEvent convert(CArray manualObject, Target t) {
-			return null;
-		}
-
-		@Override
-		public Map<String, Mixed> evaluate(BindableEvent event) throws EventException {
+		public Map<String, Mixed> evaluate(BindableEvent event, Environment env) throws EventException {
 			if(event instanceof MCProjectileLaunchEvent) {
 				MCProjectileLaunchEvent projectileLaunchEvent = (MCProjectileLaunchEvent) event;
 				Map<String, Mixed> mapEvent = evaluate_helper(event);
@@ -588,7 +568,7 @@ public Map<String, Mixed> evaluate(BindableEvent event) throws EventException {
 				}
 				mapEvent.put("location", ObjectGenerator.GetGenerator().location(projectile.getLocation()));
 				CArray velocity = ObjectGenerator.GetGenerator().vector(projectile.getVelocity(), Target.UNKNOWN);
-				velocity.set("magnitude", new CDouble(projectile.getVelocity().length(), Target.UNKNOWN), Target.UNKNOWN);
+				velocity.set("magnitude", new CDouble(projectile.getVelocity().length(), Target.UNKNOWN), Target.UNKNOWN, env);
 				mapEvent.put("velocity", velocity);
 				return mapEvent;
 			} else {
@@ -597,7 +577,7 @@ public Map<String, Mixed> evaluate(BindableEvent event) throws EventException {
 		}
 
 		@Override
-		public boolean modifyEvent(String key, Mixed value, BindableEvent event) {
+		public boolean modifyEvent(String key, Mixed value, BindableEvent event, Environment env) {
 			if(event instanceof MCProjectileLaunchEvent) {
 				MCProjectileLaunchEvent projectileLaunchEvent = (MCProjectileLaunchEvent) event;
 				if(key.equals("velocity")) {
@@ -659,12 +639,7 @@ public boolean matches(Map<String, Mixed> prefilter, BindableEvent e)
 		}
 
 		@Override
-		public BindableEvent convert(CArray manualObject, Target t) {
-			return null;
-		}
-
-		@Override
-		public Map<String, Mixed> evaluate(BindableEvent event)
+		public Map<String, Mixed> evaluate(BindableEvent event, Environment env)
 				throws EventException {
 			if(event instanceof MCEntityDeathEvent) {
 				MCEntityDeathEvent e = (MCEntityDeathEvent) event;
@@ -673,16 +648,16 @@ public Map<String, Mixed> evaluate(BindableEvent event)
 				Map<String, Mixed> map = evaluate_helper(event);
 				CArray drops = new CArray(t);
 				for(MCItemStack is : e.getDrops()) {
-					drops.push(ObjectGenerator.GetGenerator().item(is, t), t);
+					drops.push(ObjectGenerator.GetGenerator().item(is, t), t, env);
 				}
 				map.put("type", new CString(dead.getType().name(), t));
 				map.put("id", new CString(dead.getUniqueId().toString(), t));
 				map.put("drops", drops);
 				map.put("xp", new CInt(e.getDroppedExp(), t));
-				CArray cod = CArray.GetAssociativeArray(t);
+				CArray cod = CArray.GetAssociativeArray(t, null, env);
 				Map<String, Mixed> ldc = parseEntityDamageEvent(dead.getLastDamageCause(), new HashMap<>());
 				for(Map.Entry<String, Mixed> entry : ldc.entrySet()) {
-					cod.set(entry.getKey(), entry.getValue(), t);
+					cod.set(entry.getKey(), entry.getValue(), t, env);
 				}
 				map.put("cause", cod);
 				map.put("location", ObjectGenerator.GetGenerator().location(dead.getLocation()));
@@ -698,24 +673,24 @@ public Driver driver() {
 		}
 
 		@Override
-		public boolean modifyEvent(String key, Mixed value, BindableEvent event) {
+		public boolean modifyEvent(String key, Mixed value, BindableEvent event, Environment env) {
 			if(event instanceof MCEntityDeathEvent) {
 				MCEntityDeathEvent e = (MCEntityDeathEvent) event;
 				if(key.equals("xp")) {
-					e.setDroppedExp(ArgumentValidation.getInt32(value, value.getTarget()));
+					e.setDroppedExp(ArgumentValidation.getInt32(value, value.getTarget(), env));
 					return true;
 				}
 				if(key.equals("drops")) {
 					if(value instanceof CNull) {
 						value = new CArray(value.getTarget());
 					}
-					if(!(value.isInstanceOf(CArray.TYPE))) {
+					if(!(value.isInstanceOf(CArray.TYPE, null, env))) {
 						throw new CRECastException("drops must be an array, or null", value.getTarget());
 					}
 					e.clearDrops();
 					CArray drops = (CArray) value;
 					for(String dropID : drops.stringKeySet()) {
-						e.addDrop(ObjectGenerator.GetGenerator().item(drops.get(dropID, value.getTarget()), value.getTarget()));
+						e.addDrop(ObjectGenerator.GetGenerator().item(drops.get(dropID, value.getTarget(), env), value.getTarget(), env));
 					}
 					return true;
 				}
@@ -773,12 +748,7 @@ public boolean matches(Map<String, Mixed> prefilter, BindableEvent event) throws
 		}
 
 		@Override
-		public BindableEvent convert(CArray manualObject, Target t) {
-			return null;
-		}
-
-		@Override
-		public Map<String, Mixed> evaluate(BindableEvent event) throws EventException {
+		public Map<String, Mixed> evaluate(BindableEvent event, Environment env) throws EventException {
 			if(!(event instanceof MCCreatureSpawnEvent)) {
 				throw new EventException("Could not convert to MCCreatureSpawnEvent");
 			}
@@ -798,7 +768,7 @@ public Driver driver() {
 		}
 
 		@Override
-		public boolean modifyEvent(String key, Mixed value, BindableEvent event) {
+		public boolean modifyEvent(String key, Mixed value, BindableEvent event, Environment env) {
 			MCCreatureSpawnEvent e = (MCCreatureSpawnEvent) event;
 			if(key.equals("type")) {
 				MCEntityType type;
@@ -878,13 +848,8 @@ public boolean matches(Map<String, Mixed> prefilter, BindableEvent event)
 		}
 
 		@Override
-		public BindableEvent convert(CArray manualObject, Target t) {
-			return null;
-		}
-
-		@Override
-		public Map<String, Mixed> evaluate(BindableEvent e)
-				throws EventException {
+		public Map<String, Mixed> evaluate(BindableEvent e,
+				Environment env) throws EventException {
 			if(e instanceof MCEntityDamageEvent) {
 				MCEntityDamageEvent event = (MCEntityDamageEvent) e;
 				Map<String, Mixed> map = evaluate_helper(e);
@@ -904,10 +869,10 @@ public Driver driver() {
 
 		@Override
 		public boolean modifyEvent(String key, Mixed value,
-				BindableEvent event) {
+				BindableEvent event, Environment env) {
 			MCEntityDamageEvent e = (MCEntityDamageEvent) event;
 			if(key.equals("amount")) {
-				e.setDamage(ArgumentValidation.getDouble(value, value.getTarget()));
+				e.setDamage(ArgumentValidation.getDouble(value, value.getTarget(), env));
 				return true;
 			}
 			return false;
@@ -960,13 +925,8 @@ public boolean matches(Map<String, Mixed> prefilter, BindableEvent event)
 		}
 
 		@Override
-		public BindableEvent convert(CArray manualObject, Target t) {
-			return null;
-		}
-
-		@Override
-		public Map<String, Mixed> evaluate(BindableEvent e)
-				throws EventException {
+		public Map<String, Mixed> evaluate(BindableEvent e,
+				Environment env) throws EventException {
 			if(e instanceof MCPlayerInteractEntityEvent) {
 				MCPlayerInteractEntityEvent event = (MCPlayerInteractEntityEvent) e;
 				Map<String, Mixed> map = evaluate_helper(e);
@@ -999,7 +959,7 @@ public Driver driver() {
 
 		@Override
 		public boolean modifyEvent(String key, Mixed value,
-				BindableEvent event) {
+				BindableEvent event, Environment env) {
 			return false;
 		}
 
@@ -1056,13 +1016,8 @@ public boolean matches(Map<String, Mixed> prefilter, BindableEvent event)
 		}
 
 		@Override
-		public BindableEvent convert(CArray manualObject, Target t) {
-			return null;
-		}
-
-		@Override
-		public Map<String, Mixed> evaluate(BindableEvent e)
-				throws EventException {
+		public Map<String, Mixed> evaluate(BindableEvent e,
+				Environment env) throws EventException {
 			if(e instanceof MCPlayerInteractAtEntityEvent) {
 				MCPlayerInteractAtEntityEvent event = (MCPlayerInteractAtEntityEvent) e;
 				Map<String, Mixed> map = evaluate_helper(e);
@@ -1095,7 +1050,7 @@ public Driver driver() {
 		}
 
 		@Override
-		public boolean modifyEvent(String key, Mixed value, BindableEvent event) {
+		public boolean modifyEvent(String key, Mixed value, BindableEvent event, Environment env) {
 			return false;
 		}
 
@@ -1125,11 +1080,6 @@ public String docs() {
 					+ "{player|item}";
 		}
 
-		@Override
-		public BindableEvent convert(CArray manualObject, Target t) {
-			return null;
-		}
-
 		@Override
 		public MSVersion since() {
 			return MSVersion.V3_3_1;
@@ -1168,7 +1118,7 @@ public boolean matches(Map<String, Mixed> prefilter, BindableEvent e) throws Pre
 		}
 
 		@Override
-		public Map<String, Mixed> evaluate(BindableEvent e) throws EventException {
+		public Map<String, Mixed> evaluate(BindableEvent e, Environment env) throws EventException {
 			if(e instanceof MCPlayerDropItemEvent) {
 				MCPlayerDropItemEvent event = (MCPlayerDropItemEvent) e;
 				Map<String, Mixed> map = evaluate_helper(e);
@@ -1183,12 +1133,12 @@ public Map<String, Mixed> evaluate(BindableEvent e) throws EventException {
 		}
 
 		@Override
-		public boolean modifyEvent(String key, Mixed value, BindableEvent event) {
+		public boolean modifyEvent(String key, Mixed value, BindableEvent event, Environment env) {
 			if(event instanceof MCPlayerDropItemEvent) {
 				MCPlayerDropItemEvent e = (MCPlayerDropItemEvent) event;
 
 				if(key.equalsIgnoreCase("item")) {
-					MCItemStack stack = ObjectGenerator.GetGenerator().item(value, value.getTarget());
+					MCItemStack stack = ObjectGenerator.GetGenerator().item(value, value.getTarget(), env);
 
 					e.setItemStack(stack);
 
@@ -1247,12 +1197,7 @@ public boolean matches(Map<String, Mixed> prefilter, BindableEvent e) throws Pre
 		}
 
 		@Override
-		public BindableEvent convert(CArray manualObject, Target t) {
-			return null;
-		}
-
-		@Override
-		public Map<String, Mixed> evaluate(BindableEvent e) throws EventException {
+		public Map<String, Mixed> evaluate(BindableEvent e, Environment env) throws EventException {
 			if(e instanceof MCPlayerPickupItemEvent) {
 				MCPlayerPickupItemEvent event = (MCPlayerPickupItemEvent) e;
 				Map<String, Mixed> map = evaluate_helper(e);
@@ -1271,12 +1216,12 @@ public Driver driver() {
 		}
 
 		@Override
-		public boolean modifyEvent(String key, Mixed value, BindableEvent event) {
+		public boolean modifyEvent(String key, Mixed value, BindableEvent event, Environment env) {
 			if(event instanceof MCPlayerPickupItemEvent) {
 				MCPlayerPickupItemEvent e = (MCPlayerPickupItemEvent) event;
 
 				if(key.equalsIgnoreCase("item")) {
-					MCItemStack stack = ObjectGenerator.GetGenerator().item(value, value.getTarget());
+					MCItemStack stack = ObjectGenerator.GetGenerator().item(value, value.getTarget(), env);
 
 					e.setItemStack(stack);
 
@@ -1329,13 +1274,8 @@ public boolean matches(Map<String, Mixed> prefilter, BindableEvent e)
 		}
 
 		@Override
-		public BindableEvent convert(CArray manualObject, Target t) {
-			throw ConfigRuntimeException.CreateUncatchableException("Unsupported Operation", Target.UNKNOWN);
-		}
-
-		@Override
-		public Map<String, Mixed> evaluate(BindableEvent e)
-				throws EventException {
+		public Map<String, Mixed> evaluate(BindableEvent e,
+				Environment env) throws EventException {
 			if(e instanceof MCEntityDamageByEntityEvent) {
 				MCEntityDamageByEntityEvent event = (MCEntityDamageByEntityEvent) e;
 				Map<String, Mixed> map = evaluate_helper(e);
@@ -1381,11 +1321,11 @@ public Driver driver() {
 
 		@Override
 		public boolean modifyEvent(String key, Mixed value,
-				BindableEvent e) {
+				BindableEvent e, Environment env) {
 			MCEntityDamageByEntityEvent event = (MCEntityDamageByEntityEvent) e;
 
 			if(key.equals("amount")) {
-				if(value.isInstanceOf(CInt.TYPE)) {
+				if(value.isInstanceOf(CInt.TYPE, null, env)) {
 					event.setDamage(Integer.parseInt(value.val()));
 
 					return true;
@@ -1444,7 +1384,7 @@ public boolean matches(Map<String, Mixed> prefilter, BindableEvent e) throws Pre
 		}
 
 		@Override
-		public Map<String, Mixed> evaluate(BindableEvent e) throws EventException {
+		public Map<String, Mixed> evaluate(BindableEvent e, Environment env) throws EventException {
 			if(e instanceof MCEntityTargetEvent) {
 				MCEntityTargetEvent ete = (MCEntityTargetEvent) e;
 				Map<String, Mixed> map = evaluate_helper(e);
@@ -1461,7 +1401,7 @@ public Map<String, Mixed> evaluate(BindableEvent e) throws EventException {
 		}
 
 		@Override
-		public boolean modifyEvent(String key, Mixed value, BindableEvent event) {
+		public boolean modifyEvent(String key, Mixed value, BindableEvent event, Environment env) {
 			if(event instanceof MCEntityTargetEvent) {
 				MCEntityTargetEvent ete = (MCEntityTargetEvent) event;
 
@@ -1469,8 +1409,8 @@ public boolean modifyEvent(String key, Mixed value, BindableEvent event) {
 					if(value instanceof CNull) {
 						ete.setTarget(null);
 						return true;
-					} else if(value.isInstanceOf(CString.TYPE)) {
-						MCPlayer p = Static.GetPlayer(value.val(), value.getTarget());
+					} else if(value.isInstanceOf(CString.TYPE, null, env)) {
+						MCPlayer p = Static.GetPlayer(value.val(), value.getTarget(), env);
 
 						if(p.isOnline()) {
 							ete.setTarget(p);
@@ -1484,9 +1424,9 @@ public boolean modifyEvent(String key, Mixed value, BindableEvent event) {
 		}
 
 		@Override
-		public BindableEvent convert(CArray manual, Target t) {
+		public BindableEvent convert(CArray manual, Target t, Environment env) {
 			return EventBuilder.instantiate(MCEntityTargetEvent.class,
-					Static.GetPlayer(manual.get("player", Target.UNKNOWN).val(), Target.UNKNOWN));
+					Static.GetPlayer(manual.get("player", Target.UNKNOWN, env).val(), Target.UNKNOWN, env));
 		}
 
 	}
@@ -1529,12 +1469,7 @@ public boolean matches(Map<String, Mixed> prefilter, BindableEvent e) throws Pre
 		}
 
 		@Override
-		public BindableEvent convert(CArray manualObject, Target t) {
-			throw ConfigRuntimeException.CreateUncatchableException("Unsupported Operation", Target.UNKNOWN);
-		}
-
-		@Override
-		public Map<String, Mixed> evaluate(BindableEvent e) throws EventException {
+		public Map<String, Mixed> evaluate(BindableEvent e, Environment env) throws EventException {
 			if(e instanceof MCEntityEnterPortalEvent) {
 				MCEntityEnterPortalEvent event = (MCEntityEnterPortalEvent) e;
 				MCMaterial mat = event.getLocation().getBlock().getType();
@@ -1551,7 +1486,7 @@ public Map<String, Mixed> evaluate(BindableEvent e) throws EventException {
 		}
 
 		@Override
-		public boolean modifyEvent(String key, Mixed value, BindableEvent event) {
+		public boolean modifyEvent(String key, Mixed value, BindableEvent event, Environment env) {
 			return false;
 		}
 
@@ -1593,7 +1528,7 @@ public void bind(BoundEvent event) {
 			Map<String, Mixed> prefilter = event.getPrefilter();
 			if(prefilter.containsKey("from")) {
 				Mixed type = prefilter.get("from");
-				if(type.isInstanceOf(CString.TYPE) && type.val().contains(":") || ArgumentValidation.isNumber(type)) {
+				if(type.isInstanceOf(CString.TYPE, null, event.getEnvironment()) && type.val().contains(":") || ArgumentValidation.isNumber(type)) {
 					MSLog.GetLogger().w(MSLog.Tags.DEPRECATION, "The 0:0 block format in " + getName()
 							+ " is deprecated in \"from\" prefilter.", event.getTarget());
 					MCItemStack is = Static.ParseItemNotation(null, type.val(), 1, event.getTarget());
@@ -1602,7 +1537,7 @@ public void bind(BoundEvent event) {
 			}
 			if(prefilter.containsKey("to")) {
 				Mixed type = prefilter.get("to");
-				if(type.isInstanceOf(CString.TYPE) && type.val().contains(":") || ArgumentValidation.isNumber(type)) {
+				if(type.isInstanceOf(CString.TYPE, null, event.getEnvironment()) && type.val().contains(":") || ArgumentValidation.isNumber(type)) {
 					MSLog.GetLogger().w(MSLog.Tags.DEPRECATION, "The 0:0 block format in " + getName()
 							+ " is deprecated in \"to\" prefilter.", event.getTarget());
 					MCItemStack is = Static.ParseItemNotation(null, type.val(), 1, event.getTarget());
@@ -1625,13 +1560,8 @@ public boolean matches(Map<String, Mixed> prefilter, BindableEvent e)
 		}
 
 		@Override
-		public BindableEvent convert(CArray manualObject, Target t) {
-			return null;
-		}
-
-		@Override
-		public Map<String, Mixed> evaluate(BindableEvent e)
-				throws EventException {
+		public Map<String, Mixed> evaluate(BindableEvent e,
+				Environment env) throws EventException {
 			if(e instanceof MCEntityChangeBlockEvent) {
 				MCEntityChangeBlockEvent event = (MCEntityChangeBlockEvent) e;
 				Target t = Target.UNKNOWN;
@@ -1647,7 +1577,7 @@ public Map<String, Mixed> evaluate(BindableEvent e)
 		}
 
 		@Override
-		public boolean modifyEvent(String key, Mixed value, BindableEvent event) {
+		public boolean modifyEvent(String key, Mixed value, BindableEvent event, Environment env) {
 			return false;
 		}
 
@@ -1693,7 +1623,7 @@ public void bind(BoundEvent event) {
 						+ " is deprecated for \"block\". Converted to " + mat.getName(), event.getTarget());
 			} else if(prefilter.containsKey("block")) {
 				Mixed ctype = prefilter.get("block");
-				if(ctype.isInstanceOf(CString.TYPE) && ctype.val().contains(":") || ArgumentValidation.isNumber(ctype)) {
+				if(ctype.isInstanceOf(CString.TYPE, null, event.getEnvironment()) && ctype.val().contains(":") || ArgumentValidation.isNumber(ctype)) {
 					int type;
 					String notation = ctype.val();
 					int separatorIndex = notation.indexOf(':');
@@ -1729,12 +1659,7 @@ public boolean matches(Map<String, Mixed> prefilter, BindableEvent e) throws Pre
 		}
 
 		@Override
-		public BindableEvent convert(CArray manualObject, Target t) {
-			return null;
-		}
-
-		@Override
-		public Map<String, Mixed> evaluate(BindableEvent e) throws EventException {
+		public Map<String, Mixed> evaluate(BindableEvent e, Environment env) throws EventException {
 			if(e instanceof MCEntityInteractEvent) {
 				MCEntityInteractEvent event = (MCEntityInteractEvent) e;
 				Target t = Target.UNKNOWN;
@@ -1749,7 +1674,7 @@ public Map<String, Mixed> evaluate(BindableEvent e) throws EventException {
 		}
 
 		@Override
-		public boolean modifyEvent(String key, Mixed value, BindableEvent event) {
+		public boolean modifyEvent(String key, Mixed value, BindableEvent event, Environment env) {
 			return false;
 		}
 
@@ -1843,14 +1768,8 @@ public boolean matches(Map<String, Mixed> prefilter, BindableEvent event) throws
 				return false;
 			}
 		}
-
-		@Override
-		public BindableEvent convert(CArray manualObject, Target t) {
-			return null;
-		}
-
 		@Override
-		public Map<String, Mixed> evaluate(BindableEvent event) throws EventException {
+		public Map<String, Mixed> evaluate(BindableEvent event, Environment env) throws EventException {
 			if(event instanceof MCHangingBreakEvent) {
 				MCHangingBreakEvent hangingBreakEvent = (MCHangingBreakEvent) event;
 				Map<String, Mixed> mapEvent = evaluate_helper(event);
@@ -1878,7 +1797,7 @@ public Map<String, Mixed> evaluate(BindableEvent event) throws EventException {
 		}
 
 		@Override
-		public boolean modifyEvent(String key, Mixed value, BindableEvent event) {
+		public boolean modifyEvent(String key, Mixed value, BindableEvent event, Environment env) {
 			return false;
 		}
 	}
@@ -1932,12 +1851,7 @@ public boolean matches(Map<String, Mixed> prefilter, BindableEvent event) throws
 		}
 
 		@Override
-		public BindableEvent convert(CArray manualObject, Target t) {
-			return null;
-		}
-
-		@Override
-		public Map<String, Mixed> evaluate(BindableEvent event) throws EventException {
+		public Map<String, Mixed> evaluate(BindableEvent event, Environment env) throws EventException {
 			if(event instanceof MCHangingPlaceEvent e) {
 				Map<String, Mixed> ret = evaluate_helper(event);
 				MCHanging hanging = e.getEntity();
@@ -1983,7 +1897,7 @@ public Driver driver() {
 		}
 
 		@Override
-		public boolean modifyEvent(String key, Mixed value, BindableEvent event) {
+		public boolean modifyEvent(String key, Mixed value, BindableEvent event, Environment env) {
 			return false;
 		}
 
@@ -2026,12 +1940,7 @@ public boolean matches(Map<String, Mixed> filter, BindableEvent e) throws Prefil
 		}
 
 		@Override
-		public BindableEvent convert(CArray manualObject, Target t) {
-			return null;
-		}
-
-		@Override
-		public Map<String, Mixed> evaluate(BindableEvent e) throws EventException {
+		public Map<String, Mixed> evaluate(BindableEvent e, Environment env) throws EventException {
 			if(e instanceof MCEntityToggleGlideEvent) {
 				MCEntityToggleGlideEvent evt = (MCEntityToggleGlideEvent) e;
 				Map<String, Mixed> ret = evaluate_helper(evt);
@@ -2054,7 +1963,7 @@ public Map<String, Mixed> evaluate(BindableEvent e) throws EventException {
 		}
 
 		@Override
-		public boolean modifyEvent(String key, Mixed value, BindableEvent event) throws ConfigRuntimeException {
+		public boolean modifyEvent(String key, Mixed value, BindableEvent event, Environment env) throws ConfigRuntimeException {
 			return false;
 		}
 
@@ -2108,12 +2017,7 @@ protected String getProperty(MCEntityToggleSwimEvent event) {
 		}
 
 		@Override
-		public MCEntityToggleSwimEvent convert(CArray manualObject, Target t) {
-			return null;
-		}
-
-		@Override
-		public Map<String, Mixed> evaluate(MCEntityToggleSwimEvent e) throws EventException {
+		public Map<String, Mixed> evaluate(MCEntityToggleSwimEvent e, Environment env) throws EventException {
 			Map<String, Mixed> ret = evaluate_helper(e);
 			Target t = Target.UNKNOWN;
 
@@ -2131,7 +2035,7 @@ public Map<String, Mixed> evaluate(MCEntityToggleSwimEvent e) throws EventExcept
 		}
 
 		@Override
-		public boolean modifyEvent(String key, Mixed value, MCEntityToggleSwimEvent event) throws ConfigRuntimeException {
+		public boolean modifyEvent(String key, Mixed value, MCEntityToggleSwimEvent event, Environment env) throws ConfigRuntimeException {
 			return false;
 		}
 
@@ -2191,12 +2095,7 @@ public boolean matches(Map<String, Mixed> prefilter, BindableEvent e) throws Pre
 		}
 
 		@Override
-		public BindableEvent convert(CArray manualObject, Target t) {
-			return null;
-		}
-
-		@Override
-		public Map<String, Mixed> evaluate(BindableEvent event) throws EventException {
+		public Map<String, Mixed> evaluate(BindableEvent event, Environment env) throws EventException {
 			if(event instanceof MCFireworkExplodeEvent) {
 				MCFireworkExplodeEvent e = (MCFireworkExplodeEvent) event;
 				Map<String, Mixed> ret = new HashMap<>();
@@ -2215,7 +2114,7 @@ public Driver driver() {
 		}
 
 		@Override
-		public boolean modifyEvent(String key, Mixed value, BindableEvent event) {
+		public boolean modifyEvent(String key, Mixed value, BindableEvent event, Environment env) {
 			return false;
 		}
 	}
@@ -2256,12 +2155,7 @@ public boolean matches(Map<String, Mixed> prefilter, BindableEvent e) throws Pre
 		}
 
 		@Override
-		public BindableEvent convert(CArray manualObject, Target t) {
-			return null;
-		}
-
-		@Override
-		public Map<String, Mixed> evaluate(BindableEvent e) throws EventException {
+		public Map<String, Mixed> evaluate(BindableEvent e, Environment env) throws EventException {
 			if(e instanceof MCEntityRegainHealthEvent) {
 				MCEntityRegainHealthEvent event = (MCEntityRegainHealthEvent) e;
 
@@ -2281,11 +2175,11 @@ public Driver driver() {
 		}
 
 		@Override
-		public boolean modifyEvent(String key, Mixed value, BindableEvent event) {
+		public boolean modifyEvent(String key, Mixed value, BindableEvent event, Environment env) {
 			if(event instanceof MCEntityRegainHealthEvent) {
 				MCEntityRegainHealthEvent e = (MCEntityRegainHealthEvent) event;
 				if(key.equalsIgnoreCase("amount")) {
-					e.setAmount(ArgumentValidation.getDouble(value, value.getTarget()));
+					e.setAmount(ArgumentValidation.getDouble(value, value.getTarget(), env));
 					return true;
 				}
 			}
@@ -2331,12 +2225,7 @@ public boolean matches(Map<String, Mixed> prefilter, BindableEvent e) throws Pre
 		}
 
 		@Override
-		public BindableEvent convert(CArray manualObject, Target t) {
-			return null;
-		}
-
-		@Override
-		public Map<String, Mixed> evaluate(BindableEvent e) throws EventException {
+		public Map<String, Mixed> evaluate(BindableEvent e, Environment env) throws EventException {
 			if(e instanceof MCEntityPortalEvent) {
 				MCEntityPortalEvent event = (MCEntityPortalEvent) e;
 				Map<String, Mixed> ret = new HashMap<>();
@@ -2363,18 +2252,18 @@ public Driver driver() {
 		}
 
 		@Override
-		public boolean modifyEvent(String key, Mixed value, BindableEvent event) {
+		public boolean modifyEvent(String key, Mixed value, BindableEvent event, Environment env) {
 			if(event instanceof MCEntityPortalEvent) {
 				MCEntityPortalEvent e = (MCEntityPortalEvent) event;
 
 				if(key.equalsIgnoreCase("to")) {
-					MCLocation loc = ObjectGenerator.GetGenerator().location(value, null, value.getTarget());
+					MCLocation loc = ObjectGenerator.GetGenerator().location(value, null, value.getTarget(), env);
 					e.setTo(loc);
 					return true;
 				}
 
 				if(key.equalsIgnoreCase("searchradius")) {
-					e.setSearchRadius(ArgumentValidation.getInt32(value, value.getTarget()));
+					e.setSearchRadius(ArgumentValidation.getInt32(value, value.getTarget(), env));
 					return true;
 				}
 			}
@@ -2412,12 +2301,7 @@ public boolean matches(Map<String, Mixed> prefilter, BindableEvent e) throws Pre
 		}
 
 		@Override
-		public BindableEvent convert(CArray manualObject, Target t) {
-			return null;
-		}
-
-		@Override
-		public Map<String, Mixed> evaluate(BindableEvent e) throws EventException {
+		public Map<String, Mixed> evaluate(BindableEvent e, Environment env) throws EventException {
 			if(e instanceof MCEntityUnleashEvent) {
 				MCEntityUnleashEvent event = (MCEntityUnleashEvent) e;
 
@@ -2437,7 +2321,7 @@ public Driver driver() {
 		}
 
 		@Override
-		public boolean modifyEvent(String key, Mixed value, BindableEvent event) {
+		public boolean modifyEvent(String key, Mixed value, BindableEvent event, Environment env) {
 			return false;
 		}
 
@@ -2475,12 +2359,7 @@ public boolean matches(Map<String, Mixed> prefilter, BindableEvent event) throws
 		}
 
 		@Override
-		public BindableEvent convert(CArray manualObject, Target t) {
-			return null;
-		}
-
-		@Override
-		public Map<String, Mixed> evaluate(BindableEvent e) throws EventException {
+		public Map<String, Mixed> evaluate(BindableEvent e, Environment env) throws EventException {
 			if(e instanceof MCPotionSplashEvent) {
 				MCPotionSplashEvent event = (MCPotionSplashEvent) e;
 				Target t = Target.UNKNOWN;
@@ -2505,7 +2384,7 @@ public Driver driver() {
 		}
 
 		@Override
-		public boolean modifyEvent(String key, Mixed value, BindableEvent event) {
+		public boolean modifyEvent(String key, Mixed value, BindableEvent event, Environment env) {
 			if(event instanceof MCPotionSplashEvent) {
 				MCPotionSplashEvent splashEvent = (MCPotionSplashEvent) event;
 				Target t = value.getTarget();
@@ -2559,11 +2438,6 @@ public Driver driver() {
 			return Driver.ENTITY_POTION_EFFECT;
 		}
 
-		@Override
-		public BindableEvent convert(CArray manualObject, Target t) {
-			return null;
-		}
-
 		@Override
 		public Version since() {
 			return MSVersion.V3_3_4;
@@ -2587,7 +2461,7 @@ public boolean matches(Map<String, Mixed> prefilter, BindableEvent e) throws Pre
 		}
 
 		@Override
-		public Map<String, Mixed> evaluate(BindableEvent e) throws EventException {
+		public Map<String, Mixed> evaluate(BindableEvent e, Environment env) throws EventException {
 			if(!(e instanceof MCEntityPotionEffectEvent)) {
 				throw new EventException("Cannot convert event to MCEntityPotionEffectEvent");
 			} else {
@@ -2607,7 +2481,7 @@ public Map<String, Mixed> evaluate(BindableEvent e) throws EventException {
 		}
 
 		@Override
-		public boolean modifyEvent(String key, Mixed value, BindableEvent e) {
+		public boolean modifyEvent(String key, Mixed value, BindableEvent e, Environment env) {
 			return false;
 		}
 	}
diff --git a/src/main/java/com/laytonsmith/core/events/drivers/InventoryEvents.java b/src/main/java/com/laytonsmith/core/events/drivers/InventoryEvents.java
index c78751acbf..456792827d 100644
--- a/src/main/java/com/laytonsmith/core/events/drivers/InventoryEvents.java
+++ b/src/main/java/com/laytonsmith/core/events/drivers/InventoryEvents.java
@@ -38,15 +38,14 @@
 import com.laytonsmith.core.constructs.CInt;
 import com.laytonsmith.core.constructs.CString;
 import com.laytonsmith.core.constructs.Target;
+import com.laytonsmith.core.environments.Environment;
 import com.laytonsmith.core.events.AbstractEvent;
 import com.laytonsmith.core.events.BindableEvent;
 import com.laytonsmith.core.events.BoundEvent;
 import com.laytonsmith.core.events.Driver;
 import com.laytonsmith.core.events.Prefilters;
 import com.laytonsmith.core.events.Prefilters.PrefilterType;
-import com.laytonsmith.core.exceptions.CRE.CREBindException;
 import com.laytonsmith.core.exceptions.CRE.CREFormatException;
-import com.laytonsmith.core.exceptions.ConfigRuntimeException;
 import com.laytonsmith.core.exceptions.EventException;
 import com.laytonsmith.core.exceptions.PrefilterNonMatchException;
 import com.laytonsmith.core.functions.InventoryManagement;
@@ -102,7 +101,7 @@ public void bind(BoundEvent event) {
 			Map<String, Mixed> prefilter = event.getPrefilter();
 			if(prefilter.containsKey("slotitem")) {
 				Mixed type = prefilter.get("slotitem");
-				if(type.isInstanceOf(CString.TYPE) && type.val().contains(":") || ArgumentValidation.isNumber(type)) {
+				if(type.isInstanceOf(CString.TYPE, null, event.getEnvironment()) && type.val().contains(":") || ArgumentValidation.isNumber(type)) {
 					MCItemStack is = Static.ParseItemNotation(null, prefilter.get("slotitem").val(), 1, event.getTarget());
 					prefilter.put("slotitem", new CString(is.getType().getName(), event.getTarget()));
 					MSLog.GetLogger().w(MSLog.Tags.DEPRECATION, "The item notation format for the \"slotitem\" prefilter"
@@ -134,12 +133,7 @@ public boolean matches(Map<String, Mixed> prefilter, BindableEvent event) throws
 		}
 
 		@Override
-		public BindableEvent convert(CArray manualObject, Target t) {
-			throw new CREBindException("Unsupported Operation", Target.UNKNOWN);
-		}
-
-		@Override
-		public Map<String, Mixed> evaluate(BindableEvent event) throws EventException {
+		public Map<String, Mixed> evaluate(BindableEvent event, Environment env) throws EventException {
 			if(event instanceof MCInventoryClickEvent) {
 				MCInventoryClickEvent e = (MCInventoryClickEvent) event;
 				Map<String, Mixed> map = evaluate_helper(event);
@@ -148,7 +142,7 @@ public Map<String, Mixed> evaluate(BindableEvent event) throws EventException {
 				map.put("player", new CString(e.getWhoClicked().getName(), t));
 				CArray viewers = new CArray(t);
 				for(MCHumanEntity viewer : e.getViewers()) {
-					viewers.push(new CString(viewer.getName(), t), t);
+					viewers.push(new CString(viewer.getName(), t), t, env);
 				}
 				map.put("viewers", viewers);
 
@@ -168,10 +162,10 @@ public Map<String, Mixed> evaluate(BindableEvent event) throws EventException {
 				map.put("slottype", new CString(e.getSlotType().name(), t));
 				map.put("slotitem", ObjectGenerator.GetGenerator().item(e.getCurrentItem(), t));
 
-				CArray items = CArray.GetAssociativeArray(t);
+				CArray items = CArray.GetAssociativeArray(t, null, env);
 				MCInventory inv = e.getInventory();
 				for(int i = 0; i < inv.getSize(); i++) {
-					items.set(i, ObjectGenerator.GetGenerator().item(inv.getItem(i), t), t);
+					items.set(i, ObjectGenerator.GetGenerator().item(inv.getItem(i), t), t, env);
 				}
 				map.put("inventory", items);
 				map.put("inventorytype", new CString(inv.getType().name(), t));
@@ -189,16 +183,16 @@ public Driver driver() {
 		}
 
 		@Override
-		public boolean modifyEvent(String key, Mixed value, BindableEvent event) {
+		public boolean modifyEvent(String key, Mixed value, BindableEvent event, Environment env) {
 			if(event instanceof MCInventoryClickEvent) {
 				MCInventoryClickEvent e = (MCInventoryClickEvent) event;
 
 				if(key.equalsIgnoreCase("slotitem")) {
-					e.setCurrentItem(ObjectGenerator.GetGenerator().item(value, value.getTarget()));
+					e.setCurrentItem(ObjectGenerator.GetGenerator().item(value, value.getTarget(), env));
 					return true;
 				}
 				if(key.equalsIgnoreCase("cursoritem")) {
-					e.setCursor(ObjectGenerator.GetGenerator().item(value, value.getTarget()));
+					e.setCursor(ObjectGenerator.GetGenerator().item(value, value.getTarget(), env));
 					return true;
 				}
 			}
@@ -244,7 +238,7 @@ public void bind(BoundEvent event) {
 			Map<String, Mixed> prefilter = event.getPrefilter();
 			if(prefilter.containsKey("cursoritem")) {
 				Mixed type = prefilter.get("cursoritem");
-				if(type.isInstanceOf(CString.TYPE) && type.val().contains(":") || ArgumentValidation.isNumber(type)) {
+				if(type.isInstanceOf(CString.TYPE, null, event.getEnvironment()) && type.val().contains(":") || ArgumentValidation.isNumber(type)) {
 					MCItemStack is = Static.ParseItemNotation(null, prefilter.get("cursoritem").val(), 1, event.getTarget());
 					prefilter.put("cursoritem", new CString(is.getType().getName(), event.getTarget()));
 					MSLog.GetLogger().w(MSLog.Tags.DEPRECATION, "The item notation format for the \"cursoritem\" prefilter"
@@ -274,12 +268,7 @@ public boolean matches(Map<String, Mixed> prefilter, BindableEvent event) throws
 		}
 
 		@Override
-		public BindableEvent convert(CArray manualObject, Target t) {
-			return null;
-		}
-
-		@Override
-		public Map<String, Mixed> evaluate(BindableEvent event) throws EventException {
+		public Map<String, Mixed> evaluate(BindableEvent event, Environment env) throws EventException {
 			if(event instanceof MCInventoryDragEvent) {
 				MCInventoryDragEvent e = (MCInventoryDragEvent) event;
 				Map<String, Mixed> map = evaluate_helper(event);
@@ -290,28 +279,28 @@ public Map<String, Mixed> evaluate(BindableEvent event) throws EventException {
 
 				CArray slots = new CArray(Target.UNKNOWN);
 				for(Integer slot : e.getInventorySlots()) {
-					slots.push(new CInt(slot.intValue(), Target.UNKNOWN), Target.UNKNOWN);
+					slots.push(new CInt(slot.intValue(), Target.UNKNOWN), Target.UNKNOWN, env);
 				}
 				map.put("slots", slots);
 
 				CArray rawSlots = new CArray(Target.UNKNOWN);
 				for(Integer slot : e.getRawSlots()) {
-					rawSlots.push(new CInt(slot.intValue(), Target.UNKNOWN), Target.UNKNOWN);
+					rawSlots.push(new CInt(slot.intValue(), Target.UNKNOWN), Target.UNKNOWN, env);
 				}
 				map.put("rawslots", rawSlots);
 
-				CArray newItems = CArray.GetAssociativeArray(Target.UNKNOWN);
+				CArray newItems = CArray.GetAssociativeArray(Target.UNKNOWN, null, env);
 				for(Map.Entry<Integer, MCItemStack> ni : e.getNewItems().entrySet()) {
 					Integer key = ni.getKey();
 					MCItemStack value = ni.getValue();
-					newItems.set(key.intValue(), ObjectGenerator.GetGenerator().item(value, Target.UNKNOWN), Target.UNKNOWN);
+					newItems.set(key.intValue(), ObjectGenerator.GetGenerator().item(value, Target.UNKNOWN), Target.UNKNOWN, env);
 				}
 				map.put("newitems", newItems);
 
-				CArray items = CArray.GetAssociativeArray(Target.UNKNOWN);
+				CArray items = CArray.GetAssociativeArray(Target.UNKNOWN, null, env);
 				MCInventory inv = e.getInventory();
 				for(int i = 0; i < inv.getSize(); i++) {
-					items.set(i, ObjectGenerator.GetGenerator().item(inv.getItem(i), Target.UNKNOWN), Target.UNKNOWN);
+					items.set(i, ObjectGenerator.GetGenerator().item(inv.getItem(i), Target.UNKNOWN), Target.UNKNOWN, env);
 				}
 				map.put("inventory", items);
 				map.put("inventorytype", new CString(inv.getType().name(), Target.UNKNOWN));
@@ -331,12 +320,12 @@ public Driver driver() {
 		}
 
 		@Override
-		public boolean modifyEvent(String key, Mixed value, BindableEvent event) {
+		public boolean modifyEvent(String key, Mixed value, BindableEvent event, Environment env) {
 			if(event instanceof MCInventoryDragEvent) {
 				MCInventoryDragEvent e = (MCInventoryDragEvent) event;
 
 				if(key.equalsIgnoreCase("cursoritem")) {
-					e.setCursor(ObjectGenerator.GetGenerator().item(value, value.getTarget()));
+					e.setCursor(ObjectGenerator.GetGenerator().item(value, value.getTarget(), env));
 					return true;
 				}
 			}
@@ -384,12 +373,7 @@ public boolean matches(Map<String, Mixed> prefilter, BindableEvent event) throws
 		}
 
 		@Override
-		public BindableEvent convert(CArray manualObject, Target t) {
-			return null;
-		}
-
-		@Override
-		public Map<String, Mixed> evaluate(BindableEvent event) throws EventException {
+		public Map<String, Mixed> evaluate(BindableEvent event, Environment env) throws EventException {
 			if(event instanceof MCInventoryOpenEvent) {
 				MCInventoryOpenEvent e = (MCInventoryOpenEvent) event;
 				Map<String, Mixed> map = evaluate_helper(event);
@@ -397,16 +381,16 @@ public Map<String, Mixed> evaluate(BindableEvent event) throws EventException {
 
 				map.put("player", new CString(e.getPlayer().getName(), t));
 
-				CArray items = CArray.GetAssociativeArray(t);
+				CArray items = CArray.GetAssociativeArray(t, null, env);
 				MCInventory inv = e.getInventory();
 				for(int i = 0; i < inv.getSize(); i++) {
 					Mixed c = ObjectGenerator.GetGenerator().item(inv.getItem(i), t);
-					items.set(i, c, t);
+					items.set(i, c, t, env);
 				}
 				map.put("inventory", items);
 
 				map.put("inventorytype", new CString(inv.getType().name(), t));
-				map.put("holder", InventoryManagement.GetInventoryHolder(inv, t));
+				map.put("holder", InventoryManagement.GetInventoryHolder(inv, t, env));
 				map.put("virtual", CBoolean.get(inv.getHolder() instanceof MCVirtualInventoryHolder));
 
 				return map;
@@ -421,7 +405,7 @@ public Driver driver() {
 		}
 
 		@Override
-		public boolean modifyEvent(String key, Mixed value, BindableEvent event) {
+		public boolean modifyEvent(String key, Mixed value, BindableEvent event, Environment env) {
 			return false;
 		}
 
@@ -466,12 +450,7 @@ public boolean matches(Map<String, Mixed> prefilter, BindableEvent event) throws
 		}
 
 		@Override
-		public BindableEvent convert(CArray manualObject, Target t) {
-			return null;
-		}
-
-		@Override
-		public Map<String, Mixed> evaluate(BindableEvent event) throws EventException {
+		public Map<String, Mixed> evaluate(BindableEvent event, Environment env) throws EventException {
 			if(event instanceof MCInventoryCloseEvent) {
 				MCInventoryCloseEvent e = (MCInventoryCloseEvent) event;
 				Map<String, Mixed> map = evaluate_helper(event);
@@ -479,16 +458,16 @@ public Map<String, Mixed> evaluate(BindableEvent event) throws EventException {
 
 				map.put("player", new CString(e.getPlayer().getName(), t));
 
-				CArray items = CArray.GetAssociativeArray(t);
+				CArray items = CArray.GetAssociativeArray(t, null, env);
 				MCInventory inv = e.getInventory();
 				for(int i = 0; i < inv.getSize(); i++) {
 					Mixed c = ObjectGenerator.GetGenerator().item(inv.getItem(i), t);
-					items.set(i, c, t);
+					items.set(i, c, t, env);
 				}
 				map.put("inventory", items);
 
 				map.put("inventorytype", new CString(inv.getType().name(), t));
-				map.put("holder", InventoryManagement.GetInventoryHolder(inv, t));
+				map.put("holder", InventoryManagement.GetInventoryHolder(inv, t, env));
 				map.put("virtual", CBoolean.get(inv.getHolder() instanceof MCVirtualInventoryHolder));
 
 				return map;
@@ -503,7 +482,7 @@ public Driver driver() {
 		}
 
 		@Override
-		public boolean modifyEvent(String key, Mixed value, BindableEvent event) {
+		public boolean modifyEvent(String key, Mixed value, BindableEvent event, Environment env) {
 			return false;
 		}
 
@@ -547,12 +526,7 @@ public boolean matches(Map<String, Mixed> prefilter, BindableEvent e) throws Pre
 		}
 
 		@Override
-		public BindableEvent convert(CArray manualObject, Target t) {
-			return null;
-		}
-
-		@Override
-		public Map<String, Mixed> evaluate(BindableEvent event) throws EventException {
+		public Map<String, Mixed> evaluate(BindableEvent event, Environment env) throws EventException {
 			if(event instanceof MCEnchantItemEvent) {
 				MCEnchantItemEvent e = (MCEnchantItemEvent) event;
 				Map<String, Mixed> map = evaluate_helper(event);
@@ -581,17 +555,17 @@ public Driver driver() {
 		}
 
 		@Override
-		public boolean modifyEvent(String key, Mixed value, BindableEvent event) {
+		public boolean modifyEvent(String key, Mixed value, BindableEvent event, Environment env) {
 			if(event instanceof MCEnchantItemEvent) {
 				MCEnchantItemEvent e = (MCEnchantItemEvent) event;
 
 				if(key.equalsIgnoreCase("levels")) {
-					e.setExpLevelCost(ArgumentValidation.getInt32(value, value.getTarget()));
+					e.setExpLevelCost(ArgumentValidation.getInt32(value, value.getTarget(), env));
 					return true;
 				}
 
 				if(key.equalsIgnoreCase("item")) {
-					e.setItem(ObjectGenerator.GetGenerator().item(value, value.getTarget()));
+					e.setItem(ObjectGenerator.GetGenerator().item(value, value.getTarget(), env));
 					return true;
 				}
 
@@ -638,12 +612,7 @@ public boolean matches(Map<String, Mixed> prefilter, BindableEvent e) throws Pre
 		}
 
 		@Override
-		public BindableEvent convert(CArray manualObject, Target t) {
-			return null;
-		}
-
-		@Override
-		public Map<String, Mixed> evaluate(BindableEvent event) throws EventException {
+		public Map<String, Mixed> evaluate(BindableEvent event, Environment env) throws EventException {
 			if(event instanceof MCPrepareItemEnchantEvent) {
 				Target t = Target.UNKNOWN;
 				MCPrepareItemEnchantEvent e = (MCPrepareItemEnchantEvent) event;
@@ -657,7 +626,7 @@ public Map<String, Mixed> evaluate(BindableEvent event) throws EventException {
 				CArray expCostsCArray = new CArray(t);
 				MCEnchantmentOffer[] offers = e.getOffers();
 				for(MCEnchantmentOffer offer : offers) {
-					expCostsCArray.push(new CInt(offer.getCost(), t), t);
+					expCostsCArray.push(new CInt(offer.getCost(), t), t, env);
 				}
 				map.put("expcosts", expCostsCArray);
 
@@ -675,26 +644,26 @@ public Driver driver() {
 		}
 
 		@Override
-		public boolean modifyEvent(String key, Mixed value, BindableEvent event) {
+		public boolean modifyEvent(String key, Mixed value, BindableEvent event, Environment env) {
 			if(event instanceof MCPrepareItemEnchantEvent) {
 				Target t = value.getTarget();
 				MCPrepareItemEnchantEvent e = (MCPrepareItemEnchantEvent) event;
 
 				if(key.equalsIgnoreCase("item")) {
-					e.setItem(ObjectGenerator.GetGenerator().item(value, t));
+					e.setItem(ObjectGenerator.GetGenerator().item(value, t, env));
 					return true;
 				}
 
 				if(key.equalsIgnoreCase("expcosts")) {
-					if(value.isInstanceOf(CArray.TYPE)) {
+					if(value.isInstanceOf(CArray.TYPE, null, env)) {
 						CArray cExpCosts = (CArray) value;
 						if(!cExpCosts.inAssociativeMode()) {
 							MCEnchantmentOffer[] offers = e.getOffers();
 
 							for(int i = 0; i <= 2; i++) {
 								MCEnchantmentOffer offer = offers[i];
-								Mixed cost = cExpCosts.get(i, t);
-								offer.setCost(ArgumentValidation.getInt32(cost, t));
+								Mixed cost = cExpCosts.get(i, t, env);
+								offer.setCost(ArgumentValidation.getInt32(cost, t, env));
 							}
 						} else {
 							throw new CREFormatException("Expected a normal array!", t);
@@ -744,12 +713,7 @@ public boolean matches(Map<String, Mixed> prefilter, BindableEvent event) throws
 		}
 
 		@Override
-		public BindableEvent convert(CArray manualObject, Target t) {
-			throw ConfigRuntimeException.CreateUncatchableException("Unsupported operation.", Target.UNKNOWN);
-		}
-
-		@Override
-		public Map<String, Mixed> evaluate(BindableEvent event) throws EventException {
+		public Map<String, Mixed> evaluate(BindableEvent event, Environment env) throws EventException {
 			if(event instanceof MCItemHeldEvent) {
 				MCItemHeldEvent e = (MCItemHeldEvent) event;
 				Map<String, Mixed> ret = evaluate_helper(e);
@@ -767,11 +731,11 @@ public Driver driver() {
 		}
 
 		@Override
-		public boolean modifyEvent(String key, Mixed value, BindableEvent event) {
+		public boolean modifyEvent(String key, Mixed value, BindableEvent event, Environment env) {
 			if(event instanceof MCItemHeldEvent) {
 				MCItemHeldEvent e = (MCItemHeldEvent) event;
 				if("to".equals(key)) {
-					e.getPlayer().getInventory().setHeldItemSlot(ArgumentValidation.getInt32(value, value.getTarget()));
+					e.getPlayer().getInventory().setHeldItemSlot(ArgumentValidation.getInt32(value, value.getTarget(), env));
 					return true;
 				}
 			}
@@ -811,7 +775,7 @@ public void bind(BoundEvent event) {
 			Map<String, Mixed> prefilter = event.getPrefilter();
 			if(prefilter.containsKey("main_hand")) {
 				Mixed type = prefilter.get("main_hand");
-				if(type.isInstanceOf(CString.TYPE) && type.val().contains(":") || ArgumentValidation.isNumber(type)) {
+				if(type.isInstanceOf(CString.TYPE, null, event.getEnvironment()) && type.val().contains(":") || ArgumentValidation.isNumber(type)) {
 					MSLog.GetLogger().w(MSLog.Tags.DEPRECATION, "The item notation format in the \"main_hand\""
 							+ " prefilter in " + getName() + " is deprecated.", event.getTarget());
 					MCItemStack is = Static.ParseItemNotation(null, prefilter.get("main_hand").val(), 1, event.getTarget());
@@ -820,7 +784,7 @@ public void bind(BoundEvent event) {
 			}
 			if(prefilter.containsKey("off_hand")) {
 				Mixed type = prefilter.get("off_hand");
-				if(type.isInstanceOf(CString.TYPE) && type.val().contains(":") || ArgumentValidation.isNumber(type)) {
+				if(type.isInstanceOf(CString.TYPE, null, event.getEnvironment()) && type.val().contains(":") || ArgumentValidation.isNumber(type)) {
 					MSLog.GetLogger().w(MSLog.Tags.DEPRECATION, "The item notation format in the \"off_hand\""
 							+ " prefilter in " + getName() + " is deprecated.", event.getTarget());
 					MCItemStack is = Static.ParseItemNotation(null, prefilter.get("off_hand").val(), 1, event.getTarget());
@@ -854,12 +818,7 @@ public boolean matches(Map<String, Mixed> prefilter, BindableEvent event) throws
 		}
 
 		@Override
-		public BindableEvent convert(CArray manualObject, Target t) {
-			throw ConfigRuntimeException.CreateUncatchableException("Unsupported operation.", Target.UNKNOWN);
-		}
-
-		@Override
-		public Map<String, Mixed> evaluate(BindableEvent event) throws EventException {
+		public Map<String, Mixed> evaluate(BindableEvent event, Environment env) throws EventException {
 			if(event instanceof MCItemSwapEvent) {
 				MCItemSwapEvent e = (MCItemSwapEvent) event;
 				Map<String, Mixed> ret = evaluate_helper(e);
@@ -877,15 +836,15 @@ public Driver driver() {
 		}
 
 		@Override
-		public boolean modifyEvent(String key, Mixed value, BindableEvent event) {
+		public boolean modifyEvent(String key, Mixed value, BindableEvent event, Environment env) {
 			if(event instanceof MCItemSwapEvent) {
 				MCItemSwapEvent e = (MCItemSwapEvent) event;
 				if("main_hand".equals(key)) {
-					e.setMainHandItem(ObjectGenerator.GetGenerator().item(value, value.getTarget()));
+					e.setMainHandItem(ObjectGenerator.GetGenerator().item(value, value.getTarget(), env));
 					return true;
 				}
 				if("off_hand".equals(key)) {
-					e.setOffHandItem(ObjectGenerator.GetGenerator().item(value, value.getTarget()));
+					e.setOffHandItem(ObjectGenerator.GetGenerator().item(value, value.getTarget(), env));
 					return true;
 				}
 			}
@@ -929,27 +888,22 @@ public boolean matches(Map<String, Mixed> prefilter, BindableEvent event) throws
 		}
 
 		@Override
-		public BindableEvent convert(CArray manualObject, Target t) {
-			throw ConfigRuntimeException.CreateUncatchableException("Unsupported operation.", Target.UNKNOWN);
-		}
-
-		@Override
-		public Map<String, Mixed> evaluate(BindableEvent event) throws EventException {
+		public Map<String, Mixed> evaluate(BindableEvent event, Environment env) throws EventException {
 			if(event instanceof MCPrepareItemCraftEvent e) {
 				Map<String, Mixed> ret = evaluate_helper(e);
 				Target t = Target.UNKNOWN;
 				CArray viewers = new CArray(t);
 				for(MCHumanEntity v : e.getViewers()) {
-					viewers.push(new CString(v.getName(), t), t);
+					viewers.push(new CString(v.getName(), t), t, env);
 				}
 				ret.put("viewers", viewers);
 				ret.put("player", new CString(e.getPlayer().getName(), t));
 				ret.put("recipe", ObjectGenerator.GetGenerator().recipe(e.getRecipe(), t));
 				ret.put("isRepair", CBoolean.get(e.isRepair()));
-				CArray matrix = CArray.GetAssociativeArray(t);
+				CArray matrix = CArray.GetAssociativeArray(t, null, env);
 				MCItemStack[] mi = e.getInventory().getMatrix();
 				for(int i = 0; i < mi.length; i++) {
-					matrix.set(i, ObjectGenerator.GetGenerator().item(mi[i], t), t);
+					matrix.set(i, ObjectGenerator.GetGenerator().item(mi[i], t), t, env);
 				}
 				ret.put("matrix", matrix);
 				ret.put("result", ObjectGenerator.GetGenerator().item(e.getInventory().getResult(), t));
@@ -965,11 +919,11 @@ public Driver driver() {
 		}
 
 		@Override
-		public boolean modifyEvent(String key, Mixed value, BindableEvent event) {
+		public boolean modifyEvent(String key, Mixed value, BindableEvent event, Environment env) {
 			if(event instanceof MCPrepareItemCraftEvent e) {
 				Target t = Target.UNKNOWN;
 				if("result".equals(key)) {
-					e.getInventory().setResult(ObjectGenerator.GetGenerator().item(value, t));
+					e.getInventory().setResult(ObjectGenerator.GetGenerator().item(value, t, env));
 					return true;
 				}
 			}
@@ -1019,12 +973,7 @@ public boolean matches(Map<String, Mixed> prefilter, BindableEvent event) throws
 		}
 
 		@Override
-		public BindableEvent convert(CArray manualObject, Target t) {
-			throw ConfigRuntimeException.CreateUncatchableException("Unsupported operation.", Target.UNKNOWN);
-		}
-
-		@Override
-		public Map<String, Mixed> evaluate(BindableEvent event) throws EventException {
+		public Map<String, Mixed> evaluate(BindableEvent event, Environment env) throws EventException {
 			if(event instanceof MCPrepareAnvilEvent e) {
 				MCAnvilInventory anvil = (MCAnvilInventory) e.getInventory();
 				Map<String, Mixed> ret = evaluate_helper(e);
@@ -1051,23 +1000,23 @@ public Driver driver() {
 		}
 
 		@Override
-		public boolean modifyEvent(String key, Mixed value, BindableEvent event) {
+		public boolean modifyEvent(String key, Mixed value, BindableEvent event, Environment env) {
 			if(event instanceof MCPrepareAnvilEvent e) {
 				Target t = value.getTarget();
 				if(key.equalsIgnoreCase("result")) {
-					e.setResult(ObjectGenerator.GetGenerator().item(value, t));
+					e.setResult(ObjectGenerator.GetGenerator().item(value, t, env));
 					return true;
 				}
 
 				MCAnvilInventory anvil = (MCAnvilInventory) e.getInventory();
 				if(key.equalsIgnoreCase("level_repair_cost")) {
-					anvil.setRepairCost(ArgumentValidation.getInt32(value, t));
+					anvil.setRepairCost(ArgumentValidation.getInt32(value, t, env));
 					return true;
 				}
 
 				if(key.equalsIgnoreCase("item_repair_cost")) {
 					if(Static.getServer().getMinecraftVersion().gte(MCVersion.MC1_18_1)) {
-						anvil.setRepairCostAmount(ArgumentValidation.getInt32(value, t));
+						anvil.setRepairCostAmount(ArgumentValidation.getInt32(value, t, env));
 						return true;
 					} else {
 						return false;
@@ -1075,7 +1024,7 @@ public boolean modifyEvent(String key, Mixed value, BindableEvent event) {
 				}
 
 				if(key.equalsIgnoreCase("max_repair_cost")) {
-					anvil.setMaximumRepairCost(ArgumentValidation.getInt32(value, t));
+					anvil.setMaximumRepairCost(ArgumentValidation.getInt32(value, t, env));
 					return true;
 				}
 			}
@@ -1121,12 +1070,7 @@ public boolean matches(Map<String, Mixed> prefilter, BindableEvent event) throws
 		}
 
 		@Override
-		public BindableEvent convert(CArray manualObject, Target t) {
-			throw ConfigRuntimeException.CreateUncatchableException("Unsupported operation.", Target.UNKNOWN);
-		}
-
-		@Override
-		public Map<String, Mixed> evaluate(BindableEvent event) throws EventException {
+		public Map<String, Mixed> evaluate(BindableEvent event, Environment env) throws EventException {
 			if(event instanceof MCPrepareSmithingEvent e) {
 				MCSmithingInventory smithing = (MCSmithingInventory) e.getInventory();
 				Map<String, Mixed> ret = evaluate_helper(e);
@@ -1152,11 +1096,11 @@ public Driver driver() {
 		}
 
 		@Override
-		public boolean modifyEvent(String key, Mixed value, BindableEvent event) {
+		public boolean modifyEvent(String key, Mixed value, BindableEvent event, Environment env) {
 			if(event instanceof MCPrepareSmithingEvent e) {
 				Target t = value.getTarget();
 				if(key.equalsIgnoreCase("result")) {
-					e.setResult(ObjectGenerator.GetGenerator().item(value, t));
+					e.setResult(ObjectGenerator.GetGenerator().item(value, t, env));
 					return true;
 				}
 			}
@@ -1199,12 +1143,7 @@ public boolean matches(Map<String, Mixed> prefilter, BindableEvent event) throws
 		}
 
 		@Override
-		public BindableEvent convert(CArray manualObject, Target t) {
-			throw ConfigRuntimeException.CreateUncatchableException("Unsupported operation.", Target.UNKNOWN);
-		}
-
-		@Override
-		public Map<String, Mixed> evaluate(BindableEvent event) throws EventException {
+		public Map<String, Mixed> evaluate(BindableEvent event, Environment env) throws EventException {
 			if(event instanceof MCPrepareGrindstoneEvent e) {
 				MCGrindstoneInventory grindstone = (MCGrindstoneInventory) e.getInventory();
 				Map<String, Mixed> ret = evaluate_helper(e);
@@ -1226,11 +1165,11 @@ public Driver driver() {
 		}
 
 		@Override
-		public boolean modifyEvent(String key, Mixed value, BindableEvent event) {
+		public boolean modifyEvent(String key, Mixed value, BindableEvent event, Environment env) {
 			if(event instanceof MCPrepareGrindstoneEvent e) {
 				Target t = value.getTarget();
 				if(key.equalsIgnoreCase("result")) {
-					e.setResult(ObjectGenerator.GetGenerator().item(value, t));
+					e.setResult(ObjectGenerator.GetGenerator().item(value, t, env));
 					return true;
 				}
 			}
diff --git a/src/main/java/com/laytonsmith/core/events/drivers/PlayerEvents.java b/src/main/java/com/laytonsmith/core/events/drivers/PlayerEvents.java
index f813248389..0dca8e6593 100644
--- a/src/main/java/com/laytonsmith/core/events/drivers/PlayerEvents.java
+++ b/src/main/java/com/laytonsmith/core/events/drivers/PlayerEvents.java
@@ -151,12 +151,7 @@ protected String getProperty(MCFoodLevelChangeEvent event) {
 		}
 
 		@Override
-		public BindableEvent convert(CArray manualObject, Target t) {
-			return null;
-		}
-
-		@Override
-		public Map<String, Mixed> evaluate(BindableEvent e) throws EventException {
+		public Map<String, Mixed> evaluate(BindableEvent e, Environment env) throws EventException {
 			if(e instanceof MCFoodLevelChangeEvent) {
 				Map<String, Mixed> ret = evaluate_helper(e);
 				MCFoodLevelChangeEvent event = (MCFoodLevelChangeEvent) e;
@@ -184,12 +179,12 @@ public Driver driver() {
 		}
 
 		@Override
-		public boolean modifyEvent(String key, Mixed value, BindableEvent event) {
+		public boolean modifyEvent(String key, Mixed value, BindableEvent event, Environment env) {
 			if(event instanceof MCFoodLevelChangeEvent) {
 				MCFoodLevelChangeEvent e = (MCFoodLevelChangeEvent) event;
 
 				if(key.equalsIgnoreCase("level")) {
-					e.setFoodLevel(ArgumentValidation.getInt32(value, Target.UNKNOWN));
+					e.setFoodLevel(ArgumentValidation.getInt32(value, Target.UNKNOWN, env));
 					return true;
 				}
 			}
@@ -250,15 +245,14 @@ public void bind(BoundEvent event) {
 		}
 
 		@Override
-		public BindableEvent convert(CArray manualObject, Target t) {
-			MCPlayer p = Static.GetPlayer(manualObject.get("player", Target.UNKNOWN), Target.UNKNOWN);
-			MCItemStack i = ObjectGenerator.GetGenerator().item(manualObject.get("item", Target.UNKNOWN),
-					Target.UNKNOWN);
+		public BindableEvent convert(CArray manualObject, Target t, Environment env) {
+			MCPlayer p = Static.GetPlayer(manualObject.get("player", t, env), t, env);
+			MCItemStack i = ObjectGenerator.GetGenerator().item(manualObject.get("item", t, env), t, env);
 			return EventBuilder.instantiate(MCPlayerItemConsumeEvent.class, p, i);
 		}
 
 		@Override
-		public Map<String, Mixed> evaluate(BindableEvent event) throws EventException {
+		public Map<String, Mixed> evaluate(BindableEvent event, Environment env) throws EventException {
 			if(event instanceof MCPlayerItemConsumeEvent) {
 				MCPlayerItemConsumeEvent e = (MCPlayerItemConsumeEvent) event;
 				Map<String, Mixed> ret = evaluate_helper(e);
@@ -283,11 +277,11 @@ public Driver driver() {
 		}
 
 		@Override
-		public boolean modifyEvent(String key, Mixed value, BindableEvent event) {
+		public boolean modifyEvent(String key, Mixed value, BindableEvent event, Environment env) {
 			if(event instanceof MCPlayerItemConsumeEvent) {
 				MCPlayerItemConsumeEvent e = (MCPlayerItemConsumeEvent) event;
 				if(key.equalsIgnoreCase("item")) {
-					e.setItem(ObjectGenerator.GetGenerator().item(value, Target.UNKNOWN));
+					e.setItem(ObjectGenerator.GetGenerator().item(value, Target.UNKNOWN, env));
 					return true;
 				}
 			}
@@ -332,12 +326,7 @@ protected Object getProperty(MCPlayerKickEvent event) {
 		}
 
 		@Override
-		public BindableEvent convert(CArray manualObject, Target t) {
-			return null;
-		}
-
-		@Override
-		public Map<String, Mixed> evaluate(BindableEvent e) throws EventException {
+		public Map<String, Mixed> evaluate(BindableEvent e, Environment env) throws EventException {
 			if(e instanceof MCPlayerKickEvent) {
 				MCPlayerKickEvent event = (MCPlayerKickEvent) e;
 				Map<String, Mixed> map = evaluate_helper(e);
@@ -357,7 +346,7 @@ public Driver driver() {
 
 		@Override
 		public boolean modifyEvent(String key, Mixed value,
-				BindableEvent event) {
+				BindableEvent event, Environment env) {
 			if(event instanceof MCPlayerKickEvent) {
 				MCPlayerKickEvent e = (MCPlayerKickEvent) event;
 				if(key.equalsIgnoreCase("message")) {
@@ -424,17 +413,17 @@ protected MCLocation getLocation(MCPlayerTeleportEvent event) {
 		}
 
 		@Override
-		public BindableEvent convert(CArray manualObject, Target t) {
-			MCPlayer p = Static.GetPlayer(manualObject.get("player", Target.UNKNOWN), Target.UNKNOWN);
-			MCLocation from = ObjectGenerator.GetGenerator().location(manualObject.get("from", Target.UNKNOWN),
-					p.getWorld(), manualObject.getTarget());
-			MCLocation to = ObjectGenerator.GetGenerator().location(manualObject.get("to", Target.UNKNOWN),
-					p.getWorld(), manualObject.getTarget());
+		public BindableEvent convert(CArray manualObject, Target t, Environment env) {
+			MCPlayer p = Static.GetPlayer(manualObject.get("player", t, env), t, env);
+			MCLocation from = ObjectGenerator.GetGenerator().location(manualObject.get("from", t, env),
+					p.getWorld(), manualObject.getTarget(), env);
+			MCLocation to = ObjectGenerator.GetGenerator().location(manualObject.get("to", t, env),
+					p.getWorld(), manualObject.getTarget(), env);
 			return EventBuilder.instantiate(MCPlayerTeleportEvent.class, p, from, to);
 		}
 
 		@Override
-		public Map<String, Mixed> evaluate(BindableEvent e) throws EventException {
+		public Map<String, Mixed> evaluate(BindableEvent e, Environment env) throws EventException {
 			if(e instanceof MCPlayerTeleportEvent) {
 				MCPlayerTeleportEvent event = (MCPlayerTeleportEvent) e;
 				Map<String, Mixed> map = evaluate_helper(e);
@@ -457,12 +446,12 @@ public Driver driver() {
 		}
 
 		@Override
-		public boolean modifyEvent(String key, Mixed value, BindableEvent event) {
+		public boolean modifyEvent(String key, Mixed value, BindableEvent event, Environment env) {
 			if(event instanceof MCPlayerTeleportEvent) {
 				MCPlayerTeleportEvent e = (MCPlayerTeleportEvent) event;
 
 				if(key.equalsIgnoreCase("to")) {
-					MCLocation loc = ObjectGenerator.GetGenerator().location(value, null, Target.UNKNOWN);
+					MCLocation loc = ObjectGenerator.GetGenerator().location(value, null, Target.UNKNOWN, env);
 					e.setTo(loc);
 
 					return true;
@@ -528,17 +517,17 @@ protected MCLocation getLocation(MCPlayerPortalEvent event) {
 		}
 
 		@Override
-		public BindableEvent convert(CArray manualObject, Target t) {
-			MCPlayer p = Static.GetPlayer(manualObject.get("player", Target.UNKNOWN), Target.UNKNOWN);
-			MCLocation from = ObjectGenerator.GetGenerator().location(manualObject.get("from", Target.UNKNOWN),
-					p.getWorld(), manualObject.getTarget());
-			MCLocation to = ObjectGenerator.GetGenerator().location(manualObject.get("to", Target.UNKNOWN),
-					p.getWorld(), manualObject.getTarget());
+		public BindableEvent convert(CArray manualObject, Target t, Environment env) {
+			MCPlayer p = Static.GetPlayer(manualObject.get("player", t, env), t, env);
+			MCLocation from = ObjectGenerator.GetGenerator().location(manualObject.get("from", t, env),
+					p.getWorld(), manualObject.getTarget(), env);
+			MCLocation to = ObjectGenerator.GetGenerator().location(manualObject.get("to", t, env),
+					p.getWorld(), manualObject.getTarget(), env);
 			return EventBuilder.instantiate(MCPlayerPortalEvent.class, p, from, to);
 		}
 
 		@Override
-		public Map<String, Mixed> evaluate(BindableEvent e) throws EventException {
+		public Map<String, Mixed> evaluate(BindableEvent e, Environment env) throws EventException {
 			if(e instanceof MCPlayerPortalEvent) {
 				MCPlayerPortalEvent event = (MCPlayerPortalEvent) e;
 				Map<String, Mixed> map = evaluate_helper(e);
@@ -565,28 +554,28 @@ public Driver driver() {
 		}
 
 		@Override
-		public boolean modifyEvent(String key, Mixed value, BindableEvent event) {
+		public boolean modifyEvent(String key, Mixed value, BindableEvent event, Environment env) {
 			if(event instanceof MCPlayerPortalEvent) {
 				MCPlayerPortalEvent e = (MCPlayerPortalEvent) event;
 
 				if(key.equalsIgnoreCase("to")) {
-					MCLocation loc = ObjectGenerator.GetGenerator().location(value, null, value.getTarget());
+					MCLocation loc = ObjectGenerator.GetGenerator().location(value, null, value.getTarget(), env);
 					e.setTo(loc);
 					return true;
 				}
 
 				if(key.equalsIgnoreCase("creationallowed")) {
-					e.setCanCreatePortal(ArgumentValidation.getBooleanObject(value, value.getTarget()));
+					e.setCanCreatePortal(ArgumentValidation.getBooleanObject(value, value.getTarget(), env));
 					return true;
 				}
 
 				if(key.equalsIgnoreCase("creationradius")) {
-					e.setCreationRadius(ArgumentValidation.getInt32(value, value.getTarget()));
+					e.setCreationRadius(ArgumentValidation.getInt32(value, value.getTarget(), env));
 					return true;
 				}
 
 				if(key.equalsIgnoreCase("searchradius")) {
-					e.setSearchRadius(ArgumentValidation.getInt32(value, value.getTarget()));
+					e.setSearchRadius(ArgumentValidation.getInt32(value, value.getTarget(), env));
 					return true;
 				}
 			}
@@ -633,12 +622,7 @@ protected PrefilterBuilder getPrefilterBuilder() {
 		}
 
 		@Override
-		public BindableEvent convert(CArray manualObject, Target t) {
-			return null;
-		}
-
-		@Override
-		public Map<String, Mixed> evaluate(BindableEvent e) throws EventException {
+		public Map<String, Mixed> evaluate(BindableEvent e, Environment env) throws EventException {
 			if(e instanceof MCPlayerLoginEvent) {
 				MCPlayerLoginEvent event = (MCPlayerLoginEvent) e;
 				Map<String, Mixed> map = evaluate_helper(e);
@@ -663,7 +647,7 @@ public Driver driver() {
 		}
 
 		@Override
-		public boolean modifyEvent(String key, Mixed value, BindableEvent e) {
+		public boolean modifyEvent(String key, Mixed value, BindableEvent e, Environment env) {
 			if(e instanceof MCPlayerLoginEvent) {
 				MCPlayerLoginEvent event = (MCPlayerLoginEvent) e;
 				if(key.equals("result")) {
@@ -751,7 +735,7 @@ protected String getProperty(MCPlayerJoinEvent event) {
 		}
 
 		@Override
-		public Map<String, Mixed> evaluate(BindableEvent e) throws EventException {
+		public Map<String, Mixed> evaluate(BindableEvent e, Environment env) throws EventException {
 			if(e instanceof MCPlayerJoinEvent) {
 				MCPlayerJoinEvent ple = (MCPlayerJoinEvent) e;
 				Map<String, Mixed> map = evaluate_helper(e);
@@ -765,7 +749,7 @@ public Map<String, Mixed> evaluate(BindableEvent e) throws EventException {
 		}
 
 		@Override
-		public boolean modifyEvent(String key, Mixed value, BindableEvent event) {
+		public boolean modifyEvent(String key, Mixed value, BindableEvent event, Environment env) {
 			if(event instanceof MCPlayerJoinEvent) {
 				MCPlayerJoinEvent pje = (MCPlayerJoinEvent) event;
 				if(key.equals("join_message") || key.equals("message")) {
@@ -782,10 +766,10 @@ public boolean modifyEvent(String key, Mixed value, BindableEvent event) {
 		}
 
 		@Override
-		public BindableEvent convert(CArray manual, Target t) {
+		public BindableEvent convert(CArray manual, Target t, Environment env) {
 			MCPlayerJoinEvent e = EventBuilder.instantiate(MCPlayerJoinEvent.class,
-					Static.GetPlayer(manual.get("player", Target.UNKNOWN).val(), Target.UNKNOWN),
-					manual.get("join_message", Target.UNKNOWN).val());
+					Static.GetPlayer(manual.get("player", t, env).val(), t, env),
+					manual.get("join_message", t, env).val());
 			return e;
 		}
 
@@ -844,7 +828,7 @@ public void bind(BoundEvent event) {
 			}
 			if(prefilter.containsKey("block")) {
 				Mixed ctype = prefilter.get("block");
-				if(ctype.isInstanceOf(CString.TYPE) && ctype.val().contains(":")
+				if(ctype.isInstanceOf(CString.TYPE, null, event.getEnvironment()) && ctype.val().contains(":")
 						|| ArgumentValidation.isNumber(ctype)) {
 					int type;
 					String notation = ctype.val();
@@ -908,7 +892,7 @@ public String getProperty(MCPlayerInteractEvent pie) {
 		}
 
 		@Override
-		public Map<String, Mixed> evaluate(BindableEvent e) throws EventException {
+		public Map<String, Mixed> evaluate(BindableEvent e, Environment env) throws EventException {
 			if(e instanceof MCPlayerInteractEvent) {
 				MCPlayerInteractEvent pie = (MCPlayerInteractEvent) e;
 				Map<String, Mixed> map = evaluate_helper(e);
@@ -944,20 +928,19 @@ public Map<String, Mixed> evaluate(BindableEvent e) throws EventException {
 		}
 
 		@Override
-		public BindableEvent convert(CArray manual, Target t) {
-			MCPlayer p = Static.GetPlayer(manual.get("player", Target.UNKNOWN), Target.UNKNOWN);
-			MCAction a = MCAction.valueOf(manual.get("action", Target.UNKNOWN).val().toUpperCase());
-			MCItemStack is = Static.ParseItemNotation("player_interact event", manual.get("item", Target.UNKNOWN).val(),
-					1, Target.UNKNOWN);
-			MCBlock b = ObjectGenerator.GetGenerator().location(manual.get("location", Target.UNKNOWN), null,
-					Target.UNKNOWN).getBlock();
-			MCBlockFace bf = MCBlockFace.valueOf(manual.get("facing", Target.UNKNOWN).val().toUpperCase());
+		public BindableEvent convert(CArray manual, Target t, Environment env) {
+			MCPlayer p = Static.GetPlayer(manual.get("player", t, env), t, env);
+			MCAction a = MCAction.valueOf(manual.get("action", t, env).val().toUpperCase());
+			MCItemStack is = Static.ParseItemNotation("player_interact event", manual.get("item", t, env).val(),
+					1, t);
+			MCBlock b = ObjectGenerator.GetGenerator().location(manual.get("location", t, env), null, t, env).getBlock();
+			MCBlockFace bf = MCBlockFace.valueOf(manual.get("facing", t, env).val().toUpperCase());
 			MCPlayerInteractEvent e = EventBuilder.instantiate(MCPlayerInteractEvent.class, p, a, is, b, bf);
 			return e;
 		}
 
 		@Override
-		public boolean modifyEvent(String key, Mixed value, BindableEvent event) {
+		public boolean modifyEvent(String key, Mixed value, BindableEvent event, Environment env) {
 			if(event instanceof MCPlayerInteractEvent) {
 				MCPlayerInteractEvent pie = (MCPlayerInteractEvent) event;
 			}
@@ -1012,7 +995,7 @@ protected Enum<MCEnterBedResult> getEnum(MCPlayerEnterBedEvent event) {
 		}
 
 		@Override
-		public Map<String, Mixed> evaluate(BindableEvent e) throws EventException {
+		public Map<String, Mixed> evaluate(BindableEvent e, Environment env) throws EventException {
 			if(e instanceof MCPlayerEnterBedEvent) {
 				MCPlayerEnterBedEvent bee = (MCPlayerEnterBedEvent) e;
 				Map<String, Mixed> map = evaluate_helper(e);
@@ -1030,16 +1013,16 @@ public Driver driver() {
 		}
 
 		@Override
-		public boolean modifyEvent(String key, Mixed value, BindableEvent event) {
+		public boolean modifyEvent(String key, Mixed value, BindableEvent event, Environment env) {
 			return false;
 		}
 
 		@Override
-		public BindableEvent convert(CArray manual, Target t) {
-			MCPlayer p = Static.GetPlayer(manual.get("player", Target.UNKNOWN), Target.UNKNOWN);
-			MCBlock b = ObjectGenerator.GetGenerator().location(manual.get("location", Target.UNKNOWN),
-					null, Target.UNKNOWN).getBlock();
-			MCEnterBedResult r = MCEnterBedResult.valueOf(manual.get("result", Target.UNKNOWN).val());
+		public BindableEvent convert(CArray manual, Target t, Environment env) {
+			MCPlayer p = Static.GetPlayer(manual.get("player", t, env), t, env);
+			MCBlock b = ObjectGenerator.GetGenerator().location(manual.get("location", t, env),
+					null, t, env).getBlock();
+			MCEnterBedResult r = MCEnterBedResult.valueOf(manual.get("result", t, env).val());
 			MCPlayerEnterBedEvent e = EventBuilder.instantiate(MCPlayerEnterBedEvent.class, p, b, r);
 			return e;
 		}
@@ -1081,7 +1064,7 @@ protected MCLocation getLocation(MCPlayerLeaveBedEvent event) {
 		}
 
 		@Override
-		public Map<String, Mixed> evaluate(BindableEvent e) throws EventException {
+		public Map<String, Mixed> evaluate(BindableEvent e, Environment env) throws EventException {
 			if(e instanceof MCPlayerLeaveBedEvent) {
 				MCPlayerLeaveBedEvent bee = (MCPlayerLeaveBedEvent) e;
 				Map<String, Mixed> map = evaluate_helper(e);
@@ -1098,15 +1081,15 @@ public Driver driver() {
 		}
 
 		@Override
-		public boolean modifyEvent(String key, Mixed value, BindableEvent event) {
+		public boolean modifyEvent(String key, Mixed value, BindableEvent event, Environment env) {
 			return false;
 		}
 
 		@Override
-		public BindableEvent convert(CArray manual, Target t) {
-			MCPlayer p = Static.GetPlayer(manual.get("player", Target.UNKNOWN), Target.UNKNOWN);
-			MCBlock b = ObjectGenerator.GetGenerator().location(manual.get("location", Target.UNKNOWN),
-					null, Target.UNKNOWN).getBlock();
+		public BindableEvent convert(CArray manual, Target t, Environment env) {
+			MCPlayer p = Static.GetPlayer(manual.get("player", t, env), t, env);
+			MCBlock b = ObjectGenerator.GetGenerator().location(manual.get("location", t, env),
+					null, t, env).getBlock();
 			MCPlayerEnterBedEvent e = EventBuilder.instantiate(MCPlayerEnterBedEvent.class, p, b);
 			return e;
 		}
@@ -1145,17 +1128,16 @@ protected MCLocation getLocation(MCPlayerInteractEvent event) {
 		}
 
 		@Override
-		public BindableEvent convert(CArray manual, Target t) {
-			MCPlayer p = Static.GetPlayer(manual.get("player", Target.UNKNOWN), Target.UNKNOWN);
-			MCBlock b = ObjectGenerator.GetGenerator().location(manual.get("location", Target.UNKNOWN), null,
-					Target.UNKNOWN).getBlock();
+		public BindableEvent convert(CArray manual, Target t, Environment env) {
+			MCPlayer p = Static.GetPlayer(manual.get("player", t, env), t, env);
+			MCBlock b = ObjectGenerator.GetGenerator().location(manual.get("location", t, env), null, t, env).getBlock();
 			MCPlayerInteractEvent e = EventBuilder.instantiate(MCPlayerInteractEvent.class, p, MCAction.PHYSICAL, null,
 					b, MCBlockFace.UP);
 			return e;
 		}
 
 		@Override
-		public Map<String, Mixed> evaluate(BindableEvent e) throws EventException {
+		public Map<String, Mixed> evaluate(BindableEvent e, Environment env) throws EventException {
 			if(e instanceof MCPlayerInteractEvent) {
 				MCPlayerInteractEvent pie = (MCPlayerInteractEvent) e;
 				Map<String, Mixed> map = evaluate_helper(e);
@@ -1174,7 +1156,7 @@ public Driver driver() {
 		}
 
 		@Override
-		public boolean modifyEvent(String key, Mixed value, BindableEvent event) {
+		public boolean modifyEvent(String key, Mixed value, BindableEvent event, Environment env) {
 			return false;
 		}
 
@@ -1253,7 +1235,7 @@ protected MCLocation getLocation(MCPlayerRespawnEvent event) {
 		}
 
 		@Override
-		public Map<String, Mixed> evaluate(BindableEvent e) throws EventException {
+		public Map<String, Mixed> evaluate(BindableEvent e, Environment env) throws EventException {
 			if(e instanceof MCPlayerRespawnEvent) {
 				MCPlayerRespawnEvent event = (MCPlayerRespawnEvent) e;
 				Map<String, Mixed> map = evaluate_helper(e);
@@ -1272,24 +1254,23 @@ public Map<String, Mixed> evaluate(BindableEvent e) throws EventException {
 		}
 
 		@Override
-		public BindableEvent convert(CArray manual, Target t) {
+		public BindableEvent convert(CArray manual, Target t, Environment env) {
 			//For firing off the event manually, we have to convert the CArray into an
 			//actual object that will trigger it
-			MCPlayer p = Static.GetPlayer(manual.get("player", Target.UNKNOWN), Target.UNKNOWN);
-			MCLocation l = ObjectGenerator.GetGenerator().location(manual.get("location", Target.UNKNOWN), p.getWorld(),
-					Target.UNKNOWN);
+			MCPlayer p = Static.GetPlayer(manual.get("player", t, env), t, env);
+			MCLocation l = ObjectGenerator.GetGenerator().location(manual.get("location", t, env), p.getWorld(), t, env);
 			MCPlayerRespawnEvent e = EventBuilder.instantiate(MCPlayerRespawnEvent.class, p, l, false);
 			return e;
 		}
 
 		@Override
-		public boolean modifyEvent(String key, Mixed value, BindableEvent event) {
+		public boolean modifyEvent(String key, Mixed value, BindableEvent event, Environment env) {
 			if(event instanceof MCPlayerRespawnEvent) {
 				MCPlayerRespawnEvent e = (MCPlayerRespawnEvent) event;
 				if(key.equals("location")) {
 					//Change this parameter in e to value
 					e.setRespawnLocation(ObjectGenerator.GetGenerator().location(value, e.getPlayer().getWorld(),
-							Target.UNKNOWN));
+							Target.UNKNOWN, env));
 					return true;
 				}
 			}
@@ -1349,10 +1330,10 @@ protected Object getProperty(MCPlayerDeathEvent event) {
 		//We have an actual event now, change it into a Map
 		//that will end up being the @event object
 		@Override
-		public Map<String, Mixed> evaluate(BindableEvent e) throws EventException {
+		public Map<String, Mixed> evaluate(BindableEvent e, Environment env) throws EventException {
 			if(e instanceof MCPlayerDeathEvent) {
 				MCPlayerDeathEvent event = (MCPlayerDeathEvent) e;
-				Map<String, Mixed> map = super.evaluate(e);
+				Map<String, Mixed> map = super.evaluate(e, env);
 				map.putAll(evaluate_helper(e));
 				map.put("death_message", new CString(event.getDeathMessage(), Target.UNKNOWN));
 				map.put("keep_inventory", CBoolean.get(event.getKeepInventory()));
@@ -1372,25 +1353,25 @@ public Map<String, Mixed> evaluate(BindableEvent e) throws EventException {
 		}
 
 		@Override
-		public BindableEvent convert(CArray manual, Target t) {
+		public BindableEvent convert(CArray manual, Target t, Environment env) {
 			//For firing off the event manually, we have to convert the CArray into an
 			//actual object that will trigger it
-			String splayer = manual.get("player", Target.UNKNOWN).val();
+			String splayer = manual.get("player", t, env).val();
 			List<MCItemStack> list = new ArrayList<>();
-			String deathMessage = manual.get("death_message", Target.UNKNOWN).val();
-			CArray clist = (CArray) manual.get("drops", Target.UNKNOWN);
+			String deathMessage = manual.get("death_message", t, env).val();
+			CArray clist = (CArray) manual.get("drops", t, env);
 			for(String key : clist.stringKeySet()) {
-				list.add(ObjectGenerator.GetGenerator().item(clist.get(key, Target.UNKNOWN), clist.getTarget()));
+				list.add(ObjectGenerator.GetGenerator().item(clist.get(key, t, env), clist.getTarget(), env));
 			}
 			MCPlayerDeathEvent e = EventBuilder.instantiate(MCPlayerDeathEvent.class, Static.GetPlayer(splayer,
-					Target.UNKNOWN), list,
+					t, env), list,
 					0, deathMessage);
 			return e;
 		}
 
 		//Given the paramters, change the underlying event
 		@Override
-		public boolean modifyEvent(String key, Mixed value, BindableEvent event) {
+		public boolean modifyEvent(String key, Mixed value, BindableEvent event, Environment env) {
 			if(event instanceof MCPlayerDeathEvent) {
 				MCPlayerDeathEvent e = (MCPlayerDeathEvent) event;
 				switch(key) {
@@ -1398,22 +1379,22 @@ public boolean modifyEvent(String key, Mixed value, BindableEvent event) {
 						e.setDeathMessage(Construct.nval(value));
 						return true;
 					case "keep_inventory":
-						e.setKeepInventory(ArgumentValidation.getBoolean(value, Target.UNKNOWN));
+						e.setKeepInventory(ArgumentValidation.getBoolean(value, Target.UNKNOWN, env));
 						return true;
 					case "keep_level":
-						e.setKeepLevel(ArgumentValidation.getBoolean(value, Target.UNKNOWN));
+						e.setKeepLevel(ArgumentValidation.getBoolean(value, Target.UNKNOWN, env));
 						return true;
 					case "new_exp":
-						e.setNewExp(ArgumentValidation.getInt32(value, Target.UNKNOWN));
+						e.setNewExp(ArgumentValidation.getInt32(value, Target.UNKNOWN, env));
 						return true;
 					case "new_level":
-						e.setNewLevel(ArgumentValidation.getInt32(value, Target.UNKNOWN));
+						e.setNewLevel(ArgumentValidation.getInt32(value, Target.UNKNOWN, env));
 						return true;
 					case "new_total_exp":
-						e.setNewTotalExp(ArgumentValidation.getInt32(value, Target.UNKNOWN));
+						e.setNewTotalExp(ArgumentValidation.getInt32(value, Target.UNKNOWN, env));
 						return true;
 					default:
-						return super.modifyEvent(key, value, event);
+						return super.modifyEvent(key, value, event, env);
 				}
 			} else {
 				return false;
@@ -1455,10 +1436,10 @@ protected PrefilterBuilder getPrefilterBuilder() {
 		}
 
 		@Override
-		public BindableEvent convert(CArray manualObject, Target t) {
+		public BindableEvent convert(CArray manualObject, Target t, Environment env) {
 			//Get the parameters from the manualObject
-			MCPlayer player = Static.GetPlayer(manualObject.get("player", Target.UNKNOWN), Target.UNKNOWN);
-			String message = Construct.nval(manualObject.get("message", Target.UNKNOWN));
+			MCPlayer player = Static.GetPlayer(manualObject.get("player", Target.UNKNOWN, env), Target.UNKNOWN, env);
+			String message = Construct.nval(manualObject.get("message", Target.UNKNOWN, env));
 
 			BindableEvent e = EventBuilder.instantiate(MCPlayerCommandEvent.class,
 					player, message);
@@ -1466,7 +1447,7 @@ public BindableEvent convert(CArray manualObject, Target t) {
 		}
 
 		@Override
-		public Map<String, Mixed> evaluate(BindableEvent e) throws EventException {
+		public Map<String, Mixed> evaluate(BindableEvent e, Environment env) throws EventException {
 			if(e instanceof MCPlayerQuitEvent) {
 				MCPlayerQuitEvent event = (MCPlayerQuitEvent) e;
 				Map<String, Mixed> map = evaluate_helper(e);
@@ -1479,7 +1460,7 @@ public Map<String, Mixed> evaluate(BindableEvent e) throws EventException {
 		}
 
 		@Override
-		public boolean modifyEvent(String key, Mixed value, BindableEvent event) {
+		public boolean modifyEvent(String key, Mixed value, BindableEvent event, Environment env) {
 			if(event instanceof MCPlayerQuitEvent) {
 				MCPlayerQuitEvent e = (MCPlayerQuitEvent) event;
 				if("message".equals(key)) {
@@ -1543,11 +1524,11 @@ public boolean matches(String key, Mixed value, MCPlayerChatEvent event, Target
 		}
 
 		@Override
-		public BindableEvent convert(CArray manualObject, Target t) {
+		public BindableEvent convert(CArray manualObject, Target t, Environment env) {
 			//Get the parameters from the manualObject
-			MCPlayer player = Static.GetPlayer(manualObject.get("player", Target.UNKNOWN), Target.UNKNOWN);
-			String message = Construct.nval(manualObject.get("message", Target.UNKNOWN));
-			String format = Construct.nval(manualObject.get("format", Target.UNKNOWN));
+			MCPlayer player = Static.GetPlayer(manualObject.get("player", Target.UNKNOWN, env), Target.UNKNOWN, env);
+			String message = Construct.nval(manualObject.get("message", Target.UNKNOWN, env));
+			String format = Construct.nval(manualObject.get("format", Target.UNKNOWN, env));
 
 			BindableEvent e = EventBuilder.instantiate(MCPlayerChatEvent.class,
 					player, message, format);
@@ -1555,7 +1536,7 @@ public BindableEvent convert(CArray manualObject, Target t) {
 		}
 
 		@Override
-		public Map<String, Mixed> evaluate(BindableEvent e) throws EventException {
+		public Map<String, Mixed> evaluate(BindableEvent e, Environment env) throws EventException {
 			if(e instanceof MCPlayerChatEvent) {
 				MCPlayerChatEvent event = (MCPlayerChatEvent) e;
 				Map<String, Mixed> map = evaluate_helper(e);
@@ -1563,7 +1544,7 @@ public Map<String, Mixed> evaluate(BindableEvent e) throws EventException {
 				map.put("message", new CString(event.getMessage(), Target.UNKNOWN));
 				CArray ca = new CArray(Target.UNKNOWN);
 				for(MCPlayer recipient : event.getRecipients()) {
-					ca.push(new CString(recipient.getName(), Target.UNKNOWN), Target.UNKNOWN);
+					ca.push(new CString(recipient.getName(), Target.UNKNOWN), Target.UNKNOWN, env);
 				}
 				map.put("format", new CString(event.getFormat(), Target.UNKNOWN));
 				map.put("recipients", ca);
@@ -1574,19 +1555,19 @@ public Map<String, Mixed> evaluate(BindableEvent e) throws EventException {
 		}
 
 		@Override
-		public boolean modifyEvent(String key, Mixed value, BindableEvent event) {
+		public boolean modifyEvent(String key, Mixed value, BindableEvent event, Environment env) {
 			if(event instanceof MCPlayerChatEvent) {
 				MCPlayerChatEvent e = (MCPlayerChatEvent) event;
 				if("message".equals(key)) {
 					e.setMessage(Construct.nval(value));
 				}
 				if("recipients".equals(key)) {
-					if(value.isInstanceOf(CArray.TYPE)) {
+					if(value.isInstanceOf(CArray.TYPE, null, env)) {
 						List<MCPlayer> list = new ArrayList<MCPlayer>();
 						for(String index : ((CArray) value).stringKeySet()) {
-							Mixed v = ((CArray) value).get(index, value.getTarget());
+							Mixed v = ((CArray) value).get(index, value.getTarget(), env);
 							try {
-								list.add(Static.GetPlayer(v, value.getTarget()));
+								list.add(Static.GetPlayer(v, value.getTarget(), env));
 							} catch (ConfigRuntimeException ex) {
 								//Ignored
 							}
@@ -1684,10 +1665,10 @@ public boolean matches(String key, Mixed value, MCPlayerChatEvent event, Target
 		}
 
 		@Override
-		public BindableEvent convert(CArray manualObject, Target t) {
+		public BindableEvent convert(CArray manualObject, Target t, Environment env) {
 			//Get the parameters from the manualObject
-			MCPlayer player = Static.GetPlayer(manualObject.get("player", Target.UNKNOWN), Target.UNKNOWN);
-			String message = Construct.nval(manualObject.get("message", Target.UNKNOWN));
+			MCPlayer player = Static.GetPlayer(manualObject.get("player", Target.UNKNOWN, env), Target.UNKNOWN);
+			String message = Construct.nval(manualObject.get("message", Target.UNKNOWN, env));
 
 			BindableEvent e = EventBuilder.instantiate(MCPlayerChatEvent.class,
 					player, message);
@@ -1695,7 +1676,7 @@ public BindableEvent convert(CArray manualObject, Target t) {
 		}
 
 		@Override
-		public Map<String, Mixed> evaluate(BindableEvent e) throws EventException {
+		public Map<String, Mixed> evaluate(BindableEvent e, Environment env) throws EventException {
 			if(e instanceof MCPlayerChatEvent) {
 				MCPlayerChatEvent event = (MCPlayerChatEvent) e;
 				Map<String, Mixed> map = evaluate_helper(e);
@@ -1714,14 +1695,14 @@ public Map<String, Mixed> evaluate(BindableEvent e) throws EventException {
 		}
 
 		@Override
-		public boolean modifyEvent(String key, Mixed value, BindableEvent event) {
+		public boolean modifyEvent(String key, Mixed value, BindableEvent event, Environment env) {
 			if(event instanceof MCPlayerChatEvent) {
 				MCPlayerChatEvent e = (MCPlayerChatEvent) event;
 				if("message".equals(key)) {
 					e.setMessage(Construct.nval(value));
 				}
 				if("recipients".equals(key)) {
-					if(value.isInstanceOf(CArray.TYPE)) {
+					if(value.isInstanceOf(CArray.TYPE, null, env)) {
 						List<MCPlayer> list = new ArrayList<>();
 						for(String index : ((CArray) value).stringKeySet()) {
 							Mixed v = ((CArray) value).get(index, value.getTarget());
@@ -1793,7 +1774,7 @@ public boolean matches(String key, Mixed value, MCPlayerCommandEvent event, Targ
 							String command = event.getCommand();
 							String prefilter = value.val();
 							StringHandling.parse_args pa = new StringHandling.parse_args();
-							CArray ca = (CArray) pa.exec(Target.UNKNOWN, null, new CString(command, Target.UNKNOWN));
+							CArray ca = (CArray) pa.exec(Target.UNKNOWN, null, null, new CString(command, Target.UNKNOWN));
 							if(ca.size() > 0) {
 								if(!ca.get(0, Target.UNKNOWN).val().equals(prefilter)) {
 									return false;
@@ -1814,16 +1795,16 @@ public PrefilterMatcher.PrefilterDocs getDocsObject() {
 		}
 
 		@Override
-		public BindableEvent convert(CArray manualObject, Target t) {
-			MCPlayer player = Static.GetPlayer(manualObject.get("player", Target.UNKNOWN), Target.UNKNOWN);
-			String command = Construct.nval(manualObject.get("command", Target.UNKNOWN));
+		public BindableEvent convert(CArray manualObject, Target t, Environment env) {
+			MCPlayer player = Static.GetPlayer(manualObject.get("player", Target.UNKNOWN, env), Target.UNKNOWN);
+			String command = Construct.nval(manualObject.get("command", Target.UNKNOWN, env));
 
 			BindableEvent e = EventBuilder.instantiate(MCPlayerCommandEvent.class, player, command);
 			return e;
 		}
 
 		@Override
-		public Map<String, Mixed> evaluate(BindableEvent e) throws EventException {
+		public Map<String, Mixed> evaluate(BindableEvent e, Environment env) throws EventException {
 			if(e instanceof MCPlayerCommandEvent) {
 				MCPlayerCommandEvent event = (MCPlayerCommandEvent) e;
 				Map<String, Mixed> map = evaluate_helper(e);
@@ -1831,7 +1812,7 @@ public Map<String, Mixed> evaluate(BindableEvent e) throws EventException {
 				map.put("command", new CString(event.getCommand(), Target.UNKNOWN));
 
 				StringHandling.parse_args pa = new StringHandling.parse_args();
-				CArray ca = (CArray) pa.exec(Target.UNKNOWN, null, new CString(event.getCommand(), Target.UNKNOWN));
+				CArray ca = (CArray) pa.exec(Target.UNKNOWN, null, null, new CString(event.getCommand(), Target.UNKNOWN));
 				map.put("prefix", new CString(ca.get(0, Target.UNKNOWN).val(), Target.UNKNOWN));
 
 				return map;
@@ -1841,7 +1822,7 @@ public Map<String, Mixed> evaluate(BindableEvent e) throws EventException {
 		}
 
 		@Override
-		public boolean modifyEvent(String key, Mixed value, BindableEvent event) {
+		public boolean modifyEvent(String key, Mixed value, BindableEvent event, Environment env) {
 			if(event instanceof MCPlayerCommandEvent) {
 				MCPlayerCommandEvent e = (MCPlayerCommandEvent) event;
 
@@ -1908,9 +1889,9 @@ protected MCWorld getWorld(MCWorldChangedEvent event) {
 		}
 
 		@Override
-		public BindableEvent convert(CArray manualObject, Target t) {
-			MCPlayer player = Static.GetPlayer(manualObject.get("player", Target.UNKNOWN), Target.UNKNOWN);
-			MCWorld from = Static.getServer().getWorld(manualObject.get("from", Target.UNKNOWN).val());
+		public BindableEvent convert(CArray manualObject, Target t, Environment env) {
+			MCPlayer player = Static.GetPlayer(manualObject.get("player", Target.UNKNOWN, env), Target.UNKNOWN);
+			MCWorld from = Static.getServer().getWorld(manualObject.get("from", Target.UNKNOWN, env).val());
 
 			BindableEvent e = EventBuilder.instantiate(MCPlayerCommandEvent.class,
 					player, from);
@@ -1918,7 +1899,7 @@ public BindableEvent convert(CArray manualObject, Target t) {
 		}
 
 		@Override
-		public Map<String, Mixed> evaluate(BindableEvent e) throws EventException {
+		public Map<String, Mixed> evaluate(BindableEvent e, Environment env) throws EventException {
 			if(e instanceof MCWorldChangedEvent) {
 				MCWorldChangedEvent event = (MCWorldChangedEvent) e;
 				Map<String, Mixed> map = evaluate_helper(e);
@@ -1932,7 +1913,7 @@ public Map<String, Mixed> evaluate(BindableEvent e) throws EventException {
 		}
 
 		@Override
-		public boolean modifyEvent(String key, Mixed value, BindableEvent event) {
+		public boolean modifyEvent(String key, Mixed value, BindableEvent event, Environment env) {
 			if(event instanceof MCWorldChangedEvent) {
 				MCWorldChangedEvent e = (MCWorldChangedEvent) event;
 			}
@@ -2045,17 +2026,17 @@ protected MCWorld getWorld(MCPlayerMoveEvent event) {
 		}
 
 		@Override
-		public BindableEvent convert(CArray manualObject, Target t) {
-			MCPlayer p = Static.GetPlayer(manualObject.get("player", Target.UNKNOWN), Target.UNKNOWN);
-			MCLocation from = ObjectGenerator.GetGenerator().location(manualObject.get("from", Target.UNKNOWN),
+		public BindableEvent convert(CArray manualObject, Target t, Environment env) {
+			MCPlayer p = Static.GetPlayer(manualObject.get("player", Target.UNKNOWN, env), Target.UNKNOWN);
+			MCLocation from = ObjectGenerator.GetGenerator().location(manualObject.get("from", Target.UNKNOWN, env),
 					p.getWorld(), manualObject.getTarget());
-			MCLocation to = ObjectGenerator.GetGenerator().location(manualObject.get("to", Target.UNKNOWN),
+			MCLocation to = ObjectGenerator.GetGenerator().location(manualObject.get("to", Target.UNKNOWN, env),
 					p.getWorld(), manualObject.getTarget());
 			return EventBuilder.instantiate(MCPlayerMoveEvent.class, p, from, to);
 		}
 
 		@Override
-		public Map<String, Mixed> evaluate(BindableEvent e) throws EventException {
+		public Map<String, Mixed> evaluate(BindableEvent e, Environment env) throws EventException {
 			if(e instanceof MCPlayerMoveEvent) {
 				MCPlayerMoveEvent event = (MCPlayerMoveEvent) e;
 				Map<String, Mixed> map = new HashMap<>();
@@ -2075,7 +2056,7 @@ public Driver driver() {
 		}
 
 		@Override
-		public boolean modifyEvent(String key, Mixed value, BindableEvent event) {
+		public boolean modifyEvent(String key, Mixed value, BindableEvent event, Environment env) {
 			//Nothing can be modified, so always return false
 			return false;
 		}
@@ -2139,12 +2120,7 @@ public boolean matches(Map<String, Mixed> prefilter, BindableEvent e) throws Pre
 		}
 
 		@Override
-		public BindableEvent convert(CArray manualObject, Target t) {
-			throw ConfigRuntimeException.CreateUncatchableException("Unsupported Operation", Target.UNKNOWN);
-		}
-
-		@Override
-		public Map<String, Mixed> evaluate(BindableEvent e) throws EventException {
+		public Map<String, Mixed> evaluate(BindableEvent e, Environment env) throws EventException {
 			if(e instanceof MCPlayerFishEvent) {
 				MCPlayerFishEvent event = (MCPlayerFishEvent) e;
 				Target t = Target.UNKNOWN;
@@ -2173,7 +2149,7 @@ public Map<String, Mixed> evaluate(BindableEvent e) throws EventException {
 		}
 
 		@Override
-		public boolean modifyEvent(String key, Mixed value, BindableEvent event) {
+		public boolean modifyEvent(String key, Mixed value, BindableEvent event, Environment env) {
 			if(event instanceof MCPlayerFishEvent) {
 				MCPlayerFishEvent e = (MCPlayerFishEvent) event;
 				if(key.equals("xp")) {
@@ -2269,12 +2245,7 @@ protected Enum<MCGameMode> getEnum(MCGamemodeChangeEvent event) {
 		}
 
 		@Override
-		public BindableEvent convert(CArray manualObject, Target t) {
-			throw new CREBindException("Unsupported Operation", Target.UNKNOWN);
-		}
-
-		@Override
-		public Map<String, Mixed> evaluate(BindableEvent event) throws EventException {
+		public Map<String, Mixed> evaluate(BindableEvent event, Environment env) throws EventException {
 			if(event instanceof MCGamemodeChangeEvent) {
 				MCGamemodeChangeEvent e = (MCGamemodeChangeEvent) event;
 				Map<String, Mixed> ret = evaluate_helper(e);
@@ -2291,7 +2262,7 @@ public Driver driver() {
 		}
 
 		@Override
-		public boolean modifyEvent(String key, Mixed value, BindableEvent event) {
+		public boolean modifyEvent(String key, Mixed value, BindableEvent event, Environment env) {
 			return false;
 		}
 
@@ -2325,12 +2296,7 @@ protected PrefilterBuilder getPrefilterBuilder() {
 		}
 
 		@Override
-		public BindableEvent convert(CArray manualObject, Target t) {
-			throw ConfigRuntimeException.CreateUncatchableException("Unsupported Operation", Target.UNKNOWN);
-		}
-
-		@Override
-		public Map<String, Mixed> evaluate(BindableEvent event) throws EventException {
+		public Map<String, Mixed> evaluate(BindableEvent event, Environment env) throws EventException {
 			if(event instanceof MCExpChangeEvent) {
 				MCExpChangeEvent e = (MCExpChangeEvent) event;
 				Map<String, Mixed> ret = evaluate_helper(e);
@@ -2347,7 +2313,7 @@ public Driver driver() {
 		}
 
 		@Override
-		public boolean modifyEvent(String key, Mixed value, BindableEvent event) {
+		public boolean modifyEvent(String key, Mixed value, BindableEvent event, Environment env) {
 			if(event instanceof MCExpChangeEvent) {
 				MCExpChangeEvent e = (MCExpChangeEvent) event;
 				if("amount".equals(key)) {
@@ -2407,12 +2373,7 @@ protected boolean getProperty(MCPlayerEditBookEvent event) {
 		}
 
 		@Override
-		public BindableEvent convert(CArray manualObject, Target t) {
-			return null;
-		}
-
-		@Override
-		public Map<String, Mixed> evaluate(BindableEvent event) throws EventException {
+		public Map<String, Mixed> evaluate(BindableEvent event, Environment env) throws EventException {
 			if(event instanceof MCPlayerEditBookEvent) {
 				MCPlayerEditBookEvent playerEditBookEvent = (MCPlayerEditBookEvent) event;
 				Map<String, Mixed> mapEvent = evaluate_helper(event);
@@ -2469,7 +2430,7 @@ public Map<String, Mixed> evaluate(BindableEvent event) throws EventException {
 		}
 
 		@Override
-		public boolean modifyEvent(String key, Mixed value, BindableEvent event) {
+		public boolean modifyEvent(String key, Mixed value, BindableEvent event, Environment env) {
 			if(event instanceof MCPlayerEditBookEvent) {
 				if(key.equalsIgnoreCase("title")) {
 					MCPlayerEditBookEvent e = ((MCPlayerEditBookEvent) event);
@@ -2558,12 +2519,7 @@ protected Object getProperty(MCPlayerToggleFlightEvent event) {
 		}
 
 		@Override
-		public BindableEvent convert(CArray manualObject, Target t) {
-			return null;
-		}
-
-		@Override
-		public Map<String, Mixed> evaluate(BindableEvent event) throws EventException {
+		public Map<String, Mixed> evaluate(BindableEvent event, Environment env) throws EventException {
 			if(event instanceof MCPlayerToggleFlightEvent) {
 				MCPlayerToggleFlightEvent ptfe = (MCPlayerToggleFlightEvent) event;
 				Map<String, Mixed> mapEvent = evaluate_helper(event);
@@ -2576,7 +2532,7 @@ public Map<String, Mixed> evaluate(BindableEvent event) throws EventException {
 		}
 
 		@Override
-		public boolean modifyEvent(String key, Mixed value, BindableEvent event) {
+		public boolean modifyEvent(String key, Mixed value, BindableEvent event, Environment env) {
 			return false;
 		}
 	}
@@ -2627,14 +2583,8 @@ protected Object getProperty(MCPlayerToggleSneakEvent event) {
 						}
 					});
 		}
-
 		@Override
-		public BindableEvent convert(CArray manualObject, Target t) {
-			return null;
-		}
-
-		@Override
-		public Map<String, Mixed> evaluate(BindableEvent event) throws EventException {
+		public Map<String, Mixed> evaluate(BindableEvent event, Environment env) throws EventException {
 			if(event instanceof MCPlayerToggleSneakEvent) {
 				MCPlayerToggleSneakEvent ptse = (MCPlayerToggleSneakEvent) event;
 				Map<String, Mixed> mapEvent = evaluate_helper(event);
@@ -2647,7 +2597,7 @@ public Map<String, Mixed> evaluate(BindableEvent event) throws EventException {
 		}
 
 		@Override
-		public boolean modifyEvent(String key, Mixed value, BindableEvent event) {
+		public boolean modifyEvent(String key, Mixed value, BindableEvent event, Environment env) {
 			return false;
 		}
 	}
@@ -2700,12 +2650,7 @@ protected Object getProperty(MCPlayerToggleSprintEvent event) {
 		}
 
 		@Override
-		public BindableEvent convert(CArray manualObject, Target t) {
-			return null;
-		}
-
-		@Override
-		public Map<String, Mixed> evaluate(BindableEvent event) throws EventException {
+		public Map<String, Mixed> evaluate(BindableEvent event, Environment env) throws EventException {
 			if(event instanceof MCPlayerToggleSprintEvent) {
 				MCPlayerToggleSprintEvent ptse = (MCPlayerToggleSprintEvent) event;
 				Map<String, Mixed> mapEvent = evaluate_helper(event);
@@ -2718,7 +2663,7 @@ public Map<String, Mixed> evaluate(BindableEvent event) throws EventException {
 		}
 
 		@Override
-		public boolean modifyEvent(String key, Mixed value, BindableEvent event) {
+		public boolean modifyEvent(String key, Mixed value, BindableEvent event, Environment env) {
 			return false;
 		}
 	}
@@ -2764,7 +2709,7 @@ protected Enum<MCResourcePackStatus> getEnum(MCPlayerResourcePackEvent event) {
 		}
 
 		@Override
-		public Map<String, Mixed> evaluate(BindableEvent event) throws EventException {
+		public Map<String, Mixed> evaluate(BindableEvent event, Environment env) throws EventException {
 			Map<String, Mixed> map = evaluate_helper(event);
 			map.put("status", new CString(((MCPlayerResourcePackEvent) event).getStatus().name(), Target.UNKNOWN));
 			if(Static.getServer().getMinecraftVersion().gte(MCVersion.MC1_20_4)) {
@@ -2774,7 +2719,7 @@ public Map<String, Mixed> evaluate(BindableEvent event) throws EventException {
 		}
 
 		@Override
-		public boolean modifyEvent(String key, Mixed value, BindableEvent event) {
+		public boolean modifyEvent(String key, Mixed value, BindableEvent event, Environment env) {
 			return false;
 		}
 
@@ -2782,11 +2727,6 @@ public boolean modifyEvent(String key, Mixed value, BindableEvent event) {
 		public MSVersion since() {
 			return MSVersion.V3_3_4;
 		}
-
-		@Override
-		public BindableEvent convert(CArray manualObject, Target t) {
-			return null;
-		}
 	}
 
 	public abstract static class player_bucket_event extends AbstractEvent {
@@ -2800,17 +2740,12 @@ public boolean matches(Map<String, Mixed> prefilter, BindableEvent e) throws Pre
 		}
 
 		@Override
-		public BindableEvent convert(CArray manualObject, Target t) {
-			throw ConfigRuntimeException.CreateUncatchableException("Unsupported operation.", Target.UNKNOWN);
-		}
-
-		@Override
-		public boolean modifyEvent(String key, Mixed value, BindableEvent e) {
+		public boolean modifyEvent(String key, Mixed value, BindableEvent e, Environment env) {
 			return false;
 		}
 
 		@Override
-		public Map<String, Mixed> evaluate(BindableEvent event) throws EventException {
+		public Map<String, Mixed> evaluate(BindableEvent event, Environment env) throws EventException {
 			if(event instanceof MCPlayerBucketEvent e) {
 				Map<String, Mixed> ret = evaluate_helper(e);
 				Target t = Target.UNKNOWN;
@@ -2933,7 +2868,7 @@ protected String getProperty(MCPlayerAdvancementDoneEvent event) {
 		}
 
 		@Override
-		public Map<String, Mixed> evaluate(BindableEvent event) throws EventException {
+		public Map<String, Mixed> evaluate(BindableEvent event, Environment env) throws EventException {
 			if(event instanceof MCPlayerAdvancementDoneEvent e) {
 				Map<String, Mixed> map = new HashMap<>();
 				map.put("player", new CString(e.getPlayer().getName(), Target.UNKNOWN));
@@ -2946,7 +2881,7 @@ public Map<String, Mixed> evaluate(BindableEvent event) throws EventException {
 		}
 
 		@Override
-		public boolean modifyEvent(String key, Mixed value, BindableEvent event) {
+		public boolean modifyEvent(String key, Mixed value, BindableEvent event, Environment env) {
 			return false;
 		}
 
@@ -2954,11 +2889,6 @@ public boolean modifyEvent(String key, Mixed value, BindableEvent event) {
 		public MSVersion since() {
 			return MSVersion.V3_3_5;
 		}
-
-		@Override
-		public BindableEvent convert(CArray manualObject, Target t) {
-			return null;
-		}
 	}
 
 	@api
@@ -2999,7 +2929,7 @@ protected MCItemStack getItemStack(MCPlayerStopUsingItemEvent event) {
 		}
 
 		@Override
-		public Map<String, Mixed> evaluate(BindableEvent event) throws EventException {
+		public Map<String, Mixed> evaluate(BindableEvent event, Environment env) throws EventException {
 			if(event instanceof MCPlayerStopUsingItemEvent e) {
 				Map<String, Mixed> map = new HashMap<>();
 				map.put("player", new CString(e.getPlayer().getName(), Target.UNKNOWN));
@@ -3012,7 +2942,7 @@ public Map<String, Mixed> evaluate(BindableEvent event) throws EventException {
 		}
 
 		@Override
-		public boolean modifyEvent(String key, Mixed value, BindableEvent event) {
+		public boolean modifyEvent(String key, Mixed value, BindableEvent event, Environment env) {
 			return false;
 		}
 
@@ -3020,10 +2950,5 @@ public boolean modifyEvent(String key, Mixed value, BindableEvent event) {
 		public MSVersion since() {
 			return MSVersion.V3_3_5;
 		}
-
-		@Override
-		public BindableEvent convert(CArray manualObject, Target t) {
-			return null;
-		}
 	}
 }
diff --git a/src/main/java/com/laytonsmith/core/events/drivers/PluginEvents.java b/src/main/java/com/laytonsmith/core/events/drivers/PluginEvents.java
index f6e06d9a15..39ee6219a0 100644
--- a/src/main/java/com/laytonsmith/core/events/drivers/PluginEvents.java
+++ b/src/main/java/com/laytonsmith/core/events/drivers/PluginEvents.java
@@ -3,13 +3,13 @@
 import com.laytonsmith.abstraction.events.MCPluginIncomingMessageEvent;
 import com.laytonsmith.annotations.api;
 import com.laytonsmith.core.MSVersion;
-import com.laytonsmith.core.constructs.CArray;
 import com.laytonsmith.core.constructs.CByteArray;
 import com.laytonsmith.core.constructs.CString;
 import com.laytonsmith.core.constructs.Target;
 import com.laytonsmith.core.events.AbstractEvent;
 import com.laytonsmith.core.events.BindableEvent;
 import com.laytonsmith.core.events.Driver;
+import com.laytonsmith.core.environments.Environment;
 import com.laytonsmith.core.events.Prefilters;
 import com.laytonsmith.core.exceptions.EventException;
 import com.laytonsmith.core.exceptions.PrefilterNonMatchException;
@@ -62,12 +62,7 @@ public boolean matches(Map<String, Mixed> prefilter, BindableEvent e) throws Pre
 		}
 
 		@Override
-		public BindableEvent convert(CArray manualObject, Target t) {
-			return null;
-		}
-
-		@Override
-		public Map<String, Mixed> evaluate(BindableEvent e) throws EventException {
+		public Map<String, Mixed> evaluate(BindableEvent e, Environment env) throws EventException {
 			if(e instanceof MCPluginIncomingMessageEvent) {
 				MCPluginIncomingMessageEvent event = (MCPluginIncomingMessageEvent) e;
 				Map<String, Mixed> ret = evaluate_helper(e);
@@ -94,7 +89,7 @@ public Driver driver() {
 		}
 
 		@Override
-		public boolean modifyEvent(String key, Mixed value, BindableEvent event) {
+		public boolean modifyEvent(String key, Mixed value, BindableEvent event, Environment env) {
 			return false;
 		}
 
diff --git a/src/main/java/com/laytonsmith/core/events/drivers/ServerEvents.java b/src/main/java/com/laytonsmith/core/events/drivers/ServerEvents.java
index e5c2418f19..e43979cb26 100644
--- a/src/main/java/com/laytonsmith/core/events/drivers/ServerEvents.java
+++ b/src/main/java/com/laytonsmith/core/events/drivers/ServerEvents.java
@@ -33,7 +33,6 @@
 import com.laytonsmith.core.events.EventBuilder;
 import com.laytonsmith.core.events.Prefilters;
 import com.laytonsmith.core.events.Prefilters.PrefilterType;
-import com.laytonsmith.core.exceptions.ConfigRuntimeException;
 import com.laytonsmith.core.exceptions.EventException;
 import com.laytonsmith.core.exceptions.PrefilterNonMatchException;
 import com.laytonsmith.core.exceptions.CRE.CRECastException;
@@ -99,12 +98,7 @@ public boolean matches(Map<String, Mixed> prefilter, BindableEvent e) throws Pre
 		}
 
 		@Override
-		public BindableEvent convert(CArray manualObject, Target t) {
-			throw new UnsupportedOperationException("Not supported yet.");
-		}
-
-		@Override
-		public Map<String, Mixed> evaluate(BindableEvent e) throws EventException {
+		public Map<String, Mixed> evaluate(BindableEvent e, Environment env) throws EventException {
 			if(!(e instanceof MCServerCommandEvent)) {
 				throw new EventException("Cannot convert e to MCServerCommandEvent");
 			}
@@ -134,7 +128,7 @@ private static String getCommandsenderString(MCCommandSender sender) {
 		}
 
 		@Override
-		public boolean modifyEvent(String key, Mixed value, BindableEvent event) {
+		public boolean modifyEvent(String key, Mixed value, BindableEvent event, Environment env) {
 			if(event instanceof MCServerCommandEvent) {
 				MCServerCommandEvent e = (MCServerCommandEvent) event;
 				if(key.equals("command")) {
@@ -186,12 +180,7 @@ public boolean matches(Map<String, Mixed> prefilter, BindableEvent e) throws Pre
 		}
 
 		@Override
-		public BindableEvent convert(CArray manualObject, Target t) {
-			throw ConfigRuntimeException.CreateUncatchableException("Unsupported Operation", Target.UNKNOWN);
-		}
-
-		@Override
-		public Map<String, Mixed> evaluate(BindableEvent e) throws EventException {
+		public Map<String, Mixed> evaluate(BindableEvent e, Environment env) throws EventException {
 			if(e instanceof MCServerPingEvent) {
 				MCServerPingEvent event = (MCServerPingEvent) e;
 				Target t = Target.UNKNOWN;
@@ -208,7 +197,7 @@ public Map<String, Mixed> evaluate(BindableEvent e) throws EventException {
 				ret.put("maxplayers", new CInt(event.getMaxPlayers(), t));
 				CArray players = new CArray(t);
 				for(MCPlayer player : event.getPlayers()) {
-					players.push(new CString(player.getName(), t), t);
+					players.push(new CString(player.getName(), t), t, env);
 				}
 				ret.put("list", players);
 				return ret;
@@ -218,7 +207,7 @@ public Map<String, Mixed> evaluate(BindableEvent e) throws EventException {
 		}
 
 		@Override
-		public boolean modifyEvent(String key, Mixed value, BindableEvent event) {
+		public boolean modifyEvent(String key, Mixed value, BindableEvent event, Environment env) {
 			if(event instanceof MCServerPingEvent) {
 				MCServerPingEvent e = (MCServerPingEvent) event;
 				switch(key.toLowerCase()) {
@@ -226,13 +215,13 @@ public boolean modifyEvent(String key, Mixed value, BindableEvent event) {
 						e.setMOTD(value.val());
 						return true;
 					case "maxplayers":
-						e.setMaxPlayers(ArgumentValidation.getInt32(value, value.getTarget()));
+						e.setMaxPlayers(ArgumentValidation.getInt32(value, value.getTarget(), env));
 						return true;
 					case "list":
 						// Modifies the player list. The new list will be the intersection of the original
 						// and the given list. Names and UUID's outside this intersection will simply be ignored.
 						Set<MCPlayer> modifiedPlayers = new HashSet<>();
-						List<Mixed> passedList = ArgumentValidation.getArray(value, value.getTarget()).asList();
+						List<Mixed> passedList = ArgumentValidation.getArray(value, value.getTarget(), env).asList(env);
 						for(MCPlayer player : e.getPlayers()) {
 							for(Mixed construct : passedList) {
 								String playerStr = construct.val();
@@ -294,12 +283,7 @@ public boolean matches(Map<String, Mixed> prefilter, BindableEvent event) throws
 		}
 
 		@Override
-		public BindableEvent convert(CArray manualObject, Target t) {
-			throw ConfigRuntimeException.CreateUncatchableException("Unsupported Operation", Target.UNKNOWN);
-		}
-
-		@Override
-		public Map<String, Mixed> evaluate(BindableEvent event) throws EventException {
+		public Map<String, Mixed> evaluate(BindableEvent event, Environment env) throws EventException {
 			if(event instanceof MCCommandTabCompleteEvent) {
 				MCCommandTabCompleteEvent e = (MCCommandTabCompleteEvent) event;
 				Target t = Target.UNKNOWN;
@@ -308,14 +292,14 @@ public Map<String, Mixed> evaluate(BindableEvent event) throws EventException {
 				CArray comp = new CArray(t);
 				if(e.getCompletions() != null) {
 					for(String c : e.getCompletions()) {
-						comp.push(new CString(c, t), t);
+						comp.push(new CString(c, t), t, env);
 					}
 				}
 				ret.put("completions", comp);
 				ret.put("command", new CString(e.getCommand().getName(), t));
 				CArray args = new CArray(t);
 				for(String a : e.getArguments()) {
-					args.push(new CString(a, t), t);
+					args.push(new CString(a, t), t, env);
 				}
 				ret.put("args", args);
 				ret.put("alias", new CString(e.getAlias(), t));
@@ -331,18 +315,18 @@ public Driver driver() {
 		}
 
 		@Override
-		public boolean modifyEvent(String key, Mixed value, BindableEvent event) {
+		public boolean modifyEvent(String key, Mixed value, BindableEvent event, Environment env) {
 			if(event instanceof MCCommandTabCompleteEvent) {
 				MCCommandTabCompleteEvent e = (MCCommandTabCompleteEvent) event;
 				if("completions".equals(key)) {
-					if(value.isInstanceOf(CArray.TYPE)) {
+					if(value.isInstanceOf(CArray.TYPE, null, env)) {
 						List<String> comp = new ArrayList<>();
 						if(((CArray) value).inAssociativeMode()) {
-							for(Mixed k : ((CArray) value).keySet()) {
-								comp.add(((CArray) value).get(k, value.getTarget()).val());
+							for(Mixed k : ((CArray) value).keySet(env)) {
+								comp.add(((CArray) value).get(k, value.getTarget(), env).val());
 							}
 						} else {
-							for(Mixed v : ((CArray) value).asList()) {
+							for(Mixed v : ((CArray) value).asList(env)) {
 								comp.add(v.val());
 							}
 						}
@@ -406,12 +390,7 @@ public boolean matches(Map<String, com.laytonsmith.core.natives.interfaces.Mixed
 		}
 
 		@Override
-		public BindableEvent convert(CArray manualObject, Target t) {
-			throw new UnsupportedOperationException("Not supported yet.");
-		}
-
-		@Override
-		public Map<String, Mixed> evaluate(BindableEvent e) throws EventException {
+		public Map<String, Mixed> evaluate(BindableEvent e, Environment env) throws EventException {
 			MCRedstoneChangedEvent event = (MCRedstoneChangedEvent) e;
 			Map<String, Mixed> map = evaluate_helper(e);
 			map.put("location", ObjectGenerator.GetGenerator().location(event.getLocation(), false));
@@ -425,7 +404,7 @@ public Driver driver() {
 		}
 
 		@Override
-		public boolean modifyEvent(String key, Mixed value, BindableEvent event) {
+		public boolean modifyEvent(String key, Mixed value, BindableEvent event, Environment env) {
 			return false;
 		}
 
@@ -465,26 +444,24 @@ public boolean matches(Map<String, Mixed> prefilter, BindableEvent e) throws Pre
 		}
 
 		@Override
-		public BindableEvent convert(CArray manualObject, Target t) {
+		public BindableEvent convert(CArray manualObject, Target t, Environment env) {
 
 			// Get the player recipients.
-			Mixed cRecipients = manualObject.get("player_recipients", t);
+			Mixed cRecipients = manualObject.get("player_recipients", t, env);
 			if(!(cRecipients instanceof CArray) && !(cRecipients instanceof CNull)) {
-				throw new CRECastException("Expected player_recipients to be an array, but received: "
-						+ cRecipients.typeof().toString(), t);
+				throw new CRECastException("Expected player_recipients to be an array", t);
 			}
 			Set<MCCommandSender> recipients = new HashSet<>();
 			CArray recipientsArray = (CArray) cRecipients;
-			for(int i = 0; i < recipientsArray.size(); i++) {
-				MCPlayer player = Static.GetPlayer(recipientsArray.get(i, t), t);
+			for(int i = 0; i < recipientsArray.size(env); i++) {
+				MCPlayer player = Static.GetPlayer(recipientsArray.get(i, t, env), t, env);
 				recipients.add(player);
 			}
 
 			// Get the message.
-			Mixed cMessage = manualObject.get("message", t);
+			Mixed cMessage = manualObject.get("message", t, env);
 			if(!(cMessage instanceof CString)) {
-				throw new CRECastException("Expected message to be a string, but received: "
-						+ cMessage.typeof().toString(), t);
+				throw new CRECastException("Expected message to be a string.", t);
 			}
 
 			// Instantiate and return the event.
@@ -493,13 +470,13 @@ public BindableEvent convert(CArray manualObject, Target t) {
 		}
 
 		@Override
-		public Map<String, Mixed> evaluate(BindableEvent e) throws EventException {
+		public Map<String, Mixed> evaluate(BindableEvent e, Environment env) throws EventException {
 			MCBroadcastMessageEvent event = (MCBroadcastMessageEvent) e;
 			Map<String, Mixed> map = evaluate_helper(e);
 			map.put("message", new CString(event.getMessage(), Target.UNKNOWN));
 			CArray cRecipients = new CArray(Target.UNKNOWN);
 			for(MCPlayer player : event.getPlayerRecipients()) {
-				cRecipients.push(new CString(player.getName(), Target.UNKNOWN), Target.UNKNOWN);
+				cRecipients.push(new CString(player.getName(), Target.UNKNOWN), Target.UNKNOWN, env);
 			}
 			map.put("player_recipients", cRecipients);
 			return map;
@@ -511,7 +488,7 @@ public Driver driver() {
 		}
 
 		@Override
-		public boolean modifyEvent(String key, Mixed value, BindableEvent e) {
+		public boolean modifyEvent(String key, Mixed value, BindableEvent e, Environment env) {
 			if(key.equals("message")) {
 				MCBroadcastMessageEvent event = (MCBroadcastMessageEvent) e;
 				event.setMessage(Construct.nval(value));
diff --git a/src/main/java/com/laytonsmith/core/events/drivers/VehicleEvents.java b/src/main/java/com/laytonsmith/core/events/drivers/VehicleEvents.java
index a975390fd4..e7b2855aaf 100644
--- a/src/main/java/com/laytonsmith/core/events/drivers/VehicleEvents.java
+++ b/src/main/java/com/laytonsmith/core/events/drivers/VehicleEvents.java
@@ -29,6 +29,7 @@
 import com.laytonsmith.core.constructs.CNull;
 import com.laytonsmith.core.constructs.CString;
 import com.laytonsmith.core.constructs.Target;
+import com.laytonsmith.core.environments.Environment;
 import com.laytonsmith.core.events.AbstractEvent;
 import com.laytonsmith.core.events.BindableEvent;
 import com.laytonsmith.core.events.BoundEvent;
@@ -86,12 +87,7 @@ public boolean matches(Map<String, Mixed> prefilter, BindableEvent event) throws
 		}
 
 		@Override
-		public BindableEvent convert(CArray manualObject, Target t) {
-			throw ConfigRuntimeException.CreateUncatchableException("Unsupported Operation", Target.UNKNOWN);
-		}
-
-		@Override
-		public Map<String, Mixed> evaluate(BindableEvent event) throws EventException {
+		public Map<String, Mixed> evaluate(BindableEvent event, Environment env) throws EventException {
 			if(event instanceof MCVehicleEnterExitEvent) {
 				MCVehicleEnterExitEvent e = (MCVehicleEnterExitEvent) event;
 				Target t = Target.UNKNOWN;
@@ -117,7 +113,7 @@ public Driver driver() {
 		}
 
 		@Override
-		public boolean modifyEvent(String key, Mixed value, BindableEvent event) {
+		public boolean modifyEvent(String key, Mixed value, BindableEvent event, Environment env) {
 			return false;
 		}
 
@@ -157,12 +153,7 @@ public boolean matches(Map<String, Mixed> prefilter, BindableEvent event) throws
 		}
 
 		@Override
-		public BindableEvent convert(CArray manualObject, Target t) {
-			throw ConfigRuntimeException.CreateUncatchableException("Unsupported Operation", Target.UNKNOWN);
-		}
-
-		@Override
-		public Map<String, Mixed> evaluate(BindableEvent event) throws EventException {
+		public Map<String, Mixed> evaluate(BindableEvent event, Environment env) throws EventException {
 			if(event instanceof MCVehicleEnterExitEvent) {
 				MCVehicleEnterExitEvent e = (MCVehicleEnterExitEvent) event;
 				Target t = Target.UNKNOWN;
@@ -188,7 +179,7 @@ public Driver driver() {
 		}
 
 		@Override
-		public boolean modifyEvent(String key, Mixed value, BindableEvent event) {
+		public boolean modifyEvent(String key, Mixed value, BindableEvent event, Environment env) {
 			return false;
 		}
 
@@ -229,7 +220,7 @@ public void bind(BoundEvent event) {
 			Map<String, Mixed> prefilter = event.getPrefilter();
 			if(prefilter.containsKey("hittype")) {
 				Mixed type = prefilter.get("hittype");
-				if(type.isInstanceOf(CString.TYPE) && type.val().contains(":") || ArgumentValidation.isNumber(type)) {
+				if(type.isInstanceOf(CString.TYPE, null, event.getEnvironment()) && type.val().contains(":") || ArgumentValidation.isNumber(type)) {
 					MSLog.GetLogger().w(MSLog.Tags.DEPRECATION, "The 0:0 block format in " + getName()
 							+ " is deprecated in \"hittype\".", event.getTarget());
 					MCItemStack is = Static.ParseItemNotation(null, type.val(), 1, event.getTarget());
@@ -272,14 +263,8 @@ public boolean matches(Map<String, Mixed> prefilter, BindableEvent e) throws Pre
 			}
 			return false;
 		}
-
 		@Override
-		public BindableEvent convert(CArray manualObject, Target t) {
-			throw ConfigRuntimeException.CreateUncatchableException("Unsupported Operation", Target.UNKNOWN);
-		}
-
-		@Override
-		public Map<String, Mixed> evaluate(BindableEvent event) throws EventException {
+		public Map<String, Mixed> evaluate(BindableEvent event, Environment env) throws EventException {
 			if(event instanceof MCVehicleCollideEvent) {
 				MCVehicleCollideEvent e = (MCVehicleCollideEvent) event;
 				Target t = Target.UNKNOWN;
@@ -323,15 +308,15 @@ public Driver driver() {
 		}
 
 		@Override
-		public boolean modifyEvent(String key, Mixed value, BindableEvent event) {
+		public boolean modifyEvent(String key, Mixed value, BindableEvent event, Environment env) {
 			if(event instanceof MCVehicleEntityCollideEvent) {
 				MCVehicleEntityCollideEvent e = (MCVehicleEntityCollideEvent) event;
 				if(key.equals("collide")) {
-					e.setCollisionCancelled(!ArgumentValidation.getBoolean(value, Target.UNKNOWN));
+					e.setCollisionCancelled(!ArgumentValidation.getBoolean(value, Target.UNKNOWN, env));
 					return true;
 				}
 				if(key.equals("pickup")) {
-					e.setPickupCancelled(!ArgumentValidation.getBoolean(value, Target.UNKNOWN));
+					e.setPickupCancelled(!ArgumentValidation.getBoolean(value, Target.UNKNOWN, env));
 					return true;
 				}
 			}
@@ -482,20 +467,22 @@ public boolean matches(Map<String, Mixed> prefilter, BindableEvent e) throws Pre
 		}
 
 		@Override
-		public BindableEvent convert(CArray manualObject, Target t) {
+		public BindableEvent convert(CArray manualObject, Target t, Environment env) {
 
-			MCEntity e = Static.getEntity(manualObject.get("id", Target.UNKNOWN), Target.UNKNOWN);
+			MCEntity e = Static.getEntity(manualObject.get("id", t, env), t);
 			if(!(e instanceof MCVehicle)) {
-				throw new CREBadEntityException("The id was not a vehicle", Target.UNKNOWN);
+				throw new CREBadEntityException("The id was not a vehicle", t);
 			}
 
-			MCLocation from = ObjectGenerator.GetGenerator().location(manualObject.get("from", Target.UNKNOWN), e.getWorld(), manualObject.getTarget());
-			MCLocation to = ObjectGenerator.GetGenerator().location(manualObject.get("to", Target.UNKNOWN), e.getWorld(), manualObject.getTarget());
+			MCLocation from = ObjectGenerator.GetGenerator().location(manualObject.get("from", t, env),
+					e.getWorld(), manualObject.getTarget());
+			MCLocation to = ObjectGenerator.GetGenerator().location(manualObject.get("to", t, env),
+					e.getWorld(), manualObject.getTarget());
 			return EventBuilder.instantiate(MCVehicleMoveEvent.class, e, from, to);
 		}
 
 		@Override
-		public Map<String, Mixed> evaluate(BindableEvent event) throws EventException {
+		public Map<String, Mixed> evaluate(BindableEvent event, Environment env) throws EventException {
 			if(event instanceof MCVehicleMoveEvent) {
 				MCVehicleMoveEvent e = (MCVehicleMoveEvent) event;
 				Target t = Target.UNKNOWN;
@@ -538,7 +525,7 @@ public Driver driver() {
 		}
 
 		@Override
-		public boolean modifyEvent(String key, Mixed value, BindableEvent event) {
+		public boolean modifyEvent(String key, Mixed value, BindableEvent event, Environment env) {
 			//Nothing can be modified, so always return false
 			return false;
 		}
@@ -581,12 +568,7 @@ public boolean matches(Map<String, Mixed> prefilter, BindableEvent event) throws
 		}
 
 		@Override
-		public BindableEvent convert(CArray manualObject, Target t) {
-			throw ConfigRuntimeException.CreateUncatchableException("Unsupported Operation", Target.UNKNOWN);
-		}
-
-		@Override
-		public Map<String, Mixed> evaluate(BindableEvent event) throws EventException {
+		public Map<String, Mixed> evaluate(BindableEvent event, Environment env) throws EventException {
 			if(event instanceof MCVehicleDestroyEvent) {
 				MCVehicleDestroyEvent e = (MCVehicleDestroyEvent) event;
 				Target t = Target.UNKNOWN;
@@ -622,7 +604,7 @@ public Driver driver() {
 		}
 
 		@Override
-		public boolean modifyEvent(String key, Mixed value, BindableEvent event) {
+		public boolean modifyEvent(String key, Mixed value, BindableEvent event, Environment env) {
 			return false;
 		}
 
diff --git a/src/main/java/com/laytonsmith/core/events/drivers/WeatherEvents.java b/src/main/java/com/laytonsmith/core/events/drivers/WeatherEvents.java
index f260067c3b..dfb22ced06 100644
--- a/src/main/java/com/laytonsmith/core/events/drivers/WeatherEvents.java
+++ b/src/main/java/com/laytonsmith/core/events/drivers/WeatherEvents.java
@@ -9,7 +9,6 @@
 import com.laytonsmith.core.MSVersion;
 import com.laytonsmith.core.ObjectGenerator;
 import com.laytonsmith.core.Static;
-import com.laytonsmith.core.constructs.CArray;
 import com.laytonsmith.core.constructs.CBoolean;
 import com.laytonsmith.core.constructs.CString;
 import com.laytonsmith.core.constructs.Target;
@@ -64,12 +63,7 @@ public boolean matches(Map<String, Mixed> prefilter, BindableEvent event) throws
 		}
 
 		@Override
-		public BindableEvent convert(CArray manualObject, Target t) {
-			return null;
-		}
-
-		@Override
-		public Map<String, Mixed> evaluate(BindableEvent event) throws EventException {
+		public Map<String, Mixed> evaluate(BindableEvent event, Environment env) throws EventException {
 			if(event instanceof MCLightningStrikeEvent) {
 				MCLightningStrikeEvent e = (MCLightningStrikeEvent) event;
 				Target t = Target.UNKNOWN;
@@ -91,7 +85,7 @@ public Driver driver() {
 		}
 
 		@Override
-		public boolean modifyEvent(String key, Mixed value, BindableEvent event) {
+		public boolean modifyEvent(String key, Mixed value, BindableEvent event, Environment env) {
 			return false;
 		}
 
@@ -149,12 +143,7 @@ public boolean matches(Map<String, Mixed> prefilter, BindableEvent event) throws
 		}
 
 		@Override
-		public BindableEvent convert(CArray manualObject, Target t) {
-			return null;
-		}
-
-		@Override
-		public Map<String, Mixed> evaluate(BindableEvent event) throws EventException {
+		public Map<String, Mixed> evaluate(BindableEvent event, Environment env) throws EventException {
 			if(event instanceof MCThunderChangeEvent) {
 				MCThunderChangeEvent e = (MCThunderChangeEvent) event;
 				Target t = Target.UNKNOWN;
@@ -173,7 +162,7 @@ public Driver driver() {
 		}
 
 		@Override
-		public boolean modifyEvent(String key, Mixed value, BindableEvent event) {
+		public boolean modifyEvent(String key, Mixed value, BindableEvent event, Environment env) {
 			return false;
 		}
 
@@ -212,13 +201,9 @@ public boolean matches(Map<String, Mixed> prefilter, BindableEvent event) throws
 			return false;
 		}
 
-		@Override
-		public BindableEvent convert(CArray manualObject, Target t) {
-			return null;
-		}
 
 		@Override
-		public Map<String, Mixed> evaluate(BindableEvent event) throws EventException {
+		public Map<String, Mixed> evaluate(BindableEvent event, Environment env) throws EventException {
 			if(event instanceof MCWeatherChangeEvent) {
 				MCWeatherChangeEvent e = (MCWeatherChangeEvent) event;
 				Target t = Target.UNKNOWN;
@@ -237,7 +222,7 @@ public Driver driver() {
 		}
 
 		@Override
-		public boolean modifyEvent(String key, Mixed value, BindableEvent event) {
+		public boolean modifyEvent(String key, Mixed value, BindableEvent event, Environment env) {
 			return false;
 		}
 
diff --git a/src/main/java/com/laytonsmith/core/events/drivers/WorldEvents.java b/src/main/java/com/laytonsmith/core/events/drivers/WorldEvents.java
index b8544dbc8c..52c6af5c12 100644
--- a/src/main/java/com/laytonsmith/core/events/drivers/WorldEvents.java
+++ b/src/main/java/com/laytonsmith/core/events/drivers/WorldEvents.java
@@ -21,6 +21,7 @@
 import com.laytonsmith.core.events.AbstractEvent;
 import com.laytonsmith.core.events.BindableEvent;
 import com.laytonsmith.core.events.Driver;
+import com.laytonsmith.core.environments.Environment;
 import com.laytonsmith.core.events.Prefilters;
 import com.laytonsmith.core.exceptions.EventException;
 import com.laytonsmith.core.exceptions.PrefilterNonMatchException;
@@ -40,7 +41,7 @@ public static String docs() {
 	public abstract static class WorldEvent extends AbstractEvent {
 
 		@Override
-		public Map<String, Mixed> evaluate(BindableEvent e) throws EventException {
+		public Map<String, Mixed> evaluate(BindableEvent e, Environment env) throws EventException {
 			Map<String, Mixed> r = evaluate_helper(e);
 			r.put("world", new CString(((MCWorldEvent) e).getWorld().getName(), Target.UNKNOWN));
 			return r;
@@ -85,14 +86,9 @@ public boolean matches(Map<String, Mixed> prefilter, BindableEvent e) throws Pre
 		}
 
 		@Override
-		public boolean modifyEvent(String key, Mixed value, BindableEvent event) {
+		public boolean modifyEvent(String key, Mixed value, BindableEvent event, Environment env) {
 			return false;
 		}
-
-		@Override
-		public BindableEvent convert(CArray manualObject, Target t) {
-			return null;
-		}
 	}
 
 	@api
@@ -133,14 +129,9 @@ public boolean matches(Map<String, Mixed> prefilter, BindableEvent e) throws Pre
 		}
 
 		@Override
-		public boolean modifyEvent(String key, Mixed value, BindableEvent event) {
+		public boolean modifyEvent(String key, Mixed value, BindableEvent event, Environment env) {
 			return false;
 		}
-
-		@Override
-		public BindableEvent convert(CArray manualObject, Target t) {
-			return null;
-		}
 	}
 
 	@api
@@ -181,14 +172,9 @@ public boolean matches(Map<String, Mixed> prefilter, BindableEvent e) throws Pre
 		}
 
 		@Override
-		public boolean modifyEvent(String key, Mixed value, BindableEvent event) {
+		public boolean modifyEvent(String key, Mixed value, BindableEvent event, Environment env) {
 			return false;
 		}
-
-		@Override
-		public BindableEvent convert(CArray manualObject, Target t) {
-			return null;
-		}
 	}
 
 	@api
@@ -248,13 +234,13 @@ public boolean matches(Map<String, Mixed> prefilter, BindableEvent e) throws Pre
 		}
 
 		@Override
-		public Map<String, Mixed> evaluate(BindableEvent e) throws EventException {
-			Map<String, Mixed> r = super.evaluate(e);
+		public Map<String, Mixed> evaluate(BindableEvent e, Environment env) throws EventException {
+			Map<String, Mixed> r = super.evaluate(e, env);
 			MCStructureGrowEvent event = (MCStructureGrowEvent) e;
 			List<MCBlockState> blocks = event.getBlocks();
 			CArray a = new CArray(Target.UNKNOWN, blocks.size());
 			for(MCBlockState block : blocks) {
-				a.push(ObjectGenerator.GetGenerator().location(block.getLocation(), false), Target.UNKNOWN);
+				a.push(ObjectGenerator.GetGenerator().location(block.getLocation(), false), Target.UNKNOWN, env);
 			}
 			r.put("blocks", a);
 			r.put("location", ObjectGenerator.GetGenerator().location(event.getLocation(), false));
@@ -266,13 +252,8 @@ public Map<String, Mixed> evaluate(BindableEvent e) throws EventException {
 		}
 
 		@Override
-		public boolean modifyEvent(String key, Mixed value, BindableEvent event) {
+		public boolean modifyEvent(String key, Mixed value, BindableEvent event, Environment env) {
 			return false;
 		}
-
-		@Override
-		public BindableEvent convert(CArray manualObject, Target t) {
-			return null;
-		}
 	}
 }
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 76dc6339ba..03cf1c4aba 100644
--- a/src/main/java/com/laytonsmith/core/exceptions/CRE/AbstractCREException.java
+++ b/src/main/java/com/laytonsmith/core/exceptions/CRE/AbstractCREException.java
@@ -14,8 +14,11 @@
 import com.laytonsmith.core.constructs.Construct;
 import com.laytonsmith.core.constructs.NativeTypeList;
 import com.laytonsmith.core.constructs.Target;
+import com.laytonsmith.core.constructs.generics.GenericParameters;
+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;
@@ -35,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);
@@ -118,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);
 		}
@@ -133,18 +136,18 @@ public static AbstractCREException getFromCArray(CArray exception, Target t, Env
 				.forName(exception.get("classType", t).val(), t, env);
 		Class<? extends Mixed> clzz = NativeTypeList.getNativeClass(classType);
 		Throwable cause = null;
-		if(exception.get("causedBy", t).isInstanceOf(CArray.TYPE)) {
+		if(exception.get("causedBy", t).isInstanceOf(CArray.TYPE, null, env)) {
 			// It has a cause
 			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};
@@ -189,25 +192,53 @@ public String val() {
 	 * @param t
 	 * @return
 	 * @throws ConfigRuntimeException
+	 * @deprecated Use {@link #get(String, Target, Environment)} instead.
 	 */
+	@Deprecated
 	@Override
 	public Mixed get(String index, Target t) throws ConfigRuntimeException {
-		return exceptionObject.get(index, t);
+		return get(index, t, null);
 	}
 
+	@Override
+	public Mixed get(String index, Target t, Environment env) throws ConfigRuntimeException {
+		return exceptionObject.get(index, t, env);
+	}
+
+	/** @deprecated Use {@link #get(int, Target, Environment)} instead. */
+	@Deprecated
 	@Override
 	public Mixed get(int index, Target t) throws ConfigRuntimeException {
-		return exceptionObject.get(index, t);
+		return get(index, t, null);
 	}
 
+	@Override
+	public Mixed get(int index, Target t, Environment env) throws ConfigRuntimeException {
+		return exceptionObject.get(index, t, env);
+	}
+
+	/** @deprecated Use {@link #get(Mixed, Target, Environment)} instead. */
+	@Deprecated
 	@Override
 	public Mixed get(Mixed index, Target t) throws ConfigRuntimeException {
-		return exceptionObject.get(index, t);
+		return get(index, t, null);
+	}
+
+	@Override
+	public Mixed get(Mixed index, Target t, Environment env) throws ConfigRuntimeException {
+		return exceptionObject.get(index, t, env);
 	}
 
+	/** @deprecated Use {@link #keySet(Environment)} instead. */
+	@Deprecated
 	@Override
 	public Set<Mixed> keySet() {
-		return exceptionObject.keySet();
+		return keySet(null);
+	}
+
+	@Override
+	public Set<Mixed> keySet(Environment env) {
+		return exceptionObject.keySet(env);
 	}
 
 	@Override
@@ -220,9 +251,16 @@ public boolean canBeAssociative() {
 		return exceptionObject.canBeAssociative();
 	}
 
+	/** @deprecated Use {@link #slice(int, int, Target, Environment)} instead. */
+	@Deprecated
 	@Override
 	public Mixed slice(int begin, int end, Target t) {
-		return exceptionObject.slice(begin, end, t);
+		return slice(begin, end, t, null);
+	}
+
+	@Override
+	public Mixed slice(int begin, int end, Target t, Environment env) {
+		return exceptionObject.slice(begin, end, t, env);
 	}
 
 	@Override
@@ -260,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<>();
 		}
@@ -294,9 +332,11 @@ public CClassType[] getSuperclasses() {
 		throw new UnsupportedOperationException();
 	}
 
+	/** @deprecated Use {@link #isInstanceOf(CClassType, LeftHandGenericUse, Environment)} instead. */
+	@Deprecated
 	@Override
 	public boolean isInstanceOf(CClassType type) {
-		return Construct.isInstanceof(this, type);
+		return isInstanceOf(type, null, null);
 	}
 
 	@Override
@@ -304,13 +344,37 @@ public boolean isInstanceOf(Class<? extends Mixed> type) {
 		return Construct.isInstanceof(this, type);
 	}
 
+	@Override
+	public boolean isInstanceOf(CClassType type, LeftHandGenericUse lhsGenericParameters, Environment env) {
+		return Construct.isInstanceof(this, type, env);
+	}
+
+	/** @deprecated Use {@link #typeof(Environment)} instead. */
+	@Deprecated
 	@Override
 	public CClassType typeof() {
+		return typeof(null);
+	}
+
+	@Override
+	public CClassType typeof(Environment env) {
 		return Construct.typeof(this);
 	}
 
+	@Override
+	public GenericParameters getGenericParameters() {
+		return null;
+	}
+
+	/** @deprecated Use {@link #getBooleanValue(Target, Environment)} instead. */
+	@Deprecated
 	@Override
 	public boolean getBooleanValue(Target t) {
+		return getBooleanValue(t, null);
+	}
+
+	@Override
+	public boolean getBooleanValue(Target t, Environment env) {
 		return true;
 	}
 
diff --git a/src/main/java/com/laytonsmith/core/exceptions/CRE/CREBadEntityException.java b/src/main/java/com/laytonsmith/core/exceptions/CRE/CREBadEntityException.java
index fe48f197e7..bebfada60c 100644
--- a/src/main/java/com/laytonsmith/core/exceptions/CRE/CREBadEntityException.java
+++ b/src/main/java/com/laytonsmith/core/exceptions/CRE/CREBadEntityException.java
@@ -5,6 +5,7 @@
 import com.laytonsmith.core.MSVersion;
 import com.laytonsmith.core.constructs.CClassType;
 import com.laytonsmith.core.constructs.Target;
+import com.laytonsmith.core.constructs.generics.GenericParameters;
 
 /**
  *
@@ -43,4 +44,9 @@ public CClassType[] getInterfaces() {
 		return super.getInterfaces();
 	}
 
+	@Override
+	public GenericParameters getGenericParameters() {
+		return null;
+	}
+
 }
diff --git a/src/main/java/com/laytonsmith/core/exceptions/CRE/CREBadEntityTypeException.java b/src/main/java/com/laytonsmith/core/exceptions/CRE/CREBadEntityTypeException.java
index d41b5b1ff2..0d3a66b607 100644
--- a/src/main/java/com/laytonsmith/core/exceptions/CRE/CREBadEntityTypeException.java
+++ b/src/main/java/com/laytonsmith/core/exceptions/CRE/CREBadEntityTypeException.java
@@ -5,6 +5,7 @@
 import com.laytonsmith.core.MSVersion;
 import com.laytonsmith.core.constructs.CClassType;
 import com.laytonsmith.core.constructs.Target;
+import com.laytonsmith.core.constructs.generics.GenericParameters;
 
 /**
  *
@@ -42,4 +43,9 @@ public CClassType[] getSuperclasses() {
 	public CClassType[] getInterfaces() {
 		return super.getInterfaces();
 	}
+
+	@Override
+	public GenericParameters getGenericParameters() {
+		return null;
+	}
 }
diff --git a/src/main/java/com/laytonsmith/core/exceptions/CRE/CREBindException.java b/src/main/java/com/laytonsmith/core/exceptions/CRE/CREBindException.java
index fcbb5b0dae..51cebed418 100644
--- a/src/main/java/com/laytonsmith/core/exceptions/CRE/CREBindException.java
+++ b/src/main/java/com/laytonsmith/core/exceptions/CRE/CREBindException.java
@@ -5,6 +5,7 @@
 import com.laytonsmith.core.MSVersion;
 import com.laytonsmith.core.constructs.CClassType;
 import com.laytonsmith.core.constructs.Target;
+import com.laytonsmith.core.constructs.generics.GenericParameters;
 
 /**
  *
@@ -43,4 +44,9 @@ public CClassType[] getSuperclasses() {
 	public CClassType[] getInterfaces() {
 		return super.getInterfaces();
 	}
+
+	@Override
+	public GenericParameters getGenericParameters() {
+		return null;
+	}
 }
diff --git a/src/main/java/com/laytonsmith/core/exceptions/CRE/CRECastException.java b/src/main/java/com/laytonsmith/core/exceptions/CRE/CRECastException.java
index 834436bc90..fbdf1c38c3 100644
--- a/src/main/java/com/laytonsmith/core/exceptions/CRE/CRECastException.java
+++ b/src/main/java/com/laytonsmith/core/exceptions/CRE/CRECastException.java
@@ -5,6 +5,7 @@
 import com.laytonsmith.core.MSVersion;
 import com.laytonsmith.core.constructs.CClassType;
 import com.laytonsmith.core.constructs.Target;
+import com.laytonsmith.core.constructs.generics.GenericParameters;
 
 /**
  *
@@ -44,4 +45,9 @@ public CClassType[] getSuperclasses() {
 	public CClassType[] getInterfaces() {
 		return super.getInterfaces();
 	}
+
+	@Override
+	public GenericParameters getGenericParameters() {
+		return null;
+	}
 }
diff --git a/src/main/java/com/laytonsmith/core/exceptions/CRE/CRECausedByWrapper.java b/src/main/java/com/laytonsmith/core/exceptions/CRE/CRECausedByWrapper.java
index 71f049d874..da6165fabd 100644
--- a/src/main/java/com/laytonsmith/core/exceptions/CRE/CRECausedByWrapper.java
+++ b/src/main/java/com/laytonsmith/core/exceptions/CRE/CRECausedByWrapper.java
@@ -4,6 +4,7 @@
 import com.laytonsmith.core.constructs.CArray;
 import com.laytonsmith.core.constructs.CClassType;
 import com.laytonsmith.core.constructs.Target;
+import com.laytonsmith.core.constructs.generics.GenericParameters;
 
 /**
  * Wraps a CArray that represents a causedBy exception.
@@ -51,4 +52,9 @@ public CClassType[] getSuperclasses() {
 		throw new UnsupportedOperationException();
 	}
 
+	@Override
+	public GenericParameters getGenericParameters() {
+		return null;
+	}
+
 }
diff --git a/src/main/java/com/laytonsmith/core/exceptions/CRE/CREClassDefinitionError.java b/src/main/java/com/laytonsmith/core/exceptions/CRE/CREClassDefinitionError.java
index fec6573b99..53e6c12df8 100644
--- a/src/main/java/com/laytonsmith/core/exceptions/CRE/CREClassDefinitionError.java
+++ b/src/main/java/com/laytonsmith/core/exceptions/CRE/CREClassDefinitionError.java
@@ -5,6 +5,7 @@
 import com.laytonsmith.core.MSVersion;
 import com.laytonsmith.core.constructs.CClassType;
 import com.laytonsmith.core.constructs.Target;
+import com.laytonsmith.core.constructs.generics.GenericParameters;
 
 /**
  * This is thrown if a class definition is incorrect. Normally this should be a compiler error, but in dynamic code
@@ -44,4 +45,9 @@ public CClassType[] getSuperclasses() {
 	public CClassType[] getInterfaces() {
 		return super.getInterfaces();
 	}
+
+	@Override
+	public GenericParameters getGenericParameters() {
+		return null;
+	}
 }
diff --git a/src/main/java/com/laytonsmith/core/exceptions/CRE/CREEnchantmentException.java b/src/main/java/com/laytonsmith/core/exceptions/CRE/CREEnchantmentException.java
index 45ce8bcbed..79f764cb41 100644
--- a/src/main/java/com/laytonsmith/core/exceptions/CRE/CREEnchantmentException.java
+++ b/src/main/java/com/laytonsmith/core/exceptions/CRE/CREEnchantmentException.java
@@ -5,6 +5,7 @@
 import com.laytonsmith.core.MSVersion;
 import com.laytonsmith.core.constructs.CClassType;
 import com.laytonsmith.core.constructs.Target;
+import com.laytonsmith.core.constructs.generics.GenericParameters;
 
 /**
  *
@@ -42,4 +43,9 @@ public CClassType[] getSuperclasses() {
 	public CClassType[] getInterfaces() {
 		return super.getInterfaces();
 	}
+
+	@Override
+	public GenericParameters getGenericParameters() {
+		return null;
+	}
 }
diff --git a/src/main/java/com/laytonsmith/core/exceptions/CRE/CREError.java b/src/main/java/com/laytonsmith/core/exceptions/CRE/CREError.java
index f4a6b58e08..14dacf2b1c 100644
--- a/src/main/java/com/laytonsmith/core/exceptions/CRE/CREError.java
+++ b/src/main/java/com/laytonsmith/core/exceptions/CRE/CREError.java
@@ -5,6 +5,7 @@
 import com.laytonsmith.core.MSVersion;
 import com.laytonsmith.core.constructs.CClassType;
 import com.laytonsmith.core.constructs.Target;
+import com.laytonsmith.core.constructs.generics.GenericParameters;
 
 /**
  *
@@ -42,4 +43,9 @@ public CClassType[] getSuperclasses() {
 	public CClassType[] getInterfaces() {
 		return super.getInterfaces();
 	}
+
+	@Override
+	public GenericParameters getGenericParameters() {
+		return null;
+	}
 }
diff --git a/src/main/java/com/laytonsmith/core/exceptions/CRE/CREEventException.java b/src/main/java/com/laytonsmith/core/exceptions/CRE/CREEventException.java
index c7790c8978..4ce443dd7b 100644
--- a/src/main/java/com/laytonsmith/core/exceptions/CRE/CREEventException.java
+++ b/src/main/java/com/laytonsmith/core/exceptions/CRE/CREEventException.java
@@ -5,6 +5,7 @@
 import com.laytonsmith.core.MSVersion;
 import com.laytonsmith.core.constructs.CClassType;
 import com.laytonsmith.core.constructs.Target;
+import com.laytonsmith.core.constructs.generics.GenericParameters;
 
 /**
  *
@@ -44,4 +45,9 @@ public CClassType[] getInterfaces() {
 		return super.getInterfaces();
 	}
 
+	@Override
+	public GenericParameters getGenericParameters() {
+		return null;
+	}
+
 }
diff --git a/src/main/java/com/laytonsmith/core/exceptions/CRE/CREException.java b/src/main/java/com/laytonsmith/core/exceptions/CRE/CREException.java
index cb1652bee9..a24dbe410e 100644
--- a/src/main/java/com/laytonsmith/core/exceptions/CRE/CREException.java
+++ b/src/main/java/com/laytonsmith/core/exceptions/CRE/CREException.java
@@ -5,6 +5,7 @@
 import com.laytonsmith.core.MSVersion;
 import com.laytonsmith.core.constructs.CClassType;
 import com.laytonsmith.core.constructs.Target;
+import com.laytonsmith.core.constructs.generics.GenericParameters;
 
 /**
  *
@@ -42,4 +43,9 @@ public CClassType[] getSuperclasses() {
 	public CClassType[] getInterfaces() {
 		return super.getInterfaces();
 	}
+
+	@Override
+	public GenericParameters getGenericParameters() {
+		return null;
+	}
 }
diff --git a/src/main/java/com/laytonsmith/core/exceptions/CRE/CREFormatException.java b/src/main/java/com/laytonsmith/core/exceptions/CRE/CREFormatException.java
index 2305b968e5..92c5787010 100644
--- a/src/main/java/com/laytonsmith/core/exceptions/CRE/CREFormatException.java
+++ b/src/main/java/com/laytonsmith/core/exceptions/CRE/CREFormatException.java
@@ -5,6 +5,7 @@
 import com.laytonsmith.core.MSVersion;
 import com.laytonsmith.core.constructs.CClassType;
 import com.laytonsmith.core.constructs.Target;
+import com.laytonsmith.core.constructs.generics.GenericParameters;
 
 /**
  *
@@ -44,4 +45,9 @@ public CClassType[] getSuperclasses() {
 	public CClassType[] getInterfaces() {
 		return super.getInterfaces();
 	}
+
+	@Override
+	public GenericParameters getGenericParameters() {
+		return null;
+	}
 }
diff --git a/src/main/java/com/laytonsmith/core/exceptions/CRE/CREGenericConstraintException.java b/src/main/java/com/laytonsmith/core/exceptions/CRE/CREGenericConstraintException.java
index 4afdf03bd4..2395fdd9b9 100644
--- a/src/main/java/com/laytonsmith/core/exceptions/CRE/CREGenericConstraintException.java
+++ b/src/main/java/com/laytonsmith/core/exceptions/CRE/CREGenericConstraintException.java
@@ -5,6 +5,7 @@
 import com.laytonsmith.core.MSVersion;
 import com.laytonsmith.core.constructs.CClassType;
 import com.laytonsmith.core.constructs.Target;
+import com.laytonsmith.core.constructs.generics.GenericParameters;
 
 /**
  *
@@ -45,5 +46,10 @@ public CClassType[] getInterfaces() {
 		return super.getInterfaces();
 	}
 
+	@Override
+	public GenericParameters getGenericParameters() {
+		return null;
+	}
+
 }
 
diff --git a/src/main/java/com/laytonsmith/core/exceptions/CRE/CREIOException.java b/src/main/java/com/laytonsmith/core/exceptions/CRE/CREIOException.java
index 76f9d77cff..ab6c3f8d59 100644
--- a/src/main/java/com/laytonsmith/core/exceptions/CRE/CREIOException.java
+++ b/src/main/java/com/laytonsmith/core/exceptions/CRE/CREIOException.java
@@ -5,6 +5,7 @@
 import com.laytonsmith.core.MSVersion;
 import com.laytonsmith.core.constructs.CClassType;
 import com.laytonsmith.core.constructs.Target;
+import com.laytonsmith.core.constructs.generics.GenericParameters;
 
 /**
  *
@@ -42,4 +43,9 @@ public CClassType[] getSuperclasses() {
 	public CClassType[] getInterfaces() {
 		return super.getInterfaces();
 	}
+
+	@Override
+	public GenericParameters getGenericParameters() {
+		return null;
+	}
 }
diff --git a/src/main/java/com/laytonsmith/core/exceptions/CRE/CREIllegalArgumentException.java b/src/main/java/com/laytonsmith/core/exceptions/CRE/CREIllegalArgumentException.java
index 9853b2d528..fd9b84f2d9 100644
--- a/src/main/java/com/laytonsmith/core/exceptions/CRE/CREIllegalArgumentException.java
+++ b/src/main/java/com/laytonsmith/core/exceptions/CRE/CREIllegalArgumentException.java
@@ -5,6 +5,7 @@
 import com.laytonsmith.core.MSVersion;
 import com.laytonsmith.core.constructs.CClassType;
 import com.laytonsmith.core.constructs.Target;
+import com.laytonsmith.core.constructs.generics.GenericParameters;
 
 /**
  *
@@ -42,4 +43,9 @@ public CClassType[] getSuperclasses() {
 	public CClassType[] getInterfaces() {
 		return super.getInterfaces();
 	}
+
+	@Override
+	public GenericParameters getGenericParameters() {
+		return null;
+	}
 }
diff --git a/src/main/java/com/laytonsmith/core/exceptions/CRE/CREIncludeException.java b/src/main/java/com/laytonsmith/core/exceptions/CRE/CREIncludeException.java
index 53d4bd4024..dddde74b63 100644
--- a/src/main/java/com/laytonsmith/core/exceptions/CRE/CREIncludeException.java
+++ b/src/main/java/com/laytonsmith/core/exceptions/CRE/CREIncludeException.java
@@ -5,6 +5,7 @@
 import com.laytonsmith.core.MSVersion;
 import com.laytonsmith.core.constructs.CClassType;
 import com.laytonsmith.core.constructs.Target;
+import com.laytonsmith.core.constructs.generics.GenericParameters;
 
 /**
  *
@@ -43,4 +44,9 @@ public CClassType[] getSuperclasses() {
 	public CClassType[] getInterfaces() {
 		return super.getInterfaces();
 	}
+
+	@Override
+	public GenericParameters getGenericParameters() {
+		return null;
+	}
 }
diff --git a/src/main/java/com/laytonsmith/core/exceptions/CRE/CREIndexOverflowException.java b/src/main/java/com/laytonsmith/core/exceptions/CRE/CREIndexOverflowException.java
index 26fb90dfcf..0344b88c0e 100644
--- a/src/main/java/com/laytonsmith/core/exceptions/CRE/CREIndexOverflowException.java
+++ b/src/main/java/com/laytonsmith/core/exceptions/CRE/CREIndexOverflowException.java
@@ -5,6 +5,7 @@
 import com.laytonsmith.core.MSVersion;
 import com.laytonsmith.core.constructs.CClassType;
 import com.laytonsmith.core.constructs.Target;
+import com.laytonsmith.core.constructs.generics.GenericParameters;
 
 /**
  *
@@ -43,4 +44,9 @@ public CClassType[] getSuperclasses() {
 	public CClassType[] getInterfaces() {
 		return super.getInterfaces();
 	}
+
+	@Override
+	public GenericParameters getGenericParameters() {
+		return null;
+	}
 }
diff --git a/src/main/java/com/laytonsmith/core/exceptions/CRE/CREInsufficientArgumentsException.java b/src/main/java/com/laytonsmith/core/exceptions/CRE/CREInsufficientArgumentsException.java
index 1304ba5b8d..9074deecef 100644
--- a/src/main/java/com/laytonsmith/core/exceptions/CRE/CREInsufficientArgumentsException.java
+++ b/src/main/java/com/laytonsmith/core/exceptions/CRE/CREInsufficientArgumentsException.java
@@ -5,6 +5,7 @@
 import com.laytonsmith.core.MSVersion;
 import com.laytonsmith.core.constructs.CClassType;
 import com.laytonsmith.core.constructs.Target;
+import com.laytonsmith.core.constructs.generics.GenericParameters;
 
 /**
  *
@@ -43,4 +44,9 @@ public CClassType[] getSuperclasses() {
 	public CClassType[] getInterfaces() {
 		return super.getInterfaces();
 	}
+
+	@Override
+	public GenericParameters getGenericParameters() {
+		return null;
+	}
 }
diff --git a/src/main/java/com/laytonsmith/core/exceptions/CRE/CREInsufficientPermissionException.java b/src/main/java/com/laytonsmith/core/exceptions/CRE/CREInsufficientPermissionException.java
index b141aeaebb..14b4e99272 100644
--- a/src/main/java/com/laytonsmith/core/exceptions/CRE/CREInsufficientPermissionException.java
+++ b/src/main/java/com/laytonsmith/core/exceptions/CRE/CREInsufficientPermissionException.java
@@ -5,6 +5,7 @@
 import com.laytonsmith.core.MSVersion;
 import com.laytonsmith.core.constructs.CClassType;
 import com.laytonsmith.core.constructs.Target;
+import com.laytonsmith.core.constructs.generics.GenericParameters;
 
 /**
  *
@@ -43,4 +44,9 @@ public CClassType[] getSuperclasses() {
 	public CClassType[] getInterfaces() {
 		return super.getInterfaces();
 	}
+
+	@Override
+	public GenericParameters getGenericParameters() {
+		return null;
+	}
 }
diff --git a/src/main/java/com/laytonsmith/core/exceptions/CRE/CREInterruptedException.java b/src/main/java/com/laytonsmith/core/exceptions/CRE/CREInterruptedException.java
index 11738c3d00..997d8b19c3 100644
--- a/src/main/java/com/laytonsmith/core/exceptions/CRE/CREInterruptedException.java
+++ b/src/main/java/com/laytonsmith/core/exceptions/CRE/CREInterruptedException.java
@@ -5,6 +5,7 @@
 import com.laytonsmith.core.MSVersion;
 import com.laytonsmith.core.constructs.CClassType;
 import com.laytonsmith.core.constructs.Target;
+import com.laytonsmith.core.constructs.generics.GenericParameters;
 
 /**
  *
@@ -46,4 +47,9 @@ public CClassType[] getSuperclasses() {
 	public CClassType[] getInterfaces() {
 		return super.getInterfaces();
 	}
+
+	@Override
+	public GenericParameters getGenericParameters() {
+		return null;
+	}
 }
diff --git a/src/main/java/com/laytonsmith/core/exceptions/CRE/CREInvalidPluginException.java b/src/main/java/com/laytonsmith/core/exceptions/CRE/CREInvalidPluginException.java
index ce2e341f76..11b51e4aa3 100644
--- a/src/main/java/com/laytonsmith/core/exceptions/CRE/CREInvalidPluginException.java
+++ b/src/main/java/com/laytonsmith/core/exceptions/CRE/CREInvalidPluginException.java
@@ -5,6 +5,7 @@
 import com.laytonsmith.core.MSVersion;
 import com.laytonsmith.core.constructs.CClassType;
 import com.laytonsmith.core.constructs.Target;
+import com.laytonsmith.core.constructs.generics.GenericParameters;
 
 /**
  *
@@ -43,4 +44,9 @@ public CClassType[] getSuperclasses() {
 	public CClassType[] getInterfaces() {
 		return super.getInterfaces();
 	}
+
+	@Override
+	public GenericParameters getGenericParameters() {
+		return null;
+	}
 }
diff --git a/src/main/java/com/laytonsmith/core/exceptions/CRE/CREInvalidProcedureException.java b/src/main/java/com/laytonsmith/core/exceptions/CRE/CREInvalidProcedureException.java
index 4e5505da49..a73ffe184e 100644
--- a/src/main/java/com/laytonsmith/core/exceptions/CRE/CREInvalidProcedureException.java
+++ b/src/main/java/com/laytonsmith/core/exceptions/CRE/CREInvalidProcedureException.java
@@ -5,6 +5,7 @@
 import com.laytonsmith.core.MSVersion;
 import com.laytonsmith.core.constructs.CClassType;
 import com.laytonsmith.core.constructs.Target;
+import com.laytonsmith.core.constructs.generics.GenericParameters;
 
 /**
  *
@@ -44,4 +45,9 @@ public CClassType[] getSuperclasses() {
 	public CClassType[] getInterfaces() {
 		return super.getInterfaces();
 	}
+
+	@Override
+	public GenericParameters getGenericParameters() {
+		return null;
+	}
 }
diff --git a/src/main/java/com/laytonsmith/core/exceptions/CRE/CREInvalidWorldException.java b/src/main/java/com/laytonsmith/core/exceptions/CRE/CREInvalidWorldException.java
index bd69175b72..4b3818f9f3 100644
--- a/src/main/java/com/laytonsmith/core/exceptions/CRE/CREInvalidWorldException.java
+++ b/src/main/java/com/laytonsmith/core/exceptions/CRE/CREInvalidWorldException.java
@@ -5,6 +5,7 @@
 import com.laytonsmith.core.MSVersion;
 import com.laytonsmith.core.constructs.CClassType;
 import com.laytonsmith.core.constructs.Target;
+import com.laytonsmith.core.constructs.generics.GenericParameters;
 
 /**
  *
@@ -43,4 +44,9 @@ public CClassType[] getSuperclasses() {
 	public CClassType[] getInterfaces() {
 		return super.getInterfaces();
 	}
+
+	@Override
+	public GenericParameters getGenericParameters() {
+		return null;
+	}
 }
diff --git a/src/main/java/com/laytonsmith/core/exceptions/CRE/CRELengthException.java b/src/main/java/com/laytonsmith/core/exceptions/CRE/CRELengthException.java
index a70c100b46..af3bd0cbca 100644
--- a/src/main/java/com/laytonsmith/core/exceptions/CRE/CRELengthException.java
+++ b/src/main/java/com/laytonsmith/core/exceptions/CRE/CRELengthException.java
@@ -5,6 +5,7 @@
 import com.laytonsmith.core.MSVersion;
 import com.laytonsmith.core.constructs.CClassType;
 import com.laytonsmith.core.constructs.Target;
+import com.laytonsmith.core.constructs.generics.GenericParameters;
 
 /**
  *
@@ -43,4 +44,9 @@ public CClassType[] getSuperclasses() {
 	public CClassType[] getInterfaces() {
 		return super.getInterfaces();
 	}
+
+	@Override
+	public GenericParameters getGenericParameters() {
+		return null;
+	}
 }
diff --git a/src/main/java/com/laytonsmith/core/exceptions/CRE/CRENotFoundException.java b/src/main/java/com/laytonsmith/core/exceptions/CRE/CRENotFoundException.java
index 8a320f46a3..92ea04acd7 100644
--- a/src/main/java/com/laytonsmith/core/exceptions/CRE/CRENotFoundException.java
+++ b/src/main/java/com/laytonsmith/core/exceptions/CRE/CRENotFoundException.java
@@ -5,6 +5,7 @@
 import com.laytonsmith.core.MSVersion;
 import com.laytonsmith.core.constructs.CClassType;
 import com.laytonsmith.core.constructs.Target;
+import com.laytonsmith.core.constructs.generics.GenericParameters;
 
 /**
  *
@@ -42,4 +43,9 @@ public CClassType[] getSuperclasses() {
 	public CClassType[] getInterfaces() {
 		return super.getInterfaces();
 	}
+
+	@Override
+	public GenericParameters getGenericParameters() {
+		return null;
+	}
 }
diff --git a/src/main/java/com/laytonsmith/core/exceptions/CRE/CRENullPointerException.java b/src/main/java/com/laytonsmith/core/exceptions/CRE/CRENullPointerException.java
index 4e93a674eb..0043ca3344 100644
--- a/src/main/java/com/laytonsmith/core/exceptions/CRE/CRENullPointerException.java
+++ b/src/main/java/com/laytonsmith/core/exceptions/CRE/CRENullPointerException.java
@@ -5,6 +5,7 @@
 import com.laytonsmith.core.MSVersion;
 import com.laytonsmith.core.constructs.CClassType;
 import com.laytonsmith.core.constructs.Target;
+import com.laytonsmith.core.constructs.generics.GenericParameters;
 
 /**
  *
@@ -43,4 +44,9 @@ public CClassType[] getSuperclasses() {
 	public CClassType[] getInterfaces() {
 		return super.getInterfaces();
 	}
+
+	@Override
+	public GenericParameters getGenericParameters() {
+		return null;
+	}
 }
diff --git a/src/main/java/com/laytonsmith/core/exceptions/CRE/CREOAuthException.java b/src/main/java/com/laytonsmith/core/exceptions/CRE/CREOAuthException.java
index adf0afe0aa..a2eb6ab49a 100644
--- a/src/main/java/com/laytonsmith/core/exceptions/CRE/CREOAuthException.java
+++ b/src/main/java/com/laytonsmith/core/exceptions/CRE/CREOAuthException.java
@@ -5,6 +5,7 @@
 import com.laytonsmith.core.MSVersion;
 import com.laytonsmith.core.constructs.CClassType;
 import com.laytonsmith.core.constructs.Target;
+import com.laytonsmith.core.constructs.generics.GenericParameters;
 
 /**
  *
@@ -44,4 +45,9 @@ public CClassType[] getInterfaces() {
 		return super.getInterfaces();
 	}
 
+	@Override
+	public GenericParameters getGenericParameters() {
+		return null;
+	}
+
 }
diff --git a/src/main/java/com/laytonsmith/core/exceptions/CRE/CREPlayerOfflineException.java b/src/main/java/com/laytonsmith/core/exceptions/CRE/CREPlayerOfflineException.java
index 19f52cd0e8..bba08e55bb 100644
--- a/src/main/java/com/laytonsmith/core/exceptions/CRE/CREPlayerOfflineException.java
+++ b/src/main/java/com/laytonsmith/core/exceptions/CRE/CREPlayerOfflineException.java
@@ -5,6 +5,7 @@
 import com.laytonsmith.core.MSVersion;
 import com.laytonsmith.core.constructs.CClassType;
 import com.laytonsmith.core.constructs.Target;
+import com.laytonsmith.core.constructs.generics.GenericParameters;
 
 /**
  *
@@ -44,4 +45,9 @@ public CClassType[] getSuperclasses() {
 	public CClassType[] getInterfaces() {
 		return super.getInterfaces();
 	}
+
+	@Override
+	public GenericParameters getGenericParameters() {
+		return null;
+	}
 }
diff --git a/src/main/java/com/laytonsmith/core/exceptions/CRE/CREPluginChannelException.java b/src/main/java/com/laytonsmith/core/exceptions/CRE/CREPluginChannelException.java
index cae4e2cf26..615b347cd5 100644
--- a/src/main/java/com/laytonsmith/core/exceptions/CRE/CREPluginChannelException.java
+++ b/src/main/java/com/laytonsmith/core/exceptions/CRE/CREPluginChannelException.java
@@ -5,6 +5,7 @@
 import com.laytonsmith.core.MSVersion;
 import com.laytonsmith.core.constructs.CClassType;
 import com.laytonsmith.core.constructs.Target;
+import com.laytonsmith.core.constructs.generics.GenericParameters;
 
 /**
  *
@@ -43,4 +44,9 @@ public CClassType[] getSuperclasses() {
 	public CClassType[] getInterfaces() {
 		return super.getInterfaces();
 	}
+
+	@Override
+	public GenericParameters getGenericParameters() {
+		return null;
+	}
 }
diff --git a/src/main/java/com/laytonsmith/core/exceptions/CRE/CREPluginInternalException.java b/src/main/java/com/laytonsmith/core/exceptions/CRE/CREPluginInternalException.java
index 5b73cd8266..3097720dd7 100644
--- a/src/main/java/com/laytonsmith/core/exceptions/CRE/CREPluginInternalException.java
+++ b/src/main/java/com/laytonsmith/core/exceptions/CRE/CREPluginInternalException.java
@@ -5,6 +5,7 @@
 import com.laytonsmith.core.MSVersion;
 import com.laytonsmith.core.constructs.CClassType;
 import com.laytonsmith.core.constructs.Target;
+import com.laytonsmith.core.constructs.generics.GenericParameters;
 
 /**
  *
@@ -44,4 +45,9 @@ public CClassType[] getSuperclasses() {
 	public CClassType[] getInterfaces() {
 		return super.getInterfaces();
 	}
+
+	@Override
+	public GenericParameters getGenericParameters() {
+		return null;
+	}
 }
diff --git a/src/main/java/com/laytonsmith/core/exceptions/CRE/CRERangeException.java b/src/main/java/com/laytonsmith/core/exceptions/CRE/CRERangeException.java
index e866681e8a..cb7c39a19a 100644
--- a/src/main/java/com/laytonsmith/core/exceptions/CRE/CRERangeException.java
+++ b/src/main/java/com/laytonsmith/core/exceptions/CRE/CRERangeException.java
@@ -5,6 +5,7 @@
 import com.laytonsmith.core.MSVersion;
 import com.laytonsmith.core.constructs.CClassType;
 import com.laytonsmith.core.constructs.Target;
+import com.laytonsmith.core.constructs.generics.GenericParameters;
 
 /**
  *
@@ -43,4 +44,9 @@ public CClassType[] getSuperclasses() {
 	public CClassType[] getInterfaces() {
 		return super.getInterfaces();
 	}
+
+	@Override
+	public GenericParameters getGenericParameters() {
+		return null;
+	}
 }
diff --git a/src/main/java/com/laytonsmith/core/exceptions/CRE/CREReadOnlyException.java b/src/main/java/com/laytonsmith/core/exceptions/CRE/CREReadOnlyException.java
index ee297d5360..bbc93ca22d 100644
--- a/src/main/java/com/laytonsmith/core/exceptions/CRE/CREReadOnlyException.java
+++ b/src/main/java/com/laytonsmith/core/exceptions/CRE/CREReadOnlyException.java
@@ -5,6 +5,7 @@
 import com.laytonsmith.core.MSVersion;
 import com.laytonsmith.core.constructs.CClassType;
 import com.laytonsmith.core.constructs.Target;
+import com.laytonsmith.core.constructs.generics.GenericParameters;
 
 /**
  *
@@ -42,4 +43,9 @@ public CClassType[] getSuperclasses() {
 	public CClassType[] getInterfaces() {
 		return super.getInterfaces();
 	}
+
+	@Override
+	public GenericParameters getGenericParameters() {
+		return null;
+	}
 }
diff --git a/src/main/java/com/laytonsmith/core/exceptions/CRE/CRESQLException.java b/src/main/java/com/laytonsmith/core/exceptions/CRE/CRESQLException.java
index 1d8d80ad40..1696995fce 100644
--- a/src/main/java/com/laytonsmith/core/exceptions/CRE/CRESQLException.java
+++ b/src/main/java/com/laytonsmith/core/exceptions/CRE/CRESQLException.java
@@ -5,6 +5,7 @@
 import com.laytonsmith.core.MSVersion;
 import com.laytonsmith.core.constructs.CClassType;
 import com.laytonsmith.core.constructs.Target;
+import com.laytonsmith.core.constructs.generics.GenericParameters;
 
 /**
  *
@@ -42,4 +43,9 @@ public CClassType[] getSuperclasses() {
 	public CClassType[] getInterfaces() {
 		return super.getInterfaces();
 	}
+
+	@Override
+	public GenericParameters getGenericParameters() {
+		return null;
+	}
 }
diff --git a/src/main/java/com/laytonsmith/core/exceptions/CRE/CREScoreboardException.java b/src/main/java/com/laytonsmith/core/exceptions/CRE/CREScoreboardException.java
index afefcf26de..8a26940bfa 100644
--- a/src/main/java/com/laytonsmith/core/exceptions/CRE/CREScoreboardException.java
+++ b/src/main/java/com/laytonsmith/core/exceptions/CRE/CREScoreboardException.java
@@ -5,6 +5,7 @@
 import com.laytonsmith.core.MSVersion;
 import com.laytonsmith.core.constructs.CClassType;
 import com.laytonsmith.core.constructs.Target;
+import com.laytonsmith.core.constructs.generics.GenericParameters;
 
 /**
  *
@@ -44,4 +45,9 @@ public CClassType[] getSuperclasses() {
 	public CClassType[] getInterfaces() {
 		return super.getInterfaces();
 	}
+
+	@Override
+	public GenericParameters getGenericParameters() {
+		return null;
+	}
 }
diff --git a/src/main/java/com/laytonsmith/core/exceptions/CRE/CRESecurityException.java b/src/main/java/com/laytonsmith/core/exceptions/CRE/CRESecurityException.java
index d4e8c98a1a..28c387d763 100644
--- a/src/main/java/com/laytonsmith/core/exceptions/CRE/CRESecurityException.java
+++ b/src/main/java/com/laytonsmith/core/exceptions/CRE/CRESecurityException.java
@@ -5,6 +5,7 @@
 import com.laytonsmith.core.MSVersion;
 import com.laytonsmith.core.constructs.CClassType;
 import com.laytonsmith.core.constructs.Target;
+import com.laytonsmith.core.constructs.generics.GenericParameters;
 
 /**
  *
@@ -43,4 +44,9 @@ public CClassType[] getSuperclasses() {
 	public CClassType[] getInterfaces() {
 		return super.getInterfaces();
 	}
+
+	@Override
+	public GenericParameters getGenericParameters() {
+		return null;
+	}
 }
diff --git a/src/main/java/com/laytonsmith/core/exceptions/CRE/CREShellException.java b/src/main/java/com/laytonsmith/core/exceptions/CRE/CREShellException.java
index 98334e8642..98b862cb79 100644
--- a/src/main/java/com/laytonsmith/core/exceptions/CRE/CREShellException.java
+++ b/src/main/java/com/laytonsmith/core/exceptions/CRE/CREShellException.java
@@ -5,6 +5,7 @@
 import com.laytonsmith.core.MSVersion;
 import com.laytonsmith.core.constructs.CClassType;
 import com.laytonsmith.core.constructs.Target;
+import com.laytonsmith.core.constructs.generics.GenericParameters;
 
 /**
  *
@@ -42,4 +43,9 @@ public CClassType[] getSuperclasses() {
 	public CClassType[] getInterfaces() {
 		return super.getInterfaces();
 	}
+
+	@Override
+	public GenericParameters getGenericParameters() {
+		return null;
+	}
 }
diff --git a/src/main/java/com/laytonsmith/core/exceptions/CRE/CREStackOverflowError.java b/src/main/java/com/laytonsmith/core/exceptions/CRE/CREStackOverflowError.java
index 7364dd7cdc..9abf5a40bb 100644
--- a/src/main/java/com/laytonsmith/core/exceptions/CRE/CREStackOverflowError.java
+++ b/src/main/java/com/laytonsmith/core/exceptions/CRE/CREStackOverflowError.java
@@ -5,6 +5,7 @@
 import com.laytonsmith.core.MSVersion;
 import com.laytonsmith.core.constructs.CClassType;
 import com.laytonsmith.core.constructs.Target;
+import com.laytonsmith.core.constructs.generics.GenericParameters;
 
 /**
  *
@@ -43,4 +44,9 @@ public CClassType[] getSuperclasses() {
 	public CClassType[] getInterfaces() {
 		return super.getInterfaces();
 	}
+
+	@Override
+	public GenericParameters getGenericParameters() {
+		return null;
+	}
 }
diff --git a/src/main/java/com/laytonsmith/core/exceptions/CRE/CREUnageableMobException.java b/src/main/java/com/laytonsmith/core/exceptions/CRE/CREUnageableMobException.java
index 85b9ca0fbf..9e8ef47910 100644
--- a/src/main/java/com/laytonsmith/core/exceptions/CRE/CREUnageableMobException.java
+++ b/src/main/java/com/laytonsmith/core/exceptions/CRE/CREUnageableMobException.java
@@ -5,6 +5,7 @@
 import com.laytonsmith.core.MSVersion;
 import com.laytonsmith.core.constructs.CClassType;
 import com.laytonsmith.core.constructs.Target;
+import com.laytonsmith.core.constructs.generics.GenericParameters;
 
 /**
  *
@@ -43,4 +44,9 @@ public CClassType[] getSuperclasses() {
 	public CClassType[] getInterfaces() {
 		return super.getInterfaces();
 	}
+
+	@Override
+	public GenericParameters getGenericParameters() {
+		return null;
+	}
 }
diff --git a/src/main/java/com/laytonsmith/core/exceptions/CRE/CREUnsupportedOperationException.java b/src/main/java/com/laytonsmith/core/exceptions/CRE/CREUnsupportedOperationException.java
index b505c83654..0f0f7244d4 100644
--- a/src/main/java/com/laytonsmith/core/exceptions/CRE/CREUnsupportedOperationException.java
+++ b/src/main/java/com/laytonsmith/core/exceptions/CRE/CREUnsupportedOperationException.java
@@ -10,6 +10,7 @@
 import com.laytonsmith.core.MSVersion;
 import com.laytonsmith.core.constructs.CClassType;
 import com.laytonsmith.core.constructs.Target;
+import com.laytonsmith.core.constructs.generics.GenericParameters;
 
 /**
  *
@@ -52,4 +53,9 @@ public CClassType[] getSuperclasses() {
 	public CClassType[] getInterfaces() {
 		return super.getInterfaces();
 	}
+
+	@Override
+	public GenericParameters getGenericParameters() {
+		return null;
+	}
 }
diff --git a/src/main/java/com/laytonsmith/core/exceptions/CRE/CREUntameableMobException.java b/src/main/java/com/laytonsmith/core/exceptions/CRE/CREUntameableMobException.java
index b35e20abcc..24c36ed4de 100644
--- a/src/main/java/com/laytonsmith/core/exceptions/CRE/CREUntameableMobException.java
+++ b/src/main/java/com/laytonsmith/core/exceptions/CRE/CREUntameableMobException.java
@@ -5,6 +5,7 @@
 import com.laytonsmith.core.MSVersion;
 import com.laytonsmith.core.constructs.CClassType;
 import com.laytonsmith.core.constructs.Target;
+import com.laytonsmith.core.constructs.generics.GenericParameters;
 
 /**
  *
@@ -43,4 +44,9 @@ public CClassType[] getSuperclasses() {
 	public CClassType[] getInterfaces() {
 		return super.getInterfaces();
 	}
+
+	@Override
+	public GenericParameters getGenericParameters() {
+		return null;
+	}
 }
diff --git a/src/main/java/com/laytonsmith/core/exceptions/CancelCommandException.java b/src/main/java/com/laytonsmith/core/exceptions/CancelCommandException.java
index 2b3502e406..c395203eaf 100644
--- a/src/main/java/com/laytonsmith/core/exceptions/CancelCommandException.java
+++ b/src/main/java/com/laytonsmith/core/exceptions/CancelCommandException.java
@@ -3,15 +3,15 @@
 import com.laytonsmith.core.constructs.Target;
 
 /**
- *
- *
+ * Thrown by constructs like die() to cancel the current command execution.
  */
-public class CancelCommandException extends ProgramFlowManipulationException {
+public class CancelCommandException extends RuntimeException {
 
+	private final Target t;
 	String message;
 
 	public CancelCommandException(String message, Target t) {
-		super(t);
+		this.t = t;
 		this.message = message;
 	}
 
@@ -20,4 +20,18 @@ public String getMessage() {
 		return message;
 	}
 
+	/**
+	 * Returns the code target at which this cancel was triggered.
+	 *
+	 * @return
+	 */
+	public Target getTarget() {
+		return t;
+	}
+
+	@Override
+	public Throwable fillInStackTrace() {
+		return this;
+	}
+
 }
diff --git a/src/main/java/com/laytonsmith/core/exceptions/ConfigRuntimeException.java b/src/main/java/com/laytonsmith/core/exceptions/ConfigRuntimeException.java
index 02e315dd0c..02782c235d 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/FunctionReturnException.java b/src/main/java/com/laytonsmith/core/exceptions/FunctionReturnException.java
deleted file mode 100644
index e443ddf8d9..0000000000
--- a/src/main/java/com/laytonsmith/core/exceptions/FunctionReturnException.java
+++ /dev/null
@@ -1,22 +0,0 @@
-package com.laytonsmith.core.exceptions;
-
-import com.laytonsmith.core.constructs.Target;
-import com.laytonsmith.core.natives.interfaces.Mixed;
-
-/**
- *
- *
- */
-public class FunctionReturnException extends ProgramFlowManipulationException {
-
-	Mixed ret;
-
-	public FunctionReturnException(Mixed ret, Target t) {
-		super(t);
-		this.ret = ret;
-	}
-
-	public Mixed getReturn() {
-		return ret;
-	}
-}
diff --git a/src/main/java/com/laytonsmith/core/exceptions/LoopBreakException.java b/src/main/java/com/laytonsmith/core/exceptions/LoopBreakException.java
deleted file mode 100644
index c53f759156..0000000000
--- a/src/main/java/com/laytonsmith/core/exceptions/LoopBreakException.java
+++ /dev/null
@@ -1,14 +0,0 @@
-package com.laytonsmith.core.exceptions;
-
-import com.laytonsmith.core.constructs.Target;
-
-/**
- *
- *
- */
-public class LoopBreakException extends LoopManipulationException {
-
-	public LoopBreakException(int times, Target t) {
-		super(times, "break", t);
-	}
-}
diff --git a/src/main/java/com/laytonsmith/core/exceptions/LoopContinueException.java b/src/main/java/com/laytonsmith/core/exceptions/LoopContinueException.java
deleted file mode 100644
index baccd776f7..0000000000
--- a/src/main/java/com/laytonsmith/core/exceptions/LoopContinueException.java
+++ /dev/null
@@ -1,14 +0,0 @@
-package com.laytonsmith.core.exceptions;
-
-import com.laytonsmith.core.constructs.Target;
-
-/**
- *
- *
- */
-public class LoopContinueException extends LoopManipulationException {
-
-	public LoopContinueException(int times, Target t) {
-		super(times, "continue", t);
-	}
-}
diff --git a/src/main/java/com/laytonsmith/core/exceptions/LoopManipulationException.java b/src/main/java/com/laytonsmith/core/exceptions/LoopManipulationException.java
deleted file mode 100644
index f57d3c9638..0000000000
--- a/src/main/java/com/laytonsmith/core/exceptions/LoopManipulationException.java
+++ /dev/null
@@ -1,47 +0,0 @@
-package com.laytonsmith.core.exceptions;
-
-import com.laytonsmith.core.constructs.Target;
-
-/**
- * This is thrown by constructs like break and continue to indicate that a loop specific
- * ProgramFlowManipulationException is being thrown.
- */
-public abstract class LoopManipulationException extends ProgramFlowManipulationException {
-
-	private int times;
-	private final String name;
-
-	protected LoopManipulationException(int times, String name, Target t) {
-		super(t);
-		this.times = times;
-		this.name = name;
-	}
-
-	/**
-	 * Returns the number of times specified in the loop manipulation.
-	 *
-	 * @return
-	 */
-	public int getTimes() {
-		return times;
-	}
-
-	/**
-	 * Sets the number of times remaining in the loop manipulation. After handling an iteration, you should decrement
-	 * the number and set it here.
-	 *
-	 * @param number
-	 */
-	public void setTimes(int number) {
-		this.times = number;
-	}
-
-	/**
-	 * Returns the construct name that triggers this loop manipulation, i.e: break or continue.
-	 *
-	 * @return
-	 */
-	public String getName() {
-		return name;
-	}
-}
diff --git a/src/main/java/com/laytonsmith/core/exceptions/ProgramFlowManipulationException.java b/src/main/java/com/laytonsmith/core/exceptions/ProgramFlowManipulationException.java
deleted file mode 100644
index 11dbb737d4..0000000000
--- a/src/main/java/com/laytonsmith/core/exceptions/ProgramFlowManipulationException.java
+++ /dev/null
@@ -1,37 +0,0 @@
-package com.laytonsmith.core.exceptions;
-
-import com.laytonsmith.core.constructs.Target;
-
-/**
- * If an exception is meant to break the program flow in the script itself, it should extend this, so if an exception
- * passes all the way up to a top level handler, it can address it in a standard way if it doesn't know what to do with
- * these types of exceptions. Things like break, continue, etc are considered Program Flow Manipulations.
- *
- */
-public abstract class ProgramFlowManipulationException extends RuntimeException {
-
-	private final Target t;
-
-	/**
-	 *
-	 * @param t The target at which this program flow manipulation construct was defined.
-	 */
-	protected ProgramFlowManipulationException(Target t) {
-		this.t = t;
-	}
-
-	/**
-	 * Returns the code target at which this program flow manipulation construct was defined, so that if it was used
-	 * improperly, a full stacktrace can be shown.
-	 *
-	 * @return
-	 */
-	public Target getTarget() {
-		return t;
-	}
-
-	@Override
-	public Throwable fillInStackTrace() {
-		return this;
-	}
-}
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 0000000000..e33a161892
--- /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 8bab1f02fd..b088d00516 100644
--- a/src/main/java/com/laytonsmith/core/exceptions/StackTraceManager.java
+++ b/src/main/java/com/laytonsmith/core/exceptions/StackTraceManager.java
@@ -1,6 +1,11 @@
 package com.laytonsmith.core.exceptions;
 
+import com.laytonsmith.core.ArgumentValidation;
+import com.laytonsmith.core.constructs.CInt;
 import com.laytonsmith.core.constructs.Target;
+import com.laytonsmith.core.environments.GlobalEnv;
+import com.laytonsmith.core.exceptions.CRE.CREStackOverflowError;
+import com.laytonsmith.core.natives.interfaces.Mixed;
 import java.util.ArrayList;
 import java.util.Collections;
 import java.util.List;
@@ -11,38 +16,68 @@
  */
 public class StackTraceManager {
 
-	private final Stack<ConfigRuntimeException.StackTraceElement> elements = new Stack<>();
+	/**
+	 * The runtime setting key for configuring the maximum call depth.
+	 */
+	public static final String MAX_CALL_DEPTH_SETTING = "system.max_call_depth";
+
+	/**
+	 * The default maximum call depth. Can be overridden at runtime via the
+	 * {@code system.max_call_depth} runtime setting.
+	 */
+	public static final int DEFAULT_MAX_CALL_DEPTH = 1024;
+
+	private static final CInt DEFAULT_MAX_DEPTH_MIXED
+			= new CInt(DEFAULT_MAX_CALL_DEPTH, Target.UNKNOWN);
+
+	private final Stack<StackTraceFrame> elements = new Stack<>();
+	private final GlobalEnv gEnv;
 
 	/**
 	 * Creates a new, empty StackTraceManager object.
+	 *
+	 * @param gEnv The global environment, used to read runtime settings for the call depth limit.
 	 */
-	public StackTraceManager() {
-		//
+	public StackTraceManager(GlobalEnv gEnv) {
+		this.gEnv = gEnv;
 	}
 
 	/**
-	 * Adds a new stack trace trail
+	 * Adds a new stack trace element and checks the call depth against the configured maximum.
+	 * If the depth exceeds the limit, a {@link CREStackOverflowError} is thrown.
 	 *
 	 * @param element The element to be pushed on
 	 */
-	public void addStackTraceElement(ConfigRuntimeException.StackTraceElement element) {
+	public void addStackTraceFrame(StackTraceFrame element) {
+		Mixed setting = gEnv.GetRuntimeSetting(MAX_CALL_DEPTH_SETTING, DEFAULT_MAX_DEPTH_MIXED);
+		int maxDepth = ArgumentValidation.getInt32(setting, element.getDefinedAt(), null);
+		if(elements.size() >= maxDepth) {
+			throw new CREStackOverflowError("Stack overflow", element.getDefinedAt());
+		}
 		elements.add(element);
 	}
 
 	/**
 	 * Pops the top stack trace trail element off.
 	 */
-	public void popStackTraceElement() {
+	public void popStackTraceFrame() {
 		elements.pop();
 	}
 
+	/**
+	 * Clears all stack trace frames. Used primarily for test cleanup.
+	 */
+	public void clear() {
+		elements.clear();
+	}
+
 	/**
 	 * Returns a copy of the current element list.
 	 *
 	 * @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;
 	}
@@ -65,6 +100,15 @@ public boolean isStackSingle() {
 		return elements.size() == 1;
 	}
 
+	/**
+	 * Returns the current depth of the stack trace (the number of proc/closure frames currently active).
+	 *
+	 * @return The current stack depth
+	 */
+	public int getDepth() {
+		return elements.size();
+	}
+
 	/**
 	 * Sets the current element's target. This should be changed at every new element execution.
 	 *
@@ -76,4 +120,5 @@ public void setCurrentTarget(Target target) {
 		}
 	}
 
+
 }
diff --git a/src/main/java/com/laytonsmith/core/exceptions/UnhandledFlowControlException.java b/src/main/java/com/laytonsmith/core/exceptions/UnhandledFlowControlException.java
new file mode 100644
index 0000000000..dfd1c99f3c
--- /dev/null
+++ b/src/main/java/com/laytonsmith/core/exceptions/UnhandledFlowControlException.java
@@ -0,0 +1,27 @@
+package com.laytonsmith.core.exceptions;
+
+import com.laytonsmith.core.StepAction;
+
+/**
+ * Thrown by the iterative interpreter when a {@link StepAction.FlowControl} action
+ * propagates to the top of the stack without being handled by any frame. The top-level
+ * caller (e.g., {@code Script.run()}) catches this and dispatches based on the action
+ * type, matching the behavior of the old exception-based system.
+ */
+public class UnhandledFlowControlException extends RuntimeException {
+
+	private final StepAction.FlowControlAction action;
+
+	public UnhandledFlowControlException(StepAction.FlowControlAction action) {
+		this.action = action;
+	}
+
+	public StepAction.FlowControlAction getAction() {
+		return action;
+	}
+
+	@Override
+	public Throwable fillInStackTrace() {
+		return this;
+	}
+}
diff --git a/src/main/java/com/laytonsmith/core/functions/AbstractFunction.java b/src/main/java/com/laytonsmith/core/functions/AbstractFunction.java
index 26daa6c629..3b3fc7eec2 100644
--- a/src/main/java/com/laytonsmith/core/functions/AbstractFunction.java
+++ b/src/main/java/com/laytonsmith/core/functions/AbstractFunction.java
@@ -12,7 +12,6 @@
 import com.laytonsmith.core.LogLevel;
 import com.laytonsmith.core.MethodScriptCompiler;
 import com.laytonsmith.core.ParseTree;
-import com.laytonsmith.core.Script;
 import com.laytonsmith.core.SimpleDocumentation;
 import com.laytonsmith.core.compiler.FileOptions;
 import com.laytonsmith.core.compiler.SelfStatement;
@@ -24,7 +23,6 @@
 import com.laytonsmith.core.constructs.CClosure;
 import com.laytonsmith.core.constructs.CFunction;
 import com.laytonsmith.core.constructs.CString;
-import com.laytonsmith.core.constructs.CVoid;
 import com.laytonsmith.core.constructs.IVariable;
 import com.laytonsmith.core.constructs.IVariableList;
 import com.laytonsmith.core.constructs.Target;
@@ -58,22 +56,6 @@ protected AbstractFunction() {
 		shouldProfile = !this.getClass().isAnnotationPresent(noprofile.class);
 	}
 
-	/**
-	 * {@inheritDoc}
-	 *
-	 * By default, we return CVoid.
-	 *
-	 * @param t
-	 * @param env
-	 * @param parent
-	 * @param nodes
-	 * @return
-	 */
-	@Override
-	public Mixed execs(Target t, Environment env, Script parent, ParseTree... nodes) {
-		return CVoid.VOID;
-	}
-
 	/**
 	 * {@inheritDoc}
 	 * Calling {@link #getCachedSignatures()} where possible is preferred for runtime performance.
@@ -203,16 +185,6 @@ protected Scope linkScopeLazy(StaticAnalysis analysis, Scope parentScope,
 		return parentScope;
 	}
 
-	/**
-	 * By default, we return false, because most functions do not need this
-	 *
-	 * @return
-	 */
-	@Override
-	public boolean useSpecialExec() {
-		return false;
-	}
-
 	/**
 	 * Most functions should show up in the normal documentation. However, if this function shouldn't show up in the
 	 * documentation, it should mark itself with the @hide annotation.
@@ -297,7 +269,7 @@ public LogLevel profileAt() {
 	}
 
 	@Override
-	public String profileMessage(Mixed... args) {
+	public String profileMessage(Environment env, Mixed... args) {
 		StringBuilder b = new StringBuilder();
 		boolean first = true;
 		for(Mixed ccc : args) {
@@ -305,14 +277,14 @@ public String profileMessage(Mixed... args) {
 				b.append(", ");
 			}
 			first = false;
-			if(ccc.isInstanceOf(CArray.TYPE)) {
+			if(ccc.isInstanceOf(CArray.TYPE, null, env)) {
 				//Arrays take too long to toString, so we don't want to actually toString them here if
 				//we don't need to.
 				b.append("<arrayNotShown size:").append(((CArray) ccc).size()).append(">");
-			} else if(ccc.isInstanceOf(CClosure.TYPE)) {
+			} else if(ccc.isInstanceOf(CClosure.TYPE, null, env)) {
 				//The toString of a closure is too long, so let's not output them either.
 				b.append("<closureNotShown>");
-			} else if(ccc.isInstanceOf(CString.TYPE)) {
+			} else if(ccc.isInstanceOf(CString.TYPE, null, env)) {
 				String val = ccc.val().replace("\\", "\\\\").replace("'", "\\'");
 				int max = 1000;
 				if(val.length() > max) {
diff --git a/src/main/java/com/laytonsmith/core/functions/ArrayHandling.java b/src/main/java/com/laytonsmith/core/functions/ArrayHandling.java
index 2cdd7bf802..da19cca24f 100644
--- a/src/main/java/com/laytonsmith/core/functions/ArrayHandling.java
+++ b/src/main/java/com/laytonsmith/core/functions/ArrayHandling.java
@@ -11,10 +11,15 @@
 import com.laytonsmith.annotations.core;
 import com.laytonsmith.annotations.seealso;
 import com.laytonsmith.core.ArgumentValidation;
+import com.laytonsmith.core.CallbackYield;
+import com.laytonsmith.core.FlowFunction;
 import com.laytonsmith.core.MSVersion;
 import com.laytonsmith.core.Optimizable;
 import com.laytonsmith.core.ParseTree;
-import com.laytonsmith.core.Script;
+import com.laytonsmith.core.StepAction;
+import com.laytonsmith.core.StepAction.Complete;
+import com.laytonsmith.core.StepAction.Evaluate;
+import com.laytonsmith.core.StepAction.StepResult;
 import com.laytonsmith.core.compiler.FileOptions;
 import com.laytonsmith.core.compiler.analysis.StaticAnalysis;
 import com.laytonsmith.core.compiler.signature.FunctionSignatures;
@@ -33,6 +38,7 @@
 import com.laytonsmith.core.constructs.CVoid;
 import com.laytonsmith.core.constructs.Construct;
 import com.laytonsmith.core.constructs.Target;
+import com.laytonsmith.core.constructs.generics.GenericParameters;
 import com.laytonsmith.core.environments.Environment;
 import com.laytonsmith.core.environments.GlobalEnv;
 import com.laytonsmith.core.environments.StaticRuntimeEnv;
@@ -48,7 +54,6 @@
 import com.laytonsmith.core.exceptions.CancelCommandException;
 import com.laytonsmith.core.exceptions.ConfigCompileException;
 import com.laytonsmith.core.exceptions.ConfigRuntimeException;
-import com.laytonsmith.core.exceptions.ProgramFlowManipulationException;
 import com.laytonsmith.core.functions.BasicLogic.equals;
 import com.laytonsmith.core.functions.BasicLogic.equals_ic;
 import com.laytonsmith.core.functions.BasicLogic.sequals;
@@ -66,6 +71,7 @@
 import java.util.Random;
 import java.util.Set;
 import java.util.TreeSet;
+import java.util.function.BiConsumer;
 
 @core
 public class ArrayHandling {
@@ -90,14 +96,14 @@ public Integer[] numArgs() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment env, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			// TODO: It's far too late to deprecate this, but this method and length() are aliases, so
 			// we should at least harmonize the implementations.
 			if(args[0] instanceof Sizeable s) {
-				return new CInt(s.size(), t);
+				return new CInt(s.size(env), t);
 			}
-			if(args[0].isInstanceOf(CArray.TYPE) && !(args[0] instanceof CMutablePrimitive)) {
-				return new CInt(((CArray) args[0]).size(), t);
+			if(args[0].isInstanceOf(CArray.TYPE, null, env) && !(args[0] instanceof CMutablePrimitive)) {
+				return new CInt(((CArray) args[0]).size(env), t);
 			}
 			throw new CRECastException("Argument 1 of " + this.getName() + " must be an array", t);
 		}
@@ -166,7 +172,7 @@ public Integer[] numArgs() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment env, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			Mixed index;
 			Mixed defaultConstruct = null;
 			if(args.length >= 2) {
@@ -178,13 +184,13 @@ public Mixed exec(Target t, Environment env, Mixed... args) throws ConfigRuntime
 				defaultConstruct = args[2];
 			}
 
-			if(args[0].isInstanceOf(CArray.TYPE)) {
+			if(args[0].isInstanceOf(CArray.TYPE, null, env)) {
 				CArray ca = (CArray) args[0];
 				if(index instanceof CSlice) {
 
 					// Deep clone the array if the "index" is the initial one.
 					if(((CSlice) index).getStart() == 0 && ((CSlice) index).getFinish() == -1) {
-						return ca.deepClone(t);
+						return ca.deepClone(t, env);
 					} else if(ca.inAssociativeMode()) {
 						throw new CRECastException("Array slices are not allowed with an associative array", t);
 					}
@@ -195,29 +201,29 @@ public Mixed exec(Target t, Environment env, Mixed... args) throws ConfigRuntime
 					try {
 						//Convert negative indexes
 						if(start < 0) {
-							start = ca.size() + start;
+							start = ca.size(env) + start;
 							if(start < 0) {
 								throw new CREIndexOverflowException("The element at index \""
 										+ ((CSlice) index).getStart() + "\" does not exist", t);
 							}
 						}
 						if(finish < 0) {
-							finish = ca.size() + finish;
+							finish = ca.size(env) + finish;
 							if(finish < 0) {
 								throw new CREIndexOverflowException("The element at index \""
 										+ ((CSlice) index).getFinish() + "\" does not exist", t);
 							}
 						}
-						CArray na = ca.createNew(t);
+						CArray na = ca.createNew(t, env);
 						if(finish < start) {
 							//return an empty array in cases where the indexes don't make sense
 							return na;
 						}
 						for(long i = start; i <= finish; i++) {
 							try {
-								na.push(ca.get((int) i, t).clone(), t);
+								na.push(ca.get((int) i, t, env).clone(), t, env);
 							} catch(CloneNotSupportedException e) {
-								na.push(ca.get((int) i, t), t);
+								na.push(ca.get((int) i, t, env), t, env);
 							}
 						}
 						return na;
@@ -230,10 +236,10 @@ public Mixed exec(Target t, Environment env, Mixed... args) throws ConfigRuntime
 							if(index instanceof CNull) {
 								throw new CRECastException("Expected a number, but received null instead", t);
 							}
-							long iindex = ArgumentValidation.getInt(index, t);
+							long iindex = ArgumentValidation.getInt(index, t, env);
 							if(iindex < 0) {
 								//negative index, convert to positive index
-								iindex = ca.size() + iindex;
+								iindex = ca.size(env) + iindex;
 								if(iindex < 0) {
 									if(defaultConstruct != null) {
 										return defaultConstruct;
@@ -241,32 +247,32 @@ public Mixed exec(Target t, Environment env, Mixed... args) throws ConfigRuntime
 									throw new CREIndexOverflowException("The element at index \"" + index.val()
 											+ "\" does not exist", t);
 								}
-							} else if(defaultConstruct != null && iindex >= ca.size()) {
+							} else if(defaultConstruct != null && iindex >= ca.size(env)) {
 								return defaultConstruct;
 							}
-							return ca.get(iindex, t);
+							return ca.get(iindex, t, env);
 						} else {
 							if(defaultConstruct != null && !ca.containsKey(index.val())) {
 								return defaultConstruct;
 							}
-							return ca.get(index, t);
+							return ca.get(index, t, env);
 						}
 					} catch(ConfigRuntimeException e) {
 						if(env.getEnv(GlobalEnv.class).GetFlag(GlobalEnv.FLAG_ARRAY_SPECIAL_GET) != null) {
 							//They are asking for an array that doesn't exist yet, so let's create it now.
 							CArray c;
 							if(ca.inAssociativeMode()) {
-								c = CArray.GetAssociativeArray(t);
+								c = CArray.GetAssociativeArray(t, null, env);
 							} else {
 								c = new CArray(t);
 							}
-							ca.set(index, c, t);
+							ca.set(index, c, t, env);
 							return c;
 						}
 						throw e;
 					}
 				}
-			} else if(args[0].isInstanceOf(com.laytonsmith.core.natives.interfaces.Iterable.TYPE)) {
+			} else if(args[0].isInstanceOf(com.laytonsmith.core.natives.interfaces.Iterable.TYPE, null, env)) {
 				com.laytonsmith.core.natives.interfaces.Iterable aa
 						= (com.laytonsmith.core.natives.interfaces.Iterable) args[0];
 				if(index instanceof CSlice cSlice) {
@@ -276,19 +282,19 @@ public Mixed exec(Target t, Environment env, Mixed... args) throws ConfigRuntime
 					try {
 						//Convert negative indexes
 						if(start < 0) {
-							start = (int) aa.size() + start;
+							start = (int) aa.size(env) + start;
 						}
 						if(finish < 0) {
-							finish = (int) aa.size() + finish;
+							finish = (int) aa.size(env) + finish;
 						}
-						return aa.slice(start, finish + 1, t);
+						return aa.slice(start, finish + 1, t, env);
 					} catch(NumberFormatException e) {
 						throw new CRECastException("Ranges must be integer numbers, i.e., [0..5]", t);
 					}
-				} else if(index.isInstanceOf(CInt.TYPE)) {
-					return aa.get(ArgumentValidation.getInt32(index, t), t);
+				} else if(index.isInstanceOf(CInt.TYPE, null, env)) {
+					return aa.get(ArgumentValidation.getInt32(index, t, env), t, env);
 				} else {
-					return aa.get(index, t);
+					return aa.get(index, t, env);
 				}
 			} else {
 				throw new CRECastException("Argument 1 of " + this.getName() + " must be an Iterable object, such as an array.", t);
@@ -348,10 +354,10 @@ public Mixed optimize(Target t, Environment env, Mixed... args) throws ConfigCom
 			if(args.length == 0) {
 				throw new CRECastException("Argument 1 of " + this.getName() + " must be an array", t);
 			}
-			if(args[0].isInstanceOf(ArrayAccess.TYPE)) {
+			if(args[0].isInstanceOf(ArrayAccess.TYPE, null, env)) {
 				ArrayAccess aa = (ArrayAccess) args[0];
 				if(args.length > 1 && !aa.canBeAssociative()) {
-					if(!(args[1].isInstanceOf(CInt.TYPE)) && !(args[1] instanceof CSlice)) {
+					if(!(args[1].isInstanceOf(CInt.TYPE, null, env)) && !(args[1] instanceof CSlice)) {
 						throw new ConfigCompileException("Accessing an element as an associative array,"
 								+ " when it can only accept integers.", t);
 					}
@@ -386,7 +392,7 @@ public Set<OptimizationOption> optimizationOptions() {
 	@api
 	@seealso({array_get.class, array.class, array_push.class, com.laytonsmith.tools.docgen.templates.Arrays.class})
 	@OperatorPreferred("@array[@key] = @value")
-	public static class array_set extends AbstractFunction {
+	public static class array_set extends AbstractFunction implements FlowFunction<array_set.ArraySetState> {
 
 		public static final String NAME = "array_set";
 
@@ -400,39 +406,75 @@ public Integer[] numArgs() {
 			return new Integer[]{3};
 		}
 
-		@Override
-		public boolean useSpecialExec() {
-			return true;
+		static class ArraySetState {
+			enum Phase { EVAL_ARRAY, EVAL_INDEX, EVAL_VALUE }
+			Phase phase = Phase.EVAL_ARRAY;
+			ParseTree[] children;
+			Mixed array;
+			Mixed index;
+
+			ArraySetState(ParseTree[] children) {
+				this.children = children;
+			}
+
+			@Override
+			public String toString() {
+				return phase.name();
+			}
 		}
 
 		@Override
-		public Mixed execs(Target t, Environment env, Script parent, ParseTree... nodes) {
+		public StepResult<ArraySetState> begin(Target t, ParseTree[] children, Environment env) {
 			env.getEnv(GlobalEnv.class).SetFlag(GlobalEnv.FLAG_ARRAY_SPECIAL_GET, true);
-			Mixed array;
-			try {
-				array = parent.seval(nodes[0], env);
-			} finally {
-				env.getEnv(GlobalEnv.class).ClearFlag(GlobalEnv.FLAG_ARRAY_SPECIAL_GET);
-			}
-			Mixed index = parent.seval(nodes[1], env);
-			Mixed value = parent.seval(nodes[2], env);
-			if(!(array.isInstanceOf(ArrayAccessSet.TYPE))) {
-				throw new CRECastException("Argument 1 of " + this.getName() + " must be an array, or implement ArrayAccessSet.", t);
+			ArraySetState state = new ArraySetState(children);
+			return new StepResult<>(new Evaluate(children[0]), state);
+		}
+
+		@Override
+		public StepResult<ArraySetState> childCompleted(Target t, ArraySetState state,
+				Mixed result, Environment env) {
+			switch(state.phase) {
+				case EVAL_ARRAY:
+					env.getEnv(GlobalEnv.class).ClearFlag(GlobalEnv.FLAG_ARRAY_SPECIAL_GET);
+					state.array = result;
+					state.phase = ArraySetState.Phase.EVAL_INDEX;
+					return new StepResult<>(new Evaluate(state.children[1]), state);
+				case EVAL_INDEX:
+					state.index = result;
+					state.phase = ArraySetState.Phase.EVAL_VALUE;
+					return new StepResult<>(new Evaluate(state.children[2]), state);
+				case EVAL_VALUE:
+					if(!(state.array.isInstanceOf(ArrayAccessSet.TYPE, null, env))) {
+						throw new CRECastException("Argument 1 of " + getName()
+								+ " must be an array, or implement ArrayAccessSet.", t);
+					}
+					try {
+						((ArrayAccessSet) state.array).set(state.index, result, t, env);
+					} catch(IndexOutOfBoundsException e) {
+						throw new CREIndexOverflowException("The index "
+								+ new CString(state.index).getQuote() + " is out of bounds", t);
+					}
+					return new StepResult<>(new Complete(result), state);
+				default:
+					throw ConfigRuntimeException.CreateUncatchableException(
+							"Invalid array_set state: " + state.phase, t);
 			}
+		}
 
-			try {
-				((ArrayAccessSet) array).set(index, value, t);
-			} catch(IndexOutOfBoundsException e) {
-				throw new CREIndexOverflowException("The index " + new CString(index).getQuote() + " is out of bounds", t);
+		@Override
+		public StepResult<ArraySetState> childInterrupted(Target t, ArraySetState state,
+				StepAction.FlowControl action, Environment env) {
+			if(state.phase == ArraySetState.Phase.EVAL_ARRAY) {
+				env.getEnv(GlobalEnv.class).ClearFlag(GlobalEnv.FLAG_ARRAY_SPECIAL_GET);
 			}
-			return value;
+			return null;
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment env, Mixed... args) throws ConfigRuntimeException {
-			if(args[0].isInstanceOf(CArray.TYPE)) {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
+			if(args[0].isInstanceOf(CArray.TYPE, null, env)) {
 				try {
-					((CArray) args[0]).set(args[1], args[2], t);
+					((CArray) args[0]).set(args[1], args[2], t, env);
 				} catch(IndexOutOfBoundsException e) {
 					throw new CREIndexOverflowException("The index " + args[1].val() + " is out of bounds", t);
 				}
@@ -514,16 +556,16 @@ public Integer[] numArgs() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment env, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			if(args.length < 2) {
 				throw new CREInsufficientArgumentsException(
 						"At least 2 arguments must be provided to " + this.getName(), t);
 			}
-			if(args[0].isInstanceOf(CArray.TYPE)) {
+			if(args[0].isInstanceOf(CArray.TYPE, null, env)) {
 				CArray array = (CArray) args[0];
-				int initialSize = (int) array.size();
+				int initialSize = (int) array.size(env);
 				for(int i = 1; i < args.length; i++) {
-					array.push(args[i], t);
+					array.push(args[i], t, env);
 					for(Iterator iterator : env.getEnv(GlobalEnv.class).GetArrayAccessIteratorsFor(((ArrayAccess) args[0]))) {
 						//This is always pushing after the current index.
 						//Given that this is the last one, we don't need to waste
@@ -616,15 +658,15 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
-			CArray array = ArgumentValidation.getArray(args[0], t);
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
+			CArray array = ArgumentValidation.getArray(args[0], t, env);
 			Mixed value = args[1];
-			int index = ArgumentValidation.getInt32(args[2], t);
+			int index = ArgumentValidation.getInt32(args[2], t, env);
 			try {
-				array.push(value, index, t);
+				array.push(value, index, t, env);
 				//If the push succeeded (actually an insert) we need to check to see if we are currently iterating
 				//and act appropriately.
-				for(Iterator iterator : environment.getEnv(GlobalEnv.class).GetArrayAccessIteratorsFor(array)) {
+				for(Iterator iterator : env.getEnv(GlobalEnv.class).GetArrayAccessIteratorsFor(array)) {
 					if(index <= iterator.getCurrent()) {
 						//The insertion happened before (or at) this index, so we need to increment the
 						//iterator, as well as increment all the blacklist items above this one.
@@ -709,16 +751,16 @@ public Integer[] numArgs() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment env, Mixed... args) throws CancelCommandException, ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws CancelCommandException, ConfigRuntimeException {
 			ArrayAccess aa;
 			if(args[0] instanceof ArrayAccess) {
 				aa = (ArrayAccess) args[0];
 			} else {
-				CArray ca = ArgumentValidation.getArray(args[0], t);
+				CArray ca = ArgumentValidation.getArray(args[0], t, env);
 				aa = ca;
 			}
-			for(Mixed key : aa.keySet()) {
-				if(new equals().exec(t, env, aa.get(key, t), args[1]).getBoolean()) {
+			for(Mixed key : aa.keySet(env)) {
+				if(new equals().exec(t, env, null, aa.get(key, t, env), args[1]).getBoolean()) {
 					return CBoolean.TRUE;
 				}
 			}
@@ -820,15 +862,15 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			ArrayAccess aa;
 			if(args[0] instanceof ArrayAccess a) {
 				aa = a;
 			} else {
-				aa = ArgumentValidation.getArray(args[0], t);
+				aa = ArgumentValidation.getArray(args[0], t, env);
 			}
-			for(Mixed key : aa.keySet()) {
-				if(new equals_ic().exec(t, environment, aa.get(key, t), args[1]).getBoolean()) {
+			for(Mixed key : aa.keySet(env)) {
+				if(new equals_ic().exec(t, env, null, aa.get(key, t, env), args[1]).getBoolean()) {
 					return CBoolean.TRUE;
 				}
 			}
@@ -874,15 +916,15 @@ public Integer[] numArgs() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment env, Mixed... args) throws CancelCommandException, ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws CancelCommandException, ConfigRuntimeException {
 			ArrayAccess aa;
 			if(args[0] instanceof ArrayAccess a) {
 				aa = a;
 			} else {
-				aa = ArgumentValidation.getArray(args[0], t);
+				aa = ArgumentValidation.getArray(args[0], t, env);
 			}
-			for(Mixed key : aa.keySet()) {
-				if(new sequals().exec(t, env, aa.get(key, t), args[1]).getBoolean()) {
+			for(Mixed key : aa.keySet(env)) {
+				if(new sequals().exec(t, env, null, aa.get(key, t, env), args[1]).getBoolean()) {
 					return CBoolean.TRUE;
 				}
 			}
@@ -990,18 +1032,18 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment env, Mixed... args) throws ConfigRuntimeException {
-			if(args[0].isInstanceOf(CArray.TYPE)) {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
+			if(args[0].isInstanceOf(CArray.TYPE, null, env)) {
 				Mixed m = args[0];
 				for(int i = 1; i < args.length; i++) {
-					if(!(m.isInstanceOf(CArray.TYPE))) {
+					if(!(m.isInstanceOf(CArray.TYPE, null, env))) {
 						return CBoolean.FALSE;
 					}
 					CArray ca = (CArray) m;
 					if(!ca.inAssociativeMode()) {
 						try {
-							int index = ArgumentValidation.getInt32(args[i], t);
-							if(index >= ca.size() || index < 0) {
+							int index = ArgumentValidation.getInt32(args[i], t, env);
+							if(index >= ca.size(env) || index < 0) {
 								return CBoolean.FALSE;
 							}
 						} catch(ConfigRuntimeException e) {
@@ -1013,7 +1055,7 @@ public Mixed exec(Target t, Environment env, Mixed... args) throws ConfigRuntime
 							return CBoolean.FALSE;
 						}
 					}
-					m = ca.get(args[i], t);
+					m = ca.get(args[i], t, env);
 				}
 				return CBoolean.TRUE;
 			} else {
@@ -1109,16 +1151,16 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public CArray exec(Target t, Environment env, Mixed... args) throws ConfigRuntimeException {
-			if(args[0].isInstanceOf(CArray.TYPE) && args[1].isInstanceOf(CInt.TYPE)) {
+		public CArray exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
+			if(args[0].isInstanceOf(CArray.TYPE, null, env) && args[1].isInstanceOf(CInt.TYPE, null, env)) {
 				CArray original = (CArray) args[0];
 				int size = (int) ((CInt) args[1]).getInt();
 				Mixed fill = CNull.NULL;
 				if(args.length == 3) {
 					fill = args[2];
 				}
-				for(long i = original.size(); i < size; i++) {
-					original.push(fill, t);
+				for(long i = original.size(env); i < size; i++) {
+					original.push(fill, t, env);
 				}
 			} else {
 				throw new CRECastException(
@@ -1198,26 +1240,26 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public CArray exec(Target t, Environment env, Mixed... args) throws ConfigRuntimeException {
+		public CArray exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			long start = 0;
 			long finish = 0;
 			long increment = 1;
 			if(args.length == 1) {
-				finish = ArgumentValidation.getInt(args[0], t);
+				finish = ArgumentValidation.getInt(args[0], t, env);
 			} else if(args.length == 2) {
-				start = ArgumentValidation.getInt(args[0], t);
-				finish = ArgumentValidation.getInt(args[1], t);
+				start = ArgumentValidation.getInt(args[0], t, env);
+				finish = ArgumentValidation.getInt(args[1], t, env);
 			} else if(args.length == 3) {
-				start = ArgumentValidation.getInt(args[0], t);
-				finish = ArgumentValidation.getInt(args[1], t);
-				increment = ArgumentValidation.getInt(args[2], t);
+				start = ArgumentValidation.getInt(args[0], t, env);
+				finish = ArgumentValidation.getInt(args[1], t, env);
+				increment = ArgumentValidation.getInt(args[2], t, env);
 			}
 			if(start < finish && increment < 0 || start > finish && increment > 0 || increment == 0) {
-				return new CArray(t);
+				return new CArray(t, null, env);
 			}
 			CArray ret = new CArray(t);
 			for(long i = start; (increment > 0 ? i < finish : i > finish); i = i + increment) {
-				ret.push(new CInt(i, t), t);
+				ret.push(new CInt(i, t), t, env);
 			}
 			return ret;
 		}
@@ -1279,13 +1321,13 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment env, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			// As an exception, strings aren't supported here. There's no reason to do this for a string that isn't accidental.
-			if(args[0].isInstanceOf(ArrayAccess.TYPE) && !(args[0].isInstanceOf(CString.TYPE))) {
+			if(args[0].isInstanceOf(ArrayAccess.TYPE, null, env) && !(args[0].isInstanceOf(CString.TYPE, null, env))) {
 				ArrayAccess ca = (ArrayAccess) args[0];
 				CArray ca2 = new CArray(t);
-				for(Mixed c : ca.keySet()) {
-					ca2.push(c, t);
+				for(Mixed c : ca.keySet(env)) {
+					ca2.push(c, t, env);
 				}
 				return ca2;
 			} else {
@@ -1346,12 +1388,12 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment env, Mixed... args) throws ConfigRuntimeException {
-			if(args[0].isInstanceOf(CArray.TYPE)) {
-				CArray ca = ArgumentValidation.getArray(args[0], t);
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
+			if(args[0].isInstanceOf(CArray.TYPE, null, env)) {
+				CArray ca = ArgumentValidation.getArray(args[0], t, env);
 				CArray ca2 = new CArray(t);
-				for(Mixed c : ca.keySet()) {
-					ca2.push(ca.get(c, t), t);
+				for(Mixed c : ca.keySet(env)) {
+					ca2.push(ca.get(c, t, env), t, env);
 				}
 				return ca2;
 			} else {
@@ -1414,25 +1456,25 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			CArray newArray = new CArray(t);
 			if(args.length < 2) {
 				throw new CREInsufficientArgumentsException("array_merge must be called with at least two parameters", t);
 			}
 			for(Mixed arg : args) {
-				if(arg.isInstanceOf(ArrayAccess.TYPE)) {
+				if(arg.isInstanceOf(ArrayAccess.TYPE, null, env)) {
 					com.laytonsmith.core.natives.interfaces.Iterable cur
 							= (com.laytonsmith.core.natives.interfaces.Iterable) arg;
 					if(!cur.isAssociative()) {
-						for(int j = 0; j < cur.size(); j++) {
-							newArray.push(cur.get(j, t), t);
+						for(int j = 0; j < cur.size(env); j++) {
+							newArray.push(cur.get(j, t, env), t, env);
 						}
 					} else {
-						for(Mixed key : cur.keySet()) {
-							if(key.isInstanceOf(CInt.TYPE)) {
-								newArray.set(key, cur.get((int) ((CInt) key).getInt(), t), t);
+						for(Mixed key : cur.keySet(env)) {
+							if(key.isInstanceOf(CInt.TYPE, null, env)) {
+								newArray.set(key, cur.get((int) ((CInt) key).getInt(), t, env), t, env);
 							} else {
-								newArray.set(key, cur.get(key.val(), t), t);
+								newArray.set(key, cur.get(key.val(), t, env), t, env);
 							}
 						}
 					}
@@ -1500,15 +1542,15 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
-			CArray array = ArgumentValidation.getArray(args[0], t);
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
+			CArray array = ArgumentValidation.getArray(args[0], t, env);
 			if(array.isAssociative()) {
-				return array.remove(args[1]);
+				return array.remove(args[1], env);
 			} else {
-				int index = ArgumentValidation.getInt32(args[1], t);
-				Mixed removed = array.remove(args[1]);
+				int index = ArgumentValidation.getInt32(args[1], t, env);
+				Mixed removed = array.remove(args[1], env);
 				//If the removed index is <= the current index, we need to decrement the counter.
-				for(Iterator iterator : environment.getEnv(GlobalEnv.class).GetArrayAccessIteratorsFor(array)) {
+				for(Iterator iterator : env.getEnv(GlobalEnv.class).GetArrayAccessIteratorsFor(array)) {
 					if(index <= iterator.getCurrent()) {
 						iterator.decrementCurrent();
 					}
@@ -1564,8 +1606,8 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
-			if(!(args[0].isInstanceOf(ArrayAccess.TYPE))) {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
+			if(!(args[0].isInstanceOf(ArrayAccess.TYPE, null, env))) {
 				throw new CRECastException("Expecting argument 1 to be an ArrayAccess type object", t);
 			}
 			StringBuilder b = new StringBuilder();
@@ -1575,8 +1617,8 @@ public Mixed exec(Target t, Environment environment, Mixed... args) throws Confi
 				glue = ArgumentValidation.getObject(args[1], t, CPrimitive.class).val();
 			}
 			boolean first = true;
-			for(Mixed key : ca.keySet()) {
-				Mixed value = ca.get(key, t);
+			for(Mixed key : ca.keySet(env)) {
+				Mixed value = ca.get(key, t, env);
 				if(!first) {
 					b.append(glue).append(value.val());
 				} else {
@@ -1620,8 +1662,8 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
-			CArray array = ArgumentValidation.getArray(args[0], t);
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
+			CArray array = ArgumentValidation.getArray(args[0], t, env);
 			String innerGlue = ArgumentValidation.getString(args[1], t);
 			String outerGlue = ArgumentValidation.getString(args[2], t);
 			if(!array.isAssociative()) {
@@ -1631,8 +1673,8 @@ public Mixed exec(Target t, Environment environment, Mixed... args) throws Confi
 			StringBuilder b = new StringBuilder();
 
 			boolean first = true;
-			for(Mixed key : array.keySet()) {
-				Mixed value = array.get(key, t);
+			for(Mixed key : array.keySet(env)) {
+				Mixed value = array.get(key, t, env);
 				if(!first) {
 					b.append(outerGlue);
 				}
@@ -1713,8 +1755,8 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
-			return new CSlice(ArgumentValidation.getInt(args[0], t), ArgumentValidation.getInt(args[1], t), t);
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
+			return new CSlice(ArgumentValidation.getInt(args[0], t, env), ArgumentValidation.getInt(args[1], t, env), t);
 		}
 
 		@Override
@@ -1736,7 +1778,7 @@ public Set<OptimizationOption> optimizationOptions() {
 	}
 
 	@api
-	public static class array_sort extends AbstractFunction implements Optimizable {
+	public static class array_sort extends CallbackYield implements Optimizable {
 
 		@Override
 		public Class<? extends CREThrowable>[] thrown() {
@@ -1754,19 +1796,20 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
-			if(!(args[0].isInstanceOf(CArray.TYPE))) {
+		protected void execWithYield(Target t, Environment env, Mixed[] args, CallbackYield.Yield yield) {
+			if(!(args[0].isInstanceOf(CArray.TYPE, null, env))) {
 				throw new CRECastException("The first parameter to array_sort must be an array", t);
 			}
 			CArray ca = (CArray) args[0];
 			CArray.ArraySortType sortType = CArray.ArraySortType.REGULAR;
 			CClosure customSort = null;
-			if(ca.size() <= 1) {
-				return ca;
+			if(ca.size(env) <= 1) {
+				yield.done(() -> ca);
+				return;
 			}
 			try {
 				if(args.length == 2) {
-					if(args[1].isInstanceOf(CClosure.TYPE)) {
+					if(args[1].isInstanceOf(CClosure.TYPE, null, env)) {
 						sortType = null;
 						customSort = (CClosure) args[1];
 					} else {
@@ -1777,83 +1820,124 @@ public Mixed exec(Target t, Environment environment, Mixed... args) throws Confi
 				throw new CREFormatException("The sort type must be one of either: " + StringUtils.Join(CArray.ArraySortType.values(), ", ", " or "), t);
 			}
 			if(sortType == null) {
-				// It's a custom sort, which we have implemented below.
 				if(ca.isAssociative()) {
 					throw new CRECastException("Associative arrays may not be sorted using a custom comparator.", t);
 				}
-				CArray sorted = customSort(ca, customSort, t);
-				//Clear it out and re-apply the values, so this is in place.
-				ca.clear();
-				for(Mixed c : sorted.keySet()) {
-					ca.set(c, sorted.get(c, t), t);
+				// Copy elements into a working list for bottom-up merge sort
+				int n = (int) ca.size(env);
+				Mixed[] work = new Mixed[n];
+				for(int i = 0; i < n; i++) {
+					work[i] = ca.get(i, t, env);
 				}
+				// Queue the first merge comparison
+				queueMergeSort(customSort, env, t, work, ca, yield);
 			} else {
-				ca.sort(sortType);
-			}
-			return ca;
-		}
-
-		private CArray customSort(CArray ca, CClosure closure, Target t) {
-			if(ca.size() <= 1) {
-				return ca;
-			}
-
-			CArray left = new CArray(t);
-			CArray right = new CArray(t);
-			int middle = (int) (ca.size() / 2);
-			for(int i = 0; i < middle; i++) {
-				left.push(ca.get(i, t), t);
-			}
-			for(int i = middle; i < ca.size(); i++) {
-				right.push(ca.get(i, t), t);
-			}
-
-			left = customSort(left, closure, t);
-			right = customSort(right, closure, t);
-
-			return merge(left, right, closure, t);
-		}
-
-		private CArray merge(CArray left, CArray right, CClosure closure, Target t) {
-			CArray result = new CArray(t);
-			while(left.size() > 0 || right.size() > 0) {
-				if(left.size() > 0 && right.size() > 0) {
-					// Compare the first two elements of each side
-					Mixed l = left.get(0, t);
-					Mixed r = right.get(0, t);
-					Mixed c = closure.executeCallable(null, t, l, r);
-					int value;
-					if(c instanceof CNull) {
-						value = 0;
-					} else if(c.isInstanceOf(CBoolean.TYPE)) {
-						if(((CBoolean) c).getBoolean()) {
-							value = 1;
+				ca.sort(sortType, env);
+			}
+			yield.done(() -> ca);
+		}
+
+		/**
+		 * Implements a bottom-up merge sort using yield steps. Each element comparison
+		 * is a closure call that yields to the eval loop.
+		 */
+		private void queueMergeSort(CClosure closure, Environment env, Target t,
+				Mixed[] work, CArray ca, CallbackYield.Yield yield) {
+			int n = work.length;
+			// State: width doubles each pass (1, 2, 4, ...), i is the start of each merge block
+			int[] width = {1};
+			int[] i = {0};
+			// left/right pointers within the current merge
+			int[] l = {0};
+			int[] r = {0};
+			int[] lEnd = {0};
+			int[] rEnd = {0};
+			Mixed[] aux = new Mixed[n];
+
+			// Set up initial merge block
+			Runnable[] setupNextMerge = new Runnable[1];
+			setupNextMerge[0] = () -> {
+				while(width[0] < n) {
+					if(i[0] < n) {
+						l[0] = i[0];
+						lEnd[0] = java.lang.Math.min(i[0] + width[0], n);
+						r[0] = lEnd[0];
+						rEnd[0] = java.lang.Math.min(i[0] + 2 * width[0], n);
+						i[0] += 2 * width[0];
+						if(r[0] < rEnd[0]) {
+							// This merge block has elements on both sides; need comparisons
+							return;
 						} else {
-							value = -1;
+							// Only left side has elements, just copy them
+							for(int k = l[0]; k < lEnd[0]; k++) {
+								aux[k] = work[k];
+							}
+							continue;
 						}
-					} else if(c.isInstanceOf(CInt.TYPE)) {
-						long longVal = ((CInt) c).getInt();
-						value = (longVal > 0 ? 1 : (longVal < 0 ? -1 : 0));
-					} else {
-						throw new CRECastException("The custom closure did not return a value (or returned an invalid"
-								+ " type). It must always return true, false, null, or an integer.", t);
 					}
-					if(value <= 0) {
-						result.push(left.get(0, t), t);
-						left.remove(0);
-					} else {
-						result.push(right.get(0, t), t);
-						right.remove(0);
+					// Finished a pass — copy aux back to work and start next width
+					System.arraycopy(aux, 0, work, 0, n);
+					width[0] *= 2;
+					i[0] = 0;
+				}
+				// Sort complete — write results back to the CArray
+				ca.clear();
+				for(int k = 0; k < n; k++) {
+					ca.push(work[k], t, env);
+				}
+			};
+
+			// Recursive step that drives the merge comparison
+			BiConsumer<Mixed, CallbackYield.Yield>[] mergeStep = new BiConsumer[1];
+			mergeStep[0] = (result, y) -> {
+				int value = parseCompareResult(result, t, env);
+				if(value <= 0) {
+					aux[l[0] + r[0] - lEnd[0]] = work[l[0]];
+					l[0]++;
+				} else {
+					aux[l[0] + r[0] - lEnd[0]] = work[r[0]];
+					r[0]++;
+				}
+				// Continue merging this block
+				if(l[0] < lEnd[0] && r[0] < rEnd[0]) {
+					y.call(closure, env, t, work[l[0]], work[r[0]]).then(mergeStep[0]);
+				} else {
+					// One side exhausted — copy remainder
+					while(l[0] < lEnd[0]) {
+						aux[l[0] + r[0] - lEnd[0]] = work[l[0]];
+						l[0]++;
+					}
+					while(r[0] < rEnd[0]) {
+						aux[l[0] + r[0] - lEnd[0]] = work[r[0]];
+						r[0]++;
+					}
+					// Move to next merge block
+					setupNextMerge[0].run();
+					if(width[0] < n) {
+						y.call(closure, env, t, work[l[0]], work[r[0]]).then(mergeStep[0]);
 					}
-				} else if(left.size() > 0) {
-					result.push(left.get(0, t), t);
-					left.remove(0);
-				} else if(right.size() > 0) {
-					result.push(right.get(0, t), t);
-					right.remove(0);
 				}
+			};
+
+			// Kick off the first comparison
+			setupNextMerge[0].run();
+			if(width[0] < n) {
+				yield.call(closure, env, t, work[l[0]], work[r[0]]).then(mergeStep[0]);
+			}
+		}
+
+		private int parseCompareResult(Mixed c, Target t, Environment env) {
+			if(c instanceof CNull) {
+				return 0;
+			} else if(c instanceof CBoolean) {
+				return ((CBoolean) c).getBoolean() ? 1 : -1;
+			} else if(c.isInstanceOf(CInt.TYPE, null, env)) {
+				long longVal = ((CInt) c).getInt();
+				return (longVal > 0 ? 1 : (longVal < 0 ? -1 : 0));
+			} else {
+				throw new CRECastException("The custom closure did not return a value (or returned an invalid"
+						+ " type). It must always return true, false, null, or an integer.", t);
 			}
-			return result;
 		}
 
 		@Override
@@ -1991,17 +2075,17 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			startup();
-			final CArray array = ArgumentValidation.getArray(args[0], t);
+			final CArray array = ArgumentValidation.getArray(args[0], t, env);
 			final CString sortType = new CString(args.length > 2 ? args[1].val() : CArray.ArraySortType.REGULAR.name(), t);
 			final CClosure callback = ArgumentValidation.getObject((args.length == 2 ? args[1] : args[2]), t, CClosure.class);
-			queue.invokeLater(environment.getEnv(StaticRuntimeEnv.class).GetDaemonManager(), new Runnable() {
+			queue.invokeLater(env.getEnv(StaticRuntimeEnv.class).GetDaemonManager(), new Runnable() {
 
 				@Override
 				public void run() {
-					Mixed c = new array_sort().exec(Target.UNKNOWN, null, array, sortType);
-					callback.executeCallable(environment, t, new Mixed[]{c});
+					Mixed c = new array_sort().exec(Target.UNKNOWN, null, null, array, sortType);
+					callback.executeCallable(env, t, new Mixed[]{c});
 				}
 			});
 			return CVoid.VOID;
@@ -2051,17 +2135,17 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
-			CArray array = ArgumentValidation.getArray(args[0], t);
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
+			CArray array = ArgumentValidation.getArray(args[0], t, env);
 			//This needs to be in terms of array_remove, to ensure that the iteration
 			//logic is followed. We will iterate backwards, however, to make the
 			//process more efficient, unless this is an associative array.
 			if(array.isAssociative()) {
 				array.removeValues(args[1]);
 			} else {
-				for(long i = array.size() - 1; i >= 0; i--) {
-					if(BasicLogic.equals.doEquals(array.get(i, t), args[1])) {
-						new array_remove().exec(t, environment, array, new CInt(i, t));
+				for(long i = array.size(env) - 1; i >= 0; i--) {
+					if(BasicLogic.equals.doEquals(array.get(i, t, env), args[1])) {
+						new array_remove().exec(t, env, null, array, new CInt(i, t));
 					}
 				}
 			}
@@ -2120,11 +2204,11 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
-			if(!(args[0].isInstanceOf(CArray.TYPE))) {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
+			if(!(args[0].isInstanceOf(CArray.TYPE, null, env))) {
 				throw new CRECastException("Expected parameter 1 to be an array, but was " + args[0].val(), t);
 			}
-			return ((CArray) args[0]).indexesOf(args[1]);
+			return ((CArray) args[0]).indexesOf(args[1], env);
 		}
 
 		@Override
@@ -2183,12 +2267,12 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
-			CArray ca = (CArray) new array_indexes().exec(t, environment, args);
-			if(ca.isEmpty()) {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
+			CArray ca = (CArray) new array_indexes().exec(t, env, generics, args);
+			if(ca.isEmpty(env)) {
 				return CNull.NULL;
 			} else {
-				return ca.get(0, t);
+				return ca.get(0, t, env);
 			}
 		}
 
@@ -2242,12 +2326,12 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
-			CArray ca = (CArray) new array_indexes().exec(t, environment, args);
-			if(ca.isEmpty()) {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
+			CArray ca = (CArray) new array_indexes().exec(t, env, generics, args);
+			if(ca.isEmpty(env)) {
 				return CNull.NULL;
 			} else {
-				return ca.get(ca.size() - 1, t);
+				return ca.get(ca.size(env) - 1, t, env);
 			}
 		}
 
@@ -2301,8 +2385,8 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
-			if(args[0].isInstanceOf(CArray.TYPE)) {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
+			if(args[0].isInstanceOf(CArray.TYPE, null, env)) {
 				((CArray) args[0]).reverse(t);
 			}
 			return args[0];
@@ -2361,37 +2445,37 @@ public Boolean runAsync() {
 		Random r = new Random(System.currentTimeMillis());
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			long number = 1;
 			boolean getKeys = true;
-			CArray array = ArgumentValidation.getArray(args[0], t);
+			CArray array = ArgumentValidation.getArray(args[0], t, env);
 			CArray newArray = new CArray(t);
-			if(array.isEmpty()) {
+			if(array.isEmpty(env)) {
 				return newArray;
 			}
 			if(args.length > 1) {
-				number = ArgumentValidation.getInt(args[1], t);
+				number = ArgumentValidation.getInt(args[1], t, env);
 			}
 			if(number < 1) {
 				throw new CRERangeException("number may not be less than 1.", t);
 			}
-			if(number > array.size()) {
+			if(number > array.size(env)) {
 				throw new CRERangeException("Number cannot be larger than array size", t);
 			}
 			if(args.length > 2) {
-				getKeys = ArgumentValidation.getBoolean(args[2], t);
+				getKeys = ArgumentValidation.getBooleanObject(args[2], t, env);
 			}
 
 			LinkedHashSet<Integer> randoms = new LinkedHashSet<>();
 			while(randoms.size() < number) {
-				randoms.add(java.lang.Math.abs(r.nextInt() % (int) array.size()));
+				randoms.add(java.lang.Math.abs(r.nextInt() % (int) array.size(env)));
 			}
-			List<Mixed> keySet = new ArrayList<>(array.keySet());
+			List<Mixed> keySet = new ArrayList<>(array.keySet(env));
 			for(Integer i : randoms) {
 				if(getKeys) {
-					newArray.push(keySet.get(i), t);
+					newArray.push(keySet.get(i), t, env);
 				} else {
-					newArray.push(array.get(keySet.get(i), t), t);
+					newArray.push(array.get(keySet.get(i), t, env), t, env);
 				}
 			}
 			return newArray;
@@ -2466,28 +2550,28 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public CArray exec(final Target t, final Environment environment, Mixed... args) throws ConfigRuntimeException {
-			CArray array = ArgumentValidation.getArray(args[0], t);
+		public CArray exec(final Target t, final Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
+			CArray array = ArgumentValidation.getArray(args[0], t, env);
 			boolean compareTypes = true;
 			if(args.length == 2) {
-				compareTypes = ArgumentValidation.getBoolean(args[1], t);
+				compareTypes = ArgumentValidation.getBooleanObject(args[1], t, env);
 			}
 			final boolean fCompareTypes = compareTypes;
 			if(array.inAssociativeMode()) {
 				return array.clone();
 			} else {
-				List<Mixed> asList = array.asList();
+				List<Mixed> asList = array.asList(env);
 				CArray newArray = new CArray(t);
 				Set<Mixed> set = new LinkedComparatorSet<>(asList, new LinkedComparatorSet.EqualsComparator<Mixed>() {
 
 					@Override
 					public boolean checkIfEquals(Mixed item1, Mixed item2) {
-						return (fCompareTypes && ArgumentValidation.getBoolean(sequals.exec(t, environment, item1, item2), t))
-								|| (!fCompareTypes && ArgumentValidation.getBoolean(equals.exec(t, environment, item1, item2), t));
+						return (fCompareTypes && ArgumentValidation.getBooleanObject(sequals.exec(t, env, null, item1, item2), t, env))
+								|| (!fCompareTypes && ArgumentValidation.getBooleanObject(equals.exec(t, env, null, item1, item2), t, env));
 					}
 				});
 				for(Mixed c : set) {
-					newArray.push(c, t);
+					newArray.push(c, t, env);
 				}
 				return newArray;
 			}
@@ -2535,7 +2619,7 @@ public Set<OptimizationOption> optimizationOptions() {
 	}
 
 	@api
-	public static class array_filter extends AbstractFunction {
+	public static class array_filter extends CallbackYield {
 
 		@Override
 		public Class<? extends CREThrowable>[] thrown() {
@@ -2553,44 +2637,48 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
+		protected void execWithYield(Target t, Environment env, Mixed[] args, CallbackYield.Yield yield) {
 			com.laytonsmith.core.natives.interfaces.Iterable array;
 			CClosure closure;
 			if(!(args[0] instanceof com.laytonsmith.core.natives.interfaces.Iterable)) {
 				throw new CRECastException("Expecting an array for argument 1", t);
 			}
-			if(!(args[1].isInstanceOf(CClosure.TYPE))) {
+			if(!(args[1].isInstanceOf(CClosure.TYPE, null, env))) {
 				throw new CRECastException("Expecting a closure for argument 2", t);
 			}
 			array = (com.laytonsmith.core.natives.interfaces.Iterable) args[0];
 			closure = (CClosure) args[1];
 			CArray newArray;
 			if(array.isAssociative()) {
-				newArray = CArray.GetAssociativeArray(t);
-				for(Mixed key : array.keySet()) {
-					Mixed value = array.get(key, t);
-					Mixed ret = closure.executeCallable(environment, t, key, value);
-					boolean bret = ArgumentValidation.getBooleanish(ret, t);
-					if(bret) {
-						newArray.set(key, value, t);
-					}
+				newArray = CArray.GetAssociativeArray(t, null, env);
+				for(Mixed key : array.keySet(env)) {
+					Mixed value = array.get(key, t, env);
+					yield.call(closure, env, t, key, value)
+							.then((result, y) -> {
+								boolean bret = ArgumentValidation.getBooleanish(result, t, env);
+								if(bret) {
+									newArray.set(key, value, t, env);
+								}
+							});
 				}
 			} else {
 				newArray = new CArray(t);
-				for(int i = 0; i < array.size(); i++) {
-					Mixed key = new CInt(i, t);
-					Mixed value = array.get(i, t);
-					Mixed ret = closure.executeCallable(environment, t, key, value);
-					if(ret == CNull.NULL) {
-						ret = CBoolean.FALSE;
-					}
-					boolean bret = ArgumentValidation.getBooleanish(ret, t);
-					if(bret) {
-						newArray.push(value, t);
-					}
+				for(int i = 0; i < array.size(env); i++) {
+					Mixed value = array.get(i, t, env);
+					yield.call(closure, env, t, new CInt(i, t), value)
+							.then((result, y) -> {
+								Mixed r = result;
+								if(r == CNull.NULL) {
+									r = CBoolean.FALSE;
+								}
+								boolean bret = ArgumentValidation.getBooleanish(r, t, env);
+								if(bret) {
+									newArray.push(value, t, env);
+								}
+							});
 				}
 			}
-			return newArray;
+			yield.done(() -> newArray);
 		}
 
 		@Override
@@ -2656,14 +2744,14 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			if(args.length != 1) {
 				throw new CREInsufficientArgumentsException("Expecting exactly one argument", t);
 			}
-			if(!(args[0].isInstanceOf(CArray.TYPE))) {
+			if(!(args[0].isInstanceOf(CArray.TYPE, null, env))) {
 				throw new CRECastException("Expecting argument 1 to be an array", t);
 			}
-			return ((CArray) args[0]).deepClone(t);
+			return ((CArray) args[0]).deepClone(t, env);
 		}
 
 		@Override
@@ -2724,17 +2812,17 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			if(args.length != 1) {
 				throw new CREInsufficientArgumentsException("Expecting exactly one argument", t);
 			}
-			if(!(args[0].isInstanceOf(CArray.TYPE))) {
+			if(!(args[0].isInstanceOf(CArray.TYPE, null, env))) {
 				throw new CRECastException("Expecting argument 1 to be an array", t);
 			}
 			CArray array = (CArray) args[0];
-			CArray shallowClone = (array.isAssociative() ? CArray.GetAssociativeArray(t) : new CArray(t));
-			for(Mixed key : array.keySet()) {
-				shallowClone.set(key, array.get(key, t), t);
+			CArray shallowClone = (array.isAssociative() ? CArray.GetAssociativeArray(t, null, env) : new CArray(t));
+			for(Mixed key : array.keySet(env)) {
+				shallowClone.set(key, array.get(key, t, env), t, env);
 			}
 			return shallowClone;
 		}
@@ -2779,7 +2867,7 @@ public ExampleScript[] examples() throws ConfigCompileException {
 	}
 
 	@api
-	public static class array_iterate extends AbstractFunction {
+	public static class array_iterate extends CallbackYield {
 
 		@Override
 		public Class<? extends CREThrowable>[] thrown() {
@@ -2797,22 +2885,18 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
+		protected void execWithYield(Target t, Environment env, Mixed[] args, CallbackYield.Yield yield) {
 			ArrayAccess aa;
 			if(args[0] instanceof CFixedArray fa) {
 				aa = fa;
 			} else {
-				aa = ArgumentValidation.getArray(args[0], t);
+				aa = ArgumentValidation.getArray(args[0], t, env);
 			}
 			CClosure closure = ArgumentValidation.getObject(args[1], t, CClosure.class);
-			for(Mixed key : aa.keySet()) {
-				try {
-					closure.executeCallable(environment, t, key, aa.get(key, t));
-				} catch(ProgramFlowManipulationException ex) {
-					// Ignored
-				}
+			for(Mixed key : aa.keySet(env)) {
+				yield.call(closure, env, t, key, aa.get(key, t, env));
 			}
-			return aa;
+			yield.done(() -> aa);
 		}
 
 		@Override
@@ -2857,7 +2941,7 @@ public ExampleScript[] examples() throws ConfigCompileException {
 	}
 
 	@api
-	public static class array_reduce extends AbstractFunction {
+	public static class array_reduce extends CallbackYield {
 
 		@Override
 		public Class<? extends CREThrowable>[] thrown() {
@@ -2875,26 +2959,36 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
-			CArray array = ArgumentValidation.getArray(args[0], t);
+		protected void execWithYield(Target t, Environment env, Mixed[] args, CallbackYield.Yield yield) {
+			CArray array = ArgumentValidation.getArray(args[0], t, env);
 			CClosure closure = ArgumentValidation.getObject(args[1], t, CClosure.class);
-			if(array.isEmpty()) {
-				return CNull.NULL;
-			}
-			if(array.size() == 1) {
-				// This line looks bad, but all it does is return the first (and since we know only) value in the array,
-				// whether or not it is associative or normal.
-				return array.get(array.keySet().toArray(new Mixed[0])[0], t);
-			}
-			List<Mixed> keys = new ArrayList<>(array.keySet());
-			Mixed lastValue = array.get(keys.get(0), t);
-			for(int i = 1; i < keys.size(); ++i) {
-				lastValue = closure.executeCallable(environment, t, lastValue, array.get(keys.get(i), t));
-				if(lastValue instanceof CVoid) {
-					throw new CREIllegalArgumentException("The closure passed to " + getName() + " cannot return void.", t);
-				}
-			}
-			return lastValue;
+			if(array.isEmpty(env)) {
+				yield.done(() -> CNull.NULL);
+				return;
+			}
+			List<Mixed> keys = new ArrayList<>(array.keySet(env));
+			if(array.size(env) == 1) {
+				yield.done(() -> array.get(keys.get(0), t, env));
+				return;
+			}
+			Mixed[] acc = {array.get(keys.get(0), t, env)};
+			queueReduceStep(closure, env, t, array, keys, acc, 1, yield);
+			yield.done(() -> acc[0]);
+		}
+
+		private void queueReduceStep(CClosure closure, Environment env, Target t,
+				CArray array, List<Mixed> keys, Mixed[] acc, int index, CallbackYield.Yield yield) {
+			yield.call(closure, env, t, acc[0], array.get(keys.get(index), t, env))
+					.then((result, y) -> {
+						if(result instanceof CVoid) {
+							throw new CREIllegalArgumentException("The closure passed to " + getName()
+									+ " cannot return void.", t);
+						}
+						acc[0] = result;
+						if(index + 1 < keys.size()) {
+							queueReduceStep(closure, env, t, array, keys, acc, index + 1, y);
+						}
+					});
 		}
 
 		@Override
@@ -2942,7 +3036,7 @@ public ExampleScript[] examples() throws ConfigCompileException {
 	}
 
 	@api
-	public static class array_reduce_right extends AbstractFunction {
+	public static class array_reduce_right extends CallbackYield {
 
 		@Override
 		public Class<? extends CREThrowable>[] thrown() {
@@ -2960,26 +3054,36 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
-			CArray array = ArgumentValidation.getArray(args[0], t);
+		protected void execWithYield(Target t, Environment env, Mixed[] args, CallbackYield.Yield yield) {
+			CArray array = ArgumentValidation.getArray(args[0], t, env);
 			CClosure closure = ArgumentValidation.getObject(args[1], t, CClosure.class);
-			if(array.isEmpty()) {
-				return CNull.NULL;
-			}
-			if(array.size() == 1) {
-				// This line looks bad, but all it does is return the first (and since we know only) value in the array,
-				// whether or not it is associative or normal.
-				return array.get(array.keySet().toArray(new Mixed[0])[0], t);
-			}
-			List<Mixed> keys = new ArrayList<>(array.keySet());
-			Mixed lastValue = array.get(keys.get(keys.size() - 1), t);
-			for(int i = keys.size() - 2; i >= 0; --i) {
-				lastValue = closure.executeCallable(environment, t, lastValue, array.get(keys.get(i), t));
-				if(lastValue instanceof CVoid) {
-					throw new CREIllegalArgumentException("The closure passed to " + getName() + " cannot return void.", t);
-				}
-			}
-			return lastValue;
+			if(array.isEmpty(env)) {
+				yield.done(() -> CNull.NULL);
+				return;
+			}
+			List<Mixed> keys = new ArrayList<>(array.keySet(env));
+			if(array.size(env) == 1) {
+				yield.done(() -> array.get(keys.get(0), t, env));
+				return;
+			}
+			Mixed[] acc = {array.get(keys.get(keys.size() - 1), t, env)};
+			queueReduceStep(closure, env, t, array, keys, acc, keys.size() - 2, yield);
+			yield.done(() -> acc[0]);
+		}
+
+		private void queueReduceStep(CClosure closure, Environment env, Target t,
+				CArray array, List<Mixed> keys, Mixed[] acc, int index, CallbackYield.Yield yield) {
+			yield.call(closure, env, t, acc[0], array.get(keys.get(index), t, env))
+					.then((result, y) -> {
+						if(result instanceof CVoid) {
+							throw new CREIllegalArgumentException("The closure passed to " + getName()
+									+ " cannot return void.", t);
+						}
+						acc[0] = result;
+						if(index - 1 >= 0) {
+							queueReduceStep(closure, env, t, array, keys, acc, index - 1, y);
+						}
+					});
 		}
 
 		@Override
@@ -3027,7 +3131,7 @@ public ExampleScript[] examples() throws ConfigCompileException {
 	}
 
 	@api
-	public static class array_every extends AbstractFunction {
+	public static class array_every extends CallbackYield {
 
 		@Override
 		public Class<? extends CREThrowable>[] thrown() {
@@ -3045,17 +3149,21 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
-			CArray array = ArgumentValidation.getArray(args[0], t);
+		protected void execWithYield(Target t, Environment env, Mixed[] args, CallbackYield.Yield yield) {
+			CArray array = ArgumentValidation.getArray(args[0], t, env);
 			CClosure closure = ArgumentValidation.getObject(args[1], t, CClosure.class);
-			for(Mixed c : array.keySet()) {
-				Mixed fr = closure.executeCallable(environment, t, array.get(c, t));
-				boolean ret = ArgumentValidation.getBooleanish(fr, t);
-				if(ret == false) {
-					return CBoolean.FALSE;
-				}
+			boolean[] result = {true};
+			for(Mixed c : array.keySet(env)) {
+				yield.call(closure, env, t, array.get(c, t, env))
+						.then((fr, y) -> {
+							boolean ret = ArgumentValidation.getBooleanish(fr, t, env);
+							if(!ret) {
+								result[0] = false;
+								y.clear();
+							}
+						});
 			}
-			return CBoolean.TRUE;
+			yield.done(() -> CBoolean.get(result[0]));
 		}
 
 		@Override
@@ -3100,7 +3208,7 @@ public ExampleScript[] examples() throws ConfigCompileException {
 	}
 
 	@api
-	public static class array_some extends AbstractFunction {
+	public static class array_some extends CallbackYield {
 
 		@Override
 		public Class<? extends CREThrowable>[] thrown() {
@@ -3118,17 +3226,21 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
-			CArray array = ArgumentValidation.getArray(args[0], t);
+		protected void execWithYield(Target t, Environment env, Mixed[] args, CallbackYield.Yield yield) {
+			CArray array = ArgumentValidation.getArray(args[0], t, env);
 			CClosure closure = ArgumentValidation.getObject(args[1], t, CClosure.class);
-			for(Mixed c : array.keySet()) {
-				Mixed fr = closure.executeCallable(environment, t, array.get(c, t));
-				boolean ret = ArgumentValidation.getBooleanish(fr, t);
-				if(ret == true) {
-					return CBoolean.TRUE;
-				}
+			boolean[] result = {false};
+			for(Mixed c : array.keySet(env)) {
+				yield.call(closure, env, t, array.get(c, t, env))
+						.then((fr, y) -> {
+							boolean ret = ArgumentValidation.getBooleanish(fr, t, env);
+							if(ret) {
+								result[0] = true;
+								y.clear();
+							}
+						});
 			}
-			return CBoolean.FALSE;
+			yield.done(() -> CBoolean.get(result[0]));
 		}
 
 		@Override
@@ -3173,7 +3285,7 @@ public ExampleScript[] examples() throws ConfigCompileException {
 	}
 
 	@api
-	public static class array_map extends AbstractFunction {
+	public static class array_map extends CallbackYield {
 
 		@Override
 		public Class<? extends CREThrowable>[] thrown() {
@@ -3191,21 +3303,22 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
-			CArray array = ArgumentValidation.getArray(args[0], t);
+		protected void execWithYield(Target t, Environment env, Mixed[] args, CallbackYield.Yield yield) {
+			CArray array = ArgumentValidation.getArray(args[0], t, env);
 			CClosure closure = ArgumentValidation.getObject(args[1], t, CClosure.class);
-			CArray newArray = (array.isAssociative() ? CArray.GetAssociativeArray(t) : new CArray(t, (int) array.size()));
-
-			for(Mixed c : array.keySet()) {
-				Mixed fr = closure.executeCallable(environment, t, array.get(c, t));
-				if(fr.isInstanceOf(CVoid.TYPE)) {
-					throw new CREIllegalArgumentException("The closure passed to " + getName()
-							+ " must return a value.", t);
-				}
-				newArray.set(c, fr, t);
+			CArray newArray = (array.isAssociative() ? CArray.GetAssociativeArray(t, null, env) : new CArray(t, (int) array.size(env)));
+
+			for(Mixed c : array.keySet(env)) {
+				yield.call(closure, env, t, array.get(c, t, env))
+						.then((result, y) -> {
+							if(result.isInstanceOf(CVoid.TYPE, null, env)) {
+								throw new CREIllegalArgumentException("The closure passed to " + getName()
+										+ " must return a value.", t);
+							}
+							newArray.set(c, result, t, env);
+						});
 			}
-
-			return newArray;
+			yield.done(() -> newArray);
 		}
 
 		@Override
@@ -3269,7 +3382,7 @@ public Function getComparisonFunction() {
 
 	@api
 	@seealso({array_merge.class, array_subtract.class})
-	public static class array_intersect extends AbstractFunction {
+	public static class array_intersect extends CallbackYield {
 
 		@Override
 		public Class<? extends CREThrowable>[] thrown() {
@@ -3287,9 +3400,9 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
-			CArray one = ArgumentValidation.getArray(args[0], t);
-			CArray two = ArgumentValidation.getArray(args[1], t);
+		protected void execWithYield(Target t, Environment env, Mixed[] args, CallbackYield.Yield yield) {
+			CArray one = ArgumentValidation.getArray(args[0], t, env);
+			CArray two = ArgumentValidation.getArray(args[1], t, env);
 			CClosure closure = null;
 			ArrayValueComparisonMode mode = ArrayValueComparisonMode.HASH;
 			boolean associativeMode = one.isAssociative() || two.isAssociative();
@@ -3298,7 +3411,7 @@ public Mixed exec(Target t, Environment environment, Mixed... args) throws Confi
 					throw new CREIllegalArgumentException("For associative arrays, only 2 parameters may be provided,"
 							+ " the comparison mode value is not used.", t);
 				}
-				if(args[2].isInstanceOf(CClosure.TYPE)) {
+				if(args[2].isInstanceOf(CClosure.TYPE, null, env)) {
 					closure = ArgumentValidation.getObject(args[2], t, CClosure.class);
 				} else {
 					mode = ArgumentValidation.getEnum(args[2], ArrayValueComparisonMode.class, t);
@@ -3316,49 +3429,69 @@ public Mixed exec(Target t, Environment environment, Mixed... args) throws Confi
 				// Iterate one, and check if the hash of each value is in the set. If so, add it.
 				for(Mixed c : one) {
 					if(a2Set.contains(c.hashCode())) {
-						ret.push(c, t);
+						ret.push(c, t, env);
 					}
 				}
+			} else if(closure != null) {
+				Mixed[] k1 = new Mixed[(int) one.size(env)];
+				Mixed[] k2 = new Mixed[(int) two.size(env)];
+				one.keySet(env).toArray(k1);
+				two.keySet(env).toArray(k2);
+				queueIntersectStep(closure, env, t, one, two, k1, k2, ret, 0, 0, yield);
 			} else {
-				Mixed[] k1 = new Mixed[(int) one.size()];
-				Mixed[] k2 = new Mixed[(int) two.size()];
-				one.keySet().toArray(k1);
-				two.keySet().toArray(k2);
+				Mixed[] k1 = new Mixed[(int) one.size(env)];
+				Mixed[] k2 = new Mixed[(int) two.size(env)];
+				one.keySet(env).toArray(k1);
+				two.keySet(env).toArray(k2);
 				equals equals = new equals();
 				Function comparisonFunction = mode.getComparisonFunction();
 				i:
 				for(int i = 0; i < k1.length; i++) {
 					for(int j = 0; j < k2.length; j++) {
 						if(associativeMode) {
-							if(equals.exec(t, environment, k1[i], k2[j]).getBoolean()) {
-								ret.set(k1[i], one.get(k1[i], t), t);
+							if(equals.exec(t, env, null, k1[i], k2[j]).getBoolean()) {
+								ret.set(k1[i], one.get(k1[i], t, env), t, env);
 								continue i;
 							}
 						} else {
-							if(closure == null) {
-								if(comparisonFunction != null) {
-									if(ArgumentValidation.getBoolean(comparisonFunction.exec(t, environment,
-											one.get(k1[i], t), two.get(k2[j], t)
-									), t)) {
-										ret.push(one.get(k1[i], t), t);
-										continue i;
-									}
-								} else {
-									throw new Error();
-								}
-							} else {
-								Mixed fre = closure.executeCallable(environment, t, one.get(k1[i], t), two.get(k2[j], t));
-								boolean res = ArgumentValidation.getBoolean(fre, fre.getTarget());
-								if(res) {
-									ret.push(one.get(k1[i], t), t);
+							if(comparisonFunction != null) {
+								if(ArgumentValidation.getBooleanish(comparisonFunction.exec(t, env, null,
+										one.get(k1[i], t, env), two.get(k2[j], t, env)
+								), t, env)) {
+									ret.push(one.get(k1[i], t, env), t, env);
 									continue i;
 								}
+							} else {
+								throw new Error();
 							}
 						}
 					}
 				}
 			}
-			return ret;
+			yield.done(() -> ret);
+		}
+
+		private void queueIntersectStep(CClosure closure, Environment env, Target t,
+				CArray one, CArray two, Mixed[] k1, Mixed[] k2, CArray ret,
+				int i, int j, CallbackYield.Yield yield) {
+			if(i >= k1.length) {
+				return;
+			}
+			yield.call(closure, env, t, one.get(k1[i], t, env), two.get(k2[j], t, env))
+					.then((result, y) -> {
+						boolean res = ArgumentValidation.getBooleanish(result, result.getTarget(), env);
+						if(res) {
+							ret.push(one.get(k1[i], t, env), t, env);
+							// Match found, skip to next outer element
+							queueIntersectStep(closure, env, t, one, two, k1, k2, ret, i + 1, 0, y);
+						} else if(j + 1 < k2.length) {
+							// Try next inner element
+							queueIntersectStep(closure, env, t, one, two, k1, k2, ret, i, j + 1, y);
+						} else {
+							// Exhausted inner loop, move to next outer element
+							queueIntersectStep(closure, env, t, one, two, k1, k2, ret, i + 1, 0, y);
+						}
+					});
 		}
 
 		@Override
@@ -3474,16 +3607,16 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			Mixed constA = args[0];
 			Mixed constB = args[1];
-			if(!(constA.isInstanceOf(CArray.TYPE))) {
+			if(!(constA.isInstanceOf(CArray.TYPE, null, env))) {
 				throw new CREIllegalArgumentException("Expecting an array, but received " + constA, t);
 			}
-			if(!(constB.isInstanceOf(CArray.TYPE))) {
+			if(!(constB.isInstanceOf(CArray.TYPE, null, env))) {
 				throw new CREIllegalArgumentException("Expecting an array, but received " + constB, t);
 			}
-			return CBoolean.get(subsetOf(constA, constB, t));
+			return CBoolean.get(subsetOf(constA, constB, t, env));
 		}
 
 		@Override
@@ -3508,11 +3641,11 @@ public ExampleScript[] examples() throws ConfigCompileException {
 			};
 		}
 
-		public boolean subsetOf(Mixed constA, Mixed constB, Target t) {
-			if(!constA.typeof().equals(constB.typeof())) {
+		private boolean subsetOf(Mixed constA, Mixed constB, Target t, Environment env) {
+			if(!constA.typeof(env).equals(constB.typeof(env))) {
 				return false;
 			}
-			if(constA.isInstanceOf(CArray.TYPE)) {
+			if(constA.isInstanceOf(CArray.TYPE, null, env)) {
 				CArray arrA = (CArray) constA;
 				CArray arrB = (CArray) constB;
 				if(arrA.isAssociative() != arrB.isAssociative()) {
@@ -3523,20 +3656,20 @@ public boolean subsetOf(Mixed constA, Mixed constB, Target t) {
 						if(!arrB.containsKey(key)) {
 							return false;
 						}
-						Mixed eltA = arrA.get(key, t);
-						Mixed eltB = arrB.get(key, t);
-						if(!subsetOf(eltA, eltB, t)) {
+						Mixed eltA = arrA.get(key, t, env);
+						Mixed eltB = arrB.get(key, t, env);
+						if(!subsetOf(eltA, eltB, t, env)) {
 							return false;
 						}
 					}
 				} else {
-					for(int i = 0; i < arrA.size(); i++) {
+					for(int i = 0; i < arrA.size(env); i++) {
 						if(!arrB.containsKey(i)) {
 							return false;
 						}
-						Mixed eltA = arrA.get(i, t);
-						Mixed eltB = arrB.get(i, t);
-						if(!subsetOf(eltA, eltB, t)) {
+						Mixed eltA = arrA.get(i, t, env);
+						Mixed eltB = arrB.get(i, t, env);
+						if(!subsetOf(eltA, eltB, t, env)) {
 							return false;
 						}
 					}
@@ -3624,13 +3757,13 @@ public Class<? extends CREThrowable>[] thrown() {
 		Random rand = new Random();
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
-			CArray array = ArgumentValidation.getArray(args[0], t);
-			if(array.isEmpty()) {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
+			CArray array = ArgumentValidation.getArray(args[0], t, env);
+			if(array.isEmpty(env)) {
 				throw new CRELengthException("Array is empty", t);
 			}
-			List<Mixed> keySet = new ArrayList<>(array.keySet());
-			return array.get(keySet.get(java.lang.Math.abs(rand.nextInt() % (int) array.size())), t);
+			List<Mixed> keySet = new ArrayList<>(array.keySet(env));
+			return array.get(keySet.get(java.lang.Math.abs(rand.nextInt() % (int) array.size(env))), t, env);
 		}
 
 		@Override
@@ -3661,7 +3794,7 @@ public ExampleScript[] examples() throws ConfigCompileException {
 
 	@api
 	@seealso(array_intersect.class)
-	public static class array_subtract extends AbstractFunction {
+	public static class array_subtract extends CallbackYield {
 
 		@Override
 		public Class<? extends CREThrowable>[] thrown() {
@@ -3679,9 +3812,9 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
-			CArray one = ArgumentValidation.getArray(args[0], t);
-			CArray two = ArgumentValidation.getArray(args[1], t);
+		protected void execWithYield(Target t, Environment env, Mixed[] args, CallbackYield.Yield yield) {
+			CArray one = ArgumentValidation.getArray(args[0], t, env);
+			CArray two = ArgumentValidation.getArray(args[1], t, env);
 			CClosure closure = null;
 			ArrayValueComparisonMode mode = ArrayValueComparisonMode.HASH;
 			boolean associativeMode = one.isAssociative() || two.isAssociative();
@@ -3690,7 +3823,7 @@ public Mixed exec(Target t, Environment environment, Mixed... args) throws Confi
 					throw new CREIllegalArgumentException("For associative arrays, only 2 parameters may be provided,"
 							+ " the comparison mode value is not used.", t);
 				}
-				if(args[2].isInstanceOf(CClosure.TYPE)) {
+				if(args[2].isInstanceOf(CClosure.TYPE, null, env)) {
 					closure = ArgumentValidation.getObject(args[2], t, CClosure.class);
 				} else {
 					mode = ArgumentValidation.getEnum(args[2], ArrayValueComparisonMode.class, t);
@@ -3708,56 +3841,76 @@ public Mixed exec(Target t, Environment environment, Mixed... args) throws Confi
 				// Iterate one, and check if the hash of each value is in the set. If not, add it.
 				for(Mixed c : one) {
 					if(!a2Set.contains(c.hashCode())) {
-						ret.push(c, t);
+						ret.push(c, t, env);
 					}
 				}
+			} else if(closure != null) {
+				Mixed[] k1 = new Mixed[(int) one.size(env)];
+				Mixed[] k2 = new Mixed[(int) two.size(env)];
+				one.keySet(env).toArray(k1);
+				two.keySet(env).toArray(k2);
+				queueSubtractStep(closure, env, t, one, two, k1, k2, ret, 0, 0, yield);
 			} else {
-				Mixed[] k1 = new Mixed[(int) one.size()];
-				Mixed[] k2 = new Mixed[(int) two.size()];
-				one.keySet().toArray(k1);
-				two.keySet().toArray(k2);
+				Mixed[] k1 = new Mixed[(int) one.size(env)];
+				Mixed[] k2 = new Mixed[(int) two.size(env)];
+				one.keySet(env).toArray(k1);
+				two.keySet(env).toArray(k2);
 				equals equals = new equals();
 				Function comparisonFunction = mode.getComparisonFunction();
 				for(int i = 0; i < k1.length; i++) {
 					boolean addValue = true;
 					for(int j = 0; j < k2.length; j++) {
 						if(associativeMode) {
-							if(equals.exec(t, environment, k1[i], k2[j]).getBoolean()) {
+							if(equals.exec(t, env, null, k1[i], k2[j]).getBoolean()) {
 								addValue = false;
 								break;
 							}
 						} else {
-							if(closure == null) {
-								if(comparisonFunction != null) {
-									if(ArgumentValidation.getBoolean(comparisonFunction.exec(t, environment,
-											one.get(k1[i], t), two.get(k2[j], t)
-									), t)) {
-										addValue = false;
-										break;
-									}
-								} else {
-									throw new Error();
-								}
-							} else {
-								Mixed fre = closure.executeCallable(environment, t, one.get(k1[i], t), two.get(k2[j], t));
-								boolean res = ArgumentValidation.getBoolean(fre, fre.getTarget());
-								if(res) {
+							if(comparisonFunction != null) {
+								if(ArgumentValidation.getBooleanish(comparisonFunction.exec(t, env, null,
+										one.get(k1[i], t, env), two.get(k2[j], t, env)
+								), t, env)) {
 									addValue = false;
 									break;
 								}
+							} else {
+								throw new Error();
 							}
 						}
 					}
 					if(addValue) {
 						if(associativeMode) {
-							ret.set(k1[i], one.get(k1[i], t), t);
+							ret.set(k1[i], one.get(k1[i], t, env), t, env);
 						} else {
-							ret.push(one.get(k1[i], t), t);
+							ret.push(one.get(k1[i], t, env), t, env);
 						}
 					}
 				}
 			}
-			return ret;
+			yield.done(() -> ret);
+		}
+
+		private void queueSubtractStep(CClosure closure, Environment env, Target t,
+				CArray one, CArray two, Mixed[] k1, Mixed[] k2, CArray ret,
+				int i, int j, CallbackYield.Yield yield) {
+			if(i >= k1.length) {
+				return;
+			}
+			yield.call(closure, env, t, one.get(k1[i], t, env), two.get(k2[j], t, env))
+					.then((result, y) -> {
+						boolean res = ArgumentValidation.getBooleanish(result, result.getTarget(), env);
+						if(res) {
+							// Match found — this element should NOT be in the result
+							queueSubtractStep(closure, env, t, one, two, k1, k2, ret, i + 1, 0, y);
+						} else if(j + 1 < k2.length) {
+							// No match yet, try next inner element
+							queueSubtractStep(closure, env, t, one, two, k1, k2, ret, i, j + 1, y);
+						} else {
+							// Exhausted inner loop with no match — include this element
+							ret.push(one.get(k1[i], t, env), t, env);
+							queueSubtractStep(closure, env, t, one, two, k1, k2, ret, i + 1, 0, y);
+						}
+					});
 		}
 
 		@Override
@@ -3817,18 +3970,18 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			Mixed fill = args[1];
 			if(args[0] instanceof CFixedArray fa) {
-				fa.fill(fill, t);
+				fa.fill(fill, t, env);
 				return fa;
 			} else {
-				CArray array = ArgumentValidation.getArray(args[0], t);
+				CArray array = ArgumentValidation.getArray(args[0], t, env);
 				if(array.isAssociative()) {
 					throw new CRECastException(getName() + " can only accept normal arrays.", t);
 				}
-				for(Mixed key : array.keySet()) {
-					array.set(key, fill, t);
+				for(Mixed key : array.keySet(env)) {
+					array.set(key, fill, t, env);
 				}
 				return array;
 			}
@@ -3873,8 +4026,8 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment env, Mixed... args) throws ConfigRuntimeException {
-			ArgumentValidation.getArray(args[0], t).clear();
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
+			ArgumentValidation.getArray(args[0], t, env).clear();
 			return CVoid.VOID;
 		}
 
diff --git a/src/main/java/com/laytonsmith/core/functions/BasicLogic.java b/src/main/java/com/laytonsmith/core/functions/BasicLogic.java
index 0640280275..afc92d8264 100644
--- a/src/main/java/com/laytonsmith/core/functions/BasicLogic.java
+++ b/src/main/java/com/laytonsmith/core/functions/BasicLogic.java
@@ -6,10 +6,13 @@
 import com.laytonsmith.annotations.core;
 import com.laytonsmith.annotations.seealso;
 import com.laytonsmith.core.ArgumentValidation;
+import com.laytonsmith.core.FlowFunction;
 import com.laytonsmith.core.MSVersion;
 import com.laytonsmith.core.Optimizable;
 import com.laytonsmith.core.ParseTree;
-import com.laytonsmith.core.Script;
+import com.laytonsmith.core.StepAction.Complete;
+import com.laytonsmith.core.StepAction.Evaluate;
+import com.laytonsmith.core.StepAction.StepResult;
 import com.laytonsmith.core.compiler.FileOptions;
 import com.laytonsmith.core.compiler.OptimizationUtilities;
 import com.laytonsmith.core.compiler.analysis.Scope;
@@ -29,6 +32,7 @@
 import com.laytonsmith.core.constructs.CSymbol;
 import com.laytonsmith.core.constructs.CVoid;
 import com.laytonsmith.core.constructs.Target;
+import com.laytonsmith.core.constructs.generics.GenericParameters;
 import com.laytonsmith.core.environments.Environment;
 import com.laytonsmith.core.environments.GlobalEnv;
 import com.laytonsmith.core.exceptions.CRE.CRECastException;
@@ -55,6 +59,75 @@ public static String docs() {
 		return "These functions provide basic logical operations.";
 	}
 
+	/**
+	 * Shared state for short-circuit logic FlowFunctions (and, or, dand, dor, nand, nor).
+	 */
+	static class ShortCircuitState {
+		ParseTree[] children;
+		int index;
+
+		ShortCircuitState(ParseTree[] children) {
+			this.children = children;
+			this.index = 0;
+		}
+
+		@Override
+		public String toString() {
+			return "index=" + index + "/" + children.length;
+		}
+	}
+
+	enum ShortCircuitMode {
+		AND,  // short-circuit on false, return CBoolean
+		OR,   // short-circuit on true, return CBoolean
+		DAND, // short-circuit on falsy, return actual value
+		DOR   // short-circuit on truthy, return actual value
+	}
+
+	private static StepResult<ShortCircuitState> scBegin(ParseTree[] children) {
+		ShortCircuitState state = new ShortCircuitState(children);
+		return new StepResult<>(new Evaluate(children[0]), state);
+	}
+
+	private static StepResult<ShortCircuitState> scChildCompleted(Target t,
+			ShortCircuitState state, Mixed result, Environment env, ShortCircuitMode mode) {
+		boolean boolVal;
+		switch(mode) {
+			case AND -> {
+				boolVal = ArgumentValidation.getBoolean(result, t, env);
+				if(!boolVal) {
+					return new StepResult<>(new Complete(CBoolean.FALSE), state);
+				}
+			}
+			case OR -> {
+				boolVal = ArgumentValidation.getBoolean(result, t, env);
+				if(boolVal) {
+					return new StepResult<>(new Complete(CBoolean.TRUE), state);
+				}
+			}
+			case DAND -> {
+				if(!ArgumentValidation.getBooleanish(result, t, env)) {
+					return new StepResult<>(new Complete(result), state);
+				}
+			}
+			case DOR -> {
+				if(ArgumentValidation.getBooleanish(result, t, env)) {
+					return new StepResult<>(new Complete(result), state);
+				}
+			}
+		}
+		state.index++;
+		if(state.index < state.children.length) {
+			return new StepResult<>(new Evaluate(state.children[state.index]), state);
+		}
+		// All evaluated, none short-circuited
+		return switch(mode) {
+			case AND -> new StepResult<>(new Complete(CBoolean.TRUE), state);
+			case OR -> new StepResult<>(new Complete(CBoolean.FALSE), state);
+			case DAND, DOR -> new StepResult<>(new Complete(result), state);
+		};
+	}
+
 	@api
 	@seealso({nequals.class, sequals.class, snequals.class})
 	@OperatorPreferred("==")
@@ -71,7 +144,7 @@ public static class equals extends AbstractFunction implements Optimizable {
 		 * @return
 		 */
 		public static boolean doEquals(Mixed one, Mixed two) {
-			CBoolean ret = SELF.exec(Target.UNKNOWN, null, one, two);
+			CBoolean ret = SELF.exec(Target.UNKNOWN, null, null, one, two);
 			return ret.getBoolean();
 		}
 
@@ -86,7 +159,7 @@ public Integer[] numArgs() {
 		}
 
 		@Override
-		public CBoolean exec(Target t, Environment env, Mixed... args) throws CancelCommandException, ConfigRuntimeException {
+		public CBoolean exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws CancelCommandException, ConfigRuntimeException {
 			if(args.length <= 1) {
 				throw new CREInsufficientArgumentsException("At least two arguments must be passed to equals", t);
 			}
@@ -112,8 +185,8 @@ public CBoolean exec(Target t, Environment env, Mixed... args) throws CancelComm
 			if(ArgumentValidation.anyBooleans(args)) {
 				boolean equals = true;
 				for(int i = 1; i < args.length; i++) {
-					boolean arg1 = ArgumentValidation.getBoolean(args[i - 1], t);
-					boolean arg2 = ArgumentValidation.getBoolean(args[i], t);
+					boolean arg1 = ArgumentValidation.getBoolean(args[i - 1], t, env);
+					boolean arg2 = ArgumentValidation.getBoolean(args[i], t, env);
 					if(arg1 != arg2) {
 						equals = false;
 						break;
@@ -143,8 +216,8 @@ public CBoolean exec(Target t, Environment env, Mixed... args) throws CancelComm
 					if(!ArgumentValidation.isNumber(args[i])) {
 						return CBoolean.FALSE;
 					}
-					double arg1 = ArgumentValidation.getNumber(args[i - 1], t);
-					double arg2 = ArgumentValidation.getNumber(args[i], t);
+					double arg1 = ArgumentValidation.getNumber(args[i - 1], t, env);
+					double arg2 = ArgumentValidation.getNumber(args[i], t, env);
 					if(arg1 != arg2) {
 						return CBoolean.FALSE;
 					}
@@ -254,17 +327,17 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public CBoolean exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
+		public CBoolean exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			if(args.length != 2) {
 				throw new CREFormatException(this.getName() + " expects 2 arguments.", t);
 			}
-			if(args[1].typeof().equals(args[0].typeof())) {
-				if(args[0].isInstanceOf(CString.TYPE) && args[1].isInstanceOf(CString.TYPE)) {
+			if(args[1].typeof(env).equals(args[0].typeof(env))) {
+				if(args[0].isInstanceOf(CString.TYPE, null, env) && args[1].isInstanceOf(CString.TYPE, null, env)) {
 					// Check for actual string equality, so we don't do type massaging
 					// for numeric strings. Thus '2' !== '2.0'
 					return CBoolean.get(args[0].val().equals(args[1].val()));
 				}
-				return new equals().exec(t, environment, args);
+				return new equals().exec(t, env, null, args);
 			} else {
 				return CBoolean.FALSE;
 			}
@@ -332,8 +405,8 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
-			return new sequals().exec(t, environment, args).not();
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
+			return new sequals().exec(t, env, null, args).not();
 		}
 
 		@Override
@@ -410,8 +483,8 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public CBoolean exec(Target t, Environment env, Mixed... args) throws ConfigRuntimeException {
-			return new equals().exec(t, env, args).not();
+		public CBoolean exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
+			return new equals().exec(t, env, null, args).not();
 		}
 
 		@Override
@@ -480,15 +553,15 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public CBoolean exec(Target t, Environment env, Mixed... args) throws ConfigRuntimeException {
+		public CBoolean exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			if(args.length <= 1) {
 				throw new CREInsufficientArgumentsException("At least two arguments must be passed to equals_ic", t);
 			}
 			if(ArgumentValidation.anyBooleans(args)) {
 				boolean equals = true;
 				for(int i = 1; i < args.length; i++) {
-					boolean arg1 = ArgumentValidation.getBoolean(args[i - 1], t);
-					boolean arg2 = ArgumentValidation.getBoolean(args[i], t);
+					boolean arg1 = ArgumentValidation.getBoolean(args[i - 1], t, env);
+					boolean arg2 = ArgumentValidation.getBoolean(args[i], t, env);
 					if(arg1 != arg2) {
 						equals = false;
 						break;
@@ -519,8 +592,8 @@ public CBoolean exec(Target t, Environment env, Mixed... args) throws ConfigRunt
 					if(!ArgumentValidation.isNumber(args[i])) {
 						return CBoolean.FALSE;
 					}
-					double arg1 = ArgumentValidation.getNumber(args[i - 1], t);
-					double arg2 = ArgumentValidation.getNumber(args[i], t);
+					double arg1 = ArgumentValidation.getNumber(args[i - 1], t, env);
+					double arg2 = ArgumentValidation.getNumber(args[i], t, env);
 					if(arg1 != arg2) {
 						return CBoolean.FALSE;
 					}
@@ -574,13 +647,13 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public CBoolean exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
+		public CBoolean exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			Mixed v1 = args[0];
 			Mixed v2 = args[1];
 			if(!v2.getClass().equals(v1.getClass())) {
 				return CBoolean.FALSE;
 			}
-			return new equals_ic().exec(t, environment, v1, v2);
+			return new equals_ic().exec(t, env, null, v1, v2);
 		}
 
 		@Override
@@ -673,8 +746,8 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public CBoolean exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
-			return new equals_ic().exec(t, environment, args).not();
+		public CBoolean exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
+			return new equals_ic().exec(t, env, null, args).not();
 		}
 
 		@Override
@@ -720,11 +793,11 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public CBoolean exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
-			if(args[0].isInstanceOf(CArray.TYPE) && args[1].isInstanceOf(CArray.TYPE)) {
+		public CBoolean exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
+			if(args[0].isInstanceOf(CArray.TYPE, null, env) && args[1].isInstanceOf(CArray.TYPE, null, env)) {
 				return CBoolean.get(args[0] == args[1]);
 			} else {
-				return new equals().exec(t, environment, args);
+				return new equals().exec(t, env, null, args);
 			}
 		}
 
@@ -792,12 +865,12 @@ public Integer[] numArgs() {
 		}
 
 		@Override
-		public CBoolean exec(Target t, Environment env, Mixed... args) throws CancelCommandException, ConfigRuntimeException {
+		public CBoolean exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws CancelCommandException, ConfigRuntimeException {
 			if(args.length != 2) {
 				throw new CREFormatException(this.getName() + " expects 2 arguments.", t);
 			}
-			double arg1 = ArgumentValidation.getNumber(args[0], t);
-			double arg2 = ArgumentValidation.getNumber(args[1], t);
+			double arg1 = ArgumentValidation.getNumber(args[0], t, env);
+			double arg2 = ArgumentValidation.getNumber(args[1], t, env);
 			return CBoolean.get(arg1 < arg2);
 		}
 
@@ -866,12 +939,12 @@ public Integer[] numArgs() {
 		}
 
 		@Override
-		public CBoolean exec(Target t, Environment env, Mixed... args) throws CancelCommandException, ConfigRuntimeException {
+		public CBoolean exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws CancelCommandException, ConfigRuntimeException {
 			if(args.length != 2) {
 				throw new CREFormatException(this.getName() + " expects 2 arguments.", t);
 			}
-			double arg1 = ArgumentValidation.getNumber(args[0], t);
-			double arg2 = ArgumentValidation.getNumber(args[1], t);
+			double arg1 = ArgumentValidation.getNumber(args[0], t, env);
+			double arg2 = ArgumentValidation.getNumber(args[1], t, env);
 			return CBoolean.get(arg1 > arg2);
 		}
 
@@ -940,12 +1013,12 @@ public Integer[] numArgs() {
 		}
 
 		@Override
-		public CBoolean exec(Target t, Environment env, Mixed... args) throws CancelCommandException, ConfigRuntimeException {
+		public CBoolean exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws CancelCommandException, ConfigRuntimeException {
 			if(args.length != 2) {
 				throw new CREFormatException(this.getName() + " expects 2 arguments.", t);
 			}
-			double arg1 = ArgumentValidation.getNumber(args[0], t);
-			double arg2 = ArgumentValidation.getNumber(args[1], t);
+			double arg1 = ArgumentValidation.getNumber(args[0], t, env);
+			double arg2 = ArgumentValidation.getNumber(args[1], t, env);
 			return CBoolean.get(arg1 <= arg2);
 		}
 
@@ -1015,12 +1088,12 @@ public Integer[] numArgs() {
 		}
 
 		@Override
-		public CBoolean exec(Target t, Environment env, Mixed... args) throws CancelCommandException, ConfigRuntimeException {
+		public CBoolean exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws CancelCommandException, ConfigRuntimeException {
 			if(args.length != 2) {
 				throw new CREFormatException(this.getName() + " expects 2 arguments.", t);
 			}
-			double arg1 = ArgumentValidation.getNumber(args[0], t);
-			double arg2 = ArgumentValidation.getNumber(args[1], t);
+			double arg1 = ArgumentValidation.getNumber(args[0], t, env);
+			double arg2 = ArgumentValidation.getNumber(args[1], t, env);
 			return CBoolean.get(arg1 >= arg2);
 		}
 
@@ -1076,7 +1149,7 @@ public ExampleScript[] examples() throws ConfigCompileException {
 	@api(environments = {GlobalEnv.class})
 	@seealso({or.class})
 	@OperatorPreferred("&&")
-	public static class and extends AbstractFunction implements Optimizable {
+	public static class and extends AbstractFunction implements Optimizable, FlowFunction<ShortCircuitState> {
 
 		public static final String NAME = "and";
 
@@ -1091,11 +1164,11 @@ public Integer[] numArgs() {
 		}
 
 		@Override
-		public CBoolean exec(Target t, Environment env, Mixed... args) {
+		public CBoolean exec(Target t, Environment env, GenericParameters generics, Mixed... args) {
 			//This will only happen if they hardcode true/false in, but we still
 			//need to handle it appropriately.
 			for(Mixed c : args) {
-				if(!ArgumentValidation.getBoolean(c, t)) {
+				if(!ArgumentValidation.getBoolean(c, t, env)) {
 					return CBoolean.FALSE;
 				}
 			}
@@ -1103,15 +1176,14 @@ public CBoolean exec(Target t, Environment env, Mixed... args) {
 		}
 
 		@Override
-		public CBoolean execs(Target t, Environment env, Script parent, ParseTree... nodes) {
-			for(ParseTree tree : nodes) {
-				Mixed c = env.getEnv(GlobalEnv.class).GetScript().seval(tree, env);
-				boolean b = ArgumentValidation.getBoolean(c, t);
-				if(b == false) {
-					return CBoolean.FALSE;
-				}
-			}
-			return CBoolean.TRUE;
+		public StepResult<ShortCircuitState> begin(Target t, ParseTree[] children, Environment env) {
+			return scBegin(children);
+		}
+
+		@Override
+		public StepResult<ShortCircuitState> childCompleted(Target t, ShortCircuitState state,
+				Mixed result, Environment env) {
+			return scChildCompleted(t, state, result, env, ShortCircuitMode.AND);
 		}
 
 		@Override
@@ -1154,11 +1226,6 @@ public Boolean runAsync() {
 			return null;
 		}
 
-		@Override
-		public boolean useSpecialExec() {
-			return true;
-		}
-
 		@Override
 		public ParseTree optimizeDynamic(Target t, Environment env,
 				Set<Class<? extends Environment.EnvironmentImpl>> envs,
@@ -1179,7 +1246,7 @@ public ParseTree optimizeDynamic(Target t, Environment env,
 					continue;
 				}
 				if(child.isConst()) {
-					if(ArgumentValidation.getBoolean(child.getData(), t) == true) {
+					if(ArgumentValidation.getBoolean(child.getData(), t, env) == true) {
 						it.remove();
 					} else {
 						foundFalse = true;
@@ -1203,7 +1270,7 @@ public ParseTree optimizeDynamic(Target t, Environment env,
 //			}
 			// At this point, it could be that there are some conditions with side effects, followed by a final false. However,
 			// if false is the only remaining condition (which could be) then we can simply return false here.
-			if(children.size() == 1 && children.get(0).isConst() && ArgumentValidation.getBoolean(children.get(0).getData(), t) == false) {
+			if(children.size() == 1 && children.get(0).isConst() && ArgumentValidation.getBoolean(children.get(0).getData(), t, env) == false) {
 				return new ParseTree(CBoolean.FALSE, fileOptions);
 			}
 			if(children.isEmpty()) {
@@ -1229,7 +1296,7 @@ public Set<OptimizationOption> optimizationOptions() {
 	}
 
 	@api
-	public static class dand extends AbstractFunction implements Optimizable {
+	public static class dand extends AbstractFunction implements Optimizable, FlowFunction<ShortCircuitState> {
 
 		@Override
 		public Class<? extends CREThrowable>[] thrown() {
@@ -1247,25 +1314,19 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public boolean useSpecialExec() {
-			return true;
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
+			return CVoid.VOID;
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
-			return CVoid.VOID;
+		public StepResult<ShortCircuitState> begin(Target t, ParseTree[] children, Environment env) {
+			return scBegin(children);
 		}
 
 		@Override
-		public Mixed execs(Target t, Environment env, Script parent, ParseTree... nodes) {
-			Mixed lastValue = CBoolean.TRUE;
-			for(ParseTree tree : nodes) {
-				lastValue = env.getEnv(GlobalEnv.class).GetScript().seval(tree, env);
-				if(!ArgumentValidation.getBooleanish(lastValue, t)) {
-					return lastValue;
-				}
-			}
-			return lastValue;
+		public StepResult<ShortCircuitState> childCompleted(Target t, ShortCircuitState state,
+				Mixed result, Environment env) {
+			return scChildCompleted(t, state, result, env, ShortCircuitMode.DAND);
 		}
 
 		@Override
@@ -1304,7 +1365,7 @@ public ParseTree optimizeDynamic(Target t, Environment env,
 					continue;
 				}
 				if(child.isConst()) {
-					if(ArgumentValidation.getBoolean(child.getData(), t) == true) {
+					if(ArgumentValidation.getBoolean(child.getData(), t, env) == true) {
 						it.remove();
 					} else {
 						foundFalse = true;
@@ -1328,7 +1389,7 @@ public ParseTree optimizeDynamic(Target t, Environment env,
 //			}
 			// At this point, it could be that there are some conditions with side effects, followed by a final false. However,
 			// if false is the only remaining condition (which could be) then we can simply return false here.
-			if(children.size() == 1 && children.get(0).isConst() && ArgumentValidation.getBoolean(children.get(0).getData(), t) == false) {
+			if(children.size() == 1 && children.get(0).isConst() && ArgumentValidation.getBoolean(children.get(0).getData(), t, env) == false) {
 				return new ParseTree(children.get(0).getData(), fileOptions);
 			}
 			if(children.isEmpty()) {
@@ -1371,7 +1432,7 @@ public Set<OptimizationOption> optimizationOptions() {
 	@api(environments = {GlobalEnv.class})
 	@seealso({and.class})
 	@OperatorPreferred("||")
-	public static class or extends AbstractFunction implements Optimizable {
+	public static class or extends AbstractFunction implements Optimizable, FlowFunction<ShortCircuitState> {
 
 		@Override
 		public String getName() {
@@ -1384,11 +1445,11 @@ public Integer[] numArgs() {
 		}
 
 		@Override
-		public CBoolean exec(Target t, Environment env, Mixed... args) {
+		public CBoolean exec(Target t, Environment env, GenericParameters generics, Mixed... args) {
 			//This will only happen if they hardcode true/false in, but we still
 			//need to handle it appropriately.
 			for(Mixed c : args) {
-				if(ArgumentValidation.getBoolean(c, t)) {
+				if(ArgumentValidation.getBoolean(c, t, env)) {
 					return CBoolean.TRUE;
 				}
 			}
@@ -1396,14 +1457,14 @@ public CBoolean exec(Target t, Environment env, Mixed... args) {
 		}
 
 		@Override
-		public CBoolean execs(Target t, Environment env, Script parent, ParseTree... nodes) {
-			for(ParseTree tree : nodes) {
-				Mixed c = env.getEnv(GlobalEnv.class).GetScript().seval(tree, env);
-				if(ArgumentValidation.getBoolean(c, t)) {
-					return CBoolean.TRUE;
-				}
-			}
-			return CBoolean.FALSE;
+		public StepResult<ShortCircuitState> begin(Target t, ParseTree[] children, Environment env) {
+			return scBegin(children);
+		}
+
+		@Override
+		public StepResult<ShortCircuitState> childCompleted(Target t, ShortCircuitState state,
+				Mixed result, Environment env) {
+			return scChildCompleted(t, state, result, env, ShortCircuitMode.OR);
 		}
 
 		@Override
@@ -1447,11 +1508,6 @@ public Boolean runAsync() {
 			return null;
 		}
 
-		@Override
-		public boolean useSpecialExec() {
-			return true;
-		}
-
 		@Override
 		public ParseTree optimizeDynamic(Target t, Environment env,
 				Set<Class<? extends Environment.EnvironmentImpl>> envs,
@@ -1475,7 +1531,7 @@ public ParseTree optimizeDynamic(Target t, Environment env,
 					if(child.getData() instanceof CSymbol) {
 						throw new ConfigCompileException("Unexpected symbol: \"" + child.getData().val() + "\"", t);
 					}
-					if(ArgumentValidation.getBoolean(child.getData(), t) == false) {
+					if(ArgumentValidation.getBoolean(child.getData(), t, env) == false) {
 						it.remove();
 					} else {
 						foundTrue = true;
@@ -1499,7 +1555,7 @@ public ParseTree optimizeDynamic(Target t, Environment env,
 //			}
 			// At this point, it could be that there are some conditions with side effects, followed by a final true. However,
 			// if true is the only remaining condition (which could be) then we can simply return true here.
-			if(children.size() == 1 && children.get(0).isConst() && ArgumentValidation.getBoolean(children.get(0).getData(), t) == true) {
+			if(children.size() == 1 && children.get(0).isConst() && ArgumentValidation.getBoolean(children.get(0).getData(), t, env) == true) {
 				return new ParseTree(CBoolean.TRUE, fileOptions);
 			}
 			if(children.isEmpty()) {
@@ -1525,7 +1581,7 @@ public Set<OptimizationOption> optimizationOptions() {
 	}
 
 	@api
-	public static class dor extends AbstractFunction implements Optimizable {
+	public static class dor extends AbstractFunction implements Optimizable, FlowFunction<ShortCircuitState> {
 
 		@Override
 		public Class<? extends CREThrowable>[] thrown() {
@@ -1543,24 +1599,19 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public boolean useSpecialExec() {
-			return true;
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
+			return CVoid.VOID;
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
-			return CVoid.VOID;
+		public StepResult<ShortCircuitState> begin(Target t, ParseTree[] children, Environment env) {
+			return scBegin(children);
 		}
 
 		@Override
-		public Mixed execs(Target t, Environment env, Script parent, ParseTree... nodes) {
-			for(ParseTree tree : nodes) {
-				Mixed c = env.getEnv(GlobalEnv.class).GetScript().seval(tree, env);
-				if(ArgumentValidation.getBooleanish(c, t)) {
-					return c;
-				}
-			}
-			return env.getEnv(GlobalEnv.class).GetScript().seval(nodes[nodes.length - 1], env);
+		public StepResult<ShortCircuitState> childCompleted(Target t, ShortCircuitState state,
+				Mixed result, Environment env) {
+			return scChildCompleted(t, state, result, env, ShortCircuitMode.DOR);
 		}
 
 		@Override
@@ -1586,6 +1637,9 @@ public ParseTree optimizeDynamic(Target t, Environment env,
 				List<ParseTree> children, FileOptions fileOptions)
 				throws ConfigCompileException, ConfigRuntimeException {
 			OptimizationUtilities.pullUpLikeFunctions(children, getName());
+			if(children.isEmpty()) {
+				throw new ConfigCompileException(getName() + " requires at least one argument", t);
+			}
 			return null;
 		}
 
@@ -1644,11 +1698,11 @@ public Integer[] numArgs() {
 		}
 
 		@Override
-		public CBoolean exec(Target t, Environment env, Mixed... args) throws CancelCommandException, ConfigRuntimeException {
+		public CBoolean exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws CancelCommandException, ConfigRuntimeException {
 			if(args.length != 1) {
 				throw new CREFormatException(this.getName() + " expects 1 argument.", t);
 			}
-			return CBoolean.get(!ArgumentValidation.getBoolean(args[0], t));
+			return CBoolean.get(!ArgumentValidation.getBoolean(args[0], t, env));
 		}
 
 		@Override
@@ -1748,12 +1802,12 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public CBoolean exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
+		public CBoolean exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			if(args.length != 2) {
 				throw new CREFormatException(this.getName() + " expects 2 arguments.", t);
 			}
-			boolean val1 = ArgumentValidation.getBoolean(args[0], t);
-			boolean val2 = ArgumentValidation.getBoolean(args[1], t);
+			boolean val1 = ArgumentValidation.getBoolean(args[0], t, env);
+			boolean val2 = ArgumentValidation.getBoolean(args[1], t, env);
 			return CBoolean.get(val1 ^ val2);
 		}
 
@@ -1784,7 +1838,7 @@ public ExampleScript[] examples() throws ConfigCompileException {
 
 	@api
 	@seealso({and.class})
-	public static class nand extends AbstractFunction {
+	public static class nand extends AbstractFunction implements FlowFunction<ShortCircuitState> {
 
 		@Override
 		public String getName() {
@@ -1822,13 +1876,23 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) {
 			return CNull.NULL;
 		}
 
 		@Override
-		public CBoolean execs(Target t, Environment env, Script parent, ParseTree... nodes) {
-			return new and().execs(t, env, parent, nodes).not();
+		public StepResult<ShortCircuitState> begin(Target t, ParseTree[] children, Environment env) {
+			return scBegin(children);
+		}
+
+		@Override
+		public StepResult<ShortCircuitState> childCompleted(Target t, ShortCircuitState state,
+				Mixed result, Environment env) {
+			StepResult<ShortCircuitState> r = scChildCompleted(t, state, result, env, ShortCircuitMode.AND);
+			if(r.getAction() instanceof Complete c) {
+				return new StepResult<>(new Complete(((CBoolean) c.getResult()).not()), state);
+			}
+			return r;
 		}
 
 		@Override
@@ -1845,11 +1909,6 @@ public Scope linkScope(StaticAnalysis analysis, Scope parentScope,
 			return this.linkScopeLazy(analysis, parentScope, ast, env, exceptions);
 		}
 
-		@Override
-		public boolean useSpecialExec() {
-			return true;
-		}
-
 		@Override
 		public ExampleScript[] examples() throws ConfigCompileException {
 			return new ExampleScript[]{
@@ -1859,7 +1918,7 @@ public ExampleScript[] examples() throws ConfigCompileException {
 
 	@api
 	@seealso({or.class})
-	public static class nor extends AbstractFunction {
+	public static class nor extends AbstractFunction implements FlowFunction<ShortCircuitState> {
 
 		@Override
 		public String getName() {
@@ -1897,13 +1956,23 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) {
 			return CNull.NULL;
 		}
 
 		@Override
-		public CBoolean execs(Target t, Environment environment, Script parent, ParseTree... args) throws ConfigRuntimeException {
-			return new or().execs(t, environment, parent, args).not();
+		public StepResult<ShortCircuitState> begin(Target t, ParseTree[] children, Environment env) {
+			return scBegin(children);
+		}
+
+		@Override
+		public StepResult<ShortCircuitState> childCompleted(Target t, ShortCircuitState state,
+				Mixed result, Environment env) {
+			StepResult<ShortCircuitState> r = scChildCompleted(t, state, result, env, ShortCircuitMode.OR);
+			if(r.getAction() instanceof Complete c) {
+				return new StepResult<>(new Complete(((CBoolean) c.getResult()).not()), state);
+			}
+			return r;
 		}
 
 		@Override
@@ -1920,11 +1989,6 @@ public Scope linkScope(StaticAnalysis analysis, Scope parentScope,
 			return this.linkScopeLazy(analysis, parentScope, ast, env, exceptions);
 		}
 
-		@Override
-		public boolean useSpecialExec() {
-			return true;
-		}
-
 		@Override
 		public ExampleScript[] examples() throws ConfigCompileException {
 			return new ExampleScript[]{
@@ -1972,11 +2036,11 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public CBoolean exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
+		public CBoolean exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			if(args.length != 2) {
 				throw new CREFormatException(this.getName() + " expects 2 arguments.", t);
 			}
-			return new xor().exec(t, environment, args).not();
+			return new xor().exec(t, env, null, args).not();
 		}
 
 		@Override
@@ -2044,13 +2108,13 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public CInt exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
+		public CInt exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			if(args.length < 2) {
 				throw new CREFormatException(this.getName() + " expects at least 2 arguments.", t);
 			}
-			long val = ArgumentValidation.getInt(args[0], t);
+			long val = ArgumentValidation.getInt(args[0], t, env);
 			for(int i = 1; i < args.length; i++) {
-				val = val & ArgumentValidation.getInt(args[i], t);
+				val = val & ArgumentValidation.getInt(args[i], t, env);
 			}
 			return new CInt(val, t);
 		}
@@ -2131,13 +2195,13 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public CInt exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
+		public CInt exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			if(args.length < 2) {
 				throw new CREFormatException(this.getName() + " expects at least 2 arguments.", t);
 			}
-			long val = ArgumentValidation.getInt(args[0], t);
+			long val = ArgumentValidation.getInt(args[0], t, env);
 			for(int i = 1; i < args.length; i++) {
-				val = val | ArgumentValidation.getInt(args[i], t);
+				val = val | ArgumentValidation.getInt(args[i], t, env);
 			}
 			return new CInt(val, t);
 		}
@@ -2220,13 +2284,13 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public CInt exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
+		public CInt exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			if(args.length < 2) {
 				throw new CREFormatException(this.getName() + " expects at least 2 arguments.", t);
 			}
-			long val = ArgumentValidation.getInt(args[0], t);
+			long val = ArgumentValidation.getInt(args[0], t, env);
 			for(int i = 1; i < args.length; i++) {
-				val = val ^ ArgumentValidation.getInt(args[i], t);
+				val = val ^ ArgumentValidation.getInt(args[i], t, env);
 			}
 			return new CInt(val, t);
 		}
@@ -2305,11 +2369,11 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public CInt exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
+		public CInt exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			if(args.length != 1) {
 				throw new CREFormatException(this.getName() + " expects 1 argument.", t);
 			}
-			return new CInt(~ArgumentValidation.getInt(args[0], t), t);
+			return new CInt(~ArgumentValidation.getInt(args[0], t, env), t);
 		}
 
 		@Override
@@ -2371,12 +2435,12 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public CInt exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
+		public CInt exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			if(args.length != 2) {
 				throw new CREFormatException(this.getName() + " expects 2 arguments.", t);
 			}
-			long value = ArgumentValidation.getInt(args[0], t);
-			long toShift = ArgumentValidation.getInt(args[1], t);
+			long value = ArgumentValidation.getInt(args[0], t, env);
+			long toShift = ArgumentValidation.getInt(args[1], t, env);
 			return new CInt(value << toShift, t);
 		}
 
@@ -2441,12 +2505,12 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public CInt exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
+		public CInt exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			if(args.length != 2) {
 				throw new CREFormatException(this.getName() + " expects 2 arguments.", t);
 			}
-			long value = ArgumentValidation.getInt(args[0], t);
-			long toShift = ArgumentValidation.getInt(args[1], t);
+			long value = ArgumentValidation.getInt(args[0], t, env);
+			long toShift = ArgumentValidation.getInt(args[1], t, env);
 			return new CInt(value >> toShift, t);
 		}
 
@@ -2513,12 +2577,12 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public CInt exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
+		public CInt exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			if(args.length != 2) {
 				throw new CREFormatException(this.getName() + " expects 2 arguments.", t);
 			}
-			long value = ArgumentValidation.getInt(args[0], t);
-			long toShift = ArgumentValidation.getInt(args[1], t);
+			long value = ArgumentValidation.getInt(args[0], t, env);
+			long toShift = ArgumentValidation.getInt(args[1], t, env);
 			return new CInt(value >>> toShift, t);
 		}
 
@@ -2564,7 +2628,7 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			return CVoid.VOID;
 		}
 
@@ -2644,7 +2708,7 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public CInt exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
+		public CInt exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			return new CInt(args[0].hashCode(), t);
 		}
 
@@ -2705,10 +2769,10 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment env, Mixed... args) throws ConfigRuntimeException {
-			double d1 = ArgumentValidation.getNumber(args[0], t);
-			double d2 = ArgumentValidation.getNumber(args[1], t);
-			double epsilon = ArgumentValidation.getDouble(args[2], t);
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
+			double d1 = ArgumentValidation.getNumber(args[0], t, env);
+			double d2 = ArgumentValidation.getNumber(args[1], t, env);
+			double epsilon = ArgumentValidation.getDouble(args[2], t, env);
 			return CBoolean.get(java.lang.Math.abs(d1 - d2) < epsilon);
 		}
 
diff --git a/src/main/java/com/laytonsmith/core/functions/BossBar.java b/src/main/java/com/laytonsmith/core/functions/BossBar.java
index cdb67bf635..5722f1f9c7 100644
--- a/src/main/java/com/laytonsmith/core/functions/BossBar.java
+++ b/src/main/java/com/laytonsmith/core/functions/BossBar.java
@@ -16,6 +16,7 @@
 import com.laytonsmith.core.constructs.CString;
 import com.laytonsmith.core.constructs.CVoid;
 import com.laytonsmith.core.constructs.Target;
+import com.laytonsmith.core.constructs.generics.GenericParameters;
 import com.laytonsmith.core.environments.CommandHelperEnvironment;
 import com.laytonsmith.core.environments.Environment;
 import com.laytonsmith.core.exceptions.CRE.CRECastException;
@@ -78,10 +79,10 @@ public Integer[] numArgs() {
 		}
 
 		@Override
-		public CArray exec(Target t, Environment env, Mixed... args) throws ConfigRuntimeException {
+		public CArray exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			CArray ca = new CArray(t);
 			for(String id : BARS.keySet()) {
-				ca.push(new CString(id, t), t);
+				ca.push(new CString(id, t), t, env);
 			}
 			return ca;
 		}
@@ -120,7 +121,7 @@ public Integer[] numArgs() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment env, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			String id = args[0].val();
 			if(BARS.containsKey(id)) {
 				throw new CREIllegalArgumentException("That boss bar id is already in use.", t);
@@ -131,33 +132,33 @@ public Mixed exec(Target t, Environment env, Mixed... args) throws ConfigRuntime
 			boolean visible = true;
 			double percent = 1.0;
 			if(args.length == 2) {
-				if(!(args[1].isInstanceOf(CArray.TYPE))) {
+				if(!(args[1].isInstanceOf(CArray.TYPE, null, env))) {
 					throw new CRECastException("Expected array for parameter 2 of create_bar()", t);
 				}
 				CArray ca = (CArray) args[1];
 				if(ca.containsKey("title")) {
-					title = ca.get("title", t).val();
+					title = ca.get("title", t, env).val();
 				}
 				if(ca.containsKey("color")) {
 					try {
-						color = MCBarColor.valueOf(ca.get("color", t).val());
+						color = MCBarColor.valueOf(ca.get("color", t, env).val());
 					} catch (IllegalArgumentException ex) {
 						throw new CREFormatException("Invalid boss bar color.", t);
 					}
 				}
 				if(ca.containsKey("style")) {
 					try {
-						style = MCBarStyle.valueOf(ca.get("style", t).val());
+						style = MCBarStyle.valueOf(ca.get("style", t, env).val());
 					} catch (IllegalArgumentException ex) {
 						throw new CREFormatException("Invalid boss bar style.", t);
 					}
 				}
 				if(ca.containsKey("visible")) {
-					visible = ArgumentValidation.getBoolean(ca.get("visible", t), t);
+					visible = ArgumentValidation.getBoolean(ca.get("visible", t, env), t, env);
 				}
 				if(ca.containsKey("percent")) {
 					try {
-						percent = ArgumentValidation.getDouble(ca.get("percent", t), t);
+						percent = ArgumentValidation.getDouble(ca.get("percent", t, env), t, env);
 					} catch (IllegalArgumentException ex) {
 						throw new CRERangeException("Progress percentage must be from 0.0 to 1.0.", t);
 					}
@@ -202,45 +203,45 @@ public Integer[] numArgs() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment env, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			String id = args[0].val();
 			MCBossBar bar = BARS.get(id);
 			if(bar == null) {
 				throw new CRENotFoundException("That boss bar id does not exist.", t);
 			}
-			if(args[1].isInstanceOf(CString.TYPE)) {
+			if(args[1].isInstanceOf(CString.TYPE, null, env)) {
 				bar.setTitle(args[1].val());
-			} else if(args[1].isInstanceOf(CDouble.TYPE)) {
+			} else if(args[1].isInstanceOf(CDouble.TYPE, null, env)) {
 				try {
-					bar.setProgress(ArgumentValidation.getDouble(args[1], t));
+					bar.setProgress(ArgumentValidation.getDouble(args[1], t, env));
 				} catch (IllegalArgumentException ex) {
 					throw new CRERangeException("Progress percentage must be from 0.0 to 1.0.", t);
 				}
-			} else if(args[1].isInstanceOf(CArray.TYPE)) {
+			} else if(args[1].isInstanceOf(CArray.TYPE, null, env)) {
 				CArray ca = (CArray) args[1];
 				if(ca.containsKey("title")) {
-					bar.setTitle(ca.get("title", t).val());
+					bar.setTitle(ca.get("title", t, env).val());
 				}
 				if(ca.containsKey("color")) {
 					try {
-						bar.setColor(MCBarColor.valueOf(ca.get("color", t).val()));
+						bar.setColor(MCBarColor.valueOf(ca.get("color", t, env).val()));
 					} catch (IllegalArgumentException ex) {
 						throw new CREFormatException("Invalid boss bar color.", t);
 					}
 				}
 				if(ca.containsKey("style")) {
 					try {
-						bar.setStyle(MCBarStyle.valueOf(ca.get("style", t).val()));
+						bar.setStyle(MCBarStyle.valueOf(ca.get("style", t, env).val()));
 					} catch (IllegalArgumentException ex) {
 						throw new CREFormatException("Invalid boss bar style.", t);
 					}
 				}
 				if(ca.containsKey("visible")) {
-					bar.setVisible(ArgumentValidation.getBoolean(ca.get("visible", t), t));
+					bar.setVisible(ArgumentValidation.getBoolean(ca.get("visible", t, env), t, env));
 				}
 				if(ca.containsKey("percent")) {
 					try {
-						bar.setProgress(ArgumentValidation.getDouble(ca.get("percent", t), t));
+						bar.setProgress(ArgumentValidation.getDouble(ca.get("percent", t, env), t, env));
 					} catch (IllegalArgumentException ex) {
 						throw new CRERangeException("Progress percentage must be from 0.0 to 1.0.", t);
 					}
@@ -278,18 +279,18 @@ public Integer[] numArgs() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment env, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			String id = args[0].val();
 			MCBossBar bar = BARS.get(id);
 			if(bar == null) {
 				throw new CRENotFoundException("That boss bar id does not exist.", t);
 			}
-			CArray ret = CArray.GetAssociativeArray(t);
-			ret.set("title", bar.getTitle(), t);
-			ret.set("color", bar.getColor().name(), t);
-			ret.set("style", bar.getStyle().name(), t);
-			ret.set("visible", CBoolean.get(bar.isVisible()), t);
-			ret.set("percent", new CDouble(bar.getProgress(), t), t);
+			CArray ret = CArray.GetAssociativeArray(t, null, env);
+			ret.set("title", bar.getTitle(), t, env);
+			ret.set("color", bar.getColor().name(), t, env);
+			ret.set("style", bar.getStyle().name(), t, env);
+			ret.set("visible", CBoolean.get(bar.isVisible()), t, env);
+			ret.set("percent", new CDouble(bar.getProgress(), t), t, env);
 			return ret;
 		}
 
@@ -319,7 +320,7 @@ public Integer[] numArgs() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment env, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			String id = args[0].val();
 			MCBossBar bar = BARS.get(id);
 			if(bar == null) {
@@ -356,12 +357,12 @@ public Integer[] numArgs() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment env, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			MCBossBar bar = BARS.get(args[0].val());
 			if(bar == null) {
 				throw new CRENotFoundException("That boss bar id does not exist.", t);
 			}
-			bar.addPlayer(Static.GetPlayer(args[1].val(), t));
+			bar.addPlayer(Static.GetPlayer(args[1].val(), t, env));
 			return CVoid.VOID;
 		}
 
@@ -390,12 +391,12 @@ public Integer[] numArgs() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment env, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			MCBossBar bar = BARS.get(args[0].val());
 			if(bar == null) {
 				throw new CRENotFoundException("That boss bar id does not exist.", t);
 			}
-			bar.removePlayer(Static.GetPlayer(args[1].val(), t));
+			bar.removePlayer(Static.GetPlayer(args[1].val(), t, env));
 			return CVoid.VOID;
 		}
 
@@ -424,14 +425,14 @@ public Integer[] numArgs() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment env, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			MCBossBar bar = BARS.get(args[0].val());
 			if(bar == null) {
 				throw new CRENotFoundException("That boss bar id does not exist.", t);
 			}
 			CArray players = new CArray(t);
 			for(MCPlayer player : bar.getPlayers()) {
-				players.push(new CString(player.getName(), t), t);
+				players.push(new CString(player.getName(), t), t, env);
 			}
 			return players;
 		}
diff --git a/src/main/java/com/laytonsmith/core/functions/BukkitMetadata.java b/src/main/java/com/laytonsmith/core/functions/BukkitMetadata.java
index 820c9b13a8..9e9a6f7c78 100644
--- a/src/main/java/com/laytonsmith/core/functions/BukkitMetadata.java
+++ b/src/main/java/com/laytonsmith/core/functions/BukkitMetadata.java
@@ -16,6 +16,7 @@
 import com.laytonsmith.core.constructs.CString;
 import com.laytonsmith.core.constructs.CVoid;
 import com.laytonsmith.core.constructs.Target;
+import com.laytonsmith.core.constructs.generics.GenericParameters;
 import com.laytonsmith.core.environments.CommandHelperEnvironment;
 import com.laytonsmith.core.environments.Environment;
 import com.laytonsmith.core.exceptions.CRE.CREBadEntityException;
@@ -107,12 +108,12 @@ public ExampleScript[] examples() throws ConfigCompileException {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			List<MCMetadataValue> metadata;
 			if(args.length == 1) {
-				metadata = Static.getPlayer(environment, t).getMetadata(args[0].val());
+				metadata = Static.getPlayer(env, t).getMetadata(args[0].val());
 			} else {
-				metadata = GetMetadatable(args[0], t).getMetadata(args[1].val());
+				metadata = GetMetadatable(args[0], t, env).getMetadata(args[1].val());
 			}
 			if(args.length == 3) {
 				MCPlugin plugin = Static.getPlugin(args[2], t);
@@ -156,14 +157,14 @@ public String docs() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			String key;
 			MCMetadatable metadatable;
 			if(args.length == 1) {
-				metadatable = Static.getPlayer(environment, t);
+				metadatable = Static.getPlayer(env, t);
 				key = args[0].val();
 			} else {
-				metadatable = GetMetadatable(args[0], t);
+				metadatable = GetMetadatable(args[0], t, env);
 				key = args[1].val();
 			}
 			if(metadatable.hasMetadata(key)) {
@@ -213,23 +214,23 @@ public String docs() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			String key;
 			MCMetadatable metadatable;
 			Mixed value;
 			MCPlugin plugin;
 			if(args.length == 2) {
-				metadatable = Static.getPlayer(environment, t);
+				metadatable = Static.getPlayer(env, t);
 				key = args[0].val();
 				value = args[1];
 				plugin = StaticLayer.GetPlugin();
 			} else {
-				metadatable = GetMetadatable(args[0], t);
+				metadatable = GetMetadatable(args[0], t, env);
 				key = args[1].val();
 				value = args[2];
 				plugin = (args.length == 4) ? Static.getPlugin(args[3], t) : StaticLayer.GetPlugin();
 			}
-			metadatable.setMetadata(key, ObjectGenerator.GetGenerator().metadataValue(value, plugin));
+			metadatable.setMetadata(key, ObjectGenerator.GetGenerator().metadataValue(value, plugin, env));
 			return CVoid.VOID;
 		}
 
@@ -258,14 +259,14 @@ public String docs() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			String key;
 			MCMetadatable metadatable;
 			if(args.length == 1) {
-				metadatable = Static.getPlayer(environment, t);
+				metadatable = Static.getPlayer(env, t);
 				key = args[0].val();
 			} else {
-				metadatable = GetMetadatable(args[0], t);
+				metadatable = GetMetadatable(args[0], t, env);
 				key = args[1].val();
 			}
 			if(args.length == 3) {
@@ -292,8 +293,8 @@ public Version since() {
 	 * @param t
 	 * @return
 	 */
-	private static MCMetadatable GetMetadatable(Mixed construct, Target t) {
-		if(construct.isInstanceOf(CArray.TYPE)) {
+	private static MCMetadatable GetMetadatable(Mixed construct, Target t, Environment env) {
+		if(construct.isInstanceOf(CArray.TYPE, null, env)) {
 			return ObjectGenerator.GetGenerator().location(construct, null, t).getBlock();
 		} else if(construct instanceof CString) {
 			switch(construct.val().length()) {
diff --git a/src/main/java/com/laytonsmith/core/functions/ByteArrays.java b/src/main/java/com/laytonsmith/core/functions/ByteArrays.java
index 15cb83bb1a..edcfaca647 100644
--- a/src/main/java/com/laytonsmith/core/functions/ByteArrays.java
+++ b/src/main/java/com/laytonsmith/core/functions/ByteArrays.java
@@ -14,6 +14,7 @@
 import com.laytonsmith.core.constructs.CVoid;
 import com.laytonsmith.core.constructs.Construct;
 import com.laytonsmith.core.constructs.Target;
+import com.laytonsmith.core.constructs.generics.GenericParameters;
 import com.laytonsmith.core.environments.Environment;
 import com.laytonsmith.core.exceptions.CRE.CRECastException;
 import com.laytonsmith.core.exceptions.CRE.CREFormatException;
@@ -52,7 +53,7 @@ public Class<? extends CREThrowable>[] thrown() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			return new CByteArray(t);
 		}
 
@@ -82,7 +83,7 @@ public String getName() {
 	public static class ba_as_array extends ba {
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			CByteArray ba = ArgumentValidation.getByteArray(args[0], t);
 			return ba.asArray(t);
 		}
@@ -117,7 +118,7 @@ public String getName() {
 	public static class ba_rewind extends ba {
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			CByteArray ba = getBA(args, t);
 			ba.rewind();
 			return CVoid.VOID;
@@ -149,7 +150,7 @@ public String getName() {
 	public static class ba_get_byte extends ba_get {
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			CByteArray ba = getBA(args, t);
 			Integer pos = get_getPos(args, t);
 			try {
@@ -181,7 +182,7 @@ public String getName() {
 	public static class ba_get_char extends ba_get {
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			CByteArray ba = getBA(args, t);
 			Integer pos = get_getPos(args, t);
 			try {
@@ -213,7 +214,7 @@ public String getName() {
 	public static class ba_get_short extends ba_get {
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			CByteArray ba = getBA(args, t);
 			Integer pos = get_getPos(args, t);
 			try {
@@ -244,7 +245,7 @@ public String getName() {
 	public static class ba_get_int extends ba_get {
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			CByteArray ba = getBA(args, t);
 			Integer pos = get_getPos(args, t);
 			try {
@@ -276,7 +277,7 @@ public String getName() {
 	public static class ba_get_long extends ba_get {
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			CByteArray ba = getBA(args, t);
 			Integer pos = get_getPos(args, t);
 			try {
@@ -308,7 +309,7 @@ public String getName() {
 	public static class ba_get_float extends ba_get {
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			CByteArray ba = getBA(args, t);
 			Integer pos = get_getPos(args, t);
 			try {
@@ -340,7 +341,7 @@ public String getName() {
 	public static class ba_get_double extends ba_get {
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			CByteArray ba = getBA(args, t);
 			Integer pos = get_getPos(args, t);
 			try {
@@ -376,7 +377,7 @@ public Integer[] numArgs() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			CByteArray ba = getBA(args, t);
 			int size = ArgumentValidation.getInt32(args[1], t);
 			Integer pos = null;
@@ -412,7 +413,7 @@ public String getName() {
 	public static class ba_get_string extends ba_get {
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			CByteArray ba = getBA(args, t);
 			Integer pos = get_getPos(args, t);
 			String encoding = null;
@@ -454,7 +455,7 @@ public String getName() {
 	public static class ba_put_byte extends ba_put {
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			CByteArray ba = getBA(args, t);
 			byte b = ArgumentValidation.getInt8(args[1], t);
 			Integer pos = set_getPos(args, t);
@@ -489,7 +490,7 @@ public Class<? extends CREThrowable>[] thrown() {
 	public static class ba_put_char extends ba_put {
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			CByteArray ba = getBA(args, t);
 			String b = args[1].val();
 			char c = '\0';
@@ -523,7 +524,7 @@ public String getName() {
 	public static class ba_put_short extends ba_put {
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			CByteArray ba = getBA(args, t);
 			short b = ArgumentValidation.getInt16(args[1], t);
 			Integer pos = set_getPos(args, t);
@@ -558,7 +559,7 @@ public Class<? extends CREThrowable>[] thrown() {
 	public static class ba_put_int extends ba_put {
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			CByteArray ba = getBA(args, t);
 			int b = ArgumentValidation.getInt32(args[1], t);
 			Integer pos = set_getPos(args, t);
@@ -592,7 +593,7 @@ public Class<? extends CREThrowable>[] thrown() {
 	public static class ba_put_long extends ba_put {
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			CByteArray ba = getBA(args, t);
 			long b = ArgumentValidation.getInt(args[1], t);
 			Integer pos = set_getPos(args, t);
@@ -622,7 +623,7 @@ public String getName() {
 	public static class ba_put_float extends ba_put {
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			CByteArray ba = getBA(args, t);
 			float b = ArgumentValidation.getDouble32(args[1], t);
 			Integer pos = set_getPos(args, t);
@@ -657,7 +658,7 @@ public Class<? extends CREThrowable>[] thrown() {
 	public static class ba_put_double extends ba_put {
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			CByteArray ba = getBA(args, t);
 			double b = ArgumentValidation.getDouble(args[1], t);
 			Integer pos = set_getPos(args, t);
@@ -687,7 +688,7 @@ public String getName() {
 	public static class ba_put_bytes extends ba_put {
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			CByteArray dest = getBA(args, t);
 			CByteArray src = ArgumentValidation.getByteArray(args[1], t);
 			Integer pos = set_getPos(args, t);
@@ -717,7 +718,7 @@ public String getName() {
 	public static class ba_put_string extends ba_put {
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			CByteArray ba = getBA(args, t);
 			String s = args[1].val();
 			Integer pos = set_getPos(args, t);
@@ -775,7 +776,7 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			CByteArray ba = ArgumentValidation.getByteArray(args[0], t);
 			boolean setLittle = ArgumentValidation.getBoolean(args[1], t);
 			ba.setOrder(setLittle ? ByteOrder.LITTLE_ENDIAN : ByteOrder.BIG_ENDIAN);
@@ -826,7 +827,7 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			CByteArray ba = ArgumentValidation.getByteArray(args[0], t);
 			return CBoolean.get(ba.getOrder() == ByteOrder.LITTLE_ENDIAN);
 		}
diff --git a/src/main/java/com/laytonsmith/core/functions/Clipboard.java b/src/main/java/com/laytonsmith/core/functions/Clipboard.java
index a19b672894..9bb67c00d3 100644
--- a/src/main/java/com/laytonsmith/core/functions/Clipboard.java
+++ b/src/main/java/com/laytonsmith/core/functions/Clipboard.java
@@ -7,6 +7,7 @@
 import com.laytonsmith.core.constructs.CString;
 import com.laytonsmith.core.constructs.CVoid;
 import com.laytonsmith.core.constructs.Target;
+import com.laytonsmith.core.constructs.generics.GenericParameters;
 import com.laytonsmith.core.environments.Environment;
 import com.laytonsmith.core.exceptions.CRE.CREFormatException;
 import com.laytonsmith.core.exceptions.CRE.CREIOException;
@@ -64,8 +65,8 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
-			Cmdline.requireCmdlineMode(environment, this, t);
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
+			Cmdline.requireCmdlineMode(env, this, t);
 			if(clipboard == null) {
 				throw new CREUnsupportedOperationException(
 						"Clipboard functions are not supported on this platform.", t);
@@ -132,8 +133,8 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
-			Cmdline.requireCmdlineMode(environment, this, t);
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
+			Cmdline.requireCmdlineMode(env, this, t);
 			if(clipboard == null) {
 				throw new CREUnsupportedOperationException(
 						"Clipboard functions are not supported on this platform.", t);
diff --git a/src/main/java/com/laytonsmith/core/functions/Cmdline.java b/src/main/java/com/laytonsmith/core/functions/Cmdline.java
index 8b86483d91..7435ca16a2 100644
--- a/src/main/java/com/laytonsmith/core/functions/Cmdline.java
+++ b/src/main/java/com/laytonsmith/core/functions/Cmdline.java
@@ -33,6 +33,7 @@
 import com.laytonsmith.core.constructs.CVoid;
 import com.laytonsmith.core.constructs.Construct;
 import com.laytonsmith.core.constructs.Target;
+import com.laytonsmith.core.constructs.generics.GenericParameters;
 import com.laytonsmith.core.environments.Environment;
 import com.laytonsmith.core.environments.GlobalEnv;
 import com.laytonsmith.core.environments.StaticRuntimeEnv;
@@ -97,7 +98,7 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public CVoid exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
+		public CVoid exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			String msg = Static.MCToANSIColors(args[0].val());
 			PrintStream out = StreamUtils.GetSystemOut();
 			out.print(msg);
@@ -162,7 +163,7 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public CVoid exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
+		public CVoid exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			String msg = Static.MCToANSIColors(args[0].val());
 			PrintStream se = StreamUtils.GetSystemErr();
 			se.print(msg);
@@ -226,7 +227,7 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public CVoid exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
+		public CVoid exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			String msg = Static.MCToANSIColors(args[0].val());
 			PrintStream so = StreamUtils.GetSystemOut();
 			so.print(msg);
@@ -283,7 +284,7 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public CVoid exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
+		public CVoid exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			String msg = Static.MCToANSIColors(args[0].val());
 			StreamUtils.GetSystemErr().print(msg);
 			StreamUtils.GetSystemErr().flush();
@@ -338,15 +339,15 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			int exit_code = 0;
 			if(args.length == 1) {
-				exit_code = ArgumentValidation.getInt32(args[0], t);
+				exit_code = ArgumentValidation.getInt32(args[0], t, env);
 			}
-			if(Static.InCmdLine(environment, true)) {
+			if(Static.InCmdLine(env, true)) {
 				System.exit(exit_code);
 			}
-			return new ControlFlow.die().exec(t, environment, args);
+			return new ControlFlow.die().exec(t, env, null, args);
 		}
 
 		@Override
@@ -404,7 +405,7 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			if(args.length == 1) {
 				String propName = args[0].val();
 				String prop;
@@ -418,13 +419,13 @@ public Mixed exec(Target t, Environment environment, Mixed... args) throws Confi
 				}
 				return new CString(prop, t);
 			} else {
-				CArray ca = CArray.GetAssociativeArray(t);
+				CArray ca = CArray.GetAssociativeArray(t, null, env);
 				for(String key : System.getProperties().stringPropertyNames()) {
-					ca.set(key, System.getProperty(key));
+					ca.set(key, System.getProperty(key), env);
 				}
 				Map<String, String> msProps = getMethodScriptProperties();
 				for(String key : msProps.keySet()) {
-					ca.set(key, msProps.get(key));
+					ca.set(key, msProps.get(key), env);
 				}
 				return ca;
 			}
@@ -510,13 +511,13 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			if(args.length == 1) {
 				return new CString(System.getenv(args[0].val()), t);
 			} else {
-				CArray ca = CArray.GetAssociativeArray(t);
+				CArray ca = CArray.GetAssociativeArray(t, null, env);
 				for(String key : System.getenv().keySet()) {
-					ca.set(key, System.getenv(key));
+					ca.set(key, System.getenv(key), env);
 				}
 				return ca;
 			}
@@ -564,7 +565,7 @@ public Boolean runAsync() {
 
 		@SuppressWarnings({"BroadCatchBlock", "TooBroadCatch", "UseSpecificCatch"})
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			//TODO: Make this more robust by having a local cache of the environment which we modify, and get_env returns from.
 			Map<String, String> newenv = new HashMap<>(System.getenv());
 			newenv.put(args[0].val(), args[1].val());
@@ -573,8 +574,8 @@ public Mixed exec(Target t, Environment environment, Mixed... args) throws Confi
 				Class<?> processEnvironmentClass = Class.forName("java.lang.ProcessEnvironment");
 				Field theEnvironmentField = processEnvironmentClass.getDeclaredField("theEnvironment");
 				theEnvironmentField.setAccessible(true);
-				Map<String, String> env = (Map<String, String>) theEnvironmentField.get(null);
-				env.putAll(newenv);
+				Map<String, String> sysEnv = (Map<String, String>) theEnvironmentField.get(null);
+				sysEnv.putAll(newenv);
 				Field theCaseInsensitiveEnvironmentField = processEnvironmentClass.getDeclaredField("theCaseInsensitiveEnvironment");
 				theCaseInsensitiveEnvironmentField.setAccessible(true);
 				Map<String, String> cienv = (Map<String, String>) theCaseInsensitiveEnvironmentField.get(null);
@@ -583,12 +584,12 @@ public Mixed exec(Target t, Environment environment, Mixed... args) throws Confi
 			} catch (NoSuchFieldException e) {
 				try {
 					Class[] classes = Collections.class.getDeclaredClasses();
-					Map<String, String> env = System.getenv();
+					Map<String, String> sysEnv = System.getenv();
 					for(Class cl : classes) {
 						if("java.util.Collections$UnmodifiableMap".equals(cl.getName())) {
 							Field field = cl.getDeclaredField("m");
 							field.setAccessible(true);
-							Object obj = field.get(env);
+							Object obj = field.get(sysEnv);
 							Map<String, String> map = (Map<String, String>) obj;
 							map.clear();
 							map.putAll(newenv);
@@ -655,13 +656,13 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
-			if(!Static.InCmdLine(environment, true)) {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
+			if(!Static.InCmdLine(env, true)) {
 				throw new CREInsufficientPermissionException(getName() + " cannot be used outside of cmdline mode.", t);
 			}
 			boolean mask = true;
 			if(args.length > 1) {
-				mask = ArgumentValidation.getBoolean(args[1], t);
+				mask = ArgumentValidation.getBoolean(args[1], t, env);
 			}
 
 			String prompt = args[0].val();
@@ -733,8 +734,8 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
-			requireCmdlineMode(environment, this, t);
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
+			requireCmdlineMode(env, this, t);
 
 			String prompt = args[0].val();
 			try {
@@ -806,8 +807,8 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
-			if(!Static.InCmdLine(environment, true)) {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
+			if(!Static.InCmdLine(env, true)) {
 				throw new CREInsufficientPermissionException(getName() + " cannot be used outside of cmdline mode.", t);
 			}
 
@@ -865,7 +866,7 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			java.awt.Toolkit.getDefaultToolkit().beep();
 			return CVoid.VOID;
 		}
@@ -912,8 +913,8 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
-			if(Static.InCmdLine(environment, true)) {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
+			if(Static.InCmdLine(env, true)) {
 				try {
 					new jline.console.ConsoleReader().clearScreen();
 				} catch (IOException ex) {
@@ -967,12 +968,12 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(final Target t, final Environment environment, Mixed... args) throws ConfigRuntimeException {
-			if(!Static.InCmdLine(environment, true)) {
+		public Mixed exec(final Target t, final Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
+			if(!Static.InCmdLine(env, true)) {
 				if(!Prefs.AllowShellCommands()) {
 					throw new CREInsufficientPermissionException("Shell commands are not allowed. Enable them in preferences.ini.", t);
 				}
-				if(environment.getEnv(GlobalEnv.class).GetDynamicScriptingMode() && !Prefs.AllowDynamicShell()) {
+				if(env.getEnv(GlobalEnv.class).GetDynamicScriptingMode() && !Prefs.AllowDynamicShell()) {
 					throw new CREInsufficientPermissionException("Shell commands are disabled from dynamic sources.", t);
 				}
 			}
@@ -982,11 +983,11 @@ public Mixed exec(final Target t, final Environment environment, Mixed... args)
 			final CClosure stderr;
 			final CClosure exit;
 			final boolean subshell;
-			if(args[0].isInstanceOf(CArray.TYPE)) {
+			if(args[0].isInstanceOf(CArray.TYPE, null, env)) {
 				CArray array = (CArray) args[0];
-				command = new String[(int) array.size()];
-				for(int i = 0; i < array.size(); i++) {
-					command[i] = array.get(i, t).val();
+				command = new String[(int) array.size(env)];
+				for(int i = 0; i < array.size(env); i++) {
+					command[i] = array.get(i, t, env).val();
 				}
 			} else {
 				command = StringUtils.ArgParser(args[0].val()).toArray(new String[0]);
@@ -995,21 +996,21 @@ public Mixed exec(final Target t, final Environment environment, Mixed... args)
 				throw new CREIllegalArgumentException("Empty command passed to " + this.getName() + "().", t);
 			}
 			if(args.length > 1) {
-				CArray options = ArgumentValidation.getArray(args[1], t);
-				if(options.containsKey("workingDir") && !(options.get("workingDir", t) instanceof CNull)) {
-					workingDir = new File(options.get("workingDir", t).val());
+				CArray options = ArgumentValidation.getArray(args[1], t, env);
+				if(options.containsKey("workingDir") && !(options.get("workingDir", t, env) instanceof CNull)) {
+					workingDir = new File(options.get("workingDir", t, env).val());
 					if(!workingDir.isAbsolute()) {
 						workingDir = new File(t.file().getParentFile(), workingDir.getPath());
 					}
 				}
-				stdout = (options.containsKey("stdout") && !(options.get("stdout", t) instanceof CNull)
-						? ArgumentValidation.getObject(options.get("stdout", t), t, CClosure.class) : null);
-				stderr = (options.containsKey("stderr") && !(options.get("stderr", t) instanceof CNull)
-						? ArgumentValidation.getObject(options.get("stderr", t), t, CClosure.class) : null);
-				exit = (options.containsKey("exit") && !(options.get("exit", t) instanceof CNull)
-						? ArgumentValidation.getObject(options.get("exit", t), t, CClosure.class) : null);
+				stdout = (options.containsKey("stdout") && !(options.get("stdout", t, env) instanceof CNull)
+						? ArgumentValidation.getObject(options.get("stdout", t, env), t, CClosure.class) : null);
+				stderr = (options.containsKey("stderr") && !(options.get("stderr", t, env) instanceof CNull)
+						? ArgumentValidation.getObject(options.get("stderr", t, env), t, CClosure.class) : null);
+				exit = (options.containsKey("exit") && !(options.get("exit", t, env) instanceof CNull)
+						? ArgumentValidation.getObject(options.get("exit", t, env), t, CClosure.class) : null);
 				subshell = (options.containsKey("subshell")
-						? ArgumentValidation.getBoolean(options.get("subshell", t), t) : false);
+						? ArgumentValidation.getBoolean(options.get("subshell", t, env), t, env) : false);
 			} else {
 				stdout = null;
 				stderr = null;
@@ -1071,7 +1072,7 @@ public void write(int b) throws IOException {
 			}
 
 			Runnable run = () -> {
-				environment.getEnv(StaticRuntimeEnv.class).GetDaemonManager().activateThread(null);
+				env.getEnv(StaticRuntimeEnv.class).GetDaemonManager().activateThread(null);
 				try {
 					final int exitCode = cmd.waitFor();
 					try {
@@ -1103,7 +1104,7 @@ public void write(int b) throws IOException {
 				} catch (InterruptedException ex) {
 					throw ConfigRuntimeException.CreateUncatchableException(ex.getMessage(), t);
 				} finally {
-					environment.getEnv(StaticRuntimeEnv.class).GetDaemonManager().deactivateThread(null);
+					env.getEnv(StaticRuntimeEnv.class).GetDaemonManager().deactivateThread(null);
 				}
 			};
 			if(subshell) {
@@ -1175,23 +1176,23 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
-			if(!Static.InCmdLine(environment, true)) {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
+			if(!Static.InCmdLine(env, true)) {
 				if(!Prefs.AllowShellCommands()) {
 					throw new CREInsufficientPermissionException("Shell commands are not allowed. Enable them in preferences.ini.", t);
 				}
-				if(environment.getEnv(GlobalEnv.class).GetDynamicScriptingMode() && !Prefs.AllowDynamicShell()) {
+				if(env.getEnv(GlobalEnv.class).GetDynamicScriptingMode() && !Prefs.AllowDynamicShell()) {
 					throw new CREInsufficientPermissionException("Shell commands are disabled from dynamic sources.", t);
 				}
 			}
 			String[] command;
 			int expectedExitCode = 0;
 			File workingDir = null;
-			if(args[0].isInstanceOf(CArray.TYPE)) {
+			if(args[0].isInstanceOf(CArray.TYPE, null, env)) {
 				CArray array = (CArray) args[0];
-				command = new String[(int) array.size()];
-				for(int i = 0; i < array.size(); i++) {
-					command[i] = array.get(i, t).val();
+				command = new String[(int) array.size(env)];
+				for(int i = 0; i < array.size(env); i++) {
+					command[i] = array.get(i, t, env).val();
 				}
 			} else {
 				command = StringUtils.ArgParser(args[0].val()).toArray(new String[0]);
@@ -1200,12 +1201,12 @@ public Mixed exec(Target t, Environment environment, Mixed... args) throws Confi
 				throw new CREIllegalArgumentException("Empty command passed to " + this.getName() + "().", t);
 			}
 			if(args.length > 1) {
-				CArray options = ArgumentValidation.getArray(args[1], t);
+				CArray options = ArgumentValidation.getArray(args[1], t, env);
 				if(options.containsKey("expectedExitCode")) {
-					expectedExitCode = ArgumentValidation.getInt32(options.get("expectedExitCode", t), t);
+					expectedExitCode = ArgumentValidation.getInt32(options.get("expectedExitCode", t, env), t, env);
 				}
-				if(options.containsKey("workingDir") && !(options.get("workingDir", t) instanceof CNull)) {
-					workingDir = new File(options.get("workingDir", t).val());
+				if(options.containsKey("workingDir") && !(options.get("workingDir", t, env) instanceof CNull)) {
+					workingDir = new File(options.get("workingDir", t, env).val());
 					if(!workingDir.isAbsolute()) {
 						workingDir = new File(t.file().getParentFile(), workingDir.getPath());
 					}
@@ -1314,7 +1315,7 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			Set<OSUtils.OS> oses = new HashSet<>();
 			String osS = args[0].val();
 			for(String osSS : osS.split("\\|")) {
@@ -1327,7 +1328,7 @@ public Mixed exec(Target t, Environment environment, Mixed... args) throws Confi
 				oses.add(os);
 			}
 			if(oses.contains(OSUtils.GetOS())) {
-				return new shell_adv().exec(t, environment, ArrayUtils.cast(ArrayUtils.slice(args, 1, args.length - 1), Construct[].class));
+				return new shell_adv().exec(t, env, null, ArrayUtils.cast(ArrayUtils.slice(args, 1, args.length - 1), Construct[].class));
 			}
 			return CVoid.VOID;
 		}
@@ -1380,7 +1381,7 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			Set<OSUtils.OS> oses = new HashSet<>();
 			String osS = args[0].val();
 			for(String osSS : osS.split("\\|")) {
@@ -1393,7 +1394,7 @@ public Mixed exec(Target t, Environment environment, Mixed... args) throws Confi
 				oses.add(os);
 			}
 			if(oses.contains(OSUtils.GetOS())) {
-				return new shell().exec(t, environment, ArrayUtils.cast(ArrayUtils.slice(args, 1, args.length - 1), Construct[].class));
+				return new shell().exec(t, env, null, ArrayUtils.cast(ArrayUtils.slice(args, 1, args.length - 1), Construct[].class));
 			}
 			return CNull.NULL;
 		}
@@ -1456,7 +1457,7 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			return new CString(OSUtils.GetOS().name(), t);
 		}
 
@@ -1501,8 +1502,8 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
-			if(!Static.InCmdLine(environment, true)) {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
+			if(!Static.InCmdLine(env, true)) {
 				throw new CREInsufficientPermissionException(getName() + " cannot be used outside of cmdline mode.", t);
 			}
 			if(System.console() != null) {
@@ -1510,7 +1511,7 @@ public Mixed exec(Target t, Environment environment, Mixed... args) throws Confi
 			}
 			boolean binary = false;
 			if(args.length > 0) {
-				binary = ArgumentValidation.getBoolean(args[0], t);
+				binary = ArgumentValidation.getBoolean(args[0], t, env);
 			}
 			try {
 				if(binary) {
@@ -1585,10 +1586,10 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			File root;
-			if(Static.InCmdLine(environment, true)) {
-				root = environment.getEnv(GlobalEnv.class).GetRootFolder();
+			if(Static.InCmdLine(env, true)) {
+				root = env.getEnv(GlobalEnv.class).GetRootFolder();
 			} else if(t.file() == null) {
 				root = null;
 			} else {
@@ -1652,13 +1653,13 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
-			requireCmdlineMode(environment, this, t);
-			File cd = Static.GetFileFromArgument(args.length == 0 ? null : args[0].val(), environment, t, new File(System.getProperty("user.home")));
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
+			requireCmdlineMode(env, this, t);
+			File cd = Static.GetFileFromArgument(args.length == 0 ? null : args[0].val(), env, t, new File(System.getProperty("user.home")));
 			if(!cd.exists()) {
 				throw new CREIOException("No such file or directory: " + cd.getPath(), t);
 			}
-			environment.getEnv(GlobalEnv.class).SetRootFolder(cd);
+			env.getEnv(GlobalEnv.class).SetRootFolder(cd);
 			return CVoid.VOID;
 		}
 
@@ -1704,10 +1705,10 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
-			requireCmdlineMode(environment, this, t);
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
+			requireCmdlineMode(env, this, t);
 			CArray ca = new CArray(t);
-			File cwd = Static.GetFileFromArgument(args.length > 0 ? args[0].val() : null, environment, t, environment.getEnv(GlobalEnv.class).GetRootFolder());
+			File cwd = Static.GetFileFromArgument(args.length > 0 ? args[0].val() : null, env, t, env.getEnv(GlobalEnv.class).GetRootFolder());
 			if(cwd.isDirectory()) {
 				File[] fs = cwd.listFiles();
 				if(fs == null) {
@@ -1715,7 +1716,7 @@ public Mixed exec(Target t, Environment environment, Mixed... args) throws Confi
 				}
 
 				for(File f : fs) {
-					ca.push(new CString(f.getName(), t), t);
+					ca.push(new CString(f.getName(), t), t, env);
 				}
 			} else {
 				throw new CREIOException("No such directory: " + cwd.getPath(), t);
@@ -1765,12 +1766,12 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
-			requireCmdlineMode(environment, this, t);
-			if(!(args[0].isInstanceOf(CClosure.TYPE))) {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
+			requireCmdlineMode(env, this, t);
+			if(!(args[0].isInstanceOf(CClosure.TYPE, null, env))) {
 				throw new CRECastException("Expecting a closure for argument 1 of " + getName(), t);
 			}
-			environment.getEnv(GlobalEnv.class).SetCustom("cmdline_prompt", args[0]);
+			env.getEnv(GlobalEnv.class).SetCustom("cmdline_prompt", args[0]);
 			return CVoid.VOID;
 		}
 
@@ -1818,8 +1819,8 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
-			requireCmdlineMode(environment, this, t);
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
+			requireCmdlineMode(env, this, t);
 			try {
 				int i = new jline.console.ConsoleReader().getTerminal().getWidth();
 				return new CInt(i, t);
@@ -1870,8 +1871,8 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
-			String name = StaticLayer.GetConvertor().GetUser(environment);
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
+			String name = StaticLayer.GetConvertor().GetUser(env);
 			if(name == null) {
 				return CNull.NULL;
 			} else {
@@ -1922,8 +1923,8 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
-			return CBoolean.GenerateCBoolean(Static.InCmdLine(environment, true), t);
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
+			return CBoolean.GenerateCBoolean(Static.InCmdLine(env, true), t);
 		}
 
 		@Override
@@ -1967,14 +1968,14 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
-			requireCmdlineMode(environment, this, t);
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
+			requireCmdlineMode(env, this, t);
 			final CArray a = new CArray(t);
 			String regex = ArgumentValidation.getString(args[0], t);
-			String startFrom = environment.getEnv(GlobalEnv.class).GetRootFolder().getAbsolutePath();
+			String startFrom = env.getEnv(GlobalEnv.class).GetRootFolder().getAbsolutePath();
 			Set<FindType> findTypes = EnumSet.allOf(FindType.class);
 			if(args.length == 2) {
-				if(args[1].isInstanceOf(CArray.TYPE)) {
+				if(args[1].isInstanceOf(CArray.TYPE, null, env)) {
 					findTypes = ArgumentValidation.getEnumSet(args[1], FindType.class, t);
 				} else {
 					startFrom = ArgumentValidation.getString(args[1], t);
@@ -1992,7 +1993,7 @@ public Mixed exec(Target t, Environment environment, Mixed... args) throws Confi
 				FileUtil.recursiveFind(startFromF, (file) -> {
 					// We are such a potentially long running process, that we want to specially provide support
 					// for Ctrl-C, so we check for interruption here.
-					if(environment.getEnv(GlobalEnv.class).IsInterrupted()) {
+					if(env.getEnv(GlobalEnv.class).IsInterrupted()) {
 						throw new CancelCommandException("", Target.UNKNOWN);
 					}
 					if(!types.contains(FindType.FILE) && file.isHidden()) {
@@ -2005,7 +2006,7 @@ public Mixed exec(Target t, Environment environment, Mixed... args) throws Confi
 						return;
 					}
 					if(file.getName().matches(regex)) {
-						a.push(new CString(file.getAbsolutePath(), t), t);
+						a.push(new CString(file.getAbsolutePath(), t), t, env);
 					}
 				});
 			} catch (IOException ex) {
@@ -2076,13 +2077,13 @@ public Version since() {
 	/**
 	 * Requires cmdline mode. If not currently in cmdline mode, a proper CRE is thrown.
 	 *
-	 * @param environment
+	 * @param env
 	 * @param f The function this is being called from.
 	 * @param t
 	 * @throws ConfigRuntimeException If not in cmdline mode.
 	 */
-	public static void requireCmdlineMode(Environment environment, Function f, Target t) throws ConfigRuntimeException {
-		if(!Static.InCmdLine(environment, true)) {
+	public static void requireCmdlineMode(Environment env, Function f, Target t) throws ConfigRuntimeException {
+		if(!Static.InCmdLine(env, true)) {
 			throw new CREInsufficientPermissionException(f.getName() + " cannot be used outside of cmdline mode.", t);
 		}
 	}
diff --git a/src/main/java/com/laytonsmith/core/functions/Commands.java b/src/main/java/com/laytonsmith/core/functions/Commands.java
index 302391b584..ba8ef3a1bd 100644
--- a/src/main/java/com/laytonsmith/core/functions/Commands.java
+++ b/src/main/java/com/laytonsmith/core/functions/Commands.java
@@ -17,6 +17,7 @@
 import com.laytonsmith.core.constructs.CString;
 import com.laytonsmith.core.constructs.CVoid;
 import com.laytonsmith.core.constructs.Target;
+import com.laytonsmith.core.constructs.generics.GenericParameters;
 import com.laytonsmith.core.environments.CommandHelperEnvironment;
 import com.laytonsmith.core.environments.Environment;
 import com.laytonsmith.core.exceptions.CRE.CRECastException;
@@ -68,7 +69,7 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			MCServer s = Static.getServer();
 			MCCommandMap map = s.getCommandMap();
 			if(map == null) {
@@ -78,7 +79,7 @@ public Mixed exec(Target t, Environment environment, Mixed... args) throws Confi
 			if(cmd == null) {
 				throw new CRENotFoundException("Command not found, did you forget to register it?", t);
 			}
-			customExec(t, environment, cmd, args[1]);
+			customExec(t, env, cmd, args[1]);
 			return CVoid.VOID;
 		}
 
@@ -86,12 +87,12 @@ public Mixed exec(Target t, Environment environment, Mixed... args) throws Confi
 		 * For setting the completion code of a command that exists but might not be registered yet
 		 *
 		 * @param t
-		 * @param environment
+		 * @param env
 		 * @param cmd
 		 * @param arg
 		 */
-		public static void customExec(Target t, Environment environment, MCCommand cmd, Mixed arg) {
-			if(arg.isInstanceOf(Callable.TYPE)) {
+		public static void customExec(Target t, Environment env, MCCommand cmd, Mixed arg) {
+			if(arg.isInstanceOf(Callable.TYPE, null, env)) {
 				onTabComplete.put(cmd.getName(), (Callable) arg);
 			} else {
 				throw new CREFormatException("Only Callables are accepted as tabcompleters", t);
@@ -164,7 +165,7 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			MCCommandMap map = Static.getServer().getCommandMap();
 			if(map == null) {
 				throw new CRENotFoundException(this.getName() + " is not supported in this mode (CommandMap not found).", t);
@@ -225,7 +226,7 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			MCCommandMap map = Static.getServer().getCommandMap();
 			if(map == null) {
 				throw new CRENotFoundException(
@@ -243,7 +244,7 @@ public Mixed exec(Target t, Environment environment, Mixed... args) throws Confi
 				register = true;
 				cmd = StaticLayer.GetConvertor().getNewCommand(cmdStr);
 			}
-			if(args[1].isInstanceOf(CArray.TYPE)) {
+			if(args[1].isInstanceOf(CArray.TYPE, null, env)) {
 				CArray ops = (CArray) args[1];
 				if(ops.containsKey("permission")) {
 					cmd.setPermission(ops.get("permission", t).val());
@@ -259,7 +260,7 @@ public Mixed exec(Target t, Environment environment, Mixed... args) throws Confi
 				}
 				List<String> oldAliases = new ArrayList<>(cmd.getAliases());
 				if(ops.containsKey("aliases")) {
-					if(ops.get("aliases", t).isInstanceOf(CArray.TYPE)) {
+					if(ops.get("aliases", t).isInstanceOf(CArray.TYPE, null, env)) {
 						List<Mixed> ca = ((CArray) ops.get("aliases", t)).asList();
 						List<String> aliases = new ArrayList<>();
 						for(Mixed c : ca) {
@@ -280,10 +281,10 @@ public Mixed exec(Target t, Environment environment, Mixed... args) throws Confi
 					}
 				}
 				if(ops.containsKey("executor")) {
-					set_executor.customExec(t, environment, cmd, ops.get("executor", t));
+					set_executor.customExec(t, env, cmd, ops.get("executor", t));
 				}
 				if(ops.containsKey("tabcompleter")) {
-					set_tabcompleter.customExec(t, environment, cmd, ops.get("tabcompleter", t));
+					set_tabcompleter.customExec(t, env, cmd, ops.get("tabcompleter", t));
 				}
 				boolean success = true;
 				if(register) {
@@ -496,7 +497,7 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			MCCommandMap map = Static.getServer().getCommandMap();
 			if(map == null) {
 				throw new CRENotFoundException(this.getName() + " is not supported in this mode (CommandMap not found).", t);
@@ -505,7 +506,7 @@ public Mixed exec(Target t, Environment environment, Mixed... args) throws Confi
 			if(cmd == null) {
 				throw new CRENotFoundException("Command not found did you forget to register it?", t);
 			}
-			customExec(t, environment, cmd, args[1]);
+			customExec(t, env, cmd, args[1]);
 			return CVoid.VOID;
 		}
 
@@ -513,12 +514,12 @@ public Mixed exec(Target t, Environment environment, Mixed... args) throws Confi
 		 * For setting the execution code of a command that exists but might not be registered yet
 		 *
 		 * @param t
-		 * @param environment
+		 * @param env
 		 * @param cmd
 		 * @param arg
 		 */
-		static void customExec(Target t, Environment environment, MCCommand cmd, Mixed arg) {
-			if(arg.isInstanceOf(CClosure.TYPE)) {
+		static void customExec(Target t, Environment env, MCCommand cmd, Mixed arg) {
+			if(arg.isInstanceOf(CClosure.TYPE, null, env)) {
 				onCommand.put(cmd.getName(), (CClosure) arg);
 			} else {
 				throw new CREFormatException("At this time, only closures are accepted as command executors.", t);
@@ -568,7 +569,7 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			MCCommandMap map = Static.getServer().getCommandMap();
 			if(map == null) {
 				return CNull.NULL;
@@ -641,7 +642,7 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			MCCommandMap map = Static.getServer().getCommandMap();
 			if(map != null) {
 				map.clearCommands();
diff --git a/src/main/java/com/laytonsmith/core/functions/Compiler.java b/src/main/java/com/laytonsmith/core/functions/Compiler.java
index 26a2ebee2b..da57cdbaac 100644
--- a/src/main/java/com/laytonsmith/core/functions/Compiler.java
+++ b/src/main/java/com/laytonsmith/core/functions/Compiler.java
@@ -8,11 +8,14 @@
 import com.laytonsmith.annotations.noprofile;
 import com.laytonsmith.core.ArgumentValidation;
 import com.laytonsmith.core.FullyQualifiedClassName;
+import com.laytonsmith.core.FlowFunction;
 import com.laytonsmith.core.MSVersion;
 import com.laytonsmith.core.Optimizable;
 import com.laytonsmith.core.ParseTree;
-import com.laytonsmith.core.Script;
 import com.laytonsmith.core.Optimizable.OptimizationOption;
+import com.laytonsmith.core.StepAction.Complete;
+import com.laytonsmith.core.StepAction.Evaluate;
+import com.laytonsmith.core.StepAction.StepResult;
 import com.laytonsmith.core.compiler.CompilerEnvironment;
 import com.laytonsmith.core.compiler.CompilerWarning;
 import com.laytonsmith.core.compiler.FileOptions;
@@ -36,6 +39,7 @@
 import com.laytonsmith.core.constructs.InstanceofUtil;
 import com.laytonsmith.core.constructs.Target;
 import com.laytonsmith.core.constructs.Token;
+import com.laytonsmith.core.constructs.generics.GenericParameters;
 import com.laytonsmith.core.environments.Environment;
 import com.laytonsmith.core.environments.GlobalEnv;
 import com.laytonsmith.core.environments.Environment.EnvironmentImpl;
@@ -76,7 +80,7 @@ public static String docs() {
 	@api
 	@noprofile
 	@hide("This is only used internally by the compiler.")
-	public static class p extends DummyFunction implements Optimizable {
+	public static class p extends DummyFunction implements FlowFunction<Void>, Optimizable {
 
 		public static final String NAME = "p";
 
@@ -91,17 +95,20 @@ public String docs() {
 		}
 
 		@Override
-		public boolean useSpecialExec() {
-			return true;
+		public StepResult<Void> begin(Target t, ParseTree[] children, Environment env) {
+			if(children.length == 1) {
+				return new StepResult<>(new Evaluate(children[0]), null);
+			}
+			return new StepResult<>(new Complete(CVoid.VOID), null);
 		}
 
 		@Override
-		public Mixed execs(Target t, Environment env, Script parent, ParseTree... nodes) {
-			return (nodes.length == 1 ? parent.eval(nodes[0], env) : CVoid.VOID);
+		public StepResult<Void> childCompleted(Target t, Void state, Mixed result, Environment env) {
+			return new StepResult<>(new Complete(result), null);
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment env, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			return CVoid.VOID;
 		}
 
@@ -154,7 +161,7 @@ public String docs() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			return new CEntry(args[0], args[1], t);
 		}
 	}
@@ -167,7 +174,7 @@ public static class __autoconcat__ extends DummyFunction {
 		public static final String NAME = "__autoconcat__";
 
 		@Override
-		public Mixed exec(Target t, Environment env, Mixed... args) throws CancelCommandException, ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws CancelCommandException, ConfigRuntimeException {
 			throw new Error("Should not have gotten here, " + __autoconcat__.NAME + " was not removed before runtime.");
 		}
 
@@ -363,7 +370,7 @@ public static ParseTree rewrite(List<ParseTree> list, boolean returnSConcat,
 
 					// Convert bare string or concat() to type reference if needed.
 					ParseTree typeNode = node.getChildAt(0);
-					if(!typeNode.getData().isInstanceOf(CClassType.TYPE)) {
+					if(!(typeNode.getData() instanceof CClassType)) {
 						ParseTree convertedTypeNode = __type_ref__.createFromBareStringOrConcats(typeNode);
 						if(convertedTypeNode != null) {
 							typeNode = convertedTypeNode;
@@ -469,7 +476,7 @@ public static ParseTree rewrite(List<ParseTree> list, boolean returnSConcat,
 				}
 
 				if(convertedTypeNode != null
-						|| typeNode.getData().equals(CVoid.VOID) || typeNode.getData().isInstanceOf(CClassType.TYPE)) {
+						|| typeNode.getData().equals(CVoid.VOID) || typeNode.getData() instanceof CClassType) {
 					if(k == list.size() - 1) {
 						// This is not a typed assignment
 						break;
@@ -498,7 +505,7 @@ public static ParseTree rewrite(List<ParseTree> list, boolean returnSConcat,
 								list.get(k).setChildren(children);
 								break;
 							default:
-								if(typeNode.getData().equals(CVoid.VOID) || typeNode.getData().isInstanceOf(CClassType.TYPE)) {
+								if(typeNode.getData().equals(CVoid.VOID) || typeNode.getData() instanceof CClassType) {
 									throw new ConfigCompileException("Unexpected ClassType \""
 											+ typeNode.getData().val() + "\"", typeNode.getTarget());
 								}
@@ -570,9 +577,9 @@ public static ParseTree rewrite(List<ParseTree> list, boolean returnSConcat,
 								child.setChildren(list);
 							}
 							try {
-								Function f = (Function) FunctionList.getFunction(identifier, envs);
-								ParseTree node = new ParseTree(
-										f.execs(identifier.getTarget(), null, null, child), child.getFileOptions());
+								FunctionList.getFunction(identifier, envs);
+								ParseTree node = new ParseTree(identifier, child.getFileOptions());
+								node.addChild(child);
 								if(node.getData() instanceof CFunction
 										&& node.getData().val().equals(__autoconcat__.NAME)) {
 									node = rewrite(node.getChildren(), returnSConcat, envs);
@@ -663,7 +670,7 @@ private static void rewriteParenthesis(List<ParseTree> list) throws ConfigCompil
 					// Do not rewrite casts to execute() if the callable is the cast (i.e. "(type) (val)").
 					if(prevNodeVal instanceof CFunction cfunc && cfunc.val().equals(Compiler.p.NAME)
 							&& prevNode.numberOfChildren() == 1
-							&& (prevNode.getChildAt(0).getData().isInstanceOf(CClassType.TYPE)
+							&& (prevNode.getChildAt(0).getData() instanceof CClassType
 									|| __type_ref__.createFromBareStringOrConcats(prevNode.getChildAt(0)) != null)) {
 						break;
 					}
@@ -716,7 +723,7 @@ public String docs() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment env, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			return CVoid.VOID;
 		}
 
@@ -782,7 +789,7 @@ public Integer[] numArgs() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment env, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			throw new CRENotFoundException("\"" + args[0].val() + "\" cannot be resolved to a type.", t);
 		}
 
@@ -910,7 +917,7 @@ public boolean isRestricted() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment env, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			String s = null;
 			if(args.length == 1) {
 				s = args[0].val();
@@ -936,7 +943,7 @@ public String docs() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			if(args.length == 0) {
 				return CVoid.VOID;
 			}
@@ -949,7 +956,7 @@ public Mixed exec(Target t, Environment environment, Mixed... args) throws Confi
 	public static class __cbracket__ extends DummyFunction implements Optimizable {
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			throw new UnsupportedOperationException("Not supported yet.");
 		}
 
@@ -985,7 +992,7 @@ public static class __cbrace__ extends DummyFunction implements Optimizable {
 		public static final String NAME = "__cbrace__";
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			throw new UnsupportedOperationException("Not supported yet.");
 		}
 
@@ -1066,7 +1073,7 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			throw new UnsupportedOperationException(getName() + " should have been compiled out. If you are reaching"
 					+ " this, an error has occurred in the parser. Please report this error to the developers.");
 		}
@@ -1096,7 +1103,7 @@ public ParseTree postParseRewrite(ParseTree ast, Environment env,
 				if(children.size() != 1) {
 					throw new ConfigCompileException(getName() + " can only take one parameter", t);
 				}
-				if(!(children.get(0).getData().isInstanceOf(CString.TYPE))) {
+				if(!(children.get(0).getData().isInstanceOf(CString.TYPE, null, env))) {
 					throw new ConfigCompileException("Only hardcoded strings may be passed into " + getName(), t);
 				}
 				String value = children.get(0).getData().val();
@@ -1240,12 +1247,12 @@ public String docs() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment env, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			Mixed value = args[0];
 			CClassType type = ArgumentValidation.getClassType(args[1], t);
 			if(!InstanceofUtil.isInstanceof(value, type, env)) {
 				throw new CRECastException(
-						"Cannot cast from " + value.typeof().getSimpleName() + " to " + type.getSimpleName() + ".", t);
+						"Cannot cast from " + value.typeof(env).getSimpleName() + " to " + type.getSimpleName() + ".", t);
 			}
 			return value;
 		}
@@ -1337,7 +1344,7 @@ public String getName() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment env, Mixed... args) throws CancelCommandException, ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws CancelCommandException, ConfigRuntimeException {
 
 			// Get arguments.
 			CClassType type;
diff --git a/src/main/java/com/laytonsmith/core/functions/CompositeFunction.java b/src/main/java/com/laytonsmith/core/functions/CompositeFunction.java
index 30937cdf93..206a6c6a1f 100644
--- a/src/main/java/com/laytonsmith/core/functions/CompositeFunction.java
+++ b/src/main/java/com/laytonsmith/core/functions/CompositeFunction.java
@@ -1,12 +1,14 @@
 package com.laytonsmith.core.functions;
 
 import com.laytonsmith.PureUtilities.Common.StreamUtils;
-import com.laytonsmith.core.MSLog;
+import com.laytonsmith.core.FlowFunction;
 import com.laytonsmith.core.MethodScriptCompiler;
 import com.laytonsmith.core.NodeModifiers;
 import com.laytonsmith.core.ParseTree;
 import com.laytonsmith.core.Prefs;
 import com.laytonsmith.core.Script;
+import com.laytonsmith.core.StepAction;
+import com.laytonsmith.core.StepAction.StepResult;
 import com.laytonsmith.core.compiler.analysis.ParamDeclaration;
 import com.laytonsmith.core.compiler.analysis.ReturnableDeclaration;
 import com.laytonsmith.core.compiler.analysis.Scope;
@@ -16,12 +18,12 @@
 import com.laytonsmith.core.constructs.IVariable;
 import com.laytonsmith.core.constructs.IVariableList;
 import com.laytonsmith.core.constructs.Target;
+import com.laytonsmith.core.constructs.generics.GenericParameters;
 import com.laytonsmith.core.environments.Environment;
 import com.laytonsmith.core.environments.GlobalEnv;
 import com.laytonsmith.core.exceptions.ConfigCompileException;
 import com.laytonsmith.core.exceptions.ConfigCompileGroupException;
 import com.laytonsmith.core.exceptions.ConfigRuntimeException;
-import com.laytonsmith.core.exceptions.FunctionReturnException;
 import com.laytonsmith.core.natives.interfaces.Mixed;
 import java.io.File;
 
@@ -36,42 +38,25 @@
  * exist on a given platform, the function can be automatically provided on that platform.
  * This prevents rewrites for straightforward functions.
  */
-public abstract class CompositeFunction extends AbstractFunction {
+public abstract class CompositeFunction extends AbstractFunction
+		implements FlowFunction<CompositeFunction.CompositeState> {
 
 	private static final Map<Class<? extends CompositeFunction>, ParseTree> CACHED_SCRIPTS = new HashMap<>();
 
+	static class CompositeState {
+		enum Phase { EVAL_ARGS, EVAL_BODY }
+		Phase phase = Phase.EVAL_ARGS;
+		ParseTree[] children;
+		Mixed[] evaluatedArgs;
+		int argIndex = 0;
+		IVariableList oldVariables;
+	}
+
 	@Override
-	public final Mixed exec(Target t, Environment env, Mixed... args) throws ConfigRuntimeException {
-		ParseTree tree;
-		// TODO: Ultimately, this is not scalable. We need to compile and cache these scripts at Java compile time,
-		// not at runtime the first time a function is used. This is an easier first step though.
-		File debugFile = null;
-		if(Prefs.DebugMode()) {
-			debugFile = new File("/NATIVE-MSCRIPT/" + getName());
-		}
-		if(!CACHED_SCRIPTS.containsKey(this.getClass())) {
-			try {
-
-				String script = script();
-				Scope rootScope = new Scope();
-				rootScope.addDeclaration(new ParamDeclaration("@arguments", CArray.TYPE, null,
-						new NodeModifiers(),
-						Target.UNKNOWN));
-				rootScope.addDeclaration(new ReturnableDeclaration(null, new NodeModifiers(), Target.UNKNOWN));
-				tree = MethodScriptCompiler.compile(MethodScriptCompiler.lex(script, env, debugFile, true),
-						env, env.getEnvClasses(), new StaticAnalysis(rootScope, true))
-						// the root of the tree is null, so go ahead and pull it up
-						.getChildAt(0);
-			} catch (ConfigCompileException | ConfigCompileGroupException ex) {
-				// This is really bad.
-				throw new Error(ex);
-			}
-			if(cacheCompile()) {
-				CACHED_SCRIPTS.put(this.getClass(), tree);
-			}
-		} else {
-			tree = CACHED_SCRIPTS.get(this.getClass());
-		}
+	public final Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
+		// Sync fallback for compile-time optimization (CONSTANT_OFFLINE).
+		// The FlowFunction path is used during normal interpretation.
+		ParseTree tree = getOrCompileTree(env);
 
 		GlobalEnv gEnv = env.getEnv(GlobalEnv.class);
 		IVariableList oldVariables = gEnv.GetVarList();
@@ -81,32 +66,107 @@ public final Mixed exec(Target t, Environment env, Mixed... args) throws ConfigR
 		Mixed ret = CVoid.VOID;
 		try {
 			if(gEnv.GetScript() != null) {
-				gEnv.GetScript().eval(tree, env);
+				ret = gEnv.GetScript().eval(tree, env);
 			} else {
-				// This can happen when the environment is not fully setup during tests, in addition to optimization
-				Script.GenerateScript(null, null, null).eval(tree, env);
-			}
-		} catch (FunctionReturnException ex) {
-			ret = ex.getReturn();
-		} catch (ConfigRuntimeException ex) {
-			if(Prefs.DebugMode()) {
-				MSLog.GetLogger().e(MSLog.Tags.GENERAL, "Possibly false stacktrace, could be internal error",
-						ex.getTarget());
-			}
-			if(gEnv.GetStackTraceManager().getCurrentStackTrace().isEmpty()) {
-				ex.setTarget(t);
-				ConfigRuntimeException.StackTraceElement ste = new ConfigRuntimeException
-						.StackTraceElement(this.getName(), t);
-				gEnv.GetStackTraceManager().addStackTraceElement(ste);
+				ret = Script.GenerateScript(null, null, null).eval(tree, env);
 			}
-			gEnv.GetStackTraceManager().setCurrentTarget(t);
-			throw ex;
+		} finally {
+			gEnv.SetVarList(oldVariables);
 		}
-		gEnv.SetVarList(oldVariables);
 
 		return ret;
 	}
 
+	@Override
+	public StepResult<CompositeState> begin(Target t, ParseTree[] children, Environment env) {
+		CompositeState state = new CompositeState();
+		state.children = children;
+		state.evaluatedArgs = new Mixed[children.length];
+		if(children.length > 0) {
+			return new StepResult<>(new StepAction.Evaluate(children[0]), state);
+		} else {
+			return evalBody(t, state, env);
+		}
+	}
+
+	@Override
+	public StepResult<CompositeState> childCompleted(Target t, CompositeState state, Mixed result, Environment env) {
+		if(state.phase == CompositeState.Phase.EVAL_ARGS) {
+			state.evaluatedArgs[state.argIndex] = result;
+			state.argIndex++;
+			if(state.argIndex < state.children.length) {
+				return new StepResult<>(new StepAction.Evaluate(state.children[state.argIndex]), state);
+			}
+			return evalBody(t, state, env);
+		} else {
+			// Body evaluation complete
+			return new StepResult<>(new StepAction.Complete(result), state);
+		}
+	}
+
+	@Override
+	public StepResult<CompositeState> childInterrupted(Target t, CompositeState state,
+			StepAction.FlowControl action, Environment env) {
+		if(state.phase == CompositeState.Phase.EVAL_BODY
+				&& action.getAction() instanceof ControlFlow.ReturnAction ret) {
+			return new StepResult<>(new StepAction.Complete(ret.getValue()), state);
+		}
+		return null;
+	}
+
+	@Override
+	public void cleanup(Target t, CompositeState state, Environment env) {
+		if(state != null && state.oldVariables != null) {
+			env.getEnv(GlobalEnv.class).SetVarList(state.oldVariables);
+		}
+	}
+
+	private StepResult<CompositeState> evalBody(Target t, CompositeState state, Environment env) {
+		state.phase = CompositeState.Phase.EVAL_BODY;
+		ParseTree tree = getOrCompileTree(env);
+
+		GlobalEnv gEnv = env.getEnv(GlobalEnv.class);
+		state.oldVariables = gEnv.GetVarList();
+		IVariableList newVariables = new IVariableList(state.oldVariables);
+		newVariables.set(new IVariable(CArray.TYPE, "@arguments",
+				new CArray(t, state.evaluatedArgs.length, state.evaluatedArgs), t));
+		gEnv.SetVarList(newVariables);
+
+		return new StepResult<>(new StepAction.Evaluate(tree), state);
+	}
+
+	private ParseTree getOrCompileTree(Environment env) {
+		if(CACHED_SCRIPTS.containsKey(this.getClass())) {
+			return CACHED_SCRIPTS.get(this.getClass());
+		}
+		// TODO: Ultimately, this is not scalable. We need to compile and cache these scripts at Java compile time,
+		// not at runtime the first time a function is used. This is an easier first step though.
+		File debugFile = null;
+		if(Prefs.DebugMode()) {
+			debugFile = new File("/NATIVE-MSCRIPT/" + getName());
+		}
+		ParseTree tree;
+		try {
+			String script = script();
+			Scope rootScope = new Scope();
+			rootScope.addDeclaration(new ParamDeclaration("@arguments", CArray.TYPE, null,
+					new NodeModifiers(),
+					Target.UNKNOWN));
+			rootScope.addDeclaration(new ReturnableDeclaration(null, new NodeModifiers(), Target.UNKNOWN));
+			tree = MethodScriptCompiler.compile(MethodScriptCompiler.lex(script, env, debugFile, true),
+					env, env.getEnvClasses(), new StaticAnalysis(rootScope, true))
+					// the root of the tree is null, so go ahead and pull it up
+					.getChildAt(0);
+		} catch(ConfigCompileException | ConfigCompileGroupException ex) {
+			// This is really bad.
+			throw new Error(ex);
+		}
+		if(cacheCompile()) {
+			CACHED_SCRIPTS.put(this.getClass(), tree);
+		}
+		return tree;
+	}
+
 	/**
 	 * The script that will be compiled and run when this function is executed. The value array @arguments will be set
 	 * with the function inputs. Variables set in this script will not leak to the actual script environment, but in
@@ -138,15 +198,4 @@ protected boolean cacheCompile() {
 		return true;
 	}
 
-	@Override
-	public final Mixed execs(Target t, Environment env, Script parent, ParseTree... nodes) {
-		throw new Error(this.getClass().toString());
-	}
-
-	@Override
-	public final boolean useSpecialExec() {
-		// This defeats the purpose, so don't allow this.
-		return false;
-	}
-
 }
diff --git a/src/main/java/com/laytonsmith/core/functions/ControlFlow.java b/src/main/java/com/laytonsmith/core/functions/ControlFlow.java
index b571627e0e..ba8c61dcff 100644
--- a/src/main/java/com/laytonsmith/core/functions/ControlFlow.java
+++ b/src/main/java/com/laytonsmith/core/functions/ControlFlow.java
@@ -9,12 +9,18 @@
 import com.laytonsmith.annotations.noboilerplate;
 import com.laytonsmith.annotations.seealso;
 import com.laytonsmith.core.ArgumentValidation;
+import com.laytonsmith.core.CallbackYield;
+import com.laytonsmith.core.FlowFunction;
 import com.laytonsmith.core.MSVersion;
 import com.laytonsmith.core.LogLevel;
 import com.laytonsmith.core.Optimizable;
 import com.laytonsmith.core.ParseTree;
 import com.laytonsmith.core.Procedure;
-import com.laytonsmith.core.Script;
+import com.laytonsmith.core.StepAction;
+import com.laytonsmith.core.StepAction.Complete;
+import com.laytonsmith.core.StepAction.Evaluate;
+import com.laytonsmith.core.StepAction.FlowControl;
+import com.laytonsmith.core.StepAction.StepResult;
 import com.laytonsmith.core.Static;
 import com.laytonsmith.core.compiler.BranchStatement;
 import com.laytonsmith.core.compiler.CompilerEnvironment;
@@ -51,7 +57,9 @@
 import com.laytonsmith.core.constructs.Construct;
 import com.laytonsmith.core.constructs.IVariable;
 import com.laytonsmith.core.constructs.InstanceofUtil;
+import com.laytonsmith.core.constructs.ProcedureUsage;
 import com.laytonsmith.core.constructs.Target;
+import com.laytonsmith.core.constructs.generics.GenericParameters;
 import com.laytonsmith.core.environments.CommandHelperEnvironment;
 import com.laytonsmith.core.environments.Environment;
 import com.laytonsmith.core.environments.GlobalEnv;
@@ -72,9 +80,7 @@
 import com.laytonsmith.core.exceptions.CancelCommandException;
 import com.laytonsmith.core.exceptions.ConfigCompileException;
 import com.laytonsmith.core.exceptions.ConfigRuntimeException;
-import com.laytonsmith.core.exceptions.FunctionReturnException;
-import com.laytonsmith.core.exceptions.LoopBreakException;
-import com.laytonsmith.core.exceptions.LoopContinueException;
+
 import com.laytonsmith.core.natives.interfaces.Booleanish;
 import com.laytonsmith.core.natives.interfaces.Iterator;
 import com.laytonsmith.core.natives.interfaces.Mixed;
@@ -96,9 +102,115 @@ public static String docs() {
 		return "This class provides various functions to manage control flow.";
 	}
 
+	// --- FlowControlAction types ---
+	// These are the first-class representations of control flow in the iterative interpreter.
+	// They replace the old ProgramFlowManipulationException hierarchy.
+
+	/**
+	 * Produced by {@code break()}. Propagates up to the nearest loop flow function.
+	 */
+	public static class BreakAction implements StepAction.FlowControlAction {
+		private final int levels;
+		private final Target target;
+
+		public BreakAction(int levels, Target target) {
+			this.levels = levels;
+			this.target = target;
+		}
+
+		public int getLevels() {
+			return levels;
+		}
+
+		@Override
+		public Target getTarget() {
+			return target;
+		}
+	}
+
+	/**
+	 * Produced by {@code continue()}. Propagates up to the nearest loop flow function.
+	 */
+	public static class ContinueAction implements StepAction.FlowControlAction {
+		private final int levels;
+		private final Target target;
+
+		public ContinueAction(int levels, Target target) {
+			this.levels = levels;
+			this.target = target;
+		}
+
+		public int getLevels() {
+			return levels;
+		}
+
+		@Override
+		public Target getTarget() {
+			return target;
+		}
+	}
+
+	/**
+	 * Produced by {@code return()}. Propagates up to the nearest procedure/closure boundary.
+	 */
+	public static class ReturnAction implements StepAction.FlowControlAction {
+		private final Mixed value;
+		private final Target target;
+
+		public ReturnAction(Mixed value, Target target) {
+			this.value = value;
+			this.target = target;
+		}
+
+		public Mixed getValue() {
+			return value;
+		}
+
+		@Override
+		public Target getTarget() {
+			return target;
+		}
+	}
+
 	@api
 	@ConditionalSelfStatement
-	public static class _if extends AbstractFunction implements Optimizable, BranchStatement, VariableScope {
+	public static class _if extends AbstractFunction implements FlowFunction<_if.IfState>, Optimizable, BranchStatement, VariableScope {
+
+		static class IfState {
+			ParseTree[] children;
+			boolean conditionEvaluated;
+
+			IfState(ParseTree[] children) {
+				this.children = children;
+			}
+
+			@Override
+			public String toString() {
+				return conditionEvaluated ? "branch" : "condition";
+			}
+		}
+
+		@Override
+		public StepResult<IfState> begin(Target t, ParseTree[] children, Environment env) {
+			IfState state = new IfState(children);
+			return new StepResult<>(new Evaluate(children[0]), state);
+		}
+
+		@Override
+		public StepResult<IfState> childCompleted(Target t, IfState state,
+				Mixed result, Environment env) {
+			if(!state.conditionEvaluated) {
+				state.conditionEvaluated = true;
+				if(ArgumentValidation.getBooleanish(result, t, env)) {
+					return new StepResult<>(new Evaluate(state.children[1]), state);
+				} else if(state.children.length == 3) {
+					return new StepResult<>(new Evaluate(state.children[2]), state);
+				} else {
+					return new StepResult<>(new Complete(CVoid.VOID), state);
+				}
+			}
+			return new StepResult<>(new Complete(result), state);
+		}
 
 		public static final String NAME = "if";
 
@@ -113,21 +225,7 @@ public Integer[] numArgs() {
 		}
 
 		@Override
-		public Mixed execs(Target t, Environment env, Script parent, ParseTree... nodes) {
-			ParseTree condition = nodes[0];
-			if(ArgumentValidation.getBooleanish(parent.seval(condition, env), t)) {
-				ParseTree ifCode = nodes[1];
-				return parent.seval(ifCode, env);
-			} else if(nodes.length == 3) {
-				ParseTree elseCode = nodes[2];
-				return parent.seval(elseCode, env);
-			} else {
-				return CVoid.VOID;
-			}
-		}
-
-		@Override
-		public Mixed exec(Target t, Environment env, Mixed... args)
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args)
 				throws CancelCommandException, ConfigRuntimeException {
 			return CVoid.VOID;
 		}
@@ -241,11 +339,6 @@ public Boolean runAsync() {
 			return false;
 		}
 
-		@Override
-		public boolean useSpecialExec() {
-			return true;
-		}
-
 		@Override
 		public Set<OptimizationOption> optimizationOptions() {
 			return EnumSet.of(
@@ -267,7 +360,7 @@ public ParseTree optimizeDynamic(Target t, Environment env,
 			}
 			if(args.get(0).isConst()) {
 				// We can optimize this one way or the other, since the condition is const
-				if(ArgumentValidation.getBoolean(args.get(0).getData(), t)) {
+				if(ArgumentValidation.getBoolean(args.get(0).getData(), t, env)) {
 					// It's true, return the true condition
 					return args.get(1);
 				} else // If there are three args, return the else condition, otherwise,
@@ -360,7 +453,55 @@ public boolean isSelfStatement(Target t, Environment env, List<ParseTree> nodes,
 
 	@api(environments = {GlobalEnv.class})
 	@ConditionalSelfStatement
-	public static class ifelse extends AbstractFunction implements Optimizable, BranchStatement, VariableScope {
+	public static class ifelse extends AbstractFunction implements FlowFunction<ifelse.IfElseState>, Optimizable, BranchStatement, VariableScope {
+
+		static class IfElseState {
+			ParseTree[] children;
+			int condIndex; // index of current condition being tested (even indices)
+			boolean evaluatingBranch;
+
+			IfElseState(ParseTree[] children) {
+				this.children = children;
+			}
+
+			@Override
+			public String toString() {
+				return evaluatingBranch ? "branch" : "cond " + condIndex;
+			}
+		}
+
+		@Override
+		public StepResult<IfElseState> begin(Target t, ParseTree[] children, Environment env) {
+			if(children.length < 2) {
+				throw new CREInsufficientArgumentsException("ifelse expects at least 2 arguments", t);
+			}
+			IfElseState state = new IfElseState(children);
+			return new StepResult<>(new Evaluate(children[0]), state);
+		}
+
+		@Override
+		public StepResult<IfElseState> childCompleted(Target t, IfElseState state,
+				Mixed result, Environment env) {
+			if(state.evaluatingBranch) {
+				return new StepResult<>(new Complete(result), state);
+			}
+			// We just evaluated a condition
+			if(ArgumentValidation.getBooleanish(result, t, env)) {
+				state.evaluatingBranch = true;
+				return new StepResult<>(new Evaluate(state.children[state.condIndex + 1]), state);
+			}
+			// Condition was false, advance to next pair
+			state.condIndex += 2;
+			if(state.condIndex <= state.children.length - 2) {
+				return new StepResult<>(new Evaluate(state.children[state.condIndex]), state);
+			}
+			// No more condition pairs — check for else block (odd number of children)
+			if(state.children.length % 2 == 1) {
+				state.evaluatingBranch = true;
+				return new StepResult<>(new Evaluate(state.children[state.children.length - 1]), state);
+			}
+			return new StepResult<>(new Complete(CVoid.VOID), state);
+		}
 
 		public static final String NAME = "ifelse";
 
@@ -407,28 +548,10 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			return CNull.NULL;
 		}
 
-		@Override
-		public Mixed execs(Target t, Environment env, Script parent, ParseTree... nodes) {
-			if(nodes.length < 2) {
-				throw new CREInsufficientArgumentsException("ifelse expects at least 2 arguments", t);
-			}
-			for(int i = 0; i <= nodes.length - 2; i += 2) {
-				ParseTree condition = nodes[i];
-				if(ArgumentValidation.getBooleanish(parent.seval(condition, env), t)) {
-					ParseTree ifCode = nodes[i + 1];
-					return env.getEnv(GlobalEnv.class).GetScript().seval(ifCode, env);
-				}
-			}
-			if(nodes.length % 2 == 1) {
-				return env.getEnv(GlobalEnv.class).GetScript().seval(nodes[nodes.length - 1], env);
-			}
-			return CVoid.VOID;
-		}
-
 		@Override
 		public FunctionSignatures getSignatures() {
 			/*
@@ -438,11 +561,6 @@ public FunctionSignatures getSignatures() {
 			return super.getSignatures();
 		}
 
-		@Override
-		public boolean useSpecialExec() {
-			return true;
-		}
-
 		@Override
 		public Scope linkScope(StaticAnalysis analysis, Scope parentScope,
 				ParseTree ast, Environment env, Set<ConfigCompileException> exceptions) {
@@ -493,7 +611,7 @@ public ParseTree optimizeDynamic(Target t, Environment env,
 			for(int i = 0; i < children.size() - 1; i += 2) {
 				ParseTree condNode = children.get(i);
 				if(condNode.isConst()) {
-					if(ArgumentValidation.getBooleanish(condNode.getData(), t)) {
+					if(ArgumentValidation.getBooleanish(condNode.getData(), t, env)) {
 
 						// Optimize to true condition code block if no dynamic condition was present before this.
 						if(!foundDynamicCond) {
@@ -584,7 +702,125 @@ public boolean isSelfStatement(Target t, Environment env, List<ParseTree> nodes,
 	@api
 	@breakable
 	@ConditionalSelfStatement
-	public static class _switch extends AbstractFunction implements Optimizable, BranchStatement, VariableScope {
+	public static class _switch extends AbstractFunction implements FlowFunction<_switch.SwitchState>, Optimizable, BranchStatement, VariableScope {
+
+		static class SwitchState {
+			enum Phase { EVAL_VALUE, EVAL_CASE, EVAL_CODE }
+			Phase phase = Phase.EVAL_VALUE;
+			ParseTree[] children;
+			Mixed switchValue;
+			int caseIndex = 1; // starts at 1, skips switch value
+
+			SwitchState(ParseTree[] children) {
+				this.children = children;
+			}
+
+			@Override
+			public String toString() {
+				return phase + " idx=" + caseIndex;
+			}
+		}
+
+		@Override
+		public StepResult<SwitchState> begin(Target t, ParseTree[] children, Environment env) {
+			SwitchState state = new SwitchState(children);
+			return new StepResult<>(new Evaluate(children[0]), state);
+		}
+
+		@Override
+		public StepResult<SwitchState> childCompleted(Target t, SwitchState state,
+				Mixed result, Environment env) {
+			switch(state.phase) {
+				case EVAL_VALUE:
+					state.switchValue = result;
+					state.phase = SwitchState.Phase.EVAL_CASE;
+					if(state.caseIndex <= state.children.length - 2) {
+						return new StepResult<>(new Evaluate(state.children[state.caseIndex]), state);
+					}
+					// No cases, check for default
+					if(state.children.length % 2 == 0) {
+						state.phase = SwitchState.Phase.EVAL_CODE;
+						return new StepResult<>(new Evaluate(
+								state.children[state.children.length - 1]), state);
+					}
+					return new StepResult<>(new Complete(CVoid.VOID), state);
+
+				case EVAL_CASE:
+					BasicLogic.equals equals = new BasicLogic.equals();
+					boolean matched = false;
+					if(result instanceof CSlice) {
+						long rangeLeft = ((CSlice) result).getStart();
+						long rangeRight = ((CSlice) result).getFinish();
+						if(state.switchValue.isInstanceOf(CInt.TYPE, null, env)) {
+							long v = ArgumentValidation.getInt(state.switchValue, t);
+							matched = (rangeLeft < rangeRight && v >= rangeLeft && v <= rangeRight)
+									|| (rangeLeft > rangeRight && v >= rangeRight && v <= rangeLeft)
+									|| (rangeLeft == rangeRight && v == rangeLeft);
+						}
+					} else if(result.isInstanceOf(CArray.TYPE, null, env)) {
+						for(String index : ((CArray) result).stringKeySet()) {
+							Mixed inner = ((CArray) result).get(index, t, env);
+							if(inner instanceof CSlice) {
+								long rangeLeft = ((CSlice) inner).getStart();
+								long rangeRight = ((CSlice) inner).getFinish();
+								if(state.switchValue.isInstanceOf(CInt.TYPE, null, env)) {
+									long v = ArgumentValidation.getInt(state.switchValue, t);
+									if((rangeLeft < rangeRight && v >= rangeLeft && v <= rangeRight)
+											|| (rangeLeft > rangeRight && v >= rangeRight && v <= rangeLeft)
+											|| (rangeLeft == rangeRight && v == rangeLeft)) {
+										matched = true;
+										break;
+									}
+								}
+							} else if(equals.exec(t, env, null, state.switchValue, inner).getBoolean()) {
+								matched = true;
+								break;
+							}
+						}
+					} else if(equals.exec(t, env, null, state.switchValue, result).getBoolean()) {
+						matched = true;
+					}
+					if(matched) {
+						state.phase = SwitchState.Phase.EVAL_CODE;
+						return new StepResult<>(new Evaluate(
+								state.children[state.caseIndex + 1]), state);
+					}
+					// No match, advance to next case pair
+					state.caseIndex += 2;
+					if(state.caseIndex <= state.children.length - 2) {
+						return new StepResult<>(new Evaluate(state.children[state.caseIndex]), state);
+					}
+					// No more cases, check for default
+					if(state.children.length % 2 == 0) {
+						state.phase = SwitchState.Phase.EVAL_CODE;
+						return new StepResult<>(new Evaluate(
+								state.children[state.children.length - 1]), state);
+					}
+					return new StepResult<>(new Complete(CVoid.VOID), state);
+
+				case EVAL_CODE:
+					return new StepResult<>(new Complete(result), state);
+
+				default:
+					throw ConfigRuntimeException.CreateUncatchableException(
+							"Invalid switch state: " + state.phase, t);
+			}
+		}
+
+		@Override
+		public StepResult<SwitchState> childInterrupted(Target t, SwitchState state,
+				StepAction.FlowControl action, Environment env) {
+			if(state.phase == SwitchState.Phase.EVAL_CODE
+					&& action.getAction() instanceof BreakAction breakAction) {
+				int levels = breakAction.getLevels();
+				if(levels <= 1) {
+					return new StepResult<>(new Complete(CVoid.VOID), state);
+				}
+				return new StepResult<>(new FlowControl(
+						new BreakAction(levels - 1, breakAction.getTarget())), state);
+			}
+			return null; // propagate
+		}
 
 		@Override
 		public String getName() {
@@ -636,7 +872,7 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			return CNull.NULL;
 		}
 
@@ -661,62 +897,6 @@ public boolean isSelfStatement(Target t, Environment env, List<ParseTree> nodes,
 			return false;
 		}
 
-		@Override
-		public Mixed execs(Target t, Environment env, Script parent, ParseTree... nodes) {
-			Mixed value = parent.seval(nodes[0], env);
-			BasicLogic.equals equals = new BasicLogic.equals();
-			try {
-				for(int i = 1; i <= nodes.length - 2; i += 2) {
-					ParseTree statement = nodes[i];
-					ParseTree code = nodes[i + 1];
-					Mixed evalStatement = parent.seval(statement, env);
-					if(evalStatement instanceof CSlice) { //Can do more optimal handling for this Array subclass
-						long rangeLeft = ((CSlice) evalStatement).getStart();
-						long rangeRight = ((CSlice) evalStatement).getFinish();
-						if(value.isInstanceOf(CInt.TYPE)) {
-							long v = ArgumentValidation.getInt(value, t);
-							if((rangeLeft < rangeRight && v >= rangeLeft && v <= rangeRight)
-									|| (rangeLeft > rangeRight && v >= rangeRight && v <= rangeLeft)
-									|| (rangeLeft == rangeRight && v == rangeLeft)) {
-								return parent.seval(code, env);
-							}
-						}
-					} else if(evalStatement.isInstanceOf(CArray.TYPE)) {
-						for(String index : ((CArray) evalStatement).stringKeySet()) {
-							Mixed inner = ((CArray) evalStatement).get(index, t);
-							if(inner instanceof CSlice) {
-								long rangeLeft = ((CSlice) inner).getStart();
-								long rangeRight = ((CSlice) inner).getFinish();
-								if(value.isInstanceOf(CInt.TYPE)) {
-									long v = ArgumentValidation.getInt(value, t);
-									if((rangeLeft < rangeRight && v >= rangeLeft && v <= rangeRight)
-											|| (rangeLeft > rangeRight && v >= rangeRight && v <= rangeLeft)
-											|| (rangeLeft == rangeRight && v == rangeLeft)) {
-										return parent.seval(code, env);
-									}
-								}
-							} else if(equals.exec(t, env, value, inner).getBoolean()) {
-								return parent.seval(code, env);
-							}
-						}
-					} else if(equals.exec(t, env, value, evalStatement).getBoolean()) {
-						return parent.seval(code, env);
-					}
-				}
-				if(nodes.length % 2 == 0) {
-					return parent.seval(nodes[nodes.length - 1], env);
-				}
-			} catch (LoopBreakException ex) {
-				//Ignored, unless the value passed in is greater than 1, in which case
-				//we rethrow.
-				if(ex.getTimes() > 1) {
-					ex.setTimes(ex.getTimes() - 1);
-					throw ex;
-				}
-			}
-			return CVoid.VOID;
-		}
-
 		@Override
 		public FunctionSignatures getSignatures() {
 			/*
@@ -766,11 +946,6 @@ public Scope linkScope(StaticAnalysis analysis, Scope parentScope,
 			return caseParentScope;
 		}
 
-		@Override
-		public boolean useSpecialExec() {
-			return true;
-		}
-
 		@Override
 		public ExampleScript[] examples() throws ConfigCompileException {
 			return new ExampleScript[]{
@@ -856,7 +1031,7 @@ public ParseTree optimizeDynamic(Target t, Environment env,
 					+ " remove the duplicate value";
 			final BasicLogic.equals equals = new BasicLogic.equals();
 			Set<Mixed> values = new TreeSet<>((Mixed t1, Mixed t2) -> {
-				if(equals.exec(Target.UNKNOWN, null, t1, t2).getBoolean()) {
+				if(equals.exec(Target.UNKNOWN, null, null, t1, t2).getBoolean()) {
 					return 0;
 				} else {
 					return t1.val().compareTo(t2.val());
@@ -877,13 +1052,13 @@ public ParseTree optimizeDynamic(Target t, Environment env,
 						if(Construct.IsDynamicHelper(child.getData())) {
 							throw new ConfigCompileException(notConstant, child.getTarget());
 						}
-						data.push(child.getData(), t);
+						data.push(child.getData(), t, env);
 					}
 					children.set(i, new ParseTree(data, children.get(i).getFileOptions()));
 				}
 				//Now we validate that the values are constant and non-repeating.
-				if(children.get(i).getData().isInstanceOf(CArray.TYPE)) {
-					List<Mixed> list = ((CArray) children.get(i).getData()).asList();
+				if(children.get(i).getData().isInstanceOf(CArray.TYPE, null, env)) {
+					List<Mixed> list = ((CArray) children.get(i).getData()).asList(env);
 					for(Mixed c : list) {
 						if(c instanceof CSlice) {
 							for(Mixed cc : ((CSlice) c).asList()) {
@@ -914,7 +1089,7 @@ public ParseTree optimizeDynamic(Target t, Environment env,
 				}
 			}
 
-			if((children.size() > 3 || (children.size() > 1 && children.get(1).getData().isInstanceOf(CArray.TYPE)))
+			if((children.size() > 3 || (children.size() > 1 && children.get(1).getData().isInstanceOf(CArray.TYPE, null, env)))
 					//No point in doing this optimization if there are only 3 args and the case is flat.
 					//Also, doing this check prevents an inifinite loop during optimization.
 					&& (children.size() > 0 && !Construct.IsDynamicHelper(children.get(0).getData()))) {
@@ -925,16 +1100,16 @@ public ParseTree optimizeDynamic(Target t, Environment env,
 				for(int i = 1; i < children.size(); i += 2) {
 					Mixed data = children.get(i).getData();
 
-					if(!(data.isInstanceOf(CArray.TYPE)) || data instanceof CSlice) {
+					if(!(data.isInstanceOf(CArray.TYPE, null, env)) || data instanceof CSlice) {
 						//Put it in an array to make the rest of this parsing easier.
 						data = new CArray(t);
-						((CArray) data).push(children.get(i).getData(), t);
+						((CArray) data).push(children.get(i).getData(), t, env);
 					}
-					for(Mixed value : ((CArray) data).asList()) {
+					for(Mixed value : ((CArray) data).asList(env)) {
 						if(value instanceof CSlice) {
 							long rangeLeft = ((CSlice) value).getStart();
 							long rangeRight = ((CSlice) value).getFinish();
-							if(children.get(0).getData().isInstanceOf(CInt.TYPE)) {
+							if(children.get(0).getData().isInstanceOf(CInt.TYPE, null, env)) {
 								long v = ArgumentValidation.getInt(children.get(0).getData(), t);
 								if((rangeLeft < rangeRight && v >= rangeLeft && v <= rangeRight)
 										|| (rangeLeft > rangeRight && v >= rangeRight && v <= rangeLeft)
@@ -943,7 +1118,7 @@ public ParseTree optimizeDynamic(Target t, Environment env,
 									break;
 								}
 							}
-						} else if(equals.exec(t, null, children.get(0).getData(), value).getBoolean()) {
+						} else if(equals.exec(t, null, null, children.get(0).getData(), value).getBoolean()) {
 							toReturn = children.get(i + 1);
 							break;
 						}
@@ -1006,7 +1181,7 @@ public List<Boolean> isScope(List<ParseTree> children) {
 	public static class switch_ic extends _switch implements Optimizable, BranchStatement, VariableScope {
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			throw new Error();
 		}
 
@@ -1051,10 +1226,10 @@ public ParseTree optimizeDynamic(Target t, Environment env,
 				Mixed caseData = child.getData();
 				if(caseData instanceof CArray) {
 					CArray newData = new CArray(child.getTarget());
-					for(Mixed cse : ((CArray) caseData).asList()) {
+					for(Mixed cse : ((CArray) caseData).asList(env)) {
 						if(cse instanceof CString) {
 							CString data = (CString) cse;
-							newData.push(new CString(data.val().toLowerCase(), data.getTarget()), data.getTarget());
+							newData.push(new CString(data.val().toLowerCase(), data.getTarget()), data.getTarget(), env);
 						} else {
 							throw new ConfigCompileException(getName() + " can only accept strings in case statements.",
 									cse.getTarget());
@@ -1080,31 +1255,40 @@ public ParseTree optimizeDynamic(Target t, Environment env,
 	@seealso({com.laytonsmith.tools.docgen.templates.Loops.class,
 		com.laytonsmith.tools.docgen.templates.ArrayIteration.class})
 	@SelfStatement
-	public static class _for extends AbstractFunction implements Optimizable, BranchStatement, VariableScope {
+	public static class _for extends AbstractFunction implements FlowFunction<forelse.ForState>, Optimizable, BranchStatement, VariableScope {
+
+		private static final forelse FOR_DELEGATE = new forelse();
 
 		@Override
-		public String getName() {
-			return "for";
+		public StepResult<forelse.ForState> begin(Target t, ParseTree[] children, Environment env) {
+			return FOR_DELEGATE.begin(t, children, env);
 		}
 
 		@Override
-		public Integer[] numArgs() {
-			return new Integer[]{4};
+		public StepResult<forelse.ForState> childCompleted(Target t, forelse.ForState state,
+				Mixed result, Environment env) {
+			return FOR_DELEGATE.childCompleted(t, state, result, env);
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment env, Mixed... args) {
-			return CVoid.VOID;
+		public StepResult<forelse.ForState> childInterrupted(Target t, forelse.ForState state,
+				StepAction.FlowControl action, Environment env) {
+			return FOR_DELEGATE.childInterrupted(t, state, action, env);
 		}
 
 		@Override
-		public boolean useSpecialExec() {
-			return true;
+		public String getName() {
+			return "for";
+		}
+
+		@Override
+		public Integer[] numArgs() {
+			return new Integer[]{4};
 		}
 
 		@Override
-		public Mixed execs(Target t, Environment env, Script parent, ParseTree... nodes) {
-			return new forelse(true).execs(t, env, parent, nodes);
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) {
+			return CVoid.VOID;
 		}
 
 		@Override
@@ -1231,7 +1415,13 @@ public ParseTree optimizeDynamic(Target t, Environment env,
 				//existing system sort that out.
 			}
 
-			return null;
+			// Rewrite for(a, b, c, d) as forelse(a, b, c, d, null)
+			ParseTree rewrite = new ParseTree(new CFunction(forelse.NAME, t), fileOptions);
+			for(ParseTree child : children) {
+				rewrite.addChild(child);
+			}
+			rewrite.addChild(new ParseTree(CNull.NULL, fileOptions));
+			return rewrite;
 		}
 
 		@Override
@@ -1275,17 +1465,97 @@ public List<Boolean> isScope(List<ParseTree> children) {
 	@noboilerplate
 	@breakable
 	@SelfStatement
-	public static class forelse extends AbstractFunction implements BranchStatement, VariableScope {
+	public static class forelse extends AbstractFunction implements FlowFunction<forelse.ForState>, BranchStatement, VariableScope {
 
 		public static final String NAME = "forelse";
 
-		public forelse() {
+		enum Phase { ASSIGN, CONDITION, BODY, INCREMENT, ELSE }
+
+		static class ForState {
+			Phase phase;
+			ParseTree[] children;
+			boolean hasRunOnce;
+			int skipCount;
+
+			ForState(ParseTree[] children) {
+				this.phase = Phase.ASSIGN;
+				this.children = children;
+				this.hasRunOnce = false;
+			}
+
+			@Override
+			public String toString() {
+				return phase.name() + (hasRunOnce ? " (looped)" : "")
+						+ (skipCount > 0 ? " skip=" + skipCount : "");
+			}
 		}
 
-		boolean runAsFor = false;
+		@Override
+		public StepResult<ForState> begin(Target t, ParseTree[] children, Environment env) {
+			ForState state = new ForState(children);
+			return new StepResult<>(new Evaluate(children[0], null, true), state);
+		}
 
-		forelse(boolean runAsFor) {
-			this.runAsFor = runAsFor;
+		@Override
+		public StepResult<ForState> childCompleted(Target t, ForState state, Mixed result, Environment env) {
+			switch(state.phase) {
+				case ASSIGN:
+					if(!(result instanceof IVariable)) {
+						throw new CRECastException("First parameter of for must be an ivariable", t);
+					}
+					state.phase = Phase.CONDITION;
+					return new StepResult<>(new Evaluate(state.children[1]), state);
+				case CONDITION:
+					boolean cond = ArgumentValidation.getBooleanish(result, t, env);
+					if(!cond) {
+						if(!state.hasRunOnce && !(state.children[4].getData() instanceof CNull)) {
+							state.phase = Phase.ELSE;
+							return new StepResult<>(new Evaluate(state.children[4]), state);
+						}
+						return new StepResult<>(new Complete(CVoid.VOID), state);
+					}
+					state.hasRunOnce = true;
+					if(state.skipCount > 1) {
+						state.skipCount--;
+						state.phase = Phase.INCREMENT;
+						return new StepResult<>(new Evaluate(state.children[2]), state);
+					}
+					state.skipCount = 0;
+					state.phase = Phase.BODY;
+					return new StepResult<>(new Evaluate(state.children[3]), state);
+				case BODY:
+					state.phase = Phase.INCREMENT;
+					return new StepResult<>(new Evaluate(state.children[2]), state);
+				case INCREMENT:
+					state.phase = Phase.CONDITION;
+					return new StepResult<>(new Evaluate(state.children[1]), state);
+				case ELSE:
+					return new StepResult<>(new Complete(CVoid.VOID), state);
+				default:
+					throw ConfigRuntimeException.CreateUncatchableException(
+							"Invalid for loop state: " + state.phase, t);
+			}
+		}
+
+		@Override
+		public StepResult<ForState> childInterrupted(Target t, ForState state,
+				StepAction.FlowControl action, Environment env) {
+			if(state.phase == Phase.BODY) {
+				if(action.getAction() instanceof BreakAction breakAction) {
+					int levels = breakAction.getLevels();
+					if(levels <= 1) {
+						return new StepResult<>(new Complete(CVoid.VOID), state);
+					}
+					return new StepResult<>(new FlowControl(
+							new BreakAction(levels - 1, breakAction.getTarget())), state);
+				}
+				if(action.getAction() instanceof ContinueAction continueAction) {
+					state.skipCount = continueAction.getLevels();
+					state.phase = Phase.INCREMENT;
+					return new StepResult<>(new Evaluate(state.children[2]), state);
+				}
+			}
+			return null;
 		}
 
 		@Override
@@ -1309,65 +1579,10 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public boolean useSpecialExec() {
-			return true;
-		}
-
-		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			return null;
 		}
 
-		@Override
-		public Mixed execs(Target t, Environment env, Script parent, ParseTree... nodes) throws ConfigRuntimeException {
-			ParseTree assign = nodes[0];
-			ParseTree condition = nodes[1];
-			ParseTree expression = nodes[2];
-			ParseTree runnable = nodes[3];
-			ParseTree elseCode = null;
-			if(!runAsFor) {
-				elseCode = nodes[4];
-			}
-			boolean hasRunOnce = false;
-
-			Mixed counter = parent.eval(assign, env);
-			if(!(counter instanceof IVariable)) {
-				throw new CRECastException("First parameter of for must be an ivariable", t);
-			}
-			int _continue = 0;
-			while(true) {
-				boolean cond = ArgumentValidation.getBoolean(parent.seval(condition, env), t);
-				if(cond == false) {
-					break;
-				}
-				hasRunOnce = true;
-				if(_continue >= 1) {
-					--_continue;
-					parent.eval(expression, env);
-					continue;
-				}
-				try {
-					parent.eval(runnable, env);
-				} catch (LoopBreakException e) {
-					int num = e.getTimes();
-					if(num > 1) {
-						e.setTimes(--num);
-						throw e;
-					}
-					return CVoid.VOID;
-				} catch (LoopContinueException e) {
-					_continue = e.getTimes() - 1;
-					parent.eval(expression, env);
-					continue;
-				}
-				parent.eval(expression, env);
-			}
-			if(!hasRunOnce && !runAsFor && elseCode != null) {
-				parent.eval(elseCode, env);
-			}
-			return CVoid.VOID;
-		}
-
 		@Override
 		public FunctionSignatures getSignatures() {
 			return new SignatureBuilder(CVoid.TYPE)
@@ -1388,7 +1603,7 @@ public Scope linkScope(StaticAnalysis analysis, Scope parentScope,
 				ParseTree ast, Environment env, Set<ConfigCompileException> exceptions) {
 
 			// Handle not enough arguments. Link child scopes, but return parent scope.
-			if(ast.numberOfChildren() < (this.runAsFor ? 3 : 4)) {
+			if(ast.numberOfChildren() < 4) {
 				super.linkScope(analysis, parentScope, ast, env, exceptions);
 				return parentScope;
 			}
@@ -1398,7 +1613,7 @@ public Scope linkScope(StaticAnalysis analysis, Scope parentScope,
 			ParseTree cond = ast.getChildAt(1);
 			ParseTree exp = ast.getChildAt(2);
 			ParseTree code = ast.getChildAt(3);
-			ParseTree elseCode = (this.runAsFor ? null : ast.getChildAt(4));
+			ParseTree elseCode = ast.numberOfChildren() > 4 ? ast.getChildAt(4) : null;
 
 			// Order: assign -> cond -> (code -> exp -> cond)* -> elseCode?.
 			Scope assignScope = analysis.linkScope(parentScope, assign, env, exceptions);
@@ -1456,175 +1671,270 @@ public List<Boolean> isScope(List<ParseTree> children) {
 	@breakable
 	@seealso({com.laytonsmith.tools.docgen.templates.Loops.class, ArrayIteration.class})
 	@SelfStatement
-	public static class foreach extends AbstractFunction implements BranchStatement, VariableScope {
+	public static class foreach extends AbstractFunction implements FlowFunction<foreach.ForeachState>, BranchStatement, VariableScope {
 
-		@Override
-		public String getName() {
-			return "foreach";
-		}
+		static class ForeachState {
+			enum Phase { EVAL_ARRAY, EVAL_KEY, EVAL_VALUE, LOOP_BODY, ELSE_BODY }
+			Phase phase = Phase.EVAL_ARRAY;
+			ParseTree[] children;
+			int offset; // 1 if key parameter present, 0 otherwise
+			boolean hasElse;
 
-		@Override
-		public Integer[] numArgs() {
-			return new Integer[]{2, 3, 4};
+			com.laytonsmith.core.natives.interfaces.Iterable arr;
+			IVariable keyVar;
+			IVariable valueVar;
+			ParseTree codeNode;
+			ParseTree elseNode;
+
+			// Associative iteration
+			boolean isAssociative;
+			java.util.Iterator<Mixed> assocKeyIterator;
+
+			// Non-associative iteration
+			Iterator nonAssocIterator;
+			List<Iterator> arrayAccessList;
+			int skipCount;
+
+			ForeachState(ParseTree[] children, int offset, boolean hasElse) {
+				this.children = children;
+				this.offset = offset;
+				this.hasElse = hasElse;
+			}
+
+			@Override
+			public String toString() {
+				return phase.name().toLowerCase();
+			}
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment env, Mixed... args)
-				throws CancelCommandException, ConfigRuntimeException {
-			return CVoid.VOID;
+		public StepResult<ForeachState> begin(Target t, ParseTree[] children, Environment env) {
+			if(children.length < 3) {
+				throw new CREInsufficientArgumentsException(
+						"Insufficient arguments passed to " + getName(), t);
+			}
+			int offset = (children.length == 4) ? 1 : 0;
+			ForeachState state = new ForeachState(children, offset, false);
+			return new StepResult<>(new Evaluate(children[0]), state);
 		}
 
 		@Override
-		public Mixed execs(Target t, Environment env, Script parent, ParseTree... nodes) {
-			if(nodes.length < 3) {
-				throw new CREInsufficientArgumentsException("Insufficient arguments passed to " + getName(), t);
-			}
-			ParseTree array = nodes[0];
-			ParseTree key = null;
-			int offset = 0;
-			if(nodes.length == 4) {
-				//Key and value provided
-				key = nodes[1];
-				offset = 1;
-			}
-			ParseTree value = nodes[1 + offset];
-			ParseTree code = nodes[2 + offset];
-			Mixed arr = parent.seval(array, env);
-			Mixed ik = null;
-			if(key != null) {
-				ik = parent.eval(key, env);
-				if(!(ik instanceof IVariable)) {
-					throw new CRECastException("Parameter 2 of " + getName() + " must be an ivariable", t);
+		public StepResult<ForeachState> childCompleted(Target t, ForeachState state,
+				Mixed result, Environment env) {
+			switch(state.phase) {
+				case EVAL_ARRAY: {
+					Mixed arr = result;
+					if(arr instanceof CSlice) {
+						long start = ((CSlice) arr).getStart();
+						long finish = ((CSlice) arr).getFinish();
+						if(finish < start) {
+							arr = new ArrayHandling.range().exec(t, env, null,
+									new CInt(start, t), new CInt(finish - 1, t), new CInt(-1, t));
+						} else {
+							arr = new ArrayHandling.range().exec(t, env, null,
+									new CInt(start, t), new CInt(finish + 1, t));
+						}
+					}
+					if(!(arr instanceof com.laytonsmith.core.natives.interfaces.Iterable)) {
+						throw new CRECastException("Parameter 1 of " + getName()
+								+ " must be an Iterable data structure", t);
+					}
+					state.arr = (com.laytonsmith.core.natives.interfaces.Iterable) arr;
+					state.codeNode = state.children[2 + state.offset];
+					if(state.hasElse) {
+						state.elseNode = state.children[state.children.length - 1];
+					}
+
+					// Check empty for foreachelse
+					if(state.hasElse && state.arr.size(env) == 0) {
+						state.phase = ForeachState.Phase.ELSE_BODY;
+						return new StepResult<>(new Evaluate(state.elseNode), state);
+					}
+
+					if(state.offset == 1) {
+						state.phase = ForeachState.Phase.EVAL_KEY;
+						return new StepResult<>(new Evaluate(state.children[1], null, true), state);
+					}
+					state.phase = ForeachState.Phase.EVAL_VALUE;
+					return new StepResult<>(new Evaluate(state.children[1], null, true), state);
 				}
-			}
-			Mixed iv = parent.eval(value, env);
-			if(arr instanceof CSlice) {
-				long start = ((CSlice) arr).getStart();
-				long finish = ((CSlice) arr).getFinish();
-				if(finish < start) {
-					arr = new ArrayHandling.range()
-							.exec(t, env, new CInt(start, t), new CInt(finish - 1, t), new CInt(-1, t));
-				} else {
-					arr = new ArrayHandling.range().exec(t, env, new CInt(start, t), new CInt(finish + 1, t));
+				case EVAL_KEY: {
+					if(!(result instanceof IVariable)) {
+						throw new CRECastException("Parameter 2 of " + getName()
+								+ " must be an ivariable", t);
+					}
+					state.keyVar = (IVariable) result;
+					state.phase = ForeachState.Phase.EVAL_VALUE;
+					return new StepResult<>(new Evaluate(
+							state.children[1 + state.offset], null, true), state);
 				}
-			}
-			if(!(arr instanceof com.laytonsmith.core.natives.interfaces.Iterable)) {
-				throw new CRECastException("Parameter 1 of " + getName() + " must be an Iterable data structure", t);
-			}
-			if(!(iv instanceof IVariable)) {
-				throw new CRECastException(
-						"Parameter " + (2 + offset) + " of " + getName() + " must be an ivariable", t);
-			}
-			com.laytonsmith.core.natives.interfaces.Iterable one
-				= (com.laytonsmith.core.natives.interfaces.Iterable) arr;
-			IVariable kkey = (IVariable) ik;
-			IVariable two = (IVariable) iv;
-			if(one.isAssociative()) {
-				//Iteration of an associative array is much easier, and we have
-				//special logic here to decrease the complexity.
-
-				//Clone the set, so changes in the array won't cause changes in
-				//the iteration order.
-				Set<Mixed> keySet = new LinkedHashSet<>(one.keySet());
-				//Continues in an associative array are slightly different, so
-				//we have to track this differently. Basically, we skip the
-				//next element in the array key set.
-				int continues = 0;
-				for(Mixed c : keySet) {
-					if(continues > 0) {
-						//If continues is greater than 0, continue in the loop,
-						//however many times necessary to make it 0.
-						continues--;
-						continue;
+				case EVAL_VALUE: {
+					if(!(result instanceof IVariable)) {
+						throw new CRECastException("Parameter " + (2 + state.offset)
+								+ " of " + getName() + " must be an ivariable", t);
 					}
-					//If the key isn't null, set that in the variable table.
-					if(kkey != null) {
-						env.getEnv(GlobalEnv.class).GetVarList().set(new IVariable(kkey.getDefinedType(),
-								kkey.getVariableName(), c, kkey.getDefinedTarget(), env));
+					state.valueVar = (IVariable) result;
+					return startIteration(t, state, env);
+				}
+				case LOOP_BODY: {
+					if(state.isAssociative) {
+						return nextAssociativeIteration(t, state, env);
+					} else {
+						return advanceNonAssociative(t, state, env);
 					}
-					//Set the value in the variable table
-					env.getEnv(GlobalEnv.class).GetVarList().set(new IVariable(two.getDefinedType(),
-							two.getVariableName(), one.get(c, t), two.getDefinedTarget(), env));
-					try {
-						//Execute the code
-						parent.eval(code, env);
-						//And handle any break/continues.
-					} catch (LoopBreakException e) {
-						int num = e.getTimes();
-						if(num > 1) {
-							e.setTimes(--num);
-							throw e;
-						}
-						return CVoid.VOID;
-					} catch (LoopContinueException e) {
-						// In associative arrays, (unlike with normal arrays) we need to decrement it by one, because
-						// the nature of the normal array is such that the counter is handled manually by our code.
-						// Because we are letting java handle our code though, this run actually counts as one run.
-						continues += e.getTimes() - 1;
+				}
+				case ELSE_BODY:
+					return new StepResult<>(new Complete(CVoid.VOID), state);
+				default:
+					throw ConfigRuntimeException.CreateUncatchableException(
+							"Invalid foreach state: " + state.phase, t);
+			}
+		}
+
+		@Override
+		public StepResult<ForeachState> childInterrupted(Target t, ForeachState state,
+				StepAction.FlowControl action, Environment env) {
+			if(state.phase == ForeachState.Phase.LOOP_BODY) {
+				if(action.getAction() instanceof BreakAction breakAction) {
+					cleanupIterator(state);
+					int levels = breakAction.getLevels();
+					if(levels <= 1) {
+						return new StepResult<>(new Complete(CVoid.VOID), state);
 					}
+					return new StepResult<>(new FlowControl(
+							new BreakAction(levels - 1, breakAction.getTarget())), state);
 				}
-				return CVoid.VOID;
-			} else {
-				//It's not associative, so we have more complex handling. We will create an ArrayAccessIterator,
-				//and store that in the environment. As the array is iterated, underlying changes in the array
-				//will be reflected in the object, and we will adjust as necessary. The reason we use this mechanism
-				//is to avoid cloning the array, and iterating that. Arrays may be extremely large, and cloning the
-				//entire array is wasteful in that case. We are essentially tracking deltas this way, which prevents
-				//memory usage from getting out of hand.
-				Iterator iterator = new Iterator(one);
-				List<Iterator> arrayAccessList = env.getEnv(GlobalEnv.class).GetArrayAccessIterators();
-				try {
-					arrayAccessList.add(iterator);
-					int continues = 0;
-					while(true) {
-						int current = iterator.getCurrent();
-						if(continues > 0) {
-							//We have some continues to handle. Blacklisted
-							//values don't count for the continuing count, so
-							//we have to consider that when counting.
-							iterator.incrementCurrent();
-							if(iterator.isBlacklisted(current)) {
-								continue;
-							} else {
-								--continues;
-								continue;
-							}
-						}
-						if(current >= one.size()) {
-							//Done with the iterations.
-							break;
+				if(action.getAction() instanceof ContinueAction continueAction) {
+					int levels = continueAction.getLevels();
+					if(state.isAssociative) {
+						// For associative arrays, skip means skip entries in the iterator
+						for(int i = 0; i < levels - 1 && state.assocKeyIterator.hasNext(); i++) {
+							state.assocKeyIterator.next();
 						}
-						//If the item is blacklisted, we skip it.
-						if(!iterator.isBlacklisted(current)) {
-							if(kkey != null) {
-								env.getEnv(GlobalEnv.class).GetVarList().set(new IVariable(kkey.getDefinedType(),
-										kkey.getVariableName(), new CInt(current, t), kkey.getDefinedTarget(), env));
-							}
-							env.getEnv(GlobalEnv.class).GetVarList().set(new IVariable(two.getDefinedType(),
-									two.getVariableName(), one.get(current, t), two.getDefinedTarget(), env));
-							try {
-								parent.eval(code, env);
-							} catch (LoopBreakException e) {
-								int num = e.getTimes();
-								if(num > 1) {
-									e.setTimes(--num);
-									throw e;
-								}
-								return CVoid.VOID;
-							} catch (LoopContinueException e) {
-								continues += e.getTimes();
-								continue;
-							}
-						}
-						iterator.incrementCurrent();
+						return nextAssociativeIteration(t, state, env);
+					} else {
+						// For non-associative, we need to skip entries
+						state.skipCount = levels;
+						return advanceNonAssociative(t, state, env);
 					}
-				} finally {
-					arrayAccessList.remove(iterator);
 				}
+				// Other interruptions (throw, return) — cleanup before propagating
+				cleanupIterator(state);
 			}
+			return null; // propagate
+		}
+
+		private StepResult<ForeachState> startIteration(Target t, ForeachState state, Environment env) {
+			if(state.arr.isAssociative()) {
+				state.isAssociative = true;
+				// Clone the key set so modifications during iteration don't affect order
+				Set<Mixed> keySet = new LinkedHashSet<>(state.arr.keySet(env));
+				state.assocKeyIterator = keySet.iterator();
+				return nextAssociativeIteration(t, state, env);
+			} else {
+				state.isAssociative = false;
+				state.nonAssocIterator = new Iterator(state.arr);
+				state.arrayAccessList = env.getEnv(GlobalEnv.class).GetArrayAccessIterators();
+				state.arrayAccessList.add(state.nonAssocIterator);
+				return advanceNonAssociative(t, state, env);
+			}
+		}
+
+		private StepResult<ForeachState> nextAssociativeIteration(Target t,
+				ForeachState state, Environment env) {
+			if(!state.assocKeyIterator.hasNext()) {
+				return new StepResult<>(new Complete(CVoid.VOID), state);
+			}
+			Mixed key = state.assocKeyIterator.next();
+			if(state.keyVar != null) {
+				env.getEnv(GlobalEnv.class).GetVarList().set(new IVariable(
+						state.keyVar.getDefinedType(), state.keyVar.getVariableName(),
+						key, state.keyVar.getDefinedTarget(), env));
+			}
+			env.getEnv(GlobalEnv.class).GetVarList().set(new IVariable(
+					state.valueVar.getDefinedType(), state.valueVar.getVariableName(),
+					state.arr.get(key, t, env), state.valueVar.getDefinedTarget(), env));
+			state.phase = ForeachState.Phase.LOOP_BODY;
+			return new StepResult<>(new Evaluate(state.codeNode), state);
+		}
+
+		/**
+		 * Advances the non-associative iterator, skipping blacklisted entries and
+		 * handling skipCount from continue(n). If the iterator reaches the end,
+		 * cleans up and returns Complete.
+		 */
+		private StepResult<ForeachState> advanceNonAssociative(Target t,
+				ForeachState state, Environment env) {
+			Iterator iter = state.nonAssocIterator;
+			// If we are re-entering after a body execution or a continue,
+			// we need to advance past the current element first.
+			if(state.phase == ForeachState.Phase.LOOP_BODY) {
+				iter.incrementCurrent();
+			}
+			// Skip blacklisted entries (removed during iteration)
+			// and handle skipCount from continue(n)
+			while(iter.getCurrent() < state.arr.size(env)) {
+				if(iter.isBlacklisted(iter.getCurrent())) {
+					iter.incrementCurrent();
+					continue;
+				}
+				if(state.skipCount > 1) {
+					state.skipCount--;
+					iter.incrementCurrent();
+					continue;
+				}
+				state.skipCount = 0;
+				break;
+			}
+			if(iter.getCurrent() >= state.arr.size(env)) {
+				cleanupIterator(state);
+				return new StepResult<>(new Complete(CVoid.VOID), state);
+			}
+			int current = iter.getCurrent();
+			if(state.keyVar != null) {
+				env.getEnv(GlobalEnv.class).GetVarList().set(new IVariable(
+						state.keyVar.getDefinedType(), state.keyVar.getVariableName(),
+						new CInt(current, t), state.keyVar.getDefinedTarget(), env));
+			}
+			env.getEnv(GlobalEnv.class).GetVarList().set(new IVariable(
+					state.valueVar.getDefinedType(), state.valueVar.getVariableName(),
+					state.arr.get(current, t, env), state.valueVar.getDefinedTarget(), env));
+			state.phase = ForeachState.Phase.LOOP_BODY;
+			return new StepResult<>(new Evaluate(state.codeNode), state);
+		}
+
+		private void cleanupIterator(ForeachState state) {
+			if(!state.isAssociative && state.nonAssocIterator != null
+					&& state.arrayAccessList != null) {
+				state.arrayAccessList.remove(state.nonAssocIterator);
+				state.nonAssocIterator = null;
+			}
+		}
+
+		@Override
+		public void cleanup(Target t, ForeachState state, Environment env) {
+			if(state != null) {
+				cleanupIterator(state);
+			}
+		}
+
+		@Override
+		public String getName() {
+			return "foreach";
+		}
+
+		@Override
+		public Integer[] numArgs() {
+			return new Integer[]{2, 3, 4};
+		}
+
+		@Override
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args)
+				throws CancelCommandException, ConfigRuntimeException {
 			return CVoid.VOID;
 		}
 
+
 		@Override
 		public FunctionSignatures getSignatures() {
 			return new SignatureBuilder(CVoid.TYPE)
@@ -1718,11 +2028,6 @@ public Boolean runAsync() {
 			return null;
 		}
 
-		@Override
-		public boolean useSpecialExec() {
-			return true;
-		}
-
 		@Override
 		public ExampleScript[] examples() throws ConfigCompileException {
 			return new ExampleScript[]{
@@ -1910,27 +2215,14 @@ public String getName() {
 		}
 
 		@Override
-		public Mixed execs(Target t, Environment env, Script parent, ParseTree... nodes) {
-			ParseTree array = nodes[0];
-			//The last one
-			ParseTree elseCode = nodes[nodes.length - 1];
-
-			Mixed data = parent.seval(array, env);
-
-			if(!(data.isInstanceOf(CArray.TYPE)) && !(data instanceof CSlice)) {
-				throw new CRECastException(getName() + " expects an array for parameter 1", t);
+		public StepResult<ForeachState> begin(Target t, ParseTree[] children, Environment env) {
+			if(children.length < 4) {
+				throw new CREInsufficientArgumentsException(
+						"Insufficient arguments passed to " + getName(), t);
 			}
-
-			if(((CArray) data).isEmpty()) {
-				parent.eval(elseCode, env);
-			} else {
-				ParseTree pass[] = new ParseTree[nodes.length - 1];
-				System.arraycopy(nodes, 0, pass, 0, nodes.length - 1);
-				nodes[0] = new ParseTree(data, null);
-				return super.execs(t, env, parent, pass);
-			}
-
-			return CVoid.VOID;
+			int offset = (children.length == 5) ? 1 : 0;
+			ForeachState state = new ForeachState(children, offset, true);
+			return new StepResult<>(new Evaluate(children[0]), state);
 		}
 
 		@Override
@@ -2046,7 +2338,78 @@ public List<Boolean> isBranch(List<ParseTree> children) {
 	@breakable
 	@seealso({com.laytonsmith.tools.docgen.templates.Loops.class})
 	@SelfStatement
-	public static class _while extends AbstractFunction implements BranchStatement, VariableScope {
+	public static class _while extends AbstractFunction implements FlowFunction<_while.WhileState>, BranchStatement, VariableScope {
+
+		static class WhileState {
+			enum Phase { CONDITION, BODY }
+			Phase phase = Phase.CONDITION;
+			ParseTree[] children;
+			int skipCount;
+
+			WhileState(ParseTree[] children) {
+				this.children = children;
+			}
+
+			@Override
+			public String toString() {
+				return phase.name().toLowerCase();
+			}
+		}
+
+		@Override
+		public StepResult<WhileState> begin(Target t, ParseTree[] children, Environment env) {
+			WhileState state = new WhileState(children);
+			return new StepResult<>(new Evaluate(children[0]), state);
+		}
+
+		@Override
+		public StepResult<WhileState> childCompleted(Target t, WhileState state,
+				Mixed result, Environment env) {
+			switch(state.phase) {
+				case CONDITION:
+					if(ArgumentValidation.getBooleanish(result, t, env)) {
+						if(state.skipCount > 1) {
+							state.skipCount--;
+							return new StepResult<>(new Evaluate(state.children[0]), state);
+						}
+						state.skipCount = 0;
+						if(state.children.length > 1) {
+							state.phase = WhileState.Phase.BODY;
+							return new StepResult<>(new Evaluate(state.children[1]), state);
+						}
+						// while(condition) with no body — re-evaluate condition
+						return new StepResult<>(new Evaluate(state.children[0]), state);
+					}
+					return new StepResult<>(new Complete(CVoid.VOID), state);
+				case BODY:
+					state.phase = WhileState.Phase.CONDITION;
+					return new StepResult<>(new Evaluate(state.children[0]), state);
+				default:
+					throw ConfigRuntimeException.CreateUncatchableException(
+							"Invalid while state: " + state.phase, t);
+			}
+		}
+
+		@Override
+		public StepResult<WhileState> childInterrupted(Target t, WhileState state,
+				StepAction.FlowControl action, Environment env) {
+			if(state.phase == WhileState.Phase.BODY) {
+				if(action.getAction() instanceof BreakAction breakAction) {
+					int levels = breakAction.getLevels();
+					if(levels <= 1) {
+						return new StepResult<>(new Complete(CVoid.VOID), state);
+					}
+					return new StepResult<>(new FlowControl(
+							new BreakAction(levels - 1, breakAction.getTarget())), state);
+				}
+				if(action.getAction() instanceof ContinueAction continueAction) {
+					state.skipCount = continueAction.getLevels();
+					state.phase = WhileState.Phase.CONDITION;
+					return new StepResult<>(new Evaluate(state.children[0]), state);
+				}
+			}
+			return null; // propagate
+		}
 
 		public static final String NAME = "while";
 
@@ -2087,28 +2450,6 @@ public Boolean runAsync() {
 			return null;
 		}
 
-		@Override
-		public Mixed execs(Target t, Environment env, Script parent, ParseTree... nodes) {
-			try {
-				while(ArgumentValidation.getBoolean(parent.seval(nodes[0], env), t)) {
-					//We allow while(thing()); to be done. This makes certain
-					//types of coding styles possible.
-					if(nodes.length > 1) {
-						try {
-							parent.eval(nodes[1], env);
-						} catch (LoopContinueException e) {
-							//ok.
-						}
-					}
-				}
-			} catch (LoopBreakException e) {
-				if(e.getTimes() > 1) {
-					throw new LoopBreakException(e.getTimes() - 1, t);
-				}
-			}
-			return CVoid.VOID;
-		}
-
 		@Override
 		public FunctionSignatures getSignatures() {
 			return new SignatureBuilder(CVoid.TYPE)
@@ -2118,12 +2459,7 @@ public FunctionSignatures getSignatures() {
 		}
 
 		@Override
-		public boolean useSpecialExec() {
-			return true;
-		}
-
-		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			return CNull.NULL;
 		}
 
@@ -2204,7 +2540,74 @@ public List<Boolean> isScope(List<ParseTree> children) {
 	@breakable
 	@seealso({com.laytonsmith.tools.docgen.templates.Loops.class})
 	@SelfStatement
-	public static class _dowhile extends AbstractFunction implements BranchStatement, VariableScope {
+	public static class _dowhile extends AbstractFunction implements FlowFunction<_dowhile.DoWhileState>, BranchStatement, VariableScope {
+
+		static class DoWhileState {
+			enum Phase { BODY, CONDITION }
+			Phase phase = Phase.BODY;
+			ParseTree[] children;
+			int skipCount;
+
+			DoWhileState(ParseTree[] children) {
+				this.children = children;
+			}
+
+			@Override
+			public String toString() {
+				return phase.name().toLowerCase();
+			}
+		}
+
+		@Override
+		public StepResult<DoWhileState> begin(Target t, ParseTree[] children, Environment env) {
+			DoWhileState state = new DoWhileState(children);
+			return new StepResult<>(new Evaluate(children[0]), state);
+		}
+
+		@Override
+		public StepResult<DoWhileState> childCompleted(Target t, DoWhileState state,
+				Mixed result, Environment env) {
+			switch(state.phase) {
+				case BODY:
+					state.phase = DoWhileState.Phase.CONDITION;
+					return new StepResult<>(new Evaluate(state.children[1]), state);
+				case CONDITION:
+					if(ArgumentValidation.getBooleanish(result, t, env)) {
+						if(state.skipCount > 1) {
+							state.skipCount--;
+							return new StepResult<>(new Evaluate(state.children[1]), state);
+						}
+						state.skipCount = 0;
+						state.phase = DoWhileState.Phase.BODY;
+						return new StepResult<>(new Evaluate(state.children[0]), state);
+					}
+					return new StepResult<>(new Complete(CVoid.VOID), state);
+				default:
+					throw ConfigRuntimeException.CreateUncatchableException(
+							"Invalid dowhile state: " + state.phase, t);
+			}
+		}
+
+		@Override
+		public StepResult<DoWhileState> childInterrupted(Target t, DoWhileState state,
+				StepAction.FlowControl action, Environment env) {
+			if(state.phase == DoWhileState.Phase.BODY) {
+				if(action.getAction() instanceof BreakAction breakAction) {
+					int levels = breakAction.getLevels();
+					if(levels <= 1) {
+						return new StepResult<>(new Complete(CVoid.VOID), state);
+					}
+					return new StepResult<>(new FlowControl(
+							new BreakAction(levels - 1, breakAction.getTarget())), state);
+				}
+				if(action.getAction() instanceof ContinueAction continueAction) {
+					state.skipCount = continueAction.getLevels();
+					state.phase = DoWhileState.Phase.CONDITION;
+					return new StepResult<>(new Evaluate(state.children[1]), state);
+				}
+			}
+			return null; // propagate
+		}
 
 		public static final String NAME = "dowhile";
 
@@ -2229,7 +2632,7 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			return CNull.NULL;
 		}
 
@@ -2261,29 +2664,6 @@ public MSVersion since() {
 			return MSVersion.V3_3_1;
 		}
 
-		@Override
-		public boolean useSpecialExec() {
-			return true;
-		}
-
-		@Override
-		public Mixed execs(Target t, Environment env, Script parent, ParseTree... nodes) {
-			try {
-				do {
-					try {
-						parent.eval(nodes[0], env);
-					} catch (LoopContinueException e) {
-						//ok. No matter how many times it tells us to continue, we're only going to continue once.
-					}
-				} while(ArgumentValidation.getBoolean(parent.seval(nodes[1], env), t));
-			} catch (LoopBreakException e) {
-				if(e.getTimes() > 1) {
-					throw new LoopBreakException(e.getTimes() - 1, t);
-				}
-			}
-			return CVoid.VOID;
-		}
-
 		@Override
 		public Scope linkScope(StaticAnalysis analysis, Scope parentScope,
 				ParseTree ast, Environment env, Set<ConfigCompileException> exceptions) {
@@ -2353,7 +2733,7 @@ public List<Boolean> isScope(List<ParseTree> children) {
 	}
 
 	@api
-	public static class _break extends AbstractFunction implements Optimizable {
+	public static class _break extends AbstractFunction implements FlowFunction<Void>, Optimizable {
 
 		public static final String NAME = "break";
 
@@ -2362,6 +2742,20 @@ public String getName() {
 			return "break";
 		}
 
+		@Override
+		public StepResult<Void> begin(Target t, ParseTree[] children, Environment env) {
+			if(children.length == 0) {
+				return new StepResult<>(new FlowControl(new BreakAction(1, t)), null);
+			}
+			return new StepResult<>(new Evaluate(children[0]), null);
+		}
+
+		@Override
+		public StepResult<Void> childCompleted(Target t, Void state, Mixed result, Environment env) {
+			int n = ArgumentValidation.getInt32(result, t, env);
+			return new StepResult<>(new FlowControl(new BreakAction(n, t)), null);
+		}
+
 		@Override
 		public Integer[] numArgs() {
 			return new Integer[]{0, 1};
@@ -2471,13 +2865,9 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment env, Mixed... args)
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args)
 				throws CancelCommandException, ConfigRuntimeException {
-			int num = 1;
-			if(args.length == 1) {
-				num = ArgumentValidation.getInt32(args[0], t);
-			}
-			throw new LoopBreakException(num, t);
+			throw new Error("break() should not be called via exec(); it is handled by the iterative interpreter");
 		}
 
 		@Override
@@ -2515,7 +2905,7 @@ public ParseTree optimizeDynamic(Target t, Environment env,
 							+ " be hard coded, and should not be dynamically determinable, since this is always a sign"
 							+ " of loose code flow, which should be avoided.", t);
 				}
-				if(!(children.get(0).getData().isInstanceOf(CInt.TYPE))) {
+				if(!(children.get(0).getData().isInstanceOf(CInt.TYPE, null, env))) {
 					throw new ConfigCompileException("break() only accepts integer values.", t);
 				}
 			}
@@ -2533,7 +2923,7 @@ public Set<OptimizationOption> optimizationOptions() {
 	}
 
 	@api
-	public static class _continue extends AbstractFunction {
+	public static class _continue extends AbstractFunction implements FlowFunction<Void> {
 
 		public static final String NAME = "continue";
 
@@ -2542,6 +2932,20 @@ public String getName() {
 			return NAME;
 		}
 
+		@Override
+		public StepResult<Void> begin(Target t, ParseTree[] children, Environment env) {
+			if(children.length == 0) {
+				return new StepResult<>(new FlowControl(new ContinueAction(1, t)), null);
+			}
+			return new StepResult<>(new Evaluate(children[0]), null);
+		}
+
+		@Override
+		public StepResult<Void> childCompleted(Target t, Void state, Mixed result, Environment env) {
+			int n = ArgumentValidation.getInt32(result, t, env);
+			return new StepResult<>(new FlowControl(new ContinueAction(n, t)), null);
+		}
+
 		@Override
 		public Integer[] numArgs() {
 			return new Integer[]{0, 1};
@@ -2619,13 +3023,9 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment env, Mixed... args)
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args)
 				throws CancelCommandException, ConfigRuntimeException {
-			int num = 1;
-			if(args.length == 1) {
-				num = ArgumentValidation.getInt32(args[0], t);
-			}
-			throw new LoopContinueException(num, t);
+			throw new Error("continue() should not be called via exec(); it is handled by the iterative interpreter");
 		}
 
 		@Override
@@ -2649,7 +3049,7 @@ public ExampleScript[] examples() throws ConfigCompileException {
 	}
 
 	@api
-	public static class _return extends AbstractFunction implements Optimizable {
+	public static class _return extends AbstractFunction implements FlowFunction<Void>, Optimizable {
 
 		public static final String NAME = "return";
 
@@ -2658,6 +3058,19 @@ public String getName() {
 			return NAME;
 		}
 
+		@Override
+		public StepResult<Void> begin(Target t, ParseTree[] children, Environment env) {
+			if(children.length == 0) {
+				return new StepResult<>(new FlowControl(new ReturnAction(CVoid.VOID, t)), null);
+			}
+			return new StepResult<>(new Evaluate(children[0]), null);
+		}
+
+		@Override
+		public StepResult<Void> childCompleted(Target t, Void state, Mixed result, Environment env) {
+			return new StepResult<>(new FlowControl(new ReturnAction(result, t)), null);
+		}
+
 		@Override
 		public Integer[] numArgs() {
 			return new Integer[]{0, 1};
@@ -2756,9 +3169,8 @@ public Set<OptimizationOption> optimizationOptions() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment env, Mixed... args) throws ConfigRuntimeException {
-			Mixed ret = (args.length == 1 ? args[0] : CVoid.VOID);
-			throw new FunctionReturnException(ret, t);
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
+			throw new Error("return() should not be called via exec(); it is handled by the iterative interpreter");
 		}
 
 		@Override
@@ -2770,7 +3182,7 @@ public FunctionSignatures getSignatures() {
 	}
 
 	@api
-	public static class call_proc extends AbstractFunction implements Optimizable {
+	public static class call_proc extends CallbackYield implements Optimizable {
 
 		@Override
 		public String getName() {
@@ -2813,17 +3225,18 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment env, Mixed... args) throws ConfigRuntimeException {
+		protected void execWithYield(Target t, Environment env, Mixed[] args, Yield yield) {
 			if(args.length < 1) {
 				throw new CREInsufficientArgumentsException("Expecting at least one argument to " + getName(), t);
 			}
 			Procedure proc = env.getEnv(GlobalEnv.class).GetProcs().get(args[0].val());
-			if(proc != null) {
-				List<Mixed> vars = new ArrayList<>(Arrays.asList(args));
-				vars.remove(0);
-				return proc.execute(vars, env, t);
+			if(proc == null) {
+				throw new CREInvalidProcedureException("Unknown procedure \"" + args[0].val() + "\"", t);
 			}
-			throw new CREInvalidProcedureException("Unknown procedure \"" + args[0].val() + "\"", t);
+			ProcedureUsage procUsage = new ProcedureUsage(proc, env, t);
+			Mixed[] procArgs = Arrays.copyOfRange(args, 1, args.length);
+			yield.call(procUsage, env, t, procArgs)
+					.then((result, y) -> y.done(() -> result));
 		}
 
 		@Override
@@ -2863,17 +3276,18 @@ public ParseTree optimizeDynamic(Target t, Environment env,
 	public static class call_proc_array extends call_proc {
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
-			CArray ca = ArgumentValidation.getArray(args[1], t);
+		protected void execWithYield(Target t, Environment env, Mixed[] args, Yield yield) {
+			CArray ca = ArgumentValidation.getArray(args[1], t, env);
 			if(ca.inAssociativeMode()) {
 				throw new CRECastException("Expected the array passed to " + getName() + " to be non-associative.", t);
 			}
-			Mixed[] args2 = new Mixed[(int) ca.size() + 1];
+			Mixed[] args2 = new Mixed[(int) ca.size(env) + 1];
 			args2[0] = args[0];
 			for(int i = 1; i < args2.length; i++) {
-				args2[i] = ca.get(i - 1, t);
+				args2[i] = ca.get(i - 1, t, env);
 			}
-			return super.exec(t, environment, args2);
+			// TODO: This probably needs to change once generics are added
+			super.execWithYield(t, env, args2, yield);
 		}
 
 		@Override
@@ -2924,7 +3338,7 @@ public Integer[] numArgs() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment env, Mixed... args) throws CancelCommandException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws CancelCommandException {
 			if(args.length == 0) {
 				throw new CancelCommandException("", t);
 			}
diff --git a/src/main/java/com/laytonsmith/core/functions/Crypto.java b/src/main/java/com/laytonsmith/core/functions/Crypto.java
index c27de8bcd8..7d89d04ffa 100644
--- a/src/main/java/com/laytonsmith/core/functions/Crypto.java
+++ b/src/main/java/com/laytonsmith/core/functions/Crypto.java
@@ -13,6 +13,7 @@
 import com.laytonsmith.core.constructs.CSecureString;
 import com.laytonsmith.core.constructs.CString;
 import com.laytonsmith.core.constructs.Target;
+import com.laytonsmith.core.constructs.generics.GenericParameters;
 import com.laytonsmith.core.environments.Environment;
 import com.laytonsmith.core.exceptions.CRE.CRECastException;
 import com.laytonsmith.core.exceptions.CRE.CREPluginInternalException;
@@ -44,7 +45,7 @@ public static String docs() {
 				+ " rather than the default string value \"**secure string**\".";
 	}
 
-	private static CString getHMAC(String algorithm, Target t, Mixed[] args) {
+	private static CString getHMAC(String algorithm, Target t, Environment env, Mixed[] args) {
 		try {
 			byte[] key;
 			if(args[0] instanceof CByteArray) {
@@ -55,7 +56,7 @@ private static CString getHMAC(String algorithm, Target t, Mixed[] args) {
 			SecretKeySpec signingKey = new SecretKeySpec(key, algorithm);
 			Mac mac = Mac.getInstance(algorithm);
 			mac.init(signingKey);
-			byte[] hmac = mac.doFinal(getByteArrayFromArg(args[1]));
+			byte[] hmac = mac.doFinal(getByteArrayFromArg(args[1], env));
 			String hash = StringUtils.toHex(hmac).toLowerCase();
 			return new CString(hash, t);
 		} catch (NoSuchAlgorithmException | InvalidKeyException ex) {
@@ -63,9 +64,9 @@ private static CString getHMAC(String algorithm, Target t, Mixed[] args) {
 		}
 	}
 
-	private static byte[] getByteArrayFromArg(Mixed c) {
+	private static byte[] getByteArrayFromArg(Mixed c, Environment env) {
 		byte[] val;
-		if(c.isInstanceOf(CSecureString.TYPE)) {
+		if(c.isInstanceOf(CSecureString.TYPE, null, env)) {
 			val = ArrayUtils.charToBytes(((CSecureString) c).getDecryptedCharArray());
 		} else if(c instanceof CByteArray) {
 			val = ((CByteArray) c).asByteArrayCopy();
@@ -114,7 +115,7 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			String s = args[0].val();
 			StringBuilder b = new StringBuilder();
 			for(int i = 0; i < s.length(); i++) {
@@ -193,9 +194,9 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			try {
-				byte[] val = getByteArrayFromArg(args[0]);
+				byte[] val = getByteArrayFromArg(args[0], env);
 				MessageDigest digest = java.security.MessageDigest.getInstance("MD5");
 				digest.update(val);
 				String hash = StringUtils.toHex(digest.digest()).toLowerCase();
@@ -264,9 +265,9 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			try {
-				byte[] val = getByteArrayFromArg(args[0]);
+				byte[] val = getByteArrayFromArg(args[0], env);
 				MessageDigest digest = java.security.MessageDigest.getInstance("SHA1");
 				digest.update(val);
 				String hash = StringUtils.toHex(digest.digest()).toLowerCase();
@@ -334,9 +335,9 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			try {
-				byte[] val = getByteArrayFromArg(args[0]);
+				byte[] val = getByteArrayFromArg(args[0], env);
 				MessageDigest digest = java.security.MessageDigest.getInstance("SHA-256");
 				digest.update(val);
 				String hash = StringUtils.toHex(digest.digest()).toLowerCase();
@@ -405,9 +406,9 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			try {
-				byte[] val = getByteArrayFromArg(args[0]);
+				byte[] val = getByteArrayFromArg(args[0], env);
 				MessageDigest digest = java.security.MessageDigest.getInstance("SHA-512");
 				digest.update(val);
 				String hash = StringUtils.toHex(digest.digest()).toLowerCase();
@@ -453,14 +454,14 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			int log_rounds = 5;
 			if(args.length == 2) {
 				log_rounds = ArgumentValidation.getInt32(args[1], t);
 			}
 			try {
 				String val;
-				if(args[0].isInstanceOf(CSecureString.TYPE)) {
+				if(args[0].isInstanceOf(CSecureString.TYPE, null, env)) {
 					val = new String(((CSecureString) args[0]).getDecryptedCharArray());
 				} else {
 					val = args[0].val();
@@ -529,9 +530,9 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			String val;
-			if(args[0].isInstanceOf(CSecureString.TYPE)) {
+			if(args[0].isInstanceOf(CSecureString.TYPE, null, env)) {
 				val = new String(((CSecureString) args[0]).getDecryptedCharArray());
 			} else {
 				val = args[0].val();
@@ -590,7 +591,7 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			CByteArray ba = ArgumentValidation.getByteArray(args[0], t);
 			byte[] data = ba.asByteArrayCopy();
 			data = Base64.encodeBase64(data);
@@ -645,7 +646,7 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			CByteArray ba = ArgumentValidation.getByteArray(args[0], t);
 			byte[] data = ba.asByteArrayCopy();
 			data = Base64.decodeBase64(data);
@@ -722,8 +723,8 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
-			return getHMAC("HmacMD5", t, args);
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
+			return getHMAC("HmacMD5", t, env, args);
 		}
 
 		@Override
@@ -782,8 +783,8 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
-			return getHMAC("HmacSHA1", t, args);
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
+			return getHMAC("HmacSHA1", t, env, args);
 		}
 
 		@Override
@@ -842,8 +843,8 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
-			return getHMAC("HmacSHA256", t, args);
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
+			return getHMAC("HmacSHA256", t, env, args);
 		}
 
 		@Override
diff --git a/src/main/java/com/laytonsmith/core/functions/DataHandling.java b/src/main/java/com/laytonsmith/core/functions/DataHandling.java
index bc4eb359aa..66925f9117 100644
--- a/src/main/java/com/laytonsmith/core/functions/DataHandling.java
+++ b/src/main/java/com/laytonsmith/core/functions/DataHandling.java
@@ -13,7 +13,9 @@
 import com.laytonsmith.annotations.seealso;
 import com.laytonsmith.annotations.unbreakable;
 import com.laytonsmith.core.ArgumentValidation;
+import com.laytonsmith.core.CallbackYield;
 import com.laytonsmith.core.natives.interfaces.Callable;
+import com.laytonsmith.core.FlowFunction;
 import com.laytonsmith.core.Globals;
 import com.laytonsmith.core.LogLevel;
 import com.laytonsmith.core.MSLog;
@@ -26,6 +28,10 @@
 import com.laytonsmith.core.Script;
 import com.laytonsmith.core.Security;
 import com.laytonsmith.core.Static;
+import com.laytonsmith.core.StepAction;
+import com.laytonsmith.core.StepAction.Complete;
+import com.laytonsmith.core.StepAction.Evaluate;
+import com.laytonsmith.core.StepAction.StepResult;
 import com.laytonsmith.core.compiler.BranchStatement;
 import com.laytonsmith.core.compiler.CompilerEnvironment;
 import com.laytonsmith.core.compiler.CompilerWarning;
@@ -70,6 +76,7 @@
 import com.laytonsmith.core.constructs.InstanceofUtil;
 import com.laytonsmith.core.constructs.ProcedureUsage;
 import com.laytonsmith.core.constructs.Target;
+import com.laytonsmith.core.constructs.generics.GenericParameters;
 import com.laytonsmith.core.environments.CommandHelperEnvironment;
 import com.laytonsmith.core.environments.Environment;
 import com.laytonsmith.core.environments.Environment.EnvironmentImpl;
@@ -85,12 +92,12 @@
 import com.laytonsmith.core.exceptions.CRE.CREInsufficientPermissionException;
 import com.laytonsmith.core.exceptions.CRE.CREInvalidProcedureException;
 import com.laytonsmith.core.exceptions.CRE.CRERangeException;
-import com.laytonsmith.core.exceptions.CRE.CREStackOverflowError;
 import com.laytonsmith.core.exceptions.CRE.CREThrowable;
 import com.laytonsmith.core.exceptions.CancelCommandException;
 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;
@@ -143,7 +150,7 @@ public Integer[] numArgs() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment env, Mixed... args) throws CancelCommandException, ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws CancelCommandException, ConfigRuntimeException {
 			return new CArray(t, args);
 		}
 
@@ -238,7 +245,7 @@ public ParseTree optimizeDynamic(Target t, Environment env,
 						String v;
 						if(value instanceof IVariable iVariable) {
 							v = iVariable.getVariableName();
-						} else if(value.isInstanceOf(CString.TYPE)) {
+						} else if(value.isInstanceOf(CString.TYPE, null, env)) {
 							v = ((CString) value).getQuote();
 						} else {
 							v = "@value";
@@ -279,7 +286,7 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			return CArray.GetAssociativeArray(t, args);
 		}
 
@@ -340,7 +347,7 @@ public Integer[] numArgs() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment env, Mixed... args) throws CancelCommandException, ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws CancelCommandException, ConfigRuntimeException {
 			IVariableList list = env.getEnv(GlobalEnv.class).GetVarList();
 			IVariable var;
 			if(args.length == 3) {
@@ -386,9 +393,9 @@ public Mixed exec(Target t, Environment env, Mixed... args) throws CancelCommand
 				if(val instanceof CVoid) {
 					throw new CRECastException("Void may not be assigned to a variable", t);
 				}
-				if(!InstanceofUtil.isInstanceof(val.typeof(), type, env)) {
+				if(!InstanceofUtil.isInstanceof(val.typeof(env), type, env)) {
 					throw new CRECastException(varName + " is of type " + type.val() + ", but a value of type "
-							+ val.typeof() + " was assigned to it.", t);
+							+ val.typeof(env) + " was assigned to it.", t);
 				}
 
 				// Set variable in variable list.
@@ -420,9 +427,9 @@ public Mixed exec(Target t, Environment env, Mixed... args) throws CancelCommand
 					var = new IVariable(Auto.TYPE, varName, val, t);
 					list.set(var);
 				} else {
-					if(!InstanceofUtil.isInstanceof(val.typeof(), var.getDefinedType(), env)) {
+					if(!InstanceofUtil.isInstanceof(val.typeof(env), var.getDefinedType(), env)) {
 						throw new CRECastException(varName + " is of type " + var.getDefinedType()
-								+ ", but a value of type " + val.typeof() + " was assigned to it.", t);
+								+ ", but a value of type " + val.typeof(env) + " was assigned to it.", t);
 					}
 					var.setIval(val);
 				}
@@ -662,7 +669,7 @@ public Mixed optimize(Target t, Environment env, Mixed... args) throws ConfigCom
 			int offset = 0;
 			if(args.length == 3) {
 				offset = 1;
-				if(!args[0].isInstanceOf(CClassType.TYPE)
+				if(!(args[0] instanceof CClassType)
 						&& (!(args[0] instanceof CFunction) || !args[0].val().equals(__type_ref__.NAME))) {
 					throw new ConfigCompileException("Expecting a ClassType for parameter 1 to assign", t);
 				}
@@ -716,7 +723,7 @@ public ParseTree optimizeDynamic(Target t, Environment env,
 				if(typeNode.getData() instanceof CClassType declaredType
 						&& varNode.getData() instanceof IVariable) {
 					if(valNode.isConst()) {
-						CClassType valType = valNode.getData().typeof();
+						CClassType valType = valNode.getData().typeof(env);
 						if((valType != CClassType.AUTO || declaredType == CClassType.AUTO)
 								&& InstanceofUtil.isInstanceof(valType, declaredType, env)) {
 							ParseTree newAssignNode = new ParseTree(new CFunction(__unsafe_assign__.NAME, t), fileOptions);
@@ -845,8 +852,8 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment env, Mixed... args) throws ConfigRuntimeException {
-			return CBoolean.get(!(args[0].isInstanceOf(CArray.TYPE)));
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
+			return CBoolean.get(!(args[0].isInstanceOf(CArray.TYPE, null, env)));
 		}
 
 		@Override
@@ -906,8 +913,8 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment env, Mixed... args) throws ConfigRuntimeException {
-			return CBoolean.get(args[0].isInstanceOf(CString.TYPE));
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
+			return CBoolean.get(args[0].isInstanceOf(CString.TYPE, null, env));
 		}
 
 		@Override
@@ -965,8 +972,8 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment env, Mixed... args) throws ConfigRuntimeException {
-			return CBoolean.get(args[0].isInstanceOf(CByteArray.TYPE));
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
+			return CBoolean.get(args[0] instanceof CByteArray);
 		}
 
 		@Override
@@ -1025,8 +1032,8 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment env, Mixed... args) throws ConfigRuntimeException {
-			return CBoolean.get(args[0].isInstanceOf(CArray.TYPE));
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
+			return CBoolean.get(args[0].isInstanceOf(CArray.TYPE, null, env));
 		}
 
 		@Override
@@ -1087,8 +1094,8 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment env, Mixed... args) throws ConfigRuntimeException {
-			return CBoolean.get(args[0].isInstanceOf(CInt.TYPE) || args[0].isInstanceOf(CDouble.TYPE));
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
+			return CBoolean.get(args[0].isInstanceOf(CInt.TYPE, null, env) || args[0].isInstanceOf(CDouble.TYPE, null, env));
 		}
 
 		@Override
@@ -1150,8 +1157,8 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment env, Mixed... args) throws ConfigRuntimeException {
-			return CBoolean.get(args[0].isInstanceOf(CDouble.TYPE));
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
+			return CBoolean.get(args[0].isInstanceOf(CDouble.TYPE, null, env));
 		}
 
 		@Override
@@ -1211,8 +1218,8 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment env, Mixed... args) throws ConfigRuntimeException {
-			return CBoolean.get(args[0].isInstanceOf(CInt.TYPE));
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
+			return CBoolean.get(args[0].isInstanceOf(CInt.TYPE, null, env));
 		}
 
 		@Override
@@ -1271,8 +1278,8 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment env, Mixed... args) throws ConfigRuntimeException {
-			return CBoolean.get(args[0].isInstanceOf(CBoolean.TYPE));
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
+			return CBoolean.get(args[0] instanceof CBoolean);
 		}
 
 		@Override
@@ -1330,7 +1337,7 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment env, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			return CBoolean.get(args[0] instanceof CNull);
 		}
 
@@ -1385,7 +1392,7 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			boolean b = true;
 			try {
 				ArgumentValidation.getNumber(args[0], t);
@@ -1459,7 +1466,7 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			double d;
 			try {
 				d = ArgumentValidation.getDouble(args[0], t);
@@ -1497,7 +1504,197 @@ public ExampleScript[] examples() throws ConfigCompileException {
 	@api
 	@unbreakable
 	@SelfStatement
-	public static class proc extends AbstractFunction implements BranchStatement, VariableScope, DocumentSymbolProvider {
+	public static class proc extends AbstractFunction implements FlowFunction<proc.ProcState>, BranchStatement, VariableScope, DocumentSymbolProvider {
+
+		static class ProcState {
+			enum Phase { EVAL_DEFAULTS, EVAL_PARAMS }
+			Phase phase = Phase.EVAL_DEFAULTS;
+
+			ParseTree[] nodes; // after stripping return type prefix
+			CClassType returnType;
+			ParseTree code;
+			IVariableList originalList;
+
+			// Phase 1 (EVAL_DEFAULTS)
+			int defaultIndex = 1; // starts at 1, skips proc name
+			Mixed[] paramDefaultValues;
+			boolean procDefinitelyNotConstant;
+
+			// Phase 2 (EVAL_PARAMS)
+			int paramIndex = 0;
+			String name = "";
+			List<IVariable> vars = new ArrayList<>();
+			List<String> varNames = new ArrayList<>();
+
+			@Override
+			public String toString() {
+				return phase + " idx=" + (phase == Phase.EVAL_DEFAULTS ? defaultIndex : paramIndex);
+			}
+		}
+
+		@Override
+		public StepResult<ProcState> begin(Target t, ParseTree[] children, Environment env) {
+			ProcState state = new ProcState();
+
+			// Parse return type from first child (CClassType or CVoid)
+			state.returnType = Auto.TYPE;
+			NodeModifiers modifiers = null;
+			ParseTree[] nodes = children;
+			if(nodes[0].getData().equals(CVoid.VOID) || nodes[0].getData() instanceof CClassType) {
+				if(nodes[0].getData().equals(CVoid.VOID)) {
+					state.returnType = CVoid.TYPE;
+				} else {
+					state.returnType = (CClassType) nodes[0].getData();
+				}
+				ParseTree[] newNodes = new ParseTree[nodes.length - 1];
+				for(int i = 1; i < nodes.length; i++) {
+					newNodes[i - 1] = nodes[i];
+				}
+				modifiers = nodes[0].getNodeModifiers();
+				nodes = newNodes;
+			}
+			nodes[0].getNodeModifiers().merge(modifiers);
+			state.nodes = nodes;
+
+			// Save variable list for restoration after param evaluation
+			state.originalList = env.getEnv(GlobalEnv.class).GetVarList().clone();
+
+			// Get code block (last node)
+			state.code = nodes[nodes.length - 1];
+
+			// Init default values array
+			state.paramDefaultValues = new Mixed[nodes.length - 1];
+
+			// Start Phase 1: evaluate default parameter values
+			return advanceToNextDefault(t, state, env);
+		}
+
+		@Override
+		public StepResult<ProcState> childCompleted(Target t, ProcState state,
+				Mixed result, Environment env) {
+			if(state.phase == ProcState.Phase.EVAL_DEFAULTS) {
+				env.getEnv(GlobalEnv.class).ClearFlag(GlobalEnv.FLAG_VAR_ARGS_ALLOWED);
+				state.paramDefaultValues[state.defaultIndex] = result;
+				state.defaultIndex++;
+				return advanceToNextDefault(t, state, env);
+			} else {
+				// EVAL_PARAMS phase
+				env.getEnv(GlobalEnv.class).ClearFlag(GlobalEnv.FLAG_VAR_ARGS_ALLOWED);
+				env.getEnv(GlobalEnv.class).ClearFlag(GlobalEnv.FLAG_NO_CHECK_DUPLICATE_ASSIGN);
+
+				Mixed defaultValue = state.paramDefaultValues[state.paramIndex];
+				IVariable ivar;
+				if(defaultValue != null) {
+					ivar = (IVariable) result;
+				} else {
+					if(state.paramIndex == 0) {
+						if(result instanceof IVariable) {
+							throw new CREInvalidProcedureException(
+									"Anonymous Procedures are not allowed", t);
+						}
+						state.name = result.val();
+						state.paramIndex++;
+						return advanceToNextParam(t, state, env);
+					}
+					if(!(result instanceof IVariable)) {
+						throw new CREInvalidProcedureException(
+								"You must use IVariables as the arguments", t);
+					}
+					ivar = (IVariable) result;
+				}
+
+				// Check for duplicate parameter names
+				String varName = ivar.getVariableName();
+				if(state.varNames.contains(varName)) {
+					throw new CREInvalidProcedureException(
+							"Same variable name defined twice in " + state.name, t);
+				}
+				state.varNames.add(varName);
+
+				// Store IVariable with default value
+				Mixed ivarVal = (defaultValue != null ? defaultValue : new CString("", t));
+				state.vars.add(new IVariable(ivar.getDefinedType(),
+						ivar.getVariableName(), ivarVal, ivar.getTarget()));
+
+				state.paramIndex++;
+				return advanceToNextParam(t, state, env);
+			}
+		}
+
+		@Override
+		public StepResult<ProcState> childInterrupted(Target t, ProcState state,
+				StepAction.FlowControl action, Environment env) {
+			env.getEnv(GlobalEnv.class).ClearFlag(GlobalEnv.FLAG_VAR_ARGS_ALLOWED);
+			env.getEnv(GlobalEnv.class).ClearFlag(GlobalEnv.FLAG_NO_CHECK_DUPLICATE_ASSIGN);
+			return null; // propagate
+		}
+
+		private StepResult<ProcState> advanceToNextDefault(Target t, ProcState state, Environment env) {
+			while(state.defaultIndex < state.nodes.length - 1) {
+				ParseTree node = state.nodes[state.defaultIndex];
+				if(node.getData() instanceof CFunction cf) {
+					if(cf.val().equals(assign.NAME) || cf.val().equals(__unsafe_assign__.NAME)) {
+						ParseTree paramDefaultValueNode = node.getChildAt(node.numberOfChildren() - 1);
+						if(Construct.IsDynamicHelper(paramDefaultValueNode.getData())) {
+							state.procDefinitelyNotConstant = true;
+						}
+						env.getEnv(GlobalEnv.class).SetFlag(GlobalEnv.FLAG_VAR_ARGS_ALLOWED, true);
+						return new StepResult<>(new Evaluate(paramDefaultValueNode), state);
+					} else if(cf.val().equals(__autoconcat__.NAME)) {
+						throw new CREInvalidProcedureException(
+								"Invalid arguments defined for procedure", t);
+					}
+				}
+				state.paramDefaultValues[state.defaultIndex] = null;
+				state.defaultIndex++;
+			}
+			return startParamPhase(t, state, env);
+		}
+
+		private StepResult<ProcState> startParamPhase(Target t, ProcState state, Environment env) {
+			state.phase = ProcState.Phase.EVAL_PARAMS;
+			state.paramIndex = 0;
+			return advanceToNextParam(t, state, env);
+		}
+
+		private StepResult<ProcState> advanceToNextParam(Target t, ProcState state, Environment env) {
+			if(state.paramIndex >= state.nodes.length - 1) {
+				return registerProc(t, state, env);
+			}
+			env.getEnv(GlobalEnv.class).SetFlag(GlobalEnv.FLAG_NO_CHECK_DUPLICATE_ASSIGN, true);
+			env.getEnv(GlobalEnv.class).SetFlag(GlobalEnv.FLAG_VAR_ARGS_ALLOWED, true);
+			Mixed defaultValue = state.paramDefaultValues[state.paramIndex];
+			if(defaultValue != null) {
+				// Build temp assign node with pre-evaluated default value
+				ParseTree assignNode = state.nodes[state.paramIndex];
+				CFunction assignFunc = (CFunction) assignNode.getData();
+				CFunction newCf = new CFunction(assignFunc.val(), assignNode.getTarget());
+				newCf.setFunction(assignFunc.getCachedFunction());
+				ParseTree tempAssignNode = new ParseTree(newCf, assignNode.getFileOptions());
+				if(assignNode.numberOfChildren() == 3) {
+					tempAssignNode.addChild(assignNode.getChildAt(0));
+					tempAssignNode.addChild(assignNode.getChildAt(1));
+					tempAssignNode.addChild(new ParseTree(defaultValue, assignNode.getFileOptions()));
+				} else {
+					tempAssignNode.addChild(assignNode.getChildAt(0));
+					tempAssignNode.addChild(new ParseTree(defaultValue, assignNode.getFileOptions()));
+				}
+				return new StepResult<>(new Evaluate(tempAssignNode, null, true), state);
+			} else {
+				return new StepResult<>(new Evaluate(state.nodes[state.paramIndex], null, true), state);
+			}
+		}
+
+		private StepResult<ProcState> registerProc(Target t, ProcState state, Environment env) {
+			env.getEnv(GlobalEnv.class).SetVarList(state.originalList);
+			Procedure myProc = new Procedure(state.name, state.returnType, state.vars,
+					state.nodes[0].getNodeModifiers().getComment(), state.code, t);
+			if(state.procDefinitelyNotConstant) {
+				myProc.definitelyNotConstant();
+			}
+			env.getEnv(GlobalEnv.class).GetProcs().put(myProc.getName(), myProc);
+			return new StepResult<>(new Complete(CVoid.VOID), state);
+		}
 
 		public static final String NAME = "proc";
 
@@ -1546,13 +1743,6 @@ public Boolean runAsync() {
 			return null;
 		}
 
-		@Override
-		public Mixed execs(Target t, Environment env, Script parent, ParseTree... nodes) {
-			Procedure myProc = getProcedure(t, env, parent, nodes);
-			env.getEnv(GlobalEnv.class).GetProcs().put(myProc.getName(), myProc);
-			return CVoid.VOID;
-		}
-
 		public static Procedure getProcedure(Target t, Environment env, Script parent, ParseTree... nodes) {
 			String name = "";
 			List<IVariable> vars = new ArrayList<>();
@@ -1560,7 +1750,7 @@ public static Procedure getProcedure(Target t, Environment env, Script parent, P
 			boolean procDefinitelyNotConstant = false;
 			CClassType returnType = Auto.TYPE;
 			NodeModifiers modifiers = null;
-			if(nodes[0].getData().equals(CVoid.VOID) || nodes[0].getData().isInstanceOf(CClassType.TYPE)) {
+			if(nodes[0].getData().equals(CVoid.VOID) || nodes[0].getData() instanceof CClassType) {
 				if(nodes[0].getData().equals(CVoid.VOID)) {
 					returnType = CVoid.TYPE;
 				} else {
@@ -1621,8 +1811,13 @@ public static Procedure getProcedure(Target t, Environment env, Script parent, P
 					// Construct temporary assign node to assign resulting default parameter value.
 					ParseTree assignNode = nodes[i];
 					CFunction assignFunc = (CFunction) assignNode.getData();
-					ParseTree tempAssignNode = new ParseTree(new CFunction(assignFunc.val(),
-							assignNode.getTarget()), assignNode.getFileOptions());
+					CFunction tempFunc = new CFunction(assignFunc.val(), assignNode.getTarget());
+					try {
+						tempFunc.getFunction();
+					} catch(ConfigCompileException ex) {
+						throw new Error(ex);
+					}
+					ParseTree tempAssignNode = new ParseTree(tempFunc, assignNode.getFileOptions());
 					if(assignNode.numberOfChildren() == 3) {
 						tempAssignNode.addChild(assignNode.getChildAt(0));
 						tempAssignNode.addChild(assignNode.getChildAt(1));
@@ -1696,7 +1891,7 @@ public static Procedure getProcedure(Target t, Environment env, Script parent, P
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment env, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			return CVoid.VOID;
 		}
 
@@ -1768,11 +1963,6 @@ public Scope linkScope(StaticAnalysis analysis, Scope parentScope, ParseTree ast
 			return declScope;
 		}
 
-		@Override
-		public boolean useSpecialExec() {
-			return true;
-		}
-
 		/**
 		 * Returns either null to indicate that the procedure is not const, or returns a single Mixed, which should
 		 * replace the call to the procedure.
@@ -1801,8 +1991,7 @@ public static Mixed optimizeProcedure(Target t, Procedure myProc, List<ParseTree
 					//Yup! It worked. It's a const proc.
 					return c;
 				} catch (ConfigRuntimeException e) {
-					if(e instanceof CREThrowable
-							&& ((CREThrowable) e).isInstanceOf(CREInvalidProcedureException.TYPE)) {
+					if(e instanceof CREThrowable && ((CREThrowable) e) instanceof CREInvalidProcedureException) {
 						//This is the only valid exception that doesn't strictly mean it's a bad
 						//call.
 						return null;
@@ -1940,7 +2129,7 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment env, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			String procName = args[0].val();
 			Procedure proc = env.getEnv(GlobalEnv.class).GetProcs().get(procName);
 			if(proc == null) {
@@ -2035,7 +2224,8 @@ public Set<OptimizationOption> optimizationOptions() {
 
 	@api
 	@DocumentLink(0)
-	public static class include extends AbstractFunction implements Optimizable, DocumentLinkProvider {
+	public static class include extends AbstractFunction implements Optimizable, DocumentLinkProvider,
+			FlowFunction<include.IncludeState> {
 
 		public static final String NAME = "include";
 
@@ -2075,98 +2265,125 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public CVoid exec(Target t, Environment env, Mixed... args) throws ConfigRuntimeException {
+		public CVoid exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			return CVoid.VOID;
 		}
 
-		@Override
-		public CVoid execs(Target t, Environment env, Script parent, ParseTree... nodes) {
-			ParseTree tree = nodes[0];
-			Mixed arg = parent.seval(tree, env);
-			String location = arg.val();
-			File file = Static.GetFileFromArgument(location, env, t, null);
-			try {
-				file = file.getCanonicalFile();
-			} catch (IOException ex) {
-				throw new CREIOException(ex.getMessage(), t);
+		static class IncludeState {
+			enum Phase { EVAL_PATH, EVAL_INCLUDE }
+			Phase phase = Phase.EVAL_PATH;
+			ParseTree[] children;
+
+			IncludeState(ParseTree[] children) {
+				this.children = children;
 			}
-			// Create new static analysis for dynamic includes that have not yet been cached.
-			StaticAnalysis analysis;
-			IncludeCache includeCache = env.getEnv(StaticRuntimeEnv.class).getIncludeCache();
-			boolean isFirstCompile = false;
-			Scope parentScope = includeCache.getDynamicAnalysisParentScopeCache().get(t);
-			if(parentScope != null) {
-				analysis = includeCache.getStaticAnalysis(file);
-				if(analysis == null) {
-					analysis = new StaticAnalysis(true);
-					analysis.getStartScope().addParent(parentScope);
-					isFirstCompile = true;
-				}
-			} else {
-				analysis = new StaticAnalysis(true); // It's a static include.
+
+			@Override
+			public String toString() {
+				return phase.name();
 			}
+		}
 
-			// Get or load the include.
-			ParseTree include = IncludeCache.get(file, env, env.getEnvClasses(), analysis, t);
-
-			// Perform static analysis for dynamic includes.
-			// This should not run if this is the first compile for this include, as IncludeCache.get() checks it then.
-			/*
-			 *  TODO - This analysis runs on an optimized AST.
-			 *  Cloning, caching and using the non-optimized AST would be nice.
-			 *  This solution is acceptable in the meantime, as the first analysis of a dynamic include runs
-			 *  on the non-optimized AST through IncludeCache.get(), and otherwise-runtime errors should still be
-			 *  caught when analyzing the optimized AST.
-			 */
-			if(isFirstCompile) {
-
-				// Remove this parent scope since it should not end up in the cached analysis.
-				analysis.getStartScope().removeParent(parentScope);
-			} else {
+		@Override
+		public StepResult<IncludeState> begin(Target t, ParseTree[] children, Environment env) {
+			IncludeState state = new IncludeState(children);
+			return new StepResult<>(new Evaluate(children[0]), state);
+		}
 
-				// Set up analysis. Cloning is required to not mess up the cached analysis.
-				analysis = analysis.clone();
-				analysis.getStartScope().addParent(parentScope);
-				Set<ConfigCompileException> exceptions = new HashSet<>();
-				analysis.analyzeFinalScopeGraph(env, exceptions);
-
-				// Handle compile exceptions.
-				if(exceptions.size() == 1) {
-					ConfigCompileException ex = exceptions.iterator().next();
-					String fileName = (ex.getFile() == null ? "Unknown Source" : ex.getFile().getName());
-					throw new CREIncludeException(
-							"There was a compile error when trying to include the script at " + file
-							+ "\n" + ex.getMessage() + " :: " + fileName + ":" + ex.getLineNum(), t);
-				} else if(exceptions.size() > 1) {
-					StringBuilder b = new StringBuilder();
-					b.append("There were compile errors when trying to include the script at ")
-							.append(file).append("\n");
-					for(ConfigCompileException ex : exceptions) {
-						String fileName = (ex.getFile() == null ? "Unknown Source" : ex.getFile().getName());
-						b.append(ex.getMessage()).append(" :: ").append(fileName).append(":")
-								.append(ex.getLineNum()).append("\n");
+		@Override
+		public StepResult<IncludeState> childCompleted(Target t, IncludeState state,
+				Mixed result, Environment env) {
+			switch(state.phase) {
+				case EVAL_PATH -> {
+					String location = result.val();
+					File file = Static.GetFileFromArgument(location, env, t, null);
+					try {
+						file = file.getCanonicalFile();
+					} catch(IOException ex) {
+						throw new CREIOException(ex.getMessage(), t);
+					}
+					StaticAnalysis analysis;
+					IncludeCache includeCache = env.getEnv(StaticRuntimeEnv.class).getIncludeCache();
+					boolean isFirstCompile = false;
+					Scope parentScope = includeCache.getDynamicAnalysisParentScopeCache().get(t);
+					if(parentScope != null) {
+						analysis = includeCache.getStaticAnalysis(file);
+						if(analysis == null) {
+							analysis = new StaticAnalysis(true);
+							analysis.getStartScope().addParent(parentScope);
+							isFirstCompile = true;
+						}
+					} else {
+						analysis = new StaticAnalysis(true);
+					}
+					ParseTree include = IncludeCache.get(file, env, env.getEnvClasses(), analysis, t);
+					if(isFirstCompile) {
+						analysis.getStartScope().removeParent(parentScope);
+					} else if(parentScope != null) {
+						analysis = analysis.clone();
+						analysis.getStartScope().addParent(parentScope);
+						Set<ConfigCompileException> exceptions = new HashSet<>();
+						analysis.analyzeFinalScopeGraph(env, exceptions);
+						if(exceptions.size() == 1) {
+							ConfigCompileException ex = exceptions.iterator().next();
+							String fileName = (ex.getFile() == null
+									? "Unknown Source" : ex.getFile().getName());
+							throw new CREIncludeException(
+									"There was a compile error when trying to include the script at "
+									+ file + "\n" + ex.getMessage()
+									+ " :: " + fileName + ":" + ex.getLineNum(), t);
+						} else if(exceptions.size() > 1) {
+							StringBuilder b = new StringBuilder();
+							b.append("There were compile errors when trying to include the script at ")
+									.append(file).append("\n");
+							for(ConfigCompileException ex : exceptions) {
+								String fileName = (ex.getFile() == null
+										? "Unknown Source" : ex.getFile().getName());
+								b.append(ex.getMessage()).append(" :: ").append(fileName)
+										.append(":").append(ex.getLineNum()).append("\n");
+							}
+							throw new CREIncludeException(b.toString(), t);
+						}
+					}
+					if(include != null) {
+						StackTraceManager stManager
+								= env.getEnv(GlobalEnv.class).GetStackTraceManager();
+						stManager.addStackTraceFrame(
+								new StackTraceFrame("<<include " + result.val() + ">>", t));
+						state.phase = IncludeState.Phase.EVAL_INCLUDE;
+						return new StepResult<>(new Evaluate(include.getChildAt(0)), state);
 					}
-					throw new CREIncludeException(b.toString(), t);
+					return new StepResult<>(new Complete(CVoid.VOID), state);
+				}
+				case EVAL_INCLUDE -> {
+					return new StepResult<>(new Complete(CVoid.VOID), state);
 				}
 			}
+			throw ConfigRuntimeException.CreateUncatchableException(
+					"Invalid include state: " + state.phase, t);
+		}
 
-			if(include != null) {
-				// It could be an empty file
-				StackTraceManager stManager = env.getEnv(GlobalEnv.class).GetStackTraceManager();
-				stManager.addStackTraceElement(
-						new ConfigRuntimeException.StackTraceElement("<<include " + arg.val() + ">>", t));
-				try {
-					parent.eval(include.getChildAt(0), env);
-				} catch (AbstractCREException e) {
-					e.freezeStackTraceElements(stManager);
-					throw e;
-				} catch (StackOverflowError e) {
-					throw new CREStackOverflowError(null, t, e);
-				} finally {
-					stManager.popStackTraceElement();
+		@Override
+		public StepResult<IncludeState> childInterrupted(Target t, IncludeState state,
+				StepAction.FlowControl action, Environment env) {
+			if(state.phase == IncludeState.Phase.EVAL_INCLUDE) {
+				if(action.getAction() instanceof Exceptions.ThrowAction throwAction) {
+					ConfigRuntimeException ex = throwAction.getException();
+					if(ex instanceof AbstractCREException ace) {
+						ace.freezeStackTraceElements(
+								env.getEnv(GlobalEnv.class).GetStackTraceManager());
+					}
 				}
 			}
-			return CVoid.VOID;
+			return null;
+		}
+
+		@Override
+		public void cleanup(Target t, IncludeState state, Environment env) {
+			if(state != null
+					&& state.phase == IncludeState.Phase.EVAL_INCLUDE) {
+				env.getEnv(GlobalEnv.class).GetStackTraceManager().popStackTraceFrame();
+			}
 		}
 
 		@Override
@@ -2198,11 +2415,6 @@ public Scope linkScope(StaticAnalysis analysis, Scope parentScope, ParseTree ast
 			return super.linkScope(analysis, parentScope, ast, env, exceptions);
 		}
 
-		@Override
-		public boolean useSpecialExec() {
-			return true;
-		}
-
 		@Override
 		public Set<OptimizationOption> optimizationOptions() {
 			return EnumSet.of(
@@ -2291,7 +2503,7 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			// This function is rewritten to include() calls in compile time, so this doesn't exist in runtime.
 			throw new UnsupportedOperationException();
 		}
@@ -2439,7 +2651,7 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment env, Mixed... args) {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) {
 			return CBoolean.get(env.getEnv(GlobalEnv.class).GetProcs().get(args[0].val()) != null);
 		}
 	}
@@ -2483,8 +2695,8 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment env, Mixed... args) throws ConfigRuntimeException {
-			if(args[0].isInstanceOf(CArray.TYPE)) {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
+			if(args[0].isInstanceOf(CArray.TYPE, null, env)) {
 				return CBoolean.get(((CArray) args[0]).inAssociativeMode());
 			} else {
 				throw new CRECastException(this.getName() + " expects argument 1 to be an array", t);
@@ -2542,8 +2754,8 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
-			return CBoolean.get(args[0].isInstanceOf(CClosure.TYPE));
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
+			return CBoolean.get(args[0].isInstanceOf(CClosure.TYPE, null, env));
 		}
 
 		@Override
@@ -2603,11 +2815,11 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			String key;
-			if(args[0].isInstanceOf(CString.TYPE)) {
+			if(args[0].isInstanceOf(CString.TYPE, null, env)) {
 				key = args[0].val();
-			} else if(args[0].isInstanceOf(CArray.TYPE)) {
+			} else if(args[0].isInstanceOf(CArray.TYPE, null, env)) {
 				if(((CArray) args[0]).isAssociative()) {
 					throw new CREIllegalArgumentException("Associative arrays may not be used as keys in " + getName(), t);
 				}
@@ -2674,11 +2886,11 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			String key;
-			if(args[0].isInstanceOf(CString.TYPE)) {
+			if(args[0].isInstanceOf(CString.TYPE, null, env)) {
 				key = args[0].val();
-			} else if(args[0].isInstanceOf(CArray.TYPE)) {
+			} else if(args[0].isInstanceOf(CArray.TYPE, null, env)) {
 				if(((CArray) args[0]).isAssociative()) {
 					throw new CREIllegalArgumentException("Associative arrays may not be used as keys in " + getName(), t);
 				}
@@ -2717,7 +2929,117 @@ public ExampleScript[] examples() throws ConfigCompileException {
 	@api
 	@unbreakable
 	@seealso({com.laytonsmith.tools.docgen.templates.Closures.class})
-	public static class closure extends AbstractFunction implements BranchStatement, VariableScope {
+	public static class closure extends AbstractFunction implements FlowFunction<closure.ClosureState>, BranchStatement, VariableScope {
+
+		static class ClosureState {
+			ParseTree[] children;
+			Environment closureEnv;
+			CClassType returnType;
+			int nodeOffset;
+			int paramIndex;
+			int numParams;
+			String[] names;
+			Mixed[] defaults;
+			CClassType[] types;
+
+			ClosureState(ParseTree[] children, Environment closureEnv, CClassType returnType,
+					int nodeOffset, int numParams) {
+				this.children = children;
+				this.closureEnv = closureEnv;
+				this.returnType = returnType;
+				this.nodeOffset = nodeOffset;
+				this.numParams = numParams;
+				this.names = new String[numParams];
+				this.defaults = new Mixed[numParams];
+				this.types = new CClassType[numParams];
+			}
+
+			@Override
+			public String toString() {
+				return "param " + paramIndex + "/" + numParams;
+			}
+		}
+
+		@Override
+		public StepResult<ClosureState> begin(Target t, ParseTree[] children, Environment env) {
+			CClassType returnType = Auto.TYPE;
+			int nodeOffset = 0;
+			if(children.length > 0 && children[0].getData() instanceof CClassType) {
+				returnType = (CClassType) children[0].getData();
+				nodeOffset = 1;
+			}
+
+			if(children.length - nodeOffset == 0) {
+				return new StepResult<>(new Complete(
+						createClosureObject(null, env, returnType,
+						new String[0], new Mixed[0], new CClassType[0], t)), null);
+			}
+
+			Environment myEnv;
+			try {
+				myEnv = env.clone();
+			} catch(CloneNotSupportedException ex) {
+				throw new RuntimeException(ex);
+			}
+
+			int numParams = children.length - nodeOffset - 1;
+			ClosureState state = new ClosureState(children, myEnv, returnType, nodeOffset, numParams);
+
+			if(numParams == 0) {
+				return new StepResult<>(new Complete(
+						createClosureObject(children[children.length - 1], myEnv, returnType,
+						new String[0], new Mixed[0], new CClassType[0], t)), state);
+			}
+
+			myEnv.getEnv(GlobalEnv.class).SetFlag(GlobalEnv.FLAG_CLOSURE_WARN_OVERWRITE, true);
+			myEnv.getEnv(GlobalEnv.class).SetFlag(GlobalEnv.FLAG_VAR_ARGS_ALLOWED, true);
+			return new StepResult<>(new Evaluate(children[nodeOffset], myEnv, true), state);
+		}
+
+		@Override
+		public StepResult<ClosureState> childCompleted(Target t, ClosureState state,
+				Mixed result, Environment env) {
+			if(!(result instanceof IVariable iv)) {
+				throw new CRECastException("Arguments sent to " + getName()
+						+ " barring the last) must be ivariables", t);
+			}
+			state.names[state.paramIndex] = iv.getVariableName();
+			try {
+				state.defaults[state.paramIndex] = iv.ival().clone();
+				state.types[state.paramIndex] = iv.getDefinedType();
+			} catch(CloneNotSupportedException ex) {
+				Logger.getLogger(DataHandling.class.getName()).log(Level.SEVERE, null, ex);
+			}
+			state.paramIndex++;
+
+			if(state.paramIndex < state.numParams) {
+				return new StepResult<>(new Evaluate(
+						state.children[state.nodeOffset + state.paramIndex],
+						state.closureEnv, true), state);
+			}
+
+			state.closureEnv.getEnv(GlobalEnv.class).ClearFlag(GlobalEnv.FLAG_VAR_ARGS_ALLOWED);
+			state.closureEnv.getEnv(GlobalEnv.class).ClearFlag(GlobalEnv.FLAG_CLOSURE_WARN_OVERWRITE);
+			ParseTree body = state.children[state.children.length - 1];
+			return new StepResult<>(new Complete(
+					createClosureObject(body, state.closureEnv, state.returnType,
+					state.names, state.defaults, state.types, t)), state);
+		}
+
+		@Override
+		public StepResult<ClosureState> childInterrupted(Target t, ClosureState state,
+				StepAction.FlowControl action, Environment env) {
+			if(state != null && state.closureEnv != null) {
+				state.closureEnv.getEnv(GlobalEnv.class).ClearFlag(GlobalEnv.FLAG_VAR_ARGS_ALLOWED);
+				state.closureEnv.getEnv(GlobalEnv.class).ClearFlag(GlobalEnv.FLAG_CLOSURE_WARN_OVERWRITE);
+			}
+			return null;
+		}
+
+		protected Mixed createClosureObject(ParseTree body, Environment env, CClassType returnType,
+				String[] names, Mixed[] defaults, CClassType[] types, Target t) {
+			return new CClosure(body, env, returnType, names, defaults, types, t);
+		}
 
 		@Override
 		public String getName() {
@@ -2766,71 +3088,10 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			return CVoid.VOID;
 		}
 
-		@Override
-		public Mixed execs(Target t, Environment env, Script parent, ParseTree... nodes) {
-
-			// Use first child as closure return type if it is a type.
-			CClassType returnType = Auto.TYPE;
-			int nodeOffset = 0;
-			if(nodes.length > 0 && nodes[0].getData().isInstanceOf(CClassType.TYPE)) {
-				returnType = (CClassType) nodes[0].getData();
-				nodeOffset = 1;
-			}
-
-			// Return an empty (possibly statically typed) closure when it is empty and does not have any parameters.
-			if(nodes.length - nodeOffset == 0) {
-				return new CClosure(null, env, returnType, new String[0], new Mixed[0], new CClassType[0], t);
-			}
-
-			// Clone the environment to prevent parameter and variable assigns overwriting variables in the outer scope.
-			Environment myEnv;
-			try {
-				myEnv = env.clone();
-			} catch (CloneNotSupportedException ex) {
-				throw new RuntimeException(ex);
-			}
-
-			// Get closure parameter names, default values and types.
-			int numParams = nodes.length - nodeOffset - 1;
-			String[] names = new String[numParams];
-			Mixed[] defaults = new Mixed[numParams];
-			CClassType[] types = new CClassType[numParams];
-			for(int i = 0; i < numParams; i++) {
-				ParseTree node = nodes[i + nodeOffset];
-				ParseTree newNode = new ParseTree(new CFunction(g.NAME, t), node.getFileOptions());
-				List<ParseTree> children = new ArrayList<>();
-				children.add(node);
-				newNode.setChildren(children);
-				Script fakeScript = Script.GenerateScript(newNode, myEnv.getEnv(GlobalEnv.class).GetLabel(), null);
-				myEnv.getEnv(GlobalEnv.class).SetFlag(GlobalEnv.FLAG_CLOSURE_WARN_OVERWRITE, true);
-				myEnv.getEnv(GlobalEnv.class).SetFlag(GlobalEnv.FLAG_VAR_ARGS_ALLOWED, true);
-				Mixed ret;
-				try {
-					ret = MethodScriptCompiler.execute(newNode, myEnv, null, fakeScript);
-				} finally {
-					myEnv.getEnv(GlobalEnv.class).ClearFlag(GlobalEnv.FLAG_VAR_ARGS_ALLOWED);
-					myEnv.getEnv(GlobalEnv.class).ClearFlag(GlobalEnv.FLAG_CLOSURE_WARN_OVERWRITE);
-				}
-				if(!(ret instanceof IVariable)) {
-					throw new CRECastException("Arguments sent to " + getName() + " barring the last) must be ivariables", t);
-				}
-				names[i] = ((IVariable) ret).getVariableName();
-				try {
-					defaults[i] = ((IVariable) ret).ival().clone();
-					types[i] = ((IVariable) ret).getDefinedType();
-				} catch (CloneNotSupportedException ex) {
-					Logger.getLogger(DataHandling.class.getName()).log(Level.SEVERE, null, ex);
-				}
-			}
-
-			// Create and return the closure, using the last argument as the closure body.
-			return new CClosure(nodes[nodes.length - 1], myEnv, returnType, names, defaults, types, t);
-		}
-
 		@Override
 		public Scope linkScope(StaticAnalysis analysis, Scope parentScope, ParseTree ast,
 				Environment env, Set<ConfigCompileException> exceptions) {
@@ -2901,11 +3162,6 @@ public Version since() {
 			return MSVersion.V3_3_0;
 		}
 
-		@Override
-		public boolean useSpecialExec() {
-			return true;
-		}
-
 		@Override
 		public ExampleScript[] examples() throws ConfigCompileException {
 			return new ExampleScript[]{
@@ -2944,6 +3200,13 @@ public List<Boolean> isScope(List<ParseTree> children) {
 	@seealso({com.laytonsmith.tools.docgen.templates.Closures.class})
 	public static class iclosure extends closure {
 
+		@Override
+		protected Mixed createClosureObject(ParseTree body, Environment env, CClassType returnType,
+				String[] names, Mixed[] defaults, CClassType[] types, Target t) {
+			env.getEnv(GlobalEnv.class).SetVarList(null);
+			return new CIClosure(body, env, returnType, names, defaults, types, t);
+		}
+
 		@Override
 		public String getName() {
 			return "iclosure";
@@ -2967,66 +3230,6 @@ public String docs() {
 					+ " and examples.";
 		}
 
-		@Override
-		public Mixed execs(Target t, Environment env, Script parent, ParseTree... nodes) {
-			if(nodes.length == 0) {
-				//Empty closure, do nothing.
-				return new CIClosure(null, env, Auto.TYPE, new String[]{}, new Mixed[]{}, new CClassType[]{}, t);
-			}
-			// Handle the closure type first thing
-			CClassType returnType = Auto.TYPE;
-			if(nodes[0].getData().isInstanceOf(CClassType.TYPE)) {
-				returnType = (CClassType) nodes[0].getData();
-				ParseTree[] newNodes = new ParseTree[nodes.length - 1];
-				for(int i = 1; i < nodes.length; i++) {
-					newNodes[i - 1] = nodes[i];
-				}
-				nodes = newNodes;
-			}
-			String[] names = new String[nodes.length - 1];
-			Mixed[] defaults = new Mixed[nodes.length - 1];
-			CClassType[] types = new CClassType[nodes.length - 1];
-			// We clone the enviornment at this point, because we don't want the values
-			// that are assigned here to overwrite values in the main scope.
-			Environment myEnv;
-			try {
-				myEnv = env.clone();
-			} catch (CloneNotSupportedException ex) {
-				throw new RuntimeException(ex);
-			}
-			for(int i = 0; i < nodes.length - 1; i++) {
-				ParseTree node = nodes[i];
-				ParseTree newNode = new ParseTree(new CFunction(g.NAME, t), node.getFileOptions());
-				List<ParseTree> children = new ArrayList<>();
-				children.add(node);
-				newNode.setChildren(children);
-				Script fakeScript = Script.GenerateScript(newNode, myEnv.getEnv(GlobalEnv.class).GetLabel(), null);
-				myEnv.getEnv(GlobalEnv.class).SetFlag(GlobalEnv.FLAG_CLOSURE_WARN_OVERWRITE, true);
-				myEnv.getEnv(GlobalEnv.class).SetFlag(GlobalEnv.FLAG_VAR_ARGS_ALLOWED, true);
-				Mixed ret;
-				try {
-					ret = MethodScriptCompiler.execute(newNode, myEnv, null, fakeScript);
-				} finally {
-					myEnv.getEnv(GlobalEnv.class).ClearFlag(GlobalEnv.FLAG_VAR_ARGS_ALLOWED);
-					myEnv.getEnv(GlobalEnv.class).ClearFlag(GlobalEnv.FLAG_CLOSURE_WARN_OVERWRITE);
-				}
-				if(!(ret instanceof IVariable)) {
-					throw new CRECastException("Arguments sent to " + getName() + " barring the last) must be ivariables", t);
-				}
-				names[i] = ((IVariable) ret).getVariableName();
-				try {
-					defaults[i] = ((IVariable) ret).ival().clone();
-					types[i] = ((IVariable) ret).getDefinedType();
-				} catch (CloneNotSupportedException ex) {
-					Logger.getLogger(DataHandling.class.getName()).log(Level.SEVERE, null, ex);
-				}
-			}
-			// Now that iclosure is done with the current variable list, it can be removed from the cloned environment.
-			// This ensures it's not unintentionally retaining values in memory cloned from the original scope.
-			myEnv.getEnv(GlobalEnv.class).SetVarList(null);
-			return new CIClosure(nodes[nodes.length - 1], myEnv, returnType, names, defaults, types, t);
-		}
-
 		@Override
 		public Scope linkScope(StaticAnalysis analysis, Scope parentScope, ParseTree ast,
 				Environment env, Set<ConfigCompileException> exceptions) {
@@ -3091,7 +3294,7 @@ public MSVersion since() {
 
 	@api
 	@seealso({com.laytonsmith.tools.docgen.templates.Closures.class, execute_array.class, executeas.class})
-	public static class execute extends AbstractFunction {
+	public static class execute extends CallbackYield {
 
 		public static final String NAME = "execute";
 
@@ -3133,11 +3336,12 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
+		protected void execWithYield(Target t, Environment env, Mixed[] args, CallbackYield.Yield yield) {
 			if(args[args.length - 1] instanceof Callable callable) {
 				Mixed[] vals = new Mixed[args.length - 1];
 				System.arraycopy(args, 0, vals, 0, args.length - 1);
-				return callable.executeCallable(environment, t, vals);
+				yield.call(callable, env, t, vals)
+						.then((result, y) -> y.done(() -> result));
 			} else {
 				throw new CRECastException("Only a Callable (created for instance from the closure function) can be"
 						+ " sent to execute(), or executed directly, such as @c().", t);
@@ -3162,7 +3366,7 @@ public FunctionSignatures getSignatures() {
 
 	@api
 	@seealso({com.laytonsmith.tools.docgen.templates.Closures.class, execute.class})
-	public static class execute_array extends AbstractFunction {
+	public static class execute_array extends CallbackYield {
 		@Override
 		public String getName() {
 			return "execute_array";
@@ -3198,10 +3402,11 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
+		protected void execWithYield(Target t, Environment env, Mixed[] args, CallbackYield.Yield yield) {
 			Mixed[] vals = ArgumentValidation.getArray(args[0], t).asList().toArray(new Mixed[0]);
 			CClosure closure = ArgumentValidation.getObject(args[1], t, CClosure.class);
-			return closure.executeCallable(vals);
+			yield.call(closure, env, t, vals)
+					.then((result, y) -> y.done(() -> result));
 		}
 
 		@Override
@@ -3212,7 +3417,7 @@ public MSVersion since() {
 
 	@api
 	@seealso({com.laytonsmith.tools.docgen.templates.Closures.class})
-	public static class executeas extends AbstractFunction implements Optimizable {
+	public static class executeas extends CallbackYield implements Optimizable {
 
 		@Override
 		public String getName() {
@@ -3250,8 +3455,8 @@ public boolean isRestricted() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
-			if(!(args[args.length - 1].isInstanceOf(CClosure.TYPE))) {
+		protected void execWithYield(Target t, Environment env, Mixed[] args, CallbackYield.Yield yield) {
+			if(!(args[args.length - 1].isInstanceOf(CClosure.TYPE, null, env))) {
 				throw new CRECastException("Only a closure (created from the closure function) can be sent to executeas()", t);
 			}
 			Mixed[] vals = new Mixed[args.length - 3];
@@ -3263,7 +3468,7 @@ public Mixed exec(Target t, Environment environment, Mixed... args) throws Confi
 			MCCommandSender originalSender = cEnv.GetCommandSender();
 			MCCommandSender sender;
 			if(args[0] instanceof CNull) {
-				sender = environment.getEnv(CommandHelperEnvironment.class).GetCommandSender();
+				sender = env.getEnv(CommandHelperEnvironment.class).GetCommandSender();
 			} else {
 				sender = Static.GetCommandSender(args[0].val(), t);
 			}
@@ -3274,12 +3479,12 @@ public Mixed exec(Target t, Environment environment, Mixed... args) throws Confi
 				gEnv.SetLabel(args[1].val());
 			}
 
-			try {
-				return closure.executeCallable(vals);
-			} finally {
-				cEnv.SetCommandSender(originalSender);
-				gEnv.SetLabel(originalLabel);
-			}
+			yield.call(closure, env, t, vals)
+					.then((result, y) -> y.done(() -> result))
+					.cleanup(() -> {
+						cEnv.SetCommandSender(originalSender);
+						gEnv.SetLabel(originalLabel);
+					});
 		}
 
 		@Override
@@ -3339,7 +3544,7 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			return CBoolean.get(ArgumentValidation.getBoolean(args[0], t));
 		}
 
@@ -3408,7 +3613,7 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			Mixed arg = args[0];
 			if(arg instanceof CMutablePrimitive) {
 				arg = ((CMutablePrimitive) arg).get();
@@ -3501,7 +3706,7 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			return new CDouble(ArgumentValidation.getDouble(args[0], t), t);
 		}
 
@@ -3566,8 +3771,8 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
-			if(args[0].isInstanceOf(CString.TYPE)) {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
+			if(args[0].isInstanceOf(CString.TYPE, null, env)) {
 				return args[0];
 			}
 			return new CString(args[0].val(), t);
@@ -3618,7 +3823,7 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			int radix = ArgumentValidation.getInt32(args[1], t);
 			if(radix < Character.MIN_RADIX || radix > Character.MAX_RADIX) {
 				throw new CRERangeException("The radix must be between " + Character.MIN_RADIX + " and " + Character.MAX_RADIX + ", inclusive.", t);
@@ -3690,7 +3895,7 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			String value = args[0].val();
 			int radix = ArgumentValidation.getInt32(args[1], t);
 			if(radix < Character.MIN_RADIX || radix > Character.MAX_RADIX) {
@@ -3775,9 +3980,9 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			try {
-				return args[0].typeof();
+				return args[0].typeof(env);
 			} catch (IllegalArgumentException ex) {
 				throw new Error("Class " + args[0].getClass().getName() + " is not annotated with @typeof. Please report this"
 						+ " error to the developers.");
@@ -3822,7 +4027,8 @@ public Set<OptimizationOption> optimizationOptions() {
 	}
 
 	@api
-	public static class eval extends AbstractFunction implements Optimizable {
+	public static class eval extends AbstractFunction implements Optimizable,
+			FlowFunction<eval.EvalState> {
 
 		@Override
 		public String getName() {
@@ -3857,74 +4063,121 @@ public MSVersion since() {
 		}
 
 		@Override
-		public Mixed execs(Target t, Environment env, Script parent, ParseTree... nodes) {
-			if(ArgumentValidation.getBooleanish(env.getEnv(GlobalEnv.class).GetRuntimeSetting("function.eval.disable",
-					CBoolean.FALSE), t)) {
-				throw new CREInsufficientPermissionException("eval is disabled", t);
-			}
-			boolean oldDynamicScriptMode = env.getEnv(GlobalEnv.class).GetDynamicScriptingMode();
-			ParseTree node = nodes[0];
-			try {
-				env.getEnv(GlobalEnv.class).SetDynamicScriptingMode(true);
-				Mixed script = parent.seval(node, env);
-				if(script.isInstanceOf(CClosure.TYPE)) {
-					throw new CRECastException("Closures cannot be eval'd directly. Use execute() instead.", t);
-				}
-				ParseTree root = MethodScriptCompiler.compile(MethodScriptCompiler.lex(script.val(), env, t.file(), true),
-						env, env.getEnvClasses());
-				if(root == null) {
-					return new CString("", t);
-				}
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws CancelCommandException, ConfigRuntimeException {
+			return CVoid.VOID;
+		}
+		//Doesn't matter, run out of state anyways
 
-				// Unwrap single value in __statements__() and return its string value.
-				if(root.getChildren().size() == 1 && root.getChildAt(0).getData() instanceof CFunction
-						&& ((CFunction) root.getChildAt(0).getData()).getFunction().getName().equals(__statements__.NAME)
-						&& root.getChildAt(0).getChildren().size() == 1) {
-					return new CString(parent.seval(root.getChildAt(0).getChildAt(0), env).val(), t);
-				}
+		@Override
+		public Boolean runAsync() {
+			return null;
+		}
 
-				// Concat string values of all children and return the result.
-				StringBuilder b = new StringBuilder();
-				int count = 0;
-				for(ParseTree child : root.getChildren()) {
-					Mixed s = parent.seval(child, env);
-					if(!s.val().trim().isEmpty()) {
-						if(count > 0) {
-							b.append(" ");
-						}
-						b.append(s.val());
-					}
-					count++;
-				}
-				return new CString(b.toString(), t);
-			} catch (ConfigCompileException e) {
-				throw new CREFormatException("Could not compile eval'd code: " + e.getMessage(), t);
-			} catch (ConfigCompileGroupException ex) {
-				StringBuilder b = new StringBuilder();
-				b.append("Could not compile eval'd code: ");
-				for(ConfigCompileException e : ex.getList()) {
-					b.append(e.getMessage()).append("\n");
-				}
-				throw new CREFormatException(b.toString(), t);
-			} finally {
-				env.getEnv(GlobalEnv.class).SetDynamicScriptingMode(oldDynamicScriptMode);
+		static class EvalState {
+			enum Phase { EVAL_ARG, EVAL_CHILDREN }
+			Phase phase = Phase.EVAL_ARG;
+			boolean oldDynamicScriptMode;
+			List<ParseTree> compiledChildren;
+			int childIndex;
+			StringBuilder result = new StringBuilder();
+			int count;
+
+			@Override
+			public String toString() {
+				return phase == Phase.EVAL_ARG ? "EVAL_ARG"
+						: "EVAL_CHILDREN[" + childIndex + "/" + compiledChildren.size() + "]";
 			}
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment env, Mixed... args) throws CancelCommandException, ConfigRuntimeException {
-			return CVoid.VOID;
+		public StepResult<EvalState> begin(Target t, ParseTree[] children, Environment env) {
+			if(ArgumentValidation.getBooleanish(env.getEnv(GlobalEnv.class).GetRuntimeSetting(
+					"function.eval.disable", CBoolean.FALSE), t)) {
+				throw new CREInsufficientPermissionException("eval is disabled", t);
+			}
+			EvalState state = new EvalState();
+			state.oldDynamicScriptMode = env.getEnv(GlobalEnv.class).GetDynamicScriptingMode();
+			env.getEnv(GlobalEnv.class).SetDynamicScriptingMode(true);
+			return new StepResult<>(new Evaluate(children[0]), state);
 		}
-		//Doesn't matter, run out of state anyways
 
 		@Override
-		public Boolean runAsync() {
-			return null;
+		public StepResult<EvalState> childCompleted(Target t, EvalState state,
+				Mixed result, Environment env) {
+			switch(state.phase) {
+				case EVAL_ARG -> {
+					if(result.isInstanceOf(CClosure.TYPE, null, env)) {
+						throw new CRECastException(
+								"Closures cannot be eval'd directly. Use execute() instead.", t);
+					}
+					ParseTree root;
+					try {
+						root = MethodScriptCompiler.compile(
+								MethodScriptCompiler.lex(result.val(), env, t.file(), true),
+								env, env.getEnvClasses());
+					} catch(ConfigCompileException e) {
+						throw new CREFormatException(
+								"Could not compile eval'd code: " + e.getMessage(), t);
+					} catch(ConfigCompileGroupException ex) {
+						StringBuilder b = new StringBuilder();
+						b.append("Could not compile eval'd code: ");
+						for(ConfigCompileException e : ex.getList()) {
+							b.append(e.getMessage()).append("\n");
+						}
+						throw new CREFormatException(b.toString(), t);
+					}
+					if(root == null) {
+						return new StepResult<>(new Complete(new CString("", t)), state);
+					}
+					// Unwrap single value in __statements__() with single child
+					try {
+						if(root.getChildren().size() == 1 && root.getChildAt(0).getData() instanceof CFunction
+								&& ((CFunction) root.getChildAt(0).getData()).getFunction().getName()
+										.equals(__statements__.NAME)
+								&& root.getChildAt(0).getChildren().size() == 1) {
+							state.compiledChildren = List.of(root.getChildAt(0).getChildAt(0));
+						} else {
+							state.compiledChildren = root.getChildren();
+						}
+					} catch(ConfigCompileException e) {
+						throw new CREFormatException(
+								"Could not compile eval'd code: " + e.getMessage(), t);
+					}
+					state.phase = EvalState.Phase.EVAL_CHILDREN;
+					state.childIndex = 0;
+					if(state.compiledChildren.isEmpty()) {
+						return new StepResult<>(new Complete(new CString("", t)), state);
+					}
+					return new StepResult<>(
+							new Evaluate(state.compiledChildren.get(state.childIndex)), state);
+				}
+				case EVAL_CHILDREN -> {
+					if(!result.val().trim().isEmpty()) {
+						if(state.count > 0) {
+							state.result.append(" ");
+						}
+						state.result.append(result.val());
+					}
+					state.count++;
+					state.childIndex++;
+					if(state.childIndex < state.compiledChildren.size()) {
+						return new StepResult<>(
+								new Evaluate(state.compiledChildren.get(state.childIndex)), state);
+					}
+					return new StepResult<>(
+							new Complete(new CString(state.result.toString(), t)), state);
+				}
+			}
+			throw ConfigRuntimeException.CreateUncatchableException(
+					"Invalid eval state: " + state.phase, t);
 		}
 
 		@Override
-		public boolean useSpecialExec() {
-			return true;
+		public void cleanup(Target t, EvalState state, Environment env) {
+			if(state != null) {
+				env.getEnv(GlobalEnv.class).SetDynamicScriptingMode(
+						state.oldDynamicScriptMode);
+			}
 		}
 
 		@Override
@@ -3968,7 +4221,7 @@ public Integer[] numArgs() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment env, Mixed... args) throws CancelCommandException, ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws CancelCommandException, ConfigRuntimeException {
 			return CVoid.VOID;
 		}
 
@@ -4029,7 +4282,7 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			Mixed val = CNull.NULL;
 			if(args.length > 0) {
 				val = args[0];
@@ -4131,18 +4384,18 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			if(args[0] instanceof CNull) {
 				return CBoolean.FALSE;
 			}
 			CClassType type;
-			if(args[1].isInstanceOf(CClassType.TYPE)) {
+			if(args[1] instanceof CClassType) {
 				type = (CClassType) args[1];
 			} else {
 				throw new RuntimeException("This should have been optimized out, this is a bug in instanceof,"
 						+ " please report it");
 			}
-			boolean b = InstanceofUtil.isInstanceof(args[0], type, environment);
+			boolean b = InstanceofUtil.isInstanceof(args[0], type, env);
 			return CBoolean.get(b);
 		}
 
@@ -4176,7 +4429,7 @@ public ParseTree optimizeDynamic(Target t, Environment env,
 				FileOptions fileOptions) throws ConfigCompileException, ConfigRuntimeException {
 			// There are two specific cases here where we will give more precise error messages.
 			// If it's a string, yell at them (Note CKeyword extends CString, for better or worse)
-			if(children.get(1).getData().isInstanceOf(CString.TYPE)) {
+			if(children.get(1).getData().isInstanceOf(CString.TYPE, null, env)) {
 				throw new ConfigCompileException("Unexpected string type passed to \"instanceof\"", t);
 			}
 			// If it's a variable, also yell at them
@@ -4184,7 +4437,7 @@ public ParseTree optimizeDynamic(Target t, Environment env,
 				throw new ConfigCompileException("Variable types are not allowed in \"instanceof\"", t);
 			}
 			// Unknown error, but this is still never valid.
-			if(!(children.get(1).getData().isInstanceOf(CClassType.TYPE))) {
+			if(!(children.get(1).getData() instanceof CClassType)) {
 				throw new ConfigCompileException("Unexpected type for \"instanceof\": " + children.get(1).getData(), t);
 			}
 			// null is technically a type, but instanceof shouldn't work with that
@@ -4193,7 +4446,7 @@ public ParseTree optimizeDynamic(Target t, Environment env,
 			}
 			// It's hardcoded, allow it, but optimize it out.
 			if(children.get(0).isConst()) {
-				return new ParseTree(exec(t, null, children.get(0).getData(), children.get(1).getData()), fileOptions);
+				return new ParseTree(exec(t, null, null, children.get(0).getData(), children.get(1).getData()), fileOptions);
 			}
 			return null;
 		}
@@ -4238,7 +4491,7 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment env, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			IVariableList list = env.getEnv(GlobalEnv.class).GetVarList();
 			Mixed value = list.get(((IVariable) args[0]).getVariableName(), t, env).ival();
 			list.freeValue(value);
@@ -4304,7 +4557,7 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			CClassType type = ArgumentValidation.getClassType(args[0], t);
 			int size = ArgumentValidation.getInt32(args[1], t);
 			if(size < 0) {
diff --git a/src/main/java/com/laytonsmith/core/functions/DataTransformations.java b/src/main/java/com/laytonsmith/core/functions/DataTransformations.java
index e56c9db147..405df3498f 100644
--- a/src/main/java/com/laytonsmith/core/functions/DataTransformations.java
+++ b/src/main/java/com/laytonsmith/core/functions/DataTransformations.java
@@ -14,6 +14,7 @@
 import com.laytonsmith.core.constructs.CString;
 import com.laytonsmith.core.constructs.Construct;
 import com.laytonsmith.core.constructs.Target;
+import com.laytonsmith.core.constructs.generics.GenericParameters;
 import com.laytonsmith.core.environments.Environment;
 import com.laytonsmith.core.environments.GlobalEnv;
 import com.laytonsmith.core.exceptions.CRE.CRECastException;
@@ -72,10 +73,10 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
-			CArray ca = ArgumentValidation.getArray(args[0], t);
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
+			CArray ca = ArgumentValidation.getArray(args[0], t, env);
 			try {
-				return new CString(Construct.json_encode(ca, t), t);
+				return new CString(Construct.json_encode(ca, t, env), t);
 			} catch (MarshalException ex) {
 				throw new CRECastException(ex.getMessage(), t);
 			}
@@ -129,7 +130,7 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			String s = args[0].val();
 			try {
 				return Construct.json_decode(s, t);
@@ -187,11 +188,11 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
-			CArray ca = ArgumentValidation.getArray(args[0], t);
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
+			CArray ca = ArgumentValidation.getArray(args[0], t, env);
 			boolean prettyPrint = false;
 			if(args.length == 2) {
-				prettyPrint = ArgumentValidation.getBoolean(args[1], t);
+				prettyPrint = ArgumentValidation.getBooleanObject(args[1], t, env);
 			}
 			DumperOptions options = new DumperOptions();
 			if(prettyPrint) {
@@ -200,7 +201,7 @@ public Mixed exec(Target t, Environment environment, Mixed... args) throws Confi
 			}
 			Yaml yaml = new Yaml(options);
 			try {
-				return new CString(yaml.dump(Construct.GetPOJO(ca)), t);
+				return new CString(yaml.dump(Static.getJavaObject(ca, env)), t);
 			} catch (ClassCastException ex) {
 				throw new CRECastException(ex.getMessage(), t);
 			}
@@ -248,14 +249,14 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment env, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			String data = args[0].val();
 			LoaderOptions options = new LoaderOptions();
 			Mixed codePointLimit = env.getEnv(GlobalEnv.class)
 					.GetRuntimeSettingOrCNull("function.yml_decode.code_point_limit", CNull.NULL);
 			if(!CNull.NULL.equals(codePointLimit)) {
 				try {
-					options.setCodePointLimit(ArgumentValidation.getInt32(codePointLimit, t));
+					options.setCodePointLimit(ArgumentValidation.getInt32(codePointLimit, t, env));
 				} catch (CRERangeException | CRECastException e) {
 					// Ignore invalid value.
 				}
@@ -322,9 +323,9 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			Properties props = new Properties();
-			CArray arr = ArgumentValidation.getArray(args[0], t);
+			CArray arr = ArgumentValidation.getArray(args[0], t, env);
 			String comment = null;
 			if(args.length == 2) {
 				comment = args[1].val();
@@ -333,11 +334,11 @@ public Mixed exec(Target t, Environment environment, Mixed... args) throws Confi
 				throw new CRECastException("Expecting an associative array", t);
 			}
 			for(String key : arr.stringKeySet()) {
-				Mixed c = arr.get(key, t);
+				Mixed c = arr.get(key, t, env);
 				String val;
 				if(c instanceof CNull) {
 					val = "";
-				} else if(c.isInstanceOf(CArray.TYPE)) {
+				} else if(c.isInstanceOf(CArray.TYPE, null, env)) {
 					throw new CRECastException("Arrays cannot be encoded with ini_encode.", t);
 				} else {
 					val = c.val();
@@ -387,7 +388,7 @@ public static class ini_decode extends AbstractFunction {
 
 		@Override
 		public Class<? extends CREThrowable>[] thrown() {
-			return new Class[]{CREFormatException.class};
+			return new Class[]{CREFormatException.class, CRECastException.class};
 		}
 
 		@Override
@@ -401,7 +402,7 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			Properties props = new Properties();
 			Reader reader = new StringReader(args[0].val());
 			try {
@@ -409,9 +410,9 @@ public Mixed exec(Target t, Environment environment, Mixed... args) throws Confi
 			} catch (IOException ex) {
 				throw new CREFormatException(ex.getMessage(), t);
 			}
-			CArray arr = CArray.GetAssociativeArray(t);
+			CArray arr = CArray.GetAssociativeArray(t, null, env);
 			for(String key : props.stringPropertyNames()) {
-				arr.set(key, props.getProperty(key));
+				arr.set(key, props.getProperty(key), env);
 			}
 			return arr;
 		}
@@ -468,7 +469,7 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			XMLDocument doc;
 			try {
 				doc = new XMLDocument(args[0].val());
@@ -524,7 +525,7 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			throw new UnsupportedOperationException("Not supported yet.");
 		}
 
diff --git a/src/main/java/com/laytonsmith/core/functions/Debug.java b/src/main/java/com/laytonsmith/core/functions/Debug.java
index 3e8a878b2e..e03c8fbe2e 100644
--- a/src/main/java/com/laytonsmith/core/functions/Debug.java
+++ b/src/main/java/com/laytonsmith/core/functions/Debug.java
@@ -22,6 +22,7 @@
 import com.laytonsmith.core.constructs.CVoid;
 import com.laytonsmith.core.constructs.IVariable;
 import com.laytonsmith.core.constructs.Target;
+import com.laytonsmith.core.constructs.generics.GenericParameters;
 import com.laytonsmith.core.environments.Environment;
 import com.laytonsmith.core.environments.GlobalEnv;
 import com.laytonsmith.core.exceptions.CRE.CRECastException;
@@ -109,7 +110,7 @@ public static String docs() {
 //			return false;
 //		}
 //
-//		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
+//		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 //			if(!(Boolean) Static.getPreferences().getPreference("allow-debug-logging")) {
 //				throw new ConfigRuntimeException("allow-debug-logging is currently set to false. To use " + this.getVariableName() + ", enable it in your preferences.", CRESecurityException.class, t);
 //			}
@@ -242,7 +243,7 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			if(Prefs.DebugMode()) {
 				try {
 					Static.LogDebug(MethodScriptFileLocations.getDefault().getConfigDirectory(), args[0].val(), LogLevel.DEBUG);
@@ -259,11 +260,11 @@ public Mixed exec(Target t, Environment environment, Mixed... args) throws Confi
 	public static class trace extends always_trace {
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			//TODO: Once Prefs are no longer static, check to see if debug mode is on during compilation, and
 			//if so, remove this function entirely
 			if(Prefs.DebugMode()) {
-				return always_trace.doTrace(t, environment, args);
+				return always_trace.doTrace(t, env, args);
 			}
 			return CVoid.VOID;
 		}
@@ -306,8 +307,8 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
-			return doTrace(t, environment, args);
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
+			return doTrace(t, env, args);
 		}
 
 		@Override
@@ -352,13 +353,13 @@ public ExampleScript[] examples() throws ConfigCompileException {
 			};
 		}
 
-		public static CVoid doTrace(Target t, Environment environment, Mixed... args) {
+		public static CVoid doTrace(Target t, Environment env, Mixed... args) {
 			if(args[0] instanceof IVariable) {
-				IVariable ivar = environment.getEnv(GlobalEnv.class).GetVarList()
-						.get(((IVariable) args[0]).getVariableName(), t, environment);
+				IVariable ivar = env.getEnv(GlobalEnv.class).GetVarList()
+						.get(((IVariable) args[0]).getVariableName(), t, env);
 				Mixed val = ivar.ival();
 				StreamUtils.GetSystemOut().println(
-						TermColors.GREEN + environment.getEnv(GlobalEnv.class).GetStackTraceManager()
+						TermColors.GREEN + env.getEnv(GlobalEnv.class).GetStackTraceManager()
 								.getCurrentStackTrace().get(0).getProcedureName()
 						+ TermColors.RESET + ":"
 						+ TermColors.YELLOW + t.file().getName()
@@ -367,14 +368,14 @@ public static CVoid doTrace(Target t, Environment environment, Mixed... args) {
 						+ TermColors.RESET + ": "
 						+ TermColors.BRIGHT_WHITE + ivar.getDefinedType()
 						+ TermColors.RESET + " (actual type "
-						+ TermColors.BRIGHT_WHITE + val.typeof()
-						+ (val.isInstanceOf(Sizeable.TYPE) ? ", length: " + ((Sizeable) val).size() : "")
+						+ TermColors.BRIGHT_WHITE + val.typeof(env)
+						+ (val.isInstanceOf(Sizeable.TYPE, null, env) ? ", length: " + ((Sizeable) val).size() : "")
 						+ TermColors.RESET + ") "
 						+ TermColors.CYAN + ivar.getVariableName()
 						+ TermColors.RESET + ": " + val.val());
 				return CVoid.VOID;
 			} else {
-				throw new CRECastException("Expecting an ivar, but received " + args[0].typeof().getSimpleName()
+				throw new CRECastException("Expecting an ivar, but received " + args[0].typeof(env).getSimpleName()
 						+ " instead", t);
 			}
 		}
@@ -441,7 +442,7 @@ public ParseTree optimizeDynamic(Target t, Environment env,
 //			return false;
 //		}
 //
-//		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
+//		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 //			if(!(Boolean) Static.getPreferences().getPreference("allow-debug-logging")) {
 //				throw new ConfigRuntimeException("allow-debug-logging is currently set to false. To use " + this.getVariableName() + ", enable it in your preferences.", CRESecurityException.class, t);
 //			}
@@ -494,7 +495,7 @@ public ParseTree optimizeDynamic(Target t, Environment env,
 //			return true;
 //		}
 //
-//		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
+//		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 //			if(!(Boolean) Static.getPreferences().getPreference("allow-debug-logging")) {
 //				throw new ConfigRuntimeException("allow-debug-logging is currently set to false. To use " + this.getVariableName() + ", enable it in your preferences.", CRESecurityException.class, t);
 //			}
@@ -570,7 +571,7 @@ public ParseTree optimizeDynamic(Target t, Environment env,
 //			return false;
 //		}
 //
-//		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
+//		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 //			if(!(Boolean) Static.getPreferences().getPreference("allow-debug-logging")) {
 //				throw new ConfigRuntimeException("allow-debug-logging is currently set to false. To use " + this.getVariableName() + ", enable it in your preferences.", CRESecurityException.class, t);
 //			}
@@ -606,7 +607,7 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			Set<Thread> threadSet = Thread.getAllStackTraces().keySet();
 			CArray carray = new CArray(t);
 			for(Thread thread : threadSet) {
@@ -658,7 +659,7 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			File file = new File("dump.hprof");
 			try {
 				HeapDumper.dumpHeap(file.getAbsolutePath(), true);
@@ -713,7 +714,7 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			Script.debugOutput = ArgumentValidation.getBoolean(args[0], t);
 			if(Script.debugOutput) {
 				StreamUtils.GetSystemOut().println(TermColors.BG_RED + "[[DEBUG]] set_debug_output(true)"
diff --git a/src/main/java/com/laytonsmith/core/functions/Easings.java b/src/main/java/com/laytonsmith/core/functions/Easings.java
index 8e8f559765..235aa4f560 100644
--- a/src/main/java/com/laytonsmith/core/functions/Easings.java
+++ b/src/main/java/com/laytonsmith/core/functions/Easings.java
@@ -13,6 +13,7 @@
 import com.laytonsmith.core.constructs.CClassType;
 import com.laytonsmith.core.constructs.CDouble;
 import com.laytonsmith.core.constructs.Target;
+import com.laytonsmith.core.constructs.generics.GenericParameters;
 import com.laytonsmith.core.environments.Environment;
 import com.laytonsmith.core.exceptions.CRE.CRECastException;
 import com.laytonsmith.core.exceptions.CRE.CREThrowable;
@@ -52,10 +53,10 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment env, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			com.laytonsmith.core.Easings.EasingType type
 					= ArgumentValidation.getEnum(args[0], com.laytonsmith.core.Easings.EasingType.class, t);
-			double x = ArgumentValidation.getDouble(args[1], t);
+			double x = ArgumentValidation.getDouble(args[1], t, env);
 			double ret = com.laytonsmith.core.Easings.GetEasing(type, x);
 			return new CDouble(ret, Target.UNKNOWN);
 		}
@@ -136,20 +137,20 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment env, Mixed... args) throws ConfigRuntimeException {
-			CArray start = ArgumentValidation.getArray(args[0], t);
-			double startX = ArgumentValidation.getDouble(start.get("x", t), t);
-			double startY = ArgumentValidation.getDouble(start.get("y", t), t);
-			double startZ = ArgumentValidation.getDouble(start.get("z", t), t);
-			CArray finish = ArgumentValidation.getArray(args[1], t);
-			double finishX = ArgumentValidation.getDouble(finish.get("x", t), t);
-			double finishY = ArgumentValidation.getDouble(finish.get("y", t), t);
-			double finishZ = ArgumentValidation.getDouble(finish.get("z", t), t);
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
+			CArray start = ArgumentValidation.getArray(args[0], t, env);
+			double startX = ArgumentValidation.getDouble(start.get("x", t, env), t, env);
+			double startY = ArgumentValidation.getDouble(start.get("y", t, env), t, env);
+			double startZ = ArgumentValidation.getDouble(start.get("z", t, env), t, env);
+			CArray finish = ArgumentValidation.getArray(args[1], t, env);
+			double finishX = ArgumentValidation.getDouble(finish.get("x", t, env), t, env);
+			double finishY = ArgumentValidation.getDouble(finish.get("y", t, env), t, env);
+			double finishZ = ArgumentValidation.getDouble(finish.get("z", t, env), t, env);
 			com.laytonsmith.core.Easings.EasingType type
 					= ArgumentValidation.getEnum(args[2], com.laytonsmith.core.Easings.EasingType.class, t);
-			double x = ArgumentValidation.getDouble(args[3], t);
+			double x = ArgumentValidation.getDouble(args[3], t, env);
 			double percentage = com.laytonsmith.core.Easings.GetEasing(type, x);
-			CArray result = CArray.GetAssociativeArray(Target.UNKNOWN);
+			CArray result = CArray.GetAssociativeArray(Target.UNKNOWN, null, env);
 			result.set("x", startX + (finishX - startX) * percentage);
 			result.set("y", startY + (finishY - startY) * percentage);
 			result.set("z", startZ + (finishZ - startZ) * percentage);
diff --git a/src/main/java/com/laytonsmith/core/functions/Echoes.java b/src/main/java/com/laytonsmith/core/functions/Echoes.java
index 0bc72f0fbb..9d5956e820 100644
--- a/src/main/java/com/laytonsmith/core/functions/Echoes.java
+++ b/src/main/java/com/laytonsmith/core/functions/Echoes.java
@@ -25,6 +25,7 @@
 import com.laytonsmith.core.constructs.CVoid;
 import com.laytonsmith.core.constructs.Construct;
 import com.laytonsmith.core.constructs.Target;
+import com.laytonsmith.core.constructs.generics.GenericParameters;
 import com.laytonsmith.core.environments.CommandHelperEnvironment;
 import com.laytonsmith.core.environments.Environment;
 import com.laytonsmith.core.environments.GlobalEnv;
@@ -69,7 +70,7 @@ public Integer[] numArgs() {
 		}
 
 		@Override
-		public Mixed exec(final Target t, Environment env, final Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(final Target t, Environment env, GenericParameters generics, final Mixed... args) throws ConfigRuntimeException {
 			StringBuilder b = new StringBuilder();
 			for(Mixed arg : args) {
 				b.append(arg.val());
@@ -135,7 +136,7 @@ public Integer[] numArgs() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment env, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			if(args.length < 2) {
 				throw new CREInsufficientArgumentsException("You must send at least 2 arguments to tmsg", t);
 			}
@@ -143,7 +144,7 @@ public Mixed exec(Target t, Environment env, Mixed... args) throws ConfigRuntime
 			if(Static.getConsoleName().equals(args[0].val())) {
 				p = Static.getServer().getConsole();
 			} else {
-				p = Static.GetPlayer(args[0], t);
+				p = Static.GetPlayer(args[0], t, env);
 			}
 			StringBuilder b = new StringBuilder();
 			for(int i = 1; i < args.length; i++) {
@@ -201,7 +202,7 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			String selector = "@a";
 			String json;
 			try {
@@ -310,7 +311,7 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			MCPlayer player;
 			int fadein = 10;
 			int stay = 70;
@@ -318,17 +319,17 @@ public Mixed exec(Target t, Environment environment, Mixed... args) throws Confi
 			int offset = 0;
 
 			if(args.length == 3 || args.length == 6) {
-				player = Static.GetPlayer(args[0].val(), t);
+				player = Static.GetPlayer(args[0].val(), t, env);
 				offset = 1;
 			} else {
-				player = environment.getEnv(CommandHelperEnvironment.class).GetPlayer();
+				player = env.getEnv(CommandHelperEnvironment.class).GetPlayer();
 				Static.AssertPlayerNonNull(player, t);
 			}
 
 			if(args.length > 3) {
-				fadein = ArgumentValidation.getInt32(args[2 + offset], t);
-				stay = ArgumentValidation.getInt32(args[3 + offset], t);
-				fadeout = ArgumentValidation.getInt32(args[4 + offset], t);
+				fadein = ArgumentValidation.getInt32(args[2 + offset], t, env);
+				stay = ArgumentValidation.getInt32(args[3 + offset], t, env);
+				fadeout = ArgumentValidation.getInt32(args[4 + offset], t, env);
 			}
 
 			player.sendTitle(Construct.nval(args[offset]), Construct.nval(args[1 + offset]), fadein, stay, fadeout);
@@ -351,14 +352,14 @@ public String docs() {
 			return "void {[player], message} Sends a message to the action bar above the hot bar.";
 		}
 
-		public Construct exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
+		public Construct exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			MCPlayer player;
 			String message;
 			if(args.length == 2) {
-				player = Static.GetPlayer(args[0], t);
+				player = Static.GetPlayer(args[0], t, env);
 				message = args[1].val();
 			} else {
-				player = environment.getEnv(CommandHelperEnvironment.class).GetPlayer();
+				player = env.getEnv(CommandHelperEnvironment.class).GetPlayer();
 				Static.AssertPlayerNonNull(player, t);
 				message = args[0].val();
 			}
@@ -400,7 +401,7 @@ public Integer[] numArgs() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment env, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			String val = Construct.nval(args[0]);
 			if(val == null) {
 				return new CString(MCChatColor.WHITE.toString(), t);
@@ -552,7 +553,7 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			return new CString(MCChatColor.stripColor(args[0].val()), t);
 		}
 
@@ -572,7 +573,7 @@ public Integer[] numArgs() {
 		}
 
 		@Override
-		public Mixed exec(final Target t, final Environment env, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(final Target t, final Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			MCPlayer p = env.getEnv(CommandHelperEnvironment.class).GetPlayer();
 			if(p != null) {
 				p.chat(args[0].val());
@@ -646,8 +647,8 @@ public MSVersion since() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment env, Mixed... args) throws ConfigRuntimeException {
-			final MCPlayer player = Static.GetPlayer(args[0], t);
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
+			final MCPlayer player = Static.GetPlayer(args[0], t, env);
 			player.chat(args[1].val());
 			return CVoid.VOID;
 		}
@@ -700,7 +701,7 @@ public MSVersion since() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment env, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			final MCServer server = Static.getServer();
 
 			// Handle "broadcast(message, [null])".
@@ -710,7 +711,7 @@ public Mixed exec(Target t, Environment env, Mixed... args) throws ConfigRuntime
 			}
 
 			// Handle "broadcast(message, recipientsArray)".
-			if(args[1].isInstanceOf(CArray.TYPE)) {
+			if(args[1].isInstanceOf(CArray.TYPE, null, env)) {
 
 				// Get the CArray and validate that it is non-associative.
 				CArray array = (CArray) args[1];
@@ -721,12 +722,12 @@ public Mixed exec(Target t, Environment env, Mixed... args) throws ConfigRuntime
 
 				// Get the recipients from the array.
 				Set<MCCommandSender> recipients = new HashSet<>();
-				for(Mixed p : array.asList()) {
+				for(Mixed p : array.asList(env)) {
 					if(p.val().equalsIgnoreCase("~console")) {
 						recipients.add(server.getConsole());
 					} else {
 						try {
-							recipients.add(Static.GetPlayer(p, t));
+							recipients.add(Static.GetPlayer(p, t, env));
 						} catch (CREPlayerOfflineException cre) {
 							// Ignore offline players.
 						}
@@ -789,12 +790,12 @@ public MSVersion since() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment env, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			String mes = Static.MCToANSIColors(args[0].val());
 			boolean prefix = ArgumentValidation.getBooleanish(env.getEnv(GlobalEnv.class)
-					.GetRuntimeSetting("function.console.prefix_default", CBoolean.TRUE), t);
+					.GetRuntimeSetting("function.console.prefix_default", CBoolean.TRUE), t, env);
 			if(args.length > 1) {
-				prefix = ArgumentValidation.getBoolean(args[1], t);
+				prefix = ArgumentValidation.getBoolean(args[1], t, env);
 			}
 
 			if(prefix) {
@@ -835,13 +836,13 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			Mixed text = args[0];
 			String symbol = "&";
 			if(args.length == 2) {
 				symbol = args[1].val();
 			}
-			if(!(text.isInstanceOf(CString.TYPE))) {
+			if(!(text.isInstanceOf(CString.TYPE, null, env))) {
 				return text;
 			}
 			String stext = text.val();
diff --git a/src/main/java/com/laytonsmith/core/functions/Enchantments.java b/src/main/java/com/laytonsmith/core/functions/Enchantments.java
index 88c6e81994..24b88f79bf 100644
--- a/src/main/java/com/laytonsmith/core/functions/Enchantments.java
+++ b/src/main/java/com/laytonsmith/core/functions/Enchantments.java
@@ -21,6 +21,7 @@
 import com.laytonsmith.core.constructs.CString;
 import com.laytonsmith.core.constructs.CVoid;
 import com.laytonsmith.core.constructs.Target;
+import com.laytonsmith.core.constructs.generics.GenericParameters;
 import com.laytonsmith.core.environments.CommandHelperEnvironment;
 import com.laytonsmith.core.environments.Environment;
 import com.laytonsmith.core.exceptions.CRE.CRECastException;
@@ -69,8 +70,8 @@ public static MCEnchantment GetEnchantment(String name, Target t) {
 	 * @param value
 	 * @return
 	 */
-	public static int ConvertLevel(Mixed value) {
-		if(value.isInstanceOf(CInt.TYPE)) {
+	public static int ConvertLevel(Mixed value, Environment env) {
+		if(value.isInstanceOf(CInt.TYPE, null, env)) {
 			return (int) ((CInt) value).getInt();
 		}
 		String lc = value.val().toLowerCase().trim();
@@ -182,29 +183,29 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			MCPlayer p;
 			int offset = 0;
-			if(args.length == 4 || args.length == 3 && args[2].isInstanceOf(CArray.TYPE)) {
-				p = Static.GetPlayer(args[0].val(), t);
+			if(args.length == 4 || args.length == 3 && args[2].isInstanceOf(CArray.TYPE, null, env)) {
+				p = Static.GetPlayer(args[0].val(), t, env);
 				offset = 1;
 			} else {
-				p = environment.getEnv(CommandHelperEnvironment.class).GetPlayer();
+				p = env.getEnv(CommandHelperEnvironment.class).GetPlayer();
 				Static.AssertPlayerNonNull(p, t);
 			}
-			MCItemStack is = p.getItemAt(args[offset] instanceof CNull ? null : ArgumentValidation.getInt32(args[offset], t));
+			MCItemStack is = p.getItemAt(args[offset] instanceof CNull ? null : ArgumentValidation.getInt32(args[offset], t, env));
 			if(is == null) {
 				throw new CRECastException("There is no item at slot " + args[offset], t);
 			}
 
-			if(args[args.length - 1].isInstanceOf(CArray.TYPE)) {
+			if(args[args.length - 1].isInstanceOf(CArray.TYPE, null, env)) {
 				CArray ca = (CArray) args[args.length - 1];
 				Map<MCEnchantment, Integer> enchants = ObjectGenerator.GetGenerator().enchants(ca, t);
 				for(Map.Entry<MCEnchantment, Integer> en : enchants.entrySet()) {
 					is.addUnsafeEnchantment(en.getKey(), en.getValue());
 				}
 			} else {
-				int level = ConvertLevel(args[offset + 2]);
+				int level = ConvertLevel(args[offset + 2], env);
 				if(level > 0) {
 					is.addUnsafeEnchantment(GetEnchantment(args[offset + 1].val(), t), level);
 				} else {
@@ -257,23 +258,23 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			MCPlayer p;
 			int offset = 0;
 			if(args.length == 3) {
-				p = Static.GetPlayer(args[0].val(), t);
+				p = Static.GetPlayer(args[0].val(), t, env);
 				offset = 1;
 			} else {
-				p = environment.getEnv(CommandHelperEnvironment.class).GetPlayer();
+				p = env.getEnv(CommandHelperEnvironment.class).GetPlayer();
 				Static.AssertPlayerNonNull(p, t);
 			}
 
-			MCItemStack is = p.getItemAt(args[offset] instanceof CNull ? null : ArgumentValidation.getInt32(args[offset], t));
+			MCItemStack is = p.getItemAt(args[offset] instanceof CNull ? null : ArgumentValidation.getInt32(args[offset], t, env));
 			if(is == null) {
 				throw new CRECastException("There is no item at slot " + args[offset], t);
 			}
 
-			if(args[offset + 1].isInstanceOf(CArray.TYPE)) {
+			if(args[offset + 1].isInstanceOf(CArray.TYPE, null, env)) {
 				for(String name : ((CArray) args[offset + 1]).stringKeySet()) {
 					MCEnchantment e = GetEnchantment(name, t);
 					is.removeEnchantment(e);
@@ -330,18 +331,18 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			MCPlayer p;
 			Mixed slot;
 			if(args.length == 2) {
-				p = Static.GetPlayer(args[0].val(), t);
+				p = Static.GetPlayer(args[0].val(), t, env);
 				slot = args[1];
 			} else {
-				p = environment.getEnv(CommandHelperEnvironment.class).GetPlayer();
+				p = env.getEnv(CommandHelperEnvironment.class).GetPlayer();
 				Static.AssertPlayerNonNull(p, t);
 				slot = args[0];
 			}
-			MCItemStack is = p.getItemAt(slot instanceof CNull ? null : ArgumentValidation.getInt32(slot, t));
+			MCItemStack is = p.getItemAt(slot instanceof CNull ? null : ArgumentValidation.getInt32(slot, t, env));
 			if(is == null) {
 				return new CArray(t);
 			}
@@ -391,9 +392,9 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			MCEnchantment e = GetEnchantment(args[0].val(), t);
-			MCItemStack is = ObjectGenerator.GetGenerator().item(args[1], t);
+			MCItemStack is = ObjectGenerator.GetGenerator().item(args[1], t, env);
 			return CBoolean.get(e.canEnchantItem(is));
 		}
 	}
@@ -438,7 +439,7 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			MCEnchantment e = GetEnchantment(args[0].val().replace(' ', '_'), t);
 			return new CInt(e.getMaxLevel(), t);
 		}
@@ -487,10 +488,10 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			MCItemStack is;
-			if(args[0].isInstanceOf(CArray.TYPE)) {
-				is = ObjectGenerator.GetGenerator().item(args[0], t);
+			if(args[0].isInstanceOf(CArray.TYPE, null, env)) {
+				is = ObjectGenerator.GetGenerator().item(args[0], t, env);
 			} else {
 				is = Static.ParseItemNotation(null, args[0].val(), 1, t);
 			}
@@ -505,7 +506,7 @@ public Mixed exec(Target t, Environment environment, Mixed... args) throws Confi
 			CArray ca = new CArray(t);
 			for(MCEnchantment e : MCEnchantment.values()) {
 				if(e.canEnchantItem(is)) {
-					ca.push(new CString(e.name().toLowerCase(), t), t);
+					ca.push(new CString(e.name().toLowerCase(), t), t, env);
 				}
 			}
 			CACHE.put(name, ca);
@@ -518,7 +519,7 @@ public ParseTree optimizeDynamic(Target t, Environment env,
 				FileOptions fileOptions)
 				throws ConfigCompileException, ConfigRuntimeException {
 			if(children.size() == 1
-					&& (children.get(0).getData().isInstanceOf(CString.TYPE) || children.get(0).getData().isInstanceOf(CInt.TYPE))) {
+					&& (children.get(0).getData().isInstanceOf(CString.TYPE, null, env) || children.get(0).getData().isInstanceOf(CInt.TYPE, null, env))) {
 				env.getEnv(CompilerEnvironment.class).addCompilerWarning(fileOptions,
 						new CompilerWarning("The string item format in " + getName() + " is deprecated.", t, null));
 			}
@@ -570,7 +571,7 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			try {
 				GetEnchantment(args[0].val(), t);
 				return CBoolean.TRUE;
@@ -599,10 +600,10 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			CArray ret = new CArray(t);
 			for(MCEnchantment e : MCEnchantment.values()) {
-				ret.push(new CString(e.name().toLowerCase(), t), t);
+				ret.push(new CString(e.name().toLowerCase(), t), t, env);
 			}
 			return ret;
 		}
diff --git a/src/main/java/com/laytonsmith/core/functions/EntityManagement.java b/src/main/java/com/laytonsmith/core/functions/EntityManagement.java
index daa5d8e824..f3ec3e6e35 100644
--- a/src/main/java/com/laytonsmith/core/functions/EntityManagement.java
+++ b/src/main/java/com/laytonsmith/core/functions/EntityManagement.java
@@ -145,6 +145,7 @@
 import com.laytonsmith.core.constructs.CString;
 import com.laytonsmith.core.constructs.CVoid;
 import com.laytonsmith.core.constructs.Target;
+import com.laytonsmith.core.constructs.generics.GenericParameters;
 import com.laytonsmith.core.environments.CommandHelperEnvironment;
 import com.laytonsmith.core.environments.Environment;
 import com.laytonsmith.core.exceptions.CRE.CREBadEntityException;
@@ -224,12 +225,12 @@ public Class<? extends CREThrowable>[] thrown() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			CArray ret = new CArray(t);
 			if(args.length == 0) {
 				for(MCWorld w : Static.getServer().getWorlds()) {
 					for(MCEntity e : w.getEntities()) {
-						ret.push(new CString(e.getUniqueId().toString(), t), t);
+						ret.push(new CString(e.getUniqueId().toString(), t), t, env);
 					}
 				}
 			} else {
@@ -241,23 +242,23 @@ public Mixed exec(Target t, Environment environment, Mixed... args) throws Confi
 						throw new CREInvalidWorldException("Unknown world: " + args[0].val(), t);
 					}
 					try {
-						int x = ArgumentValidation.getInt32(args[1], t);
-						int z = ArgumentValidation.getInt32(args[2], t);
+						int x = ArgumentValidation.getInt32(args[1], t, env);
+						int z = ArgumentValidation.getInt32(args[2], t, env);
 						c = w.getChunkAt(x, z);
 					} catch(ConfigRuntimeException cre) {
-						CArray l = CArray.GetAssociativeArray(t);
-						l.set("x", args[1], t);
-						l.set("z", args[2], t);
-						c = w.getChunkAt(ObjectGenerator.GetGenerator().location(l, w, t));
+						CArray l = CArray.GetAssociativeArray(t, null, env);
+						l.set("x", args[1], t, env);
+						l.set("z", args[2], t, env);
+						c = w.getChunkAt(ObjectGenerator.GetGenerator().location(l, w, t, env));
 					}
 					for(MCEntity e : c.getEntities()) {
-						ret.push(new CString(e.getUniqueId().toString(), t), t);
+						ret.push(new CString(e.getUniqueId().toString(), t), t, env);
 					}
 				} else {
-					if(args[0].isInstanceOf(CArray.TYPE)) {
-						c = ObjectGenerator.GetGenerator().location(args[0], null, t).getChunk();
+					if(args[0].isInstanceOf(CArray.TYPE, null, env)) {
+						c = ObjectGenerator.GetGenerator().location(args[0], null, t, env).getChunk();
 						for(MCEntity e : c.getEntities()) {
-							ret.push(new CString(e.getUniqueId().toString(), t), t);
+							ret.push(new CString(e.getUniqueId().toString(), t), t, env);
 						}
 					} else {
 						w = Static.getServer().getWorld(args[0].val());
@@ -265,7 +266,7 @@ public Mixed exec(Target t, Environment environment, Mixed... args) throws Confi
 							throw new CREInvalidWorldException("Unknown world: " + args[0].val(), t);
 						}
 						for(MCEntity e : w.getEntities()) {
-							ret.push(new CString(e.getUniqueId().toString(), t), t);
+							ret.push(new CString(e.getUniqueId().toString(), t), t, env);
 						}
 					}
 				}
@@ -316,7 +317,7 @@ public ExampleScript[] examples() throws ConfigCompileException {
 	public static class entity_exists extends EntityGetterFunction {
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			try {
 				Static.getEntity(args[0], t);
 			} catch(ConfigRuntimeException cre) {
@@ -345,7 +346,7 @@ public MSVersion since() {
 	public static class is_entity_living extends EntityGetterFunction {
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			MCEntity e;
 
 			try {
@@ -393,7 +394,7 @@ public MSVersion since() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			MCEntity e = Static.getEntity(args[0], t);
 			return CBoolean.get(e instanceof MCLivingEntity && ((MCLivingEntity) e).isTameable());
 		}
@@ -404,7 +405,7 @@ public Mixed exec(Target t, Environment environment, Mixed... args) throws Confi
 	public static class entity_loc extends EntityGetterFunction {
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			MCEntity e = Static.getEntity(args[0], t);
 			return ObjectGenerator.GetGenerator().location(e.getLocation());
 		}
@@ -447,11 +448,11 @@ public Class<? extends CREThrowable>[] thrown() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			MCEntity e = Static.getEntity(args[0], t);
 			MCLocation l;
-			if(args[1].isInstanceOf(CArray.TYPE)) {
-				l = ObjectGenerator.GetGenerator().location(args[1], e.getWorld(), t);
+			if(args[1].isInstanceOf(CArray.TYPE, null, env)) {
+				l = ObjectGenerator.GetGenerator().location(args[1], e.getWorld(), t, env);
 			} else {
 				throw new CREFormatException("An array was expected but received " + args[1], t);
 			}
@@ -507,10 +508,10 @@ public MSVersion since() {
 	public static class entity_velocity extends EntityGetterFunction {
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			MCEntity e = Static.getEntity(args[0], t);
 			CArray va  = ObjectGenerator.GetGenerator().vector(e.getVelocity(), t);
-			va.set("magnitude", new CDouble(e.getVelocity().length(), t), t);
+			va.set("magnitude", new CDouble(e.getVelocity().length(), t), t, env);
 			return va;
 		}
 
@@ -546,7 +547,7 @@ public MSVersion since() {
 	public static class set_entity_velocity extends EntitySetterFunction {
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			MCEntity e = Static.getEntity(args[0], t);
 			try {
 				e.setVelocity(ObjectGenerator.GetGenerator().vector(args[1], t));
@@ -597,7 +598,7 @@ public MSVersion since() {
 	public static class entity_remove extends EntityGetterFunction {
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			MCEntity ent = Static.getEntity(args[0], t);
 			if(ent instanceof MCHumanEntity) {
 				throw new CREBadEntityException("Cannot remove human entity (" + ent.getUniqueId() + ")!", t);
@@ -630,7 +631,7 @@ public MSVersion since() {
 	public static class get_entity_saves_on_unload extends EntityGetterFunction {
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			MCEntity ent = Static.getEntity(args[0], t);
 			return CBoolean.get(ent.savesOnUnload());
 		}
@@ -657,9 +658,9 @@ public MSVersion since() {
 	public static class set_entity_saves_on_unload extends EntitySetterFunction {
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			MCEntity ent = Static.getEntity(args[0], t);
-			ent.setSavesOnUnload(ArgumentValidation.getBooleanObject(args[1], t));
+			ent.setSavesOnUnload(ArgumentValidation.getBooleanObject(args[1], t, env));
 			return CVoid.VOID;
 		}
 
@@ -691,7 +692,7 @@ public Class<? extends CREThrowable>[] thrown() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			MCEntity ent;
 			try {
 				ent = Static.getEntity(args[0], t);
@@ -723,7 +724,7 @@ public MSVersion since() {
 	public static class get_entity_age extends EntityGetterFunction {
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			return new CInt(Static.getEntity(args[0], t).getTicksLived(), t);
 		}
 
@@ -754,8 +755,8 @@ public Class<? extends CREThrowable>[] thrown() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
-			int age = ArgumentValidation.getInt32(args[1], t);
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
+			int age = ArgumentValidation.getInt32(args[1], t, env);
 			MCEntity ent = Static.getEntity(args[0], t);
 			try {
 				ent.setTicksLived(age);
@@ -792,7 +793,7 @@ public Class<? extends CREThrowable>[] thrown() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment env, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 
 			MCPlayer p = env.getEnv(CommandHelperEnvironment.class).GetPlayer();
 
@@ -808,11 +809,11 @@ public Mixed exec(Target t, Environment env, Mixed... args) throws ConfigRuntime
 
 			if(args.length >= 1) {
 				if(args[0] instanceof CArray) {
-					from = ObjectGenerator.GetGenerator().location(args[0], p != null ? p.getWorld() : null, t);
+					from = ObjectGenerator.GetGenerator().location(args[0], p != null ? p.getWorld() : null, t, env);
 				} else if(args[0].val().length() > 16) {
 					shooter = Static.getLivingEntity(args[0], t);
 				} else {
-					shooter = Static.GetPlayer(args[0], t);
+					shooter = Static.GetPlayer(args[0], t, env);
 				}
 
 				if(args.length >= 2) {
@@ -824,15 +825,15 @@ public Mixed exec(Target t, Environment env, Mixed... args) throws ConfigRuntime
 
 					if(args.length >= 3) {
 						if(args[2] instanceof CArray) {
-							to = ObjectGenerator.GetGenerator().location(args[2], p != null ? p.getWorld() : null, t);
+							to = ObjectGenerator.GetGenerator().location(args[2], p != null ? p.getWorld() : null, t, env);
 						} else if(args[2].val().length() > 16) {
 							target = Static.getLivingEntity(args[2], t);
 						} else {
-							target = Static.GetPlayer(args[2], t);
+							target = Static.GetPlayer(args[2], t, env);
 						}
 
 						if(args.length == 4) {
-							speed = ArgumentValidation.getDouble(args[3], t);
+							speed = ArgumentValidation.getDouble(args[3], t, env);
 						}
 					}
 				}
@@ -921,7 +922,7 @@ public ParseTree optimizeDynamic(Target t, com.laytonsmith.core.environments.Env
 				return null;
 			}
 			Mixed c = children.get(1).getData();
-			if(c.isInstanceOf(CString.TYPE)) {
+			if(c.isInstanceOf(CString.TYPE, null, env)) {
 				try {
 					MCEntityType.MCVanillaEntityType.valueOf(c.val().toUpperCase());
 				} catch(IllegalArgumentException ex) {
@@ -953,29 +954,29 @@ public Integer[] numArgs() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment env, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			MCPlayer p = env.getEnv(CommandHelperEnvironment.class).GetPlayer();
 
 			MCLocation loc;
 			int dist;
 			List<String> types = new ArrayList<>();
 
-			if(!(args[0].isInstanceOf(CArray.TYPE))) {
+			if(!(args[0].isInstanceOf(CArray.TYPE, null, env))) {
 				throw new CREBadEntityException("Expecting an array at parameter 1 of entities_in_radius", t);
 			}
 
-			loc = ObjectGenerator.GetGenerator().location(args[0], p != null ? p.getWorld() : null, t);
-			dist = ArgumentValidation.getInt32(args[1], t);
+			loc = ObjectGenerator.GetGenerator().location(args[0], p != null ? p.getWorld() : null, t, env);
+			dist = ArgumentValidation.getInt32(args[1], t, env);
 
 			if(dist < 0) {
 				throw new CRERangeException("Distance cannot be negative.", t);
 			}
 
 			if(args.length == 3) {
-				if(args[2].isInstanceOf(CArray.TYPE)) {
+				if(args[2].isInstanceOf(CArray.TYPE, null, env)) {
 					CArray ta = (CArray) args[2];
-					for(int i = 0; i < ta.size(); i++) {
-						types.add(ta.get(i, t).val());
+					for(int i = 0; i < ta.size(env); i++) {
+						types.add(ta.get(i, t, env).val());
 					}
 				} else {
 					types.add(args[2].val());
@@ -998,7 +999,7 @@ public Mixed exec(Target t, Environment env, Mixed... args) throws ConfigRuntime
 					for(MCEntity e : world.getChunkAt(centerX + offsetX, centerZ + offsetZ).getEntities()) {
 						if(e.getLocation().distanceSquared(loc) <= distanceSquared) {
 							if(types.isEmpty() || types.contains(e.getType().name())) {
-								entities.push(new CString(e.getUniqueId().toString(), t), t);
+								entities.push(new CString(e.getUniqueId().toString(), t), t, env);
 							}
 						}
 					}
@@ -1050,7 +1051,7 @@ public ParseTree optimizeDynamic(Target t, com.laytonsmith.core.environments.Env
 				return null;
 			}
 			Mixed c = children.get(children.size() - 1).getData();
-			if(c.isInstanceOf(CString.TYPE)) {
+			if(c.isInstanceOf(CString.TYPE, null, env)) {
 				try {
 					MCEntityType.MCVanillaEntityType.valueOf(c.val().toUpperCase());
 				} catch(IllegalArgumentException ex) {
@@ -1060,7 +1061,7 @@ public ParseTree optimizeDynamic(Target t, com.laytonsmith.core.environments.Env
 				}
 			} else if(c instanceof CFunction && c.val().equals(DataHandling.array.NAME)) {
 				for(ParseTree node : children.get(children.size() - 1).getChildren()) {
-					if(node.getData().isInstanceOf(CString.TYPE)) {
+					if(node.getData().isInstanceOf(CString.TYPE, null, env)) {
 						try {
 							MCEntityType.MCVanillaEntityType.valueOf(node.getData().val().toUpperCase());
 						} catch(IllegalArgumentException ex) {
@@ -1085,7 +1086,7 @@ public Set<OptimizationOption> optimizationOptions() {
 	public static class entity_onfire extends EntityGetterFunction {
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			MCEntity ent = Static.getEntity(args[0], t);
 			return new CInt(ent.getFireTicks() / 20, t);
 		}
@@ -1113,9 +1114,9 @@ public MSVersion since() {
 	public static class set_entity_onfire extends EntitySetterFunction {
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			MCEntity ent = Static.getEntity(args[0], t);
-			int seconds = ArgumentValidation.getInt32(args[1], t);
+			int seconds = ArgumentValidation.getInt32(args[1], t, env);
 			if(seconds < 0) {
 				throw new CRERangeException("Seconds cannot be less than 0", t);
 			} else if(seconds > Integer.MAX_VALUE / 20) {
@@ -1148,7 +1149,7 @@ public MSVersion since() {
 	public static class play_entity_effect extends EntitySetterFunction implements Optimizable {
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			MCEntity ent = Static.getEntity(args[0], t);
 			try {
 				MCEntityEffect mee = MCEntityEffect.valueOf(args[1].val().toUpperCase());
@@ -1190,7 +1191,7 @@ public ParseTree optimizeDynamic(Target t, com.laytonsmith.core.environments.Env
 				return null;
 			}
 			Mixed c = children.get(1).getData();
-			if(c.isInstanceOf(CString.TYPE)) {
+			if(c.isInstanceOf(CString.TYPE, null, env)) {
 				try {
 					MCEntityEffect.valueOf(c.val().toUpperCase());
 				} catch(IllegalArgumentException ex) {
@@ -1213,7 +1214,7 @@ public Set<OptimizationOption> optimizationOptions() {
 	public static class get_mob_name extends EntityGetterFunction {
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			MCEntity le = Static.getEntity(args[0], t);
 			try {
 				return new CString(le.getCustomName(), t);
@@ -1243,7 +1244,7 @@ public MSVersion since() {
 	public static class set_mob_name extends EntitySetterFunction {
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			MCEntity le = Static.getEntity(args[0], t);
 			try {
 				le.setCustomName(args[1].val());
@@ -1281,8 +1282,8 @@ public Class<? extends CREThrowable>[] thrown() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
-			MCCommandSender cs = environment.getEnv(CommandHelperEnvironment.class).GetCommandSender();
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
+			MCCommandSender cs = env.getEnv(CommandHelperEnvironment.class).GetCommandSender();
 			int qty = 1;
 			CArray ret = new CArray(t);
 			MCEntityType entType;
@@ -1290,9 +1291,9 @@ public Mixed exec(Target t, Environment environment, Mixed... args) throws Confi
 			MCEntity ent;
 			CClosure consumer = null;
 			if(args.length >= 3) {
-				l = ObjectGenerator.GetGenerator().location(args[2], null, t);
+				l = ObjectGenerator.GetGenerator().location(args[2], null, t, env);
 				if(args.length == 4) {
-					if(args[3].isInstanceOf(CClosure.TYPE)) {
+					if(args[3].isInstanceOf(CClosure.TYPE, null, env)) {
 						consumer = (CClosure) args[3];
 					} else {
 						throw new CREIllegalArgumentException("Expected a closure as last argument for spawn_entity().", t);
@@ -1310,7 +1311,7 @@ public Mixed exec(Target t, Environment environment, Mixed... args) throws Confi
 				}
 			}
 			if(args.length >= 2) {
-				qty = ArgumentValidation.getInt32(args[1], t);
+				qty = ArgumentValidation.getInt32(args[1], t, env);
 			}
 			try {
 				entType = MCEntityType.valueOf(args[0].val().toUpperCase());
@@ -1354,7 +1355,7 @@ public Mixed exec(Target t, Environment environment, Mixed... args) throws Confi
 							throw new CREFormatException(ex.getMessage(), t);
 						}
 				}
-				ret.push(new CString(ent.getUniqueId().toString(), t), t);
+				ret.push(new CString(ent.getUniqueId().toString(), t), t, env);
 			}
 			return ret;
 		}
@@ -1413,7 +1414,7 @@ public ParseTree optimizeDynamic(Target t, com.laytonsmith.core.environments.Env
 				return null;
 			}
 			Mixed c = children.get(0).getData();
-			if(c.isInstanceOf(CString.TYPE)) {
+			if(c.isInstanceOf(CString.TYPE, null, env)) {
 				try {
 					MCEntityType.MCVanillaEntityType type = MCEntityType.MCVanillaEntityType.valueOf(c.val().toUpperCase());
 					if(!type.isSpawnable()) {
@@ -1441,7 +1442,7 @@ public Set<OptimizationOption> optimizationOptions() {
 	public static class set_entity_rider extends EntitySetterFunction {
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			MCEntity horse;
 			MCEntity rider;
 			boolean success;
@@ -1498,7 +1499,7 @@ public MSVersion since() {
 	public static class get_entity_rider extends EntityGetterFunction {
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			MCEntity ent = Static.getEntity(args[0], t);
 			List<MCEntity> passengers = ent.getPassengers();
 			if(!passengers.isEmpty()) {
@@ -1529,12 +1530,12 @@ public MSVersion since() {
 	public static class get_entity_riders extends EntityGetterFunction {
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			MCEntity ent = Static.getEntity(args[0], t);
 			List<MCEntity> riders = ent.getPassengers();
 			CArray ret = new CArray(t);
 			for(MCEntity rider : riders) {
-				ret.push(new CString(rider.getUniqueId().toString(), t), t);
+				ret.push(new CString(rider.getUniqueId().toString(), t), t, env);
 			}
 			return ret;
 		}
@@ -1560,7 +1561,7 @@ public MSVersion since() {
 	public static class get_entity_vehicle extends EntityGetterFunction {
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			MCEntity ent = Static.getEntity(args[0], t);
 			if(ent.isInsideVehicle()) {
 				return new CString(ent.getVehicle().getUniqueId().toString(), t);
@@ -1594,7 +1595,7 @@ public Class<? extends CREThrowable>[] thrown() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			MCEntity e = Static.getEntity(args[0], t);
 			if(e instanceof MCMinecart) {
 				return new CDouble(((MCMinecart) e).getMaxSpeed(), t);
@@ -1629,9 +1630,9 @@ public Class<? extends CREThrowable>[] thrown() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			MCEntity e = Static.getEntity(args[0], t);
-			double speed = ArgumentValidation.getDouble(args[1], t);
+			double speed = ArgumentValidation.getDouble(args[1], t, env);
 			if(e instanceof MCMinecart) {
 				((MCMinecart) e).setMaxSpeed(speed);
 			} else {
@@ -1661,7 +1662,7 @@ public MSVersion since() {
 	public static class get_name_visible extends EntityGetterFunction {
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			try {
 				return CBoolean.get(Static.getEntity(args[0], t).isCustomNameVisible());
 			} catch(IllegalArgumentException e) {
@@ -1692,9 +1693,9 @@ public MSVersion since() {
 	public static class set_name_visible extends EntitySetterFunction {
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			try {
-				Static.getEntity(args[0], t).setCustomNameVisible(ArgumentValidation.getBoolean(args[1], t));
+				Static.getEntity(args[0], t).setCustomNameVisible(ArgumentValidation.getBoolean(args[1], t, env));
 			} catch(IllegalArgumentException e) {
 				throw new CRECastException(e.getMessage(), t);
 			}
@@ -1724,12 +1725,12 @@ public MSVersion since() {
 	public static class get_art_at extends EntityGetterFunction {
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			MCWorld w = null;
-			if(environment.getEnv(CommandHelperEnvironment.class).GetPlayer() != null) {
-				w = environment.getEnv(CommandHelperEnvironment.class).GetPlayer().getWorld();
+			if(env.getEnv(CommandHelperEnvironment.class).GetPlayer() != null) {
+				w = env.getEnv(CommandHelperEnvironment.class).GetPlayer().getWorld();
 			}
-			List<MCEntity> es = StaticLayer.GetConvertor().GetEntitiesAt(ObjectGenerator.GetGenerator().location(args[0], w, t), 1);
+			List<MCEntity> es = StaticLayer.GetConvertor().GetEntitiesAt(ObjectGenerator.GetGenerator().location(args[0], w, t, env), 1);
 			for(MCEntity e : es) {
 				if(e instanceof MCPainting) {
 					return new CString(((MCPainting) e).getArt().name(), t);
@@ -1762,12 +1763,12 @@ public Version since() {
 	public static class set_art_at extends EntitySetterFunction {
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			MCWorld w = null;
-			if(environment.getEnv(CommandHelperEnvironment.class).GetPlayer() != null) {
-				w = environment.getEnv(CommandHelperEnvironment.class).GetPlayer().getWorld();
+			if(env.getEnv(CommandHelperEnvironment.class).GetPlayer() != null) {
+				w = env.getEnv(CommandHelperEnvironment.class).GetPlayer().getWorld();
 			}
-			MCLocation loc = ObjectGenerator.GetGenerator().location(args[0], w, t);
+			MCLocation loc = ObjectGenerator.GetGenerator().location(args[0], w, t, env);
 			MCArt art;
 			try {
 				art = MCArt.valueOf(args[1].val());
@@ -1814,7 +1815,7 @@ public Version since() {
 	public static class entity_grounded extends EntityGetterFunction {
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			return CBoolean.get(Static.getEntity(args[0], t).isOnGround());
 		}
 
@@ -1881,313 +1882,313 @@ public String docs() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			MCEntity entity = Static.getEntity(args[0], t);
-			CArray specArray = CArray.GetAssociativeArray(t);
+			CArray specArray = CArray.GetAssociativeArray(t, null, env);
 			switch(entity.getType().getAbstracted()) {
 				case AREA_EFFECT_CLOUD:
 					MCAreaEffectCloud cloud = (MCAreaEffectCloud) entity;
-					specArray.set(entity_spec.KEY_AREAEFFECTCLOUD_COLOR, ObjectGenerator.GetGenerator().color(cloud.getColor(), t), t);
-					specArray.set(entity_spec.KEY_AREAEFFECTCLOUD_DURATION, new CInt(cloud.getDuration(), t), t);
-					specArray.set(entity_spec.KEY_AREAEFFECTCLOUD_DURATIONONUSE, new CInt(cloud.getDurationOnUse(), t), t);
-					specArray.set(entity_spec.KEY_AREAEFFECTCLOUD_PARTICLE, new CString(cloud.getParticle().name(), t), t);
-					CArray meta = CArray.GetAssociativeArray(t);
+					specArray.set(entity_spec.KEY_AREAEFFECTCLOUD_COLOR, ObjectGenerator.GetGenerator().color(cloud.getColor(), t), t, env);
+					specArray.set(entity_spec.KEY_AREAEFFECTCLOUD_DURATION, new CInt(cloud.getDuration(), t), t, env);
+					specArray.set(entity_spec.KEY_AREAEFFECTCLOUD_DURATIONONUSE, new CInt(cloud.getDurationOnUse(), t), t, env);
+					specArray.set(entity_spec.KEY_AREAEFFECTCLOUD_PARTICLE, new CString(cloud.getParticle().name(), t), t, env);
+					CArray meta = CArray.GetAssociativeArray(t, null, env);
 					CArray effects = ObjectGenerator.GetGenerator().potions(cloud.getCustomEffects(), t);
-					meta.set("potions", effects, t);
+					meta.set("potions", effects, t, env);
 					if(Static.getServer().getMinecraftVersion().gte(MCVersion.MC1_20_6)) {
 						MCPotionType potionType = cloud.getBasePotionType();
 						if(potionType == null) {
-							meta.set("potiontype", CNull.NULL, t);
+							meta.set("potiontype", CNull.NULL, t, env);
 						} else {
-							meta.set("potiontype", potionType.name());
+							meta.set("potiontype", potionType.name(), env);
 						}
 					} else {
-						meta.set("base", ObjectGenerator.GetGenerator().potionData(cloud.getBasePotionData(), t), t);
+						meta.set("base", ObjectGenerator.GetGenerator().potionData(cloud.getBasePotionData(), t), t, env);
 					}
-					specArray.set(entity_spec.KEY_AREAEFFECTCLOUD_POTIONMETA, meta, t);
-					specArray.set(entity_spec.KEY_AREAEFFECTCLOUD_RADIUS, new CDouble(cloud.getRadius(), t), t);
-					specArray.set(entity_spec.KEY_AREAEFFECTCLOUD_RADIUSONUSE, new CDouble(cloud.getRadiusOnUse(), t), t);
-					specArray.set(entity_spec.KEY_AREAEFFECTCLOUD_RADIUSPERTICK, new CDouble(cloud.getRadiusPerTick(), t), t);
-					specArray.set(entity_spec.KEY_AREAEFFECTCLOUD_REAPPLICATIONDELAY, new CInt(cloud.getReapplicationDelay(), t), t);
+					specArray.set(entity_spec.KEY_AREAEFFECTCLOUD_POTIONMETA, meta, t, env);
+					specArray.set(entity_spec.KEY_AREAEFFECTCLOUD_RADIUS, new CDouble(cloud.getRadius(), t), t, env);
+					specArray.set(entity_spec.KEY_AREAEFFECTCLOUD_RADIUSONUSE, new CDouble(cloud.getRadiusOnUse(), t), t, env);
+					specArray.set(entity_spec.KEY_AREAEFFECTCLOUD_RADIUSPERTICK, new CDouble(cloud.getRadiusPerTick(), t), t, env);
+					specArray.set(entity_spec.KEY_AREAEFFECTCLOUD_REAPPLICATIONDELAY, new CInt(cloud.getReapplicationDelay(), t), t, env);
 					MCProjectileSource cloudSource = cloud.getSource();
 					if(cloudSource instanceof MCBlockProjectileSource) {
 						MCLocation blockLocation = ((MCBlockProjectileSource) cloudSource).getBlock().getLocation();
 						CArray locationArray = ObjectGenerator.GetGenerator().location(blockLocation, false);
-						specArray.set(entity_spec.KEY_AREAEFFECTCLOUD_SOURCE, locationArray, t);
+						specArray.set(entity_spec.KEY_AREAEFFECTCLOUD_SOURCE, locationArray, t, env);
 					} else if(cloudSource instanceof MCEntity) {
 						String entityUUID = ((MCEntity) cloudSource).getUniqueId().toString();
-						specArray.set(entity_spec.KEY_AREAEFFECTCLOUD_SOURCE, new CString(entityUUID, t), t);
+						specArray.set(entity_spec.KEY_AREAEFFECTCLOUD_SOURCE, new CString(entityUUID, t), t, env);
 					} else {
-						specArray.set(entity_spec.KEY_AREAEFFECTCLOUD_SOURCE, CNull.NULL, t);
+						specArray.set(entity_spec.KEY_AREAEFFECTCLOUD_SOURCE, CNull.NULL, t, env);
 					}
-					specArray.set(entity_spec.KEY_AREAEFFECTCLOUD_WAITTIME, new CInt(cloud.getWaitTime(), t), t);
+					specArray.set(entity_spec.KEY_AREAEFFECTCLOUD_WAITTIME, new CInt(cloud.getWaitTime(), t), t, env);
 					break;
 				case ARROW:
 					MCArrow arrow = (MCArrow) entity;
-					specArray.set(entity_spec.KEY_ARROW_CRITICAL, CBoolean.get(arrow.isCritical()), t);
-					specArray.set(entity_spec.KEY_ARROW_KNOCKBACK, new CInt(arrow.getKnockbackStrength(), t), t);
-					specArray.set(entity_spec.KEY_ARROW_DAMAGE, new CDouble(arrow.getDamage(), t), t);
-					specArray.set(entity_spec.KEY_ARROW_PIERCE_LEVEL, new CInt(arrow.getPierceLevel(), t), t);
-					specArray.set(entity_spec.KEY_ARROW_PICKUP, new CString(arrow.getPickupStatus().name(), t), t);
-					CArray tippedmeta = CArray.GetAssociativeArray(t);
+					specArray.set(entity_spec.KEY_ARROW_CRITICAL, CBoolean.get(arrow.isCritical()), t, env);
+					specArray.set(entity_spec.KEY_ARROW_KNOCKBACK, new CInt(arrow.getKnockbackStrength(), t), t, env);
+					specArray.set(entity_spec.KEY_ARROW_DAMAGE, new CDouble(arrow.getDamage(), t), t, env);
+					specArray.set(entity_spec.KEY_ARROW_PIERCE_LEVEL, new CInt(arrow.getPierceLevel(), t), t, env);
+					specArray.set(entity_spec.KEY_ARROW_PICKUP, new CString(arrow.getPickupStatus().name(), t), t, env);
+					CArray tippedmeta = CArray.GetAssociativeArray(t, null, env);
 					CArray tippedeffects = ObjectGenerator.GetGenerator().potions(arrow.getCustomEffects(), t);
-					tippedmeta.set("potions", tippedeffects, t);
+					tippedmeta.set("potions", tippedeffects, t, env);
 					if(Static.getServer().getMinecraftVersion().gte(MCVersion.MC1_20_6)) {
 						MCPotionType potionType = arrow.getBasePotionType();
 						if(potionType == null) {
-							tippedmeta.set("potiontype", CNull.NULL, t);
+							tippedmeta.set("potiontype", CNull.NULL, t, env);
 						} else {
-							tippedmeta.set("potiontype", potionType.name());
+							tippedmeta.set("potiontype", potionType.name(), env);
 						}
 					} else {
-						tippedmeta.set("base", ObjectGenerator.GetGenerator().potionData(arrow.getBasePotionData(), t), t);
+						tippedmeta.set("base", ObjectGenerator.GetGenerator().potionData(arrow.getBasePotionData(), t), t, env);
 					}
-					specArray.set(entity_spec.KEY_ARROW_POTIONMETA, tippedmeta, t);
+					specArray.set(entity_spec.KEY_ARROW_POTIONMETA, tippedmeta, t, env);
 					MCColor arrowColor = arrow.getColor();
 					if(arrowColor == null) {
-						specArray.set(entity_spec.KEY_ARROW_COLOR, CNull.NULL, t);
+						specArray.set(entity_spec.KEY_ARROW_COLOR, CNull.NULL, t, env);
 					} else {
-						specArray.set(entity_spec.KEY_ARROW_COLOR, ObjectGenerator.GetGenerator().color(arrowColor, t), t);
+						specArray.set(entity_spec.KEY_ARROW_COLOR, ObjectGenerator.GetGenerator().color(arrowColor, t), t, env);
 					}
 					break;
 				case ARMOR_STAND:
 					MCArmorStand stand = (MCArmorStand) entity;
-					specArray.set(entity_spec.KEY_ARMORSTAND_ARMS, CBoolean.get(stand.hasArms()), t);
-					specArray.set(entity_spec.KEY_ARMORSTAND_BASEPLATE, CBoolean.get(stand.hasBasePlate()), t);
-					specArray.set(entity_spec.KEY_ARMORSTAND_GRAVITY, CBoolean.get(stand.hasGravity()), t);
-					specArray.set(entity_spec.KEY_ARMORSTAND_MARKER, CBoolean.get(stand.isMarker()), t);
-					specArray.set(entity_spec.KEY_ARMORSTAND_SMALLSIZE, CBoolean.get(stand.isSmall()), t);
-					specArray.set(entity_spec.KEY_ARMORSTAND_VISIBLE, CBoolean.get(stand.isVisible()), t);
-					CArray poses = CArray.GetAssociativeArray(t);
+					specArray.set(entity_spec.KEY_ARMORSTAND_ARMS, CBoolean.get(stand.hasArms()), t, env);
+					specArray.set(entity_spec.KEY_ARMORSTAND_BASEPLATE, CBoolean.get(stand.hasBasePlate()), t, env);
+					specArray.set(entity_spec.KEY_ARMORSTAND_GRAVITY, CBoolean.get(stand.hasGravity()), t, env);
+					specArray.set(entity_spec.KEY_ARMORSTAND_MARKER, CBoolean.get(stand.isMarker()), t, env);
+					specArray.set(entity_spec.KEY_ARMORSTAND_SMALLSIZE, CBoolean.get(stand.isSmall()), t, env);
+					specArray.set(entity_spec.KEY_ARMORSTAND_VISIBLE, CBoolean.get(stand.isVisible()), t, env);
+					CArray poses = CArray.GetAssociativeArray(t, null, env);
 					Map<MCBodyPart, Vector3D> poseMap = stand.getAllPoses();
 					for(MCBodyPart key : poseMap.keySet()) {
-						poses.set("pose" + key.name(), ObjectGenerator.GetGenerator().vector(poseMap.get(key), t), t);
+						poses.set("pose" + key.name(), ObjectGenerator.GetGenerator().vector(poseMap.get(key), t), t, env);
 					}
-					specArray.set(entity_spec.KEY_ARMORSTAND_POSES, poses, t);
+					specArray.set(entity_spec.KEY_ARMORSTAND_POSES, poses, t, env);
 					break;
 				case AXOLOTL:
 					MCAxolotl axolotl = (MCAxolotl) entity;
-					specArray.set(entity_spec.KEY_AXOLOTL_TYPE, new CString(axolotl.getAxolotlType().name(), t), t);
+					specArray.set(entity_spec.KEY_AXOLOTL_TYPE, new CString(axolotl.getAxolotlType().name(), t), t, env);
 					break;
 				case BEE:
 					MCBee bee = (MCBee) entity;
-					specArray.set(entity_spec.KEY_BEE_ANGER, new CInt(bee.getAnger(), t), t);
-					specArray.set(entity_spec.KEY_BEE_NECTAR, CBoolean.get(bee.hasNectar()), t);
-					specArray.set(entity_spec.KEY_BEE_STUNG, CBoolean.get(bee.hasStung()), t);
+					specArray.set(entity_spec.KEY_BEE_ANGER, new CInt(bee.getAnger(), t), t, env);
+					specArray.set(entity_spec.KEY_BEE_NECTAR, CBoolean.get(bee.hasNectar()), t, env);
+					specArray.set(entity_spec.KEY_BEE_STUNG, CBoolean.get(bee.hasStung()), t, env);
 					MCLocation flower = bee.getFlowerLocation();
 					if(flower == null) {
-						specArray.set(entity_spec.KEY_BEE_FLOWER_LOCATION, CNull.NULL, t);
+						specArray.set(entity_spec.KEY_BEE_FLOWER_LOCATION, CNull.NULL, t, env);
 					} else {
-						specArray.set(entity_spec.KEY_BEE_FLOWER_LOCATION, ObjectGenerator.GetGenerator().location(flower), t);
+						specArray.set(entity_spec.KEY_BEE_FLOWER_LOCATION, ObjectGenerator.GetGenerator().location(flower), t, env);
 					}
 					MCLocation hive = bee.getHiveLocation();
 					if(hive == null) {
-						specArray.set(entity_spec.KEY_BEE_HIVE_LOCATION, CNull.NULL, t);
+						specArray.set(entity_spec.KEY_BEE_HIVE_LOCATION, CNull.NULL, t, env);
 					} else {
-						specArray.set(entity_spec.KEY_BEE_HIVE_LOCATION, ObjectGenerator.GetGenerator().location(hive), t);
+						specArray.set(entity_spec.KEY_BEE_HIVE_LOCATION, ObjectGenerator.GetGenerator().location(hive), t, env);
 					}
 					break;
 				case BLOCK_DISPLAY:
 					MCBlockDisplay blockDisplay = (MCBlockDisplay) entity;
-					specArray.set(KEY_DISPLAY_BLOCK, ObjectGenerator.GetGenerator().blockData(blockDisplay.getBlockData(), t), t);
+					specArray.set(KEY_DISPLAY_BLOCK, ObjectGenerator.GetGenerator().blockData(blockDisplay.getBlockData(), t), t, env);
 					break;
 				case BOAT:
 					MCBoat boat = (MCBoat) entity;
-					specArray.set(entity_spec.KEY_BOAT_TYPE, new CString(boat.getWoodType().name(), t), t);
+					specArray.set(entity_spec.KEY_BOAT_TYPE, new CString(boat.getWoodType().name(), t), t, env);
 					break;
 				case CAT:
 					MCCat cat = (MCCat) entity;
-					specArray.set(entity_spec.KEY_CAT_TYPE, new CString(cat.getCatType().name(), t), t);
-					specArray.set(entity_spec.KEY_GENERIC_SITTING, CBoolean.get(cat.isSitting()), t);
-					specArray.set(entity_spec.KEY_CAT_COLOR, new CString(cat.getCollarColor().name(), t), t);
+					specArray.set(entity_spec.KEY_CAT_TYPE, new CString(cat.getCatType().name(), t), t, env);
+					specArray.set(entity_spec.KEY_GENERIC_SITTING, CBoolean.get(cat.isSitting()), t, env);
+					specArray.set(entity_spec.KEY_CAT_COLOR, new CString(cat.getCollarColor().name(), t), t, env);
 					break;
 				case CREEPER:
 					MCCreeper creeper = (MCCreeper) entity;
-					specArray.set(entity_spec.KEY_CREEPER_POWERED, CBoolean.get(creeper.isPowered()), t);
-					specArray.set(entity_spec.KEY_CREEPER_FUSETICKS, new CInt(creeper.getFuseTicks(), t), t);
-					specArray.set(entity_spec.KEY_CREEPER_MAXFUSETICKS, new CInt(creeper.getMaxFuseTicks(), t), t);
-					specArray.set(entity_spec.KEY_CREEPER_EXPLOSIONRADIUS, new CInt(creeper.getExplosionRadius(), t), t);
+					specArray.set(entity_spec.KEY_CREEPER_POWERED, CBoolean.get(creeper.isPowered()), t, env);
+					specArray.set(entity_spec.KEY_CREEPER_FUSETICKS, new CInt(creeper.getFuseTicks(), t), t, env);
+					specArray.set(entity_spec.KEY_CREEPER_MAXFUSETICKS, new CInt(creeper.getMaxFuseTicks(), t), t, env);
+					specArray.set(entity_spec.KEY_CREEPER_EXPLOSIONRADIUS, new CInt(creeper.getExplosionRadius(), t), t, env);
 					break;
 				case DONKEY:
 				case MULE:
 					MCChestedHorse chestedhorse = (MCChestedHorse) entity;
-					specArray.set(entity_spec.KEY_HORSE_CHEST, CBoolean.get(chestedhorse.hasChest()), t);
-					specArray.set(entity_spec.KEY_HORSE_JUMP, new CDouble(chestedhorse.getJumpStrength(), t), t);
-					specArray.set(entity_spec.KEY_HORSE_DOMESTICATION, new CInt(chestedhorse.getDomestication(), t), t);
-					specArray.set(entity_spec.KEY_HORSE_MAXDOMESTICATION, new CInt(chestedhorse.getMaxDomestication(), t), t);
-					specArray.set(entity_spec.KEY_HORSE_SADDLE, ObjectGenerator.GetGenerator().item(chestedhorse.getSaddle(), t), t);
+					specArray.set(entity_spec.KEY_HORSE_CHEST, CBoolean.get(chestedhorse.hasChest()), t, env);
+					specArray.set(entity_spec.KEY_HORSE_JUMP, new CDouble(chestedhorse.getJumpStrength(), t), t, env);
+					specArray.set(entity_spec.KEY_HORSE_DOMESTICATION, new CInt(chestedhorse.getDomestication(), t), t, env);
+					specArray.set(entity_spec.KEY_HORSE_MAXDOMESTICATION, new CInt(chestedhorse.getMaxDomestication(), t), t, env);
+					specArray.set(entity_spec.KEY_HORSE_SADDLE, ObjectGenerator.GetGenerator().item(chestedhorse.getSaddle(), t), t, env);
 					break;
 				case DROPPED_ITEM:
 					MCItem item = (MCItem) entity;
-					specArray.set(entity_spec.KEY_DROPPED_ITEM_ITEMSTACK, ObjectGenerator.GetGenerator().item(item.getItemStack(), t), t);
-					specArray.set(entity_spec.KEY_DROPPED_ITEM_PICKUPDELAY, new CInt(item.getPickupDelay(), t), t);
+					specArray.set(entity_spec.KEY_DROPPED_ITEM_ITEMSTACK, ObjectGenerator.GetGenerator().item(item.getItemStack(), t), t, env);
+					specArray.set(entity_spec.KEY_DROPPED_ITEM_PICKUPDELAY, new CInt(item.getPickupDelay(), t), t, env);
 					UUID owner = item.getOwner();
 					if(owner == null) {
-						specArray.set(entity_spec.KEY_DROPPED_ITEM_OWNER, CNull.NULL, t);
+						specArray.set(entity_spec.KEY_DROPPED_ITEM_OWNER, CNull.NULL, t, env);
 					} else {
-						specArray.set(entity_spec.KEY_DROPPED_ITEM_OWNER, new CString(owner.toString(), t), t);
+						specArray.set(entity_spec.KEY_DROPPED_ITEM_OWNER, new CString(owner.toString(), t), t, env);
 					}
 					UUID thrower = item.getThrower();
 					if(thrower == null) {
-						specArray.set(entity_spec.KEY_DROPPED_ITEM_THROWER, CNull.NULL, t);
+						specArray.set(entity_spec.KEY_DROPPED_ITEM_THROWER, CNull.NULL, t, env);
 					} else {
-						specArray.set(entity_spec.KEY_DROPPED_ITEM_THROWER, new CString(thrower.toString(), t), t);
+						specArray.set(entity_spec.KEY_DROPPED_ITEM_THROWER, new CString(thrower.toString(), t), t, env);
 					}
 					if(Static.getServer().getMinecraftVersion().gte(MCVersion.MC1_18_X)) {
-						specArray.set(entity_spec.KEY_DROPPED_ITEM_DESPAWN, CBoolean.get(item.willDespawn()), t);
+						specArray.set(entity_spec.KEY_DROPPED_ITEM_DESPAWN, CBoolean.get(item.willDespawn()), t, env);
 					} else {
-						specArray.set(entity_spec.KEY_DROPPED_ITEM_DESPAWN, CBoolean.TRUE, t);
+						specArray.set(entity_spec.KEY_DROPPED_ITEM_DESPAWN, CBoolean.TRUE, t, env);
 					}
 					break;
 				case ENDER_CRYSTAL:
 					MCEnderCrystal endercrystal = (MCEnderCrystal) entity;
-					specArray.set(entity_spec.KEY_ENDERCRYSTAL_BASE, CBoolean.get(endercrystal.isShowingBottom()), t);
+					specArray.set(entity_spec.KEY_ENDERCRYSTAL_BASE, CBoolean.get(endercrystal.isShowingBottom()), t, env);
 					MCLocation location = endercrystal.getBeamTarget();
 					if(location == null) {
-						specArray.set(entity_spec.KEY_ENDERCRYSTAL_BEAMTARGET, CNull.NULL, t);
+						specArray.set(entity_spec.KEY_ENDERCRYSTAL_BEAMTARGET, CNull.NULL, t, env);
 					} else {
 						specArray.set(entity_spec.KEY_ENDERCRYSTAL_BEAMTARGET,
-								ObjectGenerator.GetGenerator().location(location, false), t);
+								ObjectGenerator.GetGenerator().location(location, false), t, env);
 					}
 					break;
 				case ENDER_EYE:
 					MCEnderSignal endereye = (MCEnderSignal) entity;
-					specArray.set(entity_spec.KEY_ENDEREYE_DESPAWNTICKS, new CInt(endereye.getDespawnTicks(), t), t);
-					specArray.set(entity_spec.KEY_ENDEREYE_DROP, CBoolean.get(endereye.getDropItem()), t);
-					specArray.set(entity_spec.KEY_ENDEREYE_ITEM, ObjectGenerator.GetGenerator().item(endereye.getItem(), t), t);
-					specArray.set(entity_spec.KEY_ENDEREYE_TARGET, ObjectGenerator.GetGenerator().location(endereye.getTargetLocation(), false), t);
+					specArray.set(entity_spec.KEY_ENDEREYE_DESPAWNTICKS, new CInt(endereye.getDespawnTicks(), t), t, env);
+					specArray.set(entity_spec.KEY_ENDEREYE_DROP, CBoolean.get(endereye.getDropItem()), t, env);
+					specArray.set(entity_spec.KEY_ENDEREYE_ITEM, ObjectGenerator.GetGenerator().item(endereye.getItem(), t), t, env);
+					specArray.set(entity_spec.KEY_ENDEREYE_TARGET, ObjectGenerator.GetGenerator().location(endereye.getTargetLocation(), false), t, env);
 					break;
 				case ENDER_DRAGON:
 					MCEnderDragon enderdragon = (MCEnderDragon) entity;
-					specArray.set(entity_spec.KEY_ENDERDRAGON_PHASE, new CString(enderdragon.getPhase().name(), t), t);
+					specArray.set(entity_spec.KEY_ENDERDRAGON_PHASE, new CString(enderdragon.getPhase().name(), t), t, env);
 					break;
 				case ENDERMAN:
 					MCEnderman enderman = (MCEnderman) entity;
 					MCBlockData carried = enderman.getCarriedMaterial();
 					specArray.set(entity_spec.KEY_ENDERMAN_CARRIED,
-							(carried == null ? CNull.NULL : new CString(carried.getMaterial().getName(), t)), t);
+							(carried == null ? CNull.NULL : new CString(carried.getMaterial().getName(), t)), t, env);
 					break;
 				case EVOKER_FANGS:
 					MCEvokerFangs fangs = (MCEvokerFangs) entity;
 					MCLivingEntity fangsource = fangs.getOwner();
 					if(fangsource == null) {
-						specArray.set(entity_spec.KEY_EVOKERFANGS_SOURCE, CNull.NULL, t);
+						specArray.set(entity_spec.KEY_EVOKERFANGS_SOURCE, CNull.NULL, t, env);
 					} else {
-						specArray.set(entity_spec.KEY_EVOKERFANGS_SOURCE, new CString(fangsource.getUniqueId().toString(), t), t);
+						specArray.set(entity_spec.KEY_EVOKERFANGS_SOURCE, new CString(fangsource.getUniqueId().toString(), t), t, env);
 					}
 					break;
 				case EXPERIENCE_ORB:
 					MCExperienceOrb orb = (MCExperienceOrb) entity;
-					specArray.set(entity_spec.KEY_EXPERIENCE_ORB_AMOUNT, new CInt(orb.getExperience(), t), t);
+					specArray.set(entity_spec.KEY_EXPERIENCE_ORB_AMOUNT, new CInt(orb.getExperience(), t), t, env);
 					break;
 				case FALLING_BLOCK:
 					MCFallingBlock block = (MCFallingBlock) entity;
-					specArray.set(entity_spec.KEY_FALLING_BLOCK_BLOCK, new CString(block.getMaterial().getName(), t), t);
-					specArray.set(entity_spec.KEY_FALLING_BLOCK_DROPITEM, CBoolean.get(block.getDropItem()), t);
-					specArray.set(entity_spec.KEY_FALLING_BLOCK_DAMAGE, CBoolean.get(block.canHurtEntities()), t);
+					specArray.set(entity_spec.KEY_FALLING_BLOCK_BLOCK, new CString(block.getMaterial().getName(), t), t, env);
+					specArray.set(entity_spec.KEY_FALLING_BLOCK_DROPITEM, CBoolean.get(block.getDropItem()), t, env);
+					specArray.set(entity_spec.KEY_FALLING_BLOCK_DAMAGE, CBoolean.get(block.canHurtEntities()), t, env);
 					break;
 				case FIREBALL:
 				case SMALL_FIREBALL:
 					MCFireball ball = (MCFireball) entity;
-					specArray.set(entity_spec.KEY_FIREBALL_DIRECTION, ObjectGenerator.GetGenerator().vector(ball.getDirection(), t), t);
+					specArray.set(entity_spec.KEY_FIREBALL_DIRECTION, ObjectGenerator.GetGenerator().vector(ball.getDirection(), t), t, env);
 					break;
 				case FIREWORK:
 					MCFirework firework = (MCFirework) entity;
 					MCFireworkMeta fmeta = firework.getFireWorkMeta();
-					specArray.set(entity_spec.KEY_FIREWORK_STRENGTH, new CInt(fmeta.getStrength(), t), t);
+					specArray.set(entity_spec.KEY_FIREWORK_STRENGTH, new CInt(fmeta.getStrength(), t), t, env);
 					CArray fe = new CArray(t);
 					for(MCFireworkEffect effect : fmeta.getEffects()) {
-						fe.push(ObjectGenerator.GetGenerator().fireworkEffect(effect, t), t);
+						fe.push(ObjectGenerator.GetGenerator().fireworkEffect(effect, t), t, env);
 					}
-					specArray.set(entity_spec.KEY_FIREWORK_EFFECTS, fe, t);
-					specArray.set(entity_spec.KEY_FIREWORK_ANGLED, CBoolean.get(firework.isShotAtAngle()), t);
+					specArray.set(entity_spec.KEY_FIREWORK_EFFECTS, fe, t, env);
+					specArray.set(entity_spec.KEY_FIREWORK_ANGLED, CBoolean.get(firework.isShotAtAngle()), t, env);
 					break;
 				case FOX:
 					MCFox fox = (MCFox) entity;
-					specArray.set(entity_spec.KEY_GENERIC_SITTING, CBoolean.get(fox.isSitting()), t);
-					specArray.set(entity_spec.KEY_FOX_CROUCHING, CBoolean.get(fox.isCrouching()), t);
-					specArray.set(entity_spec.KEY_FOX_TYPE, fox.getVariant().name(), t);
+					specArray.set(entity_spec.KEY_GENERIC_SITTING, CBoolean.get(fox.isSitting()), t, env);
+					specArray.set(entity_spec.KEY_FOX_CROUCHING, CBoolean.get(fox.isCrouching()), t, env);
+					specArray.set(entity_spec.KEY_FOX_TYPE, fox.getVariant().name(), t, env);
 					break;
 				case FROG:
 					MCFrog frog = (MCFrog) entity;
-					specArray.set(entity_spec.KEY_FROG_TYPE, frog.getFrogType().name(), t);
+					specArray.set(entity_spec.KEY_FROG_TYPE, frog.getFrogType().name(), t, env);
 					break;
 				case GOAT:
 					MCGoat goat = (MCGoat) entity;
-					specArray.set(entity_spec.KEY_GOAT_SCREAMING, CBoolean.get(goat.isScreaming()), t);
+					specArray.set(entity_spec.KEY_GOAT_SCREAMING, CBoolean.get(goat.isScreaming()), t, env);
 					break;
 				case HORSE:
 					MCHorse horse = (MCHorse) entity;
-					specArray.set(entity_spec.KEY_HORSE_COLOR, new CString(horse.getColor().name(), t), t);
-					specArray.set(entity_spec.KEY_HORSE_STYLE, new CString(horse.getPattern().name(), t), t);
-					specArray.set(entity_spec.KEY_HORSE_JUMP, new CDouble(horse.getJumpStrength(), t), t);
-					specArray.set(entity_spec.KEY_HORSE_DOMESTICATION, new CInt(horse.getDomestication(), t), t);
-					specArray.set(entity_spec.KEY_HORSE_MAXDOMESTICATION, new CInt(horse.getMaxDomestication(), t), t);
-					specArray.set(entity_spec.KEY_HORSE_ARMOR, ObjectGenerator.GetGenerator().item(horse.getArmor(), t), t);
-					specArray.set(entity_spec.KEY_HORSE_SADDLE, ObjectGenerator.GetGenerator().item(horse.getSaddle(), t), t);
+					specArray.set(entity_spec.KEY_HORSE_COLOR, new CString(horse.getColor().name(), t), t, env);
+					specArray.set(entity_spec.KEY_HORSE_STYLE, new CString(horse.getPattern().name(), t), t, env);
+					specArray.set(entity_spec.KEY_HORSE_JUMP, new CDouble(horse.getJumpStrength(), t), t, env);
+					specArray.set(entity_spec.KEY_HORSE_DOMESTICATION, new CInt(horse.getDomestication(), t), t, env);
+					specArray.set(entity_spec.KEY_HORSE_MAXDOMESTICATION, new CInt(horse.getMaxDomestication(), t), t, env);
+					specArray.set(entity_spec.KEY_HORSE_ARMOR, ObjectGenerator.GetGenerator().item(horse.getArmor(), t), t, env);
+					specArray.set(entity_spec.KEY_HORSE_SADDLE, ObjectGenerator.GetGenerator().item(horse.getSaddle(), t), t, env);
 					break;
 				case INTERACTION:
 					MCInteraction interaction = (MCInteraction) entity;
-					specArray.set(entity_spec.KEY_INTERACTION_WIDTH, new CDouble(interaction.getWidth(), t), t);
-					specArray.set(entity_spec.KEY_INTERACTION_HEIGHT, new CDouble(interaction.getHeight(), t), t);
-					specArray.set(entity_spec.KEY_INTERACTION_RESPONSE, CBoolean.get(interaction.isResponsive()), t);
+					specArray.set(entity_spec.KEY_INTERACTION_WIDTH, new CDouble(interaction.getWidth(), t), t, env);
+					specArray.set(entity_spec.KEY_INTERACTION_HEIGHT, new CDouble(interaction.getHeight(), t), t, env);
+					specArray.set(entity_spec.KEY_INTERACTION_RESPONSE, CBoolean.get(interaction.isResponsive()), t, env);
 					MCPreviousInteraction attack = interaction.getLastAttack();
 					if(attack != null) {
-						CArray attackArray = CArray.GetAssociativeArray(t);
-						attackArray.set("puuid", attack.getUuid().toString());
-						attackArray.set("timestamp", new CInt(attack.getTimestamp(), t), t);
-						specArray.set(entity_spec.KEY_INTERACTION_ATTACK, attackArray, t);
+						CArray attackArray = CArray.GetAssociativeArray(t, null, env);
+						attackArray.set("puuid", attack.getUuid().toString(), env);
+						attackArray.set("timestamp", new CInt(attack.getTimestamp(), t), t, env);
+						specArray.set(entity_spec.KEY_INTERACTION_ATTACK, attackArray, t, env);
 					} else {
-						specArray.set(entity_spec.KEY_INTERACTION_ATTACK, CNull.NULL, t);
+						specArray.set(entity_spec.KEY_INTERACTION_ATTACK, CNull.NULL, t, env);
 					}
 					MCPreviousInteraction interact = interaction.getLastInteraction();
 					if(interact != null) {
-						CArray interactionArray = CArray.GetAssociativeArray(t);
-						interactionArray.set("puuid", interact.getUuid().toString());
-						interactionArray.set("timestamp", new CInt(interact.getTimestamp(), t), t);
-						specArray.set(entity_spec.KEY_INTERACTION_INTERACTION, interactionArray, t);
+						CArray interactionArray = CArray.GetAssociativeArray(t, null, env);
+						interactionArray.set("puuid", interact.getUuid().toString(), env);
+						interactionArray.set("timestamp", new CInt(interact.getTimestamp(), t), t, env);
+						specArray.set(entity_spec.KEY_INTERACTION_INTERACTION, interactionArray, t, env);
 					} else {
-						specArray.set(entity_spec.KEY_INTERACTION_INTERACTION, CNull.NULL, t);
+						specArray.set(entity_spec.KEY_INTERACTION_INTERACTION, CNull.NULL, t, env);
 					}
 					break;
 				case IRON_GOLEM:
 					MCIronGolem golem = (MCIronGolem) entity;
-					specArray.set(entity_spec.KEY_IRON_GOLEM_PLAYERCREATED, CBoolean.get(golem.isPlayerCreated()), t);
+					specArray.set(entity_spec.KEY_IRON_GOLEM_PLAYERCREATED, CBoolean.get(golem.isPlayerCreated()), t, env);
 					break;
 				case ITEM_DISPLAY:
 					MCItemDisplay itemDisplay = (MCItemDisplay) entity;
-					specArray.set(KEY_DISPLAY_ITEM, ObjectGenerator.GetGenerator().item(itemDisplay.getItem(), t), t);
-					specArray.set(KEY_DISPLAY_ITEM_DISPLAY, itemDisplay.getItemModelTransform().name(), t);
+					specArray.set(KEY_DISPLAY_ITEM, ObjectGenerator.GetGenerator().item(itemDisplay.getItem(), t), t, env);
+					specArray.set(KEY_DISPLAY_ITEM_DISPLAY, itemDisplay.getItemModelTransform().name(), t, env);
 					break;
 				case ITEM_FRAME:
 				case GLOW_ITEM_FRAME:
 					MCItemFrame frame = (MCItemFrame) entity;
-					specArray.set(entity_spec.KEY_ITEM_FRAME_FIXED, CBoolean.get(frame.isFixed()), t);
-					specArray.set(entity_spec.KEY_ITEM_FRAME_ITEM, ObjectGenerator.GetGenerator().item(frame.getItem(), t), t);
-					specArray.set(entity_spec.KEY_ITEM_FRAME_ROTATION, new CString(frame.getRotation().name(), t), t);
-					specArray.set(entity_spec.KEY_ITEM_FRAME_VISIBLE, CBoolean.get(frame.isVisible()), t);
+					specArray.set(entity_spec.KEY_ITEM_FRAME_FIXED, CBoolean.get(frame.isFixed()), t, env);
+					specArray.set(entity_spec.KEY_ITEM_FRAME_ITEM, ObjectGenerator.GetGenerator().item(frame.getItem(), t), t, env);
+					specArray.set(entity_spec.KEY_ITEM_FRAME_ROTATION, new CString(frame.getRotation().name(), t), t, env);
+					specArray.set(entity_spec.KEY_ITEM_FRAME_VISIBLE, CBoolean.get(frame.isVisible()), t, env);
 					break;
 				case LIGHTNING:
 					MCLightningStrike lightning = (MCLightningStrike) entity;
-					specArray.set(entity_spec.KEY_LIGHTNING_EFFECT, CBoolean.get(lightning.isEffect()), t);
+					specArray.set(entity_spec.KEY_LIGHTNING_EFFECT, CBoolean.get(lightning.isEffect()), t, env);
 					break;
 				case LLAMA:
 				case TRADER_LLAMA:
 					MCLlama llama = (MCLlama) entity;
-					specArray.set(entity_spec.KEY_HORSE_COLOR, new CString(llama.getLlamaColor().name(), t), t);
-					specArray.set(entity_spec.KEY_HORSE_CHEST, CBoolean.get(llama.hasChest()), t);
-					specArray.set(entity_spec.KEY_HORSE_DOMESTICATION, new CInt(llama.getDomestication(), t), t);
-					specArray.set(entity_spec.KEY_HORSE_MAXDOMESTICATION, new CInt(llama.getMaxDomestication(), t), t);
-					specArray.set(entity_spec.KEY_HORSE_SADDLE, ObjectGenerator.GetGenerator().item(llama.getSaddle(), t), t);
+					specArray.set(entity_spec.KEY_HORSE_COLOR, new CString(llama.getLlamaColor().name(), t), t, env);
+					specArray.set(entity_spec.KEY_HORSE_CHEST, CBoolean.get(llama.hasChest()), t, env);
+					specArray.set(entity_spec.KEY_HORSE_DOMESTICATION, new CInt(llama.getDomestication(), t), t, env);
+					specArray.set(entity_spec.KEY_HORSE_MAXDOMESTICATION, new CInt(llama.getMaxDomestication(), t), t, env);
+					specArray.set(entity_spec.KEY_HORSE_SADDLE, ObjectGenerator.GetGenerator().item(llama.getSaddle(), t), t, env);
 					break;
 				case MAGMA_CUBE:
 				case SLIME:
 					MCSlime cube = (MCSlime) entity;
-					specArray.set(entity_spec.KEY_SLIME_SIZE, new CInt(cube.getSize(), t), t);
+					specArray.set(entity_spec.KEY_SLIME_SIZE, new CInt(cube.getSize(), t), t, env);
 					break;
 				case MANNEQUIN:
 					MCMannequin mannequin = (MCMannequin) entity;
-					specArray.set(entity_spec.KEY_MANNEQUIN_IMMOVABLE, CBoolean.get(mannequin.isImmovable()), t);
+					specArray.set(entity_spec.KEY_MANNEQUIN_IMMOVABLE, CBoolean.get(mannequin.isImmovable()), t, env);
 					break;
 				case MINECART:
 				case MINECART_FURNACE:
@@ -2195,220 +2196,220 @@ public Mixed exec(Target t, Environment environment, Mixed... args) throws Confi
 				case MINECART_MOB_SPAWNER:
 				case MINECART_TNT:
 					MCMinecart minecart = (MCMinecart) entity;
-					specArray.set(entity_spec.KEY_MINECART_BLOCK, new CString(minecart.getDisplayBlock().getMaterial().getName(), t), t);
-					specArray.set(entity_spec.KEY_MINECART_OFFSET, new CInt(minecart.getDisplayBlockOffset(), t), t);
+					specArray.set(entity_spec.KEY_MINECART_BLOCK, new CString(minecart.getDisplayBlock().getMaterial().getName(), t), t, env);
+					specArray.set(entity_spec.KEY_MINECART_OFFSET, new CInt(minecart.getDisplayBlockOffset(), t), t, env);
 					break;
 				case MINECART_COMMAND:
 					MCCommandMinecart commandminecart = (MCCommandMinecart) entity;
-					specArray.set(entity_spec.KEY_MINECART_COMMAND_COMMAND, new CString(commandminecart.getCommand(), t), t);
-					specArray.set(entity_spec.KEY_MINECART_COMMAND_CUSTOMNAME, new CString(commandminecart.getName(), t), t);
-					specArray.set(entity_spec.KEY_MINECART_BLOCK, new CString(commandminecart.getDisplayBlock().getMaterial().getName(), t), t);
-					specArray.set(entity_spec.KEY_MINECART_OFFSET, new CInt(commandminecart.getDisplayBlockOffset(), t), t);
+					specArray.set(entity_spec.KEY_MINECART_COMMAND_COMMAND, new CString(commandminecart.getCommand(), t), t, env);
+					specArray.set(entity_spec.KEY_MINECART_COMMAND_CUSTOMNAME, new CString(commandminecart.getName(), t), t, env);
+					specArray.set(entity_spec.KEY_MINECART_BLOCK, new CString(commandminecart.getDisplayBlock().getMaterial().getName(), t), t, env);
+					specArray.set(entity_spec.KEY_MINECART_OFFSET, new CInt(commandminecart.getDisplayBlockOffset(), t), t, env);
 					break;
 				case MUSHROOM_COW:
 					MCMushroomCow cow = (MCMushroomCow) entity;
-					specArray.set(entity_spec.KEY_MUSHROOM_COW_TYPE, cow.getVariant().name(), t);
+					specArray.set(entity_spec.KEY_MUSHROOM_COW_TYPE, cow.getVariant().name(), t, env);
 					break;
 				case OMINOUS_ITEM_SPAWNER:
 					MCOminousItemSpawner spawner = (MCOminousItemSpawner) entity;
-					specArray.set(entity_spec.KEY_OMINOUS_SPAWNER_ITEM, ObjectGenerator.GetGenerator().item(spawner.getItem(), t), t);
-					specArray.set(entity_spec.KEY_OMINOUS_SPAWNER_DELAY, new CInt(spawner.getDelay(), t), t);
+					specArray.set(entity_spec.KEY_OMINOUS_SPAWNER_ITEM, ObjectGenerator.GetGenerator().item(spawner.getItem(), t), t, env);
+					specArray.set(entity_spec.KEY_OMINOUS_SPAWNER_DELAY, new CInt(spawner.getDelay(), t), t, env);
 					break;
 				case PAINTING:
 					MCPainting painting = (MCPainting) entity;
-					specArray.set(entity_spec.KEY_PAINTING_ART, new CString(painting.getArt().name(), t), t);
+					specArray.set(entity_spec.KEY_PAINTING_ART, new CString(painting.getArt().name(), t), t, env);
 					break;
 				case PANDA:
 					MCPanda panda = (MCPanda) entity;
-					specArray.set(entity_spec.KEY_PANDA_MAINGENE, new CString(panda.getMainGene().name(), t), t);
-					specArray.set(entity_spec.KEY_PANDA_HIDDENGENE, new CString(panda.getHiddenGene().name(), t), t);
+					specArray.set(entity_spec.KEY_PANDA_MAINGENE, new CString(panda.getMainGene().name(), t), t, env);
+					specArray.set(entity_spec.KEY_PANDA_HIDDENGENE, new CString(panda.getHiddenGene().name(), t), t, env);
 					if(Static.getServer().getMinecraftVersion().gte(MCVersion.MC1_19)) {
-						specArray.set(entity_spec.KEY_PANDA_EATING, CBoolean.get(panda.isEating()), t);
-						specArray.set(entity_spec.KEY_PANDA_ONBACK, CBoolean.get(panda.isOnBack()), t);
-						specArray.set(entity_spec.KEY_PANDA_ROLLING, CBoolean.get(panda.isRolling()), t);
-						specArray.set(entity_spec.KEY_PANDA_SNEEZING, CBoolean.get(panda.isSneezing()), t);
+						specArray.set(entity_spec.KEY_PANDA_EATING, CBoolean.get(panda.isEating()), t, env);
+						specArray.set(entity_spec.KEY_PANDA_ONBACK, CBoolean.get(panda.isOnBack()), t, env);
+						specArray.set(entity_spec.KEY_PANDA_ROLLING, CBoolean.get(panda.isRolling()), t, env);
+						specArray.set(entity_spec.KEY_PANDA_SNEEZING, CBoolean.get(panda.isSneezing()), t, env);
 					}
 					break;
 				case PARROT:
 					MCParrot parrot = (MCParrot) entity;
-					specArray.set(entity_spec.KEY_GENERIC_SITTING, CBoolean.get(parrot.isSitting()), t);
-					specArray.set(entity_spec.KEY_PARROT_TYPE, new CString(parrot.getVariant().name(), t), t);
+					specArray.set(entity_spec.KEY_GENERIC_SITTING, CBoolean.get(parrot.isSitting()), t, env);
+					specArray.set(entity_spec.KEY_PARROT_TYPE, new CString(parrot.getVariant().name(), t), t, env);
 					break;
 				case PHANTOM:
 					MCPhantom phantom = (MCPhantom) entity;
-					specArray.set(entity_spec.KEY_PHANTOM_SIZE, new CInt(phantom.getSize(), t), t);
+					specArray.set(entity_spec.KEY_PHANTOM_SIZE, new CInt(phantom.getSize(), t), t, env);
 					break;
 				case PIG:
 					MCPig pig = (MCPig) entity;
-					specArray.set(entity_spec.KEY_STEERABLE_SADDLED, CBoolean.get(pig.isSaddled()), t);
+					specArray.set(entity_spec.KEY_STEERABLE_SADDLED, CBoolean.get(pig.isSaddled()), t, env);
 					break;
 				case PIGLIN:
 					MCPiglin piglin = (MCPiglin) entity;
-					specArray.set(entity_spec.KEY_GENERIC_BABY, CBoolean.get(piglin.isBaby()), t);
-					specArray.set(entity_spec.KEY_PIGLIN_ZOMBIFICATION_IMMUNE, CBoolean.get(piglin.isImmuneToZombification()), t);
+					specArray.set(entity_spec.KEY_GENERIC_BABY, CBoolean.get(piglin.isBaby()), t, env);
+					specArray.set(entity_spec.KEY_PIGLIN_ZOMBIFICATION_IMMUNE, CBoolean.get(piglin.isImmuneToZombification()), t, env);
 					break;
 				case PRIMED_TNT:
 					MCTNT tnt = (MCTNT) entity;
-					specArray.set(entity_spec.KEY_PRIMED_TNT_FUSETICKS, new CInt(tnt.getFuseTicks(), t), t);
+					specArray.set(entity_spec.KEY_PRIMED_TNT_FUSETICKS, new CInt(tnt.getFuseTicks(), t), t, env);
 					MCEntity source = tnt.getSource();
 					if(source != null) {
-						specArray.set(entity_spec.KEY_PRIMED_TNT_SOURCE, new CString(source.getUniqueId().toString(), t), t);
+						specArray.set(entity_spec.KEY_PRIMED_TNT_SOURCE, new CString(source.getUniqueId().toString(), t), t, env);
 					} else {
-						specArray.set(entity_spec.KEY_PRIMED_TNT_SOURCE, CNull.NULL, t);
+						specArray.set(entity_spec.KEY_PRIMED_TNT_SOURCE, CNull.NULL, t, env);
 					}
 					break;
 				case PUFFERFISH:
 					MCPufferfish puffer = (MCPufferfish) entity;
-					specArray.set(entity_spec.KEY_PUFFERFISH_SIZE, new CInt(puffer.getPuffState(), t), t);
+					specArray.set(entity_spec.KEY_PUFFERFISH_SIZE, new CInt(puffer.getPuffState(), t), t, env);
 					break;
 				case RABBIT:
 					MCRabbit rabbit = (MCRabbit) entity;
-					specArray.set(entity_spec.KEY_RABBIT_TYPE, new CString(rabbit.getRabbitType().name(), t), t);
+					specArray.set(entity_spec.KEY_RABBIT_TYPE, new CString(rabbit.getRabbitType().name(), t), t, env);
 					break;
 				case SALMON:
 					MCSalmon salmon = (MCSalmon) entity;
 					if(Static.getServer().getMinecraftVersion().gte(MCVersion.MC1_21_3)) {
-						specArray.set(entity_spec.KEY_SALMON_TYPE, new CString(salmon.getVariant().name(), t), t);
+						specArray.set(entity_spec.KEY_SALMON_TYPE, new CString(salmon.getVariant().name(), t), t, env);
 					}
 					break;
 				case SHEEP:
 					MCSheep sheep = (MCSheep) entity;
-					specArray.set(entity_spec.KEY_SHEEP_COLOR, new CString(sheep.getColor().name(), t), t);
-					specArray.set(entity_spec.KEY_SHEEP_SHEARED, CBoolean.get(sheep.isSheared()), t);
+					specArray.set(entity_spec.KEY_SHEEP_COLOR, new CString(sheep.getColor().name(), t), t, env);
+					specArray.set(entity_spec.KEY_SHEEP_SHEARED, CBoolean.get(sheep.isSheared()), t, env);
 					break;
 				case SHULKER:
 					MCShulker shulker = (MCShulker) entity;
 					MCDyeColor shulkerColor = shulker.getColor();
 					if(shulkerColor == null) {
-						specArray.set(entity_spec.KEY_SHULKER_COLOR, CNull.NULL, t);
+						specArray.set(entity_spec.KEY_SHULKER_COLOR, CNull.NULL, t, env);
 					} else {
-						specArray.set(entity_spec.KEY_SHULKER_COLOR, new CString(shulker.getColor().name(), t), t);
+						specArray.set(entity_spec.KEY_SHULKER_COLOR, new CString(shulker.getColor().name(), t), t, env);
 					}
 					break;
 				case SHULKER_BULLET:
 					MCShulkerBullet bullet = (MCShulkerBullet) entity;
 					MCEntity target = bullet.getTarget();
 					if(target == null) {
-						specArray.set(entity_spec.KEY_SHULKERBULLET_TARGET, CNull.NULL, t);
+						specArray.set(entity_spec.KEY_SHULKERBULLET_TARGET, CNull.NULL, t, env);
 					} else {
-						specArray.set(entity_spec.KEY_SHULKERBULLET_TARGET, new CString(target.getUniqueId().toString(), t), t);
+						specArray.set(entity_spec.KEY_SHULKERBULLET_TARGET, new CString(target.getUniqueId().toString(), t), t, env);
 					}
 					break;
 				case SKELETON_HORSE:
 				case ZOMBIE_HORSE:
 					MCAbstractHorse undeadhorse = (MCAbstractHorse) entity;
-					specArray.set(entity_spec.KEY_HORSE_JUMP, new CDouble(undeadhorse.getJumpStrength(), t), t);
-					specArray.set(entity_spec.KEY_HORSE_DOMESTICATION, new CInt(undeadhorse.getDomestication(), t), t);
-					specArray.set(entity_spec.KEY_HORSE_MAXDOMESTICATION, new CInt(undeadhorse.getMaxDomestication(), t), t);
-					specArray.set(entity_spec.KEY_HORSE_SADDLE, ObjectGenerator.GetGenerator().item(undeadhorse.getSaddle(), t), t);
+					specArray.set(entity_spec.KEY_HORSE_JUMP, new CDouble(undeadhorse.getJumpStrength(), t), t, env);
+					specArray.set(entity_spec.KEY_HORSE_DOMESTICATION, new CInt(undeadhorse.getDomestication(), t), t, env);
+					specArray.set(entity_spec.KEY_HORSE_MAXDOMESTICATION, new CInt(undeadhorse.getMaxDomestication(), t), t, env);
+					specArray.set(entity_spec.KEY_HORSE_SADDLE, ObjectGenerator.GetGenerator().item(undeadhorse.getSaddle(), t), t, env);
 					break;
 				case SNOWMAN:
 					MCSnowman snowman = (MCSnowman) entity;
-					specArray.set(entity_spec.KEY_SNOWMAN_DERP, CBoolean.GenerateCBoolean(snowman.isDerp(), t), t);
+					specArray.set(entity_spec.KEY_SNOWMAN_DERP, CBoolean.GenerateCBoolean(snowman.isDerp(), t), t, env);
 					break;
 				case SPECTRAL_ARROW:
 					MCSpectralArrow spectral = (MCSpectralArrow) entity;
-					specArray.set(entity_spec.KEY_ARROW_CRITICAL, CBoolean.get(spectral.isCritical()), t);
-					specArray.set(entity_spec.KEY_ARROW_KNOCKBACK, new CInt(spectral.getKnockbackStrength(), t), t);
-					specArray.set(entity_spec.KEY_ARROW_DAMAGE, new CDouble(spectral.getDamage(), t), t);
-					specArray.set(entity_spec.KEY_SPECTRAL_ARROW_GLOWING_TICKS, new CInt(spectral.getGlowingTicks(), t), t);
+					specArray.set(entity_spec.KEY_ARROW_CRITICAL, CBoolean.get(spectral.isCritical()), t, env);
+					specArray.set(entity_spec.KEY_ARROW_KNOCKBACK, new CInt(spectral.getKnockbackStrength(), t), t, env);
+					specArray.set(entity_spec.KEY_ARROW_DAMAGE, new CDouble(spectral.getDamage(), t), t, env);
+					specArray.set(entity_spec.KEY_SPECTRAL_ARROW_GLOWING_TICKS, new CInt(spectral.getGlowingTicks(), t), t, env);
 					break;
 				case LINGERING_POTION:
 				case SPLASH_POTION:
 					MCThrownPotion potion = (MCThrownPotion) entity;
-					specArray.set(entity_spec.KEY_SPLASH_POTION_ITEM, ObjectGenerator.GetGenerator().item(potion.getItem(), t), t);
+					specArray.set(entity_spec.KEY_SPLASH_POTION_ITEM, ObjectGenerator.GetGenerator().item(potion.getItem(), t), t, env);
 					break;
 				case STRIDER:
 					MCStrider strider = (MCStrider) entity;
-					specArray.set(entity_spec.KEY_STEERABLE_SADDLED, CBoolean.get(strider.isSaddled()), t);
+					specArray.set(entity_spec.KEY_STEERABLE_SADDLED, CBoolean.get(strider.isSaddled()), t, env);
 					break;
 				case TEXT_DISPLAY:
 					MCTextDisplay tDisplay = (MCTextDisplay) entity;
-					specArray.set(entity_spec.KEY_DISPLAY_TEXT, tDisplay.getText());
-					specArray.set(entity_spec.KEY_DISPLAY_TEXT_ALIGNMENT, tDisplay.getAlignment().name());
-					specArray.set(entity_spec.KEY_DISPLAY_TEXT_LINE_WIDTH, new CInt(tDisplay.getLineWidth(), t), t);
-					specArray.set(entity_spec.KEY_DISPLAY_TEXT_SEE_THROUGH, CBoolean.get(tDisplay.isVisibleThroughBlocks()), t);
-					specArray.set(entity_spec.KEY_DISPLAY_TEXT_SHADOW, CBoolean.get(tDisplay.hasShadow()), t);
+					specArray.set(entity_spec.KEY_DISPLAY_TEXT, tDisplay.getText(), env);
+					specArray.set(entity_spec.KEY_DISPLAY_TEXT_ALIGNMENT, tDisplay.getAlignment().name(), env);
+					specArray.set(entity_spec.KEY_DISPLAY_TEXT_LINE_WIDTH, new CInt(tDisplay.getLineWidth(), t), t, env);
+					specArray.set(entity_spec.KEY_DISPLAY_TEXT_SEE_THROUGH, CBoolean.get(tDisplay.isVisibleThroughBlocks()), t, env);
+					specArray.set(entity_spec.KEY_DISPLAY_TEXT_SHADOW, CBoolean.get(tDisplay.hasShadow()), t, env);
 					MCColor color = tDisplay.getBackgroundColor();
 					if(color == null) {
-						specArray.set(entity_spec.KEY_DISPLAY_TEXT_BACKGROUND_COLOR, CNull.NULL, t);
+						specArray.set(entity_spec.KEY_DISPLAY_TEXT_BACKGROUND_COLOR, CNull.NULL, t, env);
 					} else {
 						specArray.set(entity_spec.KEY_DISPLAY_TEXT_BACKGROUND_COLOR,
-								ObjectGenerator.GetGenerator().transparentColor(color, t), t);
+								ObjectGenerator.GetGenerator().transparentColor(color, t), t, env);
 					}
 					long opacity = tDisplay.getOpacity();
 					if(opacity < 0) {
 						opacity += 256;
 					}
-					specArray.set(entity_spec.KEY_DISPLAY_TEXT_OPACITY, new CInt(opacity, t), t);
+					specArray.set(entity_spec.KEY_DISPLAY_TEXT_OPACITY, new CInt(opacity, t), t, env);
 					break;
 				case TRIDENT:
 					MCTrident trident = (MCTrident) entity;
-					specArray.set(entity_spec.KEY_ARROW_CRITICAL, CBoolean.get(trident.isCritical()), t);
-					specArray.set(entity_spec.KEY_ARROW_KNOCKBACK, new CInt(trident.getKnockbackStrength(), t), t);
-					specArray.set(entity_spec.KEY_ARROW_DAMAGE, new CDouble(trident.getDamage(), t), t);
+					specArray.set(entity_spec.KEY_ARROW_CRITICAL, CBoolean.get(trident.isCritical()), t, env);
+					specArray.set(entity_spec.KEY_ARROW_KNOCKBACK, new CInt(trident.getKnockbackStrength(), t), t, env);
+					specArray.set(entity_spec.KEY_ARROW_DAMAGE, new CDouble(trident.getDamage(), t), t, env);
 					break;
 				case TROPICAL_FISH:
 					MCTropicalFish fish = (MCTropicalFish) entity;
-					specArray.set(entity_spec.KEY_TROPICALFISH_COLOR, new CString(fish.getBodyColor().name(), t), t);
-					specArray.set(entity_spec.KEY_TROPICALFISH_PATTERN, new CString(fish.getPattern().name(), t), t);
-					specArray.set(entity_spec.KEY_TROPICALFISH_PATTERNCOLOR, new CString(fish.getPatternColor().name(), t), t);
+					specArray.set(entity_spec.KEY_TROPICALFISH_COLOR, new CString(fish.getBodyColor().name(), t), t, env);
+					specArray.set(entity_spec.KEY_TROPICALFISH_PATTERN, new CString(fish.getPattern().name(), t), t, env);
+					specArray.set(entity_spec.KEY_TROPICALFISH_PATTERNCOLOR, new CString(fish.getPatternColor().name(), t), t, env);
 					break;
 				case VEX:
 					MCVex vex = (MCVex) entity;
-					specArray.set(entity_spec.KEY_VEX_CHARGING, CBoolean.get(vex.isCharging()), t);
+					specArray.set(entity_spec.KEY_VEX_CHARGING, CBoolean.get(vex.isCharging()), t, env);
 					break;
 				case VILLAGER:
 					MCVillager villager = (MCVillager) entity;
-					specArray.set(entity_spec.KEY_VILLAGER_PROFESSION, new CString(villager.getProfession().name(), t), t);
-					specArray.set(entity_spec.KEY_VILLAGER_LEVEL, new CInt(villager.getLevel(), t), t);
-					specArray.set(entity_spec.KEY_VILLAGER_EXPERIENCE, new CInt(villager.getExperience(), t), t);
+					specArray.set(entity_spec.KEY_VILLAGER_PROFESSION, new CString(villager.getProfession().name(), t), t, env);
+					specArray.set(entity_spec.KEY_VILLAGER_LEVEL, new CInt(villager.getLevel(), t), t, env);
+					specArray.set(entity_spec.KEY_VILLAGER_EXPERIENCE, new CInt(villager.getExperience(), t), t, env);
 					break;
 				case WITHER_SKULL:
 					MCWitherSkull skull = (MCWitherSkull) entity;
-					specArray.set(entity_spec.KEY_WITHER_SKULL_CHARGED, CBoolean.get(skull.isCharged()), t);
-					specArray.set(entity_spec.KEY_FIREBALL_DIRECTION, ObjectGenerator.GetGenerator().vector(skull.getDirection(), t), t);
+					specArray.set(entity_spec.KEY_WITHER_SKULL_CHARGED, CBoolean.get(skull.isCharged()), t, env);
+					specArray.set(entity_spec.KEY_FIREBALL_DIRECTION, ObjectGenerator.GetGenerator().vector(skull.getDirection(), t), t, env);
 					break;
 				case WOLF:
 					MCWolf wolf = (MCWolf) entity;
-					specArray.set(entity_spec.KEY_WOLF_ANGRY, CBoolean.get(wolf.isAngry()), t);
-					specArray.set(entity_spec.KEY_WOLF_COLOR, new CString(wolf.getCollarColor().name(), t), t);
-					specArray.set(entity_spec.KEY_GENERIC_SITTING, CBoolean.get(wolf.isSitting()), t);
+					specArray.set(entity_spec.KEY_WOLF_ANGRY, CBoolean.get(wolf.isAngry()), t, env);
+					specArray.set(entity_spec.KEY_WOLF_COLOR, new CString(wolf.getCollarColor().name(), t), t, env);
+					specArray.set(entity_spec.KEY_GENERIC_SITTING, CBoolean.get(wolf.isSitting()), t, env);
 					if(Static.getServer().getMinecraftVersion().gte(MCVersion.MC1_19)) {
-						specArray.set(entity_spec.KEY_WOLF_INTERESTED, CBoolean.get(wolf.isInterested()), t);
+						specArray.set(entity_spec.KEY_WOLF_INTERESTED, CBoolean.get(wolf.isInterested()), t, env);
 						if(Static.getServer().getMinecraftVersion().gte(MCVersion.MC1_20_6)) {
-							specArray.set(entity_spec.KEY_WOLF_TYPE, new CString(wolf.getWolfVariant().name(), t), t);
+							specArray.set(entity_spec.KEY_WOLF_TYPE, new CString(wolf.getWolfVariant().name(), t), t, env);
 						}
 					}
 					break;
 				case ZOGLIN:
 					MCZoglin zoglin = (MCZoglin) entity;
-					specArray.set(entity_spec.KEY_GENERIC_BABY, CBoolean.get(zoglin.isBaby()), t);
+					specArray.set(entity_spec.KEY_GENERIC_BABY, CBoolean.get(zoglin.isBaby()), t, env);
 					break;
 				case ZOMBIE:
 				case DROWNED:
 				case HUSK:
 					MCZombie zombie = (MCZombie) entity;
-					specArray.set(entity_spec.KEY_GENERIC_BABY, CBoolean.get(zombie.isBaby()), t);
+					specArray.set(entity_spec.KEY_GENERIC_BABY, CBoolean.get(zombie.isBaby()), t, env);
 					if(Static.getServer().getMinecraftVersion().gte(MCVersion.MC1_19)) {
-						specArray.set(entity_spec.KEY_ZOMBIE_BREAK_DOORS, CBoolean.get(zombie.canBreakDoors()), t);
+						specArray.set(entity_spec.KEY_ZOMBIE_BREAK_DOORS, CBoolean.get(zombie.canBreakDoors()), t, env);
 					}
 					break;
 				case ZOMBIE_VILLAGER:
 					MCZombieVillager zombievillager = (MCZombieVillager) entity;
-					specArray.set(entity_spec.KEY_GENERIC_BABY, CBoolean.get(zombievillager.isBaby()), t);
-					specArray.set(entity_spec.KEY_VILLAGER_PROFESSION, new CString(zombievillager.getProfession().name(), t), t);
+					specArray.set(entity_spec.KEY_GENERIC_BABY, CBoolean.get(zombievillager.isBaby()), t, env);
+					specArray.set(entity_spec.KEY_VILLAGER_PROFESSION, new CString(zombievillager.getProfession().name(), t), t, env);
 					if(Static.getServer().getMinecraftVersion().gte(MCVersion.MC1_19)) {
-						specArray.set(entity_spec.KEY_ZOMBIE_BREAK_DOORS, CBoolean.get(zombievillager.canBreakDoors()), t);
+						specArray.set(entity_spec.KEY_ZOMBIE_BREAK_DOORS, CBoolean.get(zombievillager.canBreakDoors()), t, env);
 					}
 					break;
 				case ZOMBIFIED_PIGLIN:
 					MCPigZombie pigZombie = (MCPigZombie) entity;
-					specArray.set(entity_spec.KEY_ZOMBIFIED_PIGLIN_ANGRY, CBoolean.get(pigZombie.isAngry()), t);
-					specArray.set(entity_spec.KEY_ZOMBIFIED_PIGLIN_ANGER, new CInt(pigZombie.getAnger(), t), t);
-					specArray.set(entity_spec.KEY_GENERIC_BABY, CBoolean.get(pigZombie.isBaby()), t);
+					specArray.set(entity_spec.KEY_ZOMBIFIED_PIGLIN_ANGRY, CBoolean.get(pigZombie.isAngry()), t, env);
+					specArray.set(entity_spec.KEY_ZOMBIFIED_PIGLIN_ANGER, new CInt(pigZombie.getAnger(), t), t, env);
+					specArray.set(entity_spec.KEY_GENERIC_BABY, CBoolean.get(pigZombie.isBaby()), t, env);
 					if(Static.getServer().getMinecraftVersion().gte(MCVersion.MC1_19)) {
-						specArray.set(entity_spec.KEY_ZOMBIE_BREAK_DOORS, CBoolean.get(pigZombie.canBreakDoors()), t);
+						specArray.set(entity_spec.KEY_ZOMBIE_BREAK_DOORS, CBoolean.get(pigZombie.canBreakDoors()), t, env);
 					}
 					break;
 			}
@@ -2594,9 +2595,9 @@ private static void throwException(String index, Target t) throws ConfigRuntimeE
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			MCEntity entity = Static.getEntity(args[0], t);
-			CArray specArray = ArgumentValidation.getArray(args[1], t);
+			CArray specArray = ArgumentValidation.getArray(args[1], t, env);
 
 			switch(entity.getType().getAbstracted()) {
 				case AREA_EFFECT_CLOUD:
@@ -2604,8 +2605,8 @@ public Mixed exec(Target t, Environment environment, Mixed... args) throws Confi
 					for(String index : specArray.stringKeySet()) {
 						switch(index.toLowerCase()) {
 							case entity_spec.KEY_AREAEFFECTCLOUD_COLOR:
-								Mixed colorMixed = specArray.get(index, t);
-								if(colorMixed.isInstanceOf(CArray.TYPE)) {
+								Mixed colorMixed = specArray.get(index, t, env);
+								if(colorMixed.isInstanceOf(CArray.TYPE, null, env)) {
 									CArray color = (CArray) colorMixed;
 									cloud.setColor(ObjectGenerator.GetGenerator().color(color, t));
 								} else {
@@ -2613,25 +2614,25 @@ public Mixed exec(Target t, Environment environment, Mixed... args) throws Confi
 								}
 								break;
 							case entity_spec.KEY_AREAEFFECTCLOUD_DURATION:
-								cloud.setDuration(ArgumentValidation.getInt32(specArray.get(index, t), t));
+								cloud.setDuration(ArgumentValidation.getInt32(specArray.get(index, t, env), t, env));
 								break;
 							case entity_spec.KEY_AREAEFFECTCLOUD_DURATIONONUSE:
-								cloud.setDurationOnUse(ArgumentValidation.getInt32(specArray.get(index, t), t));
+								cloud.setDurationOnUse(ArgumentValidation.getInt32(specArray.get(index, t, env), t, env));
 								break;
 							case entity_spec.KEY_AREAEFFECTCLOUD_PARTICLE:
-								Mixed particleMixed = specArray.get(index, t);
-								if(particleMixed.isInstanceOf(CArray.TYPE)) {
+								Mixed particleMixed = specArray.get(index, t, env);
+								if(particleMixed.isInstanceOf(CArray.TYPE, null, env)) {
 									CArray pa = (CArray) particleMixed;
 									MCParticle p;
 									try {
-										p = MCParticle.valueOf(pa.get("particle", t).val().toUpperCase());
+										p = MCParticle.valueOf(pa.get("particle", t, env).val().toUpperCase());
 									} catch(IllegalArgumentException ex) {
 										throw new CREIllegalArgumentException("Particle name '"
-												+ pa.get("particle", t).val() + "' is invalid.", t);
+												+ pa.get("particle", t, env).val() + "' is invalid.", t);
 									}
 									try {
 										cloud.setParticle(p, ObjectGenerator.GetGenerator().particleData(p,
-												cloud.getLocation(), pa, t));
+												cloud.getLocation(), pa, t, env));
 									} catch(IllegalArgumentException ex) {
 										throw new CREFormatException("Invalid particle data for " + p.name(), t);
 									}
@@ -2645,34 +2646,34 @@ public Mixed exec(Target t, Environment environment, Mixed... args) throws Confi
 								}
 								break;
 							case entity_spec.KEY_AREAEFFECTCLOUD_POTIONMETA:
-								Mixed c = specArray.get(index, t);
-								if(c.isInstanceOf(CArray.TYPE)) {
+								Mixed c = specArray.get(index, t, env);
+								if(c.isInstanceOf(CArray.TYPE, null, env)) {
 									CArray meta = (CArray) c;
 									if(meta.containsKey("potiontype")
 											&& Static.getServer().getMinecraftVersion().gte(MCVersion.MC1_20_6)) {
-										Mixed potiontype = meta.get("potiontype", t);
+										Mixed potiontype = meta.get("potiontype", t, env);
 										if(potiontype instanceof CNull) {
 											cloud.setBasePotionType(null);
 										} else {
 											cloud.setBasePotionType(MCPotionType.valueOf(potiontype.val()));
 										}
 									} else if(meta.containsKey("base")) {
-										Mixed base = meta.get("base", t);
-										if(base.isInstanceOf(CArray.TYPE)) {
+										Mixed base = meta.get("base", t, env);
+										if(base.isInstanceOf(CArray.TYPE, null, env)) {
 											if(Static.getServer().getMinecraftVersion().gte(MCVersion.MC1_20_6)) {
 												MCPotionType type = ObjectGenerator.GetGenerator().legacyPotionData((CArray) base, t);
 												cloud.setBasePotionType(type);
 											} else {
-												MCPotionData pd = ObjectGenerator.GetGenerator().potionData((CArray) base, t);
+												MCPotionData pd = ObjectGenerator.GetGenerator().potionData((CArray) base, t, env);
 												cloud.setBasePotionData(pd);
 											}
 										}
 									}
 									if(meta.containsKey("potions")) {
 										cloud.clearCustomEffects();
-										Mixed potions = meta.get("potions", t);
-										if(potions.isInstanceOf(CArray.TYPE)) {
-											List<MCLivingEntity.MCEffect> list = ObjectGenerator.GetGenerator().potions((CArray) potions, t);
+										Mixed potions = meta.get("potions", t, env);
+										if(potions.isInstanceOf(CArray.TYPE, null, env)) {
+											List<MCLivingEntity.MCEffect> list = ObjectGenerator.GetGenerator().potions((CArray) potions, t, env);
 											for(MCLivingEntity.MCEffect effect : list) {
 												cloud.addCustomEffect(effect);
 											}
@@ -2683,23 +2684,23 @@ public Mixed exec(Target t, Environment environment, Mixed... args) throws Confi
 								}
 								break;
 							case entity_spec.KEY_AREAEFFECTCLOUD_RADIUS:
-								cloud.setRadius(ArgumentValidation.getDouble32(specArray.get(index, t), t));
+								cloud.setRadius(ArgumentValidation.getDouble32(specArray.get(index, t, env), t, env));
 								break;
 							case entity_spec.KEY_AREAEFFECTCLOUD_RADIUSONUSE:
-								cloud.setRadiusOnUse(ArgumentValidation.getDouble32(specArray.get(index, t), t));
+								cloud.setRadiusOnUse(ArgumentValidation.getDouble32(specArray.get(index, t, env), t, env));
 								break;
 							case entity_spec.KEY_AREAEFFECTCLOUD_RADIUSPERTICK:
-								cloud.setRadiusPerTick(ArgumentValidation.getDouble32(specArray.get(index, t), t));
+								cloud.setRadiusPerTick(ArgumentValidation.getDouble32(specArray.get(index, t, env), t, env));
 								break;
 							case entity_spec.KEY_AREAEFFECTCLOUD_REAPPLICATIONDELAY:
-								cloud.setReapplicationDelay(ArgumentValidation.getInt32(specArray.get(index, t), t));
+								cloud.setReapplicationDelay(ArgumentValidation.getInt32(specArray.get(index, t, env), t, env));
 								break;
 							case entity_spec.KEY_AREAEFFECTCLOUD_SOURCE:
-								Mixed cloudSource = specArray.get(index, t);
+								Mixed cloudSource = specArray.get(index, t, env);
 								if(cloudSource instanceof CNull) {
 									cloud.setSource(null);
-								} else if(cloudSource.isInstanceOf(CArray.TYPE)) {
-									MCBlock b = ObjectGenerator.GetGenerator().location(cloudSource, cloud.getWorld(), t).getBlock();
+								} else if(cloudSource.isInstanceOf(CArray.TYPE, null, env)) {
+									MCBlock b = ObjectGenerator.GetGenerator().location(cloudSource, cloud.getWorld(), t, env).getBlock();
 									if(b.isDispenser()) {
 										cloud.setSource(b.getDispenser().getBlockProjectileSource());
 									} else {
@@ -2710,7 +2711,7 @@ public Mixed exec(Target t, Environment environment, Mixed... args) throws Confi
 								}
 								break;
 							case entity_spec.KEY_AREAEFFECTCLOUD_WAITTIME:
-								cloud.setWaitTime(ArgumentValidation.getInt32(specArray.get(index, t), t));
+								cloud.setWaitTime(ArgumentValidation.getInt32(specArray.get(index, t, env), t, env));
 								break;
 							default:
 								throwException(index, t);
@@ -2722,10 +2723,10 @@ public Mixed exec(Target t, Environment environment, Mixed... args) throws Confi
 					for(String index : specArray.stringKeySet()) {
 						switch(index.toLowerCase()) {
 							case entity_spec.KEY_ARROW_CRITICAL:
-								arrow.setCritical(ArgumentValidation.getBoolean(specArray.get(index, t), t));
+								arrow.setCritical(ArgumentValidation.getBoolean(specArray.get(index, t, env), t, env));
 								break;
 							case entity_spec.KEY_ARROW_KNOCKBACK:
-								int k = ArgumentValidation.getInt32(specArray.get(index, t), t);
+								int k = ArgumentValidation.getInt32(specArray.get(index, t, env), t, env);
 								if(k < 0) {
 									throw new CRERangeException("Knockback can not be negative.", t);
 								} else {
@@ -2733,14 +2734,14 @@ public Mixed exec(Target t, Environment environment, Mixed... args) throws Confi
 								}
 								break;
 							case entity_spec.KEY_ARROW_DAMAGE:
-								double d = ArgumentValidation.getDouble(specArray.get(index, t), t);
+								double d = ArgumentValidation.getDouble(specArray.get(index, t, env), t, env);
 								if(d < 0) {
 									throw new CRERangeException("Damage cannot be negative.", t);
 								}
 								arrow.setDamage(d);
 								break;
 							case entity_spec.KEY_ARROW_PIERCE_LEVEL:
-								int level = ArgumentValidation.getInt32(specArray.get(index, t), t);
+								int level = ArgumentValidation.getInt32(specArray.get(index, t, env), t, env);
 								if(level < 0 || level > 127) {
 									throw new CRERangeException("Pierce level must be 0 to 127.", t);
 								}
@@ -2748,41 +2749,41 @@ public Mixed exec(Target t, Environment environment, Mixed... args) throws Confi
 								break;
 							case entity_spec.KEY_ARROW_PICKUP:
 								try {
-									arrow.setPickupStatus(MCArrow.PickupStatus.valueOf(specArray.get(index, t).val()));
+									arrow.setPickupStatus(MCArrow.PickupStatus.valueOf(specArray.get(index, t, env).val()));
 								} catch(IllegalArgumentException ex) {
 									throw new CREFormatException("Invalid arrow pickup status: "
-											+ specArray.get(index, t).val(), t);
+											+ specArray.get(index, t, env).val(), t);
 								}
 								break;
 							case entity_spec.KEY_ARROW_POTIONMETA:
-								Mixed c = specArray.get(index, t);
-								if(c.isInstanceOf(CArray.TYPE)) {
+								Mixed c = specArray.get(index, t, env);
+								if(c.isInstanceOf(CArray.TYPE, null, env)) {
 									CArray meta = (CArray) c;
 									if(meta.containsKey("potiontype")
 											&& Static.getServer().getMinecraftVersion().gte(MCVersion.MC1_20_6)) {
-										Mixed potiontype = meta.get("potiontype", t);
+										Mixed potiontype = meta.get("potiontype", t, env);
 										if(potiontype instanceof CNull) {
 											arrow.setBasePotionType(null);
 										} else {
 											arrow.setBasePotionType(MCPotionType.valueOf(potiontype.val()));
 										}
 									} else if(meta.containsKey("base")) {
-										Mixed base = meta.get("base", t);
-										if(base.isInstanceOf(CArray.TYPE)) {
+										Mixed base = meta.get("base", t, env);
+										if(base.isInstanceOf(CArray.TYPE, null, env)) {
 											if(Static.getServer().getMinecraftVersion().gte(MCVersion.MC1_20_6)) {
 												MCPotionType type = ObjectGenerator.GetGenerator().legacyPotionData((CArray) base, t);
 												arrow.setBasePotionType(type);
 											} else {
-												MCPotionData pd = ObjectGenerator.GetGenerator().potionData((CArray) base, t);
+												MCPotionData pd = ObjectGenerator.GetGenerator().potionData((CArray) base, t, env);
 												arrow.setBasePotionData(pd);
 											}
 										}
 									}
 									if(meta.containsKey("potions")) {
 										arrow.clearCustomEffects();
-										Mixed potions = meta.get("potions", t);
-										if(potions.isInstanceOf(CArray.TYPE)) {
-											List<MCLivingEntity.MCEffect> list = ObjectGenerator.GetGenerator().potions((CArray) potions, t);
+										Mixed potions = meta.get("potions", t, env);
+										if(potions.isInstanceOf(CArray.TYPE, null, env)) {
+											List<MCLivingEntity.MCEffect> list = ObjectGenerator.GetGenerator().potions((CArray) potions, t, env);
 											for(MCLivingEntity.MCEffect effect : list) {
 												arrow.addCustomEffect(effect);
 											}
@@ -2793,10 +2794,10 @@ public Mixed exec(Target t, Environment environment, Mixed... args) throws Confi
 								}
 								break;
 							case entity_spec.KEY_ARROW_COLOR:
-								Mixed colorMixed = specArray.get(index, t);
+								Mixed colorMixed = specArray.get(index, t, env);
 								if(colorMixed instanceof CNull) {
 									arrow.setColor(null);
-								} else if(colorMixed.isInstanceOf(CArray.TYPE)) {
+								} else if(colorMixed.isInstanceOf(CArray.TYPE, null, env)) {
 									CArray color = (CArray) colorMixed;
 									arrow.setColor(ObjectGenerator.GetGenerator().color(color, t));
 								} else {
@@ -2813,32 +2814,32 @@ public Mixed exec(Target t, Environment environment, Mixed... args) throws Confi
 					for(String index : specArray.stringKeySet()) {
 						switch(index.toLowerCase()) {
 							case entity_spec.KEY_ARMORSTAND_ARMS:
-								stand.setHasArms(ArgumentValidation.getBoolean(specArray.get(index, t), t));
+								stand.setHasArms(ArgumentValidation.getBoolean(specArray.get(index, t, env), t, env));
 								break;
 							case entity_spec.KEY_ARMORSTAND_BASEPLATE:
-								stand.setHasBasePlate(ArgumentValidation.getBoolean(specArray.get(index, t), t));
+								stand.setHasBasePlate(ArgumentValidation.getBoolean(specArray.get(index, t, env), t, env));
 								break;
 							case entity_spec.KEY_ARMORSTAND_GRAVITY:
-								stand.setHasGravity(ArgumentValidation.getBoolean(specArray.get(index, t), t));
+								stand.setHasGravity(ArgumentValidation.getBoolean(specArray.get(index, t, env), t, env));
 								break;
 							case entity_spec.KEY_ARMORSTAND_MARKER:
-								stand.setMarker(ArgumentValidation.getBoolean(specArray.get(index, t), t));
+								stand.setMarker(ArgumentValidation.getBoolean(specArray.get(index, t, env), t, env));
 								break;
 							case entity_spec.KEY_ARMORSTAND_SMALLSIZE:
-								stand.setSmall(ArgumentValidation.getBoolean(specArray.get(index, t), t));
+								stand.setSmall(ArgumentValidation.getBoolean(specArray.get(index, t, env), t, env));
 								break;
 							case entity_spec.KEY_ARMORSTAND_VISIBLE:
-								stand.setVisible(ArgumentValidation.getBoolean(specArray.get(index, t), t));
+								stand.setVisible(ArgumentValidation.getBoolean(specArray.get(index, t, env), t, env));
 								break;
 							case entity_spec.KEY_ARMORSTAND_POSES:
 								Map<MCBodyPart, Vector3D> poseMap = stand.getAllPoses();
-								Mixed posesMixed = specArray.get(index, t);
-								if(posesMixed.isInstanceOf(CArray.TYPE)) {
+								Mixed posesMixed = specArray.get(index, t, env);
+								if(posesMixed.isInstanceOf(CArray.TYPE, null, env)) {
 									CArray poseArray = (CArray) posesMixed;
 									for(MCBodyPart key : poseMap.keySet()) {
 										try {
 											poseMap.put(key, ObjectGenerator.GetGenerator().vector(poseMap.get(key),
-													poseArray.get("pose" + key.name(), t), t));
+													poseArray.get("pose" + key.name(), t, env), t));
 										} catch(ConfigRuntimeException cre) {
 											// Ignore, this just means the user didn't modify a body part
 										}
@@ -2862,9 +2863,9 @@ public Mixed exec(Target t, Environment environment, Mixed... args) throws Confi
 						switch(index.toLowerCase()) {
 							case entity_spec.KEY_AXOLOTL_TYPE:
 								try {
-									axolotl.setAxolotlType(MCAxolotlType.valueOf(specArray.get(index, t).val().toUpperCase()));
+									axolotl.setAxolotlType(MCAxolotlType.valueOf(specArray.get(index, t, env).val().toUpperCase()));
 								} catch(IllegalArgumentException exception) {
-									throw new CREFormatException("Invalid axolotl type: " + specArray.get(index, t).val(), t);
+									throw new CREFormatException("Invalid axolotl type: " + specArray.get(index, t, env).val(), t);
 								}
 								break;
 							default:
@@ -2877,28 +2878,28 @@ public Mixed exec(Target t, Environment environment, Mixed... args) throws Confi
 					for(String index : specArray.stringKeySet()) {
 						switch(index.toLowerCase()) {
 							case entity_spec.KEY_BEE_ANGER:
-								bee.setAnger(ArgumentValidation.getInt32(specArray.get(index, t), t));
+								bee.setAnger(ArgumentValidation.getInt32(specArray.get(index, t, env), t, env));
 								break;
 							case entity_spec.KEY_BEE_NECTAR:
-								bee.setHasNectar(ArgumentValidation.getBooleanObject(specArray.get(index, t), t));
+								bee.setHasNectar(ArgumentValidation.getBooleanObject(specArray.get(index, t, env), t, env));
 								break;
 							case entity_spec.KEY_BEE_STUNG:
-								bee.setHasStung(ArgumentValidation.getBooleanObject(specArray.get(index, t), t));
+								bee.setHasStung(ArgumentValidation.getBooleanObject(specArray.get(index, t, env), t, env));
 								break;
 							case entity_spec.KEY_BEE_FLOWER_LOCATION:
-								Mixed flower = specArray.get(index, t);
+								Mixed flower = specArray.get(index, t, env);
 								if(flower instanceof CNull) {
 									bee.setFlowerLocation(null);
 								} else {
-									bee.setFlowerLocation(ObjectGenerator.GetGenerator().location(flower, null, t));
+									bee.setFlowerLocation(ObjectGenerator.GetGenerator().location(flower, null, t, env));
 								}
 								break;
 							case entity_spec.KEY_BEE_HIVE_LOCATION:
-								Mixed hive = specArray.get(index, t);
+								Mixed hive = specArray.get(index, t, env);
 								if(hive instanceof CNull) {
 									bee.setHiveLocation(null);
 								} else {
-									bee.setHiveLocation(ObjectGenerator.GetGenerator().location(hive, null, t));
+									bee.setHiveLocation(ObjectGenerator.GetGenerator().location(hive, null, t, env));
 								}
 								break;
 							default:
@@ -2912,10 +2913,10 @@ public Mixed exec(Target t, Environment environment, Mixed... args) throws Confi
 						switch(index.toLowerCase()) {
 							case entity_spec.KEY_DISPLAY_BLOCK:
 								MCBlockData bd;
-								Mixed m = specArray.get(index, t);
+								Mixed m = specArray.get(index, t, env);
 								try {
-									if(m.isInstanceOf(CArray.TYPE)) {
-										bd = ObjectGenerator.GetGenerator().blockData((CArray) m, t);
+									if(m.isInstanceOf(CArray.TYPE, null, env)) {
+										bd = ObjectGenerator.GetGenerator().blockData((CArray) m, t, env);
 									} else {
 										bd = Static.getServer().createBlockData(m.val().toLowerCase());
 									}
@@ -2935,9 +2936,9 @@ public Mixed exec(Target t, Environment environment, Mixed... args) throws Confi
 						switch(index.toLowerCase()) {
 							case entity_spec.KEY_BOAT_TYPE:
 								try {
-									boat.setWoodType(MCTreeSpecies.valueOf(specArray.get(index, t).val().toUpperCase()));
+									boat.setWoodType(MCTreeSpecies.valueOf(specArray.get(index, t, env).val().toUpperCase()));
 								} catch(IllegalArgumentException ex) {
-									throw new CREFormatException("Invalid boat type: " + specArray.get(index, t).val(), t);
+									throw new CREFormatException("Invalid boat type: " + specArray.get(index, t, env).val(), t);
 								}
 								break;
 							default:
@@ -2951,19 +2952,19 @@ public Mixed exec(Target t, Environment environment, Mixed... args) throws Confi
 						switch(index.toLowerCase()) {
 							case entity_spec.KEY_CAT_TYPE:
 								try {
-									cat.setCatType(MCCatType.valueOf(specArray.get(index, t).val().toUpperCase()));
+									cat.setCatType(MCCatType.valueOf(specArray.get(index, t, env).val().toUpperCase()));
 								} catch(IllegalArgumentException exception) {
-									throw new CREFormatException("Invalid cat type: " + specArray.get(index, t).val(), t);
+									throw new CREFormatException("Invalid cat type: " + specArray.get(index, t, env).val(), t);
 								}
 								break;
 							case entity_spec.KEY_GENERIC_SITTING:
-								cat.setSitting(ArgumentValidation.getBoolean(specArray.get(index, t), t));
+								cat.setSitting(ArgumentValidation.getBoolean(specArray.get(index, t, env), t, env));
 								break;
 							case entity_spec.KEY_CAT_COLOR:
 								try {
-									cat.setCollarColor(MCDyeColor.valueOf(specArray.get(index, t).val().toUpperCase()));
+									cat.setCollarColor(MCDyeColor.valueOf(specArray.get(index, t, env).val().toUpperCase()));
 								} catch(IllegalArgumentException exception) {
-									throw new CREFormatException("Invalid collar color: " + specArray.get(index, t).val(), t);
+									throw new CREFormatException("Invalid collar color: " + specArray.get(index, t, env).val(), t);
 								}
 								break;
 							default:
@@ -2976,25 +2977,25 @@ public Mixed exec(Target t, Environment environment, Mixed... args) throws Confi
 					for(String index : specArray.stringKeySet()) {
 						switch(index.toLowerCase()) {
 							case entity_spec.KEY_CREEPER_POWERED:
-								creeper.setPowered(ArgumentValidation.getBoolean(specArray.get(index, t), t));
+								creeper.setPowered(ArgumentValidation.getBoolean(specArray.get(index, t, env), t, env));
 								break;
 							case entity_spec.KEY_CREEPER_MAXFUSETICKS:
 								try {
-									creeper.setMaxFuseTicks(ArgumentValidation.getInt32(specArray.get(index, t), t));
+									creeper.setMaxFuseTicks(ArgumentValidation.getInt32(specArray.get(index, t, env), t, env));
 								} catch(IllegalArgumentException ex) {
 									throw new CRERangeException("Ticks must not be negative.", t);
 								}
 								break;
 							case entity_spec.KEY_CREEPER_FUSETICKS:
 								try {
-									creeper.setFuseTicks(ArgumentValidation.getInt32(specArray.get(index, t), t));
+									creeper.setFuseTicks(ArgumentValidation.getInt32(specArray.get(index, t, env), t, env));
 								} catch(IllegalArgumentException ex) {
 									throw new CRERangeException(ex.getMessage(), t);
 								}
 								break;
 							case entity_spec.KEY_CREEPER_EXPLOSIONRADIUS:
 								try {
-									creeper.setExplosionRadius(ArgumentValidation.getInt32(specArray.get(index, t), t));
+									creeper.setExplosionRadius(ArgumentValidation.getInt32(specArray.get(index, t, env), t, env));
 								} catch(IllegalArgumentException ex) {
 									throw new CRERangeException("Radius must not be negative.", t);
 								}
@@ -3010,27 +3011,27 @@ public Mixed exec(Target t, Environment environment, Mixed... args) throws Confi
 					for(String index : specArray.stringKeySet()) {
 						switch(index.toLowerCase()) {
 							case entity_spec.KEY_HORSE_CHEST:
-								chestedhorse.setHasChest(ArgumentValidation.getBoolean(specArray.get(index, t), t));
+								chestedhorse.setHasChest(ArgumentValidation.getBoolean(specArray.get(index, t, env), t, env));
 								break;
 							case entity_spec.KEY_HORSE_JUMP:
 								try {
-									chestedhorse.setJumpStrength(ArgumentValidation.getDouble(specArray.get(index, t), t));
+									chestedhorse.setJumpStrength(ArgumentValidation.getDouble(specArray.get(index, t, env), t, env));
 								} catch(IllegalArgumentException exception) {
 									throw new CRERangeException("The jump strength must be between 0.0 and 2.0", t);
 								}
 								break;
 							case entity_spec.KEY_HORSE_DOMESTICATION:
 								try {
-									chestedhorse.setDomestication(ArgumentValidation.getInt32(specArray.get(index, t), t));
+									chestedhorse.setDomestication(ArgumentValidation.getInt32(specArray.get(index, t, env), t, env));
 								} catch(IllegalArgumentException exception) {
 									throw new CRERangeException("The domestication level can not be higher than the max domestication level.", t);
 								}
 								break;
 							case entity_spec.KEY_HORSE_MAXDOMESTICATION:
-								chestedhorse.setMaxDomestication(ArgumentValidation.getInt32(specArray.get(index, t), t));
+								chestedhorse.setMaxDomestication(ArgumentValidation.getInt32(specArray.get(index, t, env), t, env));
 								break;
 							case entity_spec.KEY_HORSE_SADDLE:
-								chestedhorse.setSaddle(ObjectGenerator.GetGenerator().item(specArray.get(index, t), t));
+								chestedhorse.setSaddle(ObjectGenerator.GetGenerator().item(specArray.get(index, t, env), t, env));
 								break;
 							default:
 								throwException(index, t);
@@ -3042,13 +3043,13 @@ public Mixed exec(Target t, Environment environment, Mixed... args) throws Confi
 					for(String index : specArray.stringKeySet()) {
 						switch(index.toLowerCase()) {
 							case entity_spec.KEY_DROPPED_ITEM_ITEMSTACK:
-								item.setItemStack(ObjectGenerator.GetGenerator().item(specArray.get(index, t), t));
+								item.setItemStack(ObjectGenerator.GetGenerator().item(specArray.get(index, t, env), t, env));
 								break;
 							case entity_spec.KEY_DROPPED_ITEM_PICKUPDELAY:
-								item.setPickupDelay(ArgumentValidation.getInt32(specArray.get(index, t), t));
+								item.setPickupDelay(ArgumentValidation.getInt32(specArray.get(index, t, env), t, env));
 								break;
 							case entity_spec.KEY_DROPPED_ITEM_OWNER:
-								Mixed owner = specArray.get(index, t);
+								Mixed owner = specArray.get(index, t, env);
 								if(owner instanceof CNull) {
 									item.setOwner(null);
 								} else {
@@ -3056,7 +3057,7 @@ public Mixed exec(Target t, Environment environment, Mixed... args) throws Confi
 								}
 								break;
 							case entity_spec.KEY_DROPPED_ITEM_THROWER:
-								Mixed thrower = specArray.get(index, t);
+								Mixed thrower = specArray.get(index, t, env);
 								if(thrower instanceof CNull) {
 									item.setThrower(null);
 								} else {
@@ -3065,7 +3066,7 @@ public Mixed exec(Target t, Environment environment, Mixed... args) throws Confi
 								break;
 							case entity_spec.KEY_DROPPED_ITEM_DESPAWN:
 								if(Static.getServer().getMinecraftVersion().gte(MCVersion.MC1_18_X)) {
-									item.setWillDespawn(ArgumentValidation.getBooleanObject(specArray.get(index, t), t));
+									item.setWillDespawn(ArgumentValidation.getBooleanObject(specArray.get(index, t, env), t, env));
 								}
 								break;
 							default:
@@ -3078,14 +3079,14 @@ public Mixed exec(Target t, Environment environment, Mixed... args) throws Confi
 					for(String index : specArray.stringKeySet()) {
 						switch(index.toLowerCase()) {
 							case entity_spec.KEY_ENDERCRYSTAL_BASE:
-								endercrystal.setShowingBottom(ArgumentValidation.getBoolean(specArray.get(index, t), t));
+								endercrystal.setShowingBottom(ArgumentValidation.getBoolean(specArray.get(index, t, env), t, env));
 								break;
 							case entity_spec.KEY_ENDERCRYSTAL_BEAMTARGET:
-								Mixed c = specArray.get(index, t);
+								Mixed c = specArray.get(index, t, env);
 								if(c instanceof CNull) {
 									endercrystal.setBeamTarget(null);
-								} else if(c.isInstanceOf(CArray.TYPE)) {
-									MCLocation l = ObjectGenerator.GetGenerator().location((CArray) c, endercrystal.getWorld(), t);
+								} else if(c.isInstanceOf(CArray.TYPE, null, env)) {
+									MCLocation l = ObjectGenerator.GetGenerator().location((CArray) c, endercrystal.getWorld(), t, env);
 									endercrystal.setBeamTarget(l);
 								} else {
 									throw new CRECastException("EnderCrystal beam target must be an array or null", t);
@@ -3102,9 +3103,9 @@ public Mixed exec(Target t, Environment environment, Mixed... args) throws Confi
 						switch(index.toLowerCase()) {
 							case entity_spec.KEY_ENDERDRAGON_PHASE:
 								try {
-									enderdragon.setPhase(MCEnderDragonPhase.valueOf(specArray.get(index, t).val().toUpperCase()));
+									enderdragon.setPhase(MCEnderDragonPhase.valueOf(specArray.get(index, t, env).val().toUpperCase()));
 								} catch(IllegalArgumentException ex) {
-									throw new CREFormatException("Invalid EnderDragon phase: " + specArray.get(index, t).val(), t);
+									throw new CREFormatException("Invalid EnderDragon phase: " + specArray.get(index, t, env).val(), t);
 								}
 								break;
 							default:
@@ -3116,9 +3117,9 @@ public Mixed exec(Target t, Environment environment, Mixed... args) throws Confi
 					MCEnderSignal endereye = (MCEnderSignal) entity;
 					// Order matters here. Target must be set first or it will reset despawn ticks and drop.
 					if(specArray.containsKey(entity_spec.KEY_ENDEREYE_TARGET)) {
-						Mixed targetLoc = specArray.get(entity_spec.KEY_ENDEREYE_TARGET, t);
+						Mixed targetLoc = specArray.get(entity_spec.KEY_ENDEREYE_TARGET, t, env);
 						try {
-							endereye.setTargetLocation(ObjectGenerator.GetGenerator().location(targetLoc, null, t));
+							endereye.setTargetLocation(ObjectGenerator.GetGenerator().location(targetLoc, null, t, env));
 						} catch(IllegalArgumentException ex) {
 							throw new CREInvalidWorldException("An EnderEye cannot target a location in another world.", t);
 						}
@@ -3126,17 +3127,17 @@ public Mixed exec(Target t, Environment environment, Mixed... args) throws Confi
 					for(String index : specArray.stringKeySet()) {
 						switch(index.toLowerCase()) {
 							case entity_spec.KEY_ENDEREYE_DESPAWNTICKS:
-								endereye.setDespawnTicks(ArgumentValidation.getInt32(specArray.get(index, t), t));
+								endereye.setDespawnTicks(ArgumentValidation.getInt32(specArray.get(index, t, env), t, env));
 								break;
 							case entity_spec.KEY_ENDEREYE_DROP:
-								endereye.setDropItem(ArgumentValidation.getBoolean(specArray.get(index, t), t));
+								endereye.setDropItem(ArgumentValidation.getBoolean(specArray.get(index, t, env), t, env));
 								break;
 							case entity_spec.KEY_ENDEREYE_ITEM:
-								Mixed enderItem = specArray.get(index, t);
+								Mixed enderItem = specArray.get(index, t, env);
 								if(enderItem instanceof CNull) {
 									endereye.setItem(null);
 								} else {
-									endereye.setItem(ObjectGenerator.GetGenerator().item(enderItem, t));
+									endereye.setItem(ObjectGenerator.GetGenerator().item(enderItem, t, env));
 								}
 								break;
 							case entity_spec.KEY_ENDEREYE_TARGET:
@@ -3151,7 +3152,7 @@ public Mixed exec(Target t, Environment environment, Mixed... args) throws Confi
 					for(String index : specArray.stringKeySet()) {
 						switch(index.toLowerCase()) {
 							case entity_spec.KEY_ENDERMAN_CARRIED:
-								MCMaterial mat = ObjectGenerator.GetGenerator().material(specArray.get(index, t), t);
+								MCMaterial mat = ObjectGenerator.GetGenerator().material(specArray.get(index, t, env), t);
 								enderman.setCarriedMaterial(mat.createBlockData());
 								break;
 							default:
@@ -3164,7 +3165,7 @@ public Mixed exec(Target t, Environment environment, Mixed... args) throws Confi
 					for(String index : specArray.stringKeySet()) {
 						switch(index.toLowerCase()) {
 							case entity_spec.KEY_EVOKERFANGS_SOURCE:
-								Mixed source = specArray.get(index, t);
+								Mixed source = specArray.get(index, t, env);
 								if(source instanceof CNull) {
 									fangs.setOwner(null);
 								} else {
@@ -3181,7 +3182,7 @@ public Mixed exec(Target t, Environment environment, Mixed... args) throws Confi
 					for(String index : specArray.stringKeySet()) {
 						switch(index.toLowerCase()) {
 							case entity_spec.KEY_EXPERIENCE_ORB_AMOUNT:
-								orb.setExperience(ArgumentValidation.getInt32(specArray.get(index, t), t));
+								orb.setExperience(ArgumentValidation.getInt32(specArray.get(index, t, env), t, env));
 								break;
 							default:
 								throwException(index, t);
@@ -3193,10 +3194,10 @@ public Mixed exec(Target t, Environment environment, Mixed... args) throws Confi
 					for(String index : specArray.stringKeySet()) {
 						switch(index.toLowerCase()) {
 							case entity_spec.KEY_FALLING_BLOCK_DROPITEM:
-								block.setDropItem(ArgumentValidation.getBoolean(specArray.get(index, t), t));
+								block.setDropItem(ArgumentValidation.getBoolean(specArray.get(index, t, env), t, env));
 								break;
 							case entity_spec.KEY_FALLING_BLOCK_DAMAGE:
-								block.setHurtEntities(ArgumentValidation.getBoolean(specArray.get(index, t), t));
+								block.setHurtEntities(ArgumentValidation.getBoolean(specArray.get(index, t, env), t, env));
 								break;
 							default:
 								throwException(index, t);
@@ -3210,7 +3211,7 @@ public Mixed exec(Target t, Environment environment, Mixed... args) throws Confi
 					for(String index : specArray.stringKeySet()) {
 						switch(index.toLowerCase()) {
 							case entity_spec.KEY_FIREBALL_DIRECTION:
-								ball.setDirection(ObjectGenerator.GetGenerator().vector(specArray.get(index, t), t));
+								ball.setDirection(ObjectGenerator.GetGenerator().vector(specArray.get(index, t, env), t));
 								break;
 							default:
 								throwException(index, t);
@@ -3223,13 +3224,13 @@ public Mixed exec(Target t, Environment environment, Mixed... args) throws Confi
 					for(String index : specArray.stringKeySet()) {
 						switch(index.toLowerCase()) {
 							case entity_spec.KEY_FIREWORK_STRENGTH:
-								fm.setStrength(ArgumentValidation.getInt32(specArray.get(index, t), t));
+								fm.setStrength(ArgumentValidation.getInt32(specArray.get(index, t, env), t, env));
 								break;
 							case entity_spec.KEY_FIREWORK_EFFECTS:
 								fm.clearEffects();
-								CArray effects = ArgumentValidation.getArray(specArray.get(index, t), t);
-								for(Mixed eff : effects.asList()) {
-									if(eff.isInstanceOf(CArray.TYPE)) {
+								CArray effects = ArgumentValidation.getArray(specArray.get(index, t, env), t, env);
+								for(Mixed eff : effects.asList(env)) {
+									if(eff.isInstanceOf(CArray.TYPE, null, env)) {
 										fm.addEffect(ObjectGenerator.GetGenerator().fireworkEffect((CArray) eff, t));
 									} else {
 										throw new CRECastException("Firework effect expected to be an array.", t);
@@ -3237,7 +3238,7 @@ public Mixed exec(Target t, Environment environment, Mixed... args) throws Confi
 								}
 								break;
 							case entity_spec.KEY_FIREWORK_ANGLED:
-								firework.setShotAtAngle(ArgumentValidation.getBooleanObject(specArray.get(index, t), t));
+								firework.setShotAtAngle(ArgumentValidation.getBooleanObject(specArray.get(index, t, env), t, env));
 								break;
 							default:
 								throwException(index, t);
@@ -3250,16 +3251,16 @@ public Mixed exec(Target t, Environment environment, Mixed... args) throws Confi
 					for(String index : specArray.stringKeySet()) {
 						switch(index.toLowerCase()) {
 							case entity_spec.KEY_GENERIC_SITTING:
-								fox.setSitting(ArgumentValidation.getBoolean(specArray.get(index, t), t));
+								fox.setSitting(ArgumentValidation.getBoolean(specArray.get(index, t, env), t, env));
 								break;
 							case entity_spec.KEY_FOX_CROUCHING:
-								fox.setCrouching(ArgumentValidation.getBoolean(specArray.get(index, t), t));
+								fox.setCrouching(ArgumentValidation.getBoolean(specArray.get(index, t, env), t, env));
 								break;
 							case entity_spec.KEY_FOX_TYPE:
 								try {
-									fox.setVariant(MCFoxType.valueOf(specArray.get(index, t).val().toUpperCase()));
+									fox.setVariant(MCFoxType.valueOf(specArray.get(index, t, env).val().toUpperCase()));
 								} catch(IllegalArgumentException exception) {
-									throw new CREFormatException("Invalid fox type: " + specArray.get(index, t).val(), t);
+									throw new CREFormatException("Invalid fox type: " + specArray.get(index, t, env).val(), t);
 								}
 								break;
 							default:
@@ -3273,9 +3274,9 @@ public Mixed exec(Target t, Environment environment, Mixed... args) throws Confi
 						switch(index.toLowerCase()) {
 							case entity_spec.KEY_FROG_TYPE:
 								try {
-									frog.setFrogType(MCFrogType.valueOf(specArray.get(index, t).val().toUpperCase()));
+									frog.setFrogType(MCFrogType.valueOf(specArray.get(index, t, env).val().toUpperCase()));
 								} catch(IllegalArgumentException exception) {
-									throw new CREFormatException("Invalid frog type: " + specArray.get(index, t).val(), t);
+									throw new CREFormatException("Invalid frog type: " + specArray.get(index, t, env).val(), t);
 								}
 								break;
 							default:
@@ -3288,7 +3289,7 @@ public Mixed exec(Target t, Environment environment, Mixed... args) throws Confi
 					for(String index : specArray.stringKeySet()) {
 						switch(index.toLowerCase()) {
 							case entity_spec.KEY_GOAT_SCREAMING:
-								goat.setScreaming(ArgumentValidation.getBooleanObject(specArray.get(index, t), t));
+								goat.setScreaming(ArgumentValidation.getBooleanObject(specArray.get(index, t, env), t, env));
 								break;
 							default:
 								throwException(index, t);
@@ -3301,40 +3302,40 @@ public Mixed exec(Target t, Environment environment, Mixed... args) throws Confi
 						switch(index.toLowerCase()) {
 							case entity_spec.KEY_HORSE_COLOR:
 								try {
-									horse.setColor(MCHorseColor.valueOf(specArray.get(index, t).val().toUpperCase()));
+									horse.setColor(MCHorseColor.valueOf(specArray.get(index, t, env).val().toUpperCase()));
 								} catch(IllegalArgumentException exception) {
-									throw new CREFormatException("Invalid horse color: " + specArray.get(index, t).val(), t);
+									throw new CREFormatException("Invalid horse color: " + specArray.get(index, t, env).val(), t);
 								}
 								break;
 							case entity_spec.KEY_HORSE_STYLE:
 								try {
-									horse.setPattern(MCHorsePattern.valueOf(specArray.get(index, t).val().toUpperCase()));
+									horse.setPattern(MCHorsePattern.valueOf(specArray.get(index, t, env).val().toUpperCase()));
 								} catch(IllegalArgumentException exception) {
-									throw new CREFormatException("Invalid horse style: " + specArray.get(index, t).val(), t);
+									throw new CREFormatException("Invalid horse style: " + specArray.get(index, t, env).val(), t);
 								}
 								break;
 							case entity_spec.KEY_HORSE_JUMP:
 								try {
-									horse.setJumpStrength(ArgumentValidation.getDouble(specArray.get(index, t), t));
+									horse.setJumpStrength(ArgumentValidation.getDouble(specArray.get(index, t, env), t, env));
 								} catch(IllegalArgumentException exception) {
 									throw new CRERangeException("The jump strength must be between 0.0 and 2.0", t);
 								}
 								break;
 							case entity_spec.KEY_HORSE_DOMESTICATION:
 								try {
-									horse.setDomestication(ArgumentValidation.getInt32(specArray.get(index, t), t));
+									horse.setDomestication(ArgumentValidation.getInt32(specArray.get(index, t, env), t, env));
 								} catch(IllegalArgumentException exception) {
 									throw new CRERangeException("The domestication level can not be higher than the max domestication level.", t);
 								}
 								break;
 							case entity_spec.KEY_HORSE_MAXDOMESTICATION:
-								horse.setMaxDomestication(ArgumentValidation.getInt32(specArray.get(index, t), t));
+								horse.setMaxDomestication(ArgumentValidation.getInt32(specArray.get(index, t, env), t, env));
 								break;
 							case entity_spec.KEY_HORSE_SADDLE:
-								horse.setSaddle(ObjectGenerator.GetGenerator().item(specArray.get(index, t), t));
+								horse.setSaddle(ObjectGenerator.GetGenerator().item(specArray.get(index, t, env), t, env));
 								break;
 							case entity_spec.KEY_HORSE_ARMOR:
-								horse.setArmor(ObjectGenerator.GetGenerator().item(specArray.get(index, t), t));
+								horse.setArmor(ObjectGenerator.GetGenerator().item(specArray.get(index, t, env), t, env));
 								break;
 							default:
 								throwException(index, t);
@@ -3346,13 +3347,13 @@ public Mixed exec(Target t, Environment environment, Mixed... args) throws Confi
 					for(String index : specArray.stringKeySet()) {
 						switch(index.toLowerCase()) {
 							case entity_spec.KEY_INTERACTION_HEIGHT:
-								interaction.setHeight(ArgumentValidation.getDouble(specArray.get(index, t), t));
+								interaction.setHeight(ArgumentValidation.getDouble(specArray.get(index, t, env), t, env));
 								break;
 							case entity_spec.KEY_INTERACTION_WIDTH:
-								interaction.setWidth(ArgumentValidation.getDouble(specArray.get(index, t), t));
+								interaction.setWidth(ArgumentValidation.getDouble(specArray.get(index, t, env), t, env));
 								break;
 							case entity_spec.KEY_INTERACTION_RESPONSE:
-								interaction.setResponsive(ArgumentValidation.getBooleanish(specArray.get(index, t), t));
+								interaction.setResponsive(ArgumentValidation.getBooleanish(specArray.get(index, t, env), t, env));
 								break;
 							case entity_spec.KEY_INTERACTION_ATTACK:
 							case entity_spec.KEY_INTERACTION_INTERACTION:
@@ -3367,7 +3368,7 @@ public Mixed exec(Target t, Environment environment, Mixed... args) throws Confi
 					for(String index : specArray.stringKeySet()) {
 						switch(index.toLowerCase()) {
 							case entity_spec.KEY_IRON_GOLEM_PLAYERCREATED:
-								golem.setPlayerCreated(ArgumentValidation.getBoolean(specArray.get(index, t), t));
+								golem.setPlayerCreated(ArgumentValidation.getBoolean(specArray.get(index, t, env), t, env));
 								break;
 							default:
 								throwException(index, t);
@@ -3379,14 +3380,14 @@ public Mixed exec(Target t, Environment environment, Mixed... args) throws Confi
 					for(String index : specArray.stringKeySet()) {
 						switch(index.toLowerCase()) {
 							case entity_spec.KEY_DISPLAY_ITEM:
-								itemDisplay.setItem(ObjectGenerator.GetGenerator().item(specArray.get(index, t), t));
+								itemDisplay.setItem(ObjectGenerator.GetGenerator().item(specArray.get(index, t, env), t, env));
 								break;
 							case entity_spec.KEY_DISPLAY_ITEM_DISPLAY:
 								try {
-									itemDisplay.setItemModelTransform(ModelTransform.valueOf(specArray.get(index, t).val()));
+									itemDisplay.setItemModelTransform(ModelTransform.valueOf(specArray.get(index, t, env).val()));
 								} catch(IllegalArgumentException ex) {
 									throw new CREFormatException("Invalid display item model transform: "
-											+ specArray.get(index, t).val(), t);
+											+ specArray.get(index, t, env).val(), t);
 								}
 								break;
 							default:
@@ -3400,20 +3401,20 @@ public Mixed exec(Target t, Environment environment, Mixed... args) throws Confi
 					for(String index : specArray.stringKeySet()) {
 						switch(index.toLowerCase()) {
 							case entity_spec.KEY_ITEM_FRAME_FIXED:
-								frame.setFixed(ArgumentValidation.getBoolean(specArray.get(index, t), t));
+								frame.setFixed(ArgumentValidation.getBoolean(specArray.get(index, t, env), t, env));
 								break;
 							case entity_spec.KEY_ITEM_FRAME_ITEM:
-								frame.setItem(ObjectGenerator.GetGenerator().item(specArray.get(index, t), t));
+								frame.setItem(ObjectGenerator.GetGenerator().item(specArray.get(index, t, env), t, env));
 								break;
 							case entity_spec.KEY_ITEM_FRAME_ROTATION:
 								try {
-									frame.setRotation(MCRotation.valueOf(specArray.get(index, t).val().toUpperCase()));
+									frame.setRotation(MCRotation.valueOf(specArray.get(index, t, env).val().toUpperCase()));
 								} catch(IllegalArgumentException exception) {
-									throw new CREFormatException("Invalid rotation type: " + specArray.get(index, t).val(), t);
+									throw new CREFormatException("Invalid rotation type: " + specArray.get(index, t, env).val(), t);
 								}
 								break;
 							case entity_spec.KEY_ITEM_FRAME_VISIBLE:
-								frame.setVisible(ArgumentValidation.getBoolean(specArray.get(index, t), t));
+								frame.setVisible(ArgumentValidation.getBoolean(specArray.get(index, t, env), t, env));
 								break;
 							default:
 								throwException(index, t);
@@ -3426,26 +3427,26 @@ public Mixed exec(Target t, Environment environment, Mixed... args) throws Confi
 						switch(index.toLowerCase()) {
 							case entity_spec.KEY_HORSE_COLOR:
 								try {
-									llama.setLlamaColor(MCLlamaColor.valueOf(specArray.get(index, t).val().toUpperCase()));
+									llama.setLlamaColor(MCLlamaColor.valueOf(specArray.get(index, t, env).val().toUpperCase()));
 								} catch(IllegalArgumentException exception) {
-									throw new CREFormatException("Invalid llama color: " + specArray.get(index, t).val(), t);
+									throw new CREFormatException("Invalid llama color: " + specArray.get(index, t, env).val(), t);
 								}
 								break;
 							case entity_spec.KEY_HORSE_CHEST:
-								llama.setHasChest(ArgumentValidation.getBoolean(specArray.get(index, t), t));
+								llama.setHasChest(ArgumentValidation.getBoolean(specArray.get(index, t, env), t, env));
 								break;
 							case entity_spec.KEY_HORSE_DOMESTICATION:
 								try {
-									llama.setDomestication(ArgumentValidation.getInt32(specArray.get(index, t), t));
+									llama.setDomestication(ArgumentValidation.getInt32(specArray.get(index, t, env), t, env));
 								} catch(IllegalArgumentException exception) {
 									throw new CRERangeException("The domestication level can not be higher than the max domestication level.", t);
 								}
 								break;
 							case entity_spec.KEY_HORSE_MAXDOMESTICATION:
-								llama.setMaxDomestication(ArgumentValidation.getInt32(specArray.get(index, t), t));
+								llama.setMaxDomestication(ArgumentValidation.getInt32(specArray.get(index, t, env), t, env));
 								break;
 							case entity_spec.KEY_HORSE_SADDLE:
-								llama.setSaddle(ObjectGenerator.GetGenerator().item(specArray.get(index, t), t));
+								llama.setSaddle(ObjectGenerator.GetGenerator().item(specArray.get(index, t, env), t, env));
 								break;
 							default:
 								throwException(index, t);
@@ -3458,7 +3459,7 @@ public Mixed exec(Target t, Environment environment, Mixed... args) throws Confi
 					for(String index : specArray.stringKeySet()) {
 						switch(index.toLowerCase()) {
 							case entity_spec.KEY_SLIME_SIZE:
-								cube.setSize(ArgumentValidation.getInt32(specArray.get(index, t), t));
+								cube.setSize(ArgumentValidation.getInt32(specArray.get(index, t, env), t, env));
 								break;
 							default:
 								throwException(index, t);
@@ -3470,7 +3471,7 @@ public Mixed exec(Target t, Environment environment, Mixed... args) throws Confi
 					for(String index : specArray.stringKeySet()) {
 						switch(index.toLowerCase()) {
 							case entity_spec.KEY_MANNEQUIN_IMMOVABLE:
-								mannequin.setImmovable(ArgumentValidation.getBooleanObject(specArray.get(index, t), t));
+								mannequin.setImmovable(ArgumentValidation.getBooleanObject(specArray.get(index, t, env), t, env));
 								break;
 							default:
 								throwException(index, t);
@@ -3486,11 +3487,11 @@ public Mixed exec(Target t, Environment environment, Mixed... args) throws Confi
 					for(String index : specArray.stringKeySet()) {
 						switch(index.toLowerCase()) {
 							case entity_spec.KEY_MINECART_BLOCK:
-								MCMaterial mat = ObjectGenerator.GetGenerator().material(specArray.get(index, t), t);
+								MCMaterial mat = ObjectGenerator.GetGenerator().material(specArray.get(index, t, env), t);
 								minecart.setDisplayBlock(mat.createBlockData());
 								break;
 							case entity_spec.KEY_MINECART_OFFSET:
-								minecart.setDisplayBlockOffset(ArgumentValidation.getInt32(specArray.get(index, t), t));
+								minecart.setDisplayBlockOffset(ArgumentValidation.getInt32(specArray.get(index, t, env), t, env));
 								break;
 							default:
 								throwException(index, t);
@@ -3502,7 +3503,7 @@ public Mixed exec(Target t, Environment environment, Mixed... args) throws Confi
 					for(String index : specArray.stringKeySet()) {
 						switch(index.toLowerCase()) {
 							case entity_spec.KEY_MINECART_COMMAND_CUSTOMNAME:
-								Mixed customName = specArray.get(index, t);
+								Mixed customName = specArray.get(index, t, env);
 								if(customName instanceof CNull) {
 									commandminecart.setName(null);
 								} else {
@@ -3510,7 +3511,7 @@ public Mixed exec(Target t, Environment environment, Mixed... args) throws Confi
 								}
 								break;
 							case entity_spec.KEY_MINECART_COMMAND_COMMAND:
-								Mixed command = specArray.get(index, t);
+								Mixed command = specArray.get(index, t, env);
 								if(command instanceof CNull) {
 									commandminecart.setCommand(null);
 								} else {
@@ -3518,11 +3519,11 @@ public Mixed exec(Target t, Environment environment, Mixed... args) throws Confi
 								}
 								break;
 							case entity_spec.KEY_MINECART_BLOCK:
-								MCMaterial mat = ObjectGenerator.GetGenerator().material(specArray.get(index, t), t);
+								MCMaterial mat = ObjectGenerator.GetGenerator().material(specArray.get(index, t, env), t);
 								commandminecart.setDisplayBlock(mat.createBlockData());
 								break;
 							case entity_spec.KEY_MINECART_OFFSET:
-								commandminecart.setDisplayBlockOffset(ArgumentValidation.getInt32(specArray.get(index, t), t));
+								commandminecart.setDisplayBlockOffset(ArgumentValidation.getInt32(specArray.get(index, t, env), t, env));
 								break;
 							default:
 								throwException(index, t);
@@ -3535,9 +3536,9 @@ public Mixed exec(Target t, Environment environment, Mixed... args) throws Confi
 						switch(index.toLowerCase()) {
 							case entity_spec.KEY_MUSHROOM_COW_TYPE:
 								try {
-									cow.setVariant(MCMushroomCowType.valueOf(specArray.get(index, t).val().toUpperCase()));
+									cow.setVariant(MCMushroomCowType.valueOf(specArray.get(index, t, env).val().toUpperCase()));
 								} catch(IllegalArgumentException exception) {
-									throw new CREFormatException("Invalid mushroom cow type: " + specArray.get(index, t).val(), t);
+									throw new CREFormatException("Invalid mushroom cow type: " + specArray.get(index, t, env).val(), t);
 								}
 								break;
 							default:
@@ -3550,10 +3551,10 @@ public Mixed exec(Target t, Environment environment, Mixed... args) throws Confi
 					for(String index : specArray.stringKeySet()) {
 						switch(index.toLowerCase()) {
 							case entity_spec.KEY_OMINOUS_SPAWNER_ITEM:
-								spawner.setItem(ObjectGenerator.GetGenerator().item(specArray.get(index, t), t));
+								spawner.setItem(ObjectGenerator.GetGenerator().item(specArray.get(index, t, env), t, env));
 								break;
 							case entity_spec.KEY_OMINOUS_SPAWNER_DELAY:
-								spawner.setDelay(ArgumentValidation.getInt(specArray.get(index, t), t));
+								spawner.setDelay(ArgumentValidation.getInt(specArray.get(index, t, env), t, env));
 								break;
 							default:
 								throwException(index, t);
@@ -3566,9 +3567,9 @@ public Mixed exec(Target t, Environment environment, Mixed... args) throws Confi
 						switch(index.toLowerCase()) {
 							case entity_spec.KEY_PAINTING_ART:
 								try {
-									painting.setArt(MCArt.valueOf(specArray.get(index, t).val().toUpperCase()));
+									painting.setArt(MCArt.valueOf(specArray.get(index, t, env).val().toUpperCase()));
 								} catch(IllegalArgumentException exception) {
-									throw new CREFormatException("Invalid art type: " + specArray.get(index, t).val(), t);
+									throw new CREFormatException("Invalid art type: " + specArray.get(index, t, env).val(), t);
 								}
 								break;
 							default:
@@ -3582,29 +3583,29 @@ public Mixed exec(Target t, Environment environment, Mixed... args) throws Confi
 						switch(index.toLowerCase()) {
 							case entity_spec.KEY_PANDA_MAINGENE:
 								try {
-									panda.setMainGene(MCPanda.Gene.valueOf(specArray.get(index, t).val().toUpperCase()));
+									panda.setMainGene(MCPanda.Gene.valueOf(specArray.get(index, t, env).val().toUpperCase()));
 								} catch(IllegalArgumentException exception) {
-									throw new CREFormatException("Invalid panda gene: " + specArray.get(index, t).val(), t);
+									throw new CREFormatException("Invalid panda gene: " + specArray.get(index, t, env).val(), t);
 								}
 								break;
 							case entity_spec.KEY_PANDA_HIDDENGENE:
 								try {
-									panda.setHiddenGene(MCPanda.Gene.valueOf(specArray.get(index, t).val().toUpperCase()));
+									panda.setHiddenGene(MCPanda.Gene.valueOf(specArray.get(index, t, env).val().toUpperCase()));
 								} catch(IllegalArgumentException exception) {
-									throw new CREFormatException("Invalid panda gene: " + specArray.get(index, t).val(), t);
+									throw new CREFormatException("Invalid panda gene: " + specArray.get(index, t, env).val(), t);
 								}
 								break;
 							case entity_spec.KEY_PANDA_EATING:
-								panda.setEating(ArgumentValidation.getBooleanObject(specArray.get(index, t), t));
+								panda.setEating(ArgumentValidation.getBooleanObject(specArray.get(index, t, env), t, env));
 								break;
 							case entity_spec.KEY_PANDA_ONBACK:
-								panda.setOnBack(ArgumentValidation.getBooleanObject(specArray.get(index, t), t));
+								panda.setOnBack(ArgumentValidation.getBooleanObject(specArray.get(index, t, env), t, env));
 								break;
 							case entity_spec.KEY_PANDA_ROLLING:
-								panda.setRolling(ArgumentValidation.getBooleanObject(specArray.get(index, t), t));
+								panda.setRolling(ArgumentValidation.getBooleanObject(specArray.get(index, t, env), t, env));
 								break;
 							case entity_spec.KEY_PANDA_SNEEZING:
-								panda.setSneezing(ArgumentValidation.getBooleanObject(specArray.get(index, t), t));
+								panda.setSneezing(ArgumentValidation.getBooleanObject(specArray.get(index, t, env), t, env));
 								break;
 							default:
 								throwException(index, t);
@@ -3616,13 +3617,13 @@ public Mixed exec(Target t, Environment environment, Mixed... args) throws Confi
 					for(String index : specArray.stringKeySet()) {
 						switch(index.toLowerCase()) {
 							case entity_spec.KEY_GENERIC_SITTING:
-								parrot.setSitting(ArgumentValidation.getBoolean(specArray.get(index, t), t));
+								parrot.setSitting(ArgumentValidation.getBoolean(specArray.get(index, t, env), t, env));
 								break;
 							case entity_spec.KEY_PARROT_TYPE:
 								try {
-									parrot.setVariant(MCParrotType.valueOf(specArray.get(index, t).val().toUpperCase()));
+									parrot.setVariant(MCParrotType.valueOf(specArray.get(index, t, env).val().toUpperCase()));
 								} catch(IllegalArgumentException exception) {
-									throw new CREFormatException("Invalid parrot type: " + specArray.get(index, t).val(), t);
+									throw new CREFormatException("Invalid parrot type: " + specArray.get(index, t, env).val(), t);
 								}
 								break;
 							default:
@@ -3635,7 +3636,7 @@ public Mixed exec(Target t, Environment environment, Mixed... args) throws Confi
 					for(String index : specArray.stringKeySet()) {
 						switch(index.toLowerCase()) {
 							case entity_spec.KEY_PHANTOM_SIZE:
-								phantom.setSize(ArgumentValidation.getInt32(specArray.get(index, t), t));
+								phantom.setSize(ArgumentValidation.getInt32(specArray.get(index, t, env), t, env));
 								break;
 							default:
 								throwException(index, t);
@@ -3647,7 +3648,7 @@ public Mixed exec(Target t, Environment environment, Mixed... args) throws Confi
 					for(String index : specArray.stringKeySet()) {
 						switch(index.toLowerCase()) {
 							case entity_spec.KEY_STEERABLE_SADDLED:
-								pig.setSaddled(ArgumentValidation.getBoolean(specArray.get(index, t), t));
+								pig.setSaddled(ArgumentValidation.getBoolean(specArray.get(index, t, env), t, env));
 								break;
 							default:
 								throwException(index, t);
@@ -3659,14 +3660,14 @@ public Mixed exec(Target t, Environment environment, Mixed... args) throws Confi
 					for(String index : specArray.stringKeySet()) {
 						switch(index.toLowerCase()) {
 							case entity_spec.KEY_GENERIC_BABY:
-								if(ArgumentValidation.getBooleanObject(specArray.get(index, t), t)) {
+								if(ArgumentValidation.getBooleanObject(specArray.get(index, t, env), t, env)) {
 									piglin.setBaby();
 								} else {
 									piglin.setAdult();
 								}
 								break;
 							case entity_spec.KEY_PIGLIN_ZOMBIFICATION_IMMUNE:
-								piglin.setImmuneToZombification(ArgumentValidation.getBooleanObject(specArray.get(index, t), t));
+								piglin.setImmuneToZombification(ArgumentValidation.getBooleanObject(specArray.get(index, t, env), t, env));
 								break;
 							default:
 								throwException(index, t);
@@ -3678,14 +3679,14 @@ public Mixed exec(Target t, Environment environment, Mixed... args) throws Confi
 					for(String index : specArray.stringKeySet()) {
 						switch(index.toLowerCase()) {
 							case entity_spec.KEY_PRIMED_TNT_FUSETICKS:
-								tnt.setFuseTicks(ArgumentValidation.getInt32(specArray.get(index, t), t));
+								tnt.setFuseTicks(ArgumentValidation.getInt32(specArray.get(index, t, env), t, env));
 								break;
 							case entity_spec.KEY_PRIMED_TNT_SOURCE:
-								Mixed source = specArray.get(index, t);
+								Mixed source = specArray.get(index, t, env);
 								if(source instanceof CNull) {
 									tnt.setSource(null);
 								} else {
-									tnt.setSource(Static.getLivingEntity(specArray.get(index, t), t));
+									tnt.setSource(Static.getLivingEntity(specArray.get(index, t, env), t));
 								}
 								break;
 							default:
@@ -3699,9 +3700,9 @@ public Mixed exec(Target t, Environment environment, Mixed... args) throws Confi
 						switch(index.toLowerCase()) {
 							case entity_spec.KEY_RABBIT_TYPE:
 								try {
-									rabbit.setRabbitType(MCRabbitType.valueOf(specArray.get(index, t).val().toUpperCase()));
+									rabbit.setRabbitType(MCRabbitType.valueOf(specArray.get(index, t, env).val().toUpperCase()));
 								} catch(IllegalArgumentException exception) {
-									throw new CREFormatException("Invalid rabbit type: " + specArray.get(index, t).val(), t);
+									throw new CREFormatException("Invalid rabbit type: " + specArray.get(index, t, env).val(), t);
 								}
 								break;
 							default:
@@ -3714,7 +3715,7 @@ public Mixed exec(Target t, Environment environment, Mixed... args) throws Confi
 					for(String index : specArray.stringKeySet()) {
 						switch(index.toLowerCase()) {
 							case entity_spec.KEY_PUFFERFISH_SIZE:
-								puffer.setPuffState(ArgumentValidation.getInt32(specArray.get(index, t), t));
+								puffer.setPuffState(ArgumentValidation.getInt32(specArray.get(index, t, env), t, env));
 								break;
 							default:
 								throwException(index, t);
@@ -3728,9 +3729,9 @@ public Mixed exec(Target t, Environment environment, Mixed... args) throws Confi
 							case entity_spec.KEY_SALMON_TYPE:
 								if(Static.getServer().getMinecraftVersion().gte(MCVersion.MC1_21_3)) {
 									try {
-										salmon.setVariant(MCSalmon.Variant.valueOf(specArray.get(index, t).val()));
+										salmon.setVariant(MCSalmon.Variant.valueOf(specArray.get(index, t, env).val()));
 									} catch (IllegalArgumentException exception) {
-										throw new CREFormatException("Invalid salmon type: " + specArray.get(index, t).val(), t);
+										throw new CREFormatException("Invalid salmon type: " + specArray.get(index, t, env).val(), t);
 									}
 								}
 								break;
@@ -3745,13 +3746,13 @@ public Mixed exec(Target t, Environment environment, Mixed... args) throws Confi
 						switch(index.toLowerCase()) {
 							case entity_spec.KEY_SHEEP_COLOR:
 								try {
-									sheep.setColor(MCDyeColor.valueOf(specArray.get(index, t).val().toUpperCase()));
+									sheep.setColor(MCDyeColor.valueOf(specArray.get(index, t, env).val().toUpperCase()));
 								} catch(IllegalArgumentException exception) {
-									throw new CREFormatException("Invalid sheep color: " + specArray.get(index, t).val(), t);
+									throw new CREFormatException("Invalid sheep color: " + specArray.get(index, t, env).val(), t);
 								}
 								break;
 							case entity_spec.KEY_SHEEP_SHEARED:
-								sheep.setSheared(ArgumentValidation.getBoolean(specArray.get(index, t), t));
+								sheep.setSheared(ArgumentValidation.getBoolean(specArray.get(index, t, env), t, env));
 								break;
 							default:
 								throwException(index, t);
@@ -3763,7 +3764,7 @@ public Mixed exec(Target t, Environment environment, Mixed... args) throws Confi
 					for(String index : specArray.stringKeySet()) {
 						switch(index.toLowerCase()) {
 							case entity_spec.KEY_SHULKER_COLOR:
-								Mixed value = specArray.get(index, t);
+								Mixed value = specArray.get(index, t, env);
 								if(value instanceof CNull) {
 									shulker.setColor(null);
 									break;
@@ -3771,7 +3772,7 @@ public Mixed exec(Target t, Environment environment, Mixed... args) throws Confi
 								try {
 									shulker.setColor(MCDyeColor.valueOf(value.val().toUpperCase()));
 								} catch(IllegalArgumentException exception) {
-									throw new CREFormatException("Invalid shulker color: " + specArray.get(index, t).val(), t);
+									throw new CREFormatException("Invalid shulker color: " + specArray.get(index, t, env).val(), t);
 								}
 								break;
 							default:
@@ -3784,7 +3785,7 @@ public Mixed exec(Target t, Environment environment, Mixed... args) throws Confi
 					for(String index : specArray.stringKeySet()) {
 						switch(index.toLowerCase()) {
 							case entity_spec.KEY_SHULKERBULLET_TARGET:
-								Mixed c = specArray.get(index, t);
+								Mixed c = specArray.get(index, t, env);
 								if(c instanceof CNull) {
 									bullet.setTarget(null);
 								} else {
@@ -3803,23 +3804,23 @@ public Mixed exec(Target t, Environment environment, Mixed... args) throws Confi
 						switch(index.toLowerCase()) {
 							case entity_spec.KEY_HORSE_JUMP:
 								try {
-									undeadhorse.setJumpStrength(ArgumentValidation.getDouble(specArray.get(index, t), t));
+									undeadhorse.setJumpStrength(ArgumentValidation.getDouble(specArray.get(index, t, env), t, env));
 								} catch(IllegalArgumentException exception) {
 									throw new CRERangeException("The jump strength must be between 0.0 and 2.0", t);
 								}
 								break;
 							case entity_spec.KEY_HORSE_DOMESTICATION:
 								try {
-									undeadhorse.setDomestication(ArgumentValidation.getInt32(specArray.get(index, t), t));
+									undeadhorse.setDomestication(ArgumentValidation.getInt32(specArray.get(index, t, env), t, env));
 								} catch(IllegalArgumentException exception) {
 									throw new CRERangeException("The domestication level can not be higher than the max domestication level.", t);
 								}
 								break;
 							case entity_spec.KEY_HORSE_MAXDOMESTICATION:
-								undeadhorse.setMaxDomestication(ArgumentValidation.getInt32(specArray.get(index, t), t));
+								undeadhorse.setMaxDomestication(ArgumentValidation.getInt32(specArray.get(index, t, env), t, env));
 								break;
 							case entity_spec.KEY_HORSE_SADDLE:
-								undeadhorse.setSaddle(ObjectGenerator.GetGenerator().item(specArray.get(index, t), t));
+								undeadhorse.setSaddle(ObjectGenerator.GetGenerator().item(specArray.get(index, t, env), t, env));
 								break;
 							default:
 								throwException(index, t);
@@ -3831,7 +3832,7 @@ public Mixed exec(Target t, Environment environment, Mixed... args) throws Confi
 					for(String index : specArray.stringKeySet()) {
 						switch(index.toLowerCase()) {
 							case entity_spec.KEY_SNOWMAN_DERP:
-								snowman.setDerp(ArgumentValidation.getBoolean(specArray.get(index, t), t));
+								snowman.setDerp(ArgumentValidation.getBoolean(specArray.get(index, t, env), t, env));
 								break;
 							default:
 								throwException(index, t);
@@ -3843,10 +3844,10 @@ public Mixed exec(Target t, Environment environment, Mixed... args) throws Confi
 					for(String index : specArray.stringKeySet()) {
 						switch(index.toLowerCase()) {
 							case entity_spec.KEY_ARROW_CRITICAL:
-								spectral.setCritical(ArgumentValidation.getBoolean(specArray.get(index, t), t));
+								spectral.setCritical(ArgumentValidation.getBoolean(specArray.get(index, t, env), t, env));
 								break;
 							case entity_spec.KEY_ARROW_KNOCKBACK:
-								int k = ArgumentValidation.getInt32(specArray.get(index, t), t);
+								int k = ArgumentValidation.getInt32(specArray.get(index, t, env), t, env);
 								if(k < 0) {
 									throw new CRERangeException("Knockback can not be negative.", t);
 								} else {
@@ -3854,14 +3855,14 @@ public Mixed exec(Target t, Environment environment, Mixed... args) throws Confi
 								}
 								break;
 							case entity_spec.KEY_ARROW_DAMAGE:
-								double d = ArgumentValidation.getDouble(specArray.get(index, t), t);
+								double d = ArgumentValidation.getDouble(specArray.get(index, t, env), t, env);
 								if(d < 0) {
 									throw new CRERangeException("Damage cannot be negative.", t);
 								}
 								spectral.setDamage(d);
 								break;
 							case entity_spec.KEY_SPECTRAL_ARROW_GLOWING_TICKS:
-								spectral.setGlowingTicks(ArgumentValidation.getInt32(specArray.get(index, t), t));
+								spectral.setGlowingTicks(ArgumentValidation.getInt32(specArray.get(index, t, env), t, env));
 								break;
 							default:
 								throwException(index, t);
@@ -3874,7 +3875,7 @@ public Mixed exec(Target t, Environment environment, Mixed... args) throws Confi
 					for(String index : specArray.stringKeySet()) {
 						switch(index.toLowerCase()) {
 							case entity_spec.KEY_SPLASH_POTION_ITEM:
-								MCItemStack potionItem = ObjectGenerator.GetGenerator().item(specArray.get(index, t), t);
+								MCItemStack potionItem = ObjectGenerator.GetGenerator().item(specArray.get(index, t, env), t, env);
 								try {
 									potion.setItem(potionItem);
 								} catch(IllegalArgumentException ex) {
@@ -3891,7 +3892,7 @@ public Mixed exec(Target t, Environment environment, Mixed... args) throws Confi
 					for(String index : specArray.stringKeySet()) {
 						switch(index.toLowerCase()) {
 							case entity_spec.KEY_STEERABLE_SADDLED:
-								strider.setSaddled(ArgumentValidation.getBoolean(specArray.get(index, t), t));
+								strider.setSaddled(ArgumentValidation.getBoolean(specArray.get(index, t, env), t, env));
 								break;
 							default:
 								throwException(index, t);
@@ -3903,27 +3904,27 @@ public Mixed exec(Target t, Environment environment, Mixed... args) throws Confi
 					for(String index : specArray.stringKeySet()) {
 						switch(index.toLowerCase()) {
 							case entity_spec.KEY_DISPLAY_TEXT:
-								tDisplay.setText(specArray.get(index, t).val());
+								tDisplay.setText(specArray.get(index, t, env).val());
 								break;
 							case entity_spec.KEY_DISPLAY_TEXT_ALIGNMENT:
 								try {
-									tDisplay.setAlignment(MCTextDisplay.Alignment.valueOf(specArray.get(index, t).val()));
+									tDisplay.setAlignment(MCTextDisplay.Alignment.valueOf(specArray.get(index, t, env).val()));
 								} catch(IllegalArgumentException ex) {
-									throw new CREFormatException("Invalid text alignment: " + specArray.get(index, t).val(), t);
+									throw new CREFormatException("Invalid text alignment: " + specArray.get(index, t, env).val(), t);
 								}
 								break;
 							case entity_spec.KEY_DISPLAY_TEXT_LINE_WIDTH:
-								tDisplay.setLineWidth(ArgumentValidation.getInt32(specArray.get(index, t), t));
+								tDisplay.setLineWidth(ArgumentValidation.getInt32(specArray.get(index, t, env), t, env));
 								break;
 							case entity_spec.KEY_DISPLAY_TEXT_SEE_THROUGH:
-								tDisplay.setVisibleThroughBlocks(ArgumentValidation.getBooleanObject(specArray.get(index, t), t));
+								tDisplay.setVisibleThroughBlocks(ArgumentValidation.getBooleanObject(specArray.get(index, t, env), t, env));
 								break;
 							case entity_spec.KEY_DISPLAY_TEXT_SHADOW:
-								tDisplay.setHasShadow(ArgumentValidation.getBooleanObject(specArray.get(index, t), t));
+								tDisplay.setHasShadow(ArgumentValidation.getBooleanObject(specArray.get(index, t, env), t, env));
 								break;
 							case entity_spec.KEY_DISPLAY_TEXT_BACKGROUND_COLOR:
-								Mixed color = specArray.get(index, t);
-								if(color.isInstanceOf(CArray.TYPE)) {
+								Mixed color = specArray.get(index, t, env);
+								if(color.isInstanceOf(CArray.TYPE, null, env)) {
 									tDisplay.setBackgroundColor(ObjectGenerator.GetGenerator().color((CArray) color, t));
 								} else if(color instanceof CNull) {
 									tDisplay.setBackgroundColor(null);
@@ -3932,7 +3933,7 @@ public Mixed exec(Target t, Environment environment, Mixed... args) throws Confi
 								}
 								break;
 							case entity_spec.KEY_DISPLAY_TEXT_OPACITY:
-								long opacity = ArgumentValidation.getInt(specArray.get(index, t), t);
+								long opacity = ArgumentValidation.getInt(specArray.get(index, t, env), t, env);
 								if(opacity < 0 || opacity > 255) {
 									throw new CRERangeException("Text opacity outside valid range.", t);
 								}
@@ -3948,10 +3949,10 @@ public Mixed exec(Target t, Environment environment, Mixed... args) throws Confi
 					for(String index : specArray.stringKeySet()) {
 						switch(index.toLowerCase()) {
 							case entity_spec.KEY_ARROW_CRITICAL:
-								trident.setCritical(ArgumentValidation.getBoolean(specArray.get(index, t), t));
+								trident.setCritical(ArgumentValidation.getBoolean(specArray.get(index, t, env), t, env));
 								break;
 							case entity_spec.KEY_ARROW_KNOCKBACK:
-								int k = ArgumentValidation.getInt32(specArray.get(index, t), t);
+								int k = ArgumentValidation.getInt32(specArray.get(index, t, env), t, env);
 								if(k < 0) {
 									throw new CRERangeException("Knockback can not be negative.", t);
 								} else {
@@ -3959,7 +3960,7 @@ public Mixed exec(Target t, Environment environment, Mixed... args) throws Confi
 								}
 								break;
 							case entity_spec.KEY_ARROW_DAMAGE:
-								double d = ArgumentValidation.getDouble(specArray.get(index, t), t);
+								double d = ArgumentValidation.getDouble(specArray.get(index, t, env), t, env);
 								if(d < 0) {
 									throw new CRERangeException("Damage cannot be negative.", t);
 								}
@@ -3976,23 +3977,23 @@ public Mixed exec(Target t, Environment environment, Mixed... args) throws Confi
 						switch(index.toLowerCase()) {
 							case entity_spec.KEY_TROPICALFISH_COLOR:
 								try {
-									fish.setBodyColor(MCDyeColor.valueOf(specArray.get(index, t).val().toUpperCase()));
+									fish.setBodyColor(MCDyeColor.valueOf(specArray.get(index, t, env).val().toUpperCase()));
 								} catch(IllegalArgumentException exception) {
-									throw new CREFormatException("Invalid fish color: " + specArray.get(index, t).val(), t);
+									throw new CREFormatException("Invalid fish color: " + specArray.get(index, t, env).val(), t);
 								}
 								break;
 							case entity_spec.KEY_TROPICALFISH_PATTERNCOLOR:
 								try {
-									fish.setPatternColor(MCDyeColor.valueOf(specArray.get(index, t).val().toUpperCase()));
+									fish.setPatternColor(MCDyeColor.valueOf(specArray.get(index, t, env).val().toUpperCase()));
 								} catch(IllegalArgumentException exception) {
-									throw new CREFormatException("Invalid fish pattern color: " + specArray.get(index, t).val(), t);
+									throw new CREFormatException("Invalid fish pattern color: " + specArray.get(index, t, env).val(), t);
 								}
 								break;
 							case entity_spec.KEY_TROPICALFISH_PATTERN:
 								try {
-									fish.setPattern(MCTropicalFish.MCPattern.valueOf(specArray.get(index, t).val().toUpperCase()));
+									fish.setPattern(MCTropicalFish.MCPattern.valueOf(specArray.get(index, t, env).val().toUpperCase()));
 								} catch(IllegalArgumentException exception) {
-									throw new CREFormatException("Invalid fish pattern: " + specArray.get(index, t).val(), t);
+									throw new CREFormatException("Invalid fish pattern: " + specArray.get(index, t, env).val(), t);
 								}
 								break;
 							default:
@@ -4005,7 +4006,7 @@ public Mixed exec(Target t, Environment environment, Mixed... args) throws Confi
 					for(String index : specArray.stringKeySet()) {
 						switch(index.toLowerCase()) {
 							case entity_spec.KEY_VEX_CHARGING:
-								vex.setCharging(ArgumentValidation.getBooleanObject(specArray.get(index, t), t));
+								vex.setCharging(ArgumentValidation.getBooleanObject(specArray.get(index, t, env), t, env));
 								break;
 							default:
 								throwException(index, t);
@@ -4018,25 +4019,25 @@ public Mixed exec(Target t, Environment environment, Mixed... args) throws Confi
 						switch(index.toLowerCase()) {
 							case entity_spec.KEY_VILLAGER_PROFESSION:
 								try {
-									villager.setProfession(MCProfession.valueOf(specArray.get(index, t).val().toUpperCase()));
+									villager.setProfession(MCProfession.valueOf(specArray.get(index, t, env).val().toUpperCase()));
 								} catch(IllegalArgumentException exception) {
-									throw new CREFormatException("Invalid profession: " + specArray.get(index, t).val(), t);
+									throw new CREFormatException("Invalid profession: " + specArray.get(index, t, env).val(), t);
 								}
 								break;
 							case entity_spec.KEY_VILLAGER_LEVEL:
 								try {
-									villager.setLevel(ArgumentValidation.getInt32(specArray.get(index, t), t));
+									villager.setLevel(ArgumentValidation.getInt32(specArray.get(index, t, env), t, env));
 								} catch(IllegalArgumentException exception) {
 									throw new CRERangeException("Expected profession level to be 1-5, but got "
-											+ specArray.get(index, t).val(), t);
+											+ specArray.get(index, t, env).val(), t);
 								}
 								break;
 							case entity_spec.KEY_VILLAGER_EXPERIENCE:
 								try {
-									villager.setExperience(ArgumentValidation.getInt32(specArray.get(index, t), t));
+									villager.setExperience(ArgumentValidation.getInt32(specArray.get(index, t, env), t, env));
 								} catch(IllegalArgumentException exception) {
 									throw new CRERangeException("Expected experience to be a positive number, but got "
-											+ specArray.get(index, t).val(), t);
+											+ specArray.get(index, t, env).val(), t);
 								}
 								break;
 							default:
@@ -4049,10 +4050,10 @@ public Mixed exec(Target t, Environment environment, Mixed... args) throws Confi
 					for(String index : specArray.stringKeySet()) {
 						switch(index.toLowerCase()) {
 							case entity_spec.KEY_WITHER_SKULL_CHARGED:
-								skull.setCharged(ArgumentValidation.getBoolean(specArray.get(index, t), t));
+								skull.setCharged(ArgumentValidation.getBoolean(specArray.get(index, t, env), t, env));
 								break;
 							case entity_spec.KEY_FIREBALL_DIRECTION:
-								skull.setDirection(ObjectGenerator.GetGenerator().vector(specArray.get(index, t), t));
+								skull.setDirection(ObjectGenerator.GetGenerator().vector(specArray.get(index, t, env), t));
 								break;
 							default:
 								throwException(index, t);
@@ -4064,30 +4065,30 @@ public Mixed exec(Target t, Environment environment, Mixed... args) throws Confi
 					for(String index : specArray.stringKeySet()) {
 						switch(index.toLowerCase()) {
 							case entity_spec.KEY_WOLF_ANGRY:
-								wolf.setAngry(ArgumentValidation.getBoolean(specArray.get(index, t), t));
+								wolf.setAngry(ArgumentValidation.getBoolean(specArray.get(index, t, env), t, env));
 								break;
 							case entity_spec.KEY_WOLF_COLOR:
 								try {
-									wolf.setCollarColor(MCDyeColor.valueOf(specArray.get(index, t).val().toUpperCase()));
+									wolf.setCollarColor(MCDyeColor.valueOf(specArray.get(index, t, env).val().toUpperCase()));
 								} catch(IllegalArgumentException exception) {
-									throw new CREFormatException("Invalid collar color: " + specArray.get(index, t).val(), t);
+									throw new CREFormatException("Invalid collar color: " + specArray.get(index, t, env).val(), t);
 								}
 								break;
 							case entity_spec.KEY_GENERIC_SITTING:
-								wolf.setSitting(ArgumentValidation.getBoolean(specArray.get(index, t), t));
+								wolf.setSitting(ArgumentValidation.getBoolean(specArray.get(index, t, env), t, env));
 								break;
 							case entity_spec.KEY_WOLF_INTERESTED:
 								if(Static.getServer().getMinecraftVersion().gte(MCVersion.MC1_20_6)) {
-									wolf.setInterested(ArgumentValidation.getBooleanObject(specArray.get(index, t), t));
+									wolf.setInterested(ArgumentValidation.getBooleanObject(specArray.get(index, t, env), t, env));
 								}
 								break;
 							case entity_spec.KEY_WOLF_TYPE:
 								if(Static.getServer().getMinecraftVersion().gte(MCVersion.MC1_20_6)) {
 									try {
-										MCWolf.Variant type = MCWolf.Variant.valueOf(specArray.get(index, t).val());
+										MCWolf.Variant type = MCWolf.Variant.valueOf(specArray.get(index, t, env).val());
 										wolf.setWolfVariant(type);
 									} catch (IllegalArgumentException ex) {
-										throw new CREFormatException("Invalid wolf type: " + specArray.get(index, t).val(), t);
+										throw new CREFormatException("Invalid wolf type: " + specArray.get(index, t, env).val(), t);
 									}
 								}
 								break;
@@ -4101,7 +4102,7 @@ public Mixed exec(Target t, Environment environment, Mixed... args) throws Confi
 					for(String index : specArray.stringKeySet()) {
 						switch(index.toLowerCase()) {
 							case entity_spec.KEY_GENERIC_BABY:
-								if(ArgumentValidation.getBooleanObject(specArray.get(index, t), t)) {
+								if(ArgumentValidation.getBooleanObject(specArray.get(index, t, env), t, env)) {
 									zoglin.setBaby();
 								} else {
 									zoglin.setAdult();
@@ -4119,14 +4120,14 @@ public Mixed exec(Target t, Environment environment, Mixed... args) throws Confi
 					for(String index : specArray.stringKeySet()) {
 						switch(index.toLowerCase()) {
 							case entity_spec.KEY_GENERIC_BABY:
-								if(ArgumentValidation.getBooleanObject(specArray.get(index, t), t)) {
+								if(ArgumentValidation.getBooleanObject(specArray.get(index, t, env), t, env)) {
 									zombie.setBaby();
 								} else {
 									zombie.setAdult();
 								}
 								break;
 							case entity_spec.KEY_ZOMBIE_BREAK_DOORS:
-								zombie.setCanBreakDoors(ArgumentValidation.getBooleanObject(specArray.get(index, t), t));
+								zombie.setCanBreakDoors(ArgumentValidation.getBooleanObject(specArray.get(index, t, env), t, env));
 								break;
 							default:
 								throwException(index, t);
@@ -4138,7 +4139,7 @@ public Mixed exec(Target t, Environment environment, Mixed... args) throws Confi
 					for(String index : specArray.stringKeySet()) {
 						switch(index.toLowerCase()) {
 							case entity_spec.KEY_GENERIC_BABY:
-								if(ArgumentValidation.getBooleanObject(specArray.get(index, t), t)) {
+								if(ArgumentValidation.getBooleanObject(specArray.get(index, t, env), t, env)) {
 									zombievillager.setBaby();
 								} else {
 									zombievillager.setAdult();
@@ -4146,13 +4147,13 @@ public Mixed exec(Target t, Environment environment, Mixed... args) throws Confi
 								break;
 							case entity_spec.KEY_VILLAGER_PROFESSION:
 								try {
-									zombievillager.setProfession(MCProfession.valueOf(specArray.get(index, t).val().toUpperCase()));
+									zombievillager.setProfession(MCProfession.valueOf(specArray.get(index, t, env).val().toUpperCase()));
 								} catch(IllegalArgumentException exception) {
-									throw new CREFormatException("Invalid profession: " + specArray.get(index, t).val(), t);
+									throw new CREFormatException("Invalid profession: " + specArray.get(index, t, env).val(), t);
 								}
 								break;
 							case entity_spec.KEY_ZOMBIE_BREAK_DOORS:
-								zombievillager.setCanBreakDoors(ArgumentValidation.getBooleanObject(specArray.get(index, t), t));
+								zombievillager.setCanBreakDoors(ArgumentValidation.getBooleanObject(specArray.get(index, t, env), t, env));
 								break;
 							default:
 								throwException(index, t);
@@ -4164,20 +4165,20 @@ public Mixed exec(Target t, Environment environment, Mixed... args) throws Confi
 					for(String index : specArray.stringKeySet()) {
 						switch(index.toLowerCase()) {
 							case entity_spec.KEY_GENERIC_BABY:
-								if(ArgumentValidation.getBooleanObject(specArray.get(index, t), t)) {
+								if(ArgumentValidation.getBooleanObject(specArray.get(index, t, env), t, env)) {
 									pigZombie.setBaby();
 								} else {
 									pigZombie.setAdult();
 								}
 								break;
 							case entity_spec.KEY_ZOMBIFIED_PIGLIN_ANGRY:
-								pigZombie.setAngry(ArgumentValidation.getBoolean(specArray.get(index, t), t));
+								pigZombie.setAngry(ArgumentValidation.getBoolean(specArray.get(index, t, env), t, env));
 								break;
 							case entity_spec.KEY_ZOMBIFIED_PIGLIN_ANGER:
-								pigZombie.setAnger(ArgumentValidation.getInt32(specArray.get(index, t), t));
+								pigZombie.setAnger(ArgumentValidation.getInt32(specArray.get(index, t, env), t, env));
 								break;
 							case entity_spec.KEY_ZOMBIE_BREAK_DOORS:
-								pigZombie.setCanBreakDoors(ArgumentValidation.getBooleanObject(specArray.get(index, t), t));
+								pigZombie.setCanBreakDoors(ArgumentValidation.getBooleanObject(specArray.get(index, t, env), t, env));
 								break;
 							default:
 								throwException(index, t);
@@ -4216,7 +4217,7 @@ public String docs() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			MCEntity entity = Static.getEntity(args[0], t);
 
 			if(entity instanceof MCProjectile) {
@@ -4255,13 +4256,13 @@ public String docs() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			MCEntity entity = Static.getEntity(args[0], t);
 			if(entity instanceof MCProjectile) {
 				if(args[1] instanceof CNull) {
 					((MCProjectile) entity).setShooter(null);
-				} else if(args[1].isInstanceOf(CArray.TYPE)) {
-					MCBlock b = ObjectGenerator.GetGenerator().location(args[1], entity.getWorld(), t).getBlock();
+				} else if(args[1].isInstanceOf(CArray.TYPE, null, env)) {
+					MCBlock b = ObjectGenerator.GetGenerator().location(args[1], entity.getWorld(), t, env).getBlock();
 					if(b.isDispenser()) {
 						((MCProjectile) entity).setShooter(b.getDispenser().getBlockProjectileSource());
 					} else {
@@ -4297,7 +4298,7 @@ public String docs() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			MCEntity entity = Static.getEntity(args[0], t);
 			if(entity instanceof MCProjectile) {
 				return CBoolean.get(((MCProjectile) entity).doesBounce());
@@ -4327,10 +4328,10 @@ public String docs() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			MCEntity entity = Static.getEntity(args[0], t);
 			if(entity instanceof MCProjectile) {
-				((MCProjectile) entity).setBounce(ArgumentValidation.getBoolean(args[1], t));
+				((MCProjectile) entity).setBounce(ArgumentValidation.getBoolean(args[1], t, env));
 			} else {
 				throw new CREBadEntityException("The given entity is not a projectile.", t);
 			}
@@ -4360,7 +4361,7 @@ public String docs() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			MCEntity entity = Static.getEntity(args[0], t);
 			if(entity instanceof MCItemProjectile) {
 				return ObjectGenerator.GetGenerator().item(((MCItemProjectile) entity).getItem(), t);
@@ -4392,10 +4393,10 @@ public String docs() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			MCEntity entity = Static.getEntity(args[0], t);
 			if(entity instanceof MCItemProjectile) {
-				((MCItemProjectile) entity).setItem(ObjectGenerator.GetGenerator().item(args[1], t));
+				((MCItemProjectile) entity).setItem(ObjectGenerator.GetGenerator().item(args[1], t, env));
 			} else {
 				throw new CREBadEntityException("The given entity does not have a display item.", t);
 			}
@@ -4423,7 +4424,7 @@ public String docs() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			return new CDouble(Static.getEntity(args[0], t).getFallDistance(), t);
 		}
 
@@ -4448,8 +4449,8 @@ public String docs() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
-			Static.getEntity(args[0], t).setFallDistance(ArgumentValidation.getDouble32(args[1], t));
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
+			Static.getEntity(args[0], t).setFallDistance(ArgumentValidation.getDouble32(args[1], t, env));
 			return CVoid.VOID;
 		}
 
@@ -4474,8 +4475,8 @@ public String docs() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
-			Static.getEntity(args[0], t).setGlowing(ArgumentValidation.getBoolean(args[1], t));
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
+			Static.getEntity(args[0], t).setGlowing(ArgumentValidation.getBoolean(args[1], t, env));
 			return CVoid.VOID;
 		}
 
@@ -4500,7 +4501,7 @@ public String docs() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			MCEntity e = Static.getEntity(args[0], t);
 			return CBoolean.GenerateCBoolean(e.isGlowing(), t);
 		}
@@ -4526,7 +4527,7 @@ public String docs() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			return CBoolean.GenerateCBoolean(Static.getEntity(args[0], t).isSilent(), t);
 		}
 
@@ -4551,9 +4552,9 @@ public String docs() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			MCEntity e = Static.getEntity(args[0], t);
-			e.setSilent(ArgumentValidation.getBoolean(args[1], t));
+			e.setSilent(ArgumentValidation.getBoolean(args[1], t, env));
 			return CVoid.VOID;
 		}
 
@@ -4578,7 +4579,7 @@ public String docs() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			return CBoolean.GenerateCBoolean(Static.getEntity(args[0], t).hasGravity(), t);
 		}
 
@@ -4603,9 +4604,9 @@ public String docs() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			MCEntity e = Static.getEntity(args[0], t);
-			e.setHasGravity(ArgumentValidation.getBoolean(args[1], t));
+			e.setHasGravity(ArgumentValidation.getBoolean(args[1], t, env));
 			return CVoid.VOID;
 		}
 
@@ -4630,7 +4631,7 @@ public String docs() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			return CBoolean.GenerateCBoolean(Static.getEntity(args[0], t).isInvulnerable(), t);
 		}
 
@@ -4656,9 +4657,9 @@ public String docs() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			MCEntity e = Static.getEntity(args[0], t);
-			e.setInvulnerable(ArgumentValidation.getBoolean(args[1], t));
+			e.setInvulnerable(ArgumentValidation.getBoolean(args[1], t, env));
 			return CVoid.VOID;
 		}
 
@@ -4684,7 +4685,7 @@ public String docs() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			MCEntity e = Static.getEntity(args[0], t);
 			return new CInt(e.getFreezingTicks(), t);
 		}
@@ -4717,9 +4718,9 @@ public Class<? extends CREThrowable>[] thrown() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			MCEntity entity = Static.getEntity(args[0], t);
-			int ticks = ArgumentValidation.getInt32(args[1], t);
+			int ticks = ArgumentValidation.getInt32(args[1], t, env);
 			if(ticks < 0) {
 				throw new CRERangeException("Freezing ticks must not be below zero.", t);
 			}
@@ -4748,11 +4749,11 @@ public String docs() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			MCEntity e = Static.getEntity(args[0], t);
 			CArray tags = new CArray(t);
 			for(String tag : e.getScoreboardTags()) {
-				tags.push(new CString(tag, t), t);
+				tags.push(new CString(tag, t), t, env);
 			}
 			return tags;
 		}
@@ -4783,7 +4784,7 @@ public String docs() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			MCEntity e = Static.getEntity(args[0], t);
 			return CBoolean.get(e.hasScoreboardTag(args[1].val()));
 		}
@@ -4809,7 +4810,7 @@ public String docs() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			MCEntity e = Static.getEntity(args[0], t);
 			return CBoolean.get(e.addScoreboardTag(args[1].val()));
 		}
@@ -4835,7 +4836,7 @@ public String docs() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			MCEntity e = Static.getEntity(args[0], t);
 			return CBoolean.get(e.removeScoreboardTag(args[1].val()));
 		}
@@ -4888,7 +4889,7 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment env, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			MCLocation l;
 			MCItemStack is;
 			boolean natural;
@@ -4899,26 +4900,26 @@ public Mixed exec(Target t, Environment env, Mixed... args) throws ConfigRuntime
 				} else {
 					throw new CREPlayerOfflineException("Invalid sender!", t);
 				}
-				is = ObjectGenerator.GetGenerator().item(args[0], t);
+				is = ObjectGenerator.GetGenerator().item(args[0], t, env);
 			} else {
 				MCPlayer p;
-				if(args[0].isInstanceOf(CArray.TYPE)) {
+				if(args[0].isInstanceOf(CArray.TYPE, null, env)) {
 					p = env.getEnv(CommandHelperEnvironment.class).GetPlayer();
-					l = ObjectGenerator.GetGenerator().location(args[0], (p != null ? p.getWorld() : null), t);
+					l = ObjectGenerator.GetGenerator().location(args[0], (p != null ? p.getWorld() : null), t, env);
 					natural = true;
 				} else {
-					p = Static.GetPlayer(args[0].val(), t);
+					p = Static.GetPlayer(args[0].val(), t, env);
 					l = p.getEyeLocation();
 					natural = false;
 				}
-				is = ObjectGenerator.GetGenerator().item(args[1], t);
+				is = ObjectGenerator.GetGenerator().item(args[1], t, env);
 			}
 			if(is.isEmpty()) {
 				// can't drop air
 				return CNull.NULL;
 			}
 			if(args.length == 3) {
-				natural = ArgumentValidation.getBoolean(args[2], t);
+				natural = ArgumentValidation.getBoolean(args[2], t, env);
 			}
 			MCItem item;
 			if(natural) {
@@ -4949,23 +4950,23 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
-			MCPlayer p = environment.getEnv(CommandHelperEnvironment.class).GetPlayer();
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
+			MCPlayer p = env.getEnv(CommandHelperEnvironment.class).GetPlayer();
 			MCWorld w = null;
 			if(p != null) {
 				w = p.getWorld();
 			}
-			MCLocation loc = ObjectGenerator.GetGenerator().location(args[0], w, t);
+			MCLocation loc = ObjectGenerator.GetGenerator().location(args[0], w, t, env);
 			CArray options;
 			if(args.length == 2) {
-				options = ArgumentValidation.getArray(args[1], t);
+				options = ArgumentValidation.getArray(args[1], t, env);
 			} else {
-				options = CArray.GetAssociativeArray(t);
+				options = CArray.GetAssociativeArray(t, null, env);
 			}
 
 			int strength = 2;
 			if(options.containsKey("strength")) {
-				strength = ArgumentValidation.getInt32(options.get("strength", t), t);
+				strength = ArgumentValidation.getInt32(options.get("strength", t, env), t, env);
 				if(strength > 127) {
 					throw new CRERangeException("Strength cannot be higher than 127", t);
 				}
@@ -4973,9 +4974,9 @@ public Mixed exec(Target t, Environment environment, Mixed... args) throws Confi
 
 			List<MCFireworkEffect> effects = new ArrayList<>();
 			if(options.containsKey("effects")) {
-				Mixed cEffects = options.get("effects", t);
-				if(cEffects.isInstanceOf(CArray.TYPE)) {
-					for(Mixed c : ((CArray) cEffects).asList()) {
+				Mixed cEffects = options.get("effects", t, env);
+				if(cEffects.isInstanceOf(CArray.TYPE, null, env)) {
+					for(Mixed c : ((CArray) cEffects).asList(env)) {
 						effects.add(ObjectGenerator.GetGenerator().fireworkEffect((CArray) c, t));
 					}
 				} else {
@@ -5063,7 +5064,7 @@ public MSVersion since() {
 	public static class get_hanging_direction extends EntityGetterFunction {
 
 		@Override
-		public Mixed exec(Target t, com.laytonsmith.core.environments.Environment environment, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, com.laytonsmith.core.environments.Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			MCEntity entity = Static.getEntity(args[0], t);
 			if(entity instanceof MCHanging hanging) {
 				return new CString(hanging.getFacing().name(), t);
@@ -5120,7 +5121,7 @@ public CClassType getReturnType(Target t, List<CClassType> argTypes, List<Target
 		}
 
 		@Override
-		public Mixed exec(Target t, com.laytonsmith.core.environments.Environment environment, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, com.laytonsmith.core.environments.Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			MCEntity entity = Static.getEntity(args[0], t);
 			if(entity instanceof MCHanging hanging) {
 				MCBlockFace face;
@@ -5128,7 +5129,7 @@ public Mixed exec(Target t, com.laytonsmith.core.environments.Environment enviro
 					face = MCBlockFace.valueOf(args[1].val());
 					boolean force = false;
 					if(args.length == 3) {
-						force = ArgumentValidation.getBooleanObject(args[2], t);
+						force = ArgumentValidation.getBooleanObject(args[2], t, env);
 					}
 					hanging.setFacingDirection(face, force);
 					return CVoid.VOID;
@@ -5246,40 +5247,40 @@ public String docs() {
 		}
 
 		@Override
-		public Mixed exec(Target t, com.laytonsmith.core.environments.Environment environment, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, com.laytonsmith.core.environments.Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			MCEntity entity = Static.getEntity(args[0], t);
 			if(!(entity instanceof MCDisplay display)) {
 				throw new CREBadEntityException("Not a display entity.", t);
 			}
-			CArray info = CArray.GetAssociativeArray(t);
-			info.set("billboard", display.getBillboard().name());
+			CArray info = CArray.GetAssociativeArray(t, null, env);
+			info.set("billboard", display.getBillboard().name(), env);
 			MCDisplay.Brightness brightness = display.getBrightness();
 			if(brightness != null) {
-				CArray brightnessArray = CArray.GetAssociativeArray(t);
-				brightnessArray.set("block", new CInt(brightness.block(), t), t);
-				brightnessArray.set("sky", new CInt(brightness.block(), t), t);
-				info.set("brightness", brightnessArray, t);
+				CArray brightnessArray = CArray.GetAssociativeArray(t, null, env);
+				brightnessArray.set("block", new CInt(brightness.block(), t), t, env);
+				brightnessArray.set("sky", new CInt(brightness.block(), t), t, env);
+				info.set("brightness", brightnessArray, t, env);
 			} else {
-				info.set("brightness", CNull.NULL, t);
+				info.set("brightness", CNull.NULL, t, env);
 			}
 			MCColor color = display.getGlowColorOverride();
 			if(color != null) {
-				info.set("glowcolor", ObjectGenerator.GetGenerator().color(color, t), t);
+				info.set("glowcolor", ObjectGenerator.GetGenerator().color(color, t), t, env);
 			} else {
-				info.set("glowcolor", CNull.NULL, t);
+				info.set("glowcolor", CNull.NULL, t, env);
 			}
-			info.set("height", new CDouble(display.getDisplayHeight(), t), t);
-			info.set("width", new CDouble(display.getDisplayWidth(), t), t);
-			info.set("viewrange", new CDouble(display.getViewRange(), t), t);
-			info.set("shadowradius", new CDouble(display.getShadowRadius(), t), t);
-			info.set("shadowstrength", new CDouble(display.getShadowStrength(), t), t);
+			info.set("height", new CDouble(display.getDisplayHeight(), t), t, env);
+			info.set("width", new CDouble(display.getDisplayWidth(), t), t, env);
+			info.set("viewrange", new CDouble(display.getViewRange(), t), t, env);
+			info.set("shadowradius", new CDouble(display.getShadowRadius(), t), t, env);
+			info.set("shadowstrength", new CDouble(display.getShadowStrength(), t), t, env);
 			if(Static.getServer().getMinecraftVersion().gte(MCVersion.MC1_20_2)) {
-				info.set("teleportduration", new CInt(display.getTeleportDuration(), t), t);
+				info.set("teleportduration", new CInt(display.getTeleportDuration(), t), t, env);
 			}
-			info.set("interpolationduration", new CInt(display.getInterpolationDurationTicks(), t), t);
+			info.set("interpolationduration", new CInt(display.getInterpolationDurationTicks(), t), t, env);
 			MCTransformation tr = display.getTransformation();
 			CArray transformation = GetArrayFromTransformation(tr);
-			info.set("transformation", transformation, t);
+			info.set("transformation", transformation, t, env);
 			return info;
 		}
 
@@ -5378,19 +5379,19 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment env, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			float f[] = new float[16];
 			if(args.length == 1) {
-				CArray array = ArgumentValidation.getArray(args[0], t);
-				if(array.size() != 16) {
+				CArray array = ArgumentValidation.getArray(args[0], t, env);
+				if(array.size(env) != 16) {
 					throw new CRELengthException("Input array expected to have length 16", t);
 				}
 				for(int i = 0; i < 16; i++) {
-					f[i] = ArgumentValidation.getDouble32(array.get(i, t), t);
+					f[i] = ArgumentValidation.getDouble32(array.get(i, t, env), t, env);
 				}
 			} else {
 				for(int i = 0; i < 16; i++) {
-					f[i] = ArgumentValidation.getDouble32(args[i], t);
+					f[i] = ArgumentValidation.getDouble32(args[i], t, env);
 				}
 			}
 			MCTransformation tr = GetTransformationFromMatrix(f);
@@ -5455,40 +5456,40 @@ public String docs() {
 		}
 
 		@Override
-		public Mixed exec(Target t, com.laytonsmith.core.environments.Environment environment, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, com.laytonsmith.core.environments.Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			MCEntity entity = Static.getEntity(args[0], t);
 			if(!(entity instanceof MCDisplay display)) {
 				throw new CREBadEntityException("Not a display entity.", t);
 			}
-			CArray info = ArgumentValidation.getArray(args[1], t);
+			CArray info = ArgumentValidation.getArray(args[1], t, env);
 			if(!info.isAssociative()) {
 				throw new CREIllegalArgumentException("Expected an associative array but found a normal array.", t);
 			}
 			if(info.containsKey("billboard")) {
 				try {
-					MCDisplay.Billboard billboard = MCDisplay.Billboard.valueOf(info.get("billboard", t).val());
+					MCDisplay.Billboard billboard = MCDisplay.Billboard.valueOf(info.get("billboard", t, env).val());
 					display.setBillboard(billboard);
 				} catch(IllegalArgumentException ex) {
 					throw new CREFormatException("Invalid billboard type for display entity.", t);
 				}
 			}
 			if(info.containsKey("brightness")) {
-				Mixed m = info.get("brightness", t);
+				Mixed m = info.get("brightness", t, env);
 				if(m instanceof CNull) {
 					display.setBrightness(null);
 				} else {
 					MCDisplay.Brightness brightness;
-					if(m.isInstanceOf(CArray.TYPE)) {
+					if(m.isInstanceOf(CArray.TYPE, null, env)) {
 						CArray brightnessArray = (CArray) m;
 						if(!brightnessArray.isAssociative()) {
 							throw new CREIllegalArgumentException(
 									"Expected an associative array for brightness but found a normal array.", t);
 						}
-						int blockBrightness = ArgumentValidation.getInt32(brightnessArray.get("block", t), t);
-						int skyBrightness = ArgumentValidation.getInt32(brightnessArray.get("sky", t), t);
+						int blockBrightness = ArgumentValidation.getInt32(brightnessArray.get("block", t, env), t, env);
+						int skyBrightness = ArgumentValidation.getInt32(brightnessArray.get("sky", t, env), t, env);
 						brightness = new MCDisplay.Brightness(blockBrightness, skyBrightness);
 					} else {
-						int level = ArgumentValidation.getInt32(m, t);
+						int level = ArgumentValidation.getInt32(m, t, env);
 						brightness = new MCDisplay.Brightness(level, level);
 					}
 					try {
@@ -5499,46 +5500,46 @@ public Mixed exec(Target t, com.laytonsmith.core.environments.Environment enviro
 				}
 			}
 			if(info.containsKey("glowcolor")) {
-				Mixed m = info.get("glowcolor", t);
+				Mixed m = info.get("glowcolor", t, env);
 				if(!(m instanceof CNull)) {
-					MCColor color = ObjectGenerator.GetGenerator().color(ArgumentValidation.getArray(m, t), t);
+					MCColor color = ObjectGenerator.GetGenerator().color(ArgumentValidation.getArray(m, t, env), t);
 					display.setGlowColorOverride(color);
 				}
 			}
 			if(info.containsKey("height")) {
-				display.setDisplayHeight((float) ArgumentValidation.getDouble(info.get("height", t), t));
+				display.setDisplayHeight((float) ArgumentValidation.getDouble(info.get("height", t, env), t, env));
 			}
 			if(info.containsKey("width")) {
-				display.setDisplayWidth((float) ArgumentValidation.getDouble(info.get("width", t), t));
+				display.setDisplayWidth((float) ArgumentValidation.getDouble(info.get("width", t, env), t, env));
 			}
 			if(info.containsKey("viewrange")) {
-				display.setViewRange((float) ArgumentValidation.getDouble(info.get("viewrange", t), t));
+				display.setViewRange((float) ArgumentValidation.getDouble(info.get("viewrange", t, env), t, env));
 			}
 			if(info.containsKey("shadowradius")) {
-				display.setShadowRadius((float) ArgumentValidation.getDouble(info.get("shadowradius", t), t));
+				display.setShadowRadius((float) ArgumentValidation.getDouble(info.get("shadowradius", t, env), t, env));
 			}
 			if(info.containsKey("shadowstrength")) {
-				display.setShadowStrength((float) ArgumentValidation.getDouble(info.get("shadowstrength", t), t));
+				display.setShadowStrength((float) ArgumentValidation.getDouble(info.get("shadowstrength", t, env), t, env));
 			}
 			if(info.containsKey("teleportduration") && Static.getServer().getMinecraftVersion().gte(MCVersion.MC1_20_2)) {
-				int ticks = ArgumentValidation.getInt32(info.get("teleportduration", t), t);
+				int ticks = ArgumentValidation.getInt32(info.get("teleportduration", t, env), t, env);
 				if(ticks < 0 || ticks > 59) {
 					throw new CRERangeException("Teleport duration must be from 0 - 59, but got " + ticks, t);
 				}
 				display.setTeleportDuration(ticks);
 			}
 			if(info.containsKey("interpolationduration")) {
-				display.setInterpolationDurationTicks(ArgumentValidation.getInt32(info.get("interpolationduration", t), t));
+				display.setInterpolationDurationTicks(ArgumentValidation.getInt32(info.get("interpolationduration", t, env), t, env));
 			}
 			if(info.containsKey("startinterpolation")) {
-				display.setInterpolationDelayTicks(ArgumentValidation.getInt32(info.get("startinterpolation", t), t));
+				display.setInterpolationDelayTicks(ArgumentValidation.getInt32(info.get("startinterpolation", t, env), t, env));
 			}
 			if(info.containsKey("transformation")) {
-				CArray transformation = ArgumentValidation.getArray(info.get("transformation", t), t);
-				if(transformation.size() == 16) {
+				CArray transformation = ArgumentValidation.getArray(info.get("transformation", t, env), t, env);
+				if(transformation.size(env) == 16) {
 					float[] f = new float[16];
 					for(int i = 0; i < 16; i++) {
-						f[i] = ArgumentValidation.getDouble32(transformation.get(i, t), t);
+						f[i] = ArgumentValidation.getDouble32(transformation.get(i, t, env), t, env);
 					}
 					MCTransformation tr = GetTransformationFromMatrix(f);
 					display.setTransformation(tr);
@@ -5546,43 +5547,43 @@ public Mixed exec(Target t, com.laytonsmith.core.environments.Environment enviro
 					MCTransformation existingTransformation = display.getTransformation();
 					Quaternionf leftRotation;
 					if(transformation.containsKey("leftRotation")) {
-						CArray leftRotationC = ArgumentValidation.getArray(transformation.get("leftRotation", t), t);
+						CArray leftRotationC = ArgumentValidation.getArray(transformation.get("leftRotation", t, env), t, env);
 						leftRotation = new Quaternionf(
-								ArgumentValidation.getDouble(leftRotationC.get("x", t), t),
-								ArgumentValidation.getDouble(leftRotationC.get("y", t), t),
-								ArgumentValidation.getDouble(leftRotationC.get("z", t), t),
-								ArgumentValidation.getDouble(leftRotationC.get("w", t), t));
+								ArgumentValidation.getDouble(leftRotationC.get("x", t, env), t, env),
+								ArgumentValidation.getDouble(leftRotationC.get("y", t, env), t, env),
+								ArgumentValidation.getDouble(leftRotationC.get("z", t, env), t, env),
+								ArgumentValidation.getDouble(leftRotationC.get("w", t, env), t, env));
 					} else {
 						leftRotation = existingTransformation.getLeftRotation();
 					}
 					Quaternionf rightRotation;
 					if(transformation.containsKey("rightRotation")) {
-						CArray rightRotationC = ArgumentValidation.getArray(transformation.get("rightRotation", t), t);
+						CArray rightRotationC = ArgumentValidation.getArray(transformation.get("rightRotation", t, env), t, env);
 						rightRotation = new Quaternionf(
-								ArgumentValidation.getDouble(rightRotationC.get("x", t), t),
-								ArgumentValidation.getDouble(rightRotationC.get("y", t), t),
-								ArgumentValidation.getDouble(rightRotationC.get("z", t), t),
-								ArgumentValidation.getDouble(rightRotationC.get("w", t), t));
+								ArgumentValidation.getDouble(rightRotationC.get("x", t, env), t, env),
+								ArgumentValidation.getDouble(rightRotationC.get("y", t, env), t, env),
+								ArgumentValidation.getDouble(rightRotationC.get("z", t, env), t, env),
+								ArgumentValidation.getDouble(rightRotationC.get("w", t, env), t, env));
 					} else {
 						rightRotation = existingTransformation.getRightRotation();
 					}
 					Vector3f scale;
 					if(transformation.containsKey("scale")) {
-						CArray scaleC = ArgumentValidation.getArray(transformation.get("scale", t), t);
+						CArray scaleC = ArgumentValidation.getArray(transformation.get("scale", t, env), t, env);
 						scale = new Vector3f(
-								ArgumentValidation.getDouble32(scaleC.get("x", t), t),
-								ArgumentValidation.getDouble32(scaleC.get("y", t), t),
-								ArgumentValidation.getDouble32(scaleC.get("z", t), t));
+								ArgumentValidation.getDouble32(scaleC.get("x", t, env), t, env),
+								ArgumentValidation.getDouble32(scaleC.get("y", t, env), t, env),
+								ArgumentValidation.getDouble32(scaleC.get("z", t, env), t, env));
 					} else {
 						scale = existingTransformation.getScale();
 					}
 					Vector3f translation;
 					if(transformation.containsKey("translation")) {
-						CArray translationC = ArgumentValidation.getArray(transformation.get("translation", t), t);
+						CArray translationC = ArgumentValidation.getArray(transformation.get("translation", t, env), t, env);
 						translation = new Vector3f(
-								ArgumentValidation.getDouble32(translationC.get("x", t), t),
-								ArgumentValidation.getDouble32(translationC.get("y", t), t),
-								ArgumentValidation.getDouble32(translationC.get("z", t), t));
+								ArgumentValidation.getDouble32(translationC.get("x", t, env), t, env),
+								ArgumentValidation.getDouble32(translationC.get("y", t, env), t, env),
+								ArgumentValidation.getDouble32(translationC.get("z", t, env), t, env));
 					} else {
 						translation = existingTransformation.getTranslation();
 					}
@@ -5615,7 +5616,7 @@ public boolean isRestricted() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment env, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			MCEntity entity = Static.getEntity(args[0], t);
 			return new CInt(entity.getEntityId(), t);
 		}
@@ -5654,7 +5655,7 @@ public String docs() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment env, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			MCEntity entity = Static.getEntity(args[0], t);
 			return CBoolean.get(entity.isInWater());
 		}
@@ -5684,13 +5685,13 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment env, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			MCEntity entity = Static.getEntity(args[0], t);
 
-			float yaw = (float) ArgumentValidation.getDouble(args[1], t);
+			float yaw = (float) ArgumentValidation.getDouble(args[1], t, env);
 			float pitch;
 			if(args.length == 3) {
-				pitch = (float) ArgumentValidation.getDouble(args[2], t);
+				pitch = (float) ArgumentValidation.getDouble(args[2], t, env);
 			} else {
 				pitch = entity.getLocation().getPitch();
 			}
@@ -5732,7 +5733,7 @@ public Version since() {
 	public static class get_entity_killer extends EntityGetterFunction {
 
 		@Override
-		public Mixed exec(Target t, Environment env, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			MCLivingEntity entity = Static.getLivingEntity(args[0], t);
 			MCPlayer killer = entity.getKiller();
 			if(killer == null) {
@@ -5769,12 +5770,12 @@ public Class<? extends CREThrowable>[] thrown() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment env, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			MCLivingEntity entity = Static.getLivingEntity(args[0], t);
 			if(args[1] instanceof CNull) {
 				entity.setKiller(null);
 			} else {
-				MCPlayer killer = Static.GetPlayer(args[1], t);
+				MCPlayer killer = Static.GetPlayer(args[1], t, env);
 				entity.setKiller(killer);
 			}
 			return CVoid.VOID;
@@ -5816,7 +5817,7 @@ public String docs() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment env, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			MCEntity entity = Static.getEntity(args[0], t);
 			return CBoolean.get(!entity.isVisibleByDefault());
 		}
@@ -5845,9 +5846,9 @@ public String docs() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment env, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			MCEntity entity = Static.getEntity(args[0], t);
-			entity.setVisibleByDefault(!ArgumentValidation.getBooleanObject(args[1], t));
+			entity.setVisibleByDefault(!ArgumentValidation.getBooleanObject(args[1], t, env));
 			return CVoid.VOID;
 		}
 
@@ -5915,7 +5916,7 @@ public String docs() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment env, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			MCEntity entity = Static.getEntity(args[0], t);
 			return new CString(entity.getPose().name(), t);
 		}
@@ -5953,14 +5954,14 @@ public String docs() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment env, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			MCEntity entity = Static.getEntity(args[0], t);
 			MCPose pose;
 			try {
 				pose = MCPose.valueOf(args[1].val().toUpperCase());
 				boolean fixed = false;
 				if(args.length == 3) {
-					fixed = ArgumentValidation.getBooleanObject(args[2], t);
+					fixed = ArgumentValidation.getBooleanObject(args[2], t, env);
 				}
 				entity.setPose(pose, fixed);
 			} catch(IllegalArgumentException ex) {
diff --git a/src/main/java/com/laytonsmith/core/functions/Environment.java b/src/main/java/com/laytonsmith/core/functions/Environment.java
index 86c2e365c5..c7e567d26f 100644
--- a/src/main/java/com/laytonsmith/core/functions/Environment.java
+++ b/src/main/java/com/laytonsmith/core/functions/Environment.java
@@ -58,6 +58,7 @@
 import com.laytonsmith.core.constructs.CVoid;
 import com.laytonsmith.core.constructs.Construct;
 import com.laytonsmith.core.constructs.Target;
+import com.laytonsmith.core.constructs.generics.GenericParameters;
 import com.laytonsmith.core.environments.CommandHelperEnvironment;
 import com.laytonsmith.core.exceptions.CRE.CREBadEntityException;
 import com.laytonsmith.core.exceptions.CRE.CRECastException;
@@ -105,7 +106,7 @@ public String docs() {
 		}
 
 		@Override
-		public Mixed exec(Target t, com.laytonsmith.core.environments.Environment env, Mixed... args)
+		public Mixed exec(Target t, com.laytonsmith.core.environments.Environment env, GenericParameters generics, Mixed... args)
 				throws CancelCommandException, ConfigRuntimeException {
 			MCLocation loc = ObjectGenerator.GetGenerator().location(args[0], null, t);
 			MCBlock b = loc.getWorld().getBlockAt(loc.getBlockX(), loc.getBlockY(), loc.getBlockZ());
@@ -158,12 +159,12 @@ public String docs() {
 		}
 
 		@Override
-		public Mixed exec(Target t, com.laytonsmith.core.environments.Environment env, Mixed... args)
+		public Mixed exec(Target t, com.laytonsmith.core.environments.Environment env, GenericParameters generics, Mixed... args)
 				throws CancelCommandException, ConfigRuntimeException {
 			MCLocation loc = ObjectGenerator.GetGenerator().location(args[0], null, t);
 			boolean physics = true;
 			if(args.length == 3) {
-				physics = ArgumentValidation.getBoolean(args[2], t);
+				physics = ArgumentValidation.getBoolean(args[2], t, env);
 			}
 			MCMaterial mat = StaticLayer.GetMaterial(args[1].val());
 			if(mat == null) {
@@ -215,7 +216,7 @@ public String docs() {
 		}
 
 		@Override
-		public Mixed exec(Target t, com.laytonsmith.core.environments.Environment env, Mixed... args)
+		public Mixed exec(Target t, com.laytonsmith.core.environments.Environment env, GenericParameters generics, Mixed... args)
 				throws CancelCommandException, ConfigRuntimeException {
 			MCLocation loc = ObjectGenerator.GetGenerator().location(args[0], null, t);
 			MCBlock b = loc.getWorld().getBlockAt(loc.getBlockX(), loc.getBlockY(), loc.getBlockZ());
@@ -268,7 +269,7 @@ public String docs() {
 		}
 
 		@Override
-		public Mixed exec(Target t, com.laytonsmith.core.environments.Environment env, Mixed... args)
+		public Mixed exec(Target t, com.laytonsmith.core.environments.Environment env, GenericParameters generics, Mixed... args)
 				throws CancelCommandException, ConfigRuntimeException {
 			MCLocation loc = ObjectGenerator.GetGenerator().location(args[0], null, t);
 			MCBlock b = loc.getWorld().getBlockAt(loc.getBlockX(), loc.getBlockY(), loc.getBlockZ());
@@ -283,7 +284,7 @@ public Mixed exec(Target t, com.laytonsmith.core.environments.Environment env, M
 			}
 			boolean physics = true;
 			if(args.length == 3) {
-				physics = ArgumentValidation.getBoolean(args[2], t);
+				physics = ArgumentValidation.getBoolean(args[2], t, env);
 			}
 			b.setBlockData(bd, physics);
 			return CVoid.VOID;
@@ -330,7 +331,7 @@ public String docs() {
 		}
 
 		@Override
-		public Mixed exec(Target t, com.laytonsmith.core.environments.Environment env, Mixed... args)
+		public Mixed exec(Target t, com.laytonsmith.core.environments.Environment env, GenericParameters generics, Mixed... args)
 				throws CancelCommandException, ConfigRuntimeException {
 			MCLocation loc = ObjectGenerator.GetGenerator().location(args[0], null, t);
 			MCBlock b = loc.getWorld().getBlockAt(loc.getBlockX(), loc.getBlockY(), loc.getBlockZ());
@@ -385,7 +386,7 @@ public String docs() {
 		}
 
 		@Override
-		public Mixed exec(Target t, com.laytonsmith.core.environments.Environment env, Mixed... args)
+		public Mixed exec(Target t, com.laytonsmith.core.environments.Environment env, GenericParameters generics, Mixed... args)
 				throws CancelCommandException, ConfigRuntimeException {
 			MCLocation loc = ObjectGenerator.GetGenerator().location(args[0], null, t);
 			MCBlock b = loc.getWorld().getBlockAt(loc.getBlockX(), loc.getBlockY(), loc.getBlockZ());
@@ -394,22 +395,22 @@ public Mixed exec(Target t, com.laytonsmith.core.environments.Environment env, M
 			}
 			boolean physics = true;
 			if(args.length == 3) {
-				physics = ArgumentValidation.getBooleanish(args[2], t);
+				physics = ArgumentValidation.getBooleanish(args[2], t, env);
 			}
 			MCBlockData bd;
 			try {
 				if(args[1] instanceof CArray) {
 					CArray bda = (CArray) args[1];
-					if(bda.size() == 1) {
-						MCMaterial mat = StaticLayer.GetMaterial(bda.get("block", t).val().toUpperCase());
+					if(bda.size(env) == 1) {
+						MCMaterial mat = StaticLayer.GetMaterial(bda.get("block", t, env).val().toUpperCase());
 						if(mat == null) {
 							throw new CREIllegalArgumentException("Cannot find material \""
-									+ bda.get("block", t).val() + "\".", t);
+									+ bda.get("block", t, env).val() + "\".", t);
 						}
 						b.setType(mat);
 						return CVoid.VOID;
 					}
-					bd = ObjectGenerator.GetGenerator().blockData((CArray) args[1], t);
+					bd = ObjectGenerator.GetGenerator().blockData((CArray) args[1], t, env);
 				} else {
 					bd = Static.getServer().createBlockData(args[1].val());
 				}
@@ -486,8 +487,8 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, com.laytonsmith.core.environments.Environment environment, Mixed... args) throws ConfigRuntimeException {
-			MCPlayer player = environment.getEnv(CommandHelperEnvironment.class).GetPlayer();
+		public Mixed exec(Target t, com.laytonsmith.core.environments.Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
+			MCPlayer player = env.getEnv(CommandHelperEnvironment.class).GetPlayer();
 			MCWorld world = null;
 			if(player != null) {
 				world = player.getWorld();
@@ -498,7 +499,7 @@ public Mixed exec(Target t, com.laytonsmith.core.environments.Environment enviro
 			String line2 = "";
 			String line3 = "";
 			String line4 = "";
-			if((args.length == 2 || args.length == 3) && args[args.length - 1].isInstanceOf(CArray.TYPE)) {
+			if((args.length == 2 || args.length == 3) && args[args.length - 1].isInstanceOf(CArray.TYPE, null, env)) {
 				if(args.length == 3) {
 					try {
 						side = MCSign.Side.valueOf(args[1].val());
@@ -507,17 +508,17 @@ public Mixed exec(Target t, com.laytonsmith.core.environments.Environment enviro
 					}
 				}
 				CArray ca = (CArray) args[args.length - 1];
-				if(ca.size() >= 1) {
-					line1 = ca.get(0, t).val();
+				if(ca.size(env) >= 1) {
+					line1 = ca.get(0, t, env).val();
 				}
-				if(ca.size() >= 2) {
-					line2 = ca.get(1, t).val();
+				if(ca.size(env) >= 2) {
+					line2 = ca.get(1, t, env).val();
 				}
-				if(ca.size() >= 3) {
-					line3 = ca.get(2, t).val();
+				if(ca.size(env) >= 3) {
+					line3 = ca.get(2, t, env).val();
 				}
-				if(ca.size() >= 4) {
-					line4 = ca.get(3, t).val();
+				if(ca.size(env) >= 4) {
+					line4 = ca.get(3, t, env).val();
 				}
 
 			} else {
@@ -597,8 +598,8 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, com.laytonsmith.core.environments.Environment environment, Mixed... args) throws ConfigRuntimeException {
-			MCPlayer player = environment.getEnv(CommandHelperEnvironment.class).GetPlayer();
+		public Mixed exec(Target t, com.laytonsmith.core.environments.Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
+			MCPlayer player = env.getEnv(CommandHelperEnvironment.class).GetPlayer();
 			MCWorld world = null;
 			if(player != null) {
 				world = player.getWorld();
@@ -669,8 +670,8 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, com.laytonsmith.core.environments.Environment environment, Mixed... args) throws ConfigRuntimeException {
-			MCCommandSender sender = environment.getEnv(CommandHelperEnvironment.class).GetCommandSender();
+		public Mixed exec(Target t, com.laytonsmith.core.environments.Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
+			MCCommandSender sender = env.getEnv(CommandHelperEnvironment.class).GetCommandSender();
 			MCWorld w = null;
 			if(sender instanceof MCPlayer) {
 				w = ((MCPlayer) sender).getWorld();
@@ -720,8 +721,8 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, com.laytonsmith.core.environments.Environment environment, Mixed... args) throws ConfigRuntimeException {
-			MCCommandSender sender = environment.getEnv(CommandHelperEnvironment.class).GetCommandSender();
+		public Mixed exec(Target t, com.laytonsmith.core.environments.Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
+			MCCommandSender sender = env.getEnv(CommandHelperEnvironment.class).GetCommandSender();
 			MCWorld w = null;
 			if(sender instanceof MCPlayer) {
 				w = ((MCPlayer) sender).getWorld();
@@ -789,8 +790,8 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, com.laytonsmith.core.environments.Environment environment, Mixed... args) throws ConfigRuntimeException {
-			MCCommandSender sender = environment.getEnv(CommandHelperEnvironment.class).GetCommandSender();
+		public Mixed exec(Target t, com.laytonsmith.core.environments.Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
+			MCCommandSender sender = env.getEnv(CommandHelperEnvironment.class).GetCommandSender();
 			MCWorld w = null;
 			if(sender instanceof MCPlayer) {
 				w = ((MCPlayer) sender).getWorld();
@@ -811,7 +812,7 @@ public Mixed exec(Target t, com.laytonsmith.core.environments.Environment enviro
 						throw new CREFormatException("Invalid sign side: " + args[1].val(), t);
 					}
 				}
-				text.setGlowingText(ArgumentValidation.getBooleanObject(args[args.length - 1], t));
+				text.setGlowingText(ArgumentValidation.getBooleanObject(args[args.length - 1], t, env));
 				sign.update();
 				return CVoid.VOID;
 			} else {
@@ -859,8 +860,8 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, com.laytonsmith.core.environments.Environment environment, Mixed... args) throws ConfigRuntimeException {
-			MCCommandSender sender = environment.getEnv(CommandHelperEnvironment.class).GetCommandSender();
+		public Mixed exec(Target t, com.laytonsmith.core.environments.Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
+			MCCommandSender sender = env.getEnv(CommandHelperEnvironment.class).GetCommandSender();
 			MCWorld w = null;
 			if(sender instanceof MCPlayer) {
 				w = ((MCPlayer) sender).getWorld();
@@ -915,8 +916,8 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, com.laytonsmith.core.environments.Environment environment, Mixed... args) throws ConfigRuntimeException {
-			MCCommandSender sender = environment.getEnv(CommandHelperEnvironment.class).GetCommandSender();
+		public Mixed exec(Target t, com.laytonsmith.core.environments.Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
+			MCCommandSender sender = env.getEnv(CommandHelperEnvironment.class).GetCommandSender();
 			MCWorld w = null;
 			if(sender instanceof MCPlayer) {
 				w = ((MCPlayer) sender).getWorld();
@@ -926,7 +927,7 @@ public Mixed exec(Target t, com.laytonsmith.core.environments.Environment enviro
 				throw new CRERangeException("The block at the specified location is not a sign", t);
 			}
 			MCSign sign = b.getSign();
-			sign.setWaxed(ArgumentValidation.getBooleanObject(args[1], t));
+			sign.setWaxed(ArgumentValidation.getBooleanObject(args[1], t, env));
 			sign.update();
 			return CVoid.VOID;
 		}
@@ -977,9 +978,9 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, com.laytonsmith.core.environments.Environment environment, Mixed... args)
+		public Mixed exec(Target t, com.laytonsmith.core.environments.Environment env, GenericParameters generics, Mixed... args)
 				throws ConfigRuntimeException {
-			MCPlayer p = environment.getEnv(CommandHelperEnvironment.class).GetPlayer();
+			MCPlayer p = env.getEnv(CommandHelperEnvironment.class).GetPlayer();
 			MCLocation loc = ObjectGenerator.GetGenerator().location(args[0], p != null ? p.getWorld() : null, t);
 			MCBlock block = loc.getBlock();
 			MCBlockState blockState = block.getState();
@@ -1059,9 +1060,9 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, com.laytonsmith.core.environments.Environment environment, Mixed... args)
+		public Mixed exec(Target t, com.laytonsmith.core.environments.Environment env, GenericParameters generics, Mixed... args)
 				throws ConfigRuntimeException {
-			MCPlayer p = environment.getEnv(CommandHelperEnvironment.class).GetPlayer();
+			MCPlayer p = env.getEnv(CommandHelperEnvironment.class).GetPlayer();
 			MCLocation loc = ObjectGenerator.GetGenerator().location(args[0], p != null ? p.getWorld() : null, t);
 			MCBlockState blockState = loc.getBlock().getState();
 			if(!(blockState instanceof MCSkull skull)) {
@@ -1071,16 +1072,16 @@ public Mixed exec(Target t, com.laytonsmith.core.environments.Environment enviro
 			if(owner == null) {
 				return CNull.NULL;
 			}
-			CArray ret = CArray.GetAssociativeArray(t);
-			ret.set("name", owner.getName());
-			ret.set("uuid", owner.getUniqueID().toString());
+			CArray ret = CArray.GetAssociativeArray(t, null, env);
+			ret.set("name", owner.getName(), env);
+			ret.set("uuid", owner.getUniqueID().toString(), env);
 			MCPlayerProfile playerProfile = skull.getPlayerProfile();
 			if(playerProfile != null) {
 				MCProfileProperty textureProperty = playerProfile.getProperty("textures");
 				if(textureProperty != null) {
-					ret.set("texture", skull.getPlayerProfile().getProperty("textures").getValue());
+					ret.set("texture", skull.getPlayerProfile().getProperty("textures").getValue(), env);
 				} else {
-					ret.set("texture", CNull.NULL, t);
+					ret.set("texture", CNull.NULL, t, env);
 				}
 			}
 			return ret;
@@ -1131,8 +1132,8 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, com.laytonsmith.core.environments.Environment environment, Mixed... args) throws ConfigRuntimeException {
-			MCPlayer p = environment.getEnv(CommandHelperEnvironment.class).GetPlayer();
+		public Mixed exec(Target t, com.laytonsmith.core.environments.Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
+			MCPlayer p = env.getEnv(CommandHelperEnvironment.class).GetPlayer();
 			MCWorld w = (p != null ? p.getWorld() : null);
 			MCBlock b = ObjectGenerator.GetGenerator().location(args[0], w, t).getBlock();
 			boolean success;
@@ -1185,10 +1186,10 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, com.laytonsmith.core.environments.Environment environment, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, com.laytonsmith.core.environments.Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			int x;
 			int z;
-			MCCommandSender sender = environment.getEnv(CommandHelperEnvironment.class).GetCommandSender();
+			MCCommandSender sender = env.getEnv(CommandHelperEnvironment.class).GetCommandSender();
 			MCWorld w = null;
 			if(sender instanceof MCPlayer) {
 				w = ((MCPlayer) sender).getWorld();
@@ -1207,8 +1208,8 @@ public Mixed exec(Target t, com.laytonsmith.core.environments.Environment enviro
 				MCLocation location = ObjectGenerator.GetGenerator().location(args[0], w, t);
 				location.getWorld().setBiome(location, biomeType);
 			} else {
-				x = ArgumentValidation.getInt32(args[0], t);
-				z = ArgumentValidation.getInt32(args[1], t);
+				x = ArgumentValidation.getInt32(args[0], t, env);
+				z = ArgumentValidation.getInt32(args[1], t, env);
 				if(args.length == 4) {
 					w = Static.getServer().getWorld(args[2].val());
 				} else if(w == null) {
@@ -1234,7 +1235,7 @@ public ParseTree optimizeDynamic(Target t, com.laytonsmith.core.environments.Env
 				return null;
 			}
 			Mixed c = children.get(children.size() - 1).getData();
-			if(c.isInstanceOf(CString.TYPE)) {
+			if(c.isInstanceOf(CString.TYPE, null, env)) {
 				try {
 					MCBiomeType.MCVanillaBiomeType.valueOf(c.val());
 				} catch (IllegalArgumentException ex) {
@@ -1288,8 +1289,8 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, com.laytonsmith.core.environments.Environment environment, Mixed... args) throws ConfigRuntimeException {
-			MCCommandSender sender = environment.getEnv(CommandHelperEnvironment.class).GetCommandSender();
+		public Mixed exec(Target t, com.laytonsmith.core.environments.Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
+			MCCommandSender sender = env.getEnv(CommandHelperEnvironment.class).GetCommandSender();
 			MCWorld w = null;
 			if(sender instanceof MCPlayer) {
 				w = ((MCPlayer) sender).getWorld();
@@ -1345,7 +1346,7 @@ public MSVersion since() {
 		}
 
 		@Override
-		public Mixed exec(Target t, com.laytonsmith.core.environments.Environment env, Mixed... args) throws CancelCommandException, ConfigRuntimeException {
+		public Mixed exec(Target t, com.laytonsmith.core.environments.Environment env, GenericParameters generics, Mixed... args) throws CancelCommandException, ConfigRuntimeException {
 			int x = 0;
 			int z = 0;
 			MCWorld w = null;
@@ -1355,7 +1356,7 @@ public Mixed exec(Target t, com.laytonsmith.core.environments.Environment env, M
 				w = player.getWorld();
 			}
 
-			if(args.length < 3 && args[0].isInstanceOf(CArray.TYPE)) {
+			if(args.length < 3 && args[0].isInstanceOf(CArray.TYPE, null, env)) {
 				MCLocation loc = ObjectGenerator.GetGenerator().location(args[0], w, t);
 				x = loc.getBlockX();
 				z = loc.getBlockZ();
@@ -1364,8 +1365,8 @@ public Mixed exec(Target t, com.laytonsmith.core.environments.Environment env, M
 					world = args[1].val();
 				}
 			} else if(args.length > 1) {
-				x = (int) java.lang.Math.floor(ArgumentValidation.getDouble(args[0], t));
-				z = (int) java.lang.Math.floor(ArgumentValidation.getDouble(args[1], t));
+				x = (int) java.lang.Math.floor(ArgumentValidation.getDouble(args[0], t, env));
+				z = (int) java.lang.Math.floor(ArgumentValidation.getDouble(args[1], t, env));
 				if(args.length == 3) {
 					world = args[2].val();
 				}
@@ -1431,27 +1432,27 @@ public MSVersion since() {
 		}
 
 		@Override
-		public Mixed exec(Target t, com.laytonsmith.core.environments.Environment env, Mixed... args) throws CancelCommandException, ConfigRuntimeException {
+		public Mixed exec(Target t, com.laytonsmith.core.environments.Environment env, GenericParameters generics, Mixed... args) throws CancelCommandException, ConfigRuntimeException {
 			MCLocation loc;
 			float size = 3;
 			boolean safe = false;
 			boolean fire = true;
 			MCEntity source = null;
 
-			if(!(args[0].isInstanceOf(CArray.TYPE))) {
+			if(!(args[0].isInstanceOf(CArray.TYPE, null, env))) {
 				throw new CRECastException("Expecting an array at parameter 1 of explosion", t);
 			}
 			if(args.length >= 2) {
 				if(!(args[1] instanceof CNull)) {
-					size = ArgumentValidation.getInt(args[1], t);
+					size = ArgumentValidation.getInt(args[1], t, env);
 					if(size > 100) {
 						throw new CRERangeException("A bit excessive, don't you think? Let's scale that back some, huh?", t);
 					}
 				}
 				if(args.length >= 3) {
-					safe = ArgumentValidation.getBooleanObject(args[2], t);
+					safe = ArgumentValidation.getBooleanObject(args[2], t, env);
 					if(args.length >= 4) {
-						fire = ArgumentValidation.getBooleanObject(args[3], t);
+						fire = ArgumentValidation.getBooleanObject(args[3], t, env);
 						if(args.length == 5) {
 							source = Static.getEntity(args[4], t);
 						}
@@ -1498,8 +1499,8 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, com.laytonsmith.core.environments.Environment environment, Mixed... args) throws ConfigRuntimeException {
-			MCPlayer p = environment.getEnv(CommandHelperEnvironment.class).GetPlayer();
+		public Mixed exec(Target t, com.laytonsmith.core.environments.Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
+			MCPlayer p = env.getEnv(CommandHelperEnvironment.class).GetPlayer();
 			MCInstrument i = null;
 			MCNote n = null;
 			MCLocation l;
@@ -1516,7 +1517,7 @@ public Mixed exec(Target t, com.laytonsmith.core.environments.Environment enviro
 				noteOffset = 2;
 				l = ObjectGenerator.GetGenerator().location(args[3], p.getWorld(), t);
 			} else {
-				if(!(args[1].isInstanceOf(CArray.TYPE)) && args[2].isInstanceOf(CArray.TYPE)) {
+				if(!(args[1].isInstanceOf(CArray.TYPE, null, env)) && args[2].isInstanceOf(CArray.TYPE, null, env)) {
 					//Player provided, location not
 					instrumentOffset = 1;
 					noteOffset = 2;
@@ -1537,12 +1538,12 @@ public Mixed exec(Target t, com.laytonsmith.core.environments.Environment enviro
 						+ StringUtils.Join(MCInstrument.values(), ", ", ", or "), t);
 			}
 			MCTone tone = null;
-			if(args[noteOffset].isInstanceOf(CArray.TYPE)) {
-				int octave = ArgumentValidation.getInt32(((CArray) args[noteOffset]).get("octave", t), t);
+			if(args[noteOffset].isInstanceOf(CArray.TYPE, null, env)) {
+				int octave = ArgumentValidation.getInt32(((CArray) args[noteOffset]).get("octave", t, env), t, env);
 				if(octave < 0 || octave > 2) {
 					throw new CRERangeException("The octave must be 0, 1, or 2, but was " + octave, t);
 				}
-				String ttone = ((CArray) args[noteOffset]).get("tone", t).val().toUpperCase().trim();
+				String ttone = ((CArray) args[noteOffset]).get("tone", t, env).val().toUpperCase().trim();
 				try {
 					tone = MCTone.valueOf(ttone.trim().replace("#", ""));
 				} catch (IllegalArgumentException e) {
@@ -1671,7 +1672,7 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, com.laytonsmith.core.environments.Environment environment, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, com.laytonsmith.core.environments.Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			MCLocation l = ObjectGenerator.GetGenerator().location(args[0], null, t);
 			MCParticle p;
 			int count = 0;
@@ -1682,35 +1683,35 @@ public Mixed exec(Target t, com.laytonsmith.core.environments.Environment enviro
 			boolean force = false;
 			Object data = null;
 
-			if(args[1].isInstanceOf(CArray.TYPE)) {
+			if(args[1].isInstanceOf(CArray.TYPE, null, env)) {
 				CArray pa = (CArray) args[1];
 				try {
-					p = MCParticle.valueOf(pa.get("particle", t).val().toUpperCase());
+					p = MCParticle.valueOf(pa.get("particle", t, env).val().toUpperCase());
 				} catch (IllegalArgumentException ex) {
-					throw new CREIllegalArgumentException("Particle name '" + pa.get("particle", t).val()
+					throw new CREIllegalArgumentException("Particle name '" + pa.get("particle", t, env).val()
 							+ "' is invalid.", t);
 				}
 
 				if(pa.containsKey("count")) {
-					count = ArgumentValidation.getInt32(pa.get("count", t), t);
+					count = ArgumentValidation.getInt32(pa.get("count", t, env), t, env);
 				}
 				if(pa.containsKey("xoffset")) {
-					offsetX = ArgumentValidation.getDouble(pa.get("xoffset", t), t) / 4.0D; // radius in approx. meters
+					offsetX = ArgumentValidation.getDouble(pa.get("xoffset", t, env), t, env) / 4.0D; // radius in approx. meters
 				}
 				if(pa.containsKey("yoffset")) {
-					offsetY = ArgumentValidation.getDouble(pa.get("yoffset", t), t) / 4.0D;
+					offsetY = ArgumentValidation.getDouble(pa.get("yoffset", t, env), t, env) / 4.0D;
 				}
 				if(pa.containsKey("zoffset")) {
-					offsetZ = ArgumentValidation.getDouble(pa.get("zoffset", t), t) / 4.0D;
+					offsetZ = ArgumentValidation.getDouble(pa.get("zoffset", t, env), t, env) / 4.0D;
 				}
 				if(pa.containsKey("speed")) {
-					speed = ArgumentValidation.getDouble(pa.get("speed", t), t);
+					speed = ArgumentValidation.getDouble(pa.get("speed", t, env), t, env);
 				}
 				if(pa.containsKey("force")) {
-					force = ArgumentValidation.getBooleanObject(pa.get("force", t), t);
+					force = ArgumentValidation.getBooleanObject(pa.get("force", t, env), t, env);
 				}
 
-				data = ObjectGenerator.GetGenerator().particleData(p, l, pa, t);
+				data = ObjectGenerator.GetGenerator().particleData(p, l, pa, t, env);
 
 			} else {
 				try {
@@ -1727,7 +1728,7 @@ public Mixed exec(Target t, com.laytonsmith.core.environments.Environment enviro
 						if(players.isAssociative()) {
 							throw new CREIllegalArgumentException("Players argument must be a normal array.", t);
 						}
-						for(Mixed playerName : players.asList()) {
+						for(Mixed playerName : players.asList(env)) {
 							player = Static.GetPlayer(playerName, t);
 							player.spawnParticle(l, p, count, offsetX, offsetY, offsetZ, speed, force, data);
 						}
@@ -1760,7 +1761,7 @@ public ParseTree optimizeDynamic(Target t, com.laytonsmith.core.environments.Env
 					if(node.getData() instanceof CFunction && node.getData().val().equals(Compiler.centry.NAME)) {
 						children = node.getChildren();
 						if(children.get(0).getData().val().equals("particle")
-								&& children.get(1).getData().isInstanceOf(CString.TYPE)) {
+								&& children.get(1).getData().isInstanceOf(CString.TYPE, null, env)) {
 							try {
 								MCParticle.MCVanillaParticle.valueOf(children.get(1).getData().val().toUpperCase());
 							} catch (IllegalArgumentException ex) {
@@ -1804,12 +1805,12 @@ public Boolean runAsync() {
 
 		@Override
 		public Mixed exec(Target t,
-				com.laytonsmith.core.environments.Environment environment,
-				Mixed... args) throws ConfigRuntimeException {
+				com.laytonsmith.core.environments.Environment env,
+				GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 
 			MCLocation loc = null;
 			MCEntity ent = null;
-			if(args[0].isInstanceOf(CArray.TYPE)) {
+			if(args[0].isInstanceOf(CArray.TYPE, null, env)) {
 				loc = ObjectGenerator.GetGenerator().location(args[0], null, t);
 			} else if(Static.getServer().getMinecraftVersion().gte(MCVersion.MC1_18_1)) {
 				ent = Static.getEntity(args[0], t);
@@ -1823,45 +1824,45 @@ public Mixed exec(Target t,
 			float pitch = 1;
 			Long seed = null;
 
-			if(!(args[1].isInstanceOf(CArray.TYPE))) {
+			if(!(args[1].isInstanceOf(CArray.TYPE, null, env))) {
 				throw new CREFormatException("An array was expected but received " + args[1], t);
 			}
 
 			CArray sa = (CArray) args[1];
 
 			try {
-				sound = MCSound.valueOf(sa.get("sound", t).val().toUpperCase());
+				sound = MCSound.valueOf(sa.get("sound", t, env).val().toUpperCase());
 			} catch (IllegalArgumentException iae) {
-				MSLog.GetLogger().e(MSLog.Tags.GENERAL, "Sound name '" + sa.get("sound", t).val()
+				MSLog.GetLogger().e(MSLog.Tags.GENERAL, "Sound name '" + sa.get("sound", t, env).val()
 						+ "' is invalid.", t);
 				return CVoid.VOID;
 			}
 
 			if(sa.containsKey("category")) {
 				try {
-					category = MCSoundCategory.valueOf(sa.get("category", t).val().toUpperCase());
+					category = MCSoundCategory.valueOf(sa.get("category", t, env).val().toUpperCase());
 				} catch (IllegalArgumentException iae) {
-					throw new CREFormatException("Sound category '" + sa.get("category", t).val() + "' is invalid.", t);
+					throw new CREFormatException("Sound category '" + sa.get("category", t, env).val() + "' is invalid.", t);
 				}
 			}
 
 			if(sa.containsKey("volume")) {
-				volume = ArgumentValidation.getDouble32(sa.get("volume", t), t);
+				volume = ArgumentValidation.getDouble32(sa.get("volume", t, env), t, env);
 			}
 
 			if(sa.containsKey("pitch")) {
-				pitch = ArgumentValidation.getDouble32(sa.get("pitch", t), t);
+				pitch = ArgumentValidation.getDouble32(sa.get("pitch", t, env), t, env);
 			}
 
 			if(sa.containsKey("seed") && Static.getServer().getMinecraftVersion().gte(MCVersion.MC1_20_2)) {
-				seed = ArgumentValidation.getInt(sa.get("seed", t), t);
+				seed = ArgumentValidation.getInt(sa.get("seed", t, env), t, env);
 			}
 
 			if(args.length == 3) {
-				if(args[2].isInstanceOf(CArray.TYPE)) {
+				if(args[2].isInstanceOf(CArray.TYPE, null, env)) {
 					CArray players = (CArray) args[2];
 					for(String key : players.stringKeySet()) {
-						MCPlayer p = Static.GetPlayer(players.get(key, t), t);
+						MCPlayer p = Static.GetPlayer(players.get(key, t, env), t);
 						if(ent != null) {
 							p.playSound(ent, sound, category, volume, pitch, seed);
 						} else {
@@ -1931,7 +1932,7 @@ public ParseTree optimizeDynamic(Target t, com.laytonsmith.core.environments.Env
 					if(node.getData() instanceof CFunction && node.getData().val().equals(Compiler.centry.NAME)) {
 						children = node.getChildren();
 						if(children.get(0).getData().val().equals("sound")
-								&& children.get(1).getData().isInstanceOf(CString.TYPE)) {
+								&& children.get(1).getData().isInstanceOf(CString.TYPE, null, env)) {
 							try {
 								MCSound.MCVanillaSound.valueOf(children.get(1).getData().val().toUpperCase());
 							} catch (IllegalArgumentException ex) {
@@ -1975,12 +1976,12 @@ public Boolean runAsync() {
 
 		@Override
 		public Mixed exec(Target t,
-				com.laytonsmith.core.environments.Environment environment,
-				Mixed... args) throws ConfigRuntimeException {
+				com.laytonsmith.core.environments.Environment env,
+				GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 
 			MCLocation loc = null;
 			MCEntity ent = null;
-			if(args[0].isInstanceOf(CArray.TYPE)) {
+			if(args[0].isInstanceOf(CArray.TYPE, null, env)) {
 				loc = ObjectGenerator.GetGenerator().location(args[0], null, t);
 			} else if(Static.getServer().getMinecraftVersion().gte(MCVersion.MC1_19_3)) {
 				ent = Static.getEntity(args[0], t);
@@ -1994,39 +1995,39 @@ public Mixed exec(Target t,
 			float pitch = 1;
 			Long seed = null;
 
-			if(!(args[1].isInstanceOf(CArray.TYPE))) {
+			if(!(args[1].isInstanceOf(CArray.TYPE, null, env))) {
 				throw new CREFormatException("An array was expected but received " + args[1], t);
 			}
 
 			CArray sa = (CArray) args[1];
 
-			path = ArgumentValidation.getStringObject(sa.get("sound", t), t);
+			path = ArgumentValidation.getStringObject(sa.get("sound", t, env), t, env);
 
 			if(sa.containsKey("category")) {
 				try {
-					category = MCSoundCategory.valueOf(sa.get("category", t).val().toUpperCase());
+					category = MCSoundCategory.valueOf(sa.get("category", t, env).val().toUpperCase());
 				} catch (IllegalArgumentException iae) {
-					throw new CREFormatException("Sound category '" + sa.get("category", t).val() + "' is invalid.", t);
+					throw new CREFormatException("Sound category '" + sa.get("category", t, env).val() + "' is invalid.", t);
 				}
 			}
 
 			if(sa.containsKey("volume")) {
-				volume = ArgumentValidation.getDouble32(sa.get("volume", t), t);
+				volume = ArgumentValidation.getDouble32(sa.get("volume", t, env), t, env);
 			}
 
 			if(sa.containsKey("pitch")) {
-				pitch = ArgumentValidation.getDouble32(sa.get("pitch", t), t);
+				pitch = ArgumentValidation.getDouble32(sa.get("pitch", t, env), t, env);
 			}
 
 			if(Static.getServer().getMinecraftVersion().gte(MCVersion.MC1_20_2) && sa.containsKey("seed")) {
-				seed = ArgumentValidation.getInt(sa.get("seed", t), t);
+				seed = ArgumentValidation.getInt(sa.get("seed", t, env), t, env);
 			}
 
 			if(args.length == 3) {
 				java.util.List<MCPlayer> players = new java.util.ArrayList<>();
-				if(args[2].isInstanceOf(CArray.TYPE)) {
+				if(args[2].isInstanceOf(CArray.TYPE, null, env)) {
 					for(String key : ((CArray) args[2]).stringKeySet()) {
-						players.add(Static.GetPlayer(((CArray) args[2]).get(key, t), t));
+						players.add(Static.GetPlayer(((CArray) args[2]).get(key, t, env), t));
 					}
 				} else {
 					players.add(Static.GetPlayer(args[2], t));
@@ -2109,8 +2110,8 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, com.laytonsmith.core.environments.Environment environment, Mixed... args) throws ConfigRuntimeException {
-			MCPlayer p = environment.getEnv(CommandHelperEnvironment.class).GetPlayer();
+		public Mixed exec(Target t, com.laytonsmith.core.environments.Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
+			MCPlayer p = env.getEnv(CommandHelperEnvironment.class).GetPlayer();
 			MCLocation l = ObjectGenerator.GetGenerator().location(args[0], p == null ? null : p.getWorld(), t);
 			MCBlock b = l.getBlock();
 			if(args.length == 2) {
@@ -2129,12 +2130,12 @@ public Mixed exec(Target t, com.laytonsmith.core.environments.Environment enviro
 						throw new CREFormatException("Invalid argument for block info", t);
 				}
 			}
-			CArray array = CArray.GetAssociativeArray(t);
-			array.set("solid", CBoolean.get(b.isSolid()), t);
-			array.set("flammable", CBoolean.get(b.isFlammable()), t);
-			array.set("transparent", CBoolean.get(b.isTransparent()), t);
-			array.set("occluding", CBoolean.get(b.isOccluding()), t);
-			array.set("burnable", CBoolean.get(b.isBurnable()), t);
+			CArray array = CArray.GetAssociativeArray(t, null, env);
+			array.set("solid", CBoolean.get(b.isSolid()), t, env);
+			array.set("flammable", CBoolean.get(b.isFlammable()), t, env);
+			array.set("transparent", CBoolean.get(b.isTransparent()), t, env);
+			array.set("occluding", CBoolean.get(b.isOccluding()), t, env);
+			array.set("burnable", CBoolean.get(b.isBurnable()), t, env);
 			return array;
 		}
 
@@ -2208,10 +2209,10 @@ public Version since() {
 		}
 
 		@Override
-		public Mixed exec(Target t, com.laytonsmith.core.environments.Environment environment, Mixed... args)
+		public Mixed exec(Target t, com.laytonsmith.core.environments.Environment env, GenericParameters generics, Mixed... args)
 				throws ConfigRuntimeException {
 			MCWorld w = null;
-			MCPlayer pl = environment.getEnv(CommandHelperEnvironment.class).GetPlayer();
+			MCPlayer pl = env.getEnv(CommandHelperEnvironment.class).GetPlayer();
 			if(pl != null) {
 				w = pl.getWorld();
 			}
@@ -2261,10 +2262,10 @@ public Version since() {
 		}
 
 		@Override
-		public Mixed exec(Target t, com.laytonsmith.core.environments.Environment environment, Mixed... args)
+		public Mixed exec(Target t, com.laytonsmith.core.environments.Environment env, GenericParameters generics, Mixed... args)
 				throws ConfigRuntimeException {
 			MCWorld w = null;
-			MCPlayer pl = environment.getEnv(CommandHelperEnvironment.class).GetPlayer();
+			MCPlayer pl = env.getEnv(CommandHelperEnvironment.class).GetPlayer();
 			if(pl != null) {
 				w = pl.getWorld();
 			}
@@ -2314,10 +2315,10 @@ public Version since() {
 		}
 
 		@Override
-		public Mixed exec(Target t, com.laytonsmith.core.environments.Environment environment, Mixed... args)
+		public Mixed exec(Target t, com.laytonsmith.core.environments.Environment env, GenericParameters generics, Mixed... args)
 				throws ConfigRuntimeException {
 			MCWorld w = null;
-			MCPlayer pl = environment.getEnv(CommandHelperEnvironment.class).GetPlayer();
+			MCPlayer pl = env.getEnv(CommandHelperEnvironment.class).GetPlayer();
 			if(pl != null) {
 				w = pl.getWorld();
 			}
@@ -2369,10 +2370,10 @@ public Version since() {
 		}
 
 		@Override
-		public Mixed exec(Target t, com.laytonsmith.core.environments.Environment environment, Mixed... args)
+		public Mixed exec(Target t, com.laytonsmith.core.environments.Environment env, GenericParameters generics, Mixed... args)
 				throws ConfigRuntimeException {
 			MCWorld w = null;
-			MCPlayer pl = environment.getEnv(CommandHelperEnvironment.class).GetPlayer();
+			MCPlayer pl = env.getEnv(CommandHelperEnvironment.class).GetPlayer();
 			if(pl != null) {
 				w = pl.getWorld();
 			}
@@ -2457,10 +2458,10 @@ public Version since() {
 		}
 
 		@Override
-		public Mixed exec(Target t, com.laytonsmith.core.environments.Environment environment, Mixed... args)
+		public Mixed exec(Target t, com.laytonsmith.core.environments.Environment env, GenericParameters generics, Mixed... args)
 				throws ConfigRuntimeException {
 			MCWorld w = null;
-			MCPlayer pl = environment.getEnv(CommandHelperEnvironment.class).GetPlayer();
+			MCPlayer pl = env.getEnv(CommandHelperEnvironment.class).GetPlayer();
 			if(pl != null) {
 				w = pl.getWorld();
 			}
@@ -2511,7 +2512,7 @@ public Version since() {
 		}
 
 		@Override
-		public Mixed exec(Target t, com.laytonsmith.core.environments.Environment environment, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, com.laytonsmith.core.environments.Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			MCTreeType treeType;
 			if(args.length == 1) {
 				treeType = MCTreeType.TREE;
@@ -2522,7 +2523,7 @@ public Mixed exec(Target t, com.laytonsmith.core.environments.Environment enviro
 					throw new CREFormatException("The tree type \"" + args[1].val() + "\" does not exist.", t);
 				}
 			}
-			MCPlayer psender = environment.getEnv(CommandHelperEnvironment.class).GetPlayer();
+			MCPlayer psender = env.getEnv(CommandHelperEnvironment.class).GetPlayer();
 			MCLocation location = ObjectGenerator.GetGenerator().location(args[0], (psender != null ? psender.getWorld() : null), t);
 			return CBoolean.get(location.getWorld().generateTree(location, treeType));
 		}
@@ -2569,7 +2570,7 @@ public Version since() {
 		}
 
 		@Override
-		public Mixed exec(Target t, com.laytonsmith.core.environments.Environment environment, Mixed... args)
+		public Mixed exec(Target t, com.laytonsmith.core.environments.Environment env, GenericParameters generics, Mixed... args)
 				throws ConfigRuntimeException {
 			MCLocation loc = ObjectGenerator.GetGenerator().location(args[0], null, t);
 			return CBoolean.get(loc.getBlock().getState().isLockable());
@@ -2619,7 +2620,7 @@ public Version since() {
 		}
 
 		@Override
-		public Mixed exec(Target t, com.laytonsmith.core.environments.Environment environment, Mixed... args)
+		public Mixed exec(Target t, com.laytonsmith.core.environments.Environment env, GenericParameters generics, Mixed... args)
 				throws ConfigRuntimeException {
 			MCLocation loc = ObjectGenerator.GetGenerator().location(args[0], null, t);
 			MCBlockState block = loc.getBlock().getState();
@@ -2673,7 +2674,7 @@ public Version since() {
 		}
 
 		@Override
-		public Mixed exec(Target t, com.laytonsmith.core.environments.Environment environment, Mixed... args)
+		public Mixed exec(Target t, com.laytonsmith.core.environments.Environment env, GenericParameters generics, Mixed... args)
 				throws ConfigRuntimeException {
 			MCLocation loc = ObjectGenerator.GetGenerator().location(args[0], null, t);
 			MCBlockState block = loc.getBlock().getState();
@@ -2728,7 +2729,7 @@ public Version since() {
 		}
 
 		@Override
-		public Mixed exec(Target t, com.laytonsmith.core.environments.Environment environment, Mixed... args)
+		public Mixed exec(Target t, com.laytonsmith.core.environments.Environment env, GenericParameters generics, Mixed... args)
 				throws ConfigRuntimeException {
 			MCLocation loc = ObjectGenerator.GetGenerator().location(args[0], null, t);
 			MCBlockState block = loc.getBlock().getState();
@@ -2779,7 +2780,7 @@ public Version since() {
 		}
 
 		@Override
-		public Mixed exec(Target t, com.laytonsmith.core.environments.Environment environment, Mixed... args)
+		public Mixed exec(Target t, com.laytonsmith.core.environments.Environment env, GenericParameters generics, Mixed... args)
 				throws ConfigRuntimeException {
 			MCLocation loc = ObjectGenerator.GetGenerator().location(args[0], null, t);
 			if(loc.getBlock().isCommandBlock()) {
@@ -2831,11 +2832,11 @@ public Version since() {
 		}
 
 		@Override
-		public Mixed exec(Target t, com.laytonsmith.core.environments.Environment environment, Mixed... args)
+		public Mixed exec(Target t, com.laytonsmith.core.environments.Environment env, GenericParameters generics, Mixed... args)
 				throws ConfigRuntimeException {
 			String cmd = null;
 			if(args.length == 2 && !(args[1] instanceof CNull)) {
-				if(!(args[1].isInstanceOf(CString.TYPE))) {
+				if(!(args[1].isInstanceOf(CString.TYPE, null, env))) {
 					throw new CRECastException("Parameter 2 of " + getName() + " must be a string or null", t);
 				}
 				cmd = args[1].val();
@@ -2891,7 +2892,7 @@ public Version since() {
 		}
 
 		@Override
-		public Mixed exec(Target t, com.laytonsmith.core.environments.Environment environment, Mixed... args)
+		public Mixed exec(Target t, com.laytonsmith.core.environments.Environment env, GenericParameters generics, Mixed... args)
 				throws ConfigRuntimeException {
 			MCLocation loc = ObjectGenerator.GetGenerator().location(args[0], null, t);
 			if(loc.getBlock().isCommandBlock()) {
@@ -2943,11 +2944,11 @@ public Version since() {
 		}
 
 		@Override
-		public Mixed exec(Target t, com.laytonsmith.core.environments.Environment environment, Mixed... args
+		public Mixed exec(Target t, com.laytonsmith.core.environments.Environment env, GenericParameters generics, Mixed... args
 		) throws ConfigRuntimeException {
 			String name = null;
 			if(args.length == 2 && !(args[1] instanceof CNull)) {
-				if(!(args[1].isInstanceOf(CString.TYPE))) {
+				if(!(args[1].isInstanceOf(CString.TYPE, null, env))) {
 					throw new CRECastException("Parameter 2 of " + getName() + " must be a string or null", t);
 				}
 				name = args[1].val();
@@ -2983,16 +2984,16 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, com.laytonsmith.core.environments.Environment environment, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, com.laytonsmith.core.environments.Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			MCLocation loc = ObjectGenerator.GetGenerator().location(args[0], null, t);
 			MCBlock b = loc.getWorld().getBlockAt(loc.getBlockX(), loc.getBlockY(), loc.getBlockZ());
 			if(b.getState() instanceof MCBanner banner) {
 				CArray patterns = new CArray(t, banner.numberOfPatterns());
 				for(MCPattern p : banner.getPatterns()) {
-					CArray pattern = CArray.GetAssociativeArray(t);
-					pattern.set("color", p.getColor().name());
-					pattern.set("shape", p.getShape().name());
-					patterns.push(pattern, t);
+					CArray pattern = CArray.GetAssociativeArray(t, null, env);
+					pattern.set("color", p.getColor().name(), env);
+					pattern.set("shape", p.getShape().name(), env);
+					patterns.push(pattern, t, env);
 				}
 				return patterns;
 			} else {
@@ -3056,23 +3057,23 @@ public CClassType getReturnType(Target t, List<CClassType> argTypes, List<Target
 		}
 
 		@Override
-		public Mixed exec(Target t, com.laytonsmith.core.environments.Environment environment, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, com.laytonsmith.core.environments.Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			MCLocation loc = ObjectGenerator.GetGenerator().location(args[0], null, t);
 			MCBlock b = loc.getWorld().getBlockAt(loc.getBlockX(), loc.getBlockY(), loc.getBlockZ());
-			CArray patterns = ArgumentValidation.getArray(args[1], t);
+			CArray patterns = ArgumentValidation.getArray(args[1], t, env);
 			if(b.getState() instanceof MCBanner banner) {
 				banner.clearPatterns();
-				for(Mixed mp : patterns.asList()) {
-					CArray p = ArgumentValidation.getArray(mp, t);
+				for(Mixed mp : patterns.asList(env)) {
+					CArray p = ArgumentValidation.getArray(mp, t, env);
 					MCDyeColor color;
 					try {
-						color = MCDyeColor.valueOf(p.get("color", t).val());
+						color = MCDyeColor.valueOf(p.get("color", t, env).val());
 					} catch (IllegalArgumentException ex) {
 						throw new CREFormatException("Invalid color name", t);
 					}
 					MCPatternShape shape;
 					try {
-						shape = MCPatternShape.valueOf(p.get("shape", t).val());
+						shape = MCPatternShape.valueOf(p.get("shape", t, env).val());
 					} catch (IllegalArgumentException ex) {
 						throw new CREFormatException("Invalid shape name", t);
 					}
@@ -3131,7 +3132,7 @@ public ParseTree optimizeDynamic(Target t, com.laytonsmith.core.environments.Env
 							if(node.getData() instanceof CFunction && node.getData().val().equals(Compiler.centry.NAME)) {
 								children = node.getChildren();
 								if(children.get(0).getData().val().equals("color")
-										&& children.get(1).getData().isInstanceOf(CString.TYPE)) {
+										&& children.get(1).getData().isInstanceOf(CString.TYPE, null, env)) {
 									try {
 										MCDyeColor.valueOf(children.get(1).getData().val());
 									} catch (IllegalArgumentException ex) {
@@ -3141,7 +3142,7 @@ public ParseTree optimizeDynamic(Target t, com.laytonsmith.core.environments.Env
 														children.get(1).getTarget(), null));
 									}
 								} else if(children.get(0).getData().val().equals("shape")
-										&& children.get(1).getData().isInstanceOf(CString.TYPE)) {
+										&& children.get(1).getData().isInstanceOf(CString.TYPE, null, env)) {
 									try {
 										MCPatternShape.valueOf(children.get(1).getData().val());
 									} catch (IllegalArgumentException ex) {
@@ -3200,7 +3201,7 @@ public Class<? extends CREThrowable>[] thrown() {
 		}
 
 		@Override
-		public Mixed exec(Target t, com.laytonsmith.core.environments.Environment environment, Mixed... args)
+		public Mixed exec(Target t, com.laytonsmith.core.environments.Environment env, GenericParameters generics, Mixed... args)
 				throws ConfigRuntimeException {
 			MCLocation loc = ObjectGenerator.GetGenerator().location(args[0], null, t);
 			return CBoolean.get(loc.getBlock().applyBoneMeal());
@@ -3263,15 +3264,15 @@ public Version since() {
 		}
 
 		@Override
-		public Mixed exec(Target t, com.laytonsmith.core.environments.Environment environment, Mixed... args)
+		public Mixed exec(Target t, com.laytonsmith.core.environments.Environment env, GenericParameters generics, Mixed... args)
 				throws ConfigRuntimeException {
 			MCLocation loc = ObjectGenerator.GetGenerator().location(args[0], null, t);
 			MCBlockState bs = loc.getBlock().getState();
 			if(bs instanceof MCDecoratedPot decoratedPot) {
-				CArray sherds = CArray.GetAssociativeArray(t);
+				CArray sherds = CArray.GetAssociativeArray(t, null, env);
 				Map<MCDecoratedPot.Side, MCMaterial> potSherds = decoratedPot.getSherds();
 				for(Map.Entry<MCDecoratedPot.Side, MCMaterial> side : potSherds.entrySet()) {
-					sherds.set(side.getKey().name().toLowerCase(), side.getValue().name());
+					sherds.set(side.getKey().name().toLowerCase(), side.getValue().name(), env);
 				}
 				return sherds;
 			} else {
@@ -3322,7 +3323,7 @@ public Version since() {
 		}
 
 		@Override
-		public Mixed exec(Target t, com.laytonsmith.core.environments.Environment environment, Mixed... args)
+		public Mixed exec(Target t, com.laytonsmith.core.environments.Environment env, GenericParameters generics, Mixed... args)
 				throws ConfigRuntimeException {
 			MCLocation loc = ObjectGenerator.GetGenerator().location(args[0], null, t);
 			MCBlockState bs = loc.getBlock().getState();
@@ -3330,7 +3331,7 @@ public Mixed exec(Target t, com.laytonsmith.core.environments.Environment enviro
 				throw new CREFormatException("The block at the specified location is not a decorated pot", t);
 			}
 			Mixed sherds = args[1];
-			if(sherds.isInstanceOf(CArray.TYPE)) {
+			if(sherds.isInstanceOf(CArray.TYPE, null, env)) {
 				CArray sherdArray = (CArray) sherds;
 				if(sherdArray.isAssociative()) {
 					for(String key : sherdArray.stringKeySet()) {
@@ -3341,7 +3342,7 @@ public Mixed exec(Target t, com.laytonsmith.core.environments.Environment enviro
 							throw new CREFormatException("Invalid decorated pot side: " + key, t);
 						}
 						try {
-							decoratedPot.setSherd(side, MCMaterial.valueOf(sherdArray.get(key, t).val()));
+							decoratedPot.setSherd(side, MCMaterial.valueOf(sherdArray.get(key, t, env).val()));
 						} catch (IllegalArgumentException ex) {
 							throw new CREFormatException(ex.getMessage(), t);
 						}
@@ -3396,7 +3397,7 @@ public Version since() {
 		}
 
 		@Override
-		public Mixed exec(Target t, com.laytonsmith.core.environments.Environment environment, Mixed... args)
+		public Mixed exec(Target t, com.laytonsmith.core.environments.Environment env, GenericParameters generics, Mixed... args)
 				throws ConfigRuntimeException {
 			MCLocation loc = ObjectGenerator.GetGenerator().location(args[0], null, t);
 			MCBlockState bs = loc.getBlock().getState();
@@ -3414,7 +3415,7 @@ public Mixed exec(Target t, com.laytonsmith.core.environments.Environment enviro
 				}
 			}
 			if(args.length == 3) {
-				boolean exact = ArgumentValidation.getBooleanObject(args[2], t);
+				boolean exact = ArgumentValidation.getBooleanObject(args[2], t, env);
 				endGateway.setExactTeleport(exact);
 			}
 			endGateway.update();
@@ -3464,14 +3465,14 @@ public Version since() {
 		}
 
 		@Override
-		public Mixed exec(Target t, com.laytonsmith.core.environments.Environment environment, Mixed... args)
+		public Mixed exec(Target t, com.laytonsmith.core.environments.Environment env, GenericParameters generics, Mixed... args)
 				throws ConfigRuntimeException {
 			MCLocation loc = ObjectGenerator.GetGenerator().location(args[0], null, t);
 			MCBlockState bs = loc.getBlock().getState();
 			if(!(bs instanceof MCEndGateway endGateway)) {
 				throw new CREFormatException("The block at the specified location is not an end gateway", t);
 			}
-			endGateway.setAge(ArgumentValidation.getInt(args[1], t));
+			endGateway.setAge(ArgumentValidation.getInt(args[1], t, env));
 			endGateway.update();
 			return CVoid.VOID;
 		}
diff --git a/src/main/java/com/laytonsmith/core/functions/EventBinding.java b/src/main/java/com/laytonsmith/core/functions/EventBinding.java
index afe27912ec..40e620c775 100644
--- a/src/main/java/com/laytonsmith/core/functions/EventBinding.java
+++ b/src/main/java/com/laytonsmith/core/functions/EventBinding.java
@@ -8,10 +8,13 @@
 import com.laytonsmith.annotations.hide;
 import com.laytonsmith.core.ArgumentValidation;
 import com.laytonsmith.core.MSVersion;
+import com.laytonsmith.core.FlowFunction;
 import com.laytonsmith.core.Optimizable;
 import com.laytonsmith.core.ParseTree;
-import com.laytonsmith.core.Script;
 import com.laytonsmith.core.Static;
+import com.laytonsmith.core.StepAction.Complete;
+import com.laytonsmith.core.StepAction.Evaluate;
+import com.laytonsmith.core.StepAction.StepResult;
 import com.laytonsmith.core.compiler.BranchStatement;
 import com.laytonsmith.core.compiler.CompilerEnvironment;
 import com.laytonsmith.core.compiler.CompilerWarning;
@@ -34,6 +37,7 @@
 import com.laytonsmith.core.constructs.IVariable;
 import com.laytonsmith.core.constructs.IVariableList;
 import com.laytonsmith.core.constructs.Target;
+import com.laytonsmith.core.constructs.generics.GenericParameters;
 import com.laytonsmith.core.environments.Environment;
 import com.laytonsmith.core.environments.GlobalEnv;
 import com.laytonsmith.core.environments.StaticRuntimeEnv;
@@ -80,7 +84,7 @@ public static String docs() {
 
 	@api
 	@SelfStatement
-	public static class bind extends AbstractFunction implements Optimizable, BranchStatement, VariableScope, DocumentSymbolProvider {
+	public static class bind extends AbstractFunction implements FlowFunction<bind.BindState>, Optimizable, BranchStatement, VariableScope, DocumentSymbolProvider {
 
 		@Override
 		public String getName() {
@@ -127,71 +131,122 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment env, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			return CVoid.VOID;
 		}
 
+		// -- FlowFunction implementation --
+		// bind evaluates args 0-2 with IVariable resolution (equivalent to seval),
+		// args 3..n-2 with keepIVariable=true (need raw IVariables for event_obj and custom params),
+		// and does NOT evaluate the last arg (the code tree stored in the BoundEvent).
+
+		static class BindState {
+			int nextArg = 0;
+			ParseTree[] children;
+			Mixed name;
+			Mixed options;
+			Mixed prefilter;
+			Mixed eventObj;
+			IVariableList customParams;
+		}
+
 		@Override
-		public Mixed execs(Target t, Environment env, Script parent, ParseTree... nodes) {
-			if(nodes.length < 5) {
+		public StepResult<BindState> begin(Target t, ParseTree[] children, Environment env) {
+			if(children.length < 5) {
 				throw new CREInsufficientArgumentsException("bind accepts 5 or more parameters", t);
 			}
-			Mixed name = parent.seval(nodes[0], env);
-			Mixed options = parent.seval(nodes[1], env);
-			Mixed prefilter = parent.seval(nodes[2], env);
-			Mixed event_obj = parent.eval(nodes[3], env);
-			IVariableList custom_params = new IVariableList(env.getEnv(GlobalEnv.class).GetVarList());
-			for(int a = 0; a < nodes.length - 5; a++) {
-				Mixed var = parent.eval(nodes[4 + a], env);
-				if(!(var instanceof IVariable)) {
-					throw new CRECastException("The custom parameters must be ivariables", t);
+			BindState state = new BindState();
+			state.children = children;
+			state.customParams = new IVariableList(env.getEnv(GlobalEnv.class).GetVarList());
+			return new StepResult<>(new Evaluate(children[0]), state);
+		}
+
+		@Override
+		public StepResult<BindState> childCompleted(Target t, BindState state, Mixed result, Environment env) {
+			int argIndex = state.nextArg;
+			state.nextArg++;
+
+			switch(argIndex) {
+				case 0 -> state.name = result;
+				case 1 -> {
+					if(!(result instanceof CNull || result.isInstanceOf(CArray.TYPE, null, env))) {
+						throw new CRECastException("The options must be an array or null", t);
+					}
+					state.options = result;
 				}
-				IVariable cur = (IVariable) var;
-				custom_params.set(env.getEnv(GlobalEnv.class).GetVarList().get(cur.getVariableName(),
-						cur.getTarget(), env));
+				case 2 -> {
+					if(!(result instanceof CNull || result.isInstanceOf(CArray.TYPE, null, env))) {
+						throw new CRECastException("The prefilters must be an array or null", t);
+					}
+					state.prefilter = result;
+				}
+				case 3 -> {
+					if(!(result instanceof IVariable)) {
+						throw new CRECastException("The event object must be an IVariable", t);
+					}
+					state.eventObj = result;
+				}
+				default -> {
+					if(!(result instanceof IVariable)) {
+						throw new CRECastException("The custom parameters must be ivariables", t);
+					}
+					IVariable cur = (IVariable) result;
+					state.customParams.set(env.getEnv(GlobalEnv.class).GetVarList()
+							.get(cur.getVariableName(), cur.getTarget(), env));
+				}
+			}
+
+			int nextIndex = state.nextArg;
+			int lastIndex = state.children.length - 1;
+
+			if(nextIndex < lastIndex) {
+				boolean keepIVar = nextIndex >= 3;
+				return new StepResult<>(new Evaluate(state.children[nextIndex], null, keepIVar), state);
+			}
+
+			// All args evaluated — register the event
+			return new StepResult<>(new Complete(registerBind(t, state, env)), state);
+		}
+
+		/**
+		 * Performs the bind registration after all args have been evaluated and validated.
+		 */
+		private Mixed registerBind(Target t, BindState state, Environment env) {
+			Mixed options = state.options;
+			Mixed prefilter = state.prefilter;
+
+			if(options instanceof CNull) {
+				options = null;
+			}
+			if(prefilter instanceof CNull) {
+				prefilter = null;
 			}
+
 			Environment newEnv = env;
 			try {
 				newEnv = env.clone();
-			} catch (Exception e) {
+			} catch(Exception e) {
 			}
-			// Set the permission to global if it's null, since that means
-			// it wasn't set, and so we aren't in a secured environment anyway.
 			if(newEnv.getEnv(GlobalEnv.class).GetLabel() == null) {
 				newEnv.getEnv(GlobalEnv.class).SetLabel(Static.GLOBAL_PERMISSION);
 			}
-			newEnv.getEnv(GlobalEnv.class).SetVarList(custom_params);
-			ParseTree tree = nodes[nodes.length - 1];
+			newEnv.getEnv(GlobalEnv.class).SetVarList(state.customParams);
+
+			ParseTree tree = state.children[state.children.length - 1];
 
-			//Check to see if our arguments are correct
-			if(!(options instanceof CNull || options.isInstanceOf(CArray.TYPE))) {
-				throw new CRECastException("The options must be an array or null", t);
-			}
-			if(!(prefilter instanceof CNull || prefilter.isInstanceOf(CArray.TYPE))) {
-				throw new CRECastException("The prefilters must be an array or null", t);
-			}
-			if(!(event_obj instanceof IVariable)) {
-				throw new CRECastException("The event object must be an IVariable", t);
-			}
 			CString id;
-			if(options instanceof CNull) {
-				options = null;
-			}
-			if(prefilter instanceof CNull) {
-				prefilter = null;
-			}
 			Event event;
 			try {
-				BoundEvent be = new BoundEvent(name.val(), (CArray) options, (CArray) prefilter,
-						((IVariable) event_obj).getVariableName(), newEnv, tree, t);
+				BoundEvent be = new BoundEvent(state.name.val(), (CArray) options, (CArray) prefilter,
+						((IVariable) state.eventObj).getVariableName(), newEnv, tree, t);
 				EventUtils.RegisterEvent(be);
 				id = new CString(be.getId(), t);
 				event = be.getEventDriver();
-			} catch (EventException ex) {
+			} catch(EventException ex) {
 				throw new CREBindException(ex.getMessage(), t);
 			}
 
-			//Set up our bind counter, but only if the event is supposed to be added to the counter
+			// Set up bind counter for daemon thread management
 			if(event.addCounter()) {
 				synchronized(BIND_COUNTER) {
 					if(BIND_COUNTER.get() == 0) {
@@ -353,11 +408,6 @@ public Scope linkScope(StaticAnalysis analysis, Scope parentScope,
 			return valScope;
 		}
 
-		@Override
-		public boolean useSpecialExec() {
-			return true;
-		}
-
 		@Override
 		public Set<OptimizationOption> optimizationOptions() {
 			return EnumSet.of(OptimizationOption.OPTIMIZE_DYNAMIC, OptimizationOption.CUSTOM_LINK);
@@ -386,14 +436,14 @@ public ParseTree optimizeDynamic(Target t, Environment env,
 					if(node.getData() instanceof CFunction && node.getData().val().equals(Compiler.centry.NAME)) {
 						List<ParseTree> children = node.getChildren();
 						if(children.get(0).getData().val().equals("id")
-								&& children.get(1).getData().isInstanceOf(CString.TYPE)) {
+								&& children.get(1).getData().isInstanceOf(CString.TYPE, null, env)) {
 							if(children.get(1).getData().val().matches(".*?:\\d*?")) {
 								exceptions.add(new ConfigCompileException(children.get(1).getData().val()
 											+ " is not a valid event identifier."
 											+ " It cannot match the regex \".*?:\\d*?\".", children.get(1).getTarget()));
 							}
 						} else if(children.get(0).getData().val().equals("priority")
-								&& children.get(1).getData().isInstanceOf(CString.TYPE)) {
+								&& children.get(1).getData().isInstanceOf(CString.TYPE, null, env)) {
 							try {
 								BoundEvent.Priority.valueOf(children.get(1).getData().val().toUpperCase());
 								try {
@@ -507,7 +557,7 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment env, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			return EventUtils.DumpEvents();
 		}
 	}
@@ -552,7 +602,7 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			String id;
 			BoundEvent be;
 			if(args.length == 1) {
@@ -561,10 +611,10 @@ public Mixed exec(Target t, Environment environment, Mixed... args) throws Confi
 				be = EventUtils.GetEventById(id);
 			} else {
 				//We are cancelling this event. If we are not in an event, throw an exception
-				if(environment.getEnv(GlobalEnv.class).GetEvent() == null) {
+				if(env.getEnv(GlobalEnv.class).GetEvent() == null) {
 					throw new CREBindException("No event ID specified, and not running inside an event", t);
 				}
-				be = environment.getEnv(GlobalEnv.class).GetEvent().getBoundEvent();
+				be = env.getEnv(GlobalEnv.class).GetEvent().getBoundEvent();
 				id = be.getId();
 			}
 			Event event = null;
@@ -577,7 +627,7 @@ public Mixed exec(Target t, Environment environment, Mixed... args) throws Confi
 				synchronized(BIND_COUNTER) {
 					BIND_COUNTER.decrementAndGet();
 					if(BIND_COUNTER.get() == 0) {
-						environment.getEnv(StaticRuntimeEnv.class).GetDaemonManager().deactivateThread(null);
+						env.getEnv(StaticRuntimeEnv.class).GetDaemonManager().deactivateThread(null);
 					}
 				}
 			}
@@ -627,13 +677,13 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			boolean cancelled = true;
 			if(args.length == 1) {
 				cancelled = ArgumentValidation.getBoolean(args[0], t);
 			}
 
-			BoundEvent.ActiveEvent original = environment.getEnv(GlobalEnv.class).GetEvent();
+			BoundEvent.ActiveEvent original = env.getEnv(GlobalEnv.class).GetEvent();
 			if(original == null) {
 				throw new CREBindException("cancel cannot be called outside an event handler", t);
 			}
@@ -684,8 +734,8 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
-			BoundEvent.ActiveEvent original = environment.getEnv(GlobalEnv.class).GetEvent();
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
+			BoundEvent.ActiveEvent original = env.getEnv(GlobalEnv.class).GetEvent();
 			if(original == null) {
 				throw new CREBindException("is_cancelled cannot be called outside an event handler", t);
 			}
@@ -747,20 +797,20 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			CArray obj = null;
 			if(args[1] instanceof CNull) {
 				obj = new CArray(t);
-			} else if(args[1].isInstanceOf(CArray.TYPE)) {
+			} else if(args[1].isInstanceOf(CArray.TYPE, null, env)) {
 				obj = (CArray) args[1];
 			} else {
 				throw new CRECastException("The eventObject must be null, or an array", t);
 			}
 			boolean serverWide = false;
 			if(args.length == 3) {
-				serverWide = ArgumentValidation.getBoolean(args[2], t);
+				serverWide = ArgumentValidation.getBoolean(args[2], t, env);
 			}
-			EventUtils.ManualTrigger(args[0].val(), obj, t, serverWide);
+			EventUtils.ManualTrigger(args[0].val(), obj, t, serverWide, env);
 			return CVoid.VOID;
 		}
 	}
@@ -816,25 +866,25 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			String parameter = args[0].val();
 			Mixed value = args[1];
 			boolean throwOnFailure = false;
 			if(args.length == 3) {
 				throwOnFailure = ArgumentValidation.getBoolean(args[3], t);
 			}
-			if(environment.getEnv(GlobalEnv.class).GetEvent() == null) {
+			if(env.getEnv(GlobalEnv.class).GetEvent() == null) {
 				throw new CREBindException(this.getName() + " must be called from within an event handler", t);
 			}
-			Event e = environment.getEnv(GlobalEnv.class).GetEvent().getEventDriver();
-			if(environment.getEnv(GlobalEnv.class).GetEvent().getBoundEvent().getPriority().equals(Priority.MONITOR)) {
+			Event e = env.getEnv(GlobalEnv.class).GetEvent().getEventDriver();
+			if(env.getEnv(GlobalEnv.class).GetEvent().getBoundEvent().getPriority().equals(Priority.MONITOR)) {
 				throw new CREBindException("Monitor level handlers may not modify an event!", t);
 			}
-			ActiveEvent active = environment.getEnv(GlobalEnv.class).GetEvent();
+			ActiveEvent active = env.getEnv(GlobalEnv.class).GetEvent();
 			boolean success = false;
 			if(!active.isLocked(parameter)) {
 				try {
-					success = e.modifyEvent(parameter, value, environment.getEnv(GlobalEnv.class).GetEvent().getUnderlyingEvent());
+					success = Event.ExecuteModifyEvent(e, parameter, value, env.getEnv(GlobalEnv.class).GetEvent().getUnderlyingEvent(), env);
 				} catch (ConfigRuntimeException ex) {
 					ex.setTarget(t);
 					throw ex;
@@ -884,18 +934,18 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
-			if(environment.getEnv(GlobalEnv.class).GetEvent() == null) {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
+			if(env.getEnv(GlobalEnv.class).GetEvent() == null) {
 				throw new CREBindException("lock must be called from within an event handler", t);
 			}
 
-			BoundEvent.ActiveEvent e = environment.getEnv(GlobalEnv.class).GetEvent();
+			BoundEvent.ActiveEvent e = env.getEnv(GlobalEnv.class).GetEvent();
 			Priority p = e.getBoundEvent().getPriority();
 			List<String> params = new ArrayList<String>();
 			if(args.length == 0) {
 				e.lock(null);
 			} else {
-				if(args[0].isInstanceOf(CArray.TYPE)) {
+				if(args[0].isInstanceOf(CArray.TYPE, null, env)) {
 					CArray ca = (CArray) args[1];
 					for(int i = 0; i < ca.size(); i++) {
 						params.add(ca.get(i, t).val());
@@ -955,11 +1005,11 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
-			if(environment.getEnv(GlobalEnv.class).GetEvent() == null) {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
+			if(env.getEnv(GlobalEnv.class).GetEvent() == null) {
 				throw new CREBindException("is_locked may only be called from inside an event handler", t);
 			}
-			return CBoolean.get(environment.getEnv(GlobalEnv.class).GetEvent().isLocked(args[0].val()));
+			return CBoolean.get(env.getEnv(GlobalEnv.class).GetEvent().isLocked(args[0].val()));
 		}
 
 		@Override
@@ -1004,11 +1054,11 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
-			if(environment.getEnv(GlobalEnv.class).GetEvent() == null) {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
+			if(env.getEnv(GlobalEnv.class).GetEvent() == null) {
 				throw new CREBindException("consume may only be called from an event handler!", t);
 			}
-			environment.getEnv(GlobalEnv.class).GetEvent().consume();
+			env.getEnv(GlobalEnv.class).GetEvent().consume();
 			return CVoid.VOID;
 		}
 
@@ -1055,11 +1105,11 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
-			if(environment.getEnv(GlobalEnv.class).GetEvent() == null) {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
+			if(env.getEnv(GlobalEnv.class).GetEvent() == null) {
 				throw new CREBindException("is_consumed must be called from within an event handler", t);
 			}
-			return CBoolean.get(environment.getEnv(GlobalEnv.class).GetEvent().isConsumed());
+			return CBoolean.get(env.getEnv(GlobalEnv.class).GetEvent().isConsumed());
 		}
 
 		@Override
@@ -1109,12 +1159,12 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
-			if(environment.getEnv(GlobalEnv.class).GetEvent() == null) {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
+			if(env.getEnv(GlobalEnv.class).GetEvent() == null) {
 				throw new CREBindException("event_meta must be called from within an event handler!", t);
 			}
 			CArray history = new CArray(t);
-			for(String entry : environment.getEnv(GlobalEnv.class).GetEvent().getHistory()) {
+			for(String entry : env.getEnv(GlobalEnv.class).GetEvent().getHistory()) {
 				history.push(new CString(entry, t), t);
 			}
 			return history;
@@ -1145,7 +1195,7 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			return CBoolean.get(EventUtils.GetEventById(args[0].val()) != null);
 		}
 
diff --git a/src/main/java/com/laytonsmith/core/functions/Exceptions.java b/src/main/java/com/laytonsmith/core/functions/Exceptions.java
index 916aab22e9..f5eaac14cd 100644
--- a/src/main/java/com/laytonsmith/core/functions/Exceptions.java
+++ b/src/main/java/com/laytonsmith/core/functions/Exceptions.java
@@ -14,6 +14,7 @@
 import com.laytonsmith.annotations.typeof;
 import com.laytonsmith.core.MSLog;
 import com.laytonsmith.core.ArgumentValidation;
+import com.laytonsmith.core.FlowFunction;
 import com.laytonsmith.core.FullyQualifiedClassName;
 import com.laytonsmith.core.MSVersion;
 import com.laytonsmith.core.LogLevel;
@@ -21,7 +22,6 @@
 import com.laytonsmith.core.Optimizable;
 import com.laytonsmith.core.ParseTree;
 import com.laytonsmith.core.Prefs;
-import com.laytonsmith.core.Script;
 import com.laytonsmith.core.compiler.BranchStatement;
 import com.laytonsmith.core.compiler.FileOptions;
 import com.laytonsmith.core.compiler.SelfStatement;
@@ -39,6 +39,7 @@
 import com.laytonsmith.core.constructs.IVariableList;
 import com.laytonsmith.core.constructs.NativeTypeList;
 import com.laytonsmith.core.constructs.Target;
+import com.laytonsmith.core.constructs.generics.GenericParameters;
 import com.laytonsmith.core.environments.Environment;
 import com.laytonsmith.core.environments.GlobalEnv;
 import com.laytonsmith.core.environments.StaticRuntimeEnv;
@@ -48,10 +49,13 @@
 import com.laytonsmith.core.exceptions.CRE.CREFormatException;
 import com.laytonsmith.core.exceptions.CRE.CREThrowable;
 import com.laytonsmith.core.functions.Compiler.__type_ref__;
+import com.laytonsmith.core.StepAction;
+import com.laytonsmith.core.StepAction.Complete;
+import com.laytonsmith.core.StepAction.Evaluate;
+import com.laytonsmith.core.StepAction.StepResult;
 import com.laytonsmith.core.exceptions.CancelCommandException;
 import com.laytonsmith.core.exceptions.ConfigCompileException;
 import com.laytonsmith.core.exceptions.ConfigRuntimeException;
-import com.laytonsmith.core.exceptions.FunctionReturnException;
 import com.laytonsmith.core.exceptions.StackTraceManager;
 import com.laytonsmith.core.natives.interfaces.Mixed;
 import java.util.ArrayList;
@@ -70,13 +74,186 @@ public static String docs() {
 		return "This class contains functions related to Exception handling in MethodScript";
 	}
 
+	/**
+	 * Produced by {@code throw()} and by native functions that throw {@link ConfigRuntimeException}.
+	 * The interpreter loop catches ConfigRuntimeException from exec() calls and wraps them in this.
+	 * {@code _try} and {@code complex_try} handle this in their {@code childInterrupted()}.
+	 */
+	public static class ThrowAction implements StepAction.FlowControlAction {
+		private final ConfigRuntimeException exception;
+
+		public ThrowAction(ConfigRuntimeException exception) {
+			this.exception = exception;
+		}
+
+		public ConfigRuntimeException getException() {
+			return exception;
+		}
+
+		@Override
+		public Target getTarget() {
+			return exception.getTarget();
+		}
+	}
+
 	@api
 	@seealso({_throw.class, com.laytonsmith.tools.docgen.templates.Exceptions.class})
 	@SelfStatement
-	public static class _try extends AbstractFunction implements BranchStatement, VariableScope {
+	public static class _try extends AbstractFunction implements FlowFunction<_try.TryState>, BranchStatement, VariableScope {
 
 		public static final String NAME = "try";
 
+		enum Phase { RESOLVE_VAR, RESOLVE_TYPES, TRY_BODY, CATCH_BODY }
+
+		static class TryState {
+			Phase phase;
+			ParseTree[] children;
+			IVariable ivar;
+			List<FullyQualifiedClassName> interest;
+			int catchIndex;
+
+			TryState(ParseTree[] children) {
+				this.children = children;
+				this.interest = new ArrayList<>();
+				if(children.length == 2) {
+					catchIndex = 1;
+				} else if(children.length >= 3) {
+					catchIndex = 2;
+				} else {
+					catchIndex = -1;
+				}
+			}
+
+			@Override
+			public String toString() {
+				return phase.name();
+			}
+		}
+
+		@Override
+		public StepResult<TryState> begin(Target t, ParseTree[] children, Environment env) {
+			TryState state = new TryState(children);
+			if(children.length >= 3) {
+				state.phase = Phase.RESOLVE_VAR;
+				return new StepResult<>(new Evaluate(children[1], null, true), state);
+			}
+			state.phase = Phase.TRY_BODY;
+			return new StepResult<>(new Evaluate(children[0]), state);
+		}
+
+		@Override
+		public StepResult<TryState> childCompleted(Target t, TryState state, Mixed result, Environment env) {
+			switch(state.phase) {
+				case RESOLVE_VAR:
+					if(result instanceof IVariable iv) {
+						state.ivar = iv;
+					} else {
+						throw new CRECastException("Expected argument 2 to be an IVariable", t);
+					}
+					if(state.children.length == 4) {
+						state.phase = Phase.RESOLVE_TYPES;
+						return new StepResult<>(new Evaluate(state.children[3]), state);
+					}
+					state.phase = Phase.TRY_BODY;
+					return new StepResult<>(new Evaluate(state.children[0]), state);
+				case RESOLVE_TYPES:
+					Mixed ptypes = result;
+					if(ptypes.isInstanceOf(CString.TYPE, null, env)) {
+						state.interest.add(FullyQualifiedClassName.forName(ptypes.val(), t, env));
+					} else if(ptypes.isInstanceOf(CArray.TYPE, null, env)) {
+						CArray ca = (CArray) ptypes;
+						for(int i = 0; i < ca.size(); i++) {
+							state.interest.add(FullyQualifiedClassName.forName(
+									ca.get(i, t).val(), t, env));
+						}
+					} else {
+						throw new CRECastException(
+								"Expected argument 4 to be a string, or an array of strings.", t);
+					}
+					for(FullyQualifiedClassName in : state.interest) {
+						try {
+							NativeTypeList.getNativeClass(in);
+						} catch(ClassNotFoundException e) {
+							throw new CREFormatException(
+									"Invalid exception type passed to try():" + in, t);
+						}
+					}
+					state.phase = Phase.TRY_BODY;
+					return new StepResult<>(new Evaluate(state.children[0]), state);
+				case TRY_BODY:
+				case CATCH_BODY:
+					return new StepResult<>(new Complete(CVoid.VOID), state);
+				default:
+					throw ConfigRuntimeException.CreateUncatchableException(
+							"Invalid try state: " + state.phase, t);
+			}
+		}
+
+		@Override
+		public StepResult<TryState> childInterrupted(Target t, TryState state,
+				StepAction.FlowControl action, Environment env) {
+			if(state.phase == Phase.TRY_BODY
+					&& action.getAction() instanceof ThrowAction throwAction) {
+				ConfigRuntimeException e = throwAction.getException();
+				if(!(e instanceof AbstractCREException)) {
+					return null;
+				}
+				CClassType exType = ((AbstractCREException) e).getExceptionType();
+				if(Prefs.DebugMode()) {
+					StreamUtils.GetSystemOut().println("[" + Implementation.GetServerType().getBranding() + "]:"
+							+ " Exception thrown (debug mode on) -> " + e.getMessage() + " :: " + exType.getFQCN() + ":"
+							+ e.getTarget().file() + ":" + e.getTarget().line());
+				}
+				if(matchesInterest(exType, state.interest)) {
+					if(state.catchIndex >= 0) {
+						CArray ex = ObjectGenerator.GetGenerator().exception(e, env, t);
+						if(state.ivar != null) {
+							state.ivar.setIval(ex);
+							env.getEnv(GlobalEnv.class).GetVarList().set(state.ivar);
+						}
+						state.phase = Phase.CATCH_BODY;
+						return new StepResult<>(
+								new Evaluate(state.children[state.catchIndex]), state);
+					}
+					return new StepResult<>(new Complete(CVoid.VOID), state);
+				}
+				return null;
+			}
+			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;
@@ -127,85 +304,7 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed execs(Target t, Environment env, Script that, ParseTree... nodes) {
-			ParseTree tryCode = nodes[0];
-			ParseTree varName = null;
-			ParseTree catchCode = null;
-			ParseTree types = null;
-			if(nodes.length == 2) {
-				catchCode = nodes[1];
-			} else if(nodes.length == 3) {
-				varName = nodes[1];
-				catchCode = nodes[2];
-			} else if(nodes.length == 4) {
-				varName = nodes[1];
-				catchCode = nodes[2];
-				types = nodes[3];
-			}
-
-			IVariable ivar = null;
-			if(varName != null) {
-				Mixed pivar = that.eval(varName, env);
-				if(pivar instanceof IVariable) {
-					ivar = (IVariable) pivar;
-				} else {
-					throw new CRECastException("Expected argument 2 to be an IVariable", t);
-				}
-			}
-			List<FullyQualifiedClassName> interest = new ArrayList<>();
-			if(types != null) {
-				Mixed ptypes = that.seval(types, env);
-				if(ptypes.isInstanceOf(CString.TYPE)) {
-					interest.add(FullyQualifiedClassName.forName(ptypes.val(), t, env));
-				} else if(ptypes.isInstanceOf(CArray.TYPE)) {
-					CArray ca = (CArray) ptypes;
-					for(int i = 0; i < ca.size(); i++) {
-						interest.add(FullyQualifiedClassName.forName(ca.get(i, t).val(), t, env));
-					}
-				} else {
-					throw new CRECastException("Expected argument 4 to be a string, or an array of strings.", t);
-				}
-			}
-
-			for(FullyQualifiedClassName in : interest) {
-				try {
-					NativeTypeList.getNativeClass(in);
-				} catch (ClassNotFoundException e) {
-					throw new CREFormatException("Invalid exception type passed to try():" + in, t);
-				}
-			}
-
-			try {
-				that.eval(tryCode, env);
-			} catch (ConfigRuntimeException e) {
-				if(!(e instanceof AbstractCREException)) {
-					throw e;
-				}
-				FullyQualifiedClassName name = ((AbstractCREException) e).getExceptionType().getFQCN();
-				if(Prefs.DebugMode()) {
-					StreamUtils.GetSystemOut().println("[" + Implementation.GetServerType().getBranding() + "]:"
-							+ " Exception thrown (debug mode on) -> " + e.getMessage() + " :: " + name + ":"
-							+ e.getTarget().file() + ":" + e.getTarget().line());
-				}
-				if(interest.isEmpty() || interest.contains(name)) {
-					if(catchCode != null) {
-						CArray ex = ObjectGenerator.GetGenerator().exception(e, env, t);
-						if(ivar != null) {
-							ivar.setIval(ex);
-							env.getEnv(GlobalEnv.class).GetVarList().set(ivar);
-						}
-						that.eval(catchCode, env);
-					}
-				} else {
-					throw e;
-				}
-			}
-
-			return CVoid.VOID;
-		}
-
-		@Override
-		public Mixed exec(Target t, Environment env, Mixed... args) throws CancelCommandException, ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws CancelCommandException, ConfigRuntimeException {
 			return CVoid.VOID;
 		}
 
@@ -245,11 +344,6 @@ public Scope linkScope(StaticAnalysis analysis, Scope parentScope,
 			}
 		}
 
-		@Override
-		public boolean useSpecialExec() {
-			return true;
-		}
-
 		@Override
 		public List<Boolean> isBranch(List<ParseTree> children) {
 			List<Boolean> ret = new ArrayList<>();
@@ -339,7 +433,7 @@ public Boolean runAsync() {
 //			return true;
 //		}
 		@Override
-		public Mixed exec(Target t, Environment env, Mixed... args) throws CancelCommandException, ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws CancelCommandException, ConfigRuntimeException {
 			if(args.length == 1) {
 				try {
 					// Exception type
@@ -397,10 +491,10 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
-			if(args[0].isInstanceOf(CClosure.TYPE)) {
-				CClosure old = environment.getEnv(StaticRuntimeEnv.class).getExceptionHandler();
-				environment.getEnv(StaticRuntimeEnv.class).setExceptionHandler((CClosure) args[0]);
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
+			if(args[0].isInstanceOf(CClosure.TYPE, null, env)) {
+				CClosure old = env.getEnv(StaticRuntimeEnv.class).getExceptionHandler();
+				env.getEnv(StaticRuntimeEnv.class).setExceptionHandler((CClosure) args[0]);
 				if(old == null) {
 					return CNull.NULL;
 				} else {
@@ -464,7 +558,7 @@ public ExampleScript[] examples() throws ConfigCompileException {
 	@hide("In general, this should never be used in the functional syntax, and should only be"
 			+ " automatically generated by the try keyword.")
 	@SelfStatement
-	public static class complex_try extends AbstractFunction implements Optimizable, BranchStatement, VariableScope {
+	public static class complex_try extends AbstractFunction implements FlowFunction<complex_try.ComplexTryState>, Optimizable, BranchStatement, VariableScope {
 
 		public static final String NAME = "complex_try";
 
@@ -474,6 +568,159 @@ public static class complex_try extends AbstractFunction implements Optimizable,
 		@SuppressWarnings("FieldMayBeFinal")
 		private static boolean doScreamError = false;
 
+		enum Phase { TRY_BODY, CATCH_BODY, FINALLY }
+
+		static class ComplexTryState {
+			Phase phase;
+			ParseTree[] children;
+			boolean hasFinally;
+			StepAction.FlowControl pendingAction;
+			ConfigRuntimeException suppressedException;
+			boolean exceptionWasCaught;
+			String catchVarName;
+
+			ComplexTryState(ParseTree[] children) {
+				this.children = children;
+				this.hasFinally = (children.length % 2 == 0);
+			}
+
+			@Override
+			public String toString() {
+				return phase.name();
+			}
+		}
+
+		@Override
+		public StepResult<ComplexTryState> begin(Target t, ParseTree[] children, Environment env) {
+			ComplexTryState state = new ComplexTryState(children);
+			state.phase = Phase.TRY_BODY;
+			return new StepResult<>(new Evaluate(children[0]), state);
+		}
+
+		@Override
+		public StepResult<ComplexTryState> childCompleted(Target t, ComplexTryState state,
+				Mixed result, Environment env) {
+			switch(state.phase) {
+				case TRY_BODY:
+					if(state.hasFinally) {
+						state.phase = Phase.FINALLY;
+						return new StepResult<>(new Evaluate(
+								state.children[state.children.length - 1]), state);
+					}
+					return new StepResult<>(new Complete(CVoid.VOID), state);
+				case CATCH_BODY:
+					if(state.catchVarName != null) {
+						env.getEnv(GlobalEnv.class).GetVarList().remove(state.catchVarName);
+					}
+					if(state.hasFinally) {
+						state.phase = Phase.FINALLY;
+						return new StepResult<>(new Evaluate(
+								state.children[state.children.length - 1]), state);
+					}
+					return new StepResult<>(new Complete(CVoid.VOID), state);
+				case FINALLY:
+					if(state.pendingAction != null) {
+						return new StepResult<>(state.pendingAction, state);
+					}
+					return new StepResult<>(new Complete(CVoid.VOID), state);
+				default:
+					throw ConfigRuntimeException.CreateUncatchableException(
+							"Invalid complex_try state: " + state.phase, t);
+			}
+		}
+
+		@Override
+		public StepResult<ComplexTryState> childInterrupted(Target t, ComplexTryState state,
+				StepAction.FlowControl action, Environment env) {
+			switch(state.phase) {
+				case TRY_BODY:
+					if(action.getAction() instanceof ThrowAction throwAction) {
+						ConfigRuntimeException ex = throwAction.getException();
+						if(ex instanceof AbstractCREException) {
+							AbstractCREException e = AbstractCREException.getAbstractCREException(ex);
+							CClassType exceptionType = e.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)) {
+									IVariableList varList = env.getEnv(GlobalEnv.class).GetVarList();
+									IVariable var = (IVariable) assign.getChildAt(1).getData();
+									state.catchVarName = var.getVariableName();
+									varList.set(new IVariable(CArray.TYPE, var.getVariableName(),
+											e.getExceptionObject(), t));
+									state.phase = Phase.CATCH_BODY;
+									return new StepResult<>(new Evaluate(state.children[i + 1]), state);
+								}
+							}
+						}
+						// No clause matched or non-AbstractCREException
+						if(state.hasFinally) {
+							state.pendingAction = action;
+							state.exceptionWasCaught = true;
+							state.suppressedException = throwAction.getException();
+							state.phase = Phase.FINALLY;
+							return new StepResult<>(new Evaluate(
+									state.children[state.children.length - 1]), state);
+						}
+						return null;
+					}
+					// Non-throw flow control (return, break, etc.) — run finally then re-propagate
+					if(state.hasFinally) {
+						state.pendingAction = action;
+						state.phase = Phase.FINALLY;
+						return new StepResult<>(new Evaluate(
+								state.children[state.children.length - 1]), state);
+					}
+					return null;
+				case CATCH_BODY:
+					if(action.getAction() instanceof ThrowAction throwAction) {
+						state.suppressedException = throwAction.getException();
+					}
+					state.exceptionWasCaught = true;
+					if(state.hasFinally) {
+						state.pendingAction = action;
+						state.phase = Phase.FINALLY;
+						return new StepResult<>(new Evaluate(
+								state.children[state.children.length - 1]), state);
+					}
+					return null;
+				case FINALLY:
+					if(state.exceptionWasCaught
+							&& (doScreamError || Prefs.ScreamErrors() || Prefs.DebugMode())) {
+						MSLog.GetLogger().Log(MSLog.Tags.RUNTIME, LogLevel.WARNING,
+								"Exception was thrown and unhandled in any catch clause,"
+								+ " but is being hidden by a new exception being thrown"
+								+ " in the finally clause.", t);
+						if(state.suppressedException != null) {
+							ConfigRuntimeException.HandleUncaughtException(
+									state.suppressedException, env);
+						}
+					}
+					return null;
+				default:
+					return null;
+			}
+		}
+
+		@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;
@@ -495,66 +742,7 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
-			return CVoid.VOID;
-		}
-
-		@Override
-		public Mixed execs(Target t, Environment env, Script parent, ParseTree... nodes) {
-			boolean exceptionCaught = false;
-			ConfigRuntimeException caughtException = null;
-			try {
-				parent.eval(nodes[0], env);
-			} catch (ConfigRuntimeException ex) {
-				if(!(ex instanceof AbstractCREException)) {
-					// This should never actually happen, but we want to protect
-					// against errors, and continue to throw this one up the chain
-					throw ex;
-				}
-				AbstractCREException e = AbstractCREException.getAbstractCREException(ex);
-				CClassType exceptionType = e.getExceptionType();
-				for(int i = 1; i < nodes.length - 1; i += 2) {
-					ParseTree assign = nodes[i];
-					CClassType clauseType = ((CClassType) assign.getChildAt(0).getData());
-					if(exceptionType.doesExtend(clauseType)) {
-						try {
-							// We need to define the exception in the variable table
-							IVariableList varList = env.getEnv(GlobalEnv.class).GetVarList();
-							IVariable var = (IVariable) assign.getChildAt(1).getData();
-							varList.set(new IVariable(CArray.TYPE, var.getVariableName(), e.getExceptionObject(), t));
-							parent.eval(nodes[i + 1], env);
-							varList.remove(var.getVariableName());
-						} catch (ConfigRuntimeException | FunctionReturnException newEx) {
-							if(newEx instanceof ConfigRuntimeException) {
-								caughtException = (ConfigRuntimeException) newEx;
-							}
-							exceptionCaught = true;
-							throw newEx;
-						}
-						return CVoid.VOID;
-					}
-				}
-				// No clause caught it. Continue to throw the exception up the chain
-				caughtException = ex;
-				exceptionCaught = true;
-				throw ex;
-			} finally {
-				if(nodes.length % 2 == 0) {
-					// There is a finally clause. Run that here.
-					try {
-						parent.eval(nodes[nodes.length - 1], env);
-					} catch (ConfigRuntimeException | FunctionReturnException ex) {
-						if(exceptionCaught && (doScreamError || Prefs.ScreamErrors() || Prefs.DebugMode())) {
-							MSLog.GetLogger().Log(MSLog.Tags.RUNTIME, LogLevel.WARNING, "Exception was thrown and"
-									+ " unhandled in any catch clause,"
-									+ " but is being hidden by a new exception being thrown in the finally clause.", t);
-							ConfigRuntimeException.HandleUncaughtException(caughtException, env);
-						}
-						throw ex;
-					}
-				}
-			}
-
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			return CVoid.VOID;
 		}
 
@@ -611,7 +799,7 @@ public ParseTree optimizeDynamic(Target t, Environment env,
 
 				// Check for a container function with a string as first argument, being an unknown type.
 				if(assign.numberOfChildren() > 0) {
-					if(assign.getChildAt(0).getData().isInstanceOf(CString.TYPE)) {
+					if(assign.getChildAt(0).getData().isInstanceOf(CString.TYPE, null, env)) {
 						throw new ConfigCompileException("Unknown class type: "
 								+ assign.getChildAt(0).getData().val(), t);
 					}
@@ -630,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.
@@ -678,11 +866,6 @@ public boolean preResolveVariables() {
 			return false;
 		}
 
-		@Override
-		public boolean useSpecialExec() {
-			return true;
-		}
-
 		@Override
 		public List<Boolean> isBranch(List<ParseTree> children) {
 			List<Boolean> ret = new ArrayList<>(children.size());
@@ -728,11 +911,11 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
-			StackTraceManager stManager = environment.getEnv(GlobalEnv.class).GetStackTraceManager();
-			List<ConfigRuntimeException.StackTraceElement> elements = stManager.getCurrentStackTrace();
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
+			StackTraceManager stManager = env.getEnv(GlobalEnv.class).GetStackTraceManager();
+			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/ExecutionQueue.java b/src/main/java/com/laytonsmith/core/functions/ExecutionQueue.java
index df365ec803..0ecd33953d 100644
--- a/src/main/java/com/laytonsmith/core/functions/ExecutionQueue.java
+++ b/src/main/java/com/laytonsmith/core/functions/ExecutionQueue.java
@@ -9,14 +9,15 @@
 import com.laytonsmith.core.constructs.CVoid;
 import com.laytonsmith.core.constructs.Construct;
 import com.laytonsmith.core.constructs.Target;
+import com.laytonsmith.core.constructs.generics.GenericParameters;
 import com.laytonsmith.core.environments.Environment;
 import com.laytonsmith.core.environments.GlobalEnv;
 import com.laytonsmith.core.environments.StaticRuntimeEnv;
 import com.laytonsmith.core.exceptions.CRE.CRECastException;
 import com.laytonsmith.core.exceptions.CRE.CRERangeException;
 import com.laytonsmith.core.exceptions.CRE.CREThrowable;
+import com.laytonsmith.core.exceptions.CancelCommandException;
 import com.laytonsmith.core.exceptions.ConfigRuntimeException;
-import com.laytonsmith.core.exceptions.ProgramFlowManipulationException;
 import com.laytonsmith.core.natives.interfaces.Mixed;
 import java.util.concurrent.Callable;
 import java.util.logging.Level;
@@ -56,10 +57,10 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, final Environment environment, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, final Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			final CClosure c;
 			String queue = null;
-			if(!(args[0].isInstanceOf(CClosure.TYPE))) {
+			if(!(args[0].isInstanceOf(CClosure.TYPE, null, env))) {
 				throw new CRECastException("Parameter 1 to " + getName() + " must be a closure.", t);
 			}
 			c = ((CClosure) args[0]);
@@ -67,8 +68,8 @@ public Mixed exec(Target t, final Environment environment, Mixed... args) throws
 				queue = Construct.nval(args[1]);
 			}
 
-			environment.getEnv(StaticRuntimeEnv.class).getExecutionQueue().push(
-					environment.getEnv(StaticRuntimeEnv.class).GetDaemonManager(), queue, new Runnable() {
+			env.getEnv(StaticRuntimeEnv.class).getExecutionQueue().push(
+					env.getEnv(StaticRuntimeEnv.class).GetDaemonManager(), queue, new Runnable() {
 
 				@Override
 				public void run() {
@@ -80,8 +81,8 @@ public Object call() throws Exception {
 								try {
 									c.executeCallable();
 								} catch (ConfigRuntimeException ex) {
-									ConfigRuntimeException.HandleUncaughtException(ex, environment);
-								} catch (ProgramFlowManipulationException ex) {
+									ConfigRuntimeException.HandleUncaughtException(ex, env);
+								} catch (CancelCommandException ex) {
 									// Ignored
 								}
 								return null;
@@ -139,10 +140,10 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, final Environment environment, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, final Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			final CClosure c;
 			String queue = null;
-			if(!(args[0].isInstanceOf(CClosure.TYPE))) {
+			if(!(args[0].isInstanceOf(CClosure.TYPE, null, env))) {
 				throw new CRECastException("Parameter 1 to " + getName() + " must be a closure.", t);
 			}
 			c = ((CClosure) args[0]);
@@ -150,8 +151,8 @@ public Mixed exec(Target t, final Environment environment, Mixed... args) throws
 				queue = Construct.nval(args[1]);
 			}
 
-			environment.getEnv(StaticRuntimeEnv.class).getExecutionQueue().pushFront(
-					environment.getEnv(StaticRuntimeEnv.class).GetDaemonManager(), queue, new Runnable() {
+			env.getEnv(StaticRuntimeEnv.class).getExecutionQueue().pushFront(
+					env.getEnv(StaticRuntimeEnv.class).GetDaemonManager(), queue, new Runnable() {
 
 				@Override
 				public void run() {
@@ -163,8 +164,8 @@ public Object call() throws Exception {
 								try {
 									c.executeCallable();
 								} catch (ConfigRuntimeException ex) {
-									ConfigRuntimeException.HandleUncaughtException(ex, environment);
-								} catch (ProgramFlowManipulationException ex) {
+									ConfigRuntimeException.HandleUncaughtException(ex, env);
+								} catch (CancelCommandException ex) {
 									// Ignored
 								}
 								return null;
@@ -222,12 +223,12 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			String queue = null;
 			if(args.length == 1) {
 				queue = Construct.nval(args[0]);
 			}
-			environment.getEnv(StaticRuntimeEnv.class).getExecutionQueue().remove(queue);
+			env.getEnv(StaticRuntimeEnv.class).getExecutionQueue().remove(queue);
 			return CVoid.VOID;
 		}
 
@@ -272,12 +273,12 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			String queue = null;
 			if(args.length == 1) {
 				queue = Construct.nval(args[0]);
 			}
-			environment.getEnv(StaticRuntimeEnv.class).getExecutionQueue().removeFront(queue);
+			env.getEnv(StaticRuntimeEnv.class).getExecutionQueue().removeFront(queue);
 			return CVoid.VOID;
 		}
 
@@ -323,12 +324,12 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			String queue = null;
 			if(args.length == 1) {
 				queue = Construct.nval(args[0]);
 			}
-			environment.getEnv(StaticRuntimeEnv.class).getExecutionQueue().clear(queue);
+			env.getEnv(StaticRuntimeEnv.class).getExecutionQueue().clear(queue);
 			return CVoid.VOID;
 		}
 
@@ -374,12 +375,12 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			String queue = null;
 			if(args.length == 1) {
 				queue = Construct.nval(args[0]);
 			}
-			return CBoolean.get(environment.getEnv(StaticRuntimeEnv.class).getExecutionQueue().isRunning(queue));
+			return CBoolean.get(env.getEnv(StaticRuntimeEnv.class).getExecutionQueue().isRunning(queue));
 		}
 
 		@Override
@@ -423,7 +424,7 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			String queue = null;
 			if(args.length == 2) {
 				queue = Construct.nval(args[1]);
@@ -432,8 +433,8 @@ public Mixed exec(Target t, Environment environment, Mixed... args) throws Confi
 			if(delay < 0) {
 				throw new CRERangeException("Negative delay", t);
 			}
-			environment.getEnv(StaticRuntimeEnv.class).getExecutionQueue().push(
-					environment.getEnv(StaticRuntimeEnv.class).GetDaemonManager(), queue, new Runnable() {
+			env.getEnv(StaticRuntimeEnv.class).getExecutionQueue().push(
+					env.getEnv(StaticRuntimeEnv.class).GetDaemonManager(), queue, new Runnable() {
 
 				@Override
 				public void run() {
@@ -489,7 +490,7 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			String queue = null;
 			if(args.length == 2) {
 				queue = Construct.nval(args[1]);
@@ -498,8 +499,8 @@ public Mixed exec(Target t, Environment environment, Mixed... args) throws Confi
 			if(delay < 0) {
 				throw new CRERangeException("Negative delay", t);
 			}
-			environment.getEnv(StaticRuntimeEnv.class).getExecutionQueue().pushFront(
-					environment.getEnv(StaticRuntimeEnv.class).GetDaemonManager(), queue, new Runnable() {
+			env.getEnv(StaticRuntimeEnv.class).getExecutionQueue().pushFront(
+					env.getEnv(StaticRuntimeEnv.class).GetDaemonManager(), queue, new Runnable() {
 
 				@Override
 				public void run() {
diff --git a/src/main/java/com/laytonsmith/core/functions/ExtensionMeta.java b/src/main/java/com/laytonsmith/core/functions/ExtensionMeta.java
index 633ec52668..a365094d05 100644
--- a/src/main/java/com/laytonsmith/core/functions/ExtensionMeta.java
+++ b/src/main/java/com/laytonsmith/core/functions/ExtensionMeta.java
@@ -12,6 +12,7 @@
 import com.laytonsmith.core.constructs.CBoolean;
 import com.laytonsmith.core.constructs.CString;
 import com.laytonsmith.core.constructs.Target;
+import com.laytonsmith.core.constructs.generics.GenericParameters;
 import com.laytonsmith.core.environments.Environment;
 import com.laytonsmith.core.events.Event;
 import com.laytonsmith.core.events.EventList;
@@ -57,9 +58,9 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			try {
-				FunctionList.getFunction(args[0].val().toLowerCase(), environment.getEnvClasses(), t);
+				FunctionList.getFunction(args[0].val().toLowerCase(), env.getEnvClasses(), t);
 			} catch (ConfigCompileException ex) {
 				return CBoolean.FALSE;
 			}
@@ -112,7 +113,7 @@ public ParseTree optimizeDynamic(Target t, Environment env,
 				throw new ConfigCompileException(getName() + " can only accept one argument", t);
 			}
 
-			if(!(children.get(0).getData().isInstanceOf(CString.TYPE))) {
+			if(!(children.get(0).getData().isInstanceOf(CString.TYPE, null, env))) {
 				throw new ConfigCompileException(getName() + " can only accept hardcoded string values", t);
 			}
 
@@ -159,7 +160,7 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			return CBoolean.get(EventList.getEvent(args[0].val().toLowerCase()) != null);
 		}
 
@@ -200,11 +201,11 @@ public ParseTree optimizeDynamic(Target t, Environment env,
 				throw new ConfigCompileException(getName() + " can only accept one argument", t);
 			}
 
-			if(!(children.get(0).getData().isInstanceOf(CString.TYPE))) {
+			if(!(children.get(0).getData().isInstanceOf(CString.TYPE, null, env))) {
 				throw new ConfigCompileException(getName() + " can only accept hardcoded string values", t);
 			}
 
-			return new ParseTree(this.exec(t, null, children.get(0).getData()), children.get(0).getFileOptions());
+			return new ParseTree(this.exec(t, null, null, children.get(0).getData()), children.get(0).getFileOptions());
 		}
 	}
 
@@ -228,7 +229,7 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			Map<URL, ExtensionTracker> trackers = ExtensionManager.getTrackers();
 			for(ExtensionTracker tracker : trackers.values()) {
 				String identifier = tracker.getIdentifier();
@@ -273,10 +274,10 @@ public ParseTree optimizeDynamic(Target t, Environment env,
 				throws ConfigCompileException, ConfigRuntimeException {
 			if(children.size() != 1) {
 				throw new ConfigCompileException(getName() + " can only accept one argument", t);
-			} else if(!(children.get(0).getData().isInstanceOf(CString.TYPE))) {
+			} else if(!(children.get(0).getData().isInstanceOf(CString.TYPE, null, env))) {
 				throw new ConfigCompileException(getName() + " can only accept hardcoded string values", t);
 			} else {
-				return new ParseTree(this.exec(t, null, children.get(0).getData()), children.get(0).getFileOptions());
+				return new ParseTree(this.exec(t, null, null, children.get(0).getData()), children.get(0).getFileOptions());
 			}
 		}
 	}
@@ -300,7 +301,7 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			Map<URL, ExtensionTracker> trackers = ExtensionManager.getTrackers();
 
 			CArray retn = CArray.GetAssociativeArray(t);
diff --git a/src/main/java/com/laytonsmith/core/functions/Federation.java b/src/main/java/com/laytonsmith/core/functions/Federation.java
index e7d13d91e2..eb457ec2a4 100644
--- a/src/main/java/com/laytonsmith/core/functions/Federation.java
+++ b/src/main/java/com/laytonsmith/core/functions/Federation.java
@@ -31,7 +31,7 @@ public static String docs() {
 //		}
 //
 //		@Override
-//		public Construct exec(final Target t, final Environment environment, Construct... args) throws ConfigRuntimeException {
+//		public Construct exec(final Target t, final Environment env, Construct... args) throws ConfigRuntimeException {
 //			final CArray connection_data = Static.AssertType(CArray.class, args, 0, this, t);
 //			final CClosure remote_callback = Static.AssertType(CClosure.class, args, 1, this, t);
 //			final CClosure local_callback;
@@ -67,7 +67,7 @@ public static String docs() {
 //				password = null;
 //			}
 //			if(connection_data.containsKey("remote_public_key")) {
-//				remote_public_key = Static.GetFileFromArgument(connection_data.get("remote_public_key").val(), environment, t, null);
+//				remote_public_key = Static.GetFileFromArgument(connection_data.get("remote_public_key").val(), env, t, null);
 //			} else {
 //				remote_public_key = null;
 //			}
@@ -76,7 +76,7 @@ public static String docs() {
 //			} else {
 //				master_port = com.laytonsmith.core.federation.Federation.MASTER_PORT;
 //			}
-//			final DaemonManager dm = environment.getEnv(GlobalEnv.class).GetDaemonManager();
+//			final DaemonManager dm = env.getEnv(GlobalEnv.class).GetDaemonManager();
 //			// All the arguments are now parsed. Kick off a new thread.
 //
 //			new Thread(new Runnable() {
@@ -256,7 +256,7 @@ public static String docs() {
 //		}
 //
 //		@Override
-//		public Construct exec(Target t, final Environment environment, Construct... args) throws ConfigRuntimeException {
+//		public Construct exec(Target t, final Environment env, Construct... args) throws ConfigRuntimeException {
 //			final String server_name;
 //			final String password;
 //			final File authorized_keys;
@@ -279,7 +279,7 @@ public static String docs() {
 //				password = null;
 //			}
 //			if(connection_details.containsKey("authorized_keys")) {
-//				authorized_keys = Static.GetFileFromArgument(connection_details.get("authorized_keys").val(), environment, t, null);
+//				authorized_keys = Static.GetFileFromArgument(connection_details.get("authorized_keys").val(), env, t, null);
 //			} else {
 //				authorized_keys = null;
 //			}
@@ -303,8 +303,8 @@ public static String docs() {
 //				throw new Exceptions.FormatException("A server with the name \"" + server_name + "\" is already registered.", t);
 //			}
 //
-//			final PersistenceNetwork pn = environment.getEnv(GlobalEnv.class).GetPersistenceNetwork();
-//			final DaemonManager dm = environment.getEnv(GlobalEnv.class).GetDaemonManager();
+//			final PersistenceNetwork pn = env.getEnv(GlobalEnv.class).GetPersistenceNetwork();
+//			final DaemonManager dm = env.getEnv(GlobalEnv.class).GetDaemonManager();
 //			// Argument parsing and validation is now done.
 //			final boolean is_master;
 //			try {
@@ -391,7 +391,7 @@ public static String docs() {
 //								try {
 //									HandleReadOnlyException(ex);
 //								} catch (ConfigRuntimeException ee) {
-//									ConfigRuntimeException.HandleUncaughtException(ee, environment);
+//									ConfigRuntimeException.HandleUncaughtException(ee, env);
 //								}
 //							}
 //							break;
@@ -483,7 +483,7 @@ public static String docs() {
 //		}
 //
 //		@Override
-//		public Construct exec(Target t, Environment environment, Construct... args) throws ConfigRuntimeException {
+//		public Construct exec(Target t, Environment env, Construct... args) throws ConfigRuntimeException {
 //			String server_name = args[0].val();
 //
 //			for(FederationServer server : federationServers.values()) {
@@ -501,7 +501,7 @@ public static String docs() {
 //			synchronized (serverCountLock) {
 //				serverCount--;
 //				if(serverCount == 0) {
-//					environment.getEnv(GlobalEnv.class).GetDaemonManager().deactivateThread(null);
+//					env.getEnv(GlobalEnv.class).GetDaemonManager().deactivateThread(null);
 //				}
 //			}
 //
diff --git a/src/main/java/com/laytonsmith/core/functions/FileHandling.java b/src/main/java/com/laytonsmith/core/functions/FileHandling.java
index 965f2a4cc2..bbe275b31d 100644
--- a/src/main/java/com/laytonsmith/core/functions/FileHandling.java
+++ b/src/main/java/com/laytonsmith/core/functions/FileHandling.java
@@ -28,6 +28,7 @@
 import com.laytonsmith.core.constructs.CString;
 import com.laytonsmith.core.constructs.CVoid;
 import com.laytonsmith.core.constructs.Target;
+import com.laytonsmith.core.constructs.generics.GenericParameters;
 import com.laytonsmith.core.environments.Environment;
 import com.laytonsmith.core.environments.StaticRuntimeEnv;
 import com.laytonsmith.core.exceptions.CRE.CRECastException;
@@ -80,7 +81,7 @@ public Integer[] numArgs() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment env, Mixed... args) throws CancelCommandException, ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws CancelCommandException, ConfigRuntimeException {
 			File location = Static.GetFileFromArgument(args[0].val(), env, t, null);
 			String charset = "UTF-8";
 			if(args.length > 1) {
@@ -160,7 +161,7 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			return CNull.NULL;
 		}
 
@@ -204,9 +205,9 @@ public ParseTree optimizeDynamic(Target t, Environment env,
 
 			String ret;
 			if(children.size() == 1) {
-				ret = new read().exec(t, env, children.get(0).getData()).val();
+				ret = new read().exec(t, env, null, children.get(0).getData()).val();
 			} else {
-				ret = new read().exec(t, env, children.get(0).getData(),
+				ret = new read().exec(t, env, null, children.get(0).getData(),
 						children.get(1).getData()).val();
 			}
 			ParseTree tree = new ParseTree(new CString(ret, t), fileOptions);
@@ -262,7 +263,7 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(final Target t, final Environment environment, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(final Target t, final Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			startup();
 			final String file = args[0].val();
 			final CClosure callback;
@@ -274,12 +275,12 @@ public Mixed exec(final Target t, final Environment environment, Mixed... args)
 			}
 			final String encoding = _encoding;
 
-			if(!(args[1 + callbackIndex].isInstanceOf(CClosure.TYPE))) {
+			if(!(args[1 + callbackIndex].isInstanceOf(CClosure.TYPE, null, env))) {
 				throw new CRECastException("Expected parameter " + (2 + callbackIndex) + " of " + getName() + " to be a closure!", t);
 			} else {
 				callback = ((CClosure) args[1]);
 			}
-			if(!Static.InCmdLine(environment, true)) {
+			if(!Static.InCmdLine(env, true)) {
 				try {
 					if(!Security.CheckSecurity(file)) {
 						throw new CRESecurityException("You do not have permission to access the file '" + file + "'", t);
@@ -288,7 +289,7 @@ public Mixed exec(final Target t, final Environment environment, Mixed... args)
 					throw new CREIOException(ex.getMessage(), t, ex);
 				}
 			}
-			queue.invokeLater(environment.getEnv(StaticRuntimeEnv.class).GetDaemonManager(), new Runnable() {
+			queue.invokeLater(env.getEnv(StaticRuntimeEnv.class).GetDaemonManager(), new Runnable() {
 
 				@Override
 				public void run() {
@@ -305,7 +306,7 @@ public void run() {
 					} else {
 						try {
 							//It's a local file read
-							File _file = Static.GetFileFromArgument(file, environment, t, null);
+							File _file = Static.GetFileFromArgument(file, env, t, null);
 							returnString = FileUtil.read(_file, encoding);
 						} catch (IOException ex) {
 							exception = new CREIOException(ex.getMessage(), t, ex);
@@ -321,10 +322,10 @@ public void run() {
 					if(exception == null) {
 						cex = CNull.NULL;
 					} else {
-						cex = ObjectGenerator.GetGenerator().exception(exception, environment, t);
+						cex = ObjectGenerator.GetGenerator().exception(exception, env, t);
 					}
 					StaticLayer.GetConvertor().runOnMainThreadLater(
-							environment.getEnv(StaticRuntimeEnv.class).GetDaemonManager(), new Runnable() {
+							env.getEnv(StaticRuntimeEnv.class).GetDaemonManager(), new Runnable() {
 
 						@Override
 						public void run() {
@@ -389,10 +390,10 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
-			File location = Static.GetFileFromArgument(args[0].val(), environment, t, null);
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
+			File location = Static.GetFileFromArgument(args[0].val(), env, t, null);
 			try {
-				if(!Static.InCmdLine(environment, true) && !Security.CheckSecurity(location)) {
+				if(!Static.InCmdLine(env, true) && !Security.CheckSecurity(location)) {
 					throw new CRESecurityException("You do not have permission to access the file '" + location + "'", t);
 				}
 			} catch (IOException ex) {
@@ -442,7 +443,7 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment env, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			File location = Static.GetFileFromArgument(args[0].val(), env, t, null);
 			try {
 				if(!Static.InCmdLine(env, true)) {
@@ -507,7 +508,7 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment env, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			File location = Static.GetFileFromArgument(args[0].val(), env, t, null);
 			try {
 				//Verify this file is not above the craftbukkit directory (or whatever directory the user specified
@@ -570,7 +571,7 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			//TODO: Doesn't work yet.
 			//TODO: Be sure to change over to Static.GetFileFromArgument
 			String path = args[0].val().trim().replace('\\', '/');
@@ -634,8 +635,8 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
-			File f = Static.GetFileFromArgument(args[0].val(), environment, t, null);
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
+			File f = Static.GetFileFromArgument(args[0].val(), env, t, null);
 			try {
 				return new CString(f.getCanonicalPath(), t);
 			} catch (IOException ex) {
diff --git a/src/main/java/com/laytonsmith/core/functions/Function.java b/src/main/java/com/laytonsmith/core/functions/Function.java
index 3fe5b7d4ff..2b807ed80a 100644
--- a/src/main/java/com/laytonsmith/core/functions/Function.java
+++ b/src/main/java/com/laytonsmith/core/functions/Function.java
@@ -1,9 +1,9 @@
 package com.laytonsmith.core.functions;
 
+import com.laytonsmith.PureUtilities.Common.ReflectionUtils;
 import com.laytonsmith.core.Documentation;
 import com.laytonsmith.core.LogLevel;
 import com.laytonsmith.core.ParseTree;
-import com.laytonsmith.core.Script;
 import com.laytonsmith.core.compiler.SelfStatement;
 import com.laytonsmith.core.compiler.analysis.Scope;
 import com.laytonsmith.core.compiler.analysis.StaticAnalysis;
@@ -11,14 +11,18 @@
 import com.laytonsmith.core.compiler.signature.SignatureBuilder;
 import com.laytonsmith.core.constructs.CClassType;
 import com.laytonsmith.core.constructs.Target;
+import com.laytonsmith.core.constructs.generics.GenericParameters;
 import com.laytonsmith.core.environments.Environment;
 import com.laytonsmith.core.exceptions.CRE.CREThrowable;
 import com.laytonsmith.core.exceptions.CancelCommandException;
 import com.laytonsmith.core.exceptions.ConfigCompileException;
 import com.laytonsmith.core.exceptions.ConfigRuntimeException;
 import com.laytonsmith.core.natives.interfaces.Mixed;
+import java.lang.reflect.InvocationTargetException;
+import java.util.Collections;
 import java.util.List;
 import java.util.Set;
+import java.util.concurrent.ConcurrentHashMap;
 
 /**
  * Note that to "activate" this class as a function, you must prefix the '@api' annotation to it.
@@ -68,18 +72,18 @@ public interface Function extends FunctionBase, Documentation, Comparable<Functi
 	 * function can provide a more specific error message for the user. If the function was canceled due to a fatal
 	 * error in the syntax of the user input or some similar situation, it should throw a ConfigRuntimeException. All
 	 * parameters sent to the function have already been resolved into an atomic value, so functions do not have to
-	 * worry about resolving parameters. There is an explicit check made before calling exec to ensure that Construct
-	 * ... args will only be one of the atomic Constructs. If a code tree is needed instead of a resolved construct, the
-	 * function should indicate so, and {@code execs} will be called instead. If exec is needed, execs should return
-	 * CVoid.
+	 * worry about resolving parameters. There is an explicit check made before calling exec to ensure that Mixed
+	 * ... args will only be one of the atomic objects. If a code tree is needed instead of a resolved construct, the
+	 * function should implement {@link FlowFunction} instead.
 	 *
 	 * @param t The location of this function call in the code, used for correct error messages
 	 * @param environment The current code environment
+	 * @param generics The generic parameters for this function call, or null if none were provided
 	 * @param args An array of evaluated objects
 	 * @return
 	 * @throws CancelCommandException
 	 */
-	public Mixed exec(Target t, Environment env, Mixed... args) throws ConfigRuntimeException;
+	public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException;
 
 	/**
 	 * Gets the function's signatures. {@link SignatureBuilder} offers a convenient way to create these signatures.
@@ -143,25 +147,6 @@ public Scope linkScope(StaticAnalysis analysis, Scope parentScope,
 	public ParseTree postParseRewrite(ParseTree ast, Environment env,
 			Set<Class<? extends Environment.EnvironmentImpl>> envs, Set<ConfigCompileException> exceptions);
 
-	/**
-	 * If a function needs a code tree instead of a resolved construct, it should return true here. Most functions will
-	 * return false for this value.
-	 *
-	 * @return
-	 */
-	public boolean useSpecialExec();
-
-	/**
-	 * If useSpecialExec indicates it needs the code tree instead of the resolved constructs, this gets called instead
-	 * of exec. If execs is needed, exec should return CVoid.
-	 *
-	 * @param t
-	 * @param env
-	 * @param nodes
-	 * @return
-	 */
-	public Mixed execs(Target t, Environment env, Script parent, ParseTree... nodes);
-
 	/**
 	 * Returns an array of example scripts, which are used for documentation purposes.
 	 * <p>
@@ -188,15 +173,16 @@ public ParseTree postParseRewrite(ParseTree ast, Environment env,
 	public LogLevel profileAt();
 
 	/**
-	 * Returns the message to use when this function gets profiled, if useSpecialExec returns false.
+	 * Returns the message to use when this function gets profiled with resolved args.
 	 *
+	 * @param env
 	 * @param args
 	 * @return
 	 */
-	public String profileMessage(Mixed... args);
+	public String profileMessage(Environment env, Mixed... args);
 
 	/**
-	 * Returns the message to use when this function gets profiled, if useSpecialExec returns true.
+	 * Returns the message to use when this function gets profiled with unresolved parse tree args.
 	 *
 	 * @param args
 	 * @return
@@ -237,4 +223,91 @@ public interface CodeBranch {
 		 */
 		public List<ParseTree> getBranches(ParseTree self);
 	}
+
+	// Reflection bridge for backward compatibility with 3rd-party functions
+	// that still implement the old 3-arg exec(Target, Environment, Mixed...) signature.
+	// Once all known extensions have been updated, the cache and reflection fallback
+	// can be removed, and callers can invoke exec directly.
+	// Added 2026-02-23.
+
+	/**
+	 * Cache of Function classes that only implement the old 3-arg exec signature.
+	 */
+	Set<Class<?>> OLD_EXEC_CACHE = Collections.newSetFromMap(new ConcurrentHashMap<>());
+
+	/**
+	 * Invokes {@link #exec} on the given function with backward compatibility for 3rd-party functions
+	 * that still implement the old 3-arg exec(Target, Environment, Mixed...) signature.
+	 * For functions with the new signature, this has zero overhead beyond a Set lookup on cached misses.
+	 *
+	 * @param f The function to execute.
+	 * @param t The code target.
+	 * @param env The environment.
+	 * @param args The arguments.
+	 * @return The result of the function execution.
+	 * @throws ConfigRuntimeException
+	 */
+	static Mixed ExecuteFunction(Function f, Target t, Environment env, Mixed[] args) throws ConfigRuntimeException {
+		if(OLD_EXEC_CACHE.contains(f.getClass())) {
+			return invokeOldExec(f, t, env, args);
+		}
+		try {
+			return f.exec(t, env, null, args);
+		} catch(AbstractMethodError e) {
+			OLD_EXEC_CACHE.add(f.getClass());
+			return invokeOldExec(f, t, env, args);
+		}
+	}
+
+	private static Mixed invokeOldExec(Function f, Target t, Environment env, Mixed[] args)
+			throws ConfigRuntimeException {
+		try {
+			return ReflectionUtils.invokeMethod(f.getClass(), f, "exec",
+					new Class[]{Target.class, Environment.class, Mixed[].class},
+					new Object[]{t, env, args});
+		} catch(ReflectionUtils.ReflectionException e) {
+			Throwable cause = e.getCause();
+			if(cause instanceof InvocationTargetException) {
+				cause = cause.getCause();
+			}
+			if(cause instanceof ConfigRuntimeException) {
+				throw (ConfigRuntimeException) cause;
+			}
+			throw e;
+		}
+	}
+
+	// Reflection bridge for backward compatibility with 3rd-party functions
+	// that still implement the old profileMessage(Mixed...) signature only.
+	// Added 2026-02-23.
+	Set<Class<?>> OLD_PROFILE_MESSAGE_CACHE = Collections.newSetFromMap(new ConcurrentHashMap<>());
+
+	static String ExecuteProfileMessage(Function f, Environment env, Mixed[] args) {
+		if(OLD_PROFILE_MESSAGE_CACHE.contains(f.getClass())) {
+			return invokeOldProfileMessage(f, args);
+		}
+		try {
+			return f.profileMessage(env, args);
+		} catch(AbstractMethodError e) {
+			OLD_PROFILE_MESSAGE_CACHE.add(f.getClass());
+			return invokeOldProfileMessage(f, args);
+		}
+	}
+
+	private static String invokeOldProfileMessage(Function f, Mixed[] args) {
+		try {
+			return (String) ReflectionUtils.invokeMethod(f.getClass(), f, "profileMessage",
+					new Class[]{Mixed[].class},
+					new Object[]{args});
+		} catch(ReflectionUtils.ReflectionException e) {
+			Throwable cause = e.getCause();
+			if(cause instanceof InvocationTargetException) {
+				cause = cause.getCause();
+			}
+			if(cause instanceof ConfigRuntimeException) {
+				throw (ConfigRuntimeException) cause;
+			}
+			throw e;
+		}
+	}
 }
diff --git a/src/main/java/com/laytonsmith/core/functions/IncludeCache.java b/src/main/java/com/laytonsmith/core/functions/IncludeCache.java
index f841f11414..c679bbedda 100644
--- a/src/main/java/com/laytonsmith/core/functions/IncludeCache.java
+++ b/src/main/java/com/laytonsmith/core/functions/IncludeCache.java
@@ -16,10 +16,10 @@
 import com.laytonsmith.core.exceptions.CRE.CREIOException;
 import com.laytonsmith.core.exceptions.CRE.CREIncludeException;
 import com.laytonsmith.core.exceptions.CRE.CRESecurityException;
+import com.laytonsmith.core.exceptions.CancelCommandException;
 import com.laytonsmith.core.exceptions.ConfigCompileException;
 import com.laytonsmith.core.exceptions.ConfigCompileGroupException;
 import com.laytonsmith.core.exceptions.ConfigRuntimeException;
-import com.laytonsmith.core.exceptions.ProgramFlowManipulationException;
 import com.laytonsmith.core.profiler.ProfilePoint;
 import com.laytonsmith.core.profiler.Profiler;
 import java.io.File;
@@ -238,7 +238,7 @@ public void executeAutoIncludes(Environment env, Script s) {
 			try {
 				MethodScriptCompiler.execute(
 						IncludeCache.get(f, env, env.getEnvClasses(), new Target(0, f, 0)), env, null, s);
-			} catch (ProgramFlowManipulationException e) {
+			} catch (CancelCommandException e) {
 				ConfigRuntimeException.HandleUncaughtException(ConfigRuntimeException.CreateUncatchableException(
 						"Cannot break program flow in auto include files.", e.getTarget()), env);
 			} catch (ConfigRuntimeException e) {
diff --git a/src/main/java/com/laytonsmith/core/functions/InventoryManagement.java b/src/main/java/com/laytonsmith/core/functions/InventoryManagement.java
index 69480e403b..507b81c068 100644
--- a/src/main/java/com/laytonsmith/core/functions/InventoryManagement.java
+++ b/src/main/java/com/laytonsmith/core/functions/InventoryManagement.java
@@ -38,6 +38,7 @@
 import com.laytonsmith.core.constructs.CVoid;
 import com.laytonsmith.core.constructs.Construct;
 import com.laytonsmith.core.constructs.Target;
+import com.laytonsmith.core.constructs.generics.GenericParameters;
 import com.laytonsmith.core.environments.CommandHelperEnvironment;
 import com.laytonsmith.core.environments.Environment;
 import com.laytonsmith.core.exceptions.CRE.CREBadEntityException;
@@ -122,7 +123,7 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment env, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			Integer index = -1;
 			boolean all;
 			MCPlayer m;
@@ -132,25 +133,25 @@ public Mixed exec(Target t, Environment env, Mixed... args) throws ConfigRuntime
 				Static.AssertPlayerNonNull(m, t);
 			} else if(args.length == 1) {
 				all = true;
-				m = Static.GetPlayer(args[0], t);
+				m = Static.GetPlayer(args[0], t, env);
 			} else {
 				if(args[1] instanceof CNull) {
 					index = null;
 				} else {
-					index = ArgumentValidation.getInt32(args[1], t);
+					index = ArgumentValidation.getInt32(args[1], t, env);
 				}
 				all = false;
-				m = Static.GetPlayer(args[0], t);
+				m = Static.GetPlayer(args[0], t, env);
 			}
 			if(all) {
-				CArray ret = CArray.GetAssociativeArray(t);
+				CArray ret = CArray.GetAssociativeArray(t, null, env);
 				for(int i = 0; i < 36; i++) {
-					ret.set(i, getInvSlot(m, i, t), t);
+					ret.set(i, getInvSlot(m, i, t), t, env);
 				}
 				for(int i = 100; i < 104; i++) {
-					ret.set(i, getInvSlot(m, i, t), t);
+					ret.set(i, getInvSlot(m, i, t), t, env);
 				}
-				ret.set(-106, getInvSlot(m, -106, t), t);
+				ret.set(-106, getInvSlot(m, -106, t), t, env);
 				return ret;
 			} else {
 				return getInvSlot(m, index, t);
@@ -217,13 +218,13 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			MCPlayer p;
 
 			if(args.length == 1) {
-				p = Static.GetPlayer(args[0], t);
+				p = Static.GetPlayer(args[0], t, env);
 			} else {
-				p = environment.getEnv(CommandHelperEnvironment.class).GetPlayer();
+				p = env.getEnv(CommandHelperEnvironment.class).GetPlayer();
 			}
 
 			Static.AssertPlayerNonNull(p, t);
@@ -273,13 +274,13 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			MCPlayer p;
 
 			if(args.length == 1) {
-				p = Static.GetPlayer(args[0], t);
+				p = Static.GetPlayer(args[0], t, env);
 			} else {
-				p = environment.getEnv(CommandHelperEnvironment.class).GetPlayer();
+				p = env.getEnv(CommandHelperEnvironment.class).GetPlayer();
 				if(p == null) {
 					throw new CREInsufficientArgumentsException(
 							"You have to specify a player when running " + this.getName() + " from console.", t);
@@ -332,18 +333,18 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			MCPlayer player;
 			MCPlayer other;
 
 			if(args.length == 1) {
-				player = environment.getEnv(CommandHelperEnvironment.class).GetPlayer();
-				other = Static.GetPlayer(args[0], t);
+				player = env.getEnv(CommandHelperEnvironment.class).GetPlayer();
+				other = Static.GetPlayer(args[0], t, env);
 			} else if(args.length == 2) {
-				other = Static.GetPlayer(args[0], t);
-				player = Static.GetPlayer(args[1], t);
+				other = Static.GetPlayer(args[0], t, env);
+				player = Static.GetPlayer(args[1], t, env);
 			} else {
-				player = environment.getEnv(CommandHelperEnvironment.class).GetPlayer();
+				player = env.getEnv(CommandHelperEnvironment.class).GetPlayer();
 				other = player;
 			}
 
@@ -396,13 +397,13 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			MCPlayer p;
 
 			if(args.length == 1) {
-				p = Static.GetPlayer(args[0], t);
+				p = Static.GetPlayer(args[0], t, env);
 			} else {
-				p = environment.getEnv(CommandHelperEnvironment.class).GetPlayer();
+				p = env.getEnv(CommandHelperEnvironment.class).GetPlayer();
 			}
 
 			Static.AssertPlayerNonNull(p, t);
@@ -490,17 +491,17 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment env, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			MCPlayer m;
 			Mixed arg;
 			if(args.length == 3) {
 				// Single item
-				m = Static.GetPlayer(args[0], t);
-				MCItemStack is = ObjectGenerator.GetGenerator().item(args[2], t);
+				m = Static.GetPlayer(args[0], t, env);
+				MCItemStack is = ObjectGenerator.GetGenerator().item(args[2], t, env);
 				if(args[1] instanceof CNull) {
 					m.setItemInHand(is);
 				} else {
-					setInvSlot(m.getInventory(), ArgumentValidation.getInt32(args[1], t), is);
+					setInvSlot(m.getInventory(), ArgumentValidation.getInt32(args[1], t, env), is);
 				}
 				return CVoid.VOID;
 			} else if(args.length == 1) {
@@ -508,10 +509,10 @@ public Mixed exec(Target t, Environment env, Mixed... args) throws ConfigRuntime
 				Static.AssertPlayerNonNull(m, t);
 				arg = args[0];
 			} else {
-				m = Static.GetPlayer(args[0], t);
+				m = Static.GetPlayer(args[0], t, env);
 				arg = args[1];
 			}
-			if(!(arg.isInstanceOf(CArray.TYPE))) {
+			if(!(arg.isInstanceOf(CArray.TYPE, null, env))) {
 				throw new CRECastException("Expecting an array as the last argument.", t);
 			}
 			CArray array = (CArray) arg;
@@ -519,12 +520,12 @@ public Mixed exec(Target t, Environment env, Mixed... args) throws ConfigRuntime
 			for(String key : array.stringKeySet()) {
 				if(key.isEmpty() || key.equals("null")) {
 					//It was a null key
-					MCItemStack is = ObjectGenerator.GetGenerator().item(array.get("", t), t);
+					MCItemStack is = ObjectGenerator.GetGenerator().item(array.get("", t, env), t, env);
 					m.setItemInHand(is);
 				} else {
 					try {
 						int index = Integer.parseInt(key);
-						MCItemStack is = ObjectGenerator.GetGenerator().item(array.get(index, t), t);
+						MCItemStack is = ObjectGenerator.GetGenerator().item(array.get(index, t, env), t, env);
 						setInvSlot(inv, index, is);
 					} catch (NumberFormatException e) {
 						ConfigRuntimeException.DoWarning("Expecting integer value for key in array passed to"
@@ -594,13 +595,13 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment env, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			MCPlayer p;
 			if(args.length == 0) {
 				p = env.getEnv(CommandHelperEnvironment.class).GetPlayer();
 				Static.AssertPlayerNonNull(p, t);
 			} else {
-				p = Static.GetPlayer(args[0].val(), t);
+				p = Static.GetPlayer(args[0].val(), t, env);
 			}
 			MCPlayerInventory inv = p.getInventory();
 			if(inv == null) {
@@ -651,17 +652,17 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			MCPlayer p;
 			MCItemStack is;
 			Mixed c;
 			CArray ca = null;
 			if(args.length == 1) {
-				p = environment.getEnv(CommandHelperEnvironment.class).GetPlayer();
+				p = env.getEnv(CommandHelperEnvironment.class).GetPlayer();
 				Static.AssertPlayerNonNull(p, t);
 				c = args[0];
 			} else {
-				p = Static.GetPlayer(args[0], t);
+				p = Static.GetPlayer(args[0], t, env);
 				c = args[1];
 			}
 
@@ -669,9 +670,9 @@ public Mixed exec(Target t, Environment environment, Mixed... args) throws Confi
 				return new CInt(0, t);
 			}
 
-			if(c.isInstanceOf(CArray.TYPE)) {
+			if(c.isInstanceOf(CArray.TYPE, null, env)) {
 				ca = (CArray) c;
-				is = ObjectGenerator.GetGenerator().item(ca, t);
+				is = ObjectGenerator.GetGenerator().item(ca, t, env);
 			} else {
 				is = Static.ParseItemNotation(null, c.val(), 1, t);
 			}
@@ -712,7 +713,7 @@ public ParseTree optimizeDynamic(Target t, Environment env,
 				Set<Class<? extends Environment.EnvironmentImpl>> envs,
 				List<ParseTree> children, FileOptions fileOptions)
 				throws ConfigCompileException, ConfigRuntimeException {
-			if(children.size() > 0 && children.get(children.size() - 1).getData().isInstanceOf(CString.TYPE)) {
+			if(children.size() > 0 && children.get(children.size() - 1).getData().isInstanceOf(CString.TYPE, null, env)) {
 				env.getEnv(CompilerEnvironment.class).addCompilerWarning(fileOptions,
 						new CompilerWarning("The string item format in " + getName() + " is deprecated.", t, null));
 			}
@@ -773,25 +774,25 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			MCPlayer p;
 			Mixed item;
 			CArray ca = null;
 			if(args.length == 1) {
-				p = environment.getEnv(CommandHelperEnvironment.class).GetPlayer();
+				p = env.getEnv(CommandHelperEnvironment.class).GetPlayer();
 				Static.AssertPlayerNonNull(p, t);
 				item = args[0];
 			} else {
-				p = Static.GetPlayer(args[0], t);
+				p = Static.GetPlayer(args[0], t, env);
 				item = args[1];
 			}
 			MCItemStack is;
 			if(item instanceof CNull) {
 				ca = null;
 				is = StaticLayer.GetItemStack("AIR", 1);
-			} else if(item.isInstanceOf(CArray.TYPE)) {
+			} else if(item.isInstanceOf(CArray.TYPE, null, env)) {
 				ca = (CArray) item;
-				is = ObjectGenerator.GetGenerator().item(ca, t);
+				is = ObjectGenerator.GetGenerator().item(ca, t, env);
 			} else {
 				is = Static.ParseItemNotation(null, item.val(), 1, t);
 			}
@@ -804,23 +805,23 @@ public Mixed exec(Target t, Environment environment, Mixed... args) throws Confi
 			CArray ret = new CArray(t);
 			for(int i = 0; i < 36; i++) {
 				if(IsMatch(ca, is, inv.getItem(i), t)) {
-					ret.push(new CInt(i, t), t);
+					ret.push(new CInt(i, t), t, env);
 				}
 			}
 			if(IsMatch(ca, is, inv.getBoots(), t)) {
-				ret.push(new CInt(100, t), t);
+				ret.push(new CInt(100, t), t, env);
 			}
 			if(IsMatch(ca, is, inv.getLeggings(), t)) {
-				ret.push(new CInt(101, t), t);
+				ret.push(new CInt(101, t), t, env);
 			}
 			if(IsMatch(ca, is, inv.getChestplate(), t)) {
-				ret.push(new CInt(102, t), t);
+				ret.push(new CInt(102, t), t, env);
 			}
 			if(IsMatch(ca, is, inv.getHelmet(), t)) {
-				ret.push(new CInt(103, t), t);
+				ret.push(new CInt(103, t), t, env);
 			}
 			if(IsMatch(ca, is, inv.getItemInOffHand(), t)) {
-				ret.push(new CInt(-106, t), t);
+				ret.push(new CInt(-106, t), t, env);
 			}
 			return ret;
 		}
@@ -835,7 +836,7 @@ public ParseTree optimizeDynamic(Target t, Environment env,
 				Set<Class<? extends Environment.EnvironmentImpl>> envs,
 				List<ParseTree> children, FileOptions fileOptions)
 				throws ConfigCompileException, ConfigRuntimeException {
-			if(children.size() > 0 && children.get(children.size() - 1).getData().isInstanceOf(CString.TYPE)) {
+			if(children.size() > 0 && children.get(children.size() - 1).getData().isInstanceOf(CString.TYPE, null, env)) {
 				env.getEnv(CompilerEnvironment.class).addCompilerWarning(fileOptions,
 						new CompilerWarning("The string item format in " + getName() + " is deprecated.", t, null));
 			}
@@ -907,7 +908,7 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			MCPlayer p;
 			MCItemStack is;
 			int itemOffset = 0;
@@ -916,11 +917,11 @@ public Mixed exec(Target t, Environment environment, Mixed... args) throws Confi
 				if(args[1] instanceof CNull) {
 					return new CInt(0, t);
 				}
-				if(args[1].isInstanceOf(CArray.TYPE)) {
+				if(args[1].isInstanceOf(CArray.TYPE, null, env)) {
 					itemOffset = 1;
 				}
 			} else if(args.length == 3) {
-				if(args[0].isInstanceOf(CString.TYPE)) { // we assume player here, apparently
+				if(args[0].isInstanceOf(CString.TYPE, null, env)) { // we assume player here, apparently
 					itemOffset = 1;
 				}
 			} else if(args.length == 4) {
@@ -928,16 +929,16 @@ public Mixed exec(Target t, Environment environment, Mixed... args) throws Confi
 			}
 
 			if(itemOffset == 0) {
-				p = environment.getEnv(CommandHelperEnvironment.class).GetPlayer();
+				p = env.getEnv(CommandHelperEnvironment.class).GetPlayer();
 				Static.AssertPlayerNonNull(p, t);
 			} else {
-				p = Static.GetPlayer(args[0], t);
+				p = Static.GetPlayer(args[0], t, env);
 			}
 
-			if(args[itemOffset].isInstanceOf(CArray.TYPE)) {
-				is = ObjectGenerator.GetGenerator().item(args[itemOffset], t);
+			if(args[itemOffset].isInstanceOf(CArray.TYPE, null, env)) {
+				is = ObjectGenerator.GetGenerator().item(args[itemOffset], t, env);
 			} else if(args.length > 1) {
-				is = Static.ParseItemNotation(null, args[itemOffset].val(), ArgumentValidation.getInt32(args[itemOffset + 1], t), t);
+				is = Static.ParseItemNotation(null, args[itemOffset].val(), ArgumentValidation.getInt32(args[itemOffset + 1], t, env), t);
 				if(args.length > itemOffset + 2) {
 					is.setItemMeta(ObjectGenerator.GetGenerator().itemMeta(args[itemOffset + 2], is.getType(), t));
 				}
@@ -971,7 +972,7 @@ public ParseTree optimizeDynamic(Target t, Environment env,
 				List<ParseTree> children, FileOptions fileOptions)
 				throws ConfigCompileException, ConfigRuntimeException {
 			if(children.size() > 2 || children.size() == 2
-					&& (children.get(1).getData().isInstanceOf(CString.TYPE) || children.get(1).getData().isInstanceOf(CInt.TYPE))) {
+					&& (children.get(1).getData().isInstanceOf(CString.TYPE, null, env) || children.get(1).getData().isInstanceOf(CInt.TYPE, null, env))) {
 				env.getEnv(CompilerEnvironment.class).addCompilerWarning(fileOptions,
 						new CompilerWarning("The string item format in " + getName() + " is deprecated.", t, null));
 			}
@@ -1022,7 +1023,7 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			MCPlayer p;
 			MCItemStack is;
 			int itemOffset = 0;
@@ -1032,7 +1033,7 @@ public Mixed exec(Target t, Environment environment, Mixed... args) throws Confi
 				if(args[1] instanceof CNull) {
 					return new CInt(0, t);
 				}
-				if(args[1].isInstanceOf(CArray.TYPE)) {
+				if(args[1].isInstanceOf(CArray.TYPE, null, env)) {
 					itemOffset = 1;
 				}
 			} else if(args.length == 3) {
@@ -1040,17 +1041,17 @@ public Mixed exec(Target t, Environment environment, Mixed... args) throws Confi
 			}
 
 			if(itemOffset == 0) {
-				p = environment.getEnv(CommandHelperEnvironment.class).GetPlayer();
+				p = env.getEnv(CommandHelperEnvironment.class).GetPlayer();
 				Static.AssertPlayerNonNull(p, t);
 			} else {
-				p = Static.GetPlayer(args[0], t);
+				p = Static.GetPlayer(args[0], t, env);
 			}
 
-			if(args[itemOffset].isInstanceOf(CArray.TYPE)) {
+			if(args[itemOffset].isInstanceOf(CArray.TYPE, null, env)) {
 				ca = (CArray) args[itemOffset];
-				is = ObjectGenerator.GetGenerator().item(ca, t);
+				is = ObjectGenerator.GetGenerator().item(ca, t, env);
 			} else {
-				is = Static.ParseItemNotation(null, args[itemOffset].val(), ArgumentValidation.getInt32(args[itemOffset + 1], t), t);
+				is = Static.ParseItemNotation(null, args[itemOffset].val(), ArgumentValidation.getInt32(args[itemOffset + 1], t, env), t);
 			}
 
 			int total = is.getAmount();
@@ -1094,7 +1095,7 @@ public ParseTree optimizeDynamic(Target t, Environment env,
 				List<ParseTree> children, FileOptions fileOptions)
 				throws ConfigCompileException, ConfigRuntimeException {
 			if(children.size() > 2 || children.size() == 2
-					&& (children.get(1).getData().isInstanceOf(CString.TYPE) || children.get(1).getData().isInstanceOf(CInt.TYPE))) {
+					&& (children.get(1).getData().isInstanceOf(CString.TYPE, null, env) || children.get(1).getData().isInstanceOf(CInt.TYPE, null, env))) {
 				env.getEnv(CompilerEnvironment.class).addCompilerWarning(fileOptions,
 						new CompilerWarning("The string item format in " + getName() + " is deprecated.", t, null));
 			}
@@ -1167,7 +1168,7 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			MCPlayer p;
 			MCItemStack is;
 			int itemOffset = 0;
@@ -1176,11 +1177,11 @@ public Mixed exec(Target t, Environment environment, Mixed... args) throws Confi
 				if(args[1] instanceof CNull) {
 					return new CInt(0, t);
 				}
-				if(args[1].isInstanceOf(CArray.TYPE)) {
+				if(args[1].isInstanceOf(CArray.TYPE, null, env)) {
 					itemOffset = 1;
 				}
 			} else if(args.length == 3) {
-				if(args[0].isInstanceOf(CString.TYPE)) { // we assume player here, apparently
+				if(args[0].isInstanceOf(CString.TYPE, null, env)) { // we assume player here, apparently
 					itemOffset = 1;
 				}
 			} else if(args.length == 4) {
@@ -1188,16 +1189,16 @@ public Mixed exec(Target t, Environment environment, Mixed... args) throws Confi
 			}
 
 			if(itemOffset == 0) {
-				p = environment.getEnv(CommandHelperEnvironment.class).GetPlayer();
+				p = env.getEnv(CommandHelperEnvironment.class).GetPlayer();
 				Static.AssertPlayerNonNull(p, t);
 			} else {
-				p = Static.GetPlayer(args[0], t);
+				p = Static.GetPlayer(args[0], t, env);
 			}
 
-			if(args[itemOffset].isInstanceOf(CArray.TYPE)) {
-				is = ObjectGenerator.GetGenerator().item(args[itemOffset], t);
+			if(args[itemOffset].isInstanceOf(CArray.TYPE, null, env)) {
+				is = ObjectGenerator.GetGenerator().item(args[itemOffset], t, env);
 			} else {
-				is = Static.ParseItemNotation(null, args[itemOffset].val(), ArgumentValidation.getInt32(args[itemOffset + 1], t), t);
+				is = Static.ParseItemNotation(null, args[itemOffset].val(), ArgumentValidation.getInt32(args[itemOffset + 1], t, env), t);
 				if(args.length > itemOffset + 2) {
 					is.setItemMeta(ObjectGenerator.GetGenerator().itemMeta(args[itemOffset + 2], is.getType(), t));
 				}
@@ -1229,7 +1230,7 @@ public ParseTree optimizeDynamic(Target t, Environment env,
 				List<ParseTree> children, FileOptions fileOptions)
 				throws ConfigCompileException, ConfigRuntimeException {
 			if(children.size() > 2 || children.size() == 2
-					&& (children.get(1).getData().isInstanceOf(CString.TYPE) || children.get(1).getData().isInstanceOf(CInt.TYPE))) {
+					&& (children.get(1).getData().isInstanceOf(CString.TYPE, null, env) || children.get(1).getData().isInstanceOf(CInt.TYPE, null, env))) {
 				env.getEnv(CompilerEnvironment.class).addCompilerWarning(fileOptions,
 						new CompilerWarning("The string item format in " + getName() + " is deprecated.", t, null));
 			}
@@ -1279,7 +1280,7 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			MCPlayer p;
 			MCItemStack is;
 			int itemOffset = 0;
@@ -1289,7 +1290,7 @@ public Mixed exec(Target t, Environment environment, Mixed... args) throws Confi
 				if(args[1] instanceof CNull) {
 					return new CInt(0, t);
 				}
-				if(args[1].isInstanceOf(CArray.TYPE)) {
+				if(args[1].isInstanceOf(CArray.TYPE, null, env)) {
 					itemOffset = 1;
 				}
 			} else if(args.length == 3) {
@@ -1297,17 +1298,17 @@ public Mixed exec(Target t, Environment environment, Mixed... args) throws Confi
 			}
 
 			if(itemOffset == 0) {
-				p = environment.getEnv(CommandHelperEnvironment.class).GetPlayer();
+				p = env.getEnv(CommandHelperEnvironment.class).GetPlayer();
 				Static.AssertPlayerNonNull(p, t);
 			} else {
-				p = Static.GetPlayer(args[0], t);
+				p = Static.GetPlayer(args[0], t, env);
 			}
 
-			if(args[itemOffset].isInstanceOf(CArray.TYPE)) {
+			if(args[itemOffset].isInstanceOf(CArray.TYPE, null, env)) {
 				ca = (CArray) args[itemOffset];
-				is = ObjectGenerator.GetGenerator().item(ca, t);
+				is = ObjectGenerator.GetGenerator().item(ca, t, env);
 			} else {
-				is = Static.ParseItemNotation(null, args[itemOffset].val(), ArgumentValidation.getInt32(args[itemOffset + 1], t), t);
+				is = Static.ParseItemNotation(null, args[itemOffset].val(), ArgumentValidation.getInt32(args[itemOffset + 1], t, env), t);
 			}
 
 			int total = is.getAmount();
@@ -1350,7 +1351,7 @@ public ParseTree optimizeDynamic(Target t, Environment env,
 				List<ParseTree> children, FileOptions fileOptions)
 				throws ConfigCompileException, ConfigRuntimeException {
 			if(children.size() > 2 || children.size() == 2
-					&& (children.get(1).getData().isInstanceOf(CString.TYPE) || children.get(1).getData().isInstanceOf(CInt.TYPE))) {
+					&& (children.get(1).getData().isInstanceOf(CString.TYPE, null, env) || children.get(1).getData().isInstanceOf(CInt.TYPE, null, env))) {
 				env.getEnv(CompilerEnvironment.class).addCompilerWarning(fileOptions,
 						new CompilerWarning("The string item format in " + getName() + " is deprecated.", t, null));
 			}
@@ -1431,7 +1432,7 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment env, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			MCCommandSender p = env.getEnv(CommandHelperEnvironment.class).GetCommandSender();
 
 			MCPlayer m = null;
@@ -1443,13 +1444,13 @@ public Mixed exec(Target t, Environment env, Mixed... args) throws ConfigRuntime
 			Mixed arg;
 
 			if(args.length == 2) {
-				m = Static.GetPlayer(args[0], t);
+				m = Static.GetPlayer(args[0], t, env);
 				arg = args[1];
 			} else {
 				arg = args[0];
 			}
 
-			if(!(arg.isInstanceOf(CArray.TYPE))) {
+			if(!(arg.isInstanceOf(CArray.TYPE, null, env))) {
 				throw new CRECastException("Expecting an array as argument " + (args.length == 1 ? "1" : "2"), t);
 			}
 
@@ -1471,7 +1472,7 @@ public Mixed exec(Target t, Environment env, Mixed... args) throws ConfigRuntime
 						}
 					}
 
-					MCItemStack is = ObjectGenerator.GetGenerator().item(array.get(index, t), t);
+					MCItemStack is = ObjectGenerator.GetGenerator().item(array.get(index, t, env), t, env);
 
 					if(index >= 0 && index <= 26) {
 						m.getEnderChest().setItem(index, is);
@@ -1532,7 +1533,7 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment env, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			MCCommandSender p = env.getEnv(CommandHelperEnvironment.class).GetCommandSender();
 
 			Integer index = -1;
@@ -1548,25 +1549,25 @@ public Mixed exec(Target t, Environment env, Mixed... args) throws ConfigRuntime
 			} else if(args.length == 1) {
 				all = true;
 
-				m = Static.GetPlayer(args[0], t);
+				m = Static.GetPlayer(args[0], t, env);
 			} else if(args.length == 2) {
 				if(args[1] instanceof CNull) {
 					throw new CRERangeException("Slot index must be 0-26", t);
 				} else {
-					index = ArgumentValidation.getInt32(args[1], t);
+					index = ArgumentValidation.getInt32(args[1], t, env);
 				}
 
 				all = false;
-				m = Static.GetPlayer(args[0], t);
+				m = Static.GetPlayer(args[0], t, env);
 			}
 
 			Static.AssertPlayerNonNull(m, t);
 
 			if(all) {
-				CArray ret = CArray.GetAssociativeArray(t);
+				CArray ret = CArray.GetAssociativeArray(t, null, env);
 
 				for(int i = 0; i < 27; i++) {
-					ret.set(i, getInvSlot(m, i, t), t);
+					ret.set(i, getInvSlot(m, i, t), t, env);
 				}
 
 				return ret;
@@ -1609,13 +1610,13 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			MCWorld w = null;
-			MCPlayer p = environment.getEnv(CommandHelperEnvironment.class).GetPlayer();
+			MCPlayer p = env.getEnv(CommandHelperEnvironment.class).GetPlayer();
 			if(p != null) {
 				w = p.getWorld();
 			}
-			MCInventory inv = GetInventoryOrNull(args[0], w, t);
+			MCInventory inv = GetInventoryOrNull(args[0], w, t, env);
 			return CBoolean.get(inv != null);
 		}
 
@@ -1664,15 +1665,15 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			MCWorld w = null;
-			MCPlayer p = environment.getEnv(CommandHelperEnvironment.class).GetPlayer();
+			MCPlayer p = env.getEnv(CommandHelperEnvironment.class).GetPlayer();
 			if(p != null) {
 				w = p.getWorld();
 			}
 
-			MCInventory inv = GetInventory(args[0], w, t);
-			int slot = ArgumentValidation.getInt32(args[1], t);
+			MCInventory inv = GetInventory(args[0], w, t, env);
+			int slot = ArgumentValidation.getInt32(args[1], t, env);
 			try {
 				MCItemStack is = inv.getItem(slot);
 				return ObjectGenerator.GetGenerator().item(is, t);
@@ -1728,16 +1729,16 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			MCWorld w = null;
-			MCPlayer p = environment.getEnv(CommandHelperEnvironment.class).GetPlayer();
+			MCPlayer p = env.getEnv(CommandHelperEnvironment.class).GetPlayer();
 			if(p != null) {
 				w = p.getWorld();
 			}
 
-			MCInventory inv = GetInventory(args[0], w, t);
-			int slot = ArgumentValidation.getInt32(args[1], t);
-			MCItemStack is = ObjectGenerator.GetGenerator().item(args[2], t);
+			MCInventory inv = GetInventory(args[0], w, t, env);
+			int slot = ArgumentValidation.getInt32(args[1], t, env);
+			MCItemStack is = ObjectGenerator.GetGenerator().item(args[2], t, env);
 			try {
 				inv.setItem(slot, is);
 				return CVoid.VOID;
@@ -1790,14 +1791,14 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			MCWorld w = null;
-			MCPlayer p = environment.getEnv(CommandHelperEnvironment.class).GetPlayer();
+			MCPlayer p = env.getEnv(CommandHelperEnvironment.class).GetPlayer();
 			if(p != null) {
 				w = p.getWorld();
 			}
 
-			MCInventory inv = GetInventory(args[0], w, t);
+			MCInventory inv = GetInventory(args[0], w, t, env);
 			return new CString(inv.getType().name(), t);
 		}
 
@@ -1848,12 +1849,12 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			MCWorld w = null;
-			if(environment.getEnv(CommandHelperEnvironment.class).GetPlayer() != null) {
-				w = environment.getEnv(CommandHelperEnvironment.class).GetPlayer().getWorld();
+			if(env.getEnv(CommandHelperEnvironment.class).GetPlayer() != null) {
+				w = env.getEnv(CommandHelperEnvironment.class).GetPlayer().getWorld();
 			}
-			MCInventory inventory = InventoryManagement.GetInventory(args[0], w, t);
+			MCInventory inventory = InventoryManagement.GetInventory(args[0], w, t, env);
 			return new CInt(inventory.getSize(), t);
 		}
 
@@ -1900,13 +1901,13 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			MCWorld w = null;
-			MCPlayer p = environment.getEnv(CommandHelperEnvironment.class).GetPlayer();
+			MCPlayer p = env.getEnv(CommandHelperEnvironment.class).GetPlayer();
 			if(p != null) {
 				w = p.getWorld();
 			}
-			MCInventory inventory = InventoryManagement.GetInventory(args[0], w, t);
+			MCInventory inventory = InventoryManagement.GetInventory(args[0], w, t, env);
 			try {
 				return new CString(inventory.getTitle(), t);
 			} catch (ClassCastException ex) {
@@ -1957,14 +1958,14 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
-			MCPlayer p1 = environment.getEnv(CommandHelperEnvironment.class).GetPlayer();
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
+			MCPlayer p1 = env.getEnv(CommandHelperEnvironment.class).GetPlayer();
 			MCPlayer p2;
 			if(args.length == 2) {
-				p1 = Static.GetPlayer(args[0], t);
-				p2 = Static.GetPlayer(args[1], t);
+				p1 = Static.GetPlayer(args[0], t, env);
+				p2 = Static.GetPlayer(args[1], t, env);
 			} else {
-				p2 = Static.GetPlayer(args[0], t);
+				p2 = Static.GetPlayer(args[0], t, env);
 			}
 			Static.AssertPlayerNonNull(p1, t);
 			p1.openInventory(p2.getInventory());
@@ -2040,15 +2041,15 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment env, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 
-			MCInventory inventory = InventoryManagement.GetInventory(args[0], null, t);
+			MCInventory inventory = InventoryManagement.GetInventory(args[0], null, t, env);
 
 			Integer size = inventory.getSize();
 			Integer index = -1;
 
 			if(args.length == 2) {
-				index = ArgumentValidation.getInt32(args[1], t);
+				index = ArgumentValidation.getInt32(args[1], t, env);
 
 				if(index < 0 || index >= size) {
 					throw new CRERangeException("Slot index must be 0-" + (size - 1), t);
@@ -2056,9 +2057,9 @@ public Mixed exec(Target t, Environment env, Mixed... args) throws ConfigRuntime
 			}
 
 			if(index == -1) {
-				CArray ret = CArray.GetAssociativeArray(t);
+				CArray ret = CArray.GetAssociativeArray(t, null, env);
 				for(int i = 0; i < size; i++) {
-					ret.set(i, ObjectGenerator.GetGenerator().item(inventory.getItem(i), t), t);
+					ret.set(i, ObjectGenerator.GetGenerator().item(inventory.getItem(i), t), t, env);
 				}
 
 				return ret;
@@ -2120,12 +2121,12 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment env, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 
-			MCInventory inventory = InventoryManagement.GetInventory(args[0], null, t);
+			MCInventory inventory = InventoryManagement.GetInventory(args[0], null, t, env);
 			Integer size = inventory.getSize();
 
-			if(!(args[1].isInstanceOf(CArray.TYPE))) {
+			if(!(args[1].isInstanceOf(CArray.TYPE, null, env))) {
 				throw new CRECastException("Expecting an array as argument 2", t);
 			}
 
@@ -2137,7 +2138,7 @@ public Mixed exec(Target t, Environment env, Mixed... args) throws ConfigRuntime
 					if(index < 0 || index >= size) {
 						ConfigRuntimeException.DoWarning("Out of range value (" + index + ") found in array passed to set_inventory(), so ignoring.");
 					} else {
-						MCItemStack is = ObjectGenerator.GetGenerator().item(array.get(index, t), t);
+						MCItemStack is = ObjectGenerator.GetGenerator().item(array.get(index, t, env), t, env);
 						inventory.setItem(index, is);
 					}
 				} catch (NumberFormatException e) {
@@ -2211,13 +2212,13 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
-			MCInventory inventory = InventoryManagement.GetInventory(args[0], null, t);
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
+			MCInventory inventory = InventoryManagement.GetInventory(args[0], null, t, env);
 			MCItemStack is;
 			if(args.length == 2) {
-				is = ObjectGenerator.GetGenerator().item(args[1], t);
+				is = ObjectGenerator.GetGenerator().item(args[1], t, env);
 			} else {
-				is = Static.ParseItemNotation(this.getName(), args[1].val(), ArgumentValidation.getInt32(args[2], t), t);
+				is = Static.ParseItemNotation(this.getName(), args[1].val(), ArgumentValidation.getInt32(args[2], t, env), t);
 				if(args.length == 4) {
 					is.setItemMeta(ObjectGenerator.GetGenerator().itemMeta(args[3], is.getType(), t));
 				}
@@ -2299,17 +2300,17 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
-			MCInventory inventory = InventoryManagement.GetInventory(args[0], null, t);
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
+			MCInventory inventory = InventoryManagement.GetInventory(args[0], null, t, env);
 			Integer size = inventory.getSize();
 			CArray ca = null;
 
 			MCItemStack is;
 			if(args.length == 2) {
 				ca = (CArray) args[1];
-				is = ObjectGenerator.GetGenerator().item(ca, t);
+				is = ObjectGenerator.GetGenerator().item(ca, t, env);
 			} else {
-				is = Static.ParseItemNotation(this.getName(), args[1].val(), ArgumentValidation.getInt32(args[2], t), t);
+				is = Static.ParseItemNotation(this.getName(), args[1].val(), ArgumentValidation.getInt32(args[2], t, env), t);
 			}
 
 			int total = is.getAmount();
@@ -2411,11 +2412,11 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			MCPlayer player;
 			switch(args.length) {
 				case 1: {
-					MCCommandSender sender = environment.getEnv(CommandHelperEnvironment.class).GetCommandSender();
+					MCCommandSender sender = env.getEnv(CommandHelperEnvironment.class).GetCommandSender();
 					if(sender instanceof MCPlayer) {
 						player = (MCPlayer) sender;
 					} else {
@@ -2424,7 +2425,7 @@ public Mixed exec(Target t, Environment environment, Mixed... args) throws Confi
 					break;
 				}
 				case 2: {
-					player = Static.GetPlayer(args[0], t);
+					player = Static.GetPlayer(args[0], t, env);
 					break;
 				}
 				default: {
@@ -2493,11 +2494,11 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			MCPlayer player;
 			switch(args.length) {
 				case 0: {
-					MCCommandSender sender = environment.getEnv(CommandHelperEnvironment.class).GetCommandSender();
+					MCCommandSender sender = env.getEnv(CommandHelperEnvironment.class).GetCommandSender();
 					if(sender instanceof MCPlayer) {
 						player = (MCPlayer) sender;
 					} else {
@@ -2506,7 +2507,7 @@ public Mixed exec(Target t, Environment environment, Mixed... args) throws Confi
 					break;
 				}
 				case 1: {
-					player = Static.GetPlayer(args[0], t);
+					player = Static.GetPlayer(args[0], t, env);
 					break;
 				}
 				default: {
@@ -2549,16 +2550,16 @@ public Integer[] numArgs() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment env, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			MCPlayer p;
 			MCInventory inv;
 			if(args.length == 2) {
-				p = Static.GetPlayer(args[0], t);
-				inv = GetInventory(args[1], p.getWorld(), t);
+				p = Static.GetPlayer(args[0], t, env);
+				inv = GetInventory(args[1], p.getWorld(), t, env);
 			} else {
 				p = env.getEnv(CommandHelperEnvironment.class).GetPlayer();
 				Static.AssertPlayerNonNull(p, t);
-				inv = GetInventory(args[0], p.getWorld(), t);
+				inv = GetInventory(args[0], p.getWorld(), t, env);
 			}
 			p.openInventory(inv);
 			return CVoid.VOID;
@@ -2609,10 +2610,10 @@ public String docs() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment env, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			MCPlayer p;
 			if(args.length == 1) {
-				p = Static.GetPlayer(args[0], t);
+				p = Static.GetPlayer(args[0], t, env);
 			} else {
 				p = env.getEnv(CommandHelperEnvironment.class).GetPlayer();
 				Static.AssertPlayerNonNull(p, t);
@@ -2622,7 +2623,7 @@ public Mixed exec(Target t, Environment env, Mixed... args) throws ConfigRuntime
 				// probably tests
 				return CNull.NULL;
 			}
-			return GetInventoryHolder(view.getTopInventory(), t);
+			return GetInventoryHolder(view.getTopInventory(), t, env);
 		}
 
 		@Override
@@ -2667,11 +2668,11 @@ public String docs() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment env, Mixed... args) throws ConfigRuntimeException {
-			MCInventory inv = GetInventory(args[0], null, t);
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
+			MCInventory inv = GetInventory(args[0], null, t, env);
 			CArray list = new CArray(t);
 			for(MCHumanEntity viewer : inv.getViewers()) {
-				list.push(new CString(viewer.getName(), t), t);
+				list.push(new CString(viewer.getName(), t), t, env);
 			}
 			return list;
 		}
@@ -2717,10 +2718,10 @@ public String docs() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment env, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			CArray list = new CArray(t);
 			for(String id : VIRTUAL_INVENTORIES.keySet()) {
-				list.push(new CString(id, t), t);
+				list.push(new CString(id, t), t, env);
 			}
 			return list;
 		}
@@ -2780,7 +2781,7 @@ public String docs() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment env, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			String id = args[0].val();
 			if(VIRTUAL_INVENTORIES.get(id) != null) {
 				throw new CREIllegalArgumentException("An inventory using the id \"" + id + "\" already exists.", t);
@@ -2790,8 +2791,8 @@ public Mixed exec(Target t, Environment env, Mixed... args) throws ConfigRuntime
 			int size = 54;
 			String title = null;
 			if(args.length > 1) {
-				if(args[1].isInstanceOf(CNumber.TYPE)) {
-					size = ArgumentValidation.getInt32(args[1], t);
+				if(args[1].isInstanceOf(CNumber.TYPE, null, env)) {
+					size = ArgumentValidation.getInt32(args[1], t, env);
 					if(size < 9) {
 						size = 9; // minimum
 					} else {
@@ -2824,7 +2825,7 @@ public Mixed exec(Target t, Environment env, Mixed... args) throws ConfigRuntime
 			}
 
 			if(args.length == 4) {
-				if(!(args[3].isInstanceOf(CArray.TYPE))) {
+				if(!(args[3].isInstanceOf(CArray.TYPE, null, env))) {
 					throw new CRECastException("Inventory argument not an array in " + getName(), t);
 				}
 				CArray array = (CArray) args[3];
@@ -2835,7 +2836,7 @@ public Mixed exec(Target t, Environment env, Mixed... args) throws ConfigRuntime
 							ConfigRuntimeException.DoWarning("Out of range value (" + index + ") found in array passed to "
 									+ getName() + "(), so ignoring.");
 						} else {
-							MCItemStack is = ObjectGenerator.GetGenerator().item(array.get(index, t), t);
+							MCItemStack is = ObjectGenerator.GetGenerator().item(array.get(index, t, env), t, env);
 							inv.setItem(index, is);
 						}
 					} catch (NumberFormatException e) {
@@ -2891,7 +2892,7 @@ public String docs() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment env, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			String id = args[0].val();
 			MCInventory inv = VIRTUAL_INVENTORIES.get(id);
 			if(inv != null) {
@@ -2933,10 +2934,10 @@ public MSVersion since() {
 	 * @param t
 	 * @return
 	 */
-	static MCInventory GetInventory(Mixed specifier, MCWorld w, Target t) {
-		MCInventory inv = GetInventoryOrNull(specifier, w, t);
+	static MCInventory GetInventory(Mixed specifier, MCWorld w, Target t, Environment env) {
+		MCInventory inv = GetInventoryOrNull(specifier, w, t, env);
 		if(inv == null) {
-			if(specifier.isInstanceOf(CArray.TYPE)) {
+			if(specifier.isInstanceOf(CArray.TYPE, null, env)) {
 				throw new CREIllegalArgumentException("The location specified is not capable of having an inventory.", t);
 			}
 			throw new CREIllegalArgumentException("An inventory for \"" + specifier.val() + "\" does not exist.", t);
@@ -2944,9 +2945,9 @@ static MCInventory GetInventory(Mixed specifier, MCWorld w, Target t) {
 		return inv;
 	}
 
-	private static MCInventory GetInventoryOrNull(Mixed specifier, MCWorld w, Target t) {
-		if(specifier.isInstanceOf(CArray.TYPE)) {
-			MCLocation l = ObjectGenerator.GetGenerator().location(specifier, w, t);
+	private static MCInventory GetInventoryOrNull(Mixed specifier, MCWorld w, Target t, Environment env) {
+		if(specifier.isInstanceOf(CArray.TYPE, null, env)) {
+			MCLocation l = ObjectGenerator.GetGenerator().location(specifier, w, t, env);
 			return StaticLayer.GetConvertor().GetLocationInventory(l);
 		}
 		if(specifier.val().length() == 36 || specifier.val().length() == 32) {
@@ -2967,7 +2968,7 @@ private static MCInventory GetInventoryOrNull(Mixed specifier, MCWorld w, Target
 	 * @param t
 	 * @return The construct representation of the inventory holder
 	 */
-	public static Mixed GetInventoryHolder(MCInventory inv, Target t) {
+	public static Mixed GetInventoryHolder(MCInventory inv, Target t, Environment env) {
 		MCInventoryHolder h = inv.getHolder();
 		if(h instanceof MCEntity) {
 			return new CString(((MCEntity) h).getUniqueId().toString(), t);
diff --git a/src/main/java/com/laytonsmith/core/functions/ItemMeta.java b/src/main/java/com/laytonsmith/core/functions/ItemMeta.java
index ede6f1c841..0f6e31afe4 100644
--- a/src/main/java/com/laytonsmith/core/functions/ItemMeta.java
+++ b/src/main/java/com/laytonsmith/core/functions/ItemMeta.java
@@ -35,6 +35,7 @@
 import com.laytonsmith.core.constructs.CNull;
 import com.laytonsmith.core.constructs.CVoid;
 import com.laytonsmith.core.constructs.Target;
+import com.laytonsmith.core.constructs.generics.GenericParameters;
 import com.laytonsmith.core.environments.CommandHelperEnvironment;
 import com.laytonsmith.core.environments.Environment;
 import com.laytonsmith.core.exceptions.CRE.CRECastException;
@@ -78,19 +79,19 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			MCPlayer p;
 			MCItemStack is;
 			Mixed slot;
 			if(args.length == 2) {
-				p = Static.GetPlayer(args[0], t);
+				p = Static.GetPlayer(args[0], t, env);
 				slot = args[1];
 			} else {
-				p = environment.getEnv(CommandHelperEnvironment.class).GetPlayer();
+				p = env.getEnv(CommandHelperEnvironment.class).GetPlayer();
 				Static.AssertPlayerNonNull(p, t);
 				slot = args[0];
 			}
-			is = p.getItemAt(slot instanceof CNull ? null : ArgumentValidation.getInt32(slot, t));
+			is = p.getItemAt(slot instanceof CNull ? null : ArgumentValidation.getInt32(slot, t, env));
 			return ObjectGenerator.GetGenerator().itemMeta(is, t);
 		}
 
@@ -182,26 +183,26 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			MCPlayer p;
 			Mixed slot;
 			Mixed meta;
 			MCItemStack is;
 			if(args.length == 3) {
-				p = Static.GetPlayer(args[0], t);
+				p = Static.GetPlayer(args[0], t, env);
 				slot = args[1];
 				meta = args[2];
 			} else {
-				p = environment.getEnv(CommandHelperEnvironment.class).GetPlayer();
+				p = env.getEnv(CommandHelperEnvironment.class).GetPlayer();
 				Static.AssertPlayerNonNull(p, t);
 				slot = args[0];
 				meta = args[1];
 			}
-			is = p.getItemAt(slot instanceof CNull ? null : ArgumentValidation.getInt32(slot, t));
+			is = p.getItemAt(slot instanceof CNull ? null : ArgumentValidation.getInt32(slot, t, env));
 			if(is == null) {
 				throw new CRECastException("There is no item at slot " + slot, t);
 			}
-			is.setItemMeta(ObjectGenerator.GetGenerator().itemMeta(meta, is.getType(), t));
+			is.setItemMeta(ObjectGenerator.GetGenerator().itemMeta(meta, is.getType(), t, env));
 			return CVoid.VOID;
 		}
 
@@ -290,14 +291,14 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
-			MCPlayer p = environment.getEnv(CommandHelperEnvironment.class).GetPlayer();
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
+			MCPlayer p = env.getEnv(CommandHelperEnvironment.class).GetPlayer();
 			int slot;
 			if(args.length == 2) {
-				p = Static.GetPlayer(args[0], t);
-				slot = ArgumentValidation.getInt32(args[1], t);
+				p = Static.GetPlayer(args[0], t, env);
+				slot = ArgumentValidation.getInt32(args[1], t, env);
 			} else {
-				slot = ArgumentValidation.getInt32(args[0], t);
+				slot = ArgumentValidation.getInt32(args[0], t, env);
 			}
 			Static.AssertPlayerNonNull(p, t);
 			MCItemStack is = p.getItemAt(slot);
@@ -355,21 +356,21 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
-			MCPlayer p = environment.getEnv(CommandHelperEnvironment.class).GetPlayer();
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
+			MCPlayer p = env.getEnv(CommandHelperEnvironment.class).GetPlayer();
 			int slot;
 			CArray color;
 			if(args.length == 3) {
-				p = Static.GetPlayer(args[0], t);
-				slot = ArgumentValidation.getInt32(args[1], t);
-				if(args[2].isInstanceOf(CArray.TYPE)) {
+				p = Static.GetPlayer(args[0], t, env);
+				slot = ArgumentValidation.getInt32(args[1], t, env);
+				if(args[2].isInstanceOf(CArray.TYPE, null, env)) {
 					color = (CArray) args[2];
 				} else {
 					throw new CREFormatException("Expected an array but received " + args[2] + " instead.", t);
 				}
 			} else {
-				slot = ArgumentValidation.getInt32(args[0], t);
-				if(args[1].isInstanceOf(CArray.TYPE)) {
+				slot = ArgumentValidation.getInt32(args[0], t, env);
+				if(args[1].isInstanceOf(CArray.TYPE, null, env)) {
 					color = (CArray) args[1];
 				} else {
 					throw new CREFormatException("Expected an array but received " + args[1] + " instead.", t);
@@ -434,18 +435,18 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			MCPlayer p;
 			Mixed slot;
 			if(args.length == 2) {
-				p = Static.GetPlayer(args[0], t);
+				p = Static.GetPlayer(args[0], t, env);
 				slot = args[1];
 			} else {
-				p = environment.getEnv(CommandHelperEnvironment.class).GetPlayer();
+				p = env.getEnv(CommandHelperEnvironment.class).GetPlayer();
 				Static.AssertPlayerNonNull(p, t);
 				slot = args[0];
 			}
-			MCItemStack is = p.getItemAt(slot instanceof CNull ? null : ArgumentValidation.getInt32(slot, t));
+			MCItemStack is = p.getItemAt(slot instanceof CNull ? null : ArgumentValidation.getInt32(slot, t, env));
 			if(is == null) {
 				return CBoolean.FALSE;
 			}
diff --git a/src/main/java/com/laytonsmith/core/functions/Marquee.java b/src/main/java/com/laytonsmith/core/functions/Marquee.java
index 423785a599..7a41ffbeef 100644
--- a/src/main/java/com/laytonsmith/core/functions/Marquee.java
+++ b/src/main/java/com/laytonsmith/core/functions/Marquee.java
@@ -8,6 +8,7 @@
 import com.laytonsmith.core.constructs.CString;
 import com.laytonsmith.core.constructs.CVoid;
 import com.laytonsmith.core.constructs.Target;
+import com.laytonsmith.core.constructs.generics.GenericParameters;
 import com.laytonsmith.core.environments.Environment;
 import com.laytonsmith.core.exceptions.CRE.CRECastException;
 import com.laytonsmith.core.exceptions.CRE.CREThrowable;
@@ -52,7 +53,7 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(final Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(final Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			final String marqueeName;
 			final String text;
 			final int stringWidth;
@@ -68,7 +69,7 @@ public Mixed exec(final Target t, Environment environment, Mixed... args) throws
 			text = args[1 + offset].val();
 			stringWidth = ArgumentValidation.getInt32(args[2 + offset], t);
 			delayTime = ArgumentValidation.getInt32(args[3 + offset], t);
-			if(args[4 + offset].isInstanceOf(CClosure.TYPE)) {
+			if(args[4 + offset].isInstanceOf(CClosure.TYPE, null, env)) {
 				callback = ((CClosure) args[4 + offset]);
 			} else {
 				throw new CRECastException("Expected argument " + (4 + offset + 1) + " to be a closure, but was not.", t);
@@ -158,7 +159,7 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			String marqueeName = args[0].val();
 			if(MARQUEE_MAP.containsKey(marqueeName)) {
 				MARQUEE_MAP.get(marqueeName).stop();
diff --git a/src/main/java/com/laytonsmith/core/functions/Math.java b/src/main/java/com/laytonsmith/core/functions/Math.java
index d3868ed4ab..0d94e0a888 100644
--- a/src/main/java/com/laytonsmith/core/functions/Math.java
+++ b/src/main/java/com/laytonsmith/core/functions/Math.java
@@ -10,17 +10,21 @@
 import com.laytonsmith.annotations.core;
 import com.laytonsmith.annotations.seealso;
 import com.laytonsmith.core.ArgumentValidation;
+import com.laytonsmith.core.FlowFunction;
 import com.laytonsmith.core.MSVersion;
 import com.laytonsmith.core.Optimizable;
 import com.laytonsmith.core.ParseTree;
-import com.laytonsmith.core.Script;
 import com.laytonsmith.core.SimpleDocumentation;
 import com.laytonsmith.core.Static;
+import com.laytonsmith.core.StepAction.Complete;
+import com.laytonsmith.core.StepAction.Evaluate;
+import com.laytonsmith.core.StepAction.StepResult;
 import com.laytonsmith.core.compiler.FileOptions;
 import com.laytonsmith.core.compiler.OptimizationUtilities;
 import com.laytonsmith.core.constructs.CArray;
 import com.laytonsmith.core.constructs.CClassType;
 import com.laytonsmith.core.constructs.CDouble;
+import com.laytonsmith.core.constructs.generics.GenericParameters;
 import com.laytonsmith.core.constructs.CFunction;
 import com.laytonsmith.core.constructs.CInt;
 import com.laytonsmith.core.constructs.CMutablePrimitive;
@@ -77,17 +81,17 @@ public Integer[] numArgs() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment env, Mixed... args) throws CancelCommandException, ConfigRuntimeException {
-			if(ArgumentValidation.anyDoubles(args)) {
-				double tally = ArgumentValidation.getNumber(args[0], t);
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws CancelCommandException, ConfigRuntimeException {
+			if(ArgumentValidation.anyDoubles(env, args)) {
+				double tally = ArgumentValidation.getNumber(args[0], t, env);
 				for(int i = 1; i < args.length; i++) {
-					tally += ArgumentValidation.getNumber(args[i], t);
+					tally += ArgumentValidation.getNumber(args[i], t, env);
 				}
 				return new CDouble(tally, t);
 			} else {
-				long tally = ArgumentValidation.getInt(args[0], t);
+				long tally = ArgumentValidation.getInt(args[0], t, env);
 				for(int i = 1; i < args.length; i++) {
-					tally += ArgumentValidation.getInt(args[i], t);
+					tally += ArgumentValidation.getInt(args[i], t, env);
 				}
 				return new CInt(tally, t);
 			}
@@ -165,17 +169,17 @@ public Integer[] numArgs() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment env, Mixed... args) throws CancelCommandException, ConfigRuntimeException {
-			if(ArgumentValidation.anyDoubles(args)) {
-				double tally = ArgumentValidation.getNumber(args[0], t);
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws CancelCommandException, ConfigRuntimeException {
+			if(ArgumentValidation.anyDoubles(env, args)) {
+				double tally = ArgumentValidation.getNumber(args[0], t, env);
 				for(int i = 1; i < args.length; i++) {
-					tally -= ArgumentValidation.getNumber(args[i], t);
+					tally -= ArgumentValidation.getNumber(args[i], t, env);
 				}
 				return new CDouble(tally, t);
 			} else {
-				long tally = ArgumentValidation.getInt(args[0], t);
+				long tally = ArgumentValidation.getInt(args[0], t, env);
 				for(int i = 1; i < args.length; i++) {
-					tally -= ArgumentValidation.getInt(args[i], t);
+					tally -= ArgumentValidation.getInt(args[i], t, env);
 				}
 				return new CInt(tally, t);
 			}
@@ -241,17 +245,17 @@ public Integer[] numArgs() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment env, Mixed... args) throws CancelCommandException, ConfigRuntimeException {
-			if(ArgumentValidation.anyDoubles(args)) {
-				double tally = ArgumentValidation.getNumber(args[0], t);
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws CancelCommandException, ConfigRuntimeException {
+			if(ArgumentValidation.anyDoubles(env, args)) {
+				double tally = ArgumentValidation.getNumber(args[0], t, env);
 				for(int i = 1; i < args.length; i++) {
-					tally *= ArgumentValidation.getNumber(args[i], t);
+					tally *= ArgumentValidation.getNumber(args[i], t, env);
 				}
 				return new CDouble(tally, t);
 			} else {
-				long tally = ArgumentValidation.getInt(args[0], t);
+				long tally = ArgumentValidation.getInt(args[0], t, env);
 				for(int i = 1; i < args.length; i++) {
-					tally *= ArgumentValidation.getInt(args[i], t);
+					tally *= ArgumentValidation.getInt(args[i], t, env);
 				}
 				return new CInt(tally, t);
 			}
@@ -327,10 +331,10 @@ public Integer[] numArgs() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment env, Mixed... args) throws CancelCommandException, ConfigRuntimeException {
-			double tally = ArgumentValidation.getNumber(args[0], t);
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws CancelCommandException, ConfigRuntimeException {
+			double tally = ArgumentValidation.getNumber(args[0], t, env);
 			for(int i = 1; i < args.length; i++) {
-				double next = ArgumentValidation.getNumber(args[i], t);
+				double next = ArgumentValidation.getNumber(args[i], t, env);
 				if(next == 0) {
 					throw new CRERangeException("Division by 0!", t);
 				}
@@ -403,9 +407,9 @@ public Integer[] numArgs() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment env, Mixed... args) throws CancelCommandException, ConfigRuntimeException {
-			long arg1 = ArgumentValidation.getInt(args[0], t);
-			long arg2 = ArgumentValidation.getInt(args[1], t);
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws CancelCommandException, ConfigRuntimeException {
+			long arg1 = ArgumentValidation.getInt(args[0], t, env);
+			long arg2 = ArgumentValidation.getInt(args[1], t, env);
 			if(arg2 == 0) {
 				throw new CRERangeException("Modulo by 0!", t);
 			}
@@ -468,9 +472,9 @@ public Integer[] numArgs() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment env, Mixed... args) throws CancelCommandException, ConfigRuntimeException {
-			double arg1 = ArgumentValidation.getNumber(args[0], t);
-			double arg2 = ArgumentValidation.getNumber(args[1], t);
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws CancelCommandException, ConfigRuntimeException {
+			double arg1 = ArgumentValidation.getNumber(args[0], t, env);
+			double arg2 = ArgumentValidation.getNumber(args[1], t, env);
 			return new CDouble(java.lang.Math.pow(arg1, arg2), t);
 		}
 
@@ -516,93 +520,145 @@ public Set<OptimizationOption> optimizationOptions() {
 	}
 
 	/**
-	 * If we have the case {@code @array[0]++}, we have to increment it as though it were a variable, so we have to do
-	 * that with execs. This method consolidates the code to do so.
-	 *
-	 * @return
+	 * Shared state for the inc/dec/postinc/postdec FlowFunction implementations.
 	 */
-	protected static Mixed doIncrementDecrement(ParseTree[] nodes,
-			Script parent, Environment env, Target t,
-			Function func, boolean pre, boolean inc) {
-		if(nodes[0].getData() instanceof CFunction && ((CFunction) nodes[0].getData()).hasFunction()) {
+	static class IncDecState {
+		enum Phase { EVAL_ARRAY, EVAL_INDEX, EVAL_DELTA, EVAL_ARG0, EVAL_ARG1 }
+		Phase phase;
+		ParseTree[] nodes;
+		boolean pre;
+		boolean inc;
+		Function func;
+		boolean arrayMode;
+		// Array path fields
+		Mixed array;
+		Mixed index;
+		// Variable path fields
+		Mixed[] args;
+		int argCount;
+
+		@Override
+		public String toString() {
+			return phase.name() + (arrayMode ? " (array)" : " (var)")
+					+ (pre ? " pre" : " post") + (inc ? "inc" : "dec");
+		}
+	}
+
+	private static StepResult<IncDecState> incDecBegin(Target t, ParseTree[] children,
+			Environment env, Function func, boolean pre, boolean inc) {
+		IncDecState state = new IncDecState();
+		state.nodes = children;
+		state.pre = pre;
+		state.inc = inc;
+		state.func = func;
+
+		if(children[0].getData() instanceof CFunction && ((CFunction) children[0].getData()).hasFunction()) {
 			Function f;
 			try {
-				f = ((CFunction) nodes[0].getData()).getFunction();
-			} catch (ConfigCompileException ex) {
-				// This can't really happen, as the compiler would have already caught this
+				f = ((CFunction) children[0].getData()).getFunction();
+			} catch(ConfigCompileException ex) {
 				throw new Error(ex);
 			}
-			if(f.getName().equals(new ArrayHandling.array_get().getName())) {
-				//Ok, so, this is it, we're in charge here.
-				//First, pull out the current value. We're gonna do this manually though, and we will actually
-				//skip the whole array_get execution.
-				ParseTree eval = nodes[0];
-				Mixed array = parent.seval(eval.getChildAt(0), env);
-				Mixed index = parent.seval(eval.getChildAt(1), env);
-				Mixed cdelta = new CInt(1, t);
-				if(nodes.length == 2) {
-					cdelta = parent.seval(nodes[1], env);
-				}
-				long delta = ArgumentValidation.getInt(cdelta, t);
-				//First, error check, then get the old value, and store it in temp.
-				if(!(array.isInstanceOf(CArray.TYPE)) && !(array.isInstanceOf(ArrayAccess.TYPE))) {
-					//Let's just evaluate this like normal with array_get, so it will
-					//throw the appropriate exception.
-					new ArrayHandling.array_get().exec(t, env, array, index);
-					throw ConfigRuntimeException.CreateUncatchableException("Shouldn't have gotten here. Please report this error, and how you got here.", t);
-				} else if(!(array.isInstanceOf(CArray.TYPE))) {
-					//It's an ArrayAccess type, but we can't use that here, so, throw our
-					//own exception.
-					throw new CRECastException("Cannot increment/decrement a non-array array"
-							+ " accessed value. (The value passed in was \"" + array.val() + "\")", t);
-				}
-				//Ok, we're good. Data types should all be correct.
-				CArray myArray = ((CArray) array);
-				Mixed value = myArray.get(index, t);
-
-				//Alright, now let's actually perform the increment, and store that in the array.
-				if(value.isInstanceOf(CInt.TYPE)) {
-					CInt newVal;
-					if(inc) {
-						newVal = new CInt(ArgumentValidation.getInt(value, t) + delta, t);
-					} else {
-						newVal = new CInt(ArgumentValidation.getInt(value, t) - delta, t);
-					}
-					new ArrayHandling.array_set().exec(t, env, array, index, newVal);
-					if(pre) {
-						return newVal;
-					} else {
-						return value;
-					}
-				} else if(value.isInstanceOf(CDouble.TYPE)) {
-					CDouble newVal;
-					if(inc) {
-						newVal = new CDouble(ArgumentValidation.getDouble(value, t) + delta, t);
-					} else {
-						newVal = new CDouble(ArgumentValidation.getDouble(value, t) - delta, t);
+			if(f.getName().equals(ArrayHandling.array_get.NAME)) {
+				state.arrayMode = true;
+				state.phase = IncDecState.Phase.EVAL_ARRAY;
+				return new StepResult<>(new Evaluate(children[0].getChildAt(0)), state);
+			}
+		}
+
+		// Variable path — evaluate args with keepIVariable=true
+		state.arrayMode = false;
+		state.argCount = children.length;
+		state.args = new Mixed[state.argCount];
+		state.phase = IncDecState.Phase.EVAL_ARG0;
+		return new StepResult<>(new Evaluate(children[0], null, true), state);
+	}
+
+	private static StepResult<IncDecState> incDecChildCompleted(Target t, IncDecState state,
+			Mixed result, Environment env) {
+		if(state.arrayMode) {
+			switch(state.phase) {
+				case EVAL_ARRAY:
+					state.array = result;
+					state.phase = IncDecState.Phase.EVAL_INDEX;
+					return new StepResult<>(new Evaluate(state.nodes[0].getChildAt(1)), state);
+				case EVAL_INDEX:
+					state.index = result;
+					if(state.nodes.length == 2) {
+						state.phase = IncDecState.Phase.EVAL_DELTA;
+						return new StepResult<>(new Evaluate(state.nodes[1]), state);
 					}
-					new ArrayHandling.array_set().exec(t, env, array, index, newVal);
-					if(pre) {
-						return newVal;
-					} else {
-						return value;
+					return new StepResult<>(new Complete(
+							performArrayIncDec(t, state, new CInt(1, t), env)), state);
+				case EVAL_DELTA:
+					return new StepResult<>(new Complete(
+							performArrayIncDec(t, state, result, env)), state);
+				default:
+					throw ConfigRuntimeException.CreateUncatchableException(
+							"Invalid inc/dec state: " + state.phase, t);
+			}
+		} else {
+			// Variable path
+			switch(state.phase) {
+				case EVAL_ARG0:
+					state.args[0] = result;
+					if(state.argCount > 1) {
+						state.phase = IncDecState.Phase.EVAL_ARG1;
+						return new StepResult<>(new Evaluate(state.nodes[1], null, true), state);
 					}
-				} else {
-					throw new CRECastException("Cannot increment/decrement a non numeric value.", t);
-				}
+					return new StepResult<>(new Complete(
+							state.func.exec(t, env, null, state.args)), state);
+				case EVAL_ARG1:
+					state.args[1] = result;
+					return new StepResult<>(new Complete(
+							state.func.exec(t, env, null, state.args)), state);
+				default:
+					throw ConfigRuntimeException.CreateUncatchableException(
+							"Invalid inc/dec state: " + state.phase, t);
 			}
 		}
-		Mixed[] args = new Mixed[nodes.length];
-		for(int i = 0; i < args.length; i++) {
-			args[i] = parent.eval(nodes[i], env);
+	}
+
+	private static Mixed performArrayIncDec(Target t, IncDecState state, Mixed cdelta, Environment env) {
+		long delta = ArgumentValidation.getInt(cdelta, t, env);
+		if(!(state.array.isInstanceOf(CArray.TYPE, null, env))
+				&& !(state.array.isInstanceOf(ArrayAccess.TYPE, null, env))) {
+			new ArrayHandling.array_get().exec(t, env, null, state.array, state.index);
+			throw ConfigRuntimeException.CreateUncatchableException(
+					"Shouldn't have gotten here. Please report this error, and how you got here.", t);
+		} else if(!(state.array.isInstanceOf(CArray.TYPE, null, env))) {
+			throw new CRECastException("Cannot increment/decrement a non-array array"
+					+ " accessed value. (The value passed in was \"" + state.array.val() + "\")", t);
+		}
+		CArray myArray = ((CArray) state.array);
+		Mixed value = myArray.get(state.index, t, env);
+		if(value.isInstanceOf(CInt.TYPE, null, env)) {
+			CInt newVal;
+			if(state.inc) {
+				newVal = new CInt(ArgumentValidation.getInt(value, t, env) + delta, t);
+			} else {
+				newVal = new CInt(ArgumentValidation.getInt(value, t, env) - delta, t);
+			}
+			new ArrayHandling.array_set().exec(t, env, null, state.array, state.index, newVal);
+			return state.pre ? newVal : value;
+		} else if(value.isInstanceOf(CDouble.TYPE, null, env)) {
+			CDouble newVal;
+			if(state.inc) {
+				newVal = new CDouble(ArgumentValidation.getDouble(value, t, env) + delta, t);
+			} else {
+				newVal = new CDouble(ArgumentValidation.getDouble(value, t, env) - delta, t);
+			}
+			new ArrayHandling.array_set().exec(t, env, null, state.array, state.index, newVal);
+			return state.pre ? newVal : value;
+		} else {
+			throw new CRECastException("Cannot increment/decrement a non numeric value.", t);
 		}
-		return func.exec(t, env, args);
 	}
 
 	@api
 	@seealso({dec.class, postdec.class, postinc.class})
 	@OperatorPreferred("++")
-	public static class inc extends AbstractFunction implements Optimizable {
+	public static class inc extends AbstractFunction implements Optimizable, FlowFunction<IncDecState> {
 
 		public static final String NAME = "inc";
 
@@ -617,17 +673,18 @@ public Integer[] numArgs() {
 		}
 
 		@Override
-		public boolean useSpecialExec() {
-			return true;
+		public StepResult<IncDecState> begin(Target t, ParseTree[] children, Environment env) {
+			return incDecBegin(t, children, env, this, true, true);
 		}
 
 		@Override
-		public Mixed execs(Target t, Environment env, Script parent, ParseTree... nodes) {
-			return doIncrementDecrement(nodes, parent, env, t, this, true, true);
+		public StepResult<IncDecState> childCompleted(Target t, IncDecState state,
+				Mixed result, Environment env) {
+			return incDecChildCompleted(t, state, result, env);
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment env, Mixed... args) throws CancelCommandException, ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws CancelCommandException, ConfigRuntimeException {
 			long value = 1;
 			if(args.length == 2) {
 				if(args[1] instanceof IVariable) {
@@ -635,16 +692,16 @@ public Mixed exec(Target t, Environment env, Mixed... args) throws CancelCommand
 					args[1] = env.getEnv(GlobalEnv.class).GetVarList().get(cur2.getVariableName(), cur2.getTarget(),
 							env);
 				}
-				value = ArgumentValidation.getInt(args[1], t);
+				value = ArgumentValidation.getInt(args[1], t, env);
 			}
 			if(args[0] instanceof IVariable) {
 				IVariable cur = (IVariable) args[0];
 				IVariable v = env.getEnv(GlobalEnv.class).GetVarList().get(cur.getVariableName(), cur.getTarget(), env);
 				Mixed newVal;
-				if(ArgumentValidation.anyDoubles(v.ival())) {
-					newVal = new CDouble(ArgumentValidation.getDouble(v.ival(), t) + value, t);
+				if(ArgumentValidation.anyDoubles(env, v.ival())) {
+					newVal = new CDouble(ArgumentValidation.getDouble(v.ival(), t, env) + value, t);
 				} else {
-					newVal = new CInt(ArgumentValidation.getInt(v.ival(), t) + value, t);
+					newVal = new CInt(ArgumentValidation.getInt(v.ival(), t, env) + value, t);
 				}
 				if(v.ival() instanceof CMutablePrimitive) {
 					newVal = ((CMutablePrimitive) v.ival()).setAndReturn(newVal, t);
@@ -652,10 +709,10 @@ public Mixed exec(Target t, Environment env, Mixed... args) throws CancelCommand
 				v = new IVariable(v.getDefinedType(), v.getVariableName(), newVal, v.getDefinedTarget(), env);
 				env.getEnv(GlobalEnv.class).GetVarList().set(v);
 				return v;
-			} else if(ArgumentValidation.anyDoubles(args[0])) {
-				return new CDouble(ArgumentValidation.getNumber(args[0], t) + value, t);
+			} else if(ArgumentValidation.anyDoubles(env, args[0])) {
+				return new CDouble(ArgumentValidation.getNumber(args[0], t, env) + value, t);
 			} else {
-				return new CInt(ArgumentValidation.getInt(args[0], t) + value, t);
+				return new CInt(ArgumentValidation.getInt(args[0], t, env) + value, t);
 			}
 
 		}
@@ -707,7 +764,7 @@ public Mixed optimize(Target t, Environment env, Mixed... args) throws ConfigCom
 			if(args[0] instanceof IVariable) {
 				return null;
 			} else {
-				return exec(t, null, args);
+				return exec(t, null, null, args);
 			}
 		}
 
@@ -722,7 +779,7 @@ public Set<OptimizationOption> optimizationOptions() {
 	@api
 	@seealso({postdec.class, inc.class, dec.class})
 	@OperatorPreferred("++")
-	public static class postinc extends AbstractFunction implements Optimizable {
+	public static class postinc extends AbstractFunction implements Optimizable, FlowFunction<IncDecState> {
 
 		public static final String NAME = "postinc";
 
@@ -737,17 +794,18 @@ public Integer[] numArgs() {
 		}
 
 		@Override
-		public boolean useSpecialExec() {
-			return true;
+		public StepResult<IncDecState> begin(Target t, ParseTree[] children, Environment env) {
+			return incDecBegin(t, children, env, this, false, true);
 		}
 
 		@Override
-		public Mixed execs(Target t, Environment env, Script parent, ParseTree... nodes) {
-			return Math.doIncrementDecrement(nodes, parent, env, t, this, false, true);
+		public StepResult<IncDecState> childCompleted(Target t, IncDecState state,
+				Mixed result, Environment env) {
+			return incDecChildCompleted(t, state, result, env);
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment env, Mixed... args) throws CancelCommandException, ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws CancelCommandException, ConfigRuntimeException {
 			long value = 1;
 			if(args.length == 2) {
 				if(args[1] instanceof IVariable) {
@@ -755,16 +813,16 @@ public Mixed exec(Target t, Environment env, Mixed... args) throws CancelCommand
 					args[1] = env.getEnv(GlobalEnv.class).GetVarList().get(cur2.getVariableName(), cur2.getTarget(),
 							env);
 				}
-				value = ArgumentValidation.getInt(args[1], t);
+				value = ArgumentValidation.getInt(args[1], t, env);
 			}
 			if(args[0] instanceof IVariable) {
 				IVariable cur = (IVariable) args[0];
 				IVariable v = env.getEnv(GlobalEnv.class).GetVarList().get(cur.getVariableName(), cur.getTarget(), env);
 				Mixed newVal;
-				if(ArgumentValidation.anyDoubles(v.ival())) {
-					newVal = new CDouble(ArgumentValidation.getDouble(v.ival(), t) + value, t);
+				if(ArgumentValidation.anyDoubles(env, v.ival())) {
+					newVal = new CDouble(ArgumentValidation.getDouble(v.ival(), t, env) + value, t);
 				} else {
-					newVal = new CInt(ArgumentValidation.getInt(v.ival(), t) + value, t);
+					newVal = new CInt(ArgumentValidation.getInt(v.ival(), t, env) + value, t);
 				}
 				if(v.ival() instanceof CMutablePrimitive) {
 					newVal = ((CMutablePrimitive) v.ival()).setAndReturn(newVal, t);
@@ -778,10 +836,10 @@ public Mixed exec(Target t, Environment env, Mixed... args) throws CancelCommand
 				v = new IVariable(v.getDefinedType(), v.getVariableName(), newVal, v.getDefinedTarget(), env);
 				env.getEnv(GlobalEnv.class).GetVarList().set(v);
 				return oldVal;
-			} else if(ArgumentValidation.anyDoubles(args[0])) {
-				return new CDouble(ArgumentValidation.getNumber(args[0], t) + value, t);
+			} else if(ArgumentValidation.anyDoubles(env, args[0])) {
+				return new CDouble(ArgumentValidation.getNumber(args[0], t, env) + value, t);
 			} else {
-				return new CInt(ArgumentValidation.getInt(args[0], t) + value, t);
+				return new CInt(ArgumentValidation.getInt(args[0], t, env) + value, t);
 			}
 		}
 
@@ -822,7 +880,7 @@ public Mixed optimize(Target t, Environment env, Mixed... args) throws ConfigCom
 			if(args[0] instanceof IVariable) {
 				return null;
 			} else {
-				return exec(t, null, args);
+				return exec(t, null, null, args);
 			}
 		}
 
@@ -852,7 +910,7 @@ public ExampleScript[] examples() throws ConfigCompileException {
 	@api
 	@seealso({inc.class, postdec.class, postinc.class})
 	@OperatorPreferred("--")
-	public static class dec extends AbstractFunction implements Optimizable {
+	public static class dec extends AbstractFunction implements Optimizable, FlowFunction<IncDecState> {
 
 		public static final String NAME = "dec";
 
@@ -867,17 +925,18 @@ public Integer[] numArgs() {
 		}
 
 		@Override
-		public boolean useSpecialExec() {
-			return true;
+		public StepResult<IncDecState> begin(Target t, ParseTree[] children, Environment env) {
+			return incDecBegin(t, children, env, this, true, false);
 		}
 
 		@Override
-		public Mixed execs(Target t, Environment env, Script parent, ParseTree... nodes) {
-			return doIncrementDecrement(nodes, parent, env, t, this, true, false);
+		public StepResult<IncDecState> childCompleted(Target t, IncDecState state,
+				Mixed result, Environment env) {
+			return incDecChildCompleted(t, state, result, env);
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment env, Mixed... args) throws CancelCommandException, ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws CancelCommandException, ConfigRuntimeException {
 			long value = 1;
 			if(args.length == 2) {
 				if(args[1] instanceof IVariable) {
@@ -885,16 +944,16 @@ public Mixed exec(Target t, Environment env, Mixed... args) throws CancelCommand
 					args[1] = env.getEnv(GlobalEnv.class).GetVarList().get(cur2.getVariableName(), cur2.getTarget(),
 							env);
 				}
-				value = ArgumentValidation.getInt(args[1], t);
+				value = ArgumentValidation.getInt(args[1], t, env);
 			}
 			if(args[0] instanceof IVariable) {
 				IVariable cur = (IVariable) args[0];
 				IVariable v = env.getEnv(GlobalEnv.class).GetVarList().get(cur.getVariableName(), cur.getTarget(), env);
 				Mixed newVal;
-				if(ArgumentValidation.anyDoubles(v.ival())) {
-					newVal = new CDouble(ArgumentValidation.getDouble(v.ival(), t) - value, t);
+				if(ArgumentValidation.anyDoubles(env, v.ival())) {
+					newVal = new CDouble(ArgumentValidation.getDouble(v.ival(), t, env) - value, t);
 				} else {
-					newVal = new CInt(ArgumentValidation.getInt(v.ival(), t) - value, t);
+					newVal = new CInt(ArgumentValidation.getInt(v.ival(), t, env) - value, t);
 				}
 				if(v.ival() instanceof CMutablePrimitive) {
 					newVal = ((CMutablePrimitive) v.ival()).setAndReturn(newVal, t);
@@ -902,10 +961,10 @@ public Mixed exec(Target t, Environment env, Mixed... args) throws CancelCommand
 				v = new IVariable(v.getDefinedType(), v.getVariableName(), newVal, v.getDefinedTarget(), env);
 				env.getEnv(GlobalEnv.class).GetVarList().set(v);
 				return v;
-			} else if(ArgumentValidation.anyDoubles(args[0])) {
-				return new CDouble(ArgumentValidation.getNumber(args[0], t) - value, t);
+			} else if(ArgumentValidation.anyDoubles(env, args[0])) {
+				return new CDouble(ArgumentValidation.getNumber(args[0], t, env) - value, t);
 			} else {
-				return new CInt(ArgumentValidation.getInt(args[0], t) - value, t);
+				return new CInt(ArgumentValidation.getInt(args[0], t, env) - value, t);
 			}
 		}
 
@@ -946,7 +1005,7 @@ public Mixed optimize(Target t, Environment env, Mixed... args) throws ConfigCom
 			if(args[0] instanceof IVariable) {
 				return null;
 			} else {
-				return exec(t, null, args);
+				return exec(t, null, null, args);
 			}
 		}
 
@@ -972,7 +1031,7 @@ public ExampleScript[] examples() throws ConfigCompileException {
 	@api
 	@seealso({postinc.class, inc.class, dec.class})
 	@OperatorPreferred("--")
-	public static class postdec extends AbstractFunction implements Optimizable {
+	public static class postdec extends AbstractFunction implements Optimizable, FlowFunction<IncDecState> {
 
 		public static final String NAME = "postdec";
 
@@ -987,17 +1046,18 @@ public Integer[] numArgs() {
 		}
 
 		@Override
-		public boolean useSpecialExec() {
-			return true;
+		public StepResult<IncDecState> begin(Target t, ParseTree[] children, Environment env) {
+			return incDecBegin(t, children, env, this, false, false);
 		}
 
 		@Override
-		public Mixed execs(Target t, Environment env, Script parent, ParseTree... nodes) {
-			return doIncrementDecrement(nodes, parent, env, t, this, false, false);
+		public StepResult<IncDecState> childCompleted(Target t, IncDecState state,
+				Mixed result, Environment env) {
+			return incDecChildCompleted(t, state, result, env);
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment env, Mixed... args) throws CancelCommandException, ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws CancelCommandException, ConfigRuntimeException {
 			long value = 1;
 			if(args.length == 2) {
 				if(args[1] instanceof IVariable) {
@@ -1005,16 +1065,16 @@ public Mixed exec(Target t, Environment env, Mixed... args) throws CancelCommand
 					args[1] = env.getEnv(GlobalEnv.class).GetVarList().get(cur2.getVariableName(), cur2.getTarget(),
 							env);
 				}
-				value = ArgumentValidation.getInt(args[1], t);
+				value = ArgumentValidation.getInt(args[1], t, env);
 			}
 			if(args[0] instanceof IVariable) {
 				IVariable cur = (IVariable) args[0];
 				IVariable v = env.getEnv(GlobalEnv.class).GetVarList().get(cur.getVariableName(), cur.getTarget(), env);
 				Mixed newVal;
-				if(ArgumentValidation.anyDoubles(v.ival())) {
-					newVal = new CDouble(ArgumentValidation.getDouble(v.ival(), t) - value, t);
+				if(ArgumentValidation.anyDoubles(env, v.ival())) {
+					newVal = new CDouble(ArgumentValidation.getDouble(v.ival(), t, env) - value, t);
 				} else {
-					newVal = new CInt(ArgumentValidation.getInt(v.ival(), t) - value, t);
+					newVal = new CInt(ArgumentValidation.getInt(v.ival(), t, env) - value, t);
 				}
 				if(v.ival() instanceof CMutablePrimitive) {
 					newVal = ((CMutablePrimitive) v.ival()).setAndReturn(newVal, t);
@@ -1028,10 +1088,10 @@ public Mixed exec(Target t, Environment env, Mixed... args) throws CancelCommand
 				v = new IVariable(v.getDefinedType(), v.getVariableName(), newVal, v.getDefinedTarget(), env);
 				env.getEnv(GlobalEnv.class).GetVarList().set(v);
 				return oldVal;
-			} else if(ArgumentValidation.anyDoubles(args[0])) {
-				return new CDouble(ArgumentValidation.getNumber(args[0], t) - value, t);
+			} else if(ArgumentValidation.anyDoubles(env, args[0])) {
+				return new CDouble(ArgumentValidation.getNumber(args[0], t, env) - value, t);
 			} else {
-				return new CInt(ArgumentValidation.getInt(args[0], t) - value, t);
+				return new CInt(ArgumentValidation.getInt(args[0], t, env) - value, t);
 			}
 		}
 
@@ -1072,7 +1132,7 @@ public Mixed optimize(Target t, Environment env, Mixed... args) throws ConfigCom
 			if(args[0] instanceof IVariable) {
 				return null;
 			} else {
-				return exec(t, null, args);
+				return exec(t, null, null, args);
 			}
 		}
 
@@ -1136,17 +1196,17 @@ public MSVersion since() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment env, Mixed... args) throws CancelCommandException, ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws CancelCommandException, ConfigRuntimeException {
 			if(args.length == 0) {
 				return new CDouble(java.lang.Math.random(), t);
 			} else {
 				long min = 0;
 				long max;
 				if(args.length == 1) {
-					max = ArgumentValidation.getInt(args[0], t);
+					max = ArgumentValidation.getInt(args[0], t, env);
 				} else {
-					min = ArgumentValidation.getInt(args[0], t);
-					max = ArgumentValidation.getInt(args[1], t);
+					min = ArgumentValidation.getInt(args[0], t, env);
+					max = ArgumentValidation.getInt(args[1], t, env);
 				}
 				if(max <= min) {
 					throw new CRERangeException("max must be greater than min", t);
@@ -1223,11 +1283,11 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment env, Mixed... args) throws ConfigRuntimeException {
-			if(args[0].isInstanceOf(CInt.TYPE)) {
-				return new CInt(java.lang.Math.abs(ArgumentValidation.getInt(args[0], t)), t);
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
+			if(args[0].isInstanceOf(CInt.TYPE, null, env)) {
+				return new CInt(java.lang.Math.abs(ArgumentValidation.getInt(args[0], t, env)), t);
 			} else {
-				return new CDouble(java.lang.Math.abs(ArgumentValidation.getDouble(args[0], t)), t);
+				return new CDouble(java.lang.Math.abs(ArgumentValidation.getDouble(args[0], t, env)), t);
 			}
 		}
 
@@ -1287,8 +1347,8 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment env, Mixed... args) throws ConfigRuntimeException {
-			return new CInt((long) java.lang.Math.floor(ArgumentValidation.getNumber(args[0], t)), t);
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
+			return new CInt((long) java.lang.Math.floor(ArgumentValidation.getNumber(args[0], t, env)), t);
 		}
 
 		@Override
@@ -1339,8 +1399,8 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment env, Mixed... args) throws ConfigRuntimeException {
-			return new CInt((long) java.lang.Math.ceil(ArgumentValidation.getNumber(args[0], t)), t);
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
+			return new CInt((long) java.lang.Math.ceil(ArgumentValidation.getNumber(args[0], t, env)), t);
 		}
 
 		@Override
@@ -1392,8 +1452,8 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment env, Mixed... args) throws ConfigRuntimeException {
-			double d = ArgumentValidation.getNumber(args[0], t);
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
+			double d = ArgumentValidation.getNumber(args[0], t, env);
 			if(d < 0) {
 				throw new CRERangeException("sqrt expects a number >= 0", t);
 			}
@@ -1454,15 +1514,15 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment env, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			if(args.length == 0) {
 				throw new CREInsufficientArgumentsException("You must send at least one parameter to min", t);
 			}
 			double lowest = Double.POSITIVE_INFINITY;
 			List<Mixed> list = new ArrayList<>();
-			recList(list, args);
+			recList(list, env, args);
 			for(Mixed c : list) {
-				double d = ArgumentValidation.getNumber(c, t);
+				double d = ArgumentValidation.getNumber(c, t, env);
 				if(d < lowest) {
 					lowest = d;
 				}
@@ -1474,11 +1534,11 @@ public Mixed exec(Target t, Environment env, Mixed... args) throws ConfigRuntime
 			}
 		}
 
-		public List<Mixed> recList(List<Mixed> list, Mixed... args) {
+		private List<Mixed> recList(List<Mixed> list, Environment env, Mixed... args) {
 			for(Mixed c : args) {
-				if(c.isInstanceOf(CArray.TYPE)) {
-					for(int i = 0; i < ((CArray) c).size(); i++) {
-						recList(list, ((CArray) c).get(i, Target.UNKNOWN));
+				if(c.isInstanceOf(CArray.TYPE, null, env)) {
+					for(int i = 0; i < ((CArray) c).size(env); i++) {
+						recList(list, env, ((CArray) c).get(i, Target.UNKNOWN, env));
 					}
 				} else {
 					list.add(c);
@@ -1536,15 +1596,15 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment env, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			if(args.length == 0) {
 				throw new CREInsufficientArgumentsException("You must send at least one parameter to max", t);
 			}
 			double highest = Double.NEGATIVE_INFINITY;
 			List<Mixed> list = new ArrayList<>();
-			recList(list, args);
+			recList(list, env, args);
 			for(Mixed c : list) {
-				double d = ArgumentValidation.getNumber(c, t);
+				double d = ArgumentValidation.getNumber(c, t, env);
 				if(d > highest) {
 					highest = d;
 				}
@@ -1556,11 +1616,11 @@ public Mixed exec(Target t, Environment env, Mixed... args) throws ConfigRuntime
 			}
 		}
 
-		public List<Mixed> recList(List<Mixed> list, Mixed... args) {
+		private List<Mixed> recList(List<Mixed> list, Environment env, Mixed... args) {
 			for(Mixed c : args) {
-				if(c.isInstanceOf(CArray.TYPE)) {
-					for(int i = 0; i < ((CArray) c).size(); i++) {
-						recList(list, ((CArray) c).get(i, Target.UNKNOWN));
+				if(c.isInstanceOf(CArray.TYPE, null, null)) {
+					for(int i = 0; i < ((CArray) c).size(env); i++) {
+						recList(list, env, ((CArray) c).get(i, Target.UNKNOWN, env));
 					}
 				} else {
 					list.add(c);
@@ -1617,8 +1677,8 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment env, Mixed... args) throws ConfigRuntimeException {
-			return new CDouble(java.lang.Math.sin(ArgumentValidation.getNumber(args[0], t)), t);
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
+			return new CDouble(java.lang.Math.sin(ArgumentValidation.getNumber(args[0], t, env)), t);
 		}
 
 		@Override
@@ -1669,8 +1729,8 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment env, Mixed... args) throws ConfigRuntimeException {
-			return new CDouble(java.lang.Math.cos(ArgumentValidation.getNumber(args[0], t)), t);
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
+			return new CDouble(java.lang.Math.cos(ArgumentValidation.getNumber(args[0], t, env)), t);
 		}
 
 		@Override
@@ -1721,8 +1781,8 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment env, Mixed... args) throws ConfigRuntimeException {
-			return new CDouble(java.lang.Math.tan(ArgumentValidation.getNumber(args[0], t)), t);
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
+			return new CDouble(java.lang.Math.tan(ArgumentValidation.getNumber(args[0], t, env)), t);
 		}
 
 		@Override
@@ -1773,8 +1833,8 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment env, Mixed... args) throws ConfigRuntimeException {
-			return new CDouble(java.lang.Math.asin(ArgumentValidation.getNumber(args[0], t)), t);
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
+			return new CDouble(java.lang.Math.asin(ArgumentValidation.getNumber(args[0], t, env)), t);
 		}
 
 		@Override
@@ -1825,8 +1885,8 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment env, Mixed... args) throws ConfigRuntimeException {
-			return new CDouble(java.lang.Math.acos(ArgumentValidation.getNumber(args[0], t)), t);
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
+			return new CDouble(java.lang.Math.acos(ArgumentValidation.getNumber(args[0], t, env)), t);
 		}
 
 		@Override
@@ -1877,8 +1937,8 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment env, Mixed... args) throws ConfigRuntimeException {
-			return new CDouble(java.lang.Math.atan(ArgumentValidation.getNumber(args[0], t)), t);
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
+			return new CDouble(java.lang.Math.atan(ArgumentValidation.getNumber(args[0], t, env)), t);
 		}
 
 		@Override
@@ -1929,8 +1989,8 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment env, Mixed... args) throws ConfigRuntimeException {
-			return Static.getNumber(java.lang.Math.sinh(ArgumentValidation.getNumber(args[0], t)), t);
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
+			return Static.getNumber(java.lang.Math.sinh(ArgumentValidation.getNumber(args[0], t, env)), t);
 		}
 
 		@Override
@@ -1981,8 +2041,8 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment env, Mixed... args) throws ConfigRuntimeException {
-			return Static.getNumber(java.lang.Math.cosh(ArgumentValidation.getNumber(args[0], t)), t);
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
+			return Static.getNumber(java.lang.Math.cosh(ArgumentValidation.getNumber(args[0], t, env)), t);
 		}
 
 		@Override
@@ -2033,8 +2093,8 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment env, Mixed... args) throws ConfigRuntimeException {
-			return Static.getNumber(java.lang.Math.tanh(ArgumentValidation.getNumber(args[0], t)), t);
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
+			return Static.getNumber(java.lang.Math.tanh(ArgumentValidation.getNumber(args[0], t, env)), t);
 		}
 
 		@Override
@@ -2085,8 +2145,8 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment env, Mixed... args) throws ConfigRuntimeException {
-			return new CDouble(java.lang.Math.toRadians(ArgumentValidation.getNumber(args[0], t)), t);
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
+			return new CDouble(java.lang.Math.toRadians(ArgumentValidation.getNumber(args[0], t, env)), t);
 		}
 
 		@Override
@@ -2137,8 +2197,8 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment env, Mixed... args) throws ConfigRuntimeException {
-			return new CDouble(java.lang.Math.toDegrees(ArgumentValidation.getNumber(args[0], t)), t);
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
+			return new CDouble(java.lang.Math.toDegrees(ArgumentValidation.getNumber(args[0], t, env)), t);
 		}
 
 		@Override
@@ -2193,8 +2253,8 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment env, Mixed... args) throws ConfigRuntimeException {
-			return new CDouble(java.lang.Math.atan2(ArgumentValidation.getNumber(args[0], t), ArgumentValidation.getNumber(args[1], t)), t);
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
+			return new CDouble(java.lang.Math.atan2(ArgumentValidation.getNumber(args[0], t, env), ArgumentValidation.getNumber(args[1], t, env)), t);
 		}
 
 		@Override
@@ -2246,11 +2306,11 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment env, Mixed... args) throws ConfigRuntimeException {
-			double number = ArgumentValidation.getNumber(args[0], t);
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
+			double number = ArgumentValidation.getNumber(args[0], t, env);
 			int precision = 0;
 			if(args.length > 1) {
-				precision = ArgumentValidation.getInt32(args[1], t);
+				precision = ArgumentValidation.getInt32(args[1], t, env);
 			}
 			if(precision < 0) {
 				throw new CRERangeException("precision cannot be less than 0, was " + precision, t);
@@ -2298,8 +2358,8 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
-			double x = ArgumentValidation.getDouble(args[0], t) + 1;
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
+			double x = ArgumentValidation.getDouble(args[0], t, env) + 1;
 			DecimalFormat twoDForm = new DecimalFormat("0.##############E0");
 			String str = twoDForm.format(x);
 			double d = Double.valueOf(str) - 1;
@@ -2396,15 +2456,15 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			String expr = args[0].val().trim();
 			if("".equals(expr)) {
 				throw new CREFormatException("Expression may not be empty", t);
 			}
 			CArray vars = null;
-			if(args.length == 2 && args[1].isInstanceOf(CArray.TYPE)) {
+			if(args.length == 2 && args[1].isInstanceOf(CArray.TYPE, null, env)) {
 				vars = (CArray) args[1];
-			} else if(args.length == 2 && !(args[1].isInstanceOf(CArray.TYPE))) {
+			} else if(args.length == 2 && !(args[1].isInstanceOf(CArray.TYPE, null, env))) {
 				throw new CRECastException("The second argument of expr() should be an array", t);
 			}
 			if(vars != null && !vars.inAssociativeMode()) {
@@ -2414,11 +2474,11 @@ public Mixed exec(Target t, Environment environment, Mixed... args) throws Confi
 			String[] varNames;
 			if(vars != null) {
 				int i = 0;
-				da = new double[(int) vars.size()];
-				varNames = new String[(int) vars.size()];
+				da = new double[(int) vars.size(env)];
+				varNames = new String[(int) vars.size(env)];
 				for(String key : vars.stringKeySet()) {
 					varNames[i] = key;
-					da[i] = ArgumentValidation.getDouble(vars.get(key, t), t);
+					da[i] = ArgumentValidation.getDouble(vars.get(key, t, env), t, env);
 					i++;
 				}
 			} else {
@@ -2502,11 +2562,11 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
-			if(args[0].isInstanceOf(CInt.TYPE)) {
-				return new CInt(-(ArgumentValidation.getInt(args[0], t)), t);
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
+			if(args[0].isInstanceOf(CInt.TYPE, null, env)) {
+				return new CInt(-(ArgumentValidation.getInt(args[0], t, env)), t);
 			} else {
-				return new CDouble(-(ArgumentValidation.getDouble(args[0], t)), t);
+				return new CDouble(-(ArgumentValidation.getDouble(args[0], t, env)), t);
 			}
 		}
 
@@ -2543,8 +2603,8 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
-			double val = ArgumentValidation.getDouble(args[0], t);
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
+			double val = ArgumentValidation.getDouble(args[0], t, env);
 			if(val <= 0) {
 				throw new CRERangeException("val was <= 0", t);
 			}
@@ -2552,7 +2612,7 @@ public Mixed exec(Target t, Environment environment, Mixed... args) throws Confi
 			if(args.length == 1) {
 				r = java.lang.Math.log(val);
 			} else { // if(args.length == 2) {
-				r = java.lang.Math.log(val) / java.lang.Math.log(ArgumentValidation.getDouble(args[1], t));
+				r = java.lang.Math.log(val) / java.lang.Math.log(ArgumentValidation.getDouble(args[1], t, env));
 			}
 			return new CDouble(r, t);
 		}
@@ -2688,7 +2748,7 @@ public Version since() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			try {
 				MathConstants c = MathConstants.valueOf(args[0].val());
 				Number v = c.getValue();
diff --git a/src/main/java/com/laytonsmith/core/functions/MatrixHandling.java b/src/main/java/com/laytonsmith/core/functions/MatrixHandling.java
index 9f2d217ad3..6ea7483d39 100644
--- a/src/main/java/com/laytonsmith/core/functions/MatrixHandling.java
+++ b/src/main/java/com/laytonsmith/core/functions/MatrixHandling.java
@@ -17,6 +17,7 @@
 import com.laytonsmith.core.constructs.CString;
 import com.laytonsmith.core.constructs.CVoid;
 import com.laytonsmith.core.constructs.Target;
+import com.laytonsmith.core.constructs.generics.GenericParameters;
 import com.laytonsmith.core.environments.Environment;
 import com.laytonsmith.core.exceptions.CRE.CRECastException;
 import com.laytonsmith.core.exceptions.CRE.CREIllegalArgumentException;
@@ -96,7 +97,7 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment env, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			if(args.length == 1) {
 				return CReal2dMatrix.FromConstruct(ArgumentValidation.getArray(args[0], t), t);
 			} else {
@@ -173,7 +174,7 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment env, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			CReal2dMatrix matrix = getMatrix(args[0], t, 1);
 			int column = ArgumentValidation.getInt32(args[1], t);
 			double[] data = matrix.getColumn(column);
@@ -236,7 +237,7 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment env, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			CReal2dMatrix matrix = getMatrixOnly(args[0], t, 1);
 			return matrix.deepClone();
 		}
@@ -290,7 +291,7 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment env, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			CReal2dMatrix matrix = getMatrix(args[0], t, 1);
 			double[] data = matrix.getData();
 			String format = "%.3f";
@@ -382,7 +383,7 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public CArray exec(Target t, Environment env, Mixed... args) throws ConfigRuntimeException {
+		public CArray exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			CReal2dMatrix m = MatrixHandling.getMatrixOnly(args[0], t, 1);
 			return m.toArray();
 		}
@@ -438,7 +439,7 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public CReal2dMatrix exec(Target t, Environment env, Mixed... args) throws ConfigRuntimeException {
+		public CReal2dMatrix exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			int dimension = ArgumentValidation.getInt32(args[0], t);
 			double[] data = new double[dimension * dimension];
 			for(int i = 0; i < (dimension * dimension); i++) {
@@ -498,7 +499,7 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment env, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			return MatrixHandling.getMatrix(args[0], t, 1).transpose();
 		}
 
@@ -553,7 +554,7 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment env, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			CReal2dMatrix left = MatrixHandling.getMatrix(args[0], t, 1);
 			CReal2dMatrix right = MatrixHandling.getMatrix(args[1], t, 2);
 			left.add(right, t);
@@ -618,7 +619,7 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment env, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			CReal2dMatrix left = MatrixHandling.getMatrix(args[0], t, 1);
 			CReal2dMatrix right = MatrixHandling.getMatrix(args[1], t, 2);
 			left.subtract(right, t);
@@ -683,7 +684,7 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment env, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			CReal2dMatrix matrix = MatrixHandling.getMatrix(args[0], t, 1);
 			double scalar = ArgumentValidation.getDouble(args[1], t);
 			matrix.scalarMultiply(scalar);
@@ -742,7 +743,7 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment env, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			CReal2dMatrix matrix = MatrixHandling.getMatrix(args[0], t, 1);
 			int row = ArgumentValidation.getInt32(args[1], t);
 			int column = ArgumentValidation.getInt32(args[2], t);
@@ -806,7 +807,7 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment env, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			CReal2dMatrix left = MatrixHandling.getMatrix(args[0], t, 1);
 			CReal2dMatrix right = MatrixHandling.getMatrix(args[1], t, 2);
 			return left.multiply(right, t);
@@ -872,7 +873,7 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment env, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			CReal2dMatrix left = MatrixHandling.getMatrix(args[0], t, 1);
 			CReal2dMatrix right = MatrixHandling.getMatrix(args[1], t, 2);
 			return CBoolean.get(left.canMultiply(right));
@@ -937,7 +938,7 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment env, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			CReal2dMatrix left = MatrixHandling.getMatrix(args[0], t, 1);
 			CReal2dMatrix right = MatrixHandling.getMatrix(args[1], t, 2);
 			return CBoolean.get(left.canAdd(right));
@@ -1002,7 +1003,7 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment env, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			CReal2dMatrix matrix = MatrixHandling.getMatrix(args[0], t, 1);
 			return CBoolean.get(matrix.isSquare());
 		}
@@ -1057,7 +1058,7 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment env, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			CReal2dMatrix left = MatrixHandling.getMatrix(args[0], t, 1);
 			CReal2dMatrix right = MatrixHandling.getMatrix(args[1], t, 2);
 			double tolerance = ArgumentValidation.getDouble(args[2], t);
@@ -1126,7 +1127,7 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment env, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			CReal2dMatrix matrix = MatrixHandling.getMatrix(args[0], t, 1);
 			return new CDouble(matrix.trace(t), t);
 		}
@@ -1182,7 +1183,7 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment env, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			CReal2dMatrix matrix = MatrixHandling.getMatrix(args[0], t, 1);
 			return new CDouble(matrix.determinant(t), t);
 		}
@@ -1239,7 +1240,7 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment env, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			CReal2dMatrix matrix = MatrixHandling.getMatrix(args[0], t, 1);
 			return new CDouble(matrix.norm(), t);
 		}
diff --git a/src/main/java/com/laytonsmith/core/functions/Meta.java b/src/main/java/com/laytonsmith/core/functions/Meta.java
index 6f662587fe..e5f27e132a 100644
--- a/src/main/java/com/laytonsmith/core/functions/Meta.java
+++ b/src/main/java/com/laytonsmith/core/functions/Meta.java
@@ -16,6 +16,7 @@
 import com.laytonsmith.annotations.seealso;
 import com.laytonsmith.core.AliasCore;
 import com.laytonsmith.core.ArgumentValidation;
+import com.laytonsmith.core.FlowFunction;
 import com.laytonsmith.core.MSLog;
 import com.laytonsmith.core.MSVersion;
 import com.laytonsmith.core.LogLevel;
@@ -25,6 +26,9 @@
 import com.laytonsmith.core.Prefs;
 import com.laytonsmith.core.Script;
 import com.laytonsmith.core.Static;
+import com.laytonsmith.core.StepAction.Complete;
+import com.laytonsmith.core.StepAction.Evaluate;
+import com.laytonsmith.core.StepAction.StepResult;
 import com.laytonsmith.core.compiler.BranchStatement;
 import com.laytonsmith.core.compiler.FileOptions;
 import com.laytonsmith.core.compiler.VariableScope;
@@ -42,7 +46,9 @@
 import com.laytonsmith.core.constructs.IVariable;
 import com.laytonsmith.core.constructs.Target;
 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;
@@ -115,7 +121,7 @@ public Boolean runAsync() {
 			return false;
 		}
 
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment environment, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			return CBoolean.get(CommandHelperPlugin.isFirstLoad());
 		}
 
@@ -151,15 +157,15 @@ public Integer[] numArgs() {
 		}
 
 		@Override
-		public Mixed exec(Target t, final Environment env, Mixed... args) throws CancelCommandException, ConfigRuntimeException {
+		public Mixed exec(Target t, final Environment env, GenericParameters generics, Mixed... args) throws CancelCommandException, ConfigRuntimeException {
 			if(args[1] instanceof CNull || args[1].val().isEmpty() || args[1].val().charAt(0) != '/') {
 				throw new CREFormatException("The first character of the command must be a forward slash (i.e. '/give')", t);
 			}
 			String cmd = args[1].val().substring(1);
-			if(args[0].isInstanceOf(CArray.TYPE)) {
+			if(args[0].isInstanceOf(CArray.TYPE, null, env)) {
 				CArray u = (CArray) args[0];
-				for(int i = 0; i < u.size(); i++) {
-					exec(t, env, new Mixed[]{new CString(u.get(i, t).val(), t), args[1]});
+				for(int i = 0; i < u.size(env); i++) {
+					exec(t, env, null, new Mixed[]{new CString(u.get(i, t, env).val(), t), args[1]});
 				}
 				return CVoid.VOID;
 			}
@@ -174,7 +180,7 @@ public Mixed exec(Target t, final Environment env, Mixed... args) throws CancelC
 				}
 				Static.getServer().runasConsole(cmd);
 			} else {
-				MCPlayer m = Static.GetPlayer(args[0], t);
+				MCPlayer m = Static.GetPlayer(args[0], t, env);
 
 				MCPlayer p = env.getEnv(CommandHelperEnvironment.class).GetPlayer();
 				String name;
@@ -258,11 +264,11 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment env, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			Mixed command;
 			MCPlayer sender;
 			if(args.length == 2) {
-				sender = Static.GetPlayer(args[0], t);
+				sender = Static.GetPlayer(args[0], t, env);
 				command = args[1];
 			} else {
 				sender = env.getEnv(CommandHelperEnvironment.class).GetPlayer();
@@ -271,7 +277,7 @@ public Mixed exec(Target t, Environment env, Mixed... args) throws ConfigRuntime
 
 			//If the command sender is null, this is not a player, so just try to run() this.
 			if(sender == null) {
-				return new run().exec(t, env, args);
+				return new run().exec(t, env, null, args);
 			}
 
 			if(command instanceof CNull || command.val().isEmpty() || command.val().charAt(0) != '/') {
@@ -410,7 +416,7 @@ public Integer[] numArgs() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment env, Mixed... args) throws CancelCommandException, ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws CancelCommandException, ConfigRuntimeException {
 			if(args[0] instanceof CNull || args[0].val().isEmpty() || args[0].val().charAt(0) != '/') {
 				throw new CREFormatException("The first character of the command must be a forward slash (i.e. '/give')", t);
 			}
@@ -497,7 +503,7 @@ public Integer[] numArgs() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment env, Mixed... args) throws CancelCommandException, ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws CancelCommandException, ConfigRuntimeException {
 			MCCommandSender sender;
 			String commandString;
 			List<Mixed> argList;
@@ -507,11 +513,11 @@ public Mixed exec(Target t, Environment env, Mixed... args) throws CancelCommand
 					throw new CREException("No command sender in this context.", t);
 				}
 				commandString = args[0].val();
-				argList = ArgumentValidation.getArray(args[1], t).asList();
+				argList = ArgumentValidation.getArray(args[1], t, env).asList(env);
 			} else {
 				sender = Static.GetCommandSender(args[0].val(), t);
 				commandString = args[1].val();
-				argList = ArgumentValidation.getArray(args[2], t).asList();
+				argList = ArgumentValidation.getArray(args[2], t, env).asList(env);
 			}
 
 			if(commandString.length() < 1 || commandString.charAt(0) != '/') {
@@ -531,7 +537,7 @@ public Mixed exec(Target t, Environment env, Mixed... args) throws CancelCommand
 			List<String> completions = command.tabComplete(sender, commandString, arguments);
 			CArray ret = new CArray(t);
 			for(String s : completions) {
-				ret.push(new CString(s, t), t);
+				ret.push(new CString(s, t), t, env);
 			}
 			return ret;
 		}
@@ -600,7 +606,7 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public CBoolean exec(Target t, Environment environment, Mixed... args)
+		public CBoolean exec(Target t, Environment env, GenericParameters generics, Mixed... args)
 				throws ConfigRuntimeException {
 			AliasCore ac = Static.getAliasCore();
 
@@ -679,7 +685,7 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment env, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			MCCommandSender sender = env.getEnv(CommandHelperEnvironment.class).GetCommandSender();
 			if(sender == null) {
 				throw new CREException("No command sender in this context.", t);
@@ -712,7 +718,8 @@ public Set<Optimizable.OptimizationOption> optimizationOptions() {
 	}
 
 	@api(environments = {CommandHelperEnvironment.class, GlobalEnv.class})
-	public static class scriptas extends AbstractFunction implements VariableScope, BranchStatement {
+	public static class scriptas extends AbstractFunction implements VariableScope, BranchStatement,
+			FlowFunction<scriptas.ScriptasState> {
 
 		@Override
 		public String getName() {
@@ -759,36 +766,74 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) {
 			return null;
 		}
 
+		static class ScriptasState {
+			enum Phase { EVAL_SENDER, EVAL_LABEL, EVAL_BODY }
+			Phase phase = Phase.EVAL_SENDER;
+			ParseTree[] children;
+			MCCommandSender originalSender;
+			String originalLabel;
+
+			ScriptasState(ParseTree[] children) {
+				this.children = children;
+			}
+
+			@Override
+			public String toString() {
+				return phase.name();
+			}
+		}
+
 		@Override
-		public Mixed execs(Target t, Environment environment, Script parent, ParseTree... nodes) throws ConfigRuntimeException {
-			String senderName = parent.seval(nodes[0], environment).val();
-			MCCommandSender sender = Static.GetCommandSender(senderName, t);
-			MCCommandSender originalSender = environment.getEnv(CommandHelperEnvironment.class).GetCommandSender();
-			int offset = 0;
-			String originalLabel = environment.getEnv(GlobalEnv.class).GetLabel();
-			if(nodes.length == 3) {
-				offset++;
-				String label = parent.seval(nodes[1], environment).val();
-				environment.getEnv(GlobalEnv.class).SetLabel(label);
-			} else {
-				environment.getEnv(GlobalEnv.class).SetLabel(parent.getLabel());
+		public StepResult<ScriptasState> begin(Target t, ParseTree[] children, Environment env) {
+			ScriptasState state = new ScriptasState(children);
+			return new StepResult<>(new Evaluate(children[0]), state);
+		}
+
+		@Override
+		public StepResult<ScriptasState> childCompleted(Target t, ScriptasState state,
+				Mixed result, Environment env) {
+			switch(state.phase) {
+				case EVAL_SENDER -> {
+					MCCommandSender sender = Static.GetCommandSender(result.val(), t);
+					state.originalSender = env.getEnv(CommandHelperEnvironment.class).GetCommandSender();
+					state.originalLabel = env.getEnv(GlobalEnv.class).GetLabel();
+					env.getEnv(CommandHelperEnvironment.class).SetCommandSender(sender);
+					if(state.children.length == 3) {
+						state.phase = ScriptasState.Phase.EVAL_LABEL;
+						return new StepResult<>(new Evaluate(state.children[1]), state);
+					} else {
+						// No explicit label — use parent script's label
+						// (enforceLabelPermissions is called in execs but we can't access
+						// parent here; the label is already set from the enclosing scope)
+						state.phase = ScriptasState.Phase.EVAL_BODY;
+						return new StepResult<>(new Evaluate(state.children[1]), state);
+					}
+				}
+				case EVAL_LABEL -> {
+					env.getEnv(GlobalEnv.class).SetLabel(result.val());
+					state.phase = ScriptasState.Phase.EVAL_BODY;
+					return new StepResult<>(new Evaluate(state.children[2]), state);
+				}
+				case EVAL_BODY -> {
+					return new StepResult<>(new Complete(CVoid.VOID), state);
+				}
 			}
-			environment.getEnv(CommandHelperEnvironment.class).SetCommandSender(sender);
-			parent.enforceLabelPermissions(environment);
-			ParseTree tree = nodes[1 + offset];
-			parent.eval(tree, environment);
-			environment.getEnv(CommandHelperEnvironment.class).SetCommandSender(originalSender);
-			environment.getEnv(GlobalEnv.class).SetLabel(originalLabel);
-			return CVoid.VOID;
+			throw ConfigRuntimeException.CreateUncatchableException(
+					"Invalid scriptas state: " + state.phase, t);
 		}
 
 		@Override
-		public boolean useSpecialExec() {
-			return true;
+		public void cleanup(Target t, ScriptasState state, Environment env) {
+			if(state != null) {
+				if(state.originalSender != null) {
+					env.getEnv(CommandHelperEnvironment.class).SetCommandSender(state.originalSender);
+					env.getEnv(GlobalEnv.class).SetLabel(state.originalLabel);
+				}
+			}
 		}
 
 		@Override
@@ -849,11 +894,11 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
-			if(environment.getEnv(CommandHelperEnvironment.class).GetCommand() == null) {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
+			if(env.getEnv(CommandHelperEnvironment.class).GetCommand() == null) {
 				return CNull.NULL;
 			} else {
-				return new CString(environment.getEnv(CommandHelperEnvironment.class).GetCommand(), t);
+				return new CString(env.getEnv(CommandHelperEnvironment.class).GetCommand(), t);
 			}
 		}
 
@@ -883,7 +928,7 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			String player = args[0].val();
 			String cmd = args[1].val();
 			if(cmd.isEmpty() || cmd.charAt(0) != '/') {
@@ -963,8 +1008,8 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
-			MCCommandSender sender = environment.getEnv(CommandHelperEnvironment.class).GetCommandSender();
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
+			MCCommandSender sender = env.getEnv(CommandHelperEnvironment.class).GetCommandSender();
 			MCLocation loc;
 			CArray ret;
 			if(sender instanceof MCBlockCommandSender) {
@@ -1022,16 +1067,16 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			MCPlayer player;
 			boolean state;
 			if(args.length == 1) {
-				player = environment.getEnv(CommandHelperEnvironment.class).GetPlayer();
+				player = env.getEnv(CommandHelperEnvironment.class).GetPlayer();
 				Static.AssertPlayerNonNull(player, t);
-				state = ArgumentValidation.getBoolean(args[0], t);
+				state = ArgumentValidation.getBoolean(args[0], t, env);
 			} else {
-				player = Static.GetPlayer(args[0].val(), t);
-				state = ArgumentValidation.getBoolean(args[1], t);
+				player = Static.GetPlayer(args[0].val(), t, env);
+				state = ArgumentValidation.getBoolean(args[1], t, env);
 			}
 			player.setOp(state);
 			return CVoid.VOID;
@@ -1089,17 +1134,17 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			CString s;
-			if(args[0].isInstanceOf(CString.TYPE)) {
+			if(args[0].isInstanceOf(CString.TYPE, null, env)) {
 				s = (CString) args[0];
 			} else {
 				s = new CString(args[0].val(), t);
 			}
-			if(is_alias.exec(t, environment, s).getBoolean()) {
-				call_alias.exec(t, environment, s);
+			if(is_alias.exec(t, env, null, s).getBoolean()) {
+				call_alias.exec(t, env, null, s);
 			} else {
-				run.exec(t, environment, s);
+				run.exec(t, env, null, s);
 			}
 			return CVoid.VOID;
 		}
@@ -1164,7 +1209,7 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			return CVoid.VOID;
 		}
 
@@ -1218,15 +1263,15 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public CArray exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
+		public CArray exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			CArray c = new CArray(t);
 			for(Locale l : Locale.getAvailableLocales()) {
 				if(!l.getCountry().isEmpty()) {
-					c.push(new CString(l.toString(), t), t);
+					c.push(new CString(l.toString(), t), t, env);
 				}
 			}
-			new ArrayHandling.array_sort().exec(t, environment, c);
-			c = new ArrayHandling.array_unique().exec(t, environment, c);
+			new ArrayHandling.array_sort().exec(t, env, null, c);
+			c = new ArrayHandling.array_unique().exec(t, env, null, c);
 			return c;
 
 		}
@@ -1280,12 +1325,12 @@ public Boolean runAsync() {
 		}
 
 		public static long GetEngineBuildDate() {
-			Mixed m = new engine_build_date().exec(Target.UNKNOWN, null);
+			Mixed m = new engine_build_date().exec(Target.UNKNOWN, null, null);
 			return m instanceof CNull ? 0 : ((CInt) m).getInt();
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			JarFile jf;
 			try {
 				String jar = ClassDiscovery.GetClassContainer(Meta.class).toString();
@@ -1341,8 +1386,8 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
-			return new CInt(environment.getEnv(GlobalEnv.class).GetScript().getCompileTime(), t);
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
+			return new CInt(env.getEnv(GlobalEnv.class).GetScript().getCompileTime(), t);
 		}
 
 		@Override
@@ -1386,8 +1431,8 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
-			return new CResource<>(environment, t);
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
+			return new CResource<>(env, t);
 		}
 
 		@Override
@@ -1433,10 +1478,10 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			CArray ret = new CArray(t);
 			for(FileOptions.CompilerOption s : FileOptions.CompilerOption.values()) {
-				ret.push(new CString(s.getName(), t), t);
+				ret.push(new CString(s.getName(), t), t, env);
 			}
 			return ret;
 		}
@@ -1482,10 +1527,10 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			CArray ret = new CArray(t);
 			for(FileOptions.SuppressWarning s : FileOptions.SuppressWarning.values()) {
-				ret.push(new CString(s.getName(), t), t);
+				ret.push(new CString(s.getName(), t), t, env);
 			}
 			return ret;
 		}
@@ -1533,10 +1578,10 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			String name = ArgumentValidation.getString(args[0], t);
 			Mixed setting = args[1];
-			environment.getEnv(GlobalEnv.class).SetRuntimeSetting(name, setting);
+			env.getEnv(GlobalEnv.class).SetRuntimeSetting(name, setting);
 			return CVoid.VOID;
 		}
 
@@ -1586,15 +1631,15 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			String name = ArgumentValidation.getString(args[0], t);
-			GlobalEnv env = environment.getEnv(GlobalEnv.class);
-			if(env.GetRuntimeSetting(name) != null) {
-				env.SetRuntimeSetting(name, null);
+			GlobalEnv gEnv = env.getEnv(GlobalEnv.class);
+			if(gEnv.GetRuntimeSetting(name) != null) {
+				gEnv.SetRuntimeSetting(name, null);
 			} else {
 				if(!ArgumentValidation.getBooleanish(
-						env.GetRuntimeSetting("function.remove_runtime_setting.no_warn_on_removing_blank",
-								CBoolean.FALSE), t)) {
+						gEnv.GetRuntimeSetting("function.remove_runtime_setting.no_warn_on_removing_blank",
+								CBoolean.FALSE), t, env)) {
 					MSLog.GetLogger().e(MSLog.Tags.META, "Attempting to remove a runtime setting that doesn't exist,"
 							+ " '" + name + "'", t);
 				}
@@ -1645,9 +1690,9 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			String name = ArgumentValidation.getString(args[0], t);
-			return CBoolean.get(environment.getEnv(GlobalEnv.class).GetRuntimeSetting(name) != null);
+			return CBoolean.get(env.getEnv(GlobalEnv.class).GetRuntimeSetting(name) != null);
 		}
 
 		@Override
@@ -1691,7 +1736,7 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			throw new Error();
 		}
 
@@ -1768,7 +1813,7 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			return new CString(ClassDiscovery.GetClassContainer(Meta.class).toString(), t);
 		}
 
@@ -1814,21 +1859,21 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
-			SmartComment comment = environment.getEnv(GlobalEnv.class).GetAliasComment();
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
+			SmartComment comment = env.getEnv(GlobalEnv.class).GetAliasComment();
 			if(comment == null) {
 				return CNull.NULL;
 			}
-			CArray ret = CArray.GetAssociativeArray(t);
-			ret.set("body", comment.getBody());
-			CArray annotations = CArray.GetAssociativeArray(t);
-			ret.set("annotations", annotations, t);
+			CArray ret = CArray.GetAssociativeArray(t, null, env);
+			ret.set("body", comment.getBody(), env);
+			CArray annotations = CArray.GetAssociativeArray(t, null, env);
+			ret.set("annotations", annotations, t, env);
 			for(Map.Entry<String, List<String>> entry : comment.getAnnotations().entrySet()) {
 				CArray list = new CArray(t, entry.getValue().size());
 				for(String s : entry.getValue()) {
-					list.push(new CString(s, t), t);
+					list.push(new CString(s, t), t, env);
 				}
-				annotations.set(entry.getKey(), list, t);
+				annotations.set(entry.getKey(), list, t, env);
 			}
 			return ret;
 		}
@@ -1857,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/Minecraft.java b/src/main/java/com/laytonsmith/core/functions/Minecraft.java
index 3cc9ad89c8..bd3aa04adb 100644
--- a/src/main/java/com/laytonsmith/core/functions/Minecraft.java
+++ b/src/main/java/com/laytonsmith/core/functions/Minecraft.java
@@ -38,6 +38,7 @@
 import com.laytonsmith.core.constructs.CNull;
 import com.laytonsmith.core.constructs.CString;
 import com.laytonsmith.core.constructs.CVoid;
+import com.laytonsmith.core.constructs.generics.GenericParameters;
 import com.laytonsmith.core.constructs.Target;
 import com.laytonsmith.core.environments.CommandHelperEnvironment;
 import com.laytonsmith.core.environments.Environment;
@@ -95,9 +96,9 @@ public Integer[] numArgs() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment env, Mixed... args) throws CancelCommandException, ConfigRuntimeException {
-			if(args[0].isInstanceOf(CInt.TYPE)) {
-				return new CInt(ArgumentValidation.getInt(args[0], t), t);
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws CancelCommandException, ConfigRuntimeException {
+			if(args[0].isInstanceOf(CInt.TYPE, null, env)) {
+				return new CInt(ArgumentValidation.getInt(args[0], t, env), t);
 			}
 			String c = args[0].val();
 			MCMaterial mat = StaticLayer.GetMaterial("LEGACY_" + c.toUpperCase());
@@ -225,10 +226,10 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			int i = -1;
 			int i2 = -1;
-			if(args[0].isInstanceOf(CString.TYPE)) {
+			if(args[0].isInstanceOf(CString.TYPE, null, env)) {
 				//We also accept item notation
 				if(args[0].val().contains(":")) {
 					String[] split = args[0].val().split(":");
@@ -240,13 +241,13 @@ public Mixed exec(Target t, Environment environment, Mixed... args) throws Confi
 						throw new CREFormatException("Incorrect format for the item notation: " + args[0].val(), t);
 					}
 				}
-			} else if(args[0].isInstanceOf(CArray.TYPE)) {
+			} else if(args[0].isInstanceOf(CArray.TYPE, null, env)) {
 				MCItemStack is = ObjectGenerator.GetGenerator().item(args[0], t, true);
 				return new CString(is.getType().getName(), t);
 			}
 			if(i == -1) {
 				try {
-					i = ArgumentValidation.getInt32(args[0], t);
+					i = ArgumentValidation.getInt32(args[0], t, env);
 				} catch (CRECastException ex) {
 					// possibly a material name
 					MCMaterial mat = StaticLayer.GetMaterialFromLegacy(args[0].val(), 0);
@@ -309,8 +310,8 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
-			CArray item = ArgumentValidation.getArray(args[0], t);
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
+			CArray item = ArgumentValidation.getArray(args[0], t, env);
 			MCItemStack is = ObjectGenerator.GetGenerator().item(item, t, true);
 			return ObjectGenerator.GetGenerator().item(is, t);
 		}
@@ -357,9 +358,9 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			Mixed id = args[0];
-			if(id.isInstanceOf(CArray.TYPE)) {
+			if(id.isInstanceOf(CArray.TYPE, null, env)) {
 				MCItemStack is = ObjectGenerator.GetGenerator().item(id, t);
 				return new CInt(is.maxStackSize(), t);
 			}
@@ -397,8 +398,8 @@ public ParseTree optimizeDynamic(Target t, Environment env,
 			if(children.size() < 1) {
 				return null;
 			}
-			if(children.get(0).getData().isInstanceOf(CString.TYPE) && children.get(0).getData().val().contains(":")
-					|| ArgumentValidation.isNumber(children.get(0).getData())) {
+			if(children.get(0).isConst() && (children.get(0).getData().isInstanceOf(CString.TYPE, null, env) && children.get(0).getData().val().contains(":")
+					|| ArgumentValidation.isNumber(children.get(0).getData()))) {
 				env.getEnv(CompilerEnvironment.class).addCompilerWarning(fileOptions,
 						new CompilerWarning("Numeric ids are deprecated in " + getName(), t, null));
 			}
@@ -461,9 +462,9 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment env, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			MCPlayer p = env.getEnv(CommandHelperEnvironment.class).GetPlayer();
-			MCLocation l = ObjectGenerator.GetGenerator().location(args[0], p == null ? null : p.getWorld(), t);
+			MCLocation l = ObjectGenerator.GetGenerator().location(args[0], p == null ? null : p.getWorld(), t, env);
 			MCEffect effect;
 			int data = 0;
 			String effectName = args[1].val();
@@ -481,7 +482,7 @@ public Mixed exec(Target t, Environment env, Mixed... args) throws ConfigRuntime
 				return CVoid.VOID;
 			}
 			if(args.length > 2) {
-				radius = ArgumentValidation.getInt32(args[args.length - 1], t);
+				radius = ArgumentValidation.getInt32(args[args.length - 1], t, env);
 			}
 			if(!dataString.isEmpty()) {
 				switch(effect) {
@@ -550,7 +551,7 @@ public ParseTree optimizeDynamic(Target t, Environment env,
 				return null;
 			}
 			Mixed effect = children.get(1).getData();
-			if(effect.isInstanceOf(CString.TYPE)) {
+			if(effect.isInstanceOf(CString.TYPE, null, env)) {
 				String effectName = effect.val().split(":")[0].toUpperCase();
 				try {
 					MCEffect.valueOf(effectName);
@@ -629,13 +630,13 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment env, Mixed... args) throws CancelCommandException, ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws CancelCommandException, ConfigRuntimeException {
 			MCServer server = Static.getServer();
 			int index = -1;
 			if(args.length == 0) {
 				index = -1;
 			} else if(args.length == 1) {
-				index = ArgumentValidation.getInt32(args[0], t);
+				index = ArgumentValidation.getInt32(args[0], t, env);
 			}
 
 			if(index < -1 || index > 16) {
@@ -685,7 +686,7 @@ public Mixed exec(Target t, Environment env, Mixed... args) throws CancelCommand
 						continue;
 					}
 					CString os = new CString(o.getName(), t);
-					co.push(os, t);
+					co.push(os, t, env);
 				}
 				retVals.add(co);
 			}
@@ -703,7 +704,7 @@ public Mixed exec(Target t, Environment env, Mixed... args) throws CancelCommand
 						continue;
 					}
 					CString name = new CString(p.getName(), t);
-					co.push(name, t);
+					co.push(name, t, env);
 				}
 
 				retVals.add(co);
@@ -748,7 +749,7 @@ public Mixed exec(Target t, Environment env, Mixed... args) throws CancelCommand
 
 			CArray ca = new CArray(t);
 			for(Mixed c : retVals) {
-				ca.push(c, t);
+				ca.push(c, t, env);
 			}
 			return ca;
 		}
@@ -793,7 +794,7 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment env, Mixed... args) throws CancelCommandException, ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws CancelCommandException, ConfigRuntimeException {
 			MCServer server = Static.getServer();
 			CArray co = new CArray(t);
 			List<MCOfflinePlayer> so = server.getBannedPlayers();
@@ -802,7 +803,7 @@ public Mixed exec(Target t, Environment env, Mixed... args) throws CancelCommand
 					continue;
 				}
 				CString os = new CString(o.getName(), t);
-				co.push(os, t);
+				co.push(os, t, env);
 			}
 			return co;
 		}
@@ -847,7 +848,7 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment env, Mixed... args) throws CancelCommandException, ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws CancelCommandException, ConfigRuntimeException {
 			MCServer server = Static.getServer();
 			CArray co = new CArray(t);
 			List<MCOfflinePlayer> so = server.getWhitelistedPlayers();
@@ -856,7 +857,7 @@ public Mixed exec(Target t, Environment env, Mixed... args) throws CancelCommand
 					continue;
 				}
 				CString os = new CString(o.getName(), t);
-				co.push(os, t);
+				co.push(os, t, env);
 			}
 			return co;
 		}
@@ -881,13 +882,13 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			MCWorld w = null;
-			MCPlayer p = environment.getEnv(CommandHelperEnvironment.class).GetPlayer();
+			MCPlayer p = env.getEnv(CommandHelperEnvironment.class).GetPlayer();
 			if(p != null) {
 				w = p.getWorld();
 			}
-			MCLocation location = ObjectGenerator.GetGenerator().location(args[0], w, t);
+			MCLocation location = ObjectGenerator.GetGenerator().location(args[0], w, t, env);
 			MCBlockState state = location.getBlock().getState();
 			if(!(state instanceof MCCreatureSpawner)) {
 				throw new CREFormatException("The block at " + location + " is not a spawner block", t);
@@ -941,13 +942,13 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			MCWorld w = null;
-			MCPlayer p = environment.getEnv(CommandHelperEnvironment.class).GetPlayer();
+			MCPlayer p = env.getEnv(CommandHelperEnvironment.class).GetPlayer();
 			if(p != null) {
 				w = p.getWorld();
 			}
-			MCLocation location = ObjectGenerator.GetGenerator().location(args[0], w, t);
+			MCLocation location = ObjectGenerator.GetGenerator().location(args[0], w, t, env);
 			MCBlockState state = location.getBlock().getState();
 			if(!(state instanceof MCCreatureSpawner)) {
 				throw new CREFormatException("The block at " + location + " is not a spawner block", t);
@@ -1010,8 +1011,8 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
-			MCPlayer p = Static.GetPlayer(args[0], t);
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
+			MCPlayer p = Static.GetPlayer(args[0], t, env);
 			p.sendResourcePack(args[1].val());
 			return CVoid.VOID;
 		}
@@ -1060,11 +1061,11 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			MCServer s = Static.getServer();
 			CArray ret = new CArray(t);
 			for(String ip : s.getIPBans()) {
-				ret.push(new CString(ip, t), t);
+				ret.push(new CString(ip, t), t, env);
 			}
 			return ret;
 		}
@@ -1109,10 +1110,10 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			MCServer s = Static.getServer();
 			String ip = args[0].val();
-			if(ArgumentValidation.getBoolean(args[1], t)) {
+			if(ArgumentValidation.getBoolean(args[1], t, env)) {
 				s.banIP(ip);
 			} else {
 				s.unbanIP(ip);
@@ -1151,11 +1152,11 @@ public Class<? extends CREThrowable>[] thrown() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			MCMaterial mat = StaticLayer.GetMaterial(args[0].val());
 			if(mat == null) {
 				try {
-					mat = StaticLayer.GetMaterialFromLegacy(ArgumentValidation.getInt32(args[0], t), 0);
+					mat = StaticLayer.GetMaterialFromLegacy(ArgumentValidation.getInt32(args[0], t, env), 0);
 				} catch (CRECastException ex) {
 					throw new CREIllegalArgumentException("Unable to get the material from: " + args[0].val(), t);
 				}
@@ -1204,23 +1205,23 @@ public Mixed exec(Target t, Environment environment, Mixed... args) throws Confi
 						throw new CREFormatException("Invalid argument for material_info: " + args[1].val(), t);
 				}
 			}
-			CArray ret = CArray.GetAssociativeArray(t);
-			ret.set("maxStacksize", new CInt(mat.getMaxStackSize(), t), t);
-			ret.set("maxDurability", new CInt(mat.getMaxDurability(), t), t);
-			ret.set("hasGravity", CBoolean.get(mat.hasGravity()), t);
-			ret.set("isBlock", CBoolean.get(mat.isBlock()), t);
-			ret.set("isItem", CBoolean.get(mat.isItem()), t);
-			ret.set("isBurnable", CBoolean.get(mat.isBurnable()), t);
-			ret.set("isEdible", CBoolean.get(mat.isEdible()), t);
-			ret.set("isFlammable", CBoolean.get(mat.isFlammable()), t);
-			ret.set("isOccluding", CBoolean.get(mat.isOccluding()), t);
-			ret.set("isRecord", CBoolean.get(mat.isRecord()), t);
-			ret.set("isSolid", CBoolean.get(mat.isSolid()), t);
-			ret.set("isTransparent", CBoolean.get(mat.isTransparent()), t);
-			ret.set("isInteractable", CBoolean.get(mat.isInteractable()), t);
+			CArray ret = CArray.GetAssociativeArray(t, null, env);
+			ret.set("maxStacksize", new CInt(mat.getMaxStackSize(), t), t, env);
+			ret.set("maxDurability", new CInt(mat.getMaxDurability(), t), t, env);
+			ret.set("hasGravity", CBoolean.get(mat.hasGravity()), t, env);
+			ret.set("isBlock", CBoolean.get(mat.isBlock()), t, env);
+			ret.set("isItem", CBoolean.get(mat.isItem()), t, env);
+			ret.set("isBurnable", CBoolean.get(mat.isBurnable()), t, env);
+			ret.set("isEdible", CBoolean.get(mat.isEdible()), t, env);
+			ret.set("isFlammable", CBoolean.get(mat.isFlammable()), t, env);
+			ret.set("isOccluding", CBoolean.get(mat.isOccluding()), t, env);
+			ret.set("isRecord", CBoolean.get(mat.isRecord()), t, env);
+			ret.set("isSolid", CBoolean.get(mat.isSolid()), t, env);
+			ret.set("isTransparent", CBoolean.get(mat.isTransparent()), t, env);
+			ret.set("isInteractable", CBoolean.get(mat.isInteractable()), t, env);
 			if(mat.isBlock()) {
-				ret.set("hardness", new CDouble(mat.getHardness(), t), t);
-				ret.set("blastResistance", new CDouble(mat.getBlastResistance(), t), t);
+				ret.set("hardness", new CDouble(mat.getHardness(), t), t, env);
+				ret.set("blastResistance", new CDouble(mat.getBlastResistance(), t), t, env);
 			}
 			return ret;
 		}
@@ -1267,7 +1268,7 @@ public ParseTree optimizeDynamic(Target t, Environment env,
 			if(children.size() < 1) {
 				return null;
 			}
-			if(ArgumentValidation.isNumber(children.get(0).getData())) {
+			if(children.get(0).isConst() && ArgumentValidation.isNumber(children.get(0).getData())) {
 				env.getEnv(CompilerEnvironment.class).addCompilerWarning(fileOptions,
 						new CompilerWarning("Numeric ids are deprecated in " + getName() + ".", t, null));
 			}
@@ -1319,7 +1320,7 @@ public Version since() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws CancelCommandException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws CancelCommandException {
 			Static.getServer().shutdown();
 			throw new CancelCommandException("", t);
 		}
@@ -1351,16 +1352,16 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			MCWorld world = null;
-			MCPlayer p = environment.getEnv(CommandHelperEnvironment.class).GetPlayer();
+			MCPlayer p = env.getEnv(CommandHelperEnvironment.class).GetPlayer();
 			if(p != null) {
 				world = p.getWorld();
 			}
-			MCLocation location = ObjectGenerator.GetGenerator().location(args[0], world, t);
+			MCLocation location = ObjectGenerator.GetGenerator().location(args[0], world, t, env);
 			boolean add = true;
 			if(args.length > 1) {
-				add = ArgumentValidation.getBoolean(args[1], t);
+				add = ArgumentValidation.getBoolean(args[1], t, env);
 			}
 			Map<MCLocation, Boolean> redstoneMonitors = ServerEvents.getRedstoneMonitors();
 			if(add) {
@@ -1414,10 +1415,10 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			CArray mats = new CArray(t);
 			for(String mat : MCMaterial.types()) {
-				mats.push(new CString(mat, t), t);
+				mats.push(new CString(mat, t), t, env);
 			}
 			return mats;
 		}
@@ -1465,14 +1466,14 @@ public String docs() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			MCCommandSender sender;
 			String selector;
 			if(args.length == 2) {
-				sender = Static.GetPlayer(args[0], t);
+				sender = Static.GetPlayer(args[0], t, env);
 				selector = args[1].val();
 			} else {
-				sender = environment.getEnv(CommandHelperEnvironment.class).GetCommandSender();
+				sender = env.getEnv(CommandHelperEnvironment.class).GetCommandSender();
 				if(sender == null) {
 					throw new CREException("No command sender in this context.", t);
 				}
@@ -1481,7 +1482,7 @@ public Mixed exec(Target t, Environment environment, Mixed... args) throws Confi
 			try {
 				CArray result = new CArray(t);
 				for(UUID id : Static.getServer().selectEntites(sender, selector)) {
-					result.push(new CString(id.toString(), t), t);
+					result.push(new CString(id.toString(), t), t, env);
 				}
 				return result;
 			} catch(IllegalArgumentException ex) {
diff --git a/src/main/java/com/laytonsmith/core/functions/MobManagement.java b/src/main/java/com/laytonsmith/core/functions/MobManagement.java
index a63db86dbf..3245fdb9bf 100644
--- a/src/main/java/com/laytonsmith/core/functions/MobManagement.java
+++ b/src/main/java/com/laytonsmith/core/functions/MobManagement.java
@@ -38,6 +38,7 @@
 import com.laytonsmith.core.constructs.CString;
 import com.laytonsmith.core.constructs.CVoid;
 import com.laytonsmith.core.constructs.Target;
+import com.laytonsmith.core.constructs.generics.GenericParameters;
 import com.laytonsmith.core.environments.CommandHelperEnvironment;
 import com.laytonsmith.core.environments.Environment;
 import com.laytonsmith.core.exceptions.CRE.CREBadEntityException;
@@ -108,7 +109,7 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			MCLivingEntity mob = Static.getLivingEntity(args[0], t);
 			if(!mob.isTameable()) {
 				throw new CREUntameableMobException("The specified entity is not tameable", t);
@@ -164,7 +165,7 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			MCLivingEntity mob = Static.getLivingEntity(args[0], t);
 			if(!mob.isTameable()) {
 				throw new CREUntameableMobException("The specified entity is not tameable", t);
@@ -221,7 +222,7 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			MCLivingEntity mob = Static.getLivingEntity(args[0], t);
 			Mixed player = args[1];
 			if(!mob.isTameable()) {
@@ -279,9 +280,9 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			MCLivingEntity e = Static.getLivingEntity(args[0], t);
-			double percent = ArgumentValidation.getDouble(args[1], t);
+			double percent = ArgumentValidation.getDouble(args[1], t, env);
 			if(percent < 0 || percent > 100) {
 				throw new CRERangeException("Health was expected to be a percentage between 0 and 100", t);
 			} else {
@@ -331,7 +332,7 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			MCLivingEntity e = Static.getLivingEntity(args[0], t);
 			return new CDouble(e.getHealth() / e.getMaxHealth() * 100.0, t);
 		}
@@ -341,7 +342,7 @@ public Mixed exec(Target t, Environment environment, Mixed... args) throws Confi
 	public static class get_entity_breedable extends EntityManagement.EntityGetterFunction {
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			MCEntity ent = Static.getEntity(args[0], t);
 
 			if(ent instanceof MCBreedable) {
@@ -371,8 +372,8 @@ public MSVersion since() {
 	public static class set_entity_breedable extends EntityManagement.EntitySetterFunction {
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
-			boolean breed = ArgumentValidation.getBoolean(args[1], t);
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
+			boolean breed = ArgumentValidation.getBoolean(args[1], t, env);
 
 			MCEntity ent = Static.getEntity(args[0], t);
 
@@ -411,7 +412,7 @@ public Class<? extends CREThrowable>[] thrown() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			MCLivingEntity ent = Static.getLivingEntity(args[0], t);
 			if(ent instanceof MCAgeable mob) {
 				return new CInt(mob.getAge(), t);
@@ -447,11 +448,11 @@ public Class<? extends CREThrowable>[] thrown() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
-			int age = ArgumentValidation.getInt32(args[1], t);
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
+			int age = ArgumentValidation.getInt32(args[1], t, env);
 			boolean lock = false;
 			if(args.length == 3) {
-				lock = ArgumentValidation.getBoolean(args[2], t);
+				lock = ArgumentValidation.getBoolean(args[2], t, env);
 			}
 			MCLivingEntity ent = Static.getLivingEntity(args[0], t);
 			if(ent instanceof MCAgeable mob) {
@@ -498,7 +499,7 @@ public Class<? extends CREThrowable>[] thrown() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			MCLivingEntity ent = Static.getLivingEntity(args[0], t);
 			if(ent instanceof MCAnimal animal) {
 				return new CInt(animal.getLoveTicks(), t);
@@ -533,9 +534,9 @@ public Class<? extends CREThrowable>[] thrown() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			MCLivingEntity ent = Static.getLivingEntity(args[0], t);
-			int ticks = ArgumentValidation.getInt32(args[1], t);
+			int ticks = ArgumentValidation.getInt32(args[1], t, env);
 			if(ent instanceof MCAnimal animal) {
 				animal.setLoveTicks(ticks);
 				return CVoid.VOID;
@@ -564,7 +565,7 @@ public MSVersion since() {
 	public static class get_mob_effects extends EntityManagement.EntityGetterFunction {
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			MCLivingEntity mob = Static.getLivingEntity(args[0], t);
 			return ObjectGenerator.GetGenerator().potions(mob.getEffects(), t);
 		}
@@ -629,11 +630,11 @@ public Class<? extends CREThrowable>[] thrown() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment env, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			MCLivingEntity mob = Static.getLivingEntity(args[0], t);
 
 			MCPotionEffectType type = null;
-			if(args[1].isInstanceOf(CString.TYPE)) {
+			if(args[1].isInstanceOf(CString.TYPE, null, env)) {
 				try {
 					type = MCPotionEffectType.valueOf(args[1].val().toUpperCase());
 				} catch (IllegalArgumentException ex) {
@@ -642,7 +643,7 @@ public Mixed exec(Target t, Environment env, Mixed... args) throws ConfigRuntime
 			}
 			if(type == null) {
 				try {
-					type = MCPotionEffectType.getById(ArgumentValidation.getInt32(args[1], t));
+					type = MCPotionEffectType.getById(ArgumentValidation.getInt32(args[1], t, env));
 				} catch (IllegalArgumentException ex) {
 					throw new CREFormatException("Invalid potion effect type: " + args[1].val(), t);
 				}
@@ -654,22 +655,22 @@ public Mixed exec(Target t, Environment env, Mixed... args) throws ConfigRuntime
 			boolean particles = true;
 			boolean icon = true;
 			if(args.length >= 3) {
-				strength = ArgumentValidation.getInt32(args[2], t);
+				strength = ArgumentValidation.getInt32(args[2], t, env);
 
 				if(args.length >= 4) {
-					seconds = ArgumentValidation.getDouble(args[3], t);
+					seconds = ArgumentValidation.getDouble(args[3], t, env);
 					if(seconds * 20 > Integer.MAX_VALUE) {
 						throw new CRERangeException("Seconds cannot be greater than 107374182.0", t);
 					}
 
 					if(args.length >= 5) {
-						ambient = ArgumentValidation.getBoolean(args[4], t);
+						ambient = ArgumentValidation.getBoolean(args[4], t, env);
 
 						if(args.length >= 6) {
-							particles = ArgumentValidation.getBoolean(args[5], t);
+							particles = ArgumentValidation.getBoolean(args[5], t, env);
 
 							if(args.length == 7) {
-								icon = ArgumentValidation.getBoolean(args[6], t);
+								icon = ArgumentValidation.getBoolean(args[6], t, env);
 							}
 						}
 					}
@@ -693,7 +694,7 @@ public MSVersion since() {
 	public static class get_mob_target extends EntityManagement.EntityGetterFunction {
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			MCLivingEntity le = Static.getLivingEntity(args[0], t);
 			if(le.getTarget(t) == null) {
 				return CNull.NULL;
@@ -728,7 +729,7 @@ public Class<? extends CREThrowable>[] thrown() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			MCLivingEntity le = Static.getLivingEntity(args[0], t);
 			MCLivingEntity target = null;
 			if(!(args[1] instanceof CNull)) {
@@ -760,16 +761,16 @@ public MSVersion since() {
 	public static class get_mob_equipment extends EntityManagement.EntityGetterFunction {
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			MCLivingEntity le = Static.getLivingEntity(args[0], t);
 			MCEntityEquipment eq = le.getEquipment();
 			if(eq == null) {
 				throw new CREBadEntityTypeException("Entities of type \"" + le.getType() + "\" do not have equipment.", t);
 			}
 			Map<MCEquipmentSlot, MCItemStack> eqmap = eq.getAllEquipment();
-			CArray ret = CArray.GetAssociativeArray(t);
+			CArray ret = CArray.GetAssociativeArray(t, null, env);
 			for(MCEquipmentSlot key : eqmap.keySet()) {
-				ret.set(key.name().toLowerCase(), ObjectGenerator.GetGenerator().item(eqmap.get(key), t), t);
+				ret.set(key.name().toLowerCase(), ObjectGenerator.GetGenerator().item(eqmap.get(key), t), t, env);
 			}
 			return ret;
 		}
@@ -809,7 +810,7 @@ public MSVersion since() {
 	public static class set_mob_equipment extends EntityManagement.EntitySetterFunction {
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			MCLivingEntity le = Static.getLivingEntity(args[0], t);
 			MCEntityEquipment ee = le.getEquipment();
 			if(ee == null) {
@@ -820,7 +821,7 @@ public Mixed exec(Target t, Environment environment, Mixed... args) throws Confi
 				return CVoid.VOID;
 			}
 			Map<MCEquipmentSlot, MCItemStack> eq = ee.getAllEquipment();
-			if(args[1].isInstanceOf(CArray.TYPE)) {
+			if(args[1].isInstanceOf(CArray.TYPE, null, env)) {
 				CArray ea = (CArray) args[1];
 				for(String key : ea.stringKeySet()) {
 					try {
@@ -870,7 +871,7 @@ public MSVersion since() {
 	public static class get_max_health extends EntityManagement.EntityGetterFunction {
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			MCLivingEntity le = Static.getLivingEntity(args[0], t);
 			return new CDouble(le.getMaxHealth(), t);
 		}
@@ -895,9 +896,9 @@ public MSVersion since() {
 	public static class set_max_health extends EntityManagement.EntitySetterFunction {
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			MCLivingEntity le = Static.getLivingEntity(args[0], t);
-			le.setMaxHealth(ArgumentValidation.getDouble(args[1], t));
+			le.setMaxHealth(ArgumentValidation.getDouble(args[1], t, env));
 			return CVoid.VOID;
 		}
 
@@ -929,7 +930,7 @@ public MSVersion since() {
 	public static class get_equipment_droprates extends EntityManagement.EntityGetterFunction {
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			MCLivingEntity le = Static.getLivingEntity(args[0], t);
 			if(le instanceof MCPlayer || le instanceof MCArmorStand) {
 				throw new CREBadEntityException(getName() + "() does not work on type: " + le.getType(), t);
@@ -938,9 +939,9 @@ public Mixed exec(Target t, Environment environment, Mixed... args) throws Confi
 			if(eq == null) {
 				throw new CREBadEntityTypeException("Entities of type \"" + le.getType() + "\" do not have equipment.", t);
 			}
-			CArray ret = CArray.GetAssociativeArray(t);
+			CArray ret = CArray.GetAssociativeArray(t, null, env);
 			for(Map.Entry<MCEquipmentSlot, Float> ent : eq.getAllDropChances().entrySet()) {
-				ret.set(ent.getKey().name().toLowerCase(), new CDouble(ent.getValue(), t), t);
+				ret.set(ent.getKey().name().toLowerCase(), new CDouble(ent.getValue(), t), t, env);
 			}
 			return ret;
 		}
@@ -968,7 +969,7 @@ public MSVersion since() {
 	public static class set_equipment_droprates extends EntityManagement.EntitySetterFunction {
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			MCLivingEntity le = Static.getLivingEntity(args[0], t);
 			if(le instanceof MCPlayer || le instanceof MCArmorStand) {
 				throw new CREBadEntityException(getName() + "() does not work on type: " + le.getType(), t);
@@ -982,7 +983,7 @@ public Mixed exec(Target t, Environment environment, Mixed... args) throws Confi
 				for(Map.Entry<MCEquipmentSlot, Float> ent : eq.entrySet()) {
 					eq.put(ent.getKey(), 0F);
 				}
-			} else if(args[1].isInstanceOf(CArray.TYPE)) {
+			} else if(args[1].isInstanceOf(CArray.TYPE, null, env)) {
 				CArray ea = (CArray) args[1];
 				for(String key : ea.stringKeySet()) {
 					try {
@@ -1022,7 +1023,7 @@ public MSVersion since() {
 	public static class can_pickup_items extends EntityManagement.EntityGetterFunction {
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			return CBoolean.get(Static.getLivingEntity(args[0], t).getCanPickupItems());
 		}
 
@@ -1046,8 +1047,8 @@ public MSVersion since() {
 	public static class set_can_pickup_items extends EntityManagement.EntitySetterFunction {
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
-			Static.getLivingEntity(args[0], t).setCanPickupItems(ArgumentValidation.getBoolean(args[1], t));
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
+			Static.getLivingEntity(args[0], t).setCanPickupItems(ArgumentValidation.getBoolean(args[1], t, env));
 			return CVoid.VOID;
 		}
 
@@ -1071,7 +1072,7 @@ public MSVersion since() {
 	public static class get_entity_persistence extends EntityManagement.EntityGetterFunction {
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			return CBoolean.get(!Static.getLivingEntity(args[0], t).getRemoveWhenFarAway());
 		}
 
@@ -1095,8 +1096,8 @@ public MSVersion since() {
 	public static class set_entity_persistence extends EntityManagement.EntitySetterFunction {
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
-			Static.getLivingEntity(args[0], t).setRemoveWhenFarAway(!ArgumentValidation.getBoolean(args[1], t));
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
+			Static.getLivingEntity(args[0], t).setRemoveWhenFarAway(!ArgumentValidation.getBoolean(args[1], t, env));
 			return CVoid.VOID;
 		}
 
@@ -1120,7 +1121,7 @@ public MSVersion since() {
 	public static class get_leashholder extends EntityManagement.EntityGetterFunction {
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			MCEntity e = Static.getEntity(args[0], t);
 			if(!(e instanceof MCLeashable)) {
 				throw new CREBadEntityException("Entity type is not leashable.", t);
@@ -1153,7 +1154,7 @@ public MSVersion since() {
 	public static class set_leashholder extends EntityManagement.EntitySetterFunction {
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			MCEntity e = Static.getEntity(args[0], t);
 			MCEntity holder;
 			if(args[1] instanceof CNull) {
@@ -1201,7 +1202,7 @@ public String docs() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			return new CInt(Static.getLivingEntity(args[0], t).getRemainingAir(), t);
 		}
 
@@ -1225,8 +1226,8 @@ public String docs() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
-			Static.getLivingEntity(args[0], t).setRemainingAir(ArgumentValidation.getInt32(args[1], t));
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
+			Static.getLivingEntity(args[0], t).setRemainingAir(ArgumentValidation.getInt32(args[1], t, env));
 			return CVoid.VOID;
 		}
 
@@ -1250,7 +1251,7 @@ public String docs() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			return new CInt(Static.getLivingEntity(args[0], t).getMaximumAir(), t);
 		}
 
@@ -1274,8 +1275,8 @@ public String docs() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
-			Static.getLivingEntity(args[0], t).setMaximumAir(ArgumentValidation.getInt32(args[1], t));
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
+			Static.getLivingEntity(args[0], t).setMaximumAir(ArgumentValidation.getInt32(args[1], t, env));
 			return CVoid.VOID;
 		}
 
@@ -1313,17 +1314,17 @@ public String docs() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			MCLivingEntity entity = Static.getLivingEntity(args[0], t);
 			HashSet<MCMaterial> transparents = null;
 			int maxDistance = 512;
 			if(args.length >= 2) {
-				CArray givenTransparents = ArgumentValidation.getArray(args[1], t);
+				CArray givenTransparents = ArgumentValidation.getArray(args[1], t, env);
 				if(givenTransparents.inAssociativeMode()) {
 					throw new CRECastException("The array must not be associative.", t);
 				}
 				transparents = new HashSet<>();
-				for(Mixed mat : givenTransparents.asList()) {
+				for(Mixed mat : givenTransparents.asList(env)) {
 					MCMaterial material = StaticLayer.GetMaterial(mat.val());
 					if(material != null) {
 						transparents.add(StaticLayer.GetMaterial(mat.val()));
@@ -1344,11 +1345,11 @@ public Mixed exec(Target t, Environment environment, Mixed... args) throws Confi
 				}
 			}
 			if(args.length == 3) {
-				maxDistance = ArgumentValidation.getInt32(args[2], t);
+				maxDistance = ArgumentValidation.getInt32(args[2], t, env);
 			}
 			CArray lineOfSight = new CArray(t);
 			for(MCBlock block : entity.getLineOfSight(transparents, maxDistance)) {
-				lineOfSight.push(ObjectGenerator.GetGenerator().location(block.getLocation(), false), t);
+				lineOfSight.push(ObjectGenerator.GetGenerator().location(block.getLocation(), false), t, env);
 			}
 			return lineOfSight;
 		}
@@ -1387,7 +1388,7 @@ public String docs() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			return CBoolean.get(Static.getLivingEntity(args[0], t).hasLineOfSight(Static.getEntity(args[1], t)));
 		}
 
@@ -1407,7 +1408,7 @@ public Class<? extends CREThrowable>[] thrown() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			MCEntity entity = Static.getEntity(args[0], t);
 
 			if(!(entity instanceof MCLivingEntity)) {
@@ -1417,7 +1418,7 @@ public Mixed exec(Target t, Environment environment, Mixed... args) throws Confi
 
 			MCLivingEntity living = (MCLivingEntity) entity;
 
-			double damage = ArgumentValidation.getDouble(args[1], t);
+			double damage = ArgumentValidation.getDouble(args[1], t, env);
 			if(args.length == 3) {
 				MCEntity source = Static.getEntity(args[2], t);
 				living.damage(damage, source);
@@ -1464,9 +1465,9 @@ public String docs() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			MCLivingEntity e = Static.getLivingEntity(args[0], t);
-			boolean glide = ArgumentValidation.getBoolean(args[1], t);
+			boolean glide = ArgumentValidation.getBoolean(args[1], t, env);
 
 			e.setGliding(glide);
 
@@ -1493,7 +1494,7 @@ public String docs() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			return CBoolean.GenerateCBoolean(Static.getLivingEntity(args[0], t).isGliding(), t);
 		}
 
@@ -1517,7 +1518,7 @@ public String docs() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			return CBoolean.GenerateCBoolean(Static.getLivingEntity(args[0], t).hasAI(), t);
 		}
 
@@ -1541,9 +1542,9 @@ public String docs() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			MCLivingEntity e = Static.getLivingEntity(args[0], t);
-			boolean ai = ArgumentValidation.getBoolean(args[1], t);
+			boolean ai = ArgumentValidation.getBoolean(args[1], t, env);
 
 			e.setAI(ai);
 
@@ -1570,7 +1571,7 @@ public String docs() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			return CBoolean.GenerateCBoolean(Static.getLivingEntity(args[0], t).isCollidable(), t);
 		}
 
@@ -1594,9 +1595,9 @@ public String docs() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			MCLivingEntity e = Static.getLivingEntity(args[0], t);
-			boolean collidable = ArgumentValidation.getBoolean(args[1], t);
+			boolean collidable = ArgumentValidation.getBoolean(args[1], t, env);
 			e.setCollidable(collidable);
 			return CVoid.VOID;
 		}
@@ -1644,7 +1645,7 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			MCLivingEntity e = Static.getLivingEntity(args[0], t);
 			MCAttribute attribute;
 			try {
@@ -1701,7 +1702,7 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			MCLivingEntity e = Static.getLivingEntity(args[0], t);
 			MCAttribute attribute;
 			try {
@@ -1758,7 +1759,7 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			MCLivingEntity e = Static.getLivingEntity(args[0], t);
 			MCAttribute attribute;
 			try {
@@ -1815,7 +1816,7 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			MCLivingEntity e = Static.getLivingEntity(args[0], t);
 			MCAttribute attribute;
 			try {
@@ -1826,7 +1827,7 @@ public Mixed exec(Target t, Environment environment, Mixed... args) throws Confi
 			try {
 				CArray ret = new CArray(t);
 				for(MCAttributeModifier m : e.getAttributeModifiers(attribute)) {
-					ret.push(ObjectGenerator.GetGenerator().attributeModifier(m, t), t);
+					ret.push(ObjectGenerator.GetGenerator().attributeModifier(m, t), t, env);
 				}
 				return ret;
 			} catch (IllegalArgumentException ex) {
@@ -1877,7 +1878,7 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			MCLivingEntity e = Static.getLivingEntity(args[0], t);
 			MCAttribute attribute;
 			try {
@@ -1885,7 +1886,7 @@ public Mixed exec(Target t, Environment environment, Mixed... args) throws Confi
 			} catch (IllegalArgumentException ex) {
 				throw new CREFormatException("Invalid attribute name: " + args[1].val(), t);
 			}
-			double base = ArgumentValidation.getDouble(args[2], t);
+			double base = ArgumentValidation.getDouble(args[2], t, env);
 			try {
 				e.setAttributeBase(attribute, base);
 			} catch (IllegalArgumentException ex) {
@@ -1936,7 +1937,7 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			MCLivingEntity e = Static.getLivingEntity(args[0], t);
 			MCAttribute attribute;
 			try {
@@ -1995,9 +1996,9 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			MCLivingEntity e = Static.getLivingEntity(args[0], t);
-			MCAttributeModifier modifier = ObjectGenerator.GetGenerator().attributeModifier(ArgumentValidation.getArray(args[1], t), t);
+			MCAttributeModifier modifier = ObjectGenerator.GetGenerator().attributeModifier(ArgumentValidation.getArray(args[1], t, env), t);
 			try {
 				e.addAttributeModifier(modifier);
 			} catch (IllegalArgumentException ex) {
@@ -2048,11 +2049,11 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			MCLivingEntity e = Static.getLivingEntity(args[0], t);
 			MCAttributeModifier modifier = null;
 			if(args.length == 2) {
-				modifier = ObjectGenerator.GetGenerator().attributeModifier(ArgumentValidation.getArray(args[1], t), t);
+				modifier = ObjectGenerator.GetGenerator().attributeModifier(ArgumentValidation.getArray(args[1], t, env), t);
 			} else {
 				MCAttribute attribute;
 				try {
@@ -2131,7 +2132,7 @@ public String docs() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			return new CInt(Static.getLivingEntity(args[0], t).getNoDamageTicks(), t);
 		}
 
@@ -2155,8 +2156,8 @@ public String docs() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
-			Static.getLivingEntity(args[0], t).setNoDamageTicks(ArgumentValidation.getInt32(args[1], t));
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
+			Static.getLivingEntity(args[0], t).setNoDamageTicks(ArgumentValidation.getInt32(args[1], t, env));
 			return CVoid.VOID;
 		}
 
@@ -2181,7 +2182,7 @@ public String docs() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			return CBoolean.get(Static.getLivingEntity(args[0], t).isSleeping());
 		}
 
diff --git a/src/main/java/com/laytonsmith/core/functions/OAuth.java b/src/main/java/com/laytonsmith/core/functions/OAuth.java
index b576bde393..99c1af4a23 100644
--- a/src/main/java/com/laytonsmith/core/functions/OAuth.java
+++ b/src/main/java/com/laytonsmith/core/functions/OAuth.java
@@ -20,6 +20,7 @@
 import com.laytonsmith.core.constructs.CVoid;
 import com.laytonsmith.core.constructs.Construct;
 import com.laytonsmith.core.constructs.Target;
+import com.laytonsmith.core.constructs.generics.GenericParameters;
 import com.laytonsmith.core.environments.Environment;
 import com.laytonsmith.core.environments.StaticRuntimeEnv;
 import com.laytonsmith.core.exceptions.CRE.CREFormatException;
@@ -116,7 +117,7 @@ CArray toOptionsArray() {
 		}
 
 		public static String execute(Environment env, OAuthOptions options) {
-			return new x_get_oauth_token().exec(Target.UNKNOWN, env, options.toOptionsArray()).val();
+			return new x_get_oauth_token().exec(Target.UNKNOWN, env, null, options.toOptionsArray()).val();
 		}
 
 		@Override
@@ -135,35 +136,35 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, com.laytonsmith.core.environments.Environment env, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, com.laytonsmith.core.environments.Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			// TODO: Make this part support profiles
-			CArray options = ArgumentValidation.getArray(args[0], t);
-			String authorizationUrl = options.get("authorizationUrl", t).val();
-			String tokenUrl = options.get("tokenUrl", t).val();
-			String clientId = options.get("clientId", t).val();
-			String clientSecret = options.get("clientSecret", t).val();
-			String scope = options.get("scope", t).val();
-			String successText = Construct.nval(options.get("successText", t));
+			CArray options = ArgumentValidation.getArray(args[0], t, env);
+			String authorizationUrl = options.get("authorizationUrl", t, env).val();
+			String tokenUrl = options.get("tokenUrl", t, env).val();
+			String clientId = options.get("clientId", t, env).val();
+			String clientSecret = options.get("clientSecret", t, env).val();
+			String scope = options.get("scope", t, env).val();
+			String successText = Construct.nval(options.get("successText", t, env));
 			CArray extraHeaders1 = null;
 			if(options.containsKey("extraHeaders")) {
-				extraHeaders1 = ArgumentValidation.getArray(options.get("extraHeaders", t), t);
+				extraHeaders1 = ArgumentValidation.getArray(options.get("extraHeaders", t, env), t, env);
 			}
 			Map<String, String> extraHeaders = new HashMap<>();
 			if(extraHeaders1 != null) {
 				for(String key : extraHeaders1.stringKeySet()) {
-					extraHeaders.put(key, extraHeaders1.get(key, t).val());
+					extraHeaders.put(key, extraHeaders1.get(key, t, env).val());
 				}
 			}
 			Integer forcePort = null;
 			if(options.containsKey("forcePort")) {
-				forcePort = ArgumentValidation.getInt32(options.get("forcePort", t), t);
+				forcePort = ArgumentValidation.getInt32(options.get("forcePort", t, env), t, env);
 			}
 			try { // Persistence errors
 				String accessToken = getAccessToken(env, clientId);
 				if(accessToken == null) {
 					try {
 						if(options.containsKey("refreshToken")) {
-							String refreshToken = options.get("refreshToken", t).val();
+							String refreshToken = options.get("refreshToken", t, env).val();
 							storeRefreshToken(env, clientId, refreshToken);
 						}
 						String refreshToken;
@@ -179,7 +180,7 @@ public Mixed exec(Target t, com.laytonsmith.core.environments.Environment env, M
 							}
 							String requestURI = generateRequestURI(authorizationUrl, clientId, scope, redirectUrl,
 									extraHeaders);
-							new XGUI.x_launch_browser().exec(t, env, new CString(requestURI, t));
+							new XGUI.x_launch_browser().exec(t, env, null, new CString(requestURI, t));
 							synchronized(lock) {
 								if(lock.getObject() == null) {
 									lock.wait();
@@ -207,14 +208,14 @@ public Mixed exec(Target t, com.laytonsmith.core.environments.Environment env, M
 							switch(responseType) {
 								case "application/json": {
 									CArray tokenJson = (CArray) new DataTransformations.json_decode()
-											.exec(t, env, new CString(tokenResponse.getContentAsString(), t));
+											.exec(t, env, null, new CString(tokenResponse.getContentAsString(), t));
 									if(tokenJson.containsKey("refresh_token")) {
-										storeRefreshToken(env, clientId, tokenJson.get("refresh_token", t).val());
+										storeRefreshToken(env, clientId, tokenJson.get("refresh_token", t, env).val());
 									}
-									accessToken = tokenJson.get("access_token", t).val();
+									accessToken = tokenJson.get("access_token", t, env).val();
 									int expiresIn;
 									if(tokenJson.containsKey("expires_in")) {
-										expiresIn = ArgumentValidation.getInt32(tokenJson.get("expires_in", t), t) * 1000;
+										expiresIn = ArgumentValidation.getInt32(tokenJson.get("expires_in", t, env), t, env) * 1000;
 									} else {
 										expiresIn = Integer.MAX_VALUE;
 									}
@@ -246,9 +247,9 @@ public Mixed exec(Target t, com.laytonsmith.core.environments.Environment env, M
 							tokenParameters.put("grant_type", "refresh_token");
 							settings.setParameters(tokenParameters);
 							HTTPResponse tokenResponse = WebUtility.GetPage(new URL(tokenUrl), settings);
-							CArray tokenJson = (CArray) new DataTransformations.json_decode().exec(t, env, new CString(tokenResponse.getContentAsString(), t));
-							accessToken = tokenJson.get("access_token", t).val();
-							storeAccessToken(env, clientId, new AccessToken(accessToken, ArgumentValidation.getInt32(tokenJson.get("expires_in", t), t) * 1000));
+							CArray tokenJson = (CArray) new DataTransformations.json_decode().exec(t, env, null, new CString(tokenResponse.getContentAsString(), t));
+							accessToken = tokenJson.get("access_token", t, env).val();
+							storeAccessToken(env, clientId, new AccessToken(accessToken, ArgumentValidation.getInt32(tokenJson.get("expires_in", t, env), t, env) * 1000));
 						}
 					} catch (InterruptedException ex) {
 						return CNull.NULL;
@@ -500,7 +501,7 @@ public static void execute(Environment env, String clientId) {
 			if(clientId != null) {
 				args = new Mixed[]{new CString(clientId, Target.UNKNOWN)};
 			}
-			new clear_oauth_tokens().exec(Target.UNKNOWN, env, args);
+			new clear_oauth_tokens().exec(Target.UNKNOWN, env, null, args);
 		}
 
 		@Override
@@ -519,13 +520,13 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
-			PersistenceNetwork pn = environment.getEnv(StaticRuntimeEnv.class).GetPersistenceNetwork();
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
+			PersistenceNetwork pn = env.getEnv(StaticRuntimeEnv.class).GetPersistenceNetwork();
 			String namespace = "oauth";
 			if(args.length >= 1) {
 				namespace += "." + x_get_oauth_token.getFormattedClientId(args[0].val());
 			}
-			DaemonManager dm = environment.getEnv(StaticRuntimeEnv.class).GetDaemonManager();
+			DaemonManager dm = env.getEnv(StaticRuntimeEnv.class).GetDaemonManager();
 			try {
 				Map<String[], String> list = pn.getNamespace(namespace.split("\\."));
 				for(String[] key : list.keySet()) {
diff --git a/src/main/java/com/laytonsmith/core/functions/OS.java b/src/main/java/com/laytonsmith/core/functions/OS.java
index ebed196878..c8307db6c8 100644
--- a/src/main/java/com/laytonsmith/core/functions/OS.java
+++ b/src/main/java/com/laytonsmith/core/functions/OS.java
@@ -6,6 +6,7 @@
 import com.laytonsmith.core.MSVersion;
 import com.laytonsmith.core.constructs.CInt;
 import com.laytonsmith.core.constructs.Target;
+import com.laytonsmith.core.constructs.generics.GenericParameters;
 import com.laytonsmith.core.environments.Environment;
 import com.laytonsmith.core.exceptions.CRE.CREThrowable;
 import com.laytonsmith.core.exceptions.CRE.CREUnsupportedOperationException;
@@ -41,7 +42,7 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			try {
 				return new CInt(OSUtils.GetMyPid(), t);
 			} catch (UnsupportedOperationException ex) {
diff --git a/src/main/java/com/laytonsmith/core/functions/ObjectManagement.java b/src/main/java/com/laytonsmith/core/functions/ObjectManagement.java
index 2a6a3c7d76..4d5ae8da58 100644
--- a/src/main/java/com/laytonsmith/core/functions/ObjectManagement.java
+++ b/src/main/java/com/laytonsmith/core/functions/ObjectManagement.java
@@ -8,10 +8,13 @@
 import com.laytonsmith.core.ArgumentValidation;
 import com.laytonsmith.core.natives.interfaces.Callable;
 import com.laytonsmith.core.FullyQualifiedClassName;
+import com.laytonsmith.core.FlowFunction;
 import com.laytonsmith.core.MSVersion;
 import com.laytonsmith.core.Optimizable;
 import com.laytonsmith.core.ParseTree;
-import com.laytonsmith.core.Script;
+import com.laytonsmith.core.StepAction.Complete;
+import com.laytonsmith.core.StepAction.Evaluate;
+import com.laytonsmith.core.StepAction.StepResult;
 import com.laytonsmith.core.UnqualifiedClassName;
 import com.laytonsmith.core.compiler.CompilerEnvironment;
 import com.laytonsmith.core.compiler.FileOptions;
@@ -24,6 +27,7 @@
 import com.laytonsmith.core.constructs.CVoid;
 import com.laytonsmith.core.constructs.NativeTypeList;
 import com.laytonsmith.core.constructs.Target;
+import com.laytonsmith.core.constructs.generics.GenericParameters;
 import com.laytonsmith.core.environments.Environment;
 import com.laytonsmith.core.environments.GlobalEnv;
 import com.laytonsmith.core.exceptions.CRE.CREClassDefinitionError;
@@ -80,7 +84,7 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			throw new UnsupportedOperationException("Not supported yet."); //To change body of generated methods, choose Tools | Templates.
 		}
 
@@ -108,7 +112,7 @@ public Version since() {
 
 	@api
 	@hide("Not meant for normal use")
-	public static class define_object extends AbstractFunction implements Optimizable {
+	public static class define_object extends AbstractFunction implements FlowFunction<Void>, Optimizable {
 
 		@Override
 		public Class<? extends CREThrowable>[] thrown() {
@@ -126,13 +130,19 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public boolean useSpecialExec() {
-			return true;
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
+			throw new Error();
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
-			throw new Error();
+		public StepResult<Void> begin(Target t, ParseTree[] children, Environment env) {
+			doDefineObject(t, env, children);
+			return new StepResult<>(new Complete(CVoid.VOID), null);
+		}
+
+		@Override
+		public StepResult<Void> childCompleted(Target t, Void state, Mixed result, Environment env) {
+			throw new Error("define_object does not evaluate children");
 		}
 
 		/**
@@ -168,17 +178,17 @@ private CArray evaluateArrayNoNull(ParseTree data, String component, Target t) {
 			return (CArray) d;
 		}
 
-		private Mixed evaluateString(ParseTree data, Target t) {
+		private Mixed evaluateString(ParseTree data, Target t, Environment env) {
 			if(data.getData() instanceof CNull) {
 				return CNull.NULL;
 			}
-			if(!(data.getData().isInstanceOf(CString.TYPE))) {
+			if(!(data.getData().isInstanceOf(CString.TYPE, null, env))) {
 				throw new CREClassDefinitionError("Expected a string, but found " + data.getData() + " instead", t);
 			}
 			return data.getData();
 		}
-		private CString evaluateStringNoNull(ParseTree data, Target t) {
-			Mixed d = evaluateString(data, t);
+		private CString evaluateStringNoNull(ParseTree data, Target t, Environment env) {
+			Mixed d = evaluateString(data, t, env);
 			if(d instanceof CNull) {
 				throw new CREClassDefinitionError("Expected a string, but found null instead", t);
 			}
@@ -197,7 +207,7 @@ private Mixed evaluateMixed(ParseTree data, Target t) {
 					throw new CREClassDefinitionError("Expected __to_class_reference__, but found " + data.getData()
 							+ " instead", t);
 				}
-				return new __to_class_reference__().exec(t, null,
+				return new __to_class_reference__().exec(t, null, null,
 						data.getChildren().stream()
 								.map((parseTree -> parseTree.getData()))
 								.collect(Collectors.toList())
@@ -206,10 +216,10 @@ private Mixed evaluateMixed(ParseTree data, Target t) {
 			return data.getData();
 		}
 
-		@Override
-		public Mixed execs(Target t, Environment env, Script parent, ParseTree... nodes) {
+
+		private void doDefineObject(Target t, Environment env, ParseTree... nodes) {
 			// 0 - Access Modifier
-			AccessModifier accessModifier = ArgumentValidation.getEnum(evaluateStringNoNull(nodes[0], t),
+			AccessModifier accessModifier = ArgumentValidation.getEnum(evaluateStringNoNull(nodes[0], t, env),
 					AccessModifier.class, t);
 
 			// 1 - Object Modifiers
@@ -218,11 +228,11 @@ public Mixed execs(Target t, Environment env, Script parent, ParseTree... nodes)
 					.collect(Collectors.toSet());
 
 			// 2 - Object Type
-			ObjectType type = ArgumentValidation.getEnum(evaluateStringNoNull(nodes[2], t), ObjectType.class, t);
+			ObjectType type = ArgumentValidation.getEnum(evaluateStringNoNull(nodes[2], t, env), ObjectType.class, t);
 
 			// 3 - Object Name
 			FullyQualifiedClassName name
-					= FullyQualifiedClassName.forFullyQualifiedClass(evaluateStringNoNull(nodes[3], t).val());
+					= FullyQualifiedClassName.forFullyQualifiedClass(evaluateStringNoNull(nodes[3], t, env).val());
 
 			// 4 - Superclasses
 			Set<UnqualifiedClassName> superclasses = new HashSet<>();
@@ -371,7 +381,6 @@ public Mixed execs(Target t, Environment env, Script parent, ParseTree... nodes)
 				}
 			}
 
-			return CVoid.VOID;
 		}
 
 		@Override
@@ -379,8 +388,7 @@ public ParseTree optimizeDynamic(Target t, Environment env,
 				Set<Class<? extends Environment.EnvironmentImpl>> envs,
 				List<ParseTree> children, FileOptions fileOptions)
 				throws ConfigCompileException, ConfigRuntimeException {
-			// Do the same thing as execs, but remove this call
-			execs(t, env, null, children.toArray(new ParseTree[children.size()]));
+			doDefineObject(t, env, children.toArray(new ParseTree[children.size()]));
 			return REMOVE_ME;
 		}
 
@@ -425,7 +433,7 @@ public Set<OptimizationOption> optimizationOptions() {
 
 	@api
 	@hide("Normally one should use the new keyword")
-	public static class new_object extends AbstractFunction implements Optimizable {
+	public static class new_object extends AbstractFunction implements FlowFunction<new_object.NewObjectState>, Optimizable {
 
 		@Override
 		public Class<? extends CREThrowable>[] thrown() {
@@ -443,12 +451,7 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public boolean useSpecialExec() {
-			return true;
-		}
-
-		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			throw new Error();
 		}
 
@@ -459,18 +462,25 @@ public Mixed exec(Target t, Environment environment, Mixed... args) throws Confi
 		private static final int DEFAULT = -1;
 		private static final int UNDECIDEABLE = -2;
 
+		static class NewObjectState {
+			ParseTree[] children;
+			Callable constructor;
+			Mixed obj;
+			Mixed[] constructorArgs;
+			int nextArgIndex;
+		}
+
 		@Override
-		public Mixed execs(final Target t, final Environment env, Script parent, ParseTree... args)
-				throws ConfigRuntimeException {
+		public StepResult<NewObjectState> begin(Target t, ParseTree[] children, Environment env) {
 			ObjectDefinitionTable odt = env.getEnv(CompilerEnvironment.class).getObjectDefinitionTable();
-			CClassType clazz = ((CClassType) args[0].getData());
+			CClassType clazz = ((CClassType) children[0].getData());
 			ObjectDefinition od;
 			try {
 				od = odt.get(clazz.getFQCN());
-			} catch (ObjectDefinitionNotFoundException ex) {
+			} catch(ObjectDefinitionNotFoundException ex) {
 				throw new CREClassDefinitionError(ex.getMessage(), t, ex);
 			}
-			int constructorId = (int) ((CInt) args[1].getData()).getInt();
+			int constructorId = (int) ((CInt) children[1].getData()).getInt();
 			Callable constructor;
 			switch(constructorId) {
 				case DEFAULT:
@@ -495,17 +505,39 @@ public Mixed execs(final Target t, final Environment env, Script parent, ParseTr
 				// TODO If this is a native object, we need to intercept the call to the native constructor,
 				// and grab the object generated there.
 			}
-			Mixed obj = new UserObject(t, parent, env, od, null);
+			Mixed obj = new UserObject(t, null, env, od, null);
+
+			NewObjectState state = new NewObjectState();
+			state.children = children;
+			state.constructor = constructor;
+			state.obj = obj;
+
 			// This is the MethodScript construction.
 			if(constructor != null) {
-				Mixed[] values = new Mixed[args.length - 1];
-				values[0] = obj;
-				for(int i = 2; i < args.length; i++) {
-					values[i + 1] = parent.eval(args[i], env);
+				state.constructorArgs = new Mixed[children.length - 1];
+				state.constructorArgs[0] = obj;
+				if(children.length > 2) {
+					state.nextArgIndex = 2;
+					return new StepResult<>(new Evaluate(children[2]), state);
 				}
-				constructor.executeCallable(env, t, values);
+				constructor.executeCallable(env, t, state.constructorArgs);
+			}
+
+			return new StepResult<>(new Complete(obj), state);
+		}
+
+		@Override
+		public StepResult<NewObjectState> childCompleted(Target t, NewObjectState state,
+				Mixed result, Environment env) {
+			state.constructorArgs[state.nextArgIndex - 1] = result;
+			state.nextArgIndex++;
+
+			if(state.nextArgIndex < state.children.length) {
+				return new StepResult<>(new Evaluate(state.children[state.nextArgIndex]), state);
 			}
-			return obj;
+
+			state.constructor.executeCallable(env, t, state.constructorArgs);
+			return new StepResult<>(new Complete(state.obj), state);
 		}
 
 		@Override
@@ -597,7 +629,7 @@ public Class<? extends CREThrowable>[] thrown() {
 
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			try {
 				return CClassType.get(FullyQualifiedClassName.forFullyQualifiedClass(args[0].val()));
 			} catch (ClassNotFoundException ex) {
diff --git a/src/main/java/com/laytonsmith/core/functions/Performance.java b/src/main/java/com/laytonsmith/core/functions/Performance.java
index 38adac62bd..d4bac0aac4 100644
--- a/src/main/java/com/laytonsmith/core/functions/Performance.java
+++ b/src/main/java/com/laytonsmith/core/functions/Performance.java
@@ -7,6 +7,7 @@
 import com.laytonsmith.core.Static;
 import com.laytonsmith.core.constructs.CVoid;
 import com.laytonsmith.core.constructs.Target;
+import com.laytonsmith.core.constructs.generics.GenericParameters;
 import com.laytonsmith.core.environments.Environment;
 import com.laytonsmith.core.exceptions.CRE.CRESecurityException;
 import com.laytonsmith.core.exceptions.CRE.CREThrowable;
@@ -83,7 +84,7 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			if(!Prefs.AllowProfiling()) {
 				throw new CRESecurityException("allow-profiling is currently off, you must set it to true in your preferences.", t);
 			}
diff --git a/src/main/java/com/laytonsmith/core/functions/Permissions.java b/src/main/java/com/laytonsmith/core/functions/Permissions.java
index e90b3e6474..28f0f4e32c 100644
--- a/src/main/java/com/laytonsmith/core/functions/Permissions.java
+++ b/src/main/java/com/laytonsmith/core/functions/Permissions.java
@@ -7,6 +7,7 @@
 import com.laytonsmith.core.Static;
 import com.laytonsmith.core.constructs.CBoolean;
 import com.laytonsmith.core.constructs.Target;
+import com.laytonsmith.core.constructs.generics.GenericParameters;
 import com.laytonsmith.core.environments.CommandHelperEnvironment;
 import com.laytonsmith.core.environments.Environment;
 import com.laytonsmith.core.environments.GlobalEnv;
@@ -70,21 +71,21 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 
 			MCCommandSender sender;
 			String permission;
 
 			if(args.length == 1) {
-				sender = environment.getEnv(CommandHelperEnvironment.class).GetCommandSender();
+				sender = env.getEnv(CommandHelperEnvironment.class).GetCommandSender();
 				permission = args[0].val();
 			} else {
 				sender = Static.GetCommandSender(args[0].val(), t);
 				permission = args[1].val();
 
-				MCPlayer mcp = environment.getEnv(CommandHelperEnvironment.class).GetPlayer();
+				MCPlayer mcp = env.getEnv(CommandHelperEnvironment.class).GetPlayer();
 				if(mcp != null && !mcp.getName().equals(args[0].val())) {
-					if(!Static.hasCHPermission(getName(), environment)) {
+					if(!Static.hasCHPermission(getName(), env)) {
 						throw new CREInsufficientPermissionException("You do not have permission to use the " + getName() + " function.", t);
 					}
 				}
diff --git a/src/main/java/com/laytonsmith/core/functions/Persistence.java b/src/main/java/com/laytonsmith/core/functions/Persistence.java
index 1d3e7804e5..22acc95dc8 100644
--- a/src/main/java/com/laytonsmith/core/functions/Persistence.java
+++ b/src/main/java/com/laytonsmith/core/functions/Persistence.java
@@ -15,6 +15,7 @@
 import com.laytonsmith.core.constructs.CVoid;
 import com.laytonsmith.core.constructs.Construct;
 import com.laytonsmith.core.constructs.Target;
+import com.laytonsmith.core.constructs.generics.GenericParameters;
 import com.laytonsmith.core.environments.Environment;
 import com.laytonsmith.core.environments.GlobalEnv;
 import com.laytonsmith.core.environments.StaticRuntimeEnv;
@@ -91,11 +92,11 @@ public MSVersion since() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment env, Mixed... args) throws CancelCommandException, ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws CancelCommandException, ConfigRuntimeException {
 			String key = GetNamespace(args, args.length - 1, getName(), t);
 			String value = null;
 			try {
-				value = Construct.json_encode(args[args.length - 1], t);
+				value = Construct.json_encode(args[args.length - 1], t, env);
 			} catch (MarshalException e) {
 				throw new CREFormatException(e.getMessage(), t);
 			}
@@ -174,7 +175,7 @@ public MSVersion since() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment env, Mixed... args) throws CancelCommandException, ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws CancelCommandException, ConfigRuntimeException {
 			Object o;
 			String namespace = GetNamespace(args, null, getName(), t);
 			MSLog.GetLogger().Log(MSLog.Tags.PERSISTENCE, LogLevel.DEBUG, "Getting value: " + namespace, t);
@@ -264,8 +265,8 @@ public ExampleScript[] examples() throws ConfigCompileException {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
-			PersistenceNetwork p = environment.getEnv(StaticRuntimeEnv.class).GetPersistenceNetwork();
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
+			PersistenceNetwork p = env.getEnv(StaticRuntimeEnv.class).GetPersistenceNetwork();
 			List<String> keyChain = new ArrayList<String>();
 			keyChain.add("storage");
 			String namespace = GetNamespace(args, null, getName(), t);
@@ -345,7 +346,7 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment env, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			try {
 				return CBoolean.get(env.getEnv(StaticRuntimeEnv.class).GetPersistenceNetwork()
 						.hasKey(("storage." + GetNamespace(args, null, getName(), t)).split("\\.")));
@@ -403,12 +404,12 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			String namespace = GetNamespace(args, null, getName(), t);
 			MSLog.GetLogger().Log(MSLog.Tags.PERSISTENCE, LogLevel.DEBUG, "Clearing value: " + namespace, t);
 			try {
-				environment.getEnv(StaticRuntimeEnv.class).GetPersistenceNetwork().clearKey(
-						environment.getEnv(StaticRuntimeEnv.class).GetDaemonManager(),
+				env.getEnv(StaticRuntimeEnv.class).GetPersistenceNetwork().clearKey(
+						env.getEnv(StaticRuntimeEnv.class).GetDaemonManager(),
 						("storage." + namespace).split("\\."));
 			} catch (DataSourceException | ReadOnlyException | IOException ex) {
 				throw new CREIOException(ex.getMessage(), t, ex);
diff --git a/src/main/java/com/laytonsmith/core/functions/PlayerManagement.java b/src/main/java/com/laytonsmith/core/functions/PlayerManagement.java
index 21acb4dd87..2cef8ec119 100644
--- a/src/main/java/com/laytonsmith/core/functions/PlayerManagement.java
+++ b/src/main/java/com/laytonsmith/core/functions/PlayerManagement.java
@@ -60,6 +60,7 @@
 import com.laytonsmith.core.constructs.CVoid;
 import com.laytonsmith.core.constructs.Construct;
 import com.laytonsmith.core.constructs.Target;
+import com.laytonsmith.core.constructs.generics.GenericParameters;
 import com.laytonsmith.core.environments.CommandHelperEnvironment;
 import com.laytonsmith.core.environments.Environment;
 import com.laytonsmith.core.environments.GlobalEnv;
@@ -119,11 +120,11 @@ public Integer[] numArgs() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment env, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			MCCommandSender p = env.getEnv(CommandHelperEnvironment.class).GetCommandSender();
 
 			if(args.length == 1) {
-				p = Static.GetPlayer(args[0], t);
+				p = Static.GetPlayer(args[0], t, env);
 			}
 
 			// assuming p is not null, just return the name set by the CommandSender
@@ -197,18 +198,18 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
-			MCOfflinePlayer pl = environment.getEnv(CommandHelperEnvironment.class).GetPlayer();
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
+			MCOfflinePlayer pl = env.getEnv(CommandHelperEnvironment.class).GetPlayer();
 			boolean dashless = false;
 			if(args.length >= 1) {
 				try {
-					pl = Static.GetPlayer(args[0], t);
+					pl = Static.GetPlayer(args[0], t, env);
 				} catch (ConfigRuntimeException cre) {
 					pl = Static.GetUser(args[0], t);
 				}
 			}
 			if(args.length == 2) {
-				dashless = ArgumentValidation.getBoolean(args[1], t);
+				dashless = ArgumentValidation.getBoolean(args[1], t, env);
 			}
 			if(pl == null) {
 				throw new CREPlayerOfflineException("No matching player could be found.", t);
@@ -262,11 +263,11 @@ public Integer[] numArgs() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment env, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			CArray players = new CArray(t);
 			if(args.length == 0) {
 				for(MCPlayer player : Static.getServer().getOnlinePlayers()) {
-					players.push(new CString(player.getName(), t), t);
+					players.push(new CString(player.getName(), t), t, env);
 				}
 			} else {
 				MCWorld world = Static.getServer().getWorld(args[0].val());
@@ -275,7 +276,7 @@ public Mixed exec(Target t, Environment env, Mixed... args) throws ConfigRuntime
 				}
 				for(MCPlayer player : world.getPlayers()) {
 					if(player.isOnline()) {
-						players.push(new CString(player.getName(), t), t);
+						players.push(new CString(player.getName(), t), t, env);
 					}
 				}
 			}
@@ -359,7 +360,7 @@ boolean inRadius(MCPlayer player, double dist, MCLocation loc) {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment env, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			Collection<MCPlayer> pa = Static.getServer().getOnlinePlayers();
 			MCPlayer p = env.getEnv(CommandHelperEnvironment.class).GetPlayer();
 
@@ -367,23 +368,23 @@ public Mixed exec(Target t, Environment env, Mixed... args) throws ConfigRuntime
 			double dist;
 
 			if(args.length == 1) {
-				dist = ArgumentValidation.getDouble(args[0], t);
+				dist = ArgumentValidation.getDouble(args[0], t, env);
 				Static.AssertPlayerNonNull(p, t);
 				loc = p.getLocation();
 			} else {
-				if(!(args[0].isInstanceOf(CArray.TYPE))) {
+				if(!(args[0].isInstanceOf(CArray.TYPE, null, env))) {
 					throw new CRECastException("Expecting an array at parameter 1 of players_in_radius", t);
 				}
 
-				loc = ObjectGenerator.GetGenerator().location(args[0], p != null ? p.getWorld() : null, t);
-				dist = ArgumentValidation.getDouble(args[1], t);
+				loc = ObjectGenerator.GetGenerator().location(args[0], p != null ? p.getWorld() : null, t, env);
+				dist = ArgumentValidation.getDouble(args[1], t, env);
 			}
 
 			CArray sa = new CArray(t);
 
 			for(MCPlayer pa1 : pa) {
 				if(inRadius(pa1, dist, loc)) {
-					sa.push(new CString(pa1.getName(), t), t);
+					sa.push(new CString(pa1.getName(), t), t, env);
 				}
 			}
 
@@ -431,13 +432,13 @@ public Integer[] numArgs() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment env, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			MCPlayer p;
 			if(args.length == 0) {
 				p = env.getEnv(CommandHelperEnvironment.class).GetPlayer();
 				Static.AssertPlayerNonNull(p, t);
 			} else {
-				p = Static.GetPlayer(args[0], t);
+				p = Static.GetPlayer(args[0], t, env);
 			}
 			MCLocation location = p.getLocation();
 			if(location == null) {
@@ -521,22 +522,22 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment env, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			MCPlayer p = env.getEnv(CommandHelperEnvironment.class).GetPlayer();
 			MCLocation l;
 			if(args.length <= 2) {
-				if(!(args[args.length - 1].isInstanceOf(CArray.TYPE))) {
+				if(!(args[args.length - 1].isInstanceOf(CArray.TYPE, null, env))) {
 					throw new CRECastException("Expecting an array at parameter " + args.length + " of set_ploc", t);
 				}
 				CArray ca = (CArray) args[args.length - 1];
 
 				if(args.length == 2) {
-					p = Static.GetPlayer(args[0], t);
+					p = Static.GetPlayer(args[0], t, env);
 				} else {
 					Static.AssertPlayerNonNull(p, t);
 				}
 
-				l = ObjectGenerator.GetGenerator().location(ca, p.getWorld(), t);
+				l = ObjectGenerator.GetGenerator().location(ca, p.getWorld(), t, env);
 
 				// set yaw/pitch to current player values if not given
 				MCLocation ploc = p.getLocation();
@@ -547,20 +548,20 @@ public Mixed exec(Target t, Environment env, Mixed... args) throws ConfigRuntime
 					if(!(ca.containsKey("pitch"))) {
 						l.setPitch(ploc.getPitch());
 					}
-				} else if(ca.size() < 5) {
+				} else if(ca.size(env) < 5) {
 					l.setYaw(ploc.getYaw());
 					l.setPitch(ploc.getPitch());
 				}
 			} else {
 				if(args.length == 4) {
-					p = Static.GetPlayer(args[0], t);
+					p = Static.GetPlayer(args[0], t, env);
 				} else {
 					Static.AssertPlayerNonNull(p, t);
 				}
 
-				double x = ArgumentValidation.getNumber(args[args.length - 3], t);
-				double y = ArgumentValidation.getNumber(args[args.length - 2], t);
-				double z = ArgumentValidation.getNumber(args[args.length - 1], t);
+				double x = ArgumentValidation.getNumber(args[args.length - 3], t, env);
+				double y = ArgumentValidation.getNumber(args[args.length - 2], t, env);
+				double z = ArgumentValidation.getNumber(args[args.length - 1], t, env);
 				float yaw = 0;
 				float pitch = 0;
 				MCLocation ploc = p.getLocation();
@@ -621,19 +622,19 @@ public MSVersion since() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment env, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			MCPlayer p = env.getEnv(CommandHelperEnvironment.class).GetPlayer();
 			HashSet<MCMaterial> trans = null;
 			int transparentIndex = -1;
 			if(args.length == 1) {
-				if(args[0].isInstanceOf(CArray.TYPE)) {
+				if(args[0].isInstanceOf(CArray.TYPE, null, env)) {
 					transparentIndex = 0;
 				} else {
-					p = Static.GetPlayer(args[0], t);
+					p = Static.GetPlayer(args[0], t, env);
 				}
 			} else if(args.length == 2) {
-				p = Static.GetPlayer(args[0], t);
-				if(args[1].isInstanceOf(CArray.TYPE)) {
+				p = Static.GetPlayer(args[0], t, env);
+				if(args[1].isInstanceOf(CArray.TYPE, null, env)) {
 					transparentIndex = 1;
 				} else {
 					throw new CREFormatException("An array was expected for argument 2 but received " + args[1], t);
@@ -642,7 +643,7 @@ public Mixed exec(Target t, Environment env, Mixed... args) throws ConfigRuntime
 			if(transparentIndex >= 0) {
 				CArray ta = (CArray) args[transparentIndex];
 				trans = new HashSet<>();
-				for(Mixed mat : ta.asList()) {
+				for(Mixed mat : ta.asList(env)) {
 					MCMaterial material = StaticLayer.GetMaterial(mat.val());
 					if(material != null) {
 						trans.add(StaticLayer.GetMaterial(mat.val()));
@@ -720,10 +721,10 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
-			MCPlayer p = environment.getEnv(CommandHelperEnvironment.class).GetPlayer();
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
+			MCPlayer p = env.getEnv(CommandHelperEnvironment.class).GetPlayer();
 			if(args.length > 0) {
-				p = Static.GetPlayer(args[0], t);
+				p = Static.GetPlayer(args[0], t, env);
 			}
 			Static.AssertPlayerNonNull(p, t);
 			MCBlock b = p.getTargetSpace(512);
@@ -770,11 +771,11 @@ public Integer[] numArgs() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment env, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			MCCommandSender p = env.getEnv(CommandHelperEnvironment.class).GetCommandSender();
 			MCPlayer m = null;
 			if(args.length == 1) {
-				m = Static.GetPlayer(args[0], t);
+				m = Static.GetPlayer(args[0], t, env);
 			} else {
 				if(p instanceof MCPlayer) {
 					m = (MCPlayer) p;
@@ -825,7 +826,7 @@ public Integer[] numArgs() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment env, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			MCCommandSender sender;
 			if(args.length == 0) {
 				sender = env.getEnv(CommandHelperEnvironment.class).GetCommandSender();
@@ -836,7 +837,7 @@ public Mixed exec(Target t, Environment env, Mixed... args) throws ConfigRuntime
 			CArray ret = new CArray(t);
 			if(sender != null) {
 				for(String group : sender.getGroups()) {
-					ret.push(new CString(group, t), t);
+					ret.push(new CString(group, t), t, env);
 				}
 			}
 			return ret;
@@ -938,7 +939,7 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment env, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			MCCommandSender m = env.getEnv(CommandHelperEnvironment.class).GetCommandSender();
 			String player;
 			int index;
@@ -950,9 +951,9 @@ public Mixed exec(Target t, Environment env, Mixed... args) throws ConfigRuntime
 				index = -1;
 			} else {
 				player = args[0].val();
-				index = ArgumentValidation.getInt32(args[1], t);
+				index = ArgumentValidation.getInt32(args[1], t, env);
 			}
-			MCPlayer p = Static.GetPlayer(player, t);
+			MCPlayer p = Static.GetPlayer(player, t, env);
 
 			Static.AssertPlayerNonNull(p, t);
 			int maxIndex = 20;
@@ -1026,7 +1027,7 @@ public Mixed exec(Target t, Environment env, Mixed... args) throws ConfigRuntime
 				//MCPlayer groups
 				CArray a = new CArray(t);
 				for(String group : p.getGroups()) {
-					a.push(new CString(group, t), t);
+					a.push(new CString(group, t), t, env);
 				}
 				retVals.add(a);
 			}
@@ -1079,7 +1080,7 @@ public Mixed exec(Target t, Environment env, Mixed... args) throws ConfigRuntime
 			} else {
 				CArray ca = new CArray(t);
 				for(Mixed c : retVals) {
-					ca.push(c, t);
+					ca.push(c, t, env);
 				}
 				return ca;
 			}
@@ -1126,7 +1127,7 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment env, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			MCCommandSender p = env.getEnv(CommandHelperEnvironment.class).GetCommandSender();
 			MCPlayer m = null;
 			if(args.length == 0) {
@@ -1134,7 +1135,7 @@ public Mixed exec(Target t, Environment env, Mixed... args) throws ConfigRuntime
 					m = (MCPlayer) p;
 				}
 			} else {
-				m = Static.GetPlayer(args[0], t);
+				m = Static.GetPlayer(args[0], t, env);
 			}
 			Static.AssertPlayerNonNull(m, t);
 			return new CString(m.getWorld().getName(), t);
@@ -1182,7 +1183,7 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment env, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			MCCommandSender p = env.getEnv(CommandHelperEnvironment.class).GetCommandSender();
 			String message = "You have been kicked";
 			MCPlayer m = null;
@@ -1192,7 +1193,7 @@ public Mixed exec(Target t, Environment env, Mixed... args) throws ConfigRuntime
 				}
 			}
 			if(args.length >= 1) {
-				m = Static.GetPlayer(args[0], t);
+				m = Static.GetPlayer(args[0], t, env);
 			}
 			if(args.length >= 2) {
 				message = args[1].val();
@@ -1264,13 +1265,13 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment env, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			MCPlayer m;
 			if(args.length == 0) {
 				m = env.getEnv(CommandHelperEnvironment.class).GetPlayer();
 				Static.AssertPlayerNonNull(m, t);
 			} else {
-				m = Static.GetPlayer(args[0].val(), t);
+				m = Static.GetPlayer(args[0].val(), t, env);
 			}
 			return new CString(m.getDisplayName(), t);
 		}
@@ -1338,7 +1339,7 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment env, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			MCPlayer player;
 			String name;
 			if(args.length == 1) {
@@ -1346,7 +1347,7 @@ public Mixed exec(Target t, Environment env, Mixed... args) throws ConfigRuntime
 				Static.AssertPlayerNonNull(player, t);
 				name = args[0].val();
 			} else {
-				player = Static.GetPlayer(args[0], t);
+				player = Static.GetPlayer(args[0], t, env);
 				name = args[1].val();
 			}
 			player.setDisplayName(name);
@@ -1415,13 +1416,13 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment env, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			MCPlayer player;
 			if(args.length == 0) {
 				player = env.getEnv(CommandHelperEnvironment.class).GetPlayer();
 				Static.AssertPlayerNonNull(player, t);
 			} else {
-				player = Static.GetPlayer(args[0], t);
+				player = Static.GetPlayer(args[0], t, env);
 			}
 			player.setDisplayName(player.getName());
 			return CVoid.VOID;
@@ -1485,7 +1486,7 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment env, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			MCCommandSender p = env.getEnv(CommandHelperEnvironment.class).GetCommandSender();
 			//Getter
 			if(args.length == 0 || args.length == 1) {
@@ -1496,8 +1497,8 @@ public Mixed exec(Target t, Environment env, Mixed... args) throws ConfigRuntime
 					}
 				} else {
 					//if it's a number, we are setting F. Otherwise, it's a getter for the MCPlayer specified.
-					if(!(args[0].isInstanceOf(CInt.TYPE))) {
-						MCPlayer p2 = Static.GetPlayer(args[0], t);
+					if(!(args[0].isInstanceOf(CInt.TYPE, null, env))) {
+						MCPlayer p2 = Static.GetPlayer(args[0], t, env);
 						l = p2.getLocation();
 					}
 				}
@@ -1526,7 +1527,7 @@ public Mixed exec(Target t, Environment env, Mixed... args) throws ConfigRuntime
 					}
 					pitch = loc.getPitch();
 				}
-				int g = ArgumentValidation.getInt32(args[0], t);
+				int g = ArgumentValidation.getInt32(args[0], t, env);
 				if(g < 0 || g > 3) {
 					throw new CRERangeException("The F specifed must be from 0 to 3", t);
 				}
@@ -1535,17 +1536,17 @@ public Mixed exec(Target t, Environment env, Mixed... args) throws ConfigRuntime
 				//Either we are setting this MCPlayer's pitch and yaw, or we are setting the specified MCPlayer's F.
 				//Check to see if args[0] is a number
 				try {
-					yaw = (float) ArgumentValidation.getNumber(args[0], t);
-					pitch = (float) ArgumentValidation.getNumber(args[1], t);
+					yaw = (float) ArgumentValidation.getNumber(args[0], t, env);
+					pitch = (float) ArgumentValidation.getNumber(args[1], t, env);
 					//It's the yaw, pitch variation
 					if(p instanceof MCPlayer) {
 						toSet = (MCPlayer) p;
 					}
 				} catch (CRECastException e) {
 					//It's the MCPlayer, F variation
-					toSet = Static.GetPlayer(args[0], t);
+					toSet = Static.GetPlayer(args[0], t, env);
 					pitch = toSet.getLocation().getPitch();
-					int g = ArgumentValidation.getInt32(args[1], t);
+					int g = ArgumentValidation.getInt32(args[1], t, env);
 					if(g < 0 || g > 3) {
 						throw new CRERangeException("The F specifed must be from 0 to 3", t);
 					}
@@ -1553,9 +1554,9 @@ public Mixed exec(Target t, Environment env, Mixed... args) throws ConfigRuntime
 				}
 			} else if(args.length == 3) {
 				//It's the MCPlayer, yaw, pitch variation
-				toSet = Static.GetPlayer(args[0], t);
-				yaw = (float) ArgumentValidation.getNumber(args[1], t);
-				pitch = (float) ArgumentValidation.getNumber(args[2], t);
+				toSet = Static.GetPlayer(args[0], t, env);
+				yaw = (float) ArgumentValidation.getNumber(args[1], t, env);
+				pitch = (float) ArgumentValidation.getNumber(args[2], t, env);
 			}
 
 			//Error check our data
@@ -1624,14 +1625,14 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment env, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			MCCommandSender p = env.getEnv(CommandHelperEnvironment.class).GetCommandSender();
 			MCPlayer m = null;
 			if(p instanceof MCPlayer) {
 				m = (MCPlayer) p;
 			}
 			if(args.length == 1) {
-				m = Static.GetPlayer(args[0], t);
+				m = Static.GetPlayer(args[0], t, env);
 			}
 
 			Static.AssertPlayerNonNull(m, t);
@@ -1685,7 +1686,7 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment env, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			MCCommandSender p = env.getEnv(CommandHelperEnvironment.class).GetCommandSender();
 			MCPlayer m = null;
 			String mode;
@@ -1694,7 +1695,7 @@ public Mixed exec(Target t, Environment env, Mixed... args) throws ConfigRuntime
 				m = (MCPlayer) p;
 			}
 			if(args.length == 2) {
-				m = Static.GetPlayer(args[0], t);
+				m = Static.GetPlayer(args[0], t, env);
 				mode = args[1].val();
 			} else {
 				mode = args[0].val();
@@ -1750,14 +1751,14 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment env, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			MCCommandSender p = env.getEnv(CommandHelperEnvironment.class).GetCommandSender();
 			MCPlayer m = null;
 			if(p instanceof MCPlayer) {
 				m = (MCPlayer) p;
 			}
 			if(args.length == 1) {
-				m = Static.GetPlayer(args[0].val(), t);
+				m = Static.GetPlayer(args[0].val(), t, env);
 			}
 			Static.AssertPlayerNonNull(m, t);
 			return new CInt(java.lang.Math.round(m.getExp() * 100), t);
@@ -1804,7 +1805,7 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment env, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			MCCommandSender p = env.getEnv(CommandHelperEnvironment.class).GetCommandSender();
 			MCPlayer m = null;
 			int xp;
@@ -1812,10 +1813,10 @@ public Mixed exec(Target t, Environment env, Mixed... args) throws ConfigRuntime
 				m = (MCPlayer) p;
 			}
 			if(args.length == 2) {
-				m = Static.GetPlayer(args[0].val(), t);
-				xp = ArgumentValidation.getInt32(args[1], t);
+				m = Static.GetPlayer(args[0].val(), t, env);
+				xp = ArgumentValidation.getInt32(args[1], t, env);
 			} else {
-				xp = ArgumentValidation.getInt32(args[0], t);
+				xp = ArgumentValidation.getInt32(args[0], t, env);
 			}
 			Static.AssertPlayerNonNull(m, t);
 			if(xp < 0 || xp > 100) {
@@ -1865,18 +1866,18 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
-			MCCommandSender p = environment.getEnv(CommandHelperEnvironment.class).GetCommandSender();
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
+			MCCommandSender p = env.getEnv(CommandHelperEnvironment.class).GetCommandSender();
 			MCPlayer m = null;
 			int xp;
 			if(p instanceof MCPlayer) {
 				m = (MCPlayer) p;
 			}
 			if(args.length == 2) {
-				m = Static.GetPlayer(args[0].val(), t);
-				xp = ArgumentValidation.getInt32(args[1], t);
+				m = Static.GetPlayer(args[0].val(), t, env);
+				xp = ArgumentValidation.getInt32(args[1], t, env);
 			} else {
-				xp = ArgumentValidation.getInt32(args[0], t);
+				xp = ArgumentValidation.getInt32(args[0], t, env);
 			}
 			Static.AssertPlayerNonNull(m, t);
 			m.giveExp(xp);
@@ -1924,14 +1925,14 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment env, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			MCCommandSender p = env.getEnv(CommandHelperEnvironment.class).GetCommandSender();
 			MCPlayer m = null;
 			if(p instanceof MCPlayer) {
 				m = (MCPlayer) p;
 			}
 			if(args.length == 1) {
-				m = Static.GetPlayer(args[0].val(), t);
+				m = Static.GetPlayer(args[0].val(), t, env);
 			}
 			Static.AssertPlayerNonNull(m, t);
 			return new CInt(m.getLevel(), t);
@@ -1977,7 +1978,7 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment env, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			MCCommandSender p = env.getEnv(CommandHelperEnvironment.class).GetCommandSender();
 			MCPlayer m = null;
 			int level;
@@ -1985,10 +1986,10 @@ public Mixed exec(Target t, Environment env, Mixed... args) throws ConfigRuntime
 				m = (MCPlayer) p;
 			}
 			if(args.length == 2) {
-				m = Static.GetPlayer(args[0].val(), t);
-				level = ArgumentValidation.getInt32(args[1], t);
+				m = Static.GetPlayer(args[0].val(), t, env);
+				level = ArgumentValidation.getInt32(args[1], t, env);
 			} else {
-				level = ArgumentValidation.getInt32(args[0], t);
+				level = ArgumentValidation.getInt32(args[0], t, env);
 			}
 			Static.AssertPlayerNonNull(m, t);
 			m.setLevel(level);
@@ -2035,14 +2036,14 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment env, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			MCCommandSender p = env.getEnv(CommandHelperEnvironment.class).GetCommandSender();
 			MCPlayer m = null;
 			if(p instanceof MCPlayer) {
 				m = (MCPlayer) p;
 			}
 			if(args.length == 1) {
-				m = Static.GetPlayer(args[0].val(), t);
+				m = Static.GetPlayer(args[0].val(), t, env);
 			}
 			Static.AssertPlayerNonNull(m, t);
 			int texp = m.getExpAtLevel() + java.lang.Math.round(m.getExpToLevel() * m.getExp());
@@ -2089,7 +2090,7 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment env, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			MCCommandSender p = env.getEnv(CommandHelperEnvironment.class).GetCommandSender();
 			MCPlayer m = null;
 			int xp;
@@ -2097,10 +2098,10 @@ public Mixed exec(Target t, Environment env, Mixed... args) throws ConfigRuntime
 				m = (MCPlayer) p;
 			}
 			if(args.length == 2) {
-				m = Static.GetPlayer(args[0].val(), t);
-				xp = ArgumentValidation.getInt32(args[1], t);
+				m = Static.GetPlayer(args[0].val(), t, env);
+				xp = ArgumentValidation.getInt32(args[1], t, env);
 			} else {
-				xp = ArgumentValidation.getInt32(args[0], t);
+				xp = ArgumentValidation.getInt32(args[0], t, env);
 			}
 			if(xp < 0) {
 				throw new CRERangeException("Experience can't be negative", t);
@@ -2154,14 +2155,14 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment env, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			MCCommandSender p = env.getEnv(CommandHelperEnvironment.class).GetCommandSender();
 			MCPlayer m = null;
 			if(p instanceof MCPlayer) {
 				m = (MCPlayer) p;
 			}
 			if(args.length == 1) {
-				m = Static.GetPlayer(args[0].val(), t);
+				m = Static.GetPlayer(args[0].val(), t, env);
 			}
 			Static.AssertPlayerNonNull(m, t);
 			return new CInt(m.getFoodLevel(), t);
@@ -2207,7 +2208,7 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment env, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			MCCommandSender p = env.getEnv(CommandHelperEnvironment.class).GetCommandSender();
 			MCPlayer m = null;
 			int level;
@@ -2215,10 +2216,10 @@ public Mixed exec(Target t, Environment env, Mixed... args) throws ConfigRuntime
 				m = (MCPlayer) p;
 			}
 			if(args.length == 2) {
-				m = Static.GetPlayer(args[0].val(), t);
-				level = ArgumentValidation.getInt32(args[1], t);
+				m = Static.GetPlayer(args[0].val(), t, env);
+				level = ArgumentValidation.getInt32(args[1], t, env);
 			} else {
-				level = ArgumentValidation.getInt32(args[0], t);
+				level = ArgumentValidation.getInt32(args[0], t, env);
 			}
 			Static.AssertPlayerNonNull(m, t);
 			m.setFoodLevel(level);
@@ -2277,11 +2278,11 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment env, Mixed... args) throws ConfigRuntimeException {
-			MCPlayer m = Static.GetPlayer(args[0].val(), t);
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
+			MCPlayer m = Static.GetPlayer(args[0].val(), t, env);
 
 			MCPotionEffectType type = null;
-			if(args[1].isInstanceOf(CString.TYPE)) {
+			if(args[1].isInstanceOf(CString.TYPE, null, env)) {
 				try {
 					type = MCPotionEffectType.valueOf(args[1].val().toUpperCase());
 				} catch (IllegalArgumentException ex) {
@@ -2290,7 +2291,7 @@ public Mixed exec(Target t, Environment env, Mixed... args) throws ConfigRuntime
 			}
 			if(type == null) {
 				try {
-					type = MCPotionEffectType.getById(ArgumentValidation.getInt32(args[1], t));
+					type = MCPotionEffectType.getById(ArgumentValidation.getInt32(args[1], t, env));
 				} catch (CRECastException | IllegalArgumentException ex) {
 					throw new CREFormatException("Invalid potion effect type: " + args[1].val(), t);
 				}
@@ -2302,22 +2303,22 @@ public Mixed exec(Target t, Environment env, Mixed... args) throws ConfigRuntime
 			boolean particles = true;
 			boolean icon = true;
 			if(args.length >= 3) {
-				strength = ArgumentValidation.getInt32(args[2], t);
+				strength = ArgumentValidation.getInt32(args[2], t, env);
 
 				if(args.length >= 4) {
-					seconds = ArgumentValidation.getDouble(args[3], t);
+					seconds = ArgumentValidation.getDouble(args[3], t, env);
 					if(seconds * 20 > Integer.MAX_VALUE) {
 						throw new CRERangeException("Seconds cannot be greater than 107374182.0", t);
 					}
 
 					if(args.length >= 5) {
-						ambient = ArgumentValidation.getBoolean(args[4], t);
+						ambient = ArgumentValidation.getBoolean(args[4], t, env);
 
 						if(args.length >= 6) {
-							particles = ArgumentValidation.getBoolean(args[5], t);
+							particles = ArgumentValidation.getBoolean(args[5], t, env);
 
 							if(args.length == 7) {
-								icon = ArgumentValidation.getBoolean(args[6], t);
+								icon = ArgumentValidation.getBoolean(args[6], t, env);
 							}
 						}
 					}
@@ -2366,10 +2367,10 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
-			MCPlayer p = environment.getEnv(CommandHelperEnvironment.class).GetPlayer();
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
+			MCPlayer p = env.getEnv(CommandHelperEnvironment.class).GetPlayer();
 			if(args.length > 0) {
-				p = Static.GetPlayer(args[0], t);
+				p = Static.GetPlayer(args[0], t, env);
 			}
 			Static.AssertPlayerNonNull(p, t);
 			return ObjectGenerator.GetGenerator().potions(p.getEffects(), t);
@@ -2419,13 +2420,13 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment env, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			MCPlayer p;
 			if(args.length == 0) {
 				p = env.getEnv(CommandHelperEnvironment.class).GetPlayer();
 				Static.AssertPlayerNonNull(p, t);
 			} else {
-				p = Static.GetPlayer(args[0], t);
+				p = Static.GetPlayer(args[0], t, env);
 			}
 			p.removeEffects();
 			return CVoid.VOID;
@@ -2491,13 +2492,13 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment env, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			MCPlayer m;
 			if(args.length == 0) {
 				m = env.getEnv(CommandHelperEnvironment.class).GetPlayer();
 				Static.AssertPlayerNonNull(m, t);
 			} else {
-				m = Static.GetPlayer(args[0].val(), t);
+				m = Static.GetPlayer(args[0].val(), t, env);
 			}
 			return CBoolean.get(m.isSneaking());
 		}
@@ -2542,13 +2543,13 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment env, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			MCPlayer m;
 			if(args.length == 0) {
 				m = env.getEnv(CommandHelperEnvironment.class).GetPlayer();
 				Static.AssertPlayerNonNull(m, t);
 			} else {
-				m = Static.GetPlayer(args[0].val(), t);
+				m = Static.GetPlayer(args[0].val(), t, env);
 			}
 			return new CDouble(m.getHealth(), t);
 		}
@@ -2594,7 +2595,7 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment env, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			MCCommandSender p = env.getEnv(CommandHelperEnvironment.class).GetCommandSender();
 			MCPlayer m = null;
 			if(p instanceof MCPlayer) {
@@ -2602,10 +2603,10 @@ public Mixed exec(Target t, Environment env, Mixed... args) throws ConfigRuntime
 			}
 			double health;
 			if(args.length == 2) {
-				m = Static.GetPlayer(args[0].val(), t);
-				health = ArgumentValidation.getDouble(args[1], t);
+				m = Static.GetPlayer(args[0].val(), t, env);
+				health = ArgumentValidation.getDouble(args[1], t, env);
 			} else {
-				health = ArgumentValidation.getDouble(args[0], t);
+				health = ArgumentValidation.getDouble(args[0], t, env);
 			}
 			Static.AssertPlayerNonNull(m, t);
 			if(health < 0 || health > m.getMaxHealth()) {
@@ -2658,11 +2659,11 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment env, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			try {
 				//Static.GetPlayer() autocompletes names, which we don't want in this function,
 				//however we have to check if this is an injected player first.
-				MCPlayer p = Static.GetPlayer(args[0], t);
+				MCPlayer p = Static.GetPlayer(args[0], t, env);
 				//Now we must check if the name was exact. Skip this if the argument is a UUID.
 				if(args[0].val().length() <= 16 && !p.getName().equalsIgnoreCase(args[0].val())) {
 					p = Static.getServer().getPlayerExact(args[0].val());
@@ -2715,7 +2716,7 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment env, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			MCOfflinePlayer pl = Static.GetUser(args[0].val(), t);
 			return CBoolean.get(pl != null && pl.isWhitelisted());
 		}
@@ -2761,9 +2762,9 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment env, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			MCOfflinePlayer pl = Static.GetUser(args[0].val(), t);
-			boolean whitelist = ArgumentValidation.getBoolean(args[1], t);
+			boolean whitelist = ArgumentValidation.getBoolean(args[1], t, env);
 			if(pl == null) {
 				throw new CRENotFoundException(
 						this.getName() + " could not get the offline player (are you running in cmdline mode?)", t);
@@ -2824,7 +2825,7 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment env, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			MCOfflinePlayer pl = Static.GetUser(args[0].val(), t);
 			if(pl == null) {
 				throw new CRENotFoundException(
@@ -2879,9 +2880,9 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment env, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			String target = args[0].val();
-			boolean ban = ArgumentValidation.getBoolean(args[1], t);
+			boolean ban = ArgumentValidation.getBoolean(args[1], t, env);
 			String reason = "";
 			String source = "";
 
@@ -2952,7 +2953,7 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment env, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			MCCommandSender p = env.getEnv(CommandHelperEnvironment.class).GetCommandSender();
 			MCPlayer m = null;
 			double speed;
@@ -2961,10 +2962,10 @@ public Mixed exec(Target t, Environment env, Mixed... args) throws ConfigRuntime
 				m = (MCPlayer) p;
 			}
 			if(args.length == 2) {
-				m = Static.GetPlayer(args[0], t);
-				speed = ArgumentValidation.getDouble(args[1], t);
+				m = Static.GetPlayer(args[0], t, env);
+				speed = ArgumentValidation.getDouble(args[1], t, env);
 			} else {
-				speed = ArgumentValidation.getDouble(args[0], t);
+				speed = ArgumentValidation.getDouble(args[0], t, env);
 			}
 
 			if(speed < -1 || speed > 1) {
@@ -3016,7 +3017,7 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment env, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			MCCommandSender p = env.getEnv(CommandHelperEnvironment.class).GetCommandSender();
 			MCPlayer m = null;
 
@@ -3025,7 +3026,7 @@ public Mixed exec(Target t, Environment env, Mixed... args) throws ConfigRuntime
 			}
 
 			if(args.length == 1) {
-				m = Static.GetPlayer(args[0], t);
+				m = Static.GetPlayer(args[0], t, env);
 			}
 
 			Static.AssertPlayerNonNull(m, t);
@@ -3074,7 +3075,7 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment env, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			MCCommandSender p = env.getEnv(CommandHelperEnvironment.class).GetCommandSender();
 			MCPlayer m = null;
 			double speed;
@@ -3083,10 +3084,10 @@ public Mixed exec(Target t, Environment env, Mixed... args) throws ConfigRuntime
 				m = (MCPlayer) p;
 			}
 			if(args.length == 2) {
-				m = Static.GetPlayer(args[0], t);
-				speed = ArgumentValidation.getDouble(args[1], t);
+				m = Static.GetPlayer(args[0], t, env);
+				speed = ArgumentValidation.getDouble(args[1], t, env);
 			} else {
-				speed = ArgumentValidation.getDouble(args[0], t);
+				speed = ArgumentValidation.getDouble(args[0], t, env);
 			}
 
 			if(speed < -1 || speed > 1) {
@@ -3138,7 +3139,7 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment env, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			MCCommandSender p = env.getEnv(CommandHelperEnvironment.class).GetCommandSender();
 			MCPlayer m = null;
 
@@ -3147,7 +3148,7 @@ public Mixed exec(Target t, Environment env, Mixed... args) throws ConfigRuntime
 			}
 
 			if(args.length == 1) {
-				m = Static.GetPlayer(args[0], t);
+				m = Static.GetPlayer(args[0], t, env);
 			}
 
 			Static.AssertPlayerNonNull(m, t);
@@ -3195,10 +3196,10 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
-			MCPlayer m = environment.getEnv(CommandHelperEnvironment.class).GetPlayer();
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
+			MCPlayer m = env.getEnv(CommandHelperEnvironment.class).GetPlayer();
 			if(args.length == 1) {
-				m = Static.GetPlayer(args[0].val(), t);
+				m = Static.GetPlayer(args[0].val(), t, env);
 			}
 			Static.AssertPlayerNonNull(m, t);
 			return CBoolean.get(m.isOp());
@@ -3244,14 +3245,14 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
-			MCPlayer m = environment.getEnv(CommandHelperEnvironment.class).GetPlayer();
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
+			MCPlayer m = env.getEnv(CommandHelperEnvironment.class).GetPlayer();
 			MCLocation l;
 			if(args.length == 1) {
-				l = ObjectGenerator.GetGenerator().location(args[0], null, t);
+				l = ObjectGenerator.GetGenerator().location(args[0], null, t, env);
 			} else {
-				m = Static.GetPlayer(args[0].val(), t);
-				l = ObjectGenerator.GetGenerator().location(args[1], null, t);
+				m = Static.GetPlayer(args[0].val(), t, env);
+				l = ObjectGenerator.GetGenerator().location(args[1], null, t, env);
 			}
 			if(m == null) {
 				throw new CREPlayerOfflineException("That player is not online", t);
@@ -3302,10 +3303,10 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
-			MCPlayer m = environment.getEnv(CommandHelperEnvironment.class).GetPlayer();
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
+			MCPlayer m = env.getEnv(CommandHelperEnvironment.class).GetPlayer();
 			if(args.length == 1) {
-				m = Static.GetPlayer(args[0].val(), t);
+				m = Static.GetPlayer(args[0].val(), t, env);
 			}
 			Static.AssertPlayerNonNull(m, t);
 			return ObjectGenerator.GetGenerator().location(m.getCompassTarget(), false);
@@ -3352,10 +3353,10 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
-			MCPlayer p = environment.getEnv(CommandHelperEnvironment.class).GetPlayer();
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
+			MCPlayer p = env.getEnv(CommandHelperEnvironment.class).GetPlayer();
 			if(args.length == 1) {
-				p = Static.GetPlayer(args[0], t);
+				p = Static.GetPlayer(args[0], t, env);
 			}
 			Static.AssertPlayerNonNull(p, t);
 			int left = p.getRemainingFireTicks();
@@ -3403,23 +3404,23 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
-			MCPlayer p = environment.getEnv(CommandHelperEnvironment.class).GetPlayer();
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
+			MCPlayer p = env.getEnv(CommandHelperEnvironment.class).GetPlayer();
 			Mixed ticks;
 			if(args.length == 2) {
-				p = Static.GetPlayer(args[0], t);
+				p = Static.GetPlayer(args[0], t, env);
 				ticks = args[1];
 			} else {
 				ticks = args[0];
 			}
 			int tick = 0;
-			if(ticks.isInstanceOf(CBoolean.TYPE)) {
+			if(ticks instanceof CBoolean) {
 				boolean value = ((CBoolean) ticks).getBoolean();
 				if(value) {
 					tick = 20;
 				}
 			} else {
-				tick = ArgumentValidation.getInt32(ticks, t);
+				tick = ArgumentValidation.getInt32(ticks, t, env);
 			}
 			Static.AssertPlayerNonNull(p, t);
 			p.setRemainingFireTicks(tick);
@@ -3461,10 +3462,10 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
-			MCPlayer p = environment.getEnv(CommandHelperEnvironment.class).GetPlayer();
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
+			MCPlayer p = env.getEnv(CommandHelperEnvironment.class).GetPlayer();
 			if(args.length == 1) {
-				p = Static.GetPlayer(args[0], t);
+				p = Static.GetPlayer(args[0], t, env);
 			}
 			Static.AssertPlayerNonNull(p, t);
 			return CBoolean.get(p.getAllowFlight());
@@ -3511,14 +3512,14 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
-			MCPlayer p = environment.getEnv(CommandHelperEnvironment.class).GetPlayer();
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
+			MCPlayer p = env.getEnv(CommandHelperEnvironment.class).GetPlayer();
 			boolean flight;
 			if(args.length == 1) {
-				flight = ArgumentValidation.getBoolean(args[0], t);
+				flight = ArgumentValidation.getBoolean(args[0], t, env);
 			} else {
-				p = Static.GetPlayer(args[0], t);
-				flight = ArgumentValidation.getBoolean(args[1], t);
+				p = Static.GetPlayer(args[0], t, env);
+				flight = ArgumentValidation.getBoolean(args[1], t, env);
 			}
 			Static.AssertPlayerNonNull(p, t);
 			p.setAllowFlight(flight);
@@ -3596,17 +3597,17 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			MCPlayer p = null;
 			boolean relative = false;
-			if(environment.getEnv(CommandHelperEnvironment.class).GetPlayer() != null) {
-				p = environment.getEnv(CommandHelperEnvironment.class).GetPlayer();
+			if(env.getEnv(CommandHelperEnvironment.class).GetPlayer() != null) {
+				p = env.getEnv(CommandHelperEnvironment.class).GetPlayer();
 			}
 			if(args.length >= 2) {
-				p = Static.GetPlayer(args[0], t);
+				p = Static.GetPlayer(args[0], t, env);
 			}
 			if(args.length == 3) {
-				relative = ArgumentValidation.getBoolean(args[2], t);
+				relative = ArgumentValidation.getBoolean(args[2], t, env);
 			}
 			Static.AssertPlayerNonNull(p, t);
 			long time = 0;
@@ -3692,13 +3693,13 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			MCPlayer p = null;
-			if(environment.getEnv(CommandHelperEnvironment.class).GetPlayer() != null) {
-				p = environment.getEnv(CommandHelperEnvironment.class).GetPlayer();
+			if(env.getEnv(CommandHelperEnvironment.class).GetPlayer() != null) {
+				p = env.getEnv(CommandHelperEnvironment.class).GetPlayer();
 			}
 			if(args.length == 1) {
-				p = Static.GetPlayer(args[0], t);
+				p = Static.GetPlayer(args[0], t, env);
 			}
 			Static.AssertPlayerNonNull(p, t);
 			return new CInt(p.getPlayerTime(), t);
@@ -3744,13 +3745,13 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			MCPlayer p = null;
-			if(environment.getEnv(CommandHelperEnvironment.class).GetPlayer() != null) {
-				p = environment.getEnv(CommandHelperEnvironment.class).GetPlayer();
+			if(env.getEnv(CommandHelperEnvironment.class).GetPlayer() != null) {
+				p = env.getEnv(CommandHelperEnvironment.class).GetPlayer();
 			}
 			if(args.length == 1) {
-				p = Static.GetPlayer(args[0], t);
+				p = Static.GetPlayer(args[0], t, env);
 			}
 			Static.AssertPlayerNonNull(p, t);
 			p.resetPlayerTime();
@@ -3777,10 +3778,10 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
-			MCPlayer m = environment.getEnv(CommandHelperEnvironment.class).GetPlayer();
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
+			MCPlayer m = env.getEnv(CommandHelperEnvironment.class).GetPlayer();
 			if(args.length == 1) {
-				m = Static.GetPlayer(args[0], t);
+				m = Static.GetPlayer(args[0], t, env);
 			}
 			Static.AssertPlayerNonNull(m, t);
 			return CBoolean.get(m.getPlayerWeather() == MCWeather.DOWNFALL);
@@ -3827,17 +3828,17 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
-			MCPlayer m = environment.getEnv(CommandHelperEnvironment.class).GetPlayer();
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
+			MCPlayer m = env.getEnv(CommandHelperEnvironment.class).GetPlayer();
 			int offset = 0;
 			if(args.length == 2) {
-				m = Static.GetPlayer(args[0], t);
+				m = Static.GetPlayer(args[0], t, env);
 				offset = 1;
 			}
 			Static.AssertPlayerNonNull(m, t);
 			if(args[offset] instanceof CNull) {
 				m.resetPlayerWeather();
-			} else if(ArgumentValidation.getBoolean(args[offset], t)) {
+			} else if(ArgumentValidation.getBoolean(args[offset], t, env)) {
 				m.setPlayerWeather(MCWeather.DOWNFALL);
 			} else {
 				m.setPlayerWeather(MCWeather.CLEAR);
@@ -3887,14 +3888,14 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			MCPlayer m;
 			String listName;
 			if(args.length == 2) {
-				m = Static.GetPlayer(args[0], t);
+				m = Static.GetPlayer(args[0], t, env);
 				listName = Construct.nval(args[1]);
 			} else {
-				m = environment.getEnv(CommandHelperEnvironment.class).GetPlayer();
+				m = env.getEnv(CommandHelperEnvironment.class).GetPlayer();
 				Static.AssertPlayerNonNull(m, t);
 				listName = Construct.nval(args[0]);
 			}
@@ -3943,10 +3944,10 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
-			MCPlayer p = environment.getEnv(CommandHelperEnvironment.class).GetPlayer();
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
+			MCPlayer p = env.getEnv(CommandHelperEnvironment.class).GetPlayer();
 			if(args.length == 1) {
-				p = Static.GetPlayer(args[0], t);
+				p = Static.GetPlayer(args[0], t, env);
 			}
 			Static.AssertPlayerNonNull(p, t);
 			return new CString(p.getPlayerListName(), t);
@@ -4010,12 +4011,12 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			MCPlayer p;
 			if(args.length == 1) {
-				p = Static.GetPlayer(args[0], t);
+				p = Static.GetPlayer(args[0], t, env);
 			} else {
-				p = environment.getEnv(CommandHelperEnvironment.class).GetPlayer();
+				p = env.getEnv(CommandHelperEnvironment.class).GetPlayer();
 				Static.AssertPlayerNonNull(p, t);
 			}
 			Vector3D velocity = p.getVelocity();
@@ -4024,7 +4025,7 @@ public Mixed exec(Target t, Environment environment, Mixed... args) throws Confi
 						"The players velocity could not be found (Are you running in cmdline mode?)", t);
 			}
 			CArray vector = ObjectGenerator.GetGenerator().vector(velocity, t);
-			vector.set("magnitude", new CDouble(velocity.length(), t), t);
+			vector.set("magnitude", new CDouble(velocity.length(), t), t, env);
 			return vector;
 		}
 
@@ -4054,8 +4055,8 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
-			MCPlayer p = environment.getEnv(CommandHelperEnvironment.class).GetPlayer();
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
+			MCPlayer p = env.getEnv(CommandHelperEnvironment.class).GetPlayer();
 			Vector3D v;
 			int offset = 0;
 			switch(args.length) {
@@ -4063,20 +4064,20 @@ public Mixed exec(Target t, Environment environment, Mixed... args) throws Confi
 				case 2: {
 					if(args.length == 2) {
 						offset = 1;
-						p = Static.GetPlayer(args[0], t);
+						p = Static.GetPlayer(args[0], t, env);
 					}
-					v = ObjectGenerator.GetGenerator().vector(args[offset], t);
+					v = ObjectGenerator.GetGenerator().vector(args[offset], t, env);
 					break;
 				}
 				case 3:
 				case 4: {
 					if(args.length == 4) {
 						offset = 1;
-						p = Static.GetPlayer(args[0], t);
+						p = Static.GetPlayer(args[0], t, env);
 					}
-					double x = ArgumentValidation.getDouble(args[offset], t);
-					double y = ArgumentValidation.getDouble(args[offset + 1], t);
-					double z = ArgumentValidation.getDouble(args[offset + 2], t);
+					double x = ArgumentValidation.getDouble(args[offset], t, env);
+					double y = ArgumentValidation.getDouble(args[offset + 1], t, env);
+					double z = ArgumentValidation.getDouble(args[offset + 2], t, env);
 					v = new Vector3D(x, y, z);
 					break;
 				}
@@ -4142,15 +4143,15 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
-			MCPlayer p = environment.getEnv(CommandHelperEnvironment.class).GetPlayer();
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
+			MCPlayer p = env.getEnv(CommandHelperEnvironment.class).GetPlayer();
 			int offset = 0;
 			if(args.length == 3 || args.length == 6) {
-				p = Static.GetPlayer(args[0], t);
+				p = Static.GetPlayer(args[0], t, env);
 				offset = 1;
 			}
 			Static.AssertPlayerNonNull(p, t);
-			MCLocation loc = ObjectGenerator.GetGenerator().location(args[offset], p.getWorld(), t);
+			MCLocation loc = ObjectGenerator.GetGenerator().location(args[offset], p.getWorld(), t, env);
 			MCBlock block = loc.getBlock();
 			if(!block.isSign()) {
 				return CVoid.VOID;
@@ -4159,18 +4160,18 @@ public Mixed exec(Target t, Environment environment, Mixed... args) throws Confi
 			String[] lines = sign.getLines();
 
 			if(args.length == 2 || args.length == 3) {
-				CArray signArray = ArgumentValidation.getArray(args[1 + offset], t);
+				CArray signArray = ArgumentValidation.getArray(args[1 + offset], t, env);
 				if(signArray.isAssociative()) {
 					if(signArray.containsKey("signtext")) {
-						Mixed possibleLines = signArray.get("signtext", t);
-						if(possibleLines.isInstanceOf(CArray.TYPE)) {
+						Mixed possibleLines = signArray.get("signtext", t, env);
+						if(possibleLines.isInstanceOf(CArray.TYPE, null, env)) {
 							CArray frontLines = (CArray) possibleLines;
-							if(frontLines.size() > 4) {
+							if(frontLines.size(env) > 4) {
 								throw new CREFormatException("Sign text array cannot have more than 4 elements.", t);
 							}
-							for(int i = 0; i < frontLines.size(); i++) {
-								if(!(frontLines.get(i, t) instanceof CNull)) {
-									sign.setLine(i, frontLines.get(i, t).val());
+							for(int i = 0; i < frontLines.size(env); i++) {
+								if(!(frontLines.get(i, t, env) instanceof CNull)) {
+									sign.setLine(i, frontLines.get(i, t, env).val());
 								}
 							}
 						} else {
@@ -4178,10 +4179,10 @@ public Mixed exec(Target t, Environment environment, Mixed... args) throws Confi
 						}
 					}
 					if(signArray.containsKey("glowing")) {
-						sign.setGlowingText(ArgumentValidation.getBooleanObject(signArray.get("glowing", t), t));
+						sign.setGlowingText(ArgumentValidation.getBooleanObject(signArray.get("glowing", t, env), t, env));
 					}
 					if(signArray.containsKey("color")) {
-						Mixed dye = signArray.get("color", t);
+						Mixed dye = signArray.get("color", t, env);
 						if(!(dye instanceof CNull)) {
 							try {
 								sign.setDyeColor(MCDyeColor.valueOf(dye.val()));
@@ -4193,15 +4194,15 @@ public Mixed exec(Target t, Environment environment, Mixed... args) throws Confi
 					MCSignText backText = sign.getBackText();
 					if(backText != null) {
 						if(signArray.containsKey("backtext")) {
-							Mixed possibleLines = signArray.get("backtext", t);
-							if(possibleLines.isInstanceOf(CArray.TYPE)) {
+							Mixed possibleLines = signArray.get("backtext", t, env);
+							if(possibleLines.isInstanceOf(CArray.TYPE, null, env)) {
 								CArray backLines = (CArray) possibleLines;
-								if(backLines.size() > 4) {
+								if(backLines.size(env) > 4) {
 									throw new CREFormatException("Sign back text array cannot have more than 4 elements.", t);
 								}
-								for(int i = 0; i < backLines.size(); i++) {
-									if(!(backLines.get(i, t) instanceof CNull)) {
-										backText.setLine(i, backLines.get(i, t).val());
+								for(int i = 0; i < backLines.size(env); i++) {
+									if(!(backLines.get(i, t, env) instanceof CNull)) {
+										backText.setLine(i, backLines.get(i, t, env).val());
 									}
 								}
 							} else {
@@ -4209,10 +4210,10 @@ public Mixed exec(Target t, Environment environment, Mixed... args) throws Confi
 							}
 						}
 						if(signArray.containsKey("backglowing")) {
-							backText.setGlowingText(ArgumentValidation.getBooleanObject(signArray.get("backglowing", t), t));
+							backText.setGlowingText(ArgumentValidation.getBooleanObject(signArray.get("backglowing", t, env), t, env));
 						}
 						if(signArray.containsKey("backcolor")) {
-							Mixed dye = signArray.get("backcolor", t);
+							Mixed dye = signArray.get("backcolor", t, env);
 							if(!(dye instanceof CNull)) {
 								try {
 									backText.setDyeColor(MCDyeColor.valueOf(dye.val()));
@@ -4226,11 +4227,11 @@ public Mixed exec(Target t, Environment environment, Mixed... args) throws Confi
 					return CVoid.VOID;
 				} else {
 					// Lines are in an array
-					if(signArray.size() > 4) {
+					if(signArray.size(env) > 4) {
 						throw new CREFormatException("Sign array cannot have more than 4 elements.", t);
 					}
-					for(int i = 0; i < signArray.size(); i++) {
-						Mixed line = signArray.get(i, t);
+					for(int i = 0; i < signArray.size(env); i++) {
+						Mixed line = signArray.get(i, t, env);
 						if(!(line instanceof CNull)) {
 							lines[i] = line.val();
 						}
@@ -4296,15 +4297,15 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
-			MCPlayer p = environment.getEnv(CommandHelperEnvironment.class).GetPlayer();
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
+			MCPlayer p = env.getEnv(CommandHelperEnvironment.class).GetPlayer();
 			int offset = 0;
 			if(args.length == 3) {
-				p = Static.GetPlayer(args[0], t);
+				p = Static.GetPlayer(args[0], t, env);
 				offset = 1;
 			}
 			Static.AssertPlayerNonNull(p, t);
-			MCLocation loc = ObjectGenerator.GetGenerator().location(args[offset], p.getWorld(), t);
+			MCLocation loc = ObjectGenerator.GetGenerator().location(args[offset], p.getWorld(), t, env);
 			Mixed cdata = args[1 + offset];
 			MCBlockData data;
 			if(cdata instanceof CNull) {
@@ -4408,25 +4409,25 @@ public Class<? extends CREThrowable>[] thrown() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			MCPlayer p;
 			MCLocation location;
 			float progress;
 			MCEntity entity;
 			int argOffset = 0;
 			if(args.length == 2 || args.length == 3 && args[0] instanceof CArray) {
-				p = environment.getEnv(CommandHelperEnvironment.class).GetPlayer();
+				p = env.getEnv(CommandHelperEnvironment.class).GetPlayer();
 				Static.AssertPlayerNonNull(p, t);
 			} else {
-				p = Static.GetPlayer(args[0], t);
+				p = Static.GetPlayer(args[0], t, env);
 				argOffset = 1;
 			}
-			location = ObjectGenerator.GetGenerator().location(args[argOffset], p.getWorld(), t);
+			location = ObjectGenerator.GetGenerator().location(args[argOffset], p.getWorld(), t, env);
 			Mixed progressArg = args[1 + argOffset];
 			if(progressArg instanceof CInt) {
-				progress = ArgumentValidation.getInt(progressArg, t) / 10.0F;
+				progress = ArgumentValidation.getInt(progressArg, t, env) / 10.0F;
 			} else {
-				progress = (float) ArgumentValidation.getDouble(progressArg, t);
+				progress = (float) ArgumentValidation.getDouble(progressArg, t, env);
 			}
 			if(progress < 0.0 || progress > 1.0) {
 				throw new CRERangeException("Block damage progress must be 0.0 to 1.0 (or 0 - 10).", t);
@@ -4477,10 +4478,10 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
-			MCPlayer p = environment.getEnv(CommandHelperEnvironment.class).GetPlayer();
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
+			MCPlayer p = env.getEnv(CommandHelperEnvironment.class).GetPlayer();
 			if(args.length == 1) {
-				p = Static.GetPlayer(args[0], t);
+				p = Static.GetPlayer(args[0], t, env);
 			}
 			Static.AssertPlayerNonNull(p, t);
 			return new CInt(p.getFoodLevel(), t);
@@ -4526,15 +4527,15 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
-			MCPlayer p = environment.getEnv(CommandHelperEnvironment.class).GetPlayer();
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
+			MCPlayer p = env.getEnv(CommandHelperEnvironment.class).GetPlayer();
 			int hungerIndex = 0;
 			if(args.length == 2) {
-				p = Static.GetPlayer(args[0], t);
+				p = Static.GetPlayer(args[0], t, env);
 				hungerIndex = 1;
 			}
 			Static.AssertPlayerNonNull(p, t);
-			int hunger = ArgumentValidation.getInt32(args[hungerIndex], t);
+			int hunger = ArgumentValidation.getInt32(args[hungerIndex], t, env);
 			p.setFoodLevel(hunger);
 			return CVoid.VOID;
 		}
@@ -4579,10 +4580,10 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
-			MCPlayer p = environment.getEnv(CommandHelperEnvironment.class).GetPlayer();
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
+			MCPlayer p = env.getEnv(CommandHelperEnvironment.class).GetPlayer();
 			if(args.length == 1) {
-				p = Static.GetPlayer(args[0], t);
+				p = Static.GetPlayer(args[0], t, env);
 			}
 			Static.AssertPlayerNonNull(p, t);
 			return new CDouble(p.getSaturation(), t);
@@ -4628,16 +4629,16 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
-			MCPlayer p = environment.getEnv(CommandHelperEnvironment.class).GetPlayer();
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
+			MCPlayer p = env.getEnv(CommandHelperEnvironment.class).GetPlayer();
 			float saturation;
 			int saturationIndex = 0;
 			if(args.length == 2) {
-				p = Static.GetPlayer(args[0], t);
+				p = Static.GetPlayer(args[0], t, env);
 				saturationIndex = 1;
 			}
 			Static.AssertPlayerNonNull(p, t);
-			saturation = (float) ArgumentValidation.getDouble(args[saturationIndex], t);
+			saturation = (float) ArgumentValidation.getDouble(args[saturationIndex], t, env);
 			p.setSaturation(saturation);
 			return CVoid.VOID;
 		}
@@ -4680,7 +4681,7 @@ public Integer[] numArgs() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment env, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			MCOfflinePlayer player = env.getEnv(CommandHelperEnvironment.class).GetPlayer();
 			if(args.length == 1) {
 				player = Static.GetUser(args[0].val(), t);
@@ -4771,7 +4772,7 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment env, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			MCCommandSender p = env.getEnv(CommandHelperEnvironment.class).GetCommandSender();
 			String pname = null;
 			MCPlayer m = null;
@@ -4780,7 +4781,7 @@ public Mixed exec(Target t, Environment env, Mixed... args) throws ConfigRuntime
 			boolean forced = true;
 
 			if(args.length == 1) {
-				if(args[0].isInstanceOf(CArray.TYPE)) {
+				if(args[0].isInstanceOf(CArray.TYPE, null, env)) {
 					if(p instanceof MCPlayer) {
 						m = ((MCPlayer) p);
 					}
@@ -4789,23 +4790,23 @@ public Mixed exec(Target t, Environment env, Mixed... args) throws ConfigRuntime
 					throw new CRECastException("Expecting an array in set_pbed_location", t);
 				}
 			} else if(args.length == 2) {
-				if(args[1].isInstanceOf(CArray.TYPE)) {
+				if(args[1].isInstanceOf(CArray.TYPE, null, env)) {
 					pname = args[0].val();
 					locationIndex = 1;
-				} else if(args[0].isInstanceOf(CArray.TYPE)) {
+				} else if(args[0].isInstanceOf(CArray.TYPE, null, env)) {
 					if(p instanceof MCPlayer) {
 						m = ((MCPlayer) p);
 					}
 					locationIndex = 0;
-					forced = ArgumentValidation.getBoolean(args[1], t);
+					forced = ArgumentValidation.getBoolean(args[1], t, env);
 				} else {
 					throw new CRECastException("Expecting an array in set_pbed_location", t);
 				}
 			} else if(args.length == 3) {
-				if(args[1].isInstanceOf(CArray.TYPE)) {
+				if(args[1].isInstanceOf(CArray.TYPE, null, env)) {
 					pname = args[0].val();
 					locationIndex = 1;
-					forced = ArgumentValidation.getBoolean(args[2], t);
+					forced = ArgumentValidation.getBoolean(args[2], t, env);
 				} else {
 					if(p instanceof MCPlayer) {
 						m = (MCPlayer) p;
@@ -4814,29 +4815,29 @@ public Mixed exec(Target t, Environment env, Mixed... args) throws ConfigRuntime
 				}
 			} else if(args.length == 4) {
 				try {
-					m = Static.GetPlayer(args[0], t);
+					m = Static.GetPlayer(args[0], t, env);
 					locationIndex = 1;
 				} catch (ConfigRuntimeException e) {
 					if(p instanceof MCPlayer) {
 						m = (MCPlayer) p;
 					}
 					locationIndex = 0;
-					forced = ArgumentValidation.getBoolean(args[3], t);
+					forced = ArgumentValidation.getBoolean(args[3], t, env);
 				}
 			} else {
-				m = Static.GetPlayer(args[0], t);
+				m = Static.GetPlayer(args[0], t, env);
 				locationIndex = 1;
-				forced = ArgumentValidation.getBoolean(args[4], t);
+				forced = ArgumentValidation.getBoolean(args[4], t, env);
 			}
 
 			if(m == null && pname != null) {
-				m = Static.GetPlayer(pname, t);
+				m = Static.GetPlayer(pname, t, env);
 			}
 			Static.AssertPlayerNonNull(m, t);
 
-			if(args[locationIndex].isInstanceOf(CArray.TYPE)) {
+			if(args[locationIndex].isInstanceOf(CArray.TYPE, null, env)) {
 				CArray ca = (CArray) args[locationIndex];
-				l = ObjectGenerator.GetGenerator().location(ca, m.getWorld(), t);
+				l = ObjectGenerator.GetGenerator().location(ca, m.getWorld(), t, env);
 				l.add(0, 1, 0); // someone decided to match ploc() here
 			} else {
 				l = m.getLocation();
@@ -4844,9 +4845,9 @@ public Mixed exec(Target t, Environment env, Mixed... args) throws ConfigRuntime
 					throw new CRENullPointerException(
 							"The given player has a null location (are you running from cmdline mode?)", t);
 				}
-				l.setX(ArgumentValidation.getNumber(args[locationIndex], t));
-				l.setY(ArgumentValidation.getNumber(args[locationIndex + 1], t) + 1);
-				l.setZ(ArgumentValidation.getNumber(args[locationIndex + 2], t));
+				l.setX(ArgumentValidation.getNumber(args[locationIndex], t, env));
+				l.setY(ArgumentValidation.getNumber(args[locationIndex + 1], t, env) + 1);
+				l.setZ(ArgumentValidation.getNumber(args[locationIndex + 2], t, env));
 			}
 
 			m.setBedSpawnLocation(l, forced);
@@ -4894,10 +4895,10 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
-			MCPlayer p = environment.getEnv(CommandHelperEnvironment.class).GetPlayer();
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
+			MCPlayer p = env.getEnv(CommandHelperEnvironment.class).GetPlayer();
 			if(args.length == 1) {
-				p = Static.GetPlayer(args[0].val(), t);
+				p = Static.GetPlayer(args[0].val(), t, env);
 			}
 
 			Static.AssertPlayerNonNull(p, t);
@@ -4949,10 +4950,10 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
-			MCPlayer p = environment.getEnv(CommandHelperEnvironment.class).GetPlayer();
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
+			MCPlayer p = env.getEnv(CommandHelperEnvironment.class).GetPlayer();
 			if(args.length == 1) {
-				p = Static.GetPlayer(args[0].val(), t);
+				p = Static.GetPlayer(args[0].val(), t, env);
 			}
 			Static.AssertPlayerNonNull(p, t);
 
@@ -4979,7 +4980,7 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			MCServer s = Static.getServer();
 			CArray ret = new CArray(t);
 			// This causes the function to return an empty array for a fake/null server.
@@ -4987,7 +4988,7 @@ public Mixed exec(Target t, Environment environment, Mixed... args) throws Confi
 				MCOfflinePlayer[] players = s.getOfflinePlayers();
 				if(players != null) {
 					for(MCOfflinePlayer offp : players) {
-						ret.push(new CString(offp.getName(), t), t);
+						ret.push(new CString(offp.getName(), t), t, env);
 					}
 				}
 			}
@@ -5042,7 +5043,7 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			MCOfflinePlayer offp = Static.GetUser(args[0].val(), t);
 			return CBoolean.get(offp != null && offp.hasPlayedBefore());
 		}
@@ -5099,12 +5100,12 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			MCOfflinePlayer op;
 			if(args.length == 1) {
 				op = Static.GetUser(args[0].val(), t);
 			} else {
-				op = environment.getEnv(CommandHelperEnvironment.class).GetPlayer();
+				op = env.getEnv(CommandHelperEnvironment.class).GetPlayer();
 				if(op == null) {
 					throw new CREInsufficientArgumentsException(this.getName()
 							+ " requires a player argument when ran from a non-player", t);
@@ -5166,12 +5167,12 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			MCOfflinePlayer op;
 			if(args.length == 1) {
 				op = Static.GetUser(args[0].val(), t);
 			} else {
-				op = environment.getEnv(CommandHelperEnvironment.class).GetPlayer();
+				op = env.getEnv(CommandHelperEnvironment.class).GetPlayer();
 				if(op == null) {
 					throw new CREInsufficientArgumentsException(this.getName()
 							+ " requires a player argument when ran from a non-player", t);
@@ -5232,7 +5233,7 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			MCOfflinePlayer p = Static.GetUser(args[0].val(), t);
 			if(p == null) {
 				return CNull.NULL;
@@ -5286,7 +5287,7 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			Static.getServer().savePlayers();
 			return CVoid.VOID;
 		}
@@ -5348,14 +5349,14 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
-			MCPlayer p = environment.getEnv(CommandHelperEnvironment.class).GetPlayer();
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
+			MCPlayer p = env.getEnv(CommandHelperEnvironment.class).GetPlayer();
 			boolean flight;
 			if(args.length == 1) {
-				flight = ArgumentValidation.getBoolean(args[0], t);
+				flight = ArgumentValidation.getBoolean(args[0], t, env);
 			} else {
-				p = Static.GetPlayer(args[0], t);
-				flight = ArgumentValidation.getBoolean(args[1], t);
+				p = Static.GetPlayer(args[0], t, env);
+				flight = ArgumentValidation.getBoolean(args[1], t, env);
 			}
 			Static.AssertPlayerNonNull(p, t);
 			if(!p.getAllowFlight()) {
@@ -5416,12 +5417,12 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			MCPlayer p;
 			if(args.length == 1) {
-				p = Static.GetPlayer(args[0], t);
+				p = Static.GetPlayer(args[0], t, env);
 			} else {
-				p = environment.getEnv(CommandHelperEnvironment.class).GetPlayer();
+				p = env.getEnv(CommandHelperEnvironment.class).GetPlayer();
 				Static.AssertPlayerNonNull(p, t);
 			}
 			return CBoolean.get(p.isFlying());
@@ -5469,12 +5470,12 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			MCPlayer p;
 			if(args.length == 0) {
-				p = environment.getEnv(CommandHelperEnvironment.class).GetPlayer();
+				p = env.getEnv(CommandHelperEnvironment.class).GetPlayer();
 			} else {
-				p = Static.GetPlayer(args[0], t);
+				p = Static.GetPlayer(args[0], t, env);
 			}
 			Static.AssertPlayerNonNull(p, t);
 			if(p.getGameMode() != MCGameMode.SPECTATOR) {
@@ -5530,13 +5531,13 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			MCPlayer p;
 			int offset = 0;
 			if(args.length == 1) {
-				p = environment.getEnv(CommandHelperEnvironment.class).GetPlayer();
+				p = env.getEnv(CommandHelperEnvironment.class).GetPlayer();
 			} else {
-				p = Static.GetPlayer(args[0], t);
+				p = Static.GetPlayer(args[0], t, env);
 				offset = 1;
 			}
 			Static.AssertPlayerNonNull(p, t);
@@ -5578,21 +5579,21 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, com.laytonsmith.core.environments.Environment environment, Mixed... args)
+		public Mixed exec(Target t, com.laytonsmith.core.environments.Environment env, GenericParameters generics, Mixed... args)
 				throws ConfigRuntimeException {
 
-			MCPlayer p = Static.GetPlayer(args[0], t);
+			MCPlayer p = Static.GetPlayer(args[0], t, env);
 
 			String soundName;
 			String categoryName = null;
-			if(args[1].isInstanceOf(CArray.TYPE)) {
+			if(args[1].isInstanceOf(CArray.TYPE, null, env)) {
 				CArray soundArray = (CArray) args[1];
 				if(!soundArray.isAssociative()) {
 					throw new CRECastException("Expected an associative array", t);
 				}
-				soundName = soundArray.get("sound", t).val();
+				soundName = soundArray.get("sound", t, env).val();
 				if(soundArray.containsKey("category")) {
-					categoryName = soundArray.get("category", t).val();
+					categoryName = soundArray.get("category", t, env).val();
 				}
 			} else {
 				soundName = args[1].val();
@@ -5663,10 +5664,10 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, com.laytonsmith.core.environments.Environment environment, Mixed... args)
+		public Mixed exec(Target t, com.laytonsmith.core.environments.Environment env, GenericParameters generics, Mixed... args)
 				throws ConfigRuntimeException {
 
-			MCPlayer p = Static.GetPlayer(args[0], t);
+			MCPlayer p = Static.GetPlayer(args[0], t, env);
 			MCSoundCategory category;
 			try {
 				category = MCSoundCategory.valueOf(args[1].val().toUpperCase());
@@ -5719,20 +5720,20 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, com.laytonsmith.core.environments.Environment environment, Mixed... args)
+		public Mixed exec(Target t, com.laytonsmith.core.environments.Environment env, GenericParameters generics, Mixed... args)
 				throws ConfigRuntimeException {
 
-			MCPlayer p = Static.GetPlayer(args[0], t);
+			MCPlayer p = Static.GetPlayer(args[0], t, env);
 			String soundName;
 			String categoryName = null;
-			if(args[1].isInstanceOf(CArray.TYPE)) {
+			if(args[1].isInstanceOf(CArray.TYPE, null, env)) {
 				CArray soundArray = (CArray) args[1];
 				if(!soundArray.isAssociative()) {
 					throw new CRECastException("Expected an associative array or sound string", t);
 				}
-				soundName = soundArray.get("sound", t).val();
+				soundName = soundArray.get("sound", t, env).val();
 				if(soundArray.containsKey("category")) {
-					categoryName = soundArray.get("category", t).val();
+					categoryName = soundArray.get("category", t, env).val();
 				}
 			} else {
 				soundName = args[1].val();
@@ -5798,11 +5799,11 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment env, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			MCPlayer p;
 			String materialName;
 			if(args.length == 2) {
-				p = Static.GetPlayer(args[0], t);
+				p = Static.GetPlayer(args[0], t, env);
 				materialName = args[1].val();
 			} else {
 				p = env.getEnv(CommandHelperEnvironment.class).GetPlayer();
@@ -5862,19 +5863,19 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment env, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			MCPlayer p;
 			String materialName;
 			int cooldown;
 			if(args.length == 3) {
-				p = Static.GetPlayer(args[0], t);
+				p = Static.GetPlayer(args[0], t, env);
 				materialName = args[1].val();
-				cooldown = ArgumentValidation.getInt32(args[2], t);
+				cooldown = ArgumentValidation.getInt32(args[2], t, env);
 			} else {
 				p = env.getEnv(CommandHelperEnvironment.class).GetPlayer();
 				Static.AssertPlayerNonNull(p, t);
 				materialName = args[0].val();
-				cooldown = ArgumentValidation.getInt32(args[1], t);
+				cooldown = ArgumentValidation.getInt32(args[1], t, env);
 			}
 
 			MCMaterial mat = StaticLayer.GetMaterial(materialName);
@@ -5932,12 +5933,12 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment env, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			MCHumanEntity he;
 			if(args.length == 0) {
 				he = env.getEnv(CommandHelperEnvironment.class).GetPlayer();
 			} else {
-				he = Static.GetPlayer(args[0], t);
+				he = Static.GetPlayer(args[0], t, env);
 			}
 			return new CDouble(he.getAttackCooldown(), t);
 		}
@@ -5985,10 +5986,10 @@ public String docs() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment env, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			MCPlayer p;
 			if(args.length == 2) {
-				p = Static.GetPlayer(args[0], t);
+				p = Static.GetPlayer(args[0], t, env);
 			} else {
 				p = env.getEnv(CommandHelperEnvironment.class).GetPlayer();
 				Static.AssertPlayerNonNull(p, t);
@@ -6039,11 +6040,11 @@ public String docs() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment env, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			MCPlayer p;
 			String header;
 			if(args.length == 2) {
-				p = Static.GetPlayer(args[0], t);
+				p = Static.GetPlayer(args[0], t, env);
 				header = args[1].val();
 			} else {
 				p = env.getEnv(CommandHelperEnvironment.class).GetPlayer();
@@ -6095,10 +6096,10 @@ public String docs() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment env, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			MCPlayer p;
 			if(args.length == 2) {
-				p = Static.GetPlayer(args[0], t);
+				p = Static.GetPlayer(args[0], t, env);
 			} else {
 				p = env.getEnv(CommandHelperEnvironment.class).GetPlayer();
 				Static.AssertPlayerNonNull(p, t);
@@ -6149,11 +6150,11 @@ public String docs() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment env, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			MCPlayer p;
 			String footer;
 			if(args.length == 2) {
-				p = Static.GetPlayer(args[0], t);
+				p = Static.GetPlayer(args[0], t, env);
 				footer = args[1].val();
 			} else {
 				p = env.getEnv(CommandHelperEnvironment.class).GetPlayer();
@@ -6206,8 +6207,8 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
-			MCPlayer p = environment.getEnv(CommandHelperEnvironment.class).GetPlayer();
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
+			MCPlayer p = env.getEnv(CommandHelperEnvironment.class).GetPlayer();
 			if(p == null) {
 				throw new CREPlayerOfflineException("ptellraw() requires player context. Consider tellraw().", t);
 			}
@@ -6311,14 +6312,14 @@ public String docs() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
-			MCPlayer p = environment.getEnv(CommandHelperEnvironment.class).GetPlayer();
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
+			MCPlayer p = env.getEnv(CommandHelperEnvironment.class).GetPlayer();
 			String filter = null;
 			MCPlayerStatistic stat;
 			int offset = 0;
 			if(args.length > 1) {
 				offset = 1;
-				p = Static.GetPlayer(args[0], t);
+				p = Static.GetPlayer(args[0], t, env);
 				if(args.length > 2) {
 					filter = args[2].val().toUpperCase();
 				}
@@ -6414,20 +6415,20 @@ public String docs() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
-			MCPlayer p = environment.getEnv(CommandHelperEnvironment.class).GetPlayer();
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
+			MCPlayer p = env.getEnv(CommandHelperEnvironment.class).GetPlayer();
 			String filter = null;
 			MCPlayerStatistic stat;
 			int offset = 0;
 			int amount = 0;
 			if(args.length > 2) {
 				offset = 1;
-				p = Static.GetPlayer(args[0], t);
+				p = Static.GetPlayer(args[0], t, env);
 				if(args.length == 3) {
-					amount = ArgumentValidation.getInt32(args[2], t);
+					amount = ArgumentValidation.getInt32(args[2], t, env);
 				} else {
 					filter = args[2].val().toUpperCase();
-					amount = ArgumentValidation.getInt32(args[3], t);
+					amount = ArgumentValidation.getInt32(args[3], t, env);
 				}
 			}
 
@@ -6536,12 +6537,12 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			MCPlayer p;
 			if(args.length == 1) {
-				p = Static.GetPlayer(args[0], t);
+				p = Static.GetPlayer(args[0], t, env);
 			} else {
-				p = environment.getEnv(CommandHelperEnvironment.class).GetPlayer();
+				p = env.getEnv(CommandHelperEnvironment.class).GetPlayer();
 				Static.AssertPlayerNonNull(p, t);
 			}
 			return CBoolean.get(p.isBlocking());
@@ -6587,12 +6588,12 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			MCPlayer p;
 			if(args.length == 1) {
-				p = Static.GetPlayer(args[0], t);
+				p = Static.GetPlayer(args[0], t, env);
 			} else {
-				p = environment.getEnv(CommandHelperEnvironment.class).GetPlayer();
+				p = env.getEnv(CommandHelperEnvironment.class).GetPlayer();
 				Static.AssertPlayerNonNull(p, t);
 			}
 			return CBoolean.get(p.isSprinting());
@@ -6625,23 +6626,23 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			MCPlayer p;
 			if(args.length == 1) {
-				p = Static.GetPlayer(args[0], t);
+				p = Static.GetPlayer(args[0], t, env);
 			} else {
-				p = environment.getEnv(CommandHelperEnvironment.class).GetPlayer();
+				p = env.getEnv(CommandHelperEnvironment.class).GetPlayer();
 				Static.AssertPlayerNonNull(p, t);
 			}
 			MCWorldBorder wb = p.getWorldBorder();
 			if(wb == null) {
 				return CNull.NULL;
 			}
-			CArray ret = CArray.GetAssociativeArray(t);
-			ret.set("width", new CDouble(wb.getSize(), t), t);
-			ret.set("center", ObjectGenerator.GetGenerator().location(wb.getCenter(), false), t);
-			ret.set("warningtime", new CInt(wb.getWarningTime(), t), t);
-			ret.set("warningdistance", new CInt(wb.getWarningDistance(), t), t);
+			CArray ret = CArray.GetAssociativeArray(t, null, env);
+			ret.set("width", new CDouble(wb.getSize(), t), t, env);
+			ret.set("center", ObjectGenerator.GetGenerator().location(wb.getCenter(), false), t, env);
+			ret.set("warningtime", new CInt(wb.getWarningTime(), t), t, env);
+			ret.set("warningdistance", new CInt(wb.getWarningDistance(), t), t, env);
 			return ret;
 		}
 
@@ -6690,14 +6691,14 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			MCPlayer p;
 			Mixed c;
 			if(args.length == 2) {
-				p = Static.GetPlayer(args[0], t);
+				p = Static.GetPlayer(args[0], t, env);
 				c = args[1];
 			} else {
-				p = environment.getEnv(CommandHelperEnvironment.class).GetPlayer();
+				p = env.getEnv(CommandHelperEnvironment.class).GetPlayer();
 				Static.AssertPlayerNonNull(p, t);
 				c = args[0];
 			}
@@ -6709,26 +6710,26 @@ public Mixed exec(Target t, Environment environment, Mixed... args) throws Confi
 			if(wb == null) {
 				wb = Static.getServer().createWorldBorder();
 			}
-			if(!(c.isInstanceOf(CArray.TYPE))) {
+			if(!(c.isInstanceOf(CArray.TYPE, null, env))) {
 				throw new CREFormatException("Expected array or null but given \"" + c.val() + "\"", t);
 			}
 			CArray params = (CArray) c;
 			if(params.containsKey("width")) {
 				if(params.containsKey("seconds")) {
-					wb.setSize(ArgumentValidation.getDouble(params.get("width", t), t),
-							ArgumentValidation.getInt32(params.get("seconds", t), t));
+					wb.setSize(ArgumentValidation.getDouble(params.get("width", t, env), t, env),
+							ArgumentValidation.getInt32(params.get("seconds", t, env), t, env));
 				} else {
-					wb.setSize(ArgumentValidation.getDouble(params.get("width", t), t));
+					wb.setSize(ArgumentValidation.getDouble(params.get("width", t, env), t, env));
 				}
 			}
 			if(params.containsKey("center")) {
-				wb.setCenter(ObjectGenerator.GetGenerator().location(params.get("center", t), p.getWorld(), t));
+				wb.setCenter(ObjectGenerator.GetGenerator().location(params.get("center", t, env), p.getWorld(), t, env));
 			}
 			if(params.containsKey("warningtime")) {
-				wb.setWarningTime(ArgumentValidation.getInt32(params.get("warningtime", t), t));
+				wb.setWarningTime(ArgumentValidation.getInt32(params.get("warningtime", t, env), t, env));
 			}
 			if(params.containsKey("warningdistance")) {
-				wb.setWarningDistance(ArgumentValidation.getInt32(params.get("warningdistance", t), t));
+				wb.setWarningDistance(ArgumentValidation.getInt32(params.get("warningdistance", t, env), t, env));
 			}
 			p.setWorldBorder(wb);
 			return CVoid.VOID;
@@ -6778,13 +6779,13 @@ public Integer[] numArgs() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment env, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			MCPlayer p;
 			if(args.length == 0) {
 				p = env.getEnv(CommandHelperEnvironment.class).GetPlayer();
 				Static.AssertPlayerNonNull(p, t);
 			} else {
-				p = Static.GetPlayer(args[0], t);
+				p = Static.GetPlayer(args[0], t, env);
 			}
 			return new CString(p.getLocale(), t);
 		}
@@ -6829,7 +6830,7 @@ public Integer[] numArgs() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment env, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			MCPlayer p;
 			String stringKey;
 			if(args.length == 1) {
@@ -6837,7 +6838,7 @@ public Mixed exec(Target t, Environment env, Mixed... args) throws ConfigRuntime
 				Static.AssertPlayerNonNull(p, t);
 				stringKey = args[0].val();
 			} else {
-				p = Static.GetPlayer(args[0], t);
+				p = Static.GetPlayer(args[0], t, env);
 				stringKey = args[1].val();
 			}
 			MCNamespacedKey key = StaticLayer.GetConvertor().GetNamespacedKey(stringKey);
@@ -6889,7 +6890,7 @@ public Integer[] numArgs() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment env, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			MCPlayer p;
 			Mixed value;
 			if(args.length == 1) {
@@ -6897,12 +6898,12 @@ public Mixed exec(Target t, Environment env, Mixed... args) throws ConfigRuntime
 				Static.AssertPlayerNonNull(p, t);
 				value = args[0];
 			} else {
-				p = Static.GetPlayer(args[0], t);
+				p = Static.GetPlayer(args[0], t, env);
 				value = args[1];
 			}
-			if(value.isInstanceOf(CArray.TYPE)) {
+			if(value.isInstanceOf(CArray.TYPE, null, env)) {
 				int result = 0;
-				for(Mixed element : ((CArray) value).asList()) {
+				for(Mixed element : ((CArray) value).asList(env)) {
 					MCNamespacedKey key = StaticLayer.GetConvertor().GetNamespacedKey(element.val());
 					if(key == null) {
 						throw new CREFormatException("Invalid namespaced key format: " + element.val(), t);
@@ -6960,13 +6961,13 @@ public Integer[] numArgs() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment env, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			MCPlayer p;
 			if(args.length == 0) {
 				p = env.getEnv(CommandHelperEnvironment.class).GetPlayer();
 				Static.AssertPlayerNonNull(p, t);
 			} else {
-				p = Static.GetPlayer(args[0], t);
+				p = Static.GetPlayer(args[0], t, env);
 			}
 			p.respawn();
 			return CVoid.VOID;
@@ -7014,7 +7015,7 @@ public Integer[] numArgs() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment env, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			MCPlayer p;
 			MCEntity e;
 			if(args.length == 1) {
@@ -7022,7 +7023,7 @@ public Mixed exec(Target t, Environment env, Mixed... args) throws ConfigRuntime
 				Static.AssertPlayerNonNull(p, t);
 				e = Static.getEntity(args[0], t);
 			} else {
-				p = Static.GetPlayer(args[0], t);
+				p = Static.GetPlayer(args[0], t, env);
 				e = Static.getEntity(args[1], t);
 			}
 			p.hideEntity(e);
@@ -7069,7 +7070,7 @@ public Integer[] numArgs() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment env, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			MCPlayer p;
 			MCEntity e;
 			if(args.length == 1) {
@@ -7077,7 +7078,7 @@ public Mixed exec(Target t, Environment env, Mixed... args) throws ConfigRuntime
 				Static.AssertPlayerNonNull(p, t);
 				e = Static.getEntity(args[0], t);
 			} else {
-				p = Static.GetPlayer(args[0], t);
+				p = Static.GetPlayer(args[0], t, env);
 				e = Static.getEntity(args[1], t);
 			}
 			p.showEntity(e);
@@ -7125,7 +7126,7 @@ public Integer[] numArgs() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment env, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			MCPlayer p;
 			MCEntity e;
 			if(args.length == 1) {
@@ -7133,7 +7134,7 @@ public Mixed exec(Target t, Environment env, Mixed... args) throws ConfigRuntime
 				Static.AssertPlayerNonNull(p, t);
 				e = Static.getEntity(args[0], t);
 			} else {
-				p = Static.GetPlayer(args[0], t);
+				p = Static.GetPlayer(args[0], t, env);
 				e = Static.getEntity(args[1], t);
 			}
 			return CBoolean.get(p.canSeeEntity(e));
@@ -7183,7 +7184,7 @@ public Integer[] numArgs() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment env, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			MCPlayer p;
 			MCLivingEntity le;
 			Mixed equipment;
@@ -7193,7 +7194,7 @@ public Mixed exec(Target t, Environment env, Mixed... args) throws ConfigRuntime
 				le = Static.getLivingEntity(args[0], t);
 				equipment = args[1];
 			} else {
-				p = Static.GetPlayer(args[0], t);
+				p = Static.GetPlayer(args[0], t, env);
 				le = Static.getLivingEntity(args[1], t);
 				equipment = args[2];
 			}
@@ -7201,12 +7202,12 @@ public Mixed exec(Target t, Environment env, Mixed... args) throws ConfigRuntime
 				for(MCEquipmentSlot slot : MCEquipmentSlot.values()) {
 					p.sendEquipmentChange(le, slot, null);
 				}
-			} else if(equipment.isInstanceOf(CArray.TYPE)) {
+			} else if(equipment.isInstanceOf(CArray.TYPE, null, env)) {
 				CArray ea = (CArray) equipment;
 				for(String key : ea.stringKeySet()) {
 					try {
 						p.sendEquipmentChange(le, MCEquipmentSlot.valueOf(key.toUpperCase()),
-								ObjectGenerator.GetGenerator().item(ea.get(key, t), t));
+								ObjectGenerator.GetGenerator().item(ea.get(key, t, env), t, env));
 					} catch (IllegalArgumentException iae) {
 						throw new CREFormatException("Not an equipment slot: " + key, t);
 					}
@@ -7255,10 +7256,10 @@ public String docs() {
 					+ " This is an indicator of the quality of the player's connection, as represented in the tab list.";
 		}
 
-		public Construct exec(Target t, Environment env, Mixed... args) throws ConfigRuntimeException {
+		public Construct exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			MCPlayer p;
 			if(args.length == 1) {
-				p = Static.GetPlayer(args[0].val(), t);
+				p = Static.GetPlayer(args[0].val(), t, env);
 			} else {
 				p = env.getEnv(CommandHelperEnvironment.class).GetPlayer();
 				Static.AssertPlayerNonNull(p, t);
@@ -7300,23 +7301,23 @@ public String docs() {
 					+ " Array contains the following keys: forward, backward, left, right, jump, sneak, and sprint.";
 		}
 
-		public Construct exec(Target t, Environment env, Mixed... args) throws ConfigRuntimeException {
+		public Construct exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			MCPlayer p;
 			if(args.length == 1) {
-				p = Static.GetPlayer(args[0].val(), t);
+				p = Static.GetPlayer(args[0].val(), t, env);
 			} else {
 				p = env.getEnv(CommandHelperEnvironment.class).GetPlayer();
 				Static.AssertPlayerNonNull(p, t);
 			}
-			CArray ret = CArray.GetAssociativeArray(t);
+			CArray ret = CArray.GetAssociativeArray(t, null, env);
 			MCPlayerInput input = p.getCurrentInput();
-			ret.set("forward", CBoolean.get(input.forward()), t);
-			ret.set("backward", CBoolean.get(input.backward()), t);
-			ret.set("left", CBoolean.get(input.left()), t);
-			ret.set("right", CBoolean.get(input.right()), t);
-			ret.set("jump", CBoolean.get(input.jump()), t);
-			ret.set("sneak", CBoolean.get(input.sneak()), t);
-			ret.set("sprint", CBoolean.get(input.sprint()), t);
+			ret.set("forward", CBoolean.get(input.forward()), t, env);
+			ret.set("backward", CBoolean.get(input.backward()), t, env);
+			ret.set("left", CBoolean.get(input.left()), t, env);
+			ret.set("right", CBoolean.get(input.right()), t, env);
+			ret.set("jump", CBoolean.get(input.jump()), t, env);
+			ret.set("sneak", CBoolean.get(input.sneak()), t, env);
+			ret.set("sprint", CBoolean.get(input.sprint()), t, env);
 			return ret;
 		}
 
@@ -7349,17 +7350,17 @@ public static class set_player_sleeping_ignored extends AbstractFunction {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment env, Mixed... args)
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args)
 				throws ConfigRuntimeException {
 			final MCPlayer player;
 			final boolean value;
 			if(args.length == 1) {
 				player = env.getEnv(CommandHelperEnvironment.class).GetPlayer();
 				Static.AssertPlayerNonNull(player, t);
-				value = ArgumentValidation.getBoolean(args[0], t);
+				value = ArgumentValidation.getBoolean(args[0], t, env);
 			} else {
-				player = Static.GetPlayer(args[0], t);
-				value = ArgumentValidation.getBoolean(args[1], t);
+				player = Static.GetPlayer(args[0], t, env);
+				value = ArgumentValidation.getBoolean(args[1], t, env);
 			}
 			player.setSleepingIgnored(value);
 			return CVoid.VOID;
@@ -7405,14 +7406,14 @@ public static class is_player_sleeping_ignored extends AbstractFunction {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment env, Mixed... args)
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args)
 				throws ConfigRuntimeException {
 			final MCPlayer player;
 			if(args.length == 0) {
 				player = env.getEnv(CommandHelperEnvironment.class).GetPlayer();
 				Static.AssertPlayerNonNull(player, t);
 			} else {
-				player = Static.GetPlayer(args[0], t);
+				player = Static.GetPlayer(args[0], t, env);
 			}
 			return CBoolean.get(player.isSleepingIgnored());
 		}
@@ -7480,18 +7481,18 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			MCPlayer thisPlayer;
 			boolean isVanished;
 			MCPlayer otherPlayer;
 			if(args.length == 2) {
-				thisPlayer = environment.getEnv(CommandHelperEnvironment.class).GetPlayer();
-				isVanished = ArgumentValidation.getBooleanObject(args[0], t);
-				otherPlayer = Static.GetPlayer(args[1], t);
+				thisPlayer = env.getEnv(CommandHelperEnvironment.class).GetPlayer();
+				isVanished = ArgumentValidation.getBooleanObject(args[0], t, env);
+				otherPlayer = Static.GetPlayer(args[1], t, env);
 			} else {
-				thisPlayer = Static.GetPlayer(args[0], t);
-				isVanished = ArgumentValidation.getBooleanObject(args[1], t);
-				otherPlayer = Static.GetPlayer(args[2], t);
+				thisPlayer = Static.GetPlayer(args[0], t, env);
+				isVanished = ArgumentValidation.getBooleanObject(args[1], t, env);
+				otherPlayer = Static.GetPlayer(args[2], t, env);
 			}
 			otherPlayer.setVanished(isVanished, thisPlayer);
 			return CVoid.VOID;
@@ -7539,15 +7540,15 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			MCPlayer thisPlayer;
 			MCPlayer otherPlayer;
 			if(args.length == 1) {
-				thisPlayer = environment.getEnv(CommandHelperEnvironment.class).GetPlayer();
-				otherPlayer = Static.GetPlayer(args[0], t);
+				thisPlayer = env.getEnv(CommandHelperEnvironment.class).GetPlayer();
+				otherPlayer = Static.GetPlayer(args[0], t, env);
 			} else {
-				thisPlayer = Static.GetPlayer(args[0], t);
-				otherPlayer = Static.GetPlayer(args[1], t);
+				thisPlayer = Static.GetPlayer(args[0], t, env);
+				otherPlayer = Static.GetPlayer(args[1], t, env);
 			}
 			return CBoolean.get(thisPlayer.canSee(otherPlayer));
 		}
diff --git a/src/main/java/com/laytonsmith/core/functions/PluginMeta.java b/src/main/java/com/laytonsmith/core/functions/PluginMeta.java
index f7c1ff5926..7bf915f034 100644
--- a/src/main/java/com/laytonsmith/core/functions/PluginMeta.java
+++ b/src/main/java/com/laytonsmith/core/functions/PluginMeta.java
@@ -14,6 +14,7 @@
 import com.laytonsmith.core.constructs.CString;
 import com.laytonsmith.core.constructs.CVoid;
 import com.laytonsmith.core.constructs.Target;
+import com.laytonsmith.core.constructs.generics.GenericParameters;
 import com.laytonsmith.core.environments.CommandHelperEnvironment;
 import com.laytonsmith.core.environments.Environment;
 import com.laytonsmith.core.exceptions.CRE.CRECastException;
@@ -55,9 +56,9 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			MCPluginMeta meta = StaticLayer.GetConvertor().GetPluginMeta();
-			MCPlayer p = environment.getEnv(CommandHelperEnvironment.class).GetPlayer();
+			MCPlayer p = env.getEnv(CommandHelperEnvironment.class).GetPlayer();
 			int offset = 0;
 			if(args.length == 3) {
 				offset = 1;
@@ -118,9 +119,9 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 
-			MCPlayer p = environment.getEnv(CommandHelperEnvironment.class).GetPlayer();
+			MCPlayer p = env.getEnv(CommandHelperEnvironment.class).GetPlayer();
 			int offset = 0;
 			if(args.length == 3) {
 				offset = 1;
@@ -183,7 +184,7 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			MCMessenger messenger = Static.getServer().getMessenger();
 			if(messenger == null) {
 				throw new CRENotFoundException(
@@ -248,7 +249,7 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			MCMessenger messenger = Static.getServer().getMessenger();
 			if(messenger == null) {
 				throw new CRENotFoundException(
@@ -309,7 +310,7 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			MCMessenger messenger = Static.getServer().getMessenger();
 			if(messenger == null) {
 				throw new CRENotFoundException(
@@ -363,7 +364,7 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			MCMessenger messenger = Static.getServer().getMessenger();
 			if(messenger == null) {
 				throw new CRENotFoundException(
diff --git a/src/main/java/com/laytonsmith/core/functions/Recipes.java b/src/main/java/com/laytonsmith/core/functions/Recipes.java
index 16749a8b29..9d92fed8f9 100644
--- a/src/main/java/com/laytonsmith/core/functions/Recipes.java
+++ b/src/main/java/com/laytonsmith/core/functions/Recipes.java
@@ -11,6 +11,7 @@
 import com.laytonsmith.core.constructs.CBoolean;
 import com.laytonsmith.core.constructs.CVoid;
 import com.laytonsmith.core.constructs.Target;
+import com.laytonsmith.core.constructs.generics.GenericParameters;
 import com.laytonsmith.core.environments.CommandHelperEnvironment;
 import com.laytonsmith.core.environments.Environment;
 import com.laytonsmith.core.exceptions.CRE.CRECastException;
@@ -56,9 +57,9 @@ public Class<? extends CREThrowable>[] thrown() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			try {
-				return CBoolean.get(Static.getServer().addRecipe(ObjectGenerator.GetGenerator().recipe(args[0], t)));
+				return CBoolean.get(Static.getServer().addRecipe(ObjectGenerator.GetGenerator().recipe(args[0], t, env)));
 			} catch (IllegalStateException ex) {
 				// recipe with the given key probably already exists
 				return CBoolean.FALSE;
@@ -212,7 +213,7 @@ public Class<? extends CREThrowable>[] thrown() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			return CBoolean.get(Static.getServer().removeRecipe(args[0].val()));
 		}
 
@@ -247,12 +248,12 @@ public Class<? extends CREThrowable>[] thrown() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			CArray ret = new CArray(t);
-			MCItemStack item = ObjectGenerator.GetGenerator().item(args[0], t);
+			MCItemStack item = ObjectGenerator.GetGenerator().item(args[0], t, env);
 			List<MCRecipe> recipes = Static.getServer().getRecipesFor(item);
 			for(MCRecipe recipe : recipes) {
-				ret.push(ObjectGenerator.GetGenerator().recipe(recipe, t), t);
+				ret.push(ObjectGenerator.GetGenerator().recipe(recipe, t), t, env);
 			}
 
 			return ret;
@@ -291,11 +292,11 @@ public Class<? extends CREThrowable>[] thrown() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			CArray ret = new CArray(t);
 			List<MCRecipe> recipes = Static.getServer().allRecipes();
 			for(MCRecipe recipe : recipes) {
-				ret.push(ObjectGenerator.GetGenerator().recipe(recipe, t), t);
+				ret.push(ObjectGenerator.GetGenerator().recipe(recipe, t), t, env);
 			}
 
 			return ret;
@@ -332,7 +333,7 @@ public Class<? extends CREThrowable>[] thrown() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			Static.getServer().clearRecipes();
 			return CVoid.VOID;
 		}
@@ -368,7 +369,7 @@ public Class<? extends CREThrowable>[] thrown() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			Static.getServer().resetRecipes();
 			return CVoid.VOID;
 		}
diff --git a/src/main/java/com/laytonsmith/core/functions/Redis.java b/src/main/java/com/laytonsmith/core/functions/Redis.java
index 9b5de957a0..4a258c2e5a 100644
--- a/src/main/java/com/laytonsmith/core/functions/Redis.java
+++ b/src/main/java/com/laytonsmith/core/functions/Redis.java
@@ -68,7 +68,7 @@ public static String docs() {
 //		}
 //
 //		@Override
-//		public Construct exec(Target t, Environment environment, Construct... args) throws ConfigRuntimeException {
+//		public Construct exec(Target t, Environment env, Construct... args) throws ConfigRuntimeException {
 //			BuildFunctionList();
 //			throw new UnsupportedOperationException("TODO: Not supported yet.");
 //		}
diff --git a/src/main/java/com/laytonsmith/core/functions/Reflection.java b/src/main/java/com/laytonsmith/core/functions/Reflection.java
index 83e53f70ee..6b8577701b 100644
--- a/src/main/java/com/laytonsmith/core/functions/Reflection.java
+++ b/src/main/java/com/laytonsmith/core/functions/Reflection.java
@@ -30,6 +30,7 @@
 import com.laytonsmith.core.constructs.IVariable;
 import com.laytonsmith.core.constructs.NativeTypeList;
 import com.laytonsmith.core.constructs.Target;
+import com.laytonsmith.core.constructs.generics.GenericParameters;
 import com.laytonsmith.core.environments.CommandHelperEnvironment;
 import com.laytonsmith.core.environments.Environment;
 import com.laytonsmith.core.environments.GlobalEnv;
@@ -203,7 +204,7 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment env, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			if(args.length < 1) {
 				throw new CREInsufficientArgumentsException("Not enough parameters was sent to " + getName(), t);
 			}
@@ -218,7 +219,7 @@ public Mixed exec(Target t, Environment env, Mixed... args) throws ConfigRuntime
 					//No name provided
 					CArray ca = new CArray(t);
 					for(String name : env.getEnv(GlobalEnv.class).GetVarList().keySet()) {
-						ca.push(new CString(name, t), t);
+						ca.push(new CString(name, t), t, env);
 					}
 					return ca;
 				} else if(args.length == 2) {
@@ -268,11 +269,11 @@ public Mixed exec(Target t, Environment env, Mixed... args) throws ConfigRuntime
 						//No name provided
 						for(ClassMirror<? extends Enum> e : enums) {
 							String name = (String) e.getAnnotation(MEnum.class).getValue("value");
-							a.push(CClassType.get(FullyQualifiedClassName.forNativeEnum(e.loadClass())), t);
+							a.push(CClassType.get(FullyQualifiedClassName.forNativeEnum(e.loadClass())), t, env);
 						}
 						for(ClassMirror<? extends DynamicEnum> d : dEnums) {
 							String name = (String) d.getAnnotation(MDynamicEnum.class).getValue("value");
-							a.push(CClassType.get(FullyQualifiedClassName.forFullyQualifiedClass(name)), t);
+							a.push(CClassType.get(FullyQualifiedClassName.forFullyQualifiedClass(name)), t, env);
 						}
 					} catch (ClassNotFoundException ex) {
 						throw new Error(ex);
@@ -281,7 +282,7 @@ public Mixed exec(Target t, Environment env, Mixed... args) throws ConfigRuntime
 					FullyQualifiedClassName enumName = FullyQualifiedClassName.forName(args[1].val(), t, env);
 					try {
 						for(MEnumTypeValue v : NativeTypeList.getNativeEnumType(enumName).values()) {
-							a.push(v, t);
+							a.push(v, t, env);
 						}
 					} catch (ClassNotFoundException ex) {
 						// Actually, I don't think this can
@@ -294,9 +295,9 @@ public Mixed exec(Target t, Environment env, Mixed... args) throws ConfigRuntime
 					CArray a = new CArray(t);
 					List<String> l = new ArrayList<>(KeywordList.getKeywordNames());
 					l.forEach((String t1) -> {
-						a.push(new CString(t1, Target.UNKNOWN), Target.UNKNOWN);
+						a.push(new CString(t1, Target.UNKNOWN), Target.UNKNOWN, env);
 					});
-					return new ArrayHandling.array_sort().exec(t, env, a);
+					return new ArrayHandling.array_sort().exec(t, env, null, a);
 				} else if(args.length == 2) {
 					Keyword k = KeywordList.getKeywordByName(args[1].val());
 					if(k == null) {
@@ -355,25 +356,25 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			CClassType type = ArgumentValidation.getClassType(args[0], t);
-			CArray ret = CArray.GetAssociativeArray(t);
-			ret.set("fqcn", type.getFQCN().getFQCN());
-			ret.set("name", type.getFQCN().getSimpleName());
-			ret.set("interfaces", new CArray(t, type.getTypeInterfaces(environment)), t);
-			ret.set("superclasses", new CArray(t, type.getTypeSuperclasses(environment)), t);
+			CArray ret = CArray.GetAssociativeArray(t, null, env);
+			ret.set("fqcn", type.getFQCN().getFQCN(), env);
+			ret.set("name", type.getFQCN().getSimpleName(), env);
+			ret.set("interfaces", new CArray(t, type.getTypeInterfaces(env)), t, env);
+			ret.set("superclasses", new CArray(t, type.getTypeSuperclasses(env)), t, env);
 
 			CArray typeDocs = new CArray(t);
 			// When type unions are a thing, this will need to be implemented slightly differently.
 			for(CClassType m : Arrays.asList(type)) {
-				CArray docs = CArray.GetAssociativeArray(t);
-				docs.set("package", type.getPackage() == null ? CNull.NULL : type.getPackage(), t);
-				docs.set("isNative", CBoolean.get(type.getNativeType() != null), t);
-				docs.set("docs", m.getTypeDocs(t, environment));
-				docs.set("since", m.getTypeSince(t, environment).toString());
-				typeDocs.push(docs, t);
+				CArray docs = CArray.GetAssociativeArray(t, null, env);
+				docs.set("package", type.getPackage() == null ? CNull.NULL : type.getPackage(), t, env);
+				docs.set("isNative", CBoolean.get(type.getNativeType() != null), t, env);
+				docs.set("docs", m.getTypeDocs(t, env), env);
+				docs.set("since", m.getTypeSince(t, env).toString(), env);
+				typeDocs.push(docs, t, env);
 			}
-			ret.set("typeDocs", typeDocs, t);
+			ret.set("typeDocs", typeDocs, t, env);
 			return ret;
 		}
 
@@ -442,7 +443,7 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment env, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			String element = args[0].val();
 			DocField docField;
 			try {
@@ -596,17 +597,17 @@ private void initf(Environment env) {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
-			CArray ret = CArray.GetAssociativeArray(t);
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
+			CArray ret = CArray.GetAssociativeArray(t, null, env);
 			if(FUNCS.keySet().size() < 10) {
-				initf(environment);
+				initf(env);
 			}
 			for(String cname : FUNCS.keySet()) {
 				CArray fnames = new CArray(t);
 				for(String fname : FUNCS.get(cname)) {
-					fnames.push(new CString(fname, t), t);
+					fnames.push(new CString(fname, t), t, env);
 				}
-				ret.set(new CString(cname, t), fnames, t);
+				ret.set(new CString(cname, t), fnames, t, env);
 			}
 			return ret;
 		}
@@ -653,11 +654,11 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment,
+		public Mixed exec(Target t, Environment env, GenericParameters generics,
 				Mixed... args) throws ConfigRuntimeException {
 			CArray ret = new CArray(t);
 			for(Event event : EventList.GetEvents()) {
-				ret.push(new CString(event.getName(), t), t);
+				ret.push(new CString(event.getName(), t), t, env);
 			}
 			ret.sort(CArray.ArraySortType.STRING_IC);
 			return ret;
@@ -703,10 +704,10 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			CArray ret = new CArray(t);
 			for(Script s : Static.getAliasCore().getScripts()) {
-				ret.push(new CString(s.getSignature(), t), t);
+				ret.push(new CString(s.getSignature(), t), t, env);
 			}
 			ret.sort(CArray.ArraySortType.STRING_IC);
 			return ret;
@@ -752,8 +753,8 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
-			PersistenceNetwork pn = environment.getEnv(StaticRuntimeEnv.class).GetPersistenceNetwork();
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
+			PersistenceNetwork pn = env.getEnv(StaticRuntimeEnv.class).GetPersistenceNetwork();
 			return new CString(pn.getKeySource(args[0].val().split("\\.")).toString(), t);
 		}
 
@@ -803,10 +804,10 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			CArray ret = new CArray(t);
-			for(Map.Entry<String, Procedure> p : environment.getEnv(GlobalEnv.class).GetProcs().entrySet()) {
-				ret.push(new CString(p.getKey(), t), t);
+			for(Map.Entry<String, Procedure> p : env.getEnv(GlobalEnv.class).GetProcs().entrySet()) {
+				ret.push(new CString(p.getKey(), t), t, env);
 			}
 			ret.sort(CArray.ArraySortType.STRING_IC);
 			return ret;
@@ -868,12 +869,12 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			CArray ret = new CArray(t);
-			ObjectDefinitionTable odt = environment.getEnv(CompilerEnvironment.class).getObjectDefinitionTable();
+			ObjectDefinitionTable odt = env.getEnv(CompilerEnvironment.class).getObjectDefinitionTable();
 			for(ObjectDefinition od : odt.getObjectDefinitionSet()) {
 				try {
-					ret.push(CClassType.get(FullyQualifiedClassName.forFullyQualifiedClass(od.getClassName())), t);
+					ret.push(CClassType.get(FullyQualifiedClassName.forFullyQualifiedClass(od.getClassName())), t, env);
 				} catch (ClassNotFoundException ex) {
 					throw ConfigRuntimeException.CreateUncatchableException(ex.getMessage(), t);
 				}
@@ -936,10 +937,10 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			String type = ArgumentValidation.getStringObject(args[0], t);
 			try {
-				return CClassType.get(FullyQualifiedClassName.forName(args[0].val(), t, environment));
+				return CClassType.get(FullyQualifiedClassName.forName(args[0].val(), t, env));
 			} catch (CRECastException | ClassNotFoundException ex) {
 				throw new CRENotFoundException("Could not find type " + type, t);
 			}
diff --git a/src/main/java/com/laytonsmith/core/functions/Regex.java b/src/main/java/com/laytonsmith/core/functions/Regex.java
index d4fc2aba6b..0b87e7e6d1 100644
--- a/src/main/java/com/laytonsmith/core/functions/Regex.java
+++ b/src/main/java/com/laytonsmith/core/functions/Regex.java
@@ -4,6 +4,7 @@
 import com.laytonsmith.annotations.core;
 import com.laytonsmith.annotations.seealso;
 import com.laytonsmith.core.ArgumentValidation;
+import com.laytonsmith.core.CallbackYield;
 import com.laytonsmith.core.MSVersion;
 import com.laytonsmith.core.ObjectGenerator;
 import com.laytonsmith.core.Optimizable;
@@ -16,6 +17,7 @@
 import com.laytonsmith.core.constructs.CString;
 import com.laytonsmith.core.constructs.Construct;
 import com.laytonsmith.core.constructs.Target;
+import com.laytonsmith.core.constructs.generics.GenericParameters;
 import com.laytonsmith.core.environments.Environment;
 import com.laytonsmith.core.exceptions.CRE.CRECastException;
 import com.laytonsmith.core.exceptions.CRE.CREFormatException;
@@ -90,18 +92,18 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment env, Mixed... args) throws ConfigRuntimeException {
-			Pattern pattern = getPattern(args[0], t);
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
+			Pattern pattern = getPattern(args[0], t, env);
 			String subject = args[1].val();
 			Matcher m = pattern.matcher(subject);
 			if(m.find()) {
 				CArray ret = ObjectGenerator.GetGenerator().regMatchValue(m, t);
 				for(String key : getNamedGroups(pattern.pattern())) {
-					ret.set(key, m.group(key), t);
+					ret.set(key, m.group(key), t, env);
 				}
 				return ret;
 			}
-			return CArray.GetAssociativeArray(t);
+			return CArray.GetAssociativeArray(t, null, env);
 		}
 
 		@Override
@@ -110,7 +112,7 @@ public ParseTree optimizeDynamic(Target t, Environment env,
 				List<ParseTree> children, FileOptions fileOptions)
 				throws ConfigCompileException, ConfigRuntimeException {
 			if(!Construct.IsDynamicHelper(children.get(0).getData())) {
-				getPattern(children.get(0).getData(), t);
+				getPattern(children.get(0).getData(), t, env);
 			}
 			return null;
 		}
@@ -178,8 +180,8 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment env, Mixed... args) throws ConfigRuntimeException {
-			Pattern pattern = getPattern(args[0], t);
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
+			Pattern pattern = getPattern(args[0], t, env);
 			String subject = args[1].val();
 			CArray fret = new CArray(t);
 			Matcher m = pattern.matcher(subject);
@@ -188,9 +190,9 @@ public Mixed exec(Target t, Environment env, Mixed... args) throws ConfigRuntime
 				CArray ret = ObjectGenerator.GetGenerator().regMatchValue(m, t);
 
 				for(String key : namedGroups) {
-					ret.set(key, m.group(key), t);
+					ret.set(key, m.group(key), t, env);
 				}
-				fret.push(ret, t);
+				fret.push(ret, t, env);
 			}
 			return fret;
 		}
@@ -201,7 +203,7 @@ public ParseTree optimizeDynamic(Target t, Environment env,
 				List<ParseTree> children, FileOptions fileOptions)
 				throws ConfigCompileException, ConfigRuntimeException {
 			if(!Construct.IsDynamicHelper(children.get(0).getData())) {
-				getPattern(children.get(0).getData(), t);
+				getPattern(children.get(0).getData(), t, env);
 			}
 			return null;
 		}
@@ -230,7 +232,7 @@ public ExampleScript[] examples() throws ConfigCompileException {
 	}
 
 	@api
-	public static class reg_replace extends AbstractFunction implements Optimizable {
+	public static class reg_replace extends CallbackYield implements Optimizable {
 
 		@Override
 		public String getName() {
@@ -271,26 +273,55 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment env, Mixed... args) throws ConfigRuntimeException {
-			Pattern pattern = getPattern(args[0], t);
+		protected void execWithYield(Target t, Environment env, Mixed[] args, CallbackYield.Yield yield) {
+			Pattern pattern = getPattern(args[0], t, env);
 			Mixed replacement = args[1];
 			String subject = args[2].val();
-			String ret = "";
 
-			try {
-				if(replacement instanceof Callable replacer) {
-					ret = pattern.matcher(subject).replaceAll(mr -> ArgumentValidation.getStringObject(
-							replacer.executeCallable(env, t, ObjectGenerator.GetGenerator().regMatchValue(mr, t)), t));
+			if(replacement instanceof Callable replacer) {
+				// Collect all match positions upfront, then yield each closure call.
+				Matcher m = pattern.matcher(subject);
+				StringBuilder sb = new StringBuilder();
+				int lastEnd = 0;
+				boolean found = false;
+				try {
+					while(m.find()) {
+						found = true;
+						final int segStart = lastEnd;
+						final int matchStart = m.start();
+						CArray matchData = ObjectGenerator.GetGenerator().regMatchValue(m, t);
+						yield.call(replacer, env, t, matchData)
+								.then((result, y) -> {
+									sb.append(subject, segStart, matchStart);
+									sb.append(ArgumentValidation.getStringObject(result, t, env));
+								});
+						lastEnd = m.end();
+					}
+				} catch(IndexOutOfBoundsException e) {
+					throw new CREFormatException("Expecting a regex group at parameter 1 of reg_replace", t);
+				} catch(IllegalArgumentException e) {
+					throw new CREFormatException(e.getMessage(), t);
+				}
+				if(!found) {
+					yield.done(() -> new CString(subject, t));
 				} else {
-					ret = pattern.matcher(subject).replaceAll(replacement.val());
+					final int tail = lastEnd;
+					yield.done(() -> {
+						sb.append(subject, tail, subject.length());
+						return new CString(sb.toString(), t);
+					});
+				}
+			} else {
+				// Plain string replacement — no closures, synchronous.
+				try {
+					String ret = pattern.matcher(subject).replaceAll(replacement.val());
+					yield.done(() -> new CString(ret, t));
+				} catch(IndexOutOfBoundsException e) {
+					throw new CREFormatException("Expecting a regex group at parameter 1 of reg_replace", t);
+				} catch(IllegalArgumentException e) {
+					throw new CREFormatException(e.getMessage(), t);
 				}
-			} catch (IndexOutOfBoundsException e) {
-				throw new CREFormatException("Expecting a regex group at parameter 1 of reg_replace", t);
-			} catch (IllegalArgumentException e) {
-				throw new CREFormatException(e.getMessage(), t);
 			}
-
-			return new CString(ret, t);
 		}
 
 		@Override
@@ -314,7 +345,7 @@ public ParseTree optimizeDynamic(Target t, Environment env,
 					replaceNode.addChildAt(2, children.get(1)); //replacement -> that
 					return replaceNode;
 				} else {
-					getPattern(patternArg.getData(), t);
+					getPattern(patternArg.getData(), t, env);
 				}
 			}
 			return null;
@@ -392,8 +423,8 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment env, Mixed... args) throws ConfigRuntimeException {
-			Pattern pattern = getPattern(args[0], t);
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
+			Pattern pattern = getPattern(args[0], t, env);
 			String subject = args[1].val();
 			/**
 			 * We use a different indexing notation than Java's regex split. In the case of 0 for the limit, we will
@@ -404,12 +435,12 @@ public Mixed exec(Target t, Environment env, Mixed... args) throws ConfigRuntime
 			 */
 			int limit = Integer.MAX_VALUE - 1;
 			if(args.length >= 3) {
-				limit = ArgumentValidation.getInt32(args[2], t);
+				limit = ArgumentValidation.getInt32(args[2], t, env);
 			}
 			String[] rsplit = pattern.split(subject, limit + 1);
 			CArray ret = new CArray(t);
 			for(String split : rsplit) {
-				ret.push(new CString(split, t), t);
+				ret.push(new CString(split, t), t, env);
 			}
 			return ret;
 		}
@@ -429,7 +460,7 @@ public ParseTree optimizeDynamic(Target t, Environment env,
 					splitNode.addChildAt(1, children.get(1));
 					return splitNode;
 				} else {
-					getPattern(data.getData(), t);
+					getPattern(data.getData(), t, env);
 				}
 			}
 			return null;
@@ -492,8 +523,8 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment env, Mixed... args) throws ConfigRuntimeException {
-			Pattern pattern = getPattern(args[0], t);
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
+			Pattern pattern = getPattern(args[0], t, env);
 			String subject = args[1].val();
 			long ret = 0;
 			Matcher m = pattern.matcher(subject);
@@ -509,7 +540,7 @@ public ParseTree optimizeDynamic(Target t, Environment env,
 				List<ParseTree> children, FileOptions fileOptions)
 				throws ConfigCompileException, ConfigRuntimeException {
 			if(!Construct.IsDynamicHelper(children.get(0).getData())) {
-				getPattern(children.get(0).getData(), t);
+				getPattern(children.get(0).getData(), t, env);
 			}
 			return null;
 		}
@@ -551,7 +582,7 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			return new CString(java.util.regex.Pattern.quote(args[0].val()), t);
 		}
 
@@ -595,14 +626,14 @@ public ExampleScript[] examples() throws ConfigCompileException {
 
 	}
 
-	private static Pattern getPattern(Mixed c, Target t) throws ConfigRuntimeException {
+	private static Pattern getPattern(Mixed c, Target t, Environment env) throws ConfigRuntimeException {
 		String regex = "";
 		int flags = 0;
 		String sflags = "";
-		if(c.isInstanceOf(CArray.TYPE)) {
+		if(c.isInstanceOf(CArray.TYPE, null, env)) {
 			CArray ca = (CArray) c;
-			regex = ca.get(0, t).val();
-			sflags = ca.get(1, t).val();
+			regex = ca.get(0, t, env).val();
+			sflags = ca.get(1, t, env).val();
 			for(int i = 0; i < sflags.length(); i++) {
 				if(sflags.toLowerCase().charAt(i) == 'i') {
 					flags |= java.util.regex.Pattern.CASE_INSENSITIVE;
diff --git a/src/main/java/com/laytonsmith/core/functions/ResourceManager.java b/src/main/java/com/laytonsmith/core/functions/ResourceManager.java
index 290d6ba6a3..33592dde71 100644
--- a/src/main/java/com/laytonsmith/core/functions/ResourceManager.java
+++ b/src/main/java/com/laytonsmith/core/functions/ResourceManager.java
@@ -11,6 +11,7 @@
 import com.laytonsmith.core.constructs.CResource;
 import com.laytonsmith.core.constructs.CVoid;
 import com.laytonsmith.core.constructs.Target;
+import com.laytonsmith.core.constructs.generics.GenericParameters;
 import com.laytonsmith.core.environments.Environment;
 import com.laytonsmith.core.exceptions.CRE.CRECastException;
 import com.laytonsmith.core.exceptions.CRE.CREFormatException;
@@ -110,7 +111,7 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			ResourceTypes type;
 			Mixed data = null;
 			try {
@@ -209,8 +210,8 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
-			if(args[0].isInstanceOf(CResource.TYPE)) {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
+			if(args[0].isInstanceOf(CResource.TYPE, null, env)) {
 				CResource<?> resource = (CResource<?>) args[0];
 				if(RESOURCES.containsKey(resource.getId())) {
 					RESOURCES.remove(resource.getId());
diff --git a/src/main/java/com/laytonsmith/core/functions/SQL.java b/src/main/java/com/laytonsmith/core/functions/SQL.java
index 18e1d36c3c..c4498db372 100644
--- a/src/main/java/com/laytonsmith/core/functions/SQL.java
+++ b/src/main/java/com/laytonsmith/core/functions/SQL.java
@@ -28,6 +28,7 @@
 import com.laytonsmith.core.constructs.CVoid;
 import com.laytonsmith.core.constructs.Construct;
 import com.laytonsmith.core.constructs.Target;
+import com.laytonsmith.core.constructs.generics.GenericParameters;
 import com.laytonsmith.core.environments.Environment;
 import com.laytonsmith.core.environments.StaticRuntimeEnv;
 import com.laytonsmith.core.exceptions.ConfigCompileException;
@@ -150,17 +151,17 @@ public void run() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			try {
 				Profiles.Profile profile;
-				if(args[0].isInstanceOf(CArray.TYPE)) {
+				if(args[0].isInstanceOf(CArray.TYPE, null, env)) {
 					Map<String, String> data = new HashMap<>();
 					for(String key : ((CArray) args[0]).stringKeySet()) {
-						data.put(key, ((CArray) args[0]).get(key, t).val());
+						data.put(key, ((CArray) args[0]).get(key, t, env).val());
 					}
 					profile = ProfilesImpl.getProfile(data);
 				} else {
-					Profiles profiles = environment.getEnv(StaticRuntimeEnv.class).getProfiles();
+					Profiles profiles = env.getEnv(StaticRuntimeEnv.class).getProfiles();
 					profile = profiles.getProfileById(args[0].val());
 				}
 				if(!(profile instanceof SQLProfile)) {
@@ -200,20 +201,20 @@ public Mixed exec(Target t, Environment environment, Mixed... args) throws Confi
 							continue;
 						}
 						try {
-							if(params[i].isInstanceOf(CInt.TYPE)) {
-								ps.setLong(i + 1, ArgumentValidation.getInt(params[i], t));
-							} else if(params[i].isInstanceOf(CDouble.TYPE)) {
-								ps.setDouble(i + 1, (Double) ArgumentValidation.getDouble(params[i], t));
-							} else if(params[i].isInstanceOf(CString.TYPE)) {
+							if(params[i].isInstanceOf(CInt.TYPE, null, env)) {
+								ps.setLong(i + 1, ArgumentValidation.getInt(params[i], t, env));
+							} else if(params[i].isInstanceOf(CDouble.TYPE, null, env)) {
+								ps.setDouble(i + 1, (Double) ArgumentValidation.getDouble(params[i], t, env));
+							} else if(params[i].isInstanceOf(CString.TYPE, null, env)) {
 								if(type == Types.NCHAR || type == Types.NVARCHAR || type == Types.LONGNVARCHAR) {
 									ps.setNString(i + 1, (String) params[i].val());
 								} else {
 									ps.setString(i + 1, (String) params[i].val());
 								}
-							} else if(params[i].isInstanceOf(CByteArray.TYPE)) {
+							} else if(params[i] instanceof CByteArray) {
 								ps.setBytes(i + 1, ((CByteArray) params[i]).asByteArrayCopy());
-							} else if(params[i].isInstanceOf(CBoolean.TYPE)) {
-								ps.setBoolean(i + 1, ArgumentValidation.getBoolean(params[i], t));
+							} else if(params[i] instanceof CBoolean) {
+								ps.setBoolean(i + 1, ArgumentValidation.getBoolean(params[i], t, env));
 							} else {
 								throw new CRECastException("The type " + params[i].getClass().getSimpleName()
 										+ " of parameter " + (i + 1) + " is not supported.", t);
@@ -231,7 +232,7 @@ public Mixed exec(Target t, Environment environment, Mixed... args) throws Confi
 						ResultSetMetaData md = ps.getMetaData();
 						ResultSet rs = ps.getResultSet();
 						while(rs != null && rs.next()) {
-							CArray row = CArray.GetAssociativeArray(t);
+							CArray row = CArray.GetAssociativeArray(t, null, env);
 							for(int i = 1; i <= md.getColumnCount(); i++) {
 								Construct value;
 								int columnType = md.getColumnType(i);
@@ -297,9 +298,9 @@ public Mixed exec(Target t, Environment environment, Mixed... args) throws Confi
 								// for instance SELECT foo AS bar... then we would get "foo" from that. Instead,
 								// we use the column label, which in the example, would return "bar", which is what
 								// the user will expect in the results.
-								row.set(md.getColumnLabel(i), value, t);
+								row.set(md.getColumnLabel(i), value, t, env);
 							}
-							ret.push(row, t);
+							ret.push(row, t, env);
 						}
 						return ret;
 					} else {
@@ -346,7 +347,7 @@ public ParseTree optimizeDynamic(Target t, Environment env,
 					env.getEnv(CompilerEnvironment.class).addCompilerWarning(fileOptions,
 							new CompilerWarning(msg, t, null));
 				}
-			} else if(queryData.isInstanceOf(CString.TYPE)) {
+			} else if(queryData.isInstanceOf(CString.TYPE, null, env)) {
 				//It's a hard coded query, so we can double check parameter lengths and other things
 				String query = queryData.val();
 				int count = 0;
@@ -495,31 +496,31 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(final Target t, final Environment environment, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(final Target t, final Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			startup();
 			Mixed arg = args[args.length - 1];
-			if(!(arg.isInstanceOf(CClosure.TYPE))) {
+			if(!(arg.isInstanceOf(CClosure.TYPE, null, env))) {
 				throw new CRECastException("The last argument to " + getName() + " must be a closure.", t);
 			}
 			final CClosure closure = ((CClosure) arg);
 			final Mixed[] newArgs = new Mixed[args.length - 1];
 			//Make a new array minus the closure
 			System.arraycopy(args, 0, newArgs, 0, newArgs.length);
-			queue.invokeLater(environment.getEnv(StaticRuntimeEnv.class).GetDaemonManager(), new Runnable() {
+			queue.invokeLater(env.getEnv(StaticRuntimeEnv.class).GetDaemonManager(), new Runnable() {
 
 				@Override
 				public void run() {
 					Mixed returnValue = CNull.NULL;
 					Mixed exception = CNull.NULL;
 					try {
-						returnValue = new query().exec(t, environment, newArgs);
+						returnValue = new query().exec(t, env, null, newArgs);
 					} catch (ConfigRuntimeException ex) {
-						exception = ObjectGenerator.GetGenerator().exception(ex, environment, t);
+						exception = ObjectGenerator.GetGenerator().exception(ex, env, t);
 					}
 					final Mixed cret = returnValue;
 					final Mixed cex = exception;
 					StaticLayer.GetConvertor().runOnMainThreadLater(
-							environment.getEnv(StaticRuntimeEnv.class).GetDaemonManager(), new Runnable() {
+							env.getEnv(StaticRuntimeEnv.class).GetDaemonManager(), new Runnable() {
 
 						@Override
 						public void run() {
diff --git a/src/main/java/com/laytonsmith/core/functions/Sandbox.java b/src/main/java/com/laytonsmith/core/functions/Sandbox.java
index 037cf53459..396af57565 100644
--- a/src/main/java/com/laytonsmith/core/functions/Sandbox.java
+++ b/src/main/java/com/laytonsmith/core/functions/Sandbox.java
@@ -25,6 +25,7 @@
 import com.laytonsmith.core.constructs.CString;
 import com.laytonsmith.core.constructs.CVoid;
 import com.laytonsmith.core.constructs.Target;
+import com.laytonsmith.core.constructs.generics.GenericParameters;
 import com.laytonsmith.core.environments.CommandHelperEnvironment;
 import com.laytonsmith.core.environments.Environment;
 import com.laytonsmith.core.environments.GlobalEnv;
@@ -106,8 +107,8 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
-			BoundEvent.ActiveEvent original = environment.getEnv(GlobalEnv.class).GetEvent();
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
+			BoundEvent.ActiveEvent original = env.getEnv(GlobalEnv.class).GetEvent();
 			if(original == null) {
 				throw new CREBindException("is_cancelled cannot be called outside an event handler", t);
 			}
@@ -116,7 +117,7 @@ public Mixed exec(Target t, Environment environment, Mixed... args) throws Confi
 				((Cancellable) original.getUnderlyingEvent()).setCancelled(true);
 				BukkitDirtyRegisteredListener.setCancelled((org.bukkit.event.Event) original.getUnderlyingEvent());
 			}
-			environment.getEnv(GlobalEnv.class).GetEvent().setCancelled(true);
+			env.getEnv(GlobalEnv.class).GetEvent().setCancelled(true);
 			return CVoid.VOID;
 		}
 	}
@@ -155,7 +156,7 @@ public Integer[] numArgs() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			return new CString(GenerateMooSaying(args[0].val())
 					+ " \\   ^__^\n"
 					+ "  \\  (oo)\\_______\n"
@@ -176,7 +177,7 @@ public Integer[] numArgs() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			return new CString(
 					GenerateMooSaying(args[0].val())
 					+ "              ^__^   /\n"
@@ -198,7 +199,7 @@ public Integer[] numArgs() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			return new CString("  .-*)) `*-.\n"
 					+ " /*  ((*   *'.\n"
 					+ "|   *))  *   *\\\n"
@@ -215,7 +216,7 @@ public Mixed exec(Target t, Environment environment, Mixed... args) throws Confi
 	public static class norway extends DummyFunction {
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment environment, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			MCChatColor red = MCChatColor.RED;
 			MCChatColor white = MCChatColor.WHITE;
 			MCChatColor blue = MCChatColor.BLUE;
@@ -279,7 +280,7 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment environment, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			Random r;
 			try {
 				r = (Random) ArgumentValidation.getObject(args[0], t, CResource.class).getResource();
@@ -407,7 +408,7 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment env, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			try {
 				File file = Static.GetFileFromArgument(args[0].val(), env, t, null).getCanonicalFile();
 				if(!Static.InCmdLine(env, true) && !Security.CheckSecurity(file)) {
@@ -486,7 +487,7 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment environment, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			if(!Static.InCmdLine(environment, true)) {
 				throw new CRESecurityException(getName() + " is only available in cmdline mode.", t);
 			}
@@ -496,7 +497,7 @@ public Mixed exec(Target t, Environment environment, Mixed... args) throws Confi
 			}
 
 			byte[] content;
-			if(!(args[1].isInstanceOf(CByteArray.TYPE))) {
+			if(!(args[1] instanceof CByteArray)) {
 				content = args[1].val().getBytes(Charset.forName("UTF-8"));
 			} else {
 				content = ArgumentValidation.getByteArray(args[1], t).asByteArrayCopy();
diff --git a/src/main/java/com/laytonsmith/core/functions/Scheduling.java b/src/main/java/com/laytonsmith/core/functions/Scheduling.java
index 6c9cff182a..11c196618b 100644
--- a/src/main/java/com/laytonsmith/core/functions/Scheduling.java
+++ b/src/main/java/com/laytonsmith/core/functions/Scheduling.java
@@ -30,6 +30,7 @@
 import com.laytonsmith.core.constructs.CVoid;
 import com.laytonsmith.core.constructs.Construct;
 import com.laytonsmith.core.constructs.Target;
+import com.laytonsmith.core.constructs.generics.GenericParameters;
 import com.laytonsmith.core.environments.Environment;
 import com.laytonsmith.core.environments.GlobalEnv;
 import com.laytonsmith.core.environments.StaticRuntimeEnv;
@@ -43,7 +44,6 @@
 import com.laytonsmith.core.exceptions.CancelCommandException;
 import com.laytonsmith.core.exceptions.ConfigCompileException;
 import com.laytonsmith.core.exceptions.ConfigRuntimeException;
-import com.laytonsmith.core.exceptions.ProgramFlowManipulationException;
 import com.laytonsmith.core.natives.interfaces.Callable;
 import com.laytonsmith.core.natives.interfaces.Mixed;
 import com.laytonsmith.core.profiler.ProfilePoint;
@@ -130,7 +130,7 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment env, Mixed... args) throws CancelCommandException, ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws CancelCommandException, ConfigRuntimeException {
 			return new CInt(System.currentTimeMillis(), t);
 		}
 	}
@@ -175,7 +175,7 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment env, Mixed... args) throws CancelCommandException, ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws CancelCommandException, ConfigRuntimeException {
 			return new CInt(System.nanoTime(), t);
 		}
 	}
@@ -220,7 +220,7 @@ public MSVersion since() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment env, Mixed... args) throws CancelCommandException, ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws CancelCommandException, ConfigRuntimeException {
 			Mixed x = args[0];
 			double time = ArgumentValidation.getNumber(x, t);
 			try {
@@ -277,7 +277,7 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(final Target t, final Environment environment, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(final Target t, final Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			long time = ArgumentValidation.getInt(args[0], t);
 			int offset = 0;
 			long delay = time;
@@ -291,28 +291,26 @@ public Mixed exec(final Target t, final Environment environment, Mixed... args)
 			if(time < 0) {
 				throw new CRERangeException("Negative repeating delay", t);
 			}
-			if(!(args[1 + offset].isInstanceOf(Callable.TYPE))) {
+			if(!(args[1 + offset].isInstanceOf(Callable.TYPE, null, env))) {
 				throw new CRECastException(getName() + " expects a Callable to be sent as the second argument", t);
 			}
 			final Callable c = (Callable) args[1 + offset];
 			final AtomicInteger ret = new AtomicInteger(-1);
 
-			ret.set(StaticLayer.SetFutureRepeater(environment.getEnv(StaticRuntimeEnv.class).GetDaemonManager(), time, delay, () -> {
+			ret.set(StaticLayer.SetFutureRepeater(env.getEnv(StaticRuntimeEnv.class).GetDaemonManager(), time, delay, () -> {
 				c.getEnv().getEnv(GlobalEnv.class).SetCustom("timeout-id", ret.get());
 				try {
-					ProfilePoint p = environment.getEnv(StaticRuntimeEnv.class).GetProfiler().start("Executing timeout"
+					ProfilePoint p = env.getEnv(StaticRuntimeEnv.class).GetProfiler().start("Executing timeout"
 							+ " with id " + ret.get() + " (defined at " + t.toString() + ")", LogLevel.ERROR);
 					try {
-						c.executeCallable(environment, t);
+						c.executeCallable(env, t);
 					} finally {
 						p.stop();
 					}
 				} catch (ConfigRuntimeException e) {
-					ConfigRuntimeException.HandleUncaughtException(e, environment);
+					ConfigRuntimeException.HandleUncaughtException(e, env);
 				} catch (CancelCommandException e) {
 					//Ok
-				} catch (ProgramFlowManipulationException e) {
-					ConfigRuntimeException.DoWarning("Using a program flow manipulation construct improperly! " + e.getClass().getSimpleName());
 				}
 			}));
 			return new CInt(ret.get(), t);
@@ -383,19 +381,19 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(final Target t, final Environment environment, Mixed... args) throws ConfigRuntimeException {
-			final TaskManager taskManager = environment.getEnv(StaticRuntimeEnv.class).GetTaskManager();
+		public Mixed exec(final Target t, final Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
+			final TaskManager taskManager = env.getEnv(StaticRuntimeEnv.class).GetTaskManager();
 			long time = ArgumentValidation.getInt(args[0], t);
 			if(time < 0) {
 				throw new CRERangeException("Negative delay", t);
 			}
-			if(!(args[1].isInstanceOf(Callable.TYPE))) {
+			if(!(args[1].isInstanceOf(Callable.TYPE, null, env))) {
 				throw new CRECastException(getName() + " expects a Callable to be sent as the second argument", t);
 			}
 			final Callable c = (Callable) args[1];
 			final AtomicInteger ret = new AtomicInteger(-1);
 			ret.set(StaticLayer.SetFutureRunnable(
-					environment.getEnv(StaticRuntimeEnv.class).GetDaemonManager(), time, () -> {
+					env.getEnv(StaticRuntimeEnv.class).GetDaemonManager(), time, () -> {
 				c.getEnv().getEnv(GlobalEnv.class).SetCustom("timeout-id", ret.get());
 				TaskHandler task = taskManager.getTask(CoreTaskType.TIMEOUT, ret.get());
 				if(task == null) {
@@ -409,7 +407,7 @@ public Mixed exec(final Target t, final Environment environment, Mixed... args)
 					ProfilePoint p = c.getEnv().getEnv(StaticRuntimeEnv.class).GetProfiler().start("Executing timeout"
 							+ " with id " + ret.get() + " (defined at " + t.toString() + ")", LogLevel.ERROR);
 					try {
-						c.executeCallable(environment, t);
+						c.executeCallable(env, t);
 					} finally {
 						p.stop();
 					}
@@ -417,8 +415,6 @@ public Mixed exec(final Target t, final Environment environment, Mixed... args)
 					ConfigRuntimeException.HandleUncaughtException(e, c.getEnv());
 				} catch (CancelCommandException e) {
 					//Ok
-				} catch (ProgramFlowManipulationException e) {
-					ConfigRuntimeException.DoWarning("Using a program flow manipulation construct improperly! " + e.getClass().getSimpleName());
 				} finally {
 					// If the task was somehow killed in the closure, it'll already be finished
 					if(!task.getState().isFinalized()) {
@@ -497,16 +493,16 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
-			if(args.length == 0 && environment.getEnv(GlobalEnv.class).GetCustom("timeout-id") != null) {
-				StaticLayer.ClearFutureRunnable((Integer) environment.getEnv(GlobalEnv.class).GetCustom("timeout-id"));
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
+			if(args.length == 0 && env.getEnv(GlobalEnv.class).GetCustom("timeout-id") != null) {
+				StaticLayer.ClearFutureRunnable((Integer) env.getEnv(GlobalEnv.class).GetCustom("timeout-id"));
 			} else if(args.length == 1) {
 				if(args[0] instanceof CNull) {
 					throw new CRENullPointerException("Null value sent to " + getName()
 							+ "(). Did you mean " + getName() + "(0)?", t);
 				}
 				int id = ArgumentValidation.getInt32(args[0], t);
-				TaskManager taskManager = environment.getEnv(StaticRuntimeEnv.class).GetTaskManager();
+				TaskManager taskManager = env.getEnv(StaticRuntimeEnv.class).GetTaskManager();
 				TaskHandler task = taskManager.getTask(CoreTaskType.TIMEOUT, id);
 				if(task == null) { // may not be a timeout
 					StaticLayer.ClearFutureRunnable(id);
@@ -613,7 +609,7 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public CString exec(Target t, Environment env, Mixed... args) {
+		public CString exec(Target t, Environment env, GenericParameters generics, Mixed... args) {
 			Date now = new Date();
 			if(args.length >= 2 && !(args[1] instanceof CNull)) {
 				now = new Date(ArgumentValidation.getInt(args[1], t));
@@ -684,7 +680,7 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			SimpleDateFormat dateFormat;
 			Locale locale = Locale.getDefault();
 			if(args.length >= 3) {
@@ -765,7 +761,7 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			String[] timezones = ArrayUtils.EMPTY_STRING_ARRAY;
 			try {
 				timezones = TimeZone.getAvailableIDs();
@@ -852,12 +848,12 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			//First things first, check the format of the arguments.
-			if(!(args[0].isInstanceOf(CString.TYPE))) {
+			if(!(args[0].isInstanceOf(CString.TYPE, null, env))) {
 				throw new CRECastException("Expected string for argument 1 in " + getName(), t);
 			}
-			if(!(args[1].isInstanceOf(CClosure.TYPE))) {
+			if(!(args[1].isInstanceOf(CClosure.TYPE, null, env))) {
 				throw new CRECastException("Expected closure for argument 2 in " + getName(), t);
 			}
 			CronFormat format = validateFormat(args[0].val(), t);
@@ -866,7 +862,7 @@ public Mixed exec(Target t, Environment environment, Mixed... args) throws Confi
 			//then register this job, as well as inform clear_task of this id.
 			synchronized(CRON_THREAD_LOCK) {
 				if(cronThread == null) {
-					final DaemonManager dm = environment.getEnv(StaticRuntimeEnv.class).GetDaemonManager();
+					final DaemonManager dm = env.getEnv(StaticRuntimeEnv.class).GetDaemonManager();
 					final MutableObject<Boolean> stopCron = new MutableObject<>(false);
 					StaticLayer.GetConvertor().addShutdownHook(() -> {
 						cronThread = null;
@@ -1176,7 +1172,7 @@ public ParseTree optimizeDynamic(Target t, Environment env,
 				List<ParseTree> children, FileOptions fileOptions)
 				throws ConfigCompileException, ConfigRuntimeException {
 			if(children.get(0).isConst()) {
-				if(children.get(0).getData().isInstanceOf(CString.TYPE)) {
+				if(children.get(0).getData().isInstanceOf(CString.TYPE, null, env)) {
 					validateFormat(children.get(0).getData().val(), t);
 				}
 			}
@@ -1204,8 +1200,8 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
-			Integer id = (Integer) environment.getEnv(GlobalEnv.class).GetCustom("cron-task-id");
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
+			Integer id = (Integer) env.getEnv(GlobalEnv.class).GetCustom("cron-task-id");
 			if(args.length == 1) {
 				id = (int) ArgumentValidation.getInt(args[0], t);
 			}
diff --git a/src/main/java/com/laytonsmith/core/functions/Scoreboards.java b/src/main/java/com/laytonsmith/core/functions/Scoreboards.java
index a0998c38f2..79a9b680f9 100644
--- a/src/main/java/com/laytonsmith/core/functions/Scoreboards.java
+++ b/src/main/java/com/laytonsmith/core/functions/Scoreboards.java
@@ -28,6 +28,7 @@
 import com.laytonsmith.core.constructs.CVoid;
 import com.laytonsmith.core.constructs.Construct;
 import com.laytonsmith.core.constructs.Target;
+import com.laytonsmith.core.constructs.generics.GenericParameters;
 import com.laytonsmith.core.environments.CommandHelperEnvironment;
 import com.laytonsmith.core.environments.Environment;
 import com.laytonsmith.core.exceptions.CRE.CREFormatException;
@@ -256,7 +257,7 @@ public Class<? extends CREThrowable>[] thrown() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			MCPlayer p = Static.GetPlayer(args[0], t);
 			String ret;
 			try {
@@ -300,7 +301,7 @@ public Class<? extends CREThrowable>[] thrown() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			MCPlayer p = Static.GetPlayer(args[0], t);
 			p.setScoreboard(assignBoard(1, t, args));
 			return CVoid.VOID;
@@ -337,10 +338,10 @@ public Class<? extends CREThrowable>[] thrown() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			CArray ret = new CArray(t);
 			for(String id : BOARDS.keySet()) {
-				ret.push(new CString(id, t), t);
+				ret.push(new CString(id, t), t, env);
 			}
 			return ret;
 		}
@@ -372,7 +373,7 @@ public MSVersion since() {
 	public static class get_objectives extends SBFunction {
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			MCScoreboard s;
 			if(args.length == 0) {
 				s = getBoard(MAIN, t);
@@ -393,17 +394,17 @@ public Mixed exec(Target t, Environment environment, Mixed... args) throws Confi
 			}
 			CArray ret = new CArray(t);
 			for(MCObjective o : os) {
-				CArray obj = CArray.GetAssociativeArray(t);
-				obj.set("name", new CString(o.getName(), t), t);
-				obj.set("displayname", new CString(o.getDisplayName(), t), t);
+				CArray obj = CArray.GetAssociativeArray(t, null, env);
+				obj.set("name", new CString(o.getName(), t), t, env);
+				obj.set("displayname", new CString(o.getDisplayName(), t), t, env);
 				Construct slot = CNull.NULL;
 				if(o.getDisplaySlot() != null) {
 					slot = new CString(o.getDisplaySlot().name(), t);
 				}
-				obj.set("slot", slot, t);
-				obj.set("modifiable", CBoolean.get(o.isModifiable()), t);
-				obj.set("criteria", new CString(o.getCriteria(), t), t);
-				ret.push(obj, t);
+				obj.set("slot", slot, t, env);
+				obj.set("modifiable", CBoolean.get(o.isModifiable()), t, env);
+				obj.set("criteria", new CString(o.getCriteria(), t), t, env);
+				ret.push(obj, t, env);
 			}
 			return ret;
 		}
@@ -436,16 +437,16 @@ public MSVersion since() {
 	public static class get_teams extends SBFunction {
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			MCScoreboard s;
 			if(args.length == 0) {
 				s = getBoard(MAIN, t);
 			} else {
 				s = getBoard(args[0].val(), t);
 			}
-			CArray ret = CArray.GetAssociativeArray(t);
+			CArray ret = CArray.GetAssociativeArray(t, null, env);
 			for(MCTeam team : s.getTeams()) {
-				ret.set(team.getName(), getTeam(team, t), t);
+				ret.set(team.getName(), getTeam(team, t), t, env);
 			}
 			return ret;
 		}
@@ -483,7 +484,7 @@ public Class<? extends CREThrowable>[] thrown() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			MCScoreboard newBoard = Static.getServer().getNewScoreboard();
 			if(newBoard == null) {
 				throw new CRENullPointerException(
@@ -520,7 +521,7 @@ public MSVersion since() {
 	public static class create_objective extends SBFunction {
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			MCScoreboard s = assignBoard(2, t, args);
 			String name = args[0].val();
 			MCCriteria criteria = MCCriteria.DUMMY;
@@ -568,7 +569,7 @@ public MSVersion since() {
 	public static class create_team extends SBFunction {
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			MCScoreboard s = assignBoard(1, t, args);
 			String name = args[0].val();
 			try {
@@ -611,37 +612,37 @@ public Class<? extends CREThrowable>[] thrown() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			MCScoreboard s = assignBoard(2, t, args);
 			MCObjective o = s.getObjective(args[0].val());
 			if(o == null) {
 				throw new CREScoreboardException("No objective by that name exists.", t);
 			}
-			CArray dis = CArray.GetAssociativeArray(t);
-			if(args[1].isInstanceOf(CArray.TYPE)) {
+			CArray dis = CArray.GetAssociativeArray(t, null, env);
+			if(args[1].isInstanceOf(CArray.TYPE, null, env)) {
 				dis = (CArray) args[1];
 			} else {
-				dis.set("displayname", args[1], t);
+				dis.set("displayname", args[1], t, env);
 			}
 			if(dis.containsKey("slot")) {
 				MCDisplaySlot slot;
-				if(dis.get("slot", t) instanceof CNull) {
+				if(dis.get("slot", t, env) instanceof CNull) {
 					slot = null;
 				} else {
 					try {
-						slot = MCDisplaySlot.valueOf(dis.get("slot", t).val().toUpperCase());
+						slot = MCDisplaySlot.valueOf(dis.get("slot", t, env).val().toUpperCase());
 					} catch (IllegalArgumentException iae) {
-						throw new CREFormatException("Unknown displayslot: " + dis.get("slot", t).val(), t);
+						throw new CREFormatException("Unknown displayslot: " + dis.get("slot", t, env).val(), t);
 					}
 				}
 				o.setDisplaySlot(slot);
 			}
 			if(dis.containsKey("displayname")) {
 				String dname;
-				if(dis.get("displayname", t) instanceof CNull) {
+				if(dis.get("displayname", t, env) instanceof CNull) {
 					dname = o.getName();
 				} else {
-					dname = dis.get("displayname", t).val();
+					dname = dis.get("displayname", t, env).val();
 				}
 				try {
 					o.setDisplayName(dname);
@@ -692,24 +693,24 @@ public Class<? extends CREThrowable>[] thrown() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			MCScoreboard s = assignBoard(2, t, args);
 			MCTeam o = s.getTeam(args[0].val());
 			if(o == null) {
 				throw new CREScoreboardException("No team by that name exists.", t);
 			}
-			CArray dis = CArray.GetAssociativeArray(t);
-			if(args[1].isInstanceOf(CArray.TYPE)) {
+			CArray dis = CArray.GetAssociativeArray(t, null, env);
+			if(args[1].isInstanceOf(CArray.TYPE, null, env)) {
 				dis = (CArray) args[1];
 			} else {
-				dis.set("displayname", args[1], t);
+				dis.set("displayname", args[1], t, env);
 			}
 			if(dis.containsKey("displayname")) {
 				String dname;
-				if(dis.get("displayname", t) instanceof CNull) {
+				if(dis.get("displayname", t, env) instanceof CNull) {
 					dname = o.getName();
 				} else {
-					dname = dis.get("displayname", t).val();
+					dname = dis.get("displayname", t, env).val();
 				}
 				try {
 					o.setDisplayName(dname);
@@ -720,10 +721,10 @@ public Mixed exec(Target t, Environment environment, Mixed... args) throws Confi
 			}
 			if(dis.containsKey("prefix")) {
 				String prefix;
-				if(dis.get("prefix", t) instanceof CNull) {
+				if(dis.get("prefix", t, env) instanceof CNull) {
 					prefix = "";
 				} else {
-					prefix = dis.get("prefix", t).val();
+					prefix = dis.get("prefix", t, env).val();
 				}
 				try {
 					o.setPrefix(prefix);
@@ -734,10 +735,10 @@ public Mixed exec(Target t, Environment environment, Mixed... args) throws Confi
 			}
 			if(dis.containsKey("suffix")) {
 				String suffix;
-				if(dis.get("suffix", t) instanceof CNull) {
+				if(dis.get("suffix", t, env) instanceof CNull) {
 					suffix = "";
 				} else {
-					suffix = dis.get("suffix", t).val();
+					suffix = dis.get("suffix", t, env).val();
 				}
 				try {
 					o.setSuffix(suffix);
@@ -748,11 +749,11 @@ public Mixed exec(Target t, Environment environment, Mixed... args) throws Confi
 			}
 			if(dis.containsKey("color")) {
 				try {
-					MCChatColor color = MCChatColor.valueOf(dis.get("color", t).val().toUpperCase());
+					MCChatColor color = MCChatColor.valueOf(dis.get("color", t, env).val().toUpperCase());
 					o.setColor(color);
 				} catch (IllegalArgumentException ex) {
 					throw new CREIllegalArgumentException("Invalid chat color: \""
-							+ dis.get("color", t).val() + "\"", t);
+							+ dis.get("color", t, env).val() + "\"", t);
 				}
 			}
 			return CVoid.VOID;
@@ -797,7 +798,7 @@ public MSVersion since() {
 	public static class team_add_player extends SBFunction {
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			MCScoreboard s = assignBoard(2, t, args);
 			MCTeam team = s.getTeam(args[0].val());
 			if(team == null) {
@@ -833,7 +834,7 @@ public MSVersion since() {
 	public static class team_remove_player extends SBFunction {
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			MCScoreboard s = assignBoard(2, t, args);
 			MCTeam team = s.getTeam(args[0].val());
 			if(team == null) {
@@ -868,7 +869,7 @@ public MSVersion since() {
 	public static class get_pteam extends SBFunction {
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			MCScoreboard s = assignBoard(1, t, args);
 			MCTeam team = s.getPlayerTeam(args[0].val());
 			if(team == null) {
@@ -904,11 +905,11 @@ public MSVersion since() {
 	public static class remove_scoreboard extends SBFunction {
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			String id = args[0].val();
 			boolean nullify = true;
 			if(args.length == 2) {
-				nullify = ArgumentValidation.getBoolean(args[1], t);
+				nullify = ArgumentValidation.getBoolean(args[1], t, env);
 			}
 			if(nullify) {
 				MCScoreboard s = getBoard(id, t);
@@ -960,7 +961,7 @@ public MSVersion since() {
 	public static class remove_objective extends SBFunction {
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			MCScoreboard s = assignBoard(1, t, args);
 			MCObjective o = s.getObjective(args[0].val());
 			try {
@@ -998,7 +999,7 @@ public MSVersion since() {
 	public static class remove_team extends SBFunction {
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			MCScoreboard s = assignBoard(1, t, args);
 			MCTeam team = s.getTeam(args[0].val());
 			try {
@@ -1041,7 +1042,7 @@ public Class<? extends CREThrowable>[] thrown() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			MCScoreboard s = assignBoard(2, t, args);
 			MCObjective o = s.getObjective(args[0].val());
 			if(o == null) {
@@ -1086,14 +1087,14 @@ public Class<? extends CREThrowable>[] thrown() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			MCScoreboard s = assignBoard(3, t, args);
 			MCObjective o = s.getObjective(args[0].val());
 			if(o == null) {
 				throw new CREScoreboardException("The given objective does not exist.", t);
 			}
 			try {
-				o.getScore(args[1].val()).setScore(ArgumentValidation.getInt32(args[2], t));
+				o.getScore(args[1].val()).setScore(ArgumentValidation.getInt32(args[2], t, env));
 			} catch (IllegalArgumentException ex) {
 				throw new CRELengthException(ex.getMessage(), t);
 			}
@@ -1127,7 +1128,7 @@ public MSVersion since() {
 	public static class reset_all_pscores extends SBFunction {
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			assignBoard(1, t, args).resetScores(args[0].val());
 			return CVoid.VOID;
 		}
@@ -1163,26 +1164,26 @@ public Class<? extends CREThrowable>[] thrown() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			MCScoreboard s = assignBoard(2, t, args);
 			MCTeam team = s.getTeam(args[0].val());
 			if(team == null) {
 				throw new CREScoreboardException("No team by that name exists.", t);
 			}
-			if(args[1].isInstanceOf(CArray.TYPE)) {
+			if(args[1].isInstanceOf(CArray.TYPE, null, env)) {
 				CArray options = (CArray) args[1];
 				if(options.containsKey("friendlyfire")) {
-					team.setAllowFriendlyFire(ArgumentValidation.getBoolean(options.get("friendlyfire", t), t));
+					team.setAllowFriendlyFire(ArgumentValidation.getBoolean(options.get("friendlyfire", t, env), t, env));
 				}
 				if(options.containsKey("friendlyinvisibles")) {
-					team.setCanSeeFriendlyInvisibles(ArgumentValidation.getBoolean(options.get("friendlyinvisibles", t), t));
+					team.setCanSeeFriendlyInvisibles(ArgumentValidation.getBoolean(options.get("friendlyinvisibles", t, env), t, env));
 				}
 				if(options.containsKey("nametagvisibility")) {
 					MCOptionStatus namevisibility;
 					try {
-						namevisibility = MCOptionStatus.valueOf(options.get("nametagvisibility", t).val().toUpperCase());
+						namevisibility = MCOptionStatus.valueOf(options.get("nametagvisibility", t, env).val().toUpperCase());
 					} catch (IllegalArgumentException iae) {
-						String name = options.get("nametagvisibility", t).val().toUpperCase();
+						String name = options.get("nametagvisibility", t, env).val().toUpperCase();
 						if(name.startsWith("HIDE_")) {
 							name = name.substring(5);
 							try {
@@ -1191,7 +1192,7 @@ public Mixed exec(Target t, Environment environment, Mixed... args) throws Confi
 										+ "HIDE_" + name + "\". This should be: \"" + name + "\"", t);
 							} catch (IllegalArgumentException ex) {
 								throw new CREFormatException("Unknown nametagvisibility: "
-										+ options.get("nametagvisibility", t).val(), t);
+										+ options.get("nametagvisibility", t, env).val(), t);
 							}
 						} else {
 							throw new CREFormatException("Unknown nametagvisibility: " + name, t);
@@ -1202,20 +1203,20 @@ public Mixed exec(Target t, Environment environment, Mixed... args) throws Confi
 				if(options.containsKey("collisionrule")) {
 					MCOptionStatus collision;
 					try {
-						collision = MCOptionStatus.valueOf(options.get("collisionrule", t).val().toUpperCase());
+						collision = MCOptionStatus.valueOf(options.get("collisionrule", t, env).val().toUpperCase());
 					} catch (IllegalArgumentException iae) {
 						throw new CREFormatException("Unknown collisionrule: "
-								+ options.get("collisionrule", t).val(), t);
+								+ options.get("collisionrule", t, env).val(), t);
 					}
 					team.setOption(MCOption.COLLISION_RULE, collision);
 				}
 				if(options.containsKey("deathmessagevisibility")) {
 					MCOptionStatus deathvisibility;
 					try {
-						deathvisibility = MCOptionStatus.valueOf(options.get("deathmessagevisibility", t).val().toUpperCase());
+						deathvisibility = MCOptionStatus.valueOf(options.get("deathmessagevisibility", t, env).val().toUpperCase());
 					} catch (IllegalArgumentException iae) {
 						throw new CREFormatException("Unknown deathmessagevisibility: "
-								+ options.get("deathmessagevisibility", t).val(), t);
+								+ options.get("deathmessagevisibility", t, env).val(), t);
 					}
 					team.setOption(MCOption.DEATH_MESSAGE_VISIBILITY, deathvisibility);
 				}
@@ -1254,12 +1255,12 @@ public MSVersion since() {
 	public static class get_scoreboard_entries extends SBFunction {
 
 		@Override
-		public Mixed exec(Target t, Environment env, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			MCScoreboard s = assignBoard(0, t, args);
 			Set<String> entries = s.getEntries();
 			CArray ret = new CArray(t, entries.size());
 			for(String r : entries) {
-				ret.push(new CString(r, t), t);
+				ret.push(new CString(r, t), t, env);
 			}
 			return ret;
 		}
diff --git a/src/main/java/com/laytonsmith/core/functions/Statistics.java b/src/main/java/com/laytonsmith/core/functions/Statistics.java
index 53484ad166..870c82c122 100644
--- a/src/main/java/com/laytonsmith/core/functions/Statistics.java
+++ b/src/main/java/com/laytonsmith/core/functions/Statistics.java
@@ -10,6 +10,7 @@
 import com.laytonsmith.core.constructs.CDouble;
 import com.laytonsmith.core.constructs.CNumber;
 import com.laytonsmith.core.constructs.Target;
+import com.laytonsmith.core.constructs.generics.GenericParameters;
 import com.laytonsmith.core.environments.Environment;
 import com.laytonsmith.core.exceptions.CRE.CRECastException;
 import com.laytonsmith.core.exceptions.CRE.CREIndexOverflowException;
@@ -67,15 +68,15 @@ public Set<OptimizationOption> optimizationOptions() {
 	public static class average extends StatisticsFunction {
 
 		@Override
-		public CNumber exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
+		public CNumber exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			long count;
-			if(args.length == 1 && args[0].isInstanceOf(CArray.TYPE)) {
-				CArray c = ArgumentValidation.getArray(args[0], t);
-				count = c.size();
+			if(args.length == 1 && args[0].isInstanceOf(CArray.TYPE, null, env)) {
+				CArray c = ArgumentValidation.getArray(args[0], t, env);
+				count = c.size(env);
 			} else {
 				count = args.length;
 			}
-			double sum = new sum().exec(t, environment, args).getNumber();
+			double sum = new sum().exec(t, env, null, args).getNumber();
 			return new CDouble(sum / count, t);
 		}
 
@@ -117,16 +118,16 @@ public ExampleScript[] examples() throws ConfigCompileException {
 	public static class sum extends StatisticsFunction {
 
 		@Override
-		public CNumber exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
+		public CNumber exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			List<Double> values = new ArrayList<>();
-			if(args.length == 1 && args[0].isInstanceOf(CArray.TYPE)) {
-				CArray c = ArgumentValidation.getArray(args[0], t);
-				for(Mixed m : c.asList()) {
-					values.add(ArgumentValidation.getDouble(m, t));
+			if(args.length == 1 && args[0].isInstanceOf(CArray.TYPE, null, env)) {
+				CArray c = ArgumentValidation.getArray(args[0], t, env);
+				for(Mixed m : c.asList(env)) {
+					values.add(ArgumentValidation.getDouble(m, t, env));
 				}
 			} else {
 				for(Mixed m : args) {
-					values.add(ArgumentValidation.getDouble(m, t));
+					values.add(ArgumentValidation.getDouble(m, t, env));
 				}
 			}
 			double value = 0;
@@ -173,16 +174,16 @@ public ExampleScript[] examples() throws ConfigCompileException {
 	public static class median extends StatisticsFunction {
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			List<Double> values = new ArrayList<>();
-			if(args.length == 1 && args[0].isInstanceOf(CArray.TYPE)) {
-				CArray c = ArgumentValidation.getArray(args[0], t);
-				for(Mixed m : c.asList()) {
-					values.add(ArgumentValidation.getDouble(m, t));
+			if(args.length == 1 && args[0].isInstanceOf(CArray.TYPE, null, env)) {
+				CArray c = ArgumentValidation.getArray(args[0], t, env);
+				for(Mixed m : c.asList(env)) {
+					values.add(ArgumentValidation.getDouble(m, t, env));
 				}
 			} else {
 				for(Mixed m : args) {
-					values.add(ArgumentValidation.getDouble(m, t));
+					values.add(ArgumentValidation.getDouble(m, t, env));
 				}
 			}
 			Collections.sort(values);
@@ -237,22 +238,22 @@ public ExampleScript[] examples() throws ConfigCompileException {
 	public static class mode extends StatisticsFunction {
 
 		@Override
-		public CArray exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
+		public CArray exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			List<Double> values = new ArrayList<>();
-			if(args.length == 1 && args[0].isInstanceOf(CArray.TYPE)) {
-				CArray c = ArgumentValidation.getArray(args[0], t);
-				for(Mixed m : c.asList()) {
-					values.add(ArgumentValidation.getDouble(m, t));
+			if(args.length == 1 && args[0].isInstanceOf(CArray.TYPE, null, env)) {
+				CArray c = ArgumentValidation.getArray(args[0], t, env);
+				for(Mixed m : c.asList(env)) {
+					values.add(ArgumentValidation.getDouble(m, t, env));
 				}
 			} else {
 				for(Mixed m : args) {
-					values.add(ArgumentValidation.getDouble(m, t));
+					values.add(ArgumentValidation.getDouble(m, t, env));
 				}
 			}
 			List<Double> returns = mode(values);
 			CArray ret = new CArray(t, returns.size());
 			for(Double d : returns) {
-				ret.push(new CDouble(d, t), t);
+				ret.push(new CDouble(d, t), t, env);
 			}
 			return ret;
 		}
@@ -336,12 +337,12 @@ public Class<? extends CREThrowable>[] thrown() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
-			double percentile = ArgumentValidation.getDouble(args[0], t);
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
+			double percentile = ArgumentValidation.getDouble(args[0], t, env);
 			List<Double> values = new ArrayList<>();
-			if(args.length == 2 && args[1].isInstanceOf(CArray.TYPE)) {
-				CArray c = ArgumentValidation.getArray(args[1], t);
-				for(Mixed m : c.asList()) {
+			if(args.length == 2 && args[1].isInstanceOf(CArray.TYPE, null, env)) {
+				CArray c = ArgumentValidation.getArray(args[1], t, env);
+				for(Mixed m : c.asList(env)) {
 					values.add(ArgumentValidation.getNumber(m, t));
 				}
 			} else {
diff --git a/src/main/java/com/laytonsmith/core/functions/StringHandling.java b/src/main/java/com/laytonsmith/core/functions/StringHandling.java
index cc9e8b0fbe..0c134f6ad4 100644
--- a/src/main/java/com/laytonsmith/core/functions/StringHandling.java
+++ b/src/main/java/com/laytonsmith/core/functions/StringHandling.java
@@ -33,6 +33,7 @@
 import com.laytonsmith.core.constructs.Construct;
 import com.laytonsmith.core.constructs.InstanceofUtil;
 import com.laytonsmith.core.constructs.Target;
+import com.laytonsmith.core.constructs.generics.GenericParameters;
 import com.laytonsmith.core.environments.Environment;
 import com.laytonsmith.core.exceptions.CRE.CRECastException;
 import com.laytonsmith.core.exceptions.CRE.CREError;
@@ -97,7 +98,7 @@ public Class<? extends CREThrowable>[] thrown() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment env, Mixed... args) throws CancelCommandException, ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws CancelCommandException, ConfigRuntimeException {
 			StringBuilder b = new StringBuilder();
 			for(int i = 0; i < args.length; i++) {
 				b.append(args[i].val());
@@ -172,7 +173,7 @@ public Integer[] numArgs() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment env, Mixed... args) throws CancelCommandException, ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws CancelCommandException, ConfigRuntimeException {
 			StringBuilder b = new StringBuilder();
 			for(int i = 0; i < args.length; i++) {
 				if(i > 0) {
@@ -256,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) {
@@ -301,7 +302,7 @@ public Integer[] numArgs() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment env, Mixed... args) throws CancelCommandException, ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws CancelCommandException, ConfigRuntimeException {
 			String thing = args[0].val();
 			String what = args[1].val();
 			String that = args[2].val();
@@ -362,11 +363,11 @@ public Integer[] numArgs() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment env, Mixed... args) throws CancelCommandException, ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws CancelCommandException, ConfigRuntimeException {
 			String string = args[0].val();
 			boolean useAdvanced = false;
 			if(args.length >= 2) {
-				useAdvanced = ArgumentValidation.getBoolean(args[1], t);
+				useAdvanced = ArgumentValidation.getBoolean(args[1], t, env);
 			}
 			List<Mixed> a = new ArrayList<>();
 			if(!useAdvanced) {
@@ -469,7 +470,7 @@ public MSVersion since() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment env, Mixed... args) throws CancelCommandException, ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws CancelCommandException, ConfigRuntimeException {
 			return new CString(args[0].val().trim(), args[0].getTarget());
 		}
 
@@ -526,7 +527,7 @@ public MSVersion since() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment env, Mixed... args) throws CancelCommandException, ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws CancelCommandException, ConfigRuntimeException {
 			return new CString(StringUtils.trimRight(args[0].val()), args[0].getTarget());
 		}
 
@@ -583,7 +584,7 @@ public MSVersion since() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment env, Mixed... args) throws CancelCommandException, ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws CancelCommandException, ConfigRuntimeException {
 			return new CString(StringUtils.trimLeft(args[0].val()), t);
 		}
 
@@ -646,8 +647,8 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment env, Mixed... args) throws CancelCommandException, ConfigRuntimeException {
-			if(args[0].isInstanceOf(Sizeable.TYPE)) {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws CancelCommandException, ConfigRuntimeException {
+			if(args[0].isInstanceOf(Sizeable.TYPE, null, env)) {
 				return new CInt(((Sizeable) args[0]).size(), t);
 			} else {
 				return new CInt(args[0].val().length(), t);
@@ -708,10 +709,10 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment env, Mixed... args) throws CancelCommandException, ConfigRuntimeException {
-			if(!(args[0].isInstanceOf(CString.TYPE))) {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws CancelCommandException, ConfigRuntimeException {
+			if(!(args[0].isInstanceOf(CString.TYPE, null, env))) {
 				throw new CREFormatException(this.getName() + " expects a string as first argument, but type "
-						+ args[0].typeof() + " was found.", t);
+						+ args[0].typeof(env) + " was found.", t);
 			}
 			return new CString(args[0].val().toUpperCase(), t);
 		}
@@ -771,10 +772,10 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment env, Mixed... args) throws CancelCommandException, ConfigRuntimeException {
-			if(!(args[0].isInstanceOf(CString.TYPE))) {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws CancelCommandException, ConfigRuntimeException {
+			if(!(args[0].isInstanceOf(CString.TYPE, null, env))) {
 				throw new CREFormatException(this.getName() + " expects a string as first argument, but type "
-						+ args[0].typeof() + " was found.", t);
+						+ args[0].typeof(env) + " was found.", t);
 			}
 			return new CString(args[0].val().toLowerCase(), t);
 		}
@@ -837,13 +838,13 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment env, Mixed... args) throws CancelCommandException, ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws CancelCommandException, ConfigRuntimeException {
 			try {
 				String s = args[0].val();
-				int begin = ArgumentValidation.getInt32(args[1], t);
+				int begin = ArgumentValidation.getInt32(args[1], t, env);
 				int end;
 				if(args.length == 3) {
-					end = ArgumentValidation.getInt32(args[2], t);
+					end = ArgumentValidation.getInt32(args[2], t, env);
 				} else {
 					end = s.length();
 				}
@@ -893,7 +894,7 @@ public String docs() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment env, Mixed... args) throws CancelCommandException, ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws CancelCommandException, ConfigRuntimeException {
 			Static.AssertNonCNull(t, args);
 
 			String teststring = args[0].val();
@@ -961,7 +962,7 @@ public String docs() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment env, Mixed... args) throws CancelCommandException, ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws CancelCommandException, ConfigRuntimeException {
 			Static.AssertNonCNull(t, args);
 
 			String teststring = args[0].val();
@@ -1021,7 +1022,7 @@ public String getName() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws CancelCommandException, ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws CancelCommandException, ConfigRuntimeException {
 			if(args[0] instanceof CNull) {
 				throw new CRECastException(this.getName() + " expects a string as first argument, but found null.", t);
 			}
@@ -1125,7 +1126,7 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment env, Mixed... args) throws CancelCommandException, ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws CancelCommandException, ConfigRuntimeException {
 			Static.AssertNonCNull(t, args);
 			String haystack = args[0].val();
 			String needle = args[1].val();
@@ -1309,7 +1310,7 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment env, Mixed... args) throws CancelCommandException, ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws CancelCommandException, ConfigRuntimeException {
 			//http://stackoverflow.com/questions/2667015/is-regex-too-slow-real-life-examples-where-simple-non-regex-alternative-is-bett
 			//According to this, regex isn't necessarily slower, but we do want to escape the pattern either way, since the main advantage
 			//of this function is convenience (not speed) however, if we can eek out a little extra speed too, excellent.
@@ -1318,13 +1319,13 @@ public Mixed exec(Target t, Environment env, Mixed... args) throws CancelCommand
 			String string = args[1].val();
 			int limit = Integer.MAX_VALUE;
 			if(args.length >= 3) {
-				limit = ArgumentValidation.getInt32(args[2], t);
+				limit = ArgumentValidation.getInt32(args[2], t, env);
 			}
 			int sp = 0;
 			if(split.length() == 0) {
 				//Empty string, so special case.
 				for(int i = 0; i < string.length(); i++) {
-					array.push(new CString(string.charAt(i), t), t);
+					array.push(new CString(string.charAt(i), t), t, env);
 				}
 				return array;
 			}
@@ -1333,16 +1334,16 @@ public Mixed exec(Target t, Environment env, Mixed... args) throws CancelCommand
 				if(string.substring(i, i + split.length()).equals(split)) {
 					//Split point found
 					splitsFound++;
-					array.push(new CString(string.substring(sp, i), t), t);
+					array.push(new CString(string.substring(sp, i), t), t, env);
 					sp = i + split.length();
 					i += split.length() - 1;
 				}
 			}
 			if(sp != 0) {
-				array.push(new CString(string.substring(sp, string.length()), t), t);
+				array.push(new CString(string.substring(sp, string.length()), t), t, env);
 			} else {
 				//It was not found anywhere, so put the whole string in
-				array.push(args[1], t);
+				array.push(args[1], t, env);
 			}
 			return array;
 		}
@@ -1386,7 +1387,7 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			if(args.length < 2) {
 				throw new CREInsufficientArgumentsException(getName() + " expects 2 or more arguments", t);
 			}
@@ -1419,7 +1420,7 @@ public Mixed exec(Target t, Environment environment, Mixed... args) throws Confi
 			}
 
 			List<Mixed> flattenedArgs = new ArrayList<>();
-			if(numArgs == 3 && args[2].isInstanceOf(CArray.TYPE)) {
+			if(numArgs == 3 && args[2].isInstanceOf(CArray.TYPE, null, env)) {
 				if(((CArray) args[2]).inAssociativeMode()) {
 					throw new CRECastException("If the second argument to " + getName() + " is an array, it may not be associative.", t);
 				} else {
@@ -1936,7 +1937,7 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			String val = args[0].val();
 			String encoding = "UTF-8";
 			if(args.length == 2) {
@@ -1992,8 +1993,8 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
-			CByteArray ba = ArgumentValidation.getByteArray(args[0], t);
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
+			CByteArray ba = ArgumentValidation.getByteArray(args[0], t, env);
 			String encoding = "UTF-8";
 			if(args.length == 2) {
 				encoding = args[1].val();
@@ -2047,7 +2048,7 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			if(args.length < 2) {
 				throw new CREInsufficientArgumentsException(getName() + " must have 2 arguments at minimum", t);
 			}
@@ -2136,9 +2137,9 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			try {
-				return new CString(new String(Character.toChars(ArgumentValidation.getInt32(args[0], t))), t);
+				return new CString(new String(Character.toChars(ArgumentValidation.getInt32(args[0], t, env))), t);
 			} catch (IllegalArgumentException ex) {
 				throw new CRERangeException("Code point out of range: " + args[0].val(), t);
 			}
@@ -2204,7 +2205,7 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			if(args[0].val().toCharArray().length == 0) {
 				throw new CRERangeException("Empty string cannot be converted to unicode.", t);
 			}
@@ -2262,7 +2263,7 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			return new CInt(StringUtils.LevenshteinDistance(args[0].val(), args[1].val()), t);
 		}
 
@@ -2319,7 +2320,7 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			return new CInt(args[0].val().compareTo(args[1].val()), t);
 		}
 
@@ -2364,7 +2365,7 @@ public ExampleScript[] examples() throws ConfigCompileException {
 	public static class string_compare_ic extends string_compare {
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			return new CInt(args[0].val().compareToIgnoreCase(args[1].val()), t);
 		}
 
@@ -2417,12 +2418,12 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			if(args[0] instanceof CNull) {
 				return CNull.NULL;
 			}
 			String string = args[0].val();
-			int times = ArgumentValidation.getInt32(args[1], t);
+			int times = ArgumentValidation.getInt32(args[1], t, env);
 			if(times < 0) {
 				throw new CRERangeException("Expecting a value >= 0, but " + times + " was found.", t);
 			}
@@ -2526,9 +2527,9 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
-			if(args[0].isInstanceOf(CArray.TYPE)) {
-				CArray array = ArgumentValidation.getArray(args[0], t);
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
+			if(args[0].isInstanceOf(CArray.TYPE, null, env)) {
+				CArray array = ArgumentValidation.getArray(args[0], t, env);
 				return new CSecureString(array, t);
 			} else {
 				String s = args[0].val();
@@ -2604,14 +2605,14 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
-			if(args[0].isInstanceOf(CSecureString.TYPE)) {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
+			if(args[0].isInstanceOf(CSecureString.TYPE, null, env)) {
 				CSecureString secure = ArgumentValidation.getObject(args[0], t, CSecureString.class);
 				return secure.getDecryptedCharCArray();
-			} else if(args[0].isInstanceOf(CString.TYPE)) {
+			} else if(args[0].isInstanceOf(CString.TYPE, null, env)) {
 				CArray array = new CArray(Target.UNKNOWN, args[0].val().length());
 				for(char c : args[0].val().toCharArray()) {
-					array.push(new CString(c, t), t);
+					array.push(new CString(c, t), t, env);
 				}
 				return array;
 			} else {
@@ -2713,7 +2714,7 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			UUIDType type = UUIDType.RANDOM;
 			String input = null;
 			if(args.length > 0) {
diff --git a/src/main/java/com/laytonsmith/core/functions/TaskHandling.java b/src/main/java/com/laytonsmith/core/functions/TaskHandling.java
index d058dcb761..24fcb604e0 100644
--- a/src/main/java/com/laytonsmith/core/functions/TaskHandling.java
+++ b/src/main/java/com/laytonsmith/core/functions/TaskHandling.java
@@ -10,6 +10,7 @@
 import com.laytonsmith.core.constructs.CInt;
 import com.laytonsmith.core.constructs.CVoid;
 import com.laytonsmith.core.constructs.Target;
+import com.laytonsmith.core.constructs.generics.GenericParameters;
 import com.laytonsmith.core.environments.Environment;
 import com.laytonsmith.core.environments.StaticRuntimeEnv;
 import com.laytonsmith.core.exceptions.CRE.CRECastException;
@@ -50,21 +51,21 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
-			TaskManager tm = environment.getEnv(StaticRuntimeEnv.class).GetTaskManager();
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
+			TaskManager tm = env.getEnv(StaticRuntimeEnv.class).GetTaskManager();
 			CArray ret = new CArray(t);
 			for(TaskHandler task : tm.getTasks()) {
-				CArray tt = CArray.GetAssociativeArray(t);
-				tt.set("id", new CInt(task.getID(), t), t);
-				tt.set("type", task.getType().name());
-				tt.set("state", task.getState().name());
-				tt.set("target", task.getDefinedAt().toString());
-				CArray properties = CArray.GetAssociativeArray(t);
+				CArray tt = CArray.GetAssociativeArray(t, null, env);
+				tt.set("id", new CInt(task.getID(), t), t, env);
+				tt.set("type", task.getType().name(), env);
+				tt.set("state", task.getState().name(), env);
+				tt.set("target", task.getDefinedAt().toString(), env);
+				CArray properties = CArray.GetAssociativeArray(t, null, env);
 				for(String prop : task.getProperties()) {
-					properties.set(prop, task.getPropertyData().get(prop).toString());
+					properties.set(prop, task.getPropertyData().get(prop).toString(), env);
 				}
-				tt.set("properties", properties, t);
-				ret.push(tt, t);
+				tt.set("properties", properties, t, env);
+				ret.push(tt, t, env);
 			}
 			return ret;
 		}
@@ -134,10 +135,10 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			String type = args[0].val();
-			int id = ArgumentValidation.getInt32(args[1], t);
-			TaskManager tm = environment.getEnv(StaticRuntimeEnv.class).GetTaskManager();
+			int id = ArgumentValidation.getInt32(args[1], t, env);
+			TaskManager tm = env.getEnv(StaticRuntimeEnv.class).GetTaskManager();
 			tm.killTask(type, id);
 			return CVoid.VOID;
 		}
diff --git a/src/main/java/com/laytonsmith/core/functions/Threading.java b/src/main/java/com/laytonsmith/core/functions/Threading.java
index 7b00b4757d..3653e9c66a 100644
--- a/src/main/java/com/laytonsmith/core/functions/Threading.java
+++ b/src/main/java/com/laytonsmith/core/functions/Threading.java
@@ -10,9 +10,12 @@
 import com.laytonsmith.annotations.noboilerplate;
 import com.laytonsmith.annotations.seealso;
 import com.laytonsmith.core.ArgumentValidation;
+import com.laytonsmith.core.FlowFunction;
 import com.laytonsmith.core.MSVersion;
 import com.laytonsmith.core.ParseTree;
-import com.laytonsmith.core.Script;
+import com.laytonsmith.core.StepAction.Complete;
+import com.laytonsmith.core.StepAction.Evaluate;
+import com.laytonsmith.core.StepAction.StepResult;
 import com.laytonsmith.core.compiler.BranchStatement;
 import com.laytonsmith.core.compiler.SelfStatement;
 import com.laytonsmith.core.compiler.VariableScope;
@@ -23,6 +26,7 @@
 import com.laytonsmith.core.constructs.CString;
 import com.laytonsmith.core.constructs.CVoid;
 import com.laytonsmith.core.constructs.Target;
+import com.laytonsmith.core.constructs.generics.GenericParameters;
 import com.laytonsmith.core.environments.Environment;
 import com.laytonsmith.core.environments.StaticRuntimeEnv;
 import com.laytonsmith.core.exceptions.CRE.CRECastException;
@@ -33,8 +37,6 @@
 import com.laytonsmith.core.exceptions.CancelCommandException;
 import com.laytonsmith.core.exceptions.ConfigCompileException;
 import com.laytonsmith.core.exceptions.ConfigRuntimeException;
-import com.laytonsmith.core.exceptions.LoopManipulationException;
-import com.laytonsmith.core.exceptions.ProgramFlowManipulationException;
 import com.laytonsmith.core.natives.interfaces.Mixed;
 import com.laytonsmith.core.natives.interfaces.ValueType;
 import java.util.ArrayList;
@@ -84,25 +86,21 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(final Target t, final Environment env, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(final Target t, final Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			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 (LoopManipulationException ex) {
-						ConfigRuntimeException.HandleUncaughtException(ConfigRuntimeException.CreateUncatchableException("Unexpected loop manipulation"
-								+ " operation was triggered inside the closure.", t), env);
 					} catch (ConfigRuntimeException ex) {
 						ConfigRuntimeException.HandleUncaughtException(ex, env);
 					} catch (CancelCommandException ex) {
 						if(ex.getMessage() != null) {
-							new Echoes.console().exec(t, env, new CString(ex.getMessage(), t), CBoolean.FALSE);
+							new Echoes.console().exec(t, env, null, new CString(ex.getMessage(), t), CBoolean.FALSE);
 						}
 					} finally {
 						dm.deactivateThread(Thread.currentThread());
@@ -114,6 +112,7 @@ public void run() {
 					}
 				}
 			};
+			dm.activateThread(th, threadId);
 			th.start();
 			synchronized(THREAD_ID_MAP) {
 				THREAD_ID_MAP.put(threadId, th);
@@ -183,7 +182,7 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			return new CString(Thread.currentThread().getName(), t);
 		}
 
@@ -237,7 +236,7 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(final Target t, final Environment env, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(final Target t, final Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			final com.laytonsmith.core.natives.interfaces.Callable closure
 					= ArgumentValidation.getObject(args[0], t, com.laytonsmith.core.natives.interfaces.Callable.class);
 			StaticLayer.GetConvertor().runOnMainThreadLater(
@@ -249,7 +248,7 @@ public void run() {
 						closure.executeCallable(env, t);
 					} catch (ConfigRuntimeException e) {
 						ConfigRuntimeException.HandleUncaughtException(e, env);
-					} catch (ProgramFlowManipulationException e) {
+					} catch (CancelCommandException e) {
 						// Ignored
 					}
 				}
@@ -302,7 +301,7 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(final Target t, final Environment env, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(final Target t, final Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			final com.laytonsmith.core.natives.interfaces.Callable closure = ArgumentValidation.getObject(args[0], t,
 					com.laytonsmith.core.natives.interfaces.Callable.class);
 			Object ret;
@@ -313,7 +312,7 @@ public Mixed exec(final Target t, final Environment env, Mixed... args) throws C
 					public Object call() throws Exception {
 						try {
 							return closure.executeCallable(env, t);
-						} catch (ConfigRuntimeException | ProgramFlowManipulationException e) {
+						} catch (ConfigRuntimeException | CancelCommandException e) {
 							return e;
 						}
 					}
@@ -370,13 +369,13 @@ public Version since() {
 	 */
 	private static final Map<Object, Lock> SYNC_OBJECT_LOCKS = new HashMap<>();
 
-	private static Lock getSyncObject(Mixed cSyncObject, Function f, Target t) {
+	private static Lock getSyncObject(Mixed cSyncObject, Function f, Target t, Environment env) {
 
 		if(cSyncObject instanceof CNull || cSyncObject == null) {
 			throw new CRENullPointerException("Synchronization object may not be null in " + f.getName() + "().", t);
 		}
 		Object syncObject = cSyncObject;
-		if(cSyncObject.isInstanceOf(ValueType.TYPE)) {
+		if(cSyncObject.isInstanceOf(ValueType.TYPE, null, env)) {
 			if(!(cSyncObject instanceof CString)) {
 				throw new CREIllegalArgumentException("Only strings and non-value types can be used for synchronization.", t);
 			}
@@ -459,7 +458,7 @@ private static void PumpQueue(Lock syncObject, DaemonManager dm) {
 	@noboilerplate
 	@seealso({x_new_thread.class, x_get_lock.class})
 	@SelfStatement
-	public static class _synchronized extends AbstractFunction implements VariableScope, BranchStatement {
+	public static class _synchronized extends AbstractFunction implements FlowFunction<_synchronized.SyncState>, VariableScope, BranchStatement {
 
 
 
@@ -484,35 +483,52 @@ public boolean preResolveVariables() {
 		}
 
 		@Override
-		public boolean useSpecialExec() {
-			return true;
+		public Mixed exec(final Target t, final Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
+			return CVoid.VOID;
 		}
 
-		@Override
-		public Mixed execs(Target t, Environment env, Script parent, ParseTree... nodes) {
+		// -- FlowFunction implementation --
+		// Phase 1: evaluate sync object (arg 0, with IVariable resolution)
+		// Phase 2: acquire lock, evaluate code (arg 1)
+		// cleanup() releases the lock if acquired
 
-			// Get the sync object tree and the code to synchronize.
-			ParseTree syncObjectTree = nodes[0];
-			ParseTree code = nodes[1];
+		static class SyncState {
+			enum Phase { EVAL_SYNC_OBJ, EVAL_CODE }
+			Phase phase = Phase.EVAL_SYNC_OBJ;
+			ParseTree[] children;
+			Lock syncObject;
+		}
 
-			// Get the sync object (CArray or String value of the Mixed).
-			Mixed cSyncObject = parent.seval(syncObjectTree, env);
-			Lock syncObject = getSyncObject(cSyncObject, this, t);
+		@Override
+		public StepResult<SyncState> begin(Target t, ParseTree[] children, Environment env) {
+			SyncState state = new SyncState();
+			state.children = children;
+			return new StepResult<>(new Evaluate(children[0]), state);
+		}
 
-			// Evaluate the code, synchronized by the passed sync object.
-			try {
-				syncObject.lock();
-				parent.eval(code, env);
-			} finally {
-				syncObject.unlock();
-				cleanupSync(syncObject);
+		@Override
+		public StepResult<SyncState> childCompleted(Target t, SyncState state,
+				Mixed result, Environment env) {
+			switch(state.phase) {
+				case EVAL_SYNC_OBJ -> {
+					state.syncObject = getSyncObject(result, this, t, env);
+					state.syncObject.lock();
+					state.phase = SyncState.Phase.EVAL_CODE;
+					return new StepResult<>(new Evaluate(state.children[1]), state);
+				}
+				case EVAL_CODE -> {
+					return new StepResult<>(new Complete(CVoid.VOID), state);
+				}
 			}
-			return CVoid.VOID;
+			throw new Error("Unreachable");
 		}
 
 		@Override
-		public Mixed exec(final Target t, final Environment env, Mixed... args) throws ConfigRuntimeException {
-			return CVoid.VOID;
+		public void cleanup(Target t, SyncState state, Environment env) {
+			if(state != null && state.syncObject != null) {
+				state.syncObject.unlock();
+				cleanupSync(state.syncObject);
+			}
 		}
 
 		@Override
@@ -631,14 +647,14 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment env, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			// Get the sync object tree and the code to synchronize.
 			Mixed cSyncObject = args[0];
 			com.laytonsmith.core.natives.interfaces.Callable callable
 					= ArgumentValidation.getObject(args[1], t, com.laytonsmith.core.natives.interfaces.Callable.class);
 
 			// Get the sync object (CArray or String value of the Mixed).
-			Lock syncObject = getSyncObject(cSyncObject, this, t);
+			Lock syncObject = getSyncObject(cSyncObject, this, t, env);
 
 			// Evaluate the code, synchronized by the passed sync object.
 			DaemonManager dm = env.getEnv(StaticRuntimeEnv.class).GetDaemonManager();
@@ -726,7 +742,7 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			String threadId = args[0].val();
 			Thread th;
 			synchronized(THREAD_ID_MAP) {
@@ -791,7 +807,7 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			String threadId = args[0].val();
 			Thread th;
 			synchronized(THREAD_ID_MAP) {
@@ -844,7 +860,7 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			Thread th;
 			if(args.length == 1) {
 				String threadId = args[0].val();
@@ -904,7 +920,7 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			if(args.length == 1) {
 				String threadId = args[0].val();
 				Thread th;
@@ -963,7 +979,7 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			return CBoolean.get(Thread.interrupted());
 		}
 
diff --git a/src/main/java/com/laytonsmith/core/functions/Trades.java b/src/main/java/com/laytonsmith/core/functions/Trades.java
index 8493ca3b57..8daccc71ed 100644
--- a/src/main/java/com/laytonsmith/core/functions/Trades.java
+++ b/src/main/java/com/laytonsmith/core/functions/Trades.java
@@ -21,6 +21,7 @@
 import com.laytonsmith.core.constructs.CString;
 import com.laytonsmith.core.constructs.CVoid;
 import com.laytonsmith.core.constructs.Target;
+import com.laytonsmith.core.constructs.generics.GenericParameters;
 import com.laytonsmith.core.environments.CommandHelperEnvironment;
 import com.laytonsmith.core.environments.Environment;
 import com.laytonsmith.core.exceptions.CRE.CREBadEntityException;
@@ -57,10 +58,10 @@ public Class<? extends CREThrowable>[] thrown() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment env, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			CArray ret = new CArray(t);
 			for(MCMerchantRecipe mr : GetMerchant(args[0], t).getRecipes()) {
-				ret.push(trade(mr, t), t);
+				ret.push(trade(mr, t, env), t, env);
 			}
 			return ret;
 		}
@@ -97,15 +98,15 @@ public Class<? extends CREThrowable>[] thrown() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment env, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			MCMerchant merchant = GetMerchant(args[0], t);
-			CArray trades = ArgumentValidation.getArray(args[1], t);
+			CArray trades = ArgumentValidation.getArray(args[1], t, env);
 			List<MCMerchantRecipe> recipes = new ArrayList<>();
 			if(trades.isAssociative()) {
 				throw new CRECastException("Expected non-associative array for list of trade arrays.", t);
 			}
-			for(Mixed trade : trades.asList()) {
-				recipes.add(trade(trade, t));
+			for(Mixed trade : trades.asList(env)) {
+				recipes.add(trade(trade, t, env));
 			}
 			merchant.setRecipes(recipes);
 			return CVoid.VOID;
@@ -169,14 +170,14 @@ public Class<? extends CREThrowable>[] thrown() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment env, Mixed... args) throws ConfigRuntimeException {
-			CArray ret = CArray.GetAssociativeArray(t);
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
+			CArray ret = CArray.GetAssociativeArray(t, null, env);
 			for(Map.Entry<String, MCMerchant> entry : VIRTUAL_MERCHANTS.entrySet()) {
 				if(entry.getValue() == null) {
 					VIRTUAL_MERCHANTS.remove(entry.getKey());
 					continue;
 				}
-				ret.set(entry.getKey(), entry.getValue().getTitle(), t);
+				ret.set(entry.getKey(), entry.getValue().getTitle(), t, env);
 			}
 			return ret;
 		}
@@ -212,7 +213,7 @@ public Class<? extends CREThrowable>[] thrown() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment env, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			if(VIRTUAL_MERCHANTS.containsKey(args[0].val())) {
 				throw new CREIllegalArgumentException("There is already a merchant with id " + args[0].val(), t);
 			} else {
@@ -255,7 +256,7 @@ public Class<? extends CREThrowable>[] thrown() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment env, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			return CBoolean.get(VIRTUAL_MERCHANTS.remove(args[0].val()) != null);
 		}
 
@@ -291,16 +292,16 @@ public Class<? extends CREThrowable>[] thrown() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment env, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			MCPlayer player;
 			boolean force = false;
 			if(args.length > 1) {
-				player = Static.GetPlayer(args[1], t);
+				player = Static.GetPlayer(args[1], t, env);
 			} else {
 				player = Static.getPlayer(env, t);
 			}
 			if(args.length == 3) {
-				force = ArgumentValidation.getBooleanish(args[2], t);
+				force = ArgumentValidation.getBooleanish(args[2], t, env);
 			}
 			MCMerchant merchant = GetMerchant(args[0], t);
 			if(!force && merchant.isTrading()) {
@@ -344,7 +345,7 @@ public Class<? extends CREThrowable>[] thrown() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			MCMerchant merchant = GetMerchant(args[0], t);
 			return merchant.isTrading() ? new CString(merchant.getTrader().getUniqueId().toString(), t) : CNull.NULL;
 		}
@@ -398,55 +399,55 @@ private static MCMerchant GetMerchant(Mixed specifier, Target t) {
 		return merchant;
 	}
 
-	private static MCMerchantRecipe trade(Mixed c, Target t) {
+	private static MCMerchantRecipe trade(Mixed c, Target t, Environment env) {
 
-		CArray recipe = ArgumentValidation.getArray(c, t);
+		CArray recipe = ArgumentValidation.getArray(c, t, env);
 
-		MCItemStack result = ObjectGenerator.GetGenerator().item(recipe.get("result", t), t);
+		MCItemStack result = ObjectGenerator.GetGenerator().item(recipe.get("result", t, env), t, env);
 
 		MCMerchantRecipe mer = (MCMerchantRecipe) StaticLayer.GetNewRecipe(null, MCRecipeType.MERCHANT, result);
 
 		if(recipe.containsKey("maxuses")) {
-			mer.setMaxUses(ArgumentValidation.getInt32(recipe.get("maxuses", t), t));
+			mer.setMaxUses(ArgumentValidation.getInt32(recipe.get("maxuses", t, env), t, env));
 		}
 		if(recipe.containsKey("uses")) {
-			mer.setUses(ArgumentValidation.getInt32(recipe.get("uses", t), t));
+			mer.setUses(ArgumentValidation.getInt32(recipe.get("uses", t, env), t, env));
 		}
 		if(recipe.containsKey("hasxpreward")) {
-			mer.setHasExperienceReward(ArgumentValidation.getBoolean(recipe.get("hasxpreward", t), t));
+			mer.setHasExperienceReward(ArgumentValidation.getBoolean(recipe.get("hasxpreward", t, env), t, env));
 		}
 
-		CArray ingredients = ArgumentValidation.getArray(recipe.get("ingredients", t), t);
+		CArray ingredients = ArgumentValidation.getArray(recipe.get("ingredients", t, env), t, env);
 		if(ingredients.inAssociativeMode()) {
 			throw new CREFormatException("Ingredients array is invalid.", t);
 		}
-		if(ingredients.size() < 1 || ingredients.size() > 2) {
+		if(ingredients.size(env) < 1 || ingredients.size(env) > 2) {
 			throw new CRERangeException("Ingredients for merchants must contain 1 or 2 items, found "
-					+ ingredients.size(), t);
+					+ ingredients.size(env), t);
 		}
 		List<MCItemStack> mcIngredients = new ArrayList<>();
-		for(Mixed ingredient : ingredients.asList()) {
-			mcIngredients.add(ObjectGenerator.GetGenerator().item(ingredient, t));
+		for(Mixed ingredient : ingredients.asList(env)) {
+			mcIngredients.add(ObjectGenerator.GetGenerator().item(ingredient, t, env));
 		}
 		mer.setIngredients(mcIngredients);
 
 		return mer;
 	}
 
-	private static Mixed trade(MCMerchantRecipe r, Target t) {
+	private static Mixed trade(MCMerchantRecipe r, Target t, Environment env) {
 		if(r == null) {
 			return CNull.NULL;
 		}
-		CArray ret = CArray.GetAssociativeArray(t);
-		ret.set("result", ObjectGenerator.GetGenerator().item(r.getResult(), t), t);
+		CArray ret = CArray.GetAssociativeArray(t, null, env);
+		ret.set("result", ObjectGenerator.GetGenerator().item(r.getResult(), t), t, env);
 		CArray il = new CArray(t);
 		for(MCItemStack i : r.getIngredients()) {
-			il.push(ObjectGenerator.GetGenerator().item(i, t), t);
+			il.push(ObjectGenerator.GetGenerator().item(i, t), t, env);
 		}
-		ret.set("ingredients", il, t);
-		ret.set("maxuses", new CInt(r.getMaxUses(), t), t);
-		ret.set("uses", new CInt(r.getUses(), t), t);
-		ret.set("hasxpreward", CBoolean.get(r.hasExperienceReward()), t);
+		ret.set("ingredients", il, t, env);
+		ret.set("maxuses", new CInt(r.getMaxUses(), t), t, env);
+		ret.set("uses", new CInt(r.getUses(), t), t, env);
+		ret.set("hasxpreward", CBoolean.get(r.hasExperienceReward()), t, env);
 
 		return ret;
 	}
diff --git a/src/main/java/com/laytonsmith/core/functions/Weather.java b/src/main/java/com/laytonsmith/core/functions/Weather.java
index a221e23b08..82aa62462a 100644
--- a/src/main/java/com/laytonsmith/core/functions/Weather.java
+++ b/src/main/java/com/laytonsmith/core/functions/Weather.java
@@ -18,6 +18,7 @@
 import com.laytonsmith.core.constructs.CString;
 import com.laytonsmith.core.constructs.CVoid;
 import com.laytonsmith.core.constructs.Target;
+import com.laytonsmith.core.constructs.generics.GenericParameters;
 import com.laytonsmith.core.environments.CommandHelperEnvironment;
 import com.laytonsmith.core.environments.Environment;
 import com.laytonsmith.core.exceptions.CRE.CRECastException;
@@ -59,7 +60,7 @@ public Class<? extends CREThrowable>[] thrown() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment env, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			int x;
 			int y;
 			int z;
@@ -67,7 +68,7 @@ public Mixed exec(Target t, Environment env, Mixed... args) throws ConfigRuntime
 			MCWorld w = null;
 			boolean safe = false;
 			int safeIndex = 1;
-			if(args[0].isInstanceOf(CArray.TYPE)) {
+			if(args[0].isInstanceOf(CArray.TYPE, null, env)) {
 				CArray a = (CArray) args[0];
 				MCPlayer p = env.getEnv(CommandHelperEnvironment.class).GetPlayer();
 				MCLocation l = ObjectGenerator.GetGenerator().location(a, p == null ? null : p.getWorld(), t);
@@ -82,7 +83,7 @@ public Mixed exec(Target t, Environment env, Mixed... args) throws ConfigRuntime
 				safeIndex = 3;
 			}
 			if(args.length >= safeIndex + 1) {
-				safe = ArgumentValidation.getBoolean(args[safeIndex], t);
+				safe = ArgumentValidation.getBoolean(args[safeIndex], t, env);
 			}
 			if(w != null) {
 				if(!safe) {
@@ -136,22 +137,22 @@ public Integer[] numArgs() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment env, Mixed... args) throws ConfigRuntimeException {
-			boolean b = ArgumentValidation.getBoolean(args[0], t);
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
+			boolean b = ArgumentValidation.getBoolean(args[0], t, env);
 			MCWorld w = null;
 			int duration = -1;
 			if(args.length == 2) {
-				if(args[1].isInstanceOf(CString.TYPE)) {
+				if(args[1].isInstanceOf(CString.TYPE, null, env)) {
 					w = Static.getServer().getWorld(args[1].val());
-				} else if(args[1].isInstanceOf(CInt.TYPE)) {
-					duration = ArgumentValidation.getInt32(args[1], t);
+				} else if(args[1].isInstanceOf(CInt.TYPE, null, env)) {
+					duration = ArgumentValidation.getInt32(args[1], t, env);
 				} else {
 					throw new CREFormatException("", t);
 				}
 			}
 			if(args.length == 3) {
 				w = Static.getServer().getWorld(args[1].val());
-				duration = ArgumentValidation.getInt32(args[2], t);
+				duration = ArgumentValidation.getInt32(args[2], t, env);
 			}
 			if(w == null) {
 				MCCommandSender sender = env.getEnv(CommandHelperEnvironment.class).GetCommandSender();
@@ -227,22 +228,22 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			MCWorld w = null;
 			if(args.length == 1) {
-				if(environment.getEnv(CommandHelperEnvironment.class).GetCommandSender() instanceof MCPlayer) {
-					w = environment.getEnv(CommandHelperEnvironment.class).GetPlayer().getWorld();
+				if(env.getEnv(CommandHelperEnvironment.class).GetCommandSender() instanceof MCPlayer) {
+					w = env.getEnv(CommandHelperEnvironment.class).GetPlayer().getWorld();
 				}
 			} else {
 				w = Static.getServer().getWorld(args[1].val());
 			}
 			if(w != null) {
-				w.setThundering(ArgumentValidation.getBoolean(args[0], t));
+				w.setThundering(ArgumentValidation.getBoolean(args[0], t, env));
 			} else {
 				throw new CREInvalidWorldException("No existing world specified!", t);
 			}
 			if(args.length == 3) {
-				w.setThunderDuration(ArgumentValidation.getInt32(args[2], t));
+				w.setThunderDuration(ArgumentValidation.getInt32(args[2], t, env));
 			}
 			return CVoid.VOID;
 		}
@@ -289,13 +290,13 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			MCWorld w = null;
 			if(args.length == 1) {
 				w = Static.getServer().getWorld(args[0].val());
 			} else {
-				if(environment.getEnv(CommandHelperEnvironment.class).GetCommandSender() instanceof MCPlayer) {
-					w = environment.getEnv(CommandHelperEnvironment.class).GetPlayer().getWorld();
+				if(env.getEnv(CommandHelperEnvironment.class).GetCommandSender() instanceof MCPlayer) {
+					w = env.getEnv(CommandHelperEnvironment.class).GetPlayer().getWorld();
 				}
 			}
 			if(w != null) {
@@ -346,13 +347,13 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			MCWorld w = null;
 			if(args.length == 1) {
 				w = Static.getServer().getWorld(args[0].val());
 			} else {
-				if(environment.getEnv(CommandHelperEnvironment.class).GetCommandSender() instanceof MCPlayer) {
-					w = environment.getEnv(CommandHelperEnvironment.class).GetPlayer().getWorld();
+				if(env.getEnv(CommandHelperEnvironment.class).GetCommandSender() instanceof MCPlayer) {
+					w = env.getEnv(CommandHelperEnvironment.class).GetPlayer().getWorld();
 				}
 			}
 			if(w != null) {
diff --git a/src/main/java/com/laytonsmith/core/functions/Web.java b/src/main/java/com/laytonsmith/core/functions/Web.java
index d07fe19bc2..21286b9a01 100644
--- a/src/main/java/com/laytonsmith/core/functions/Web.java
+++ b/src/main/java/com/laytonsmith/core/functions/Web.java
@@ -36,6 +36,7 @@
 import com.laytonsmith.core.constructs.CVoid;
 import com.laytonsmith.core.constructs.Construct;
 import com.laytonsmith.core.constructs.Target;
+import com.laytonsmith.core.constructs.generics.GenericParameters;
 import com.laytonsmith.core.environments.Environment;
 import com.laytonsmith.core.environments.GlobalEnv;
 import com.laytonsmith.core.environments.StaticRuntimeEnv;
@@ -44,9 +45,10 @@
 import com.laytonsmith.core.exceptions.CRE.CREIOException;
 import com.laytonsmith.core.exceptions.CRE.CREPluginInternalException;
 import com.laytonsmith.core.exceptions.CRE.CREThrowable;
+import com.laytonsmith.core.exceptions.CancelCommandException;
 import com.laytonsmith.core.exceptions.ConfigCompileException;
 import com.laytonsmith.core.exceptions.ConfigRuntimeException;
-import com.laytonsmith.core.exceptions.ProgramFlowManipulationException;
+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;
@@ -104,16 +106,16 @@ public static String docs() {
 		return "Contains various methods to make HTTP requests.";
 	}
 
-	private static void getCookieJar(CArray arrayJar, CookieJar cookieJar, Target t) {
+	private static void getCookieJar(CArray arrayJar, CookieJar cookieJar, Target t, Environment env) {
 		CArray ret = arrayJar;
 		for(Cookie cookie : cookieJar.getAllCookies()) {
 			boolean update = false;
 			CArray aCookie = null;
-			for(Mixed ac : arrayJar.asList()) {
-				aCookie = ArgumentValidation.getArray(ac, t);
-				if(cookie.getName().equals(aCookie.get("name", t).val())
-						&& cookie.getDomain().equals(aCookie.get("domain", t).val())
-						&& cookie.getPath().equals(aCookie.get("path", t).val())) {
+			for(Mixed ac : arrayJar.asList(env)) {
+				aCookie = ArgumentValidation.getArray(ac, t, env);
+				if(cookie.getName().equals(aCookie.get("name", t, env).val())
+						&& cookie.getDomain().equals(aCookie.get("domain", t, env).val())
+						&& cookie.getPath().equals(aCookie.get("path", t, env).val())) {
 					//This is just an update, not a new cookie
 					update = true;
 					break;
@@ -121,27 +123,27 @@ private static void getCookieJar(CArray arrayJar, CookieJar cookieJar, Target t)
 			}
 			CArray c;
 			if(!update) {
-				c = CArray.GetAssociativeArray(t);
+				c = CArray.GetAssociativeArray(t, null, env);
 			} else {
 				c = aCookie;
 			}
-			c.set("name", cookie.getName());
-			c.set("value", cookie.getValue());
-			c.set("domain", cookie.getDomain());
-			c.set("path", cookie.getPath());
-			c.set("expiration", new CInt(cookie.getExpiration(), t), t);
-			c.set("httpOnly", CBoolean.get(cookie.isHttpOnly()), t);
-			c.set("secureOnly", CBoolean.get(cookie.isSecureOnly()), t);
+			c.set("name", cookie.getName(), env);
+			c.set("value", cookie.getValue(), env);
+			c.set("domain", cookie.getDomain(), env);
+			c.set("path", cookie.getPath(), env);
+			c.set("expiration", new CInt(cookie.getExpiration(), t), t, env);
+			c.set("httpOnly", CBoolean.get(cookie.isHttpOnly()), t, env);
+			c.set("secureOnly", CBoolean.get(cookie.isSecureOnly()), t, env);
 			if(!update) {
-				ret.push(c, t);
+				ret.push(c, t, env);
 			}
 		}
 	}
 
-	private static CookieJar getCookieJar(CArray cookieJar, Target t) {
+	private static CookieJar getCookieJar(CArray cookieJar, Target t, Environment env) {
 		CookieJar ret = new CookieJar();
 		for(String key : cookieJar.stringKeySet()) {
-			CArray cookie = ArgumentValidation.getArray(cookieJar.get(key, t), t);
+			CArray cookie = ArgumentValidation.getArray(cookieJar.get(key, t, env), t, env);
 			String name;
 			String value;
 			String domain;
@@ -151,22 +153,22 @@ private static CookieJar getCookieJar(CArray cookieJar, Target t) {
 			boolean secureOnly = false;
 			if(cookie.containsKey("name") && cookie.containsKey("value")
 					&& cookie.containsKey("domain") && cookie.containsKey("path")) {
-				name = cookie.get("name", t).val();
-				value = cookie.get("value", t).val();
-				domain = cookie.get("domain", t).val();
-				path = cookie.get("path", t).val();
+				name = cookie.get("name", t, env).val();
+				value = cookie.get("value", t, env).val();
+				domain = cookie.get("domain", t, env).val();
+				path = cookie.get("path", t, env).val();
 			} else {
 				throw new CREFormatException("The name, value, domain, and path keys are required"
 						+ " in all cookies.", t);
 			}
 			if(cookie.containsKey("expiration")) {
-				expiration = ArgumentValidation.getInt(cookie.get("expiration", t), t);
+				expiration = ArgumentValidation.getInt(cookie.get("expiration", t, env), t, env);
 			}
 			if(cookie.containsKey("httpOnly")) {
-				httpOnly = ArgumentValidation.getBoolean(cookie.get("httpOnly", t), t);
+				httpOnly = ArgumentValidation.getBoolean(cookie.get("httpOnly", t, env), t, env);
 			}
 			if(cookie.containsKey("secureOnly")) {
-				secureOnly = ArgumentValidation.getBoolean(cookie.get("secureOnly", t), t);
+				secureOnly = ArgumentValidation.getBoolean(cookie.get("secureOnly", t, env), t, env);
 			}
 			Cookie c = new Cookie(name, value, domain, path, expiration, httpOnly, secureOnly);
 			ret.addCookie(c);
@@ -218,7 +220,7 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(final Target t, final Environment environment, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(final Target t, final Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			final URL url;
 			try {
 				url = new URL(args[0].val());
@@ -232,7 +234,7 @@ public Mixed exec(final Target t, final Environment environment, Mixed... args)
 			final boolean binary;
 			final String textEncoding;
 			boolean useDefaultHeaders = true;
-			if(args[1].isInstanceOf(CClosure.TYPE)) {
+			if(args[1].isInstanceOf(CClosure.TYPE, null, env)) {
 				success = (CClosure) args[1];
 				error = null;
 				arrayJar = null;
@@ -244,26 +246,26 @@ public Mixed exec(final Target t, final Environment environment, Mixed... args)
 				}
 				settings.setHeaders(headers);
 			} else {
-				CArray csettings = ArgumentValidation.getArray(args[1], t);
+				CArray csettings = ArgumentValidation.getArray(args[1], t, env);
 				if(csettings.containsKey("method")) {
 					try {
-						settings.setMethod(HTTPMethod.valueOf(csettings.get("method", t).val()));
+						settings.setMethod(HTTPMethod.valueOf(csettings.get("method", t, env).val()));
 					} catch (IllegalArgumentException e) {
 						throw new CREFormatException(e.getMessage(), t);
 					}
 				}
 				if(csettings.containsKey("useDefaultHeaders")) {
-					useDefaultHeaders = ArgumentValidation.getBoolean(csettings.get("useDefaultHeaders", t), t);
+					useDefaultHeaders = ArgumentValidation.getBoolean(csettings.get("useDefaultHeaders", t, env), t, env);
 				}
-				if(csettings.containsKey("headers") && !(csettings.get("headers", t) instanceof CNull)) {
-					CArray headers = ArgumentValidation.getArray(csettings.get("headers", t), t);
+				if(csettings.containsKey("headers") && !(csettings.get("headers", t, env) instanceof CNull)) {
+					CArray headers = ArgumentValidation.getArray(csettings.get("headers", t, env), t, env);
 					Map<String, List<String>> mheaders = new HashMap<String, List<String>>();
 					for(String key : headers.stringKeySet()) {
 						List<String> h = new ArrayList<String>();
-						Mixed c = headers.get(key, t);
-						if(c.isInstanceOf(CArray.TYPE)) {
+						Mixed c = headers.get(key, t, env);
+						if(c.isInstanceOf(CArray.TYPE, null, env)) {
 							for(String kkey : ((CArray) c).stringKeySet()) {
-								h.add(((CArray) c).get(kkey, t).val());
+								h.add(((CArray) c).get(kkey, t, env).val());
 							}
 						} else {
 							h.add(c.val());
@@ -287,16 +289,16 @@ public Mixed exec(final Target t, final Environment environment, Mixed... args)
 						settings.getHeaders().put(key, Arrays.asList(DEFAULT_HEADERS.get(key)));
 					}
 				}
-				if(csettings.containsKey("params") && !(csettings.get("params", t) instanceof CNull)) {
-					if(csettings.get("params", t).isInstanceOf(CArray.TYPE)) {
-						CArray params = ArgumentValidation.getArray(csettings.get("params", t), t);
+				if(csettings.containsKey("params") && !(csettings.get("params", t, env) instanceof CNull)) {
+					if(csettings.get("params", t, env).isInstanceOf(CArray.TYPE, null, env)) {
+						CArray params = ArgumentValidation.getArray(csettings.get("params", t, env), t, env);
 						Map<String, List<String>> mparams = new HashMap<>();
 						for(String key : params.stringKeySet()) {
-							Mixed c = params.get(key, t);
+							Mixed c = params.get(key, t, env);
 							List<String> l = new ArrayList<>();
-							if(c.isInstanceOf(CArray.TYPE)) {
+							if(c.isInstanceOf(CArray.TYPE, null, env)) {
 								for(String kkey : ((CArray) c).stringKeySet()) {
-									l.add(((ArrayAccess) c).get(kkey, t).val());
+									l.add(((ArrayAccess) c).get(kkey, t, env).val());
 								}
 							} else {
 								l.add(c.val());
@@ -305,31 +307,31 @@ public Mixed exec(final Target t, final Environment environment, Mixed... args)
 						}
 						settings.setComplexParameters(mparams);
 					} else {
-						if(csettings.get("params", t).isInstanceOf(CByteArray.TYPE)) {
-							CByteArray b = (CByteArray) csettings.get("params", t);
+						if(csettings.get("params", t, env) instanceof CByteArray) {
+							CByteArray b = (CByteArray) csettings.get("params", t, env);
 							settings.setRawParameter(b.asByteArrayCopy());
 						} else {
 							try {
-								settings.setRawParameter(csettings.get("params", t).val().getBytes("UTF-8"));
+								settings.setRawParameter(csettings.get("params", t, env).val().getBytes("UTF-8"));
 							} catch (UnsupportedEncodingException ex) {
 								throw new Error(ex);
 							}
 						}
 					}
 				}
-				if(csettings.containsKey("cookiejar") && !(csettings.get("cookiejar", t) instanceof CNull)) {
-					arrayJar = ArgumentValidation.getArray(csettings.get("cookiejar", t), t);
-					settings.setCookieJar(getCookieJar(arrayJar, t));
+				if(csettings.containsKey("cookiejar") && !(csettings.get("cookiejar", t, env) instanceof CNull)) {
+					arrayJar = ArgumentValidation.getArray(csettings.get("cookiejar", t, env), t, env);
+					settings.setCookieJar(getCookieJar(arrayJar, t, env));
 				} else {
 					arrayJar = null;
 				}
 				if(csettings.containsKey("followRedirects")) {
-					settings.setFollowRedirects(ArgumentValidation.getBoolean(csettings.get("followRedirects", t), t));
+					settings.setFollowRedirects(ArgumentValidation.getBoolean(csettings.get("followRedirects", t, env), t, env));
 				}
 				//Only required parameter
 				if(csettings.containsKey("success")) {
-					if(csettings.get("success", t).isInstanceOf(CClosure.TYPE)) {
-						success = (CClosure) csettings.get("success", t);
+					if(csettings.get("success", t, env).isInstanceOf(CClosure.TYPE, null, env)) {
+						success = (CClosure) csettings.get("success", t, env);
 					} else {
 						throw new CRECastException("Expecting the success parameter to be a closure.", t);
 					}
@@ -337,8 +339,8 @@ public Mixed exec(final Target t, final Environment environment, Mixed... args)
 					throw new CRECastException("Missing the success parameter, which is required.", t);
 				}
 				if(csettings.containsKey("error")) {
-					if(csettings.get("error", t).isInstanceOf(CClosure.TYPE)) {
-						error = (CClosure) csettings.get("error", t);
+					if(csettings.get("error", t, env).isInstanceOf(CClosure.TYPE, null, env)) {
+						error = (CClosure) csettings.get("error", t, env);
 					} else {
 						throw new CRECastException("Expecting the error parameter to be a closure.", t);
 					}
@@ -346,42 +348,42 @@ public Mixed exec(final Target t, final Environment environment, Mixed... args)
 					error = null;
 				}
 				if(csettings.containsKey("timeout")) {
-					settings.setTimeout(ArgumentValidation.getInt32(csettings.get("timeout", t), t));
+					settings.setTimeout(ArgumentValidation.getInt32(csettings.get("timeout", t, env), t, env));
 				}
 				String username = null;
 				String password = null;
 				if(csettings.containsKey("username")) {
-					username = csettings.get("username", t).val();
+					username = csettings.get("username", t, env).val();
 				}
 				if(csettings.containsKey("password")) {
-					password = csettings.get("password", t).val();
+					password = csettings.get("password", t, env).val();
 				}
 				if(csettings.containsKey("proxy")) {
-					CArray proxySettings = ArgumentValidation.getArray(csettings.get("proxy", t), t);
+					CArray proxySettings = ArgumentValidation.getArray(csettings.get("proxy", t, env), t, env);
 					Proxy.Type type;
 					String proxyURL;
 					int port;
 					try {
-						type = Proxy.Type.valueOf(proxySettings.get("type", t).val());
+						type = Proxy.Type.valueOf(proxySettings.get("type", t, env).val());
 					} catch (IllegalArgumentException e) {
 						throw new CREFormatException(e.getMessage(), t, e);
 					}
-					proxyURL = proxySettings.get("url", t).val();
-					port = ArgumentValidation.getInt32(proxySettings.get("port", t), t);
+					proxyURL = proxySettings.get("url", t, env).val();
+					port = ArgumentValidation.getInt32(proxySettings.get("port", t, env), t, env);
 					SocketAddress addr = new InetSocketAddress(proxyURL, port);
 					Proxy proxy = new Proxy(type, addr);
 					settings.setProxy(proxy);
 				}
 				if(csettings.containsKey("trustStore")) {
-					Mixed trustStore = csettings.get("trustStore", t);
-					if(trustStore.isInstanceOf(CBoolean.TYPE) && ArgumentValidation.getBoolean(trustStore, t) == false) {
+					Mixed trustStore = csettings.get("trustStore", t, env);
+					if(trustStore instanceof CBoolean && ArgumentValidation.getBoolean(trustStore, t, env) == false) {
 						settings.setDisableCertChecking(true);
-					} else if(trustStore.isInstanceOf(CArray.TYPE)) {
+					} else if(trustStore.isInstanceOf(CArray.TYPE, null, env)) {
 						CArray trustStoreA = ((CArray) trustStore);
-						LinkedHashMap<String, String> trustStoreJ = new LinkedHashMap<>((int) trustStoreA.size());
+						LinkedHashMap<String, String> trustStoreJ = new LinkedHashMap<>((int) trustStoreA.size(env));
 						final String noDefault = "no default";
 						for(String key : trustStoreA.stringKeySet()) {
-							String value = trustStoreA.get(key, t).val();
+							String value = trustStoreA.get(key, t, env).val();
 							if(noDefault.equals(key) && noDefault.equals(value)) {
 								settings.setUseDefaultTrustStore(false);
 								continue;
@@ -396,12 +398,12 @@ public Mixed exec(final Target t, final Environment environment, Mixed... args)
 					}
 				}
 				if(csettings.containsKey("download")) {
-					Mixed download = csettings.get("download", t);
+					Mixed download = csettings.get("download", t, env);
 					if(download instanceof CNull) {
 						settings.setDownloadTo(null);
 					} else { // TODO: Remove this check and tie into the VFS once that is complete.
-						if(Static.InCmdLine(environment, true)) {
-							File file = Static.GetFileFromArgument(Construct.nval(download), environment, t, null);
+						if(Static.InCmdLine(env, true)) {
+							File file = Static.GetFileFromArgument(Construct.nval(download), env, t, null);
 							if(!file.isAbsolute()) {
 								file = new File(t.file(), file.getPath());
 							}
@@ -411,7 +413,7 @@ public Mixed exec(final Target t, final Environment environment, Mixed... args)
 				}
 				if(csettings.containsKey("downloadStrategy")) {
 					com.laytonsmith.core.FileWriteMode mode
-							= ArgumentValidation.getEnum(csettings.get("downloadStrategy", t), FileWriteMode.class, t);
+							= ArgumentValidation.getEnum(csettings.get("downloadStrategy", t, env), FileWriteMode.class, t);
 					com.laytonsmith.PureUtilities.Common.FileWriteMode puMode;
 					if(mode == com.laytonsmith.core.FileWriteMode.APPEND) {
 						puMode = com.laytonsmith.PureUtilities.Common.FileWriteMode.APPEND;
@@ -425,91 +427,91 @@ public Mixed exec(final Target t, final Environment environment, Mixed... args)
 					settings.setDownloadStrategy(puMode);
 				}
 				if(csettings.containsKey("binary")) {
-					binary = ArgumentValidation.getBoolean(csettings.get("binary", t), t);
+					binary = ArgumentValidation.getBoolean(csettings.get("binary", t, env), t, env);
 				} else {
 					binary = false;
 				}
 
 				if(csettings.containsKey("textEncoding")) {
-					textEncoding = csettings.get("textEncoding", t).val();
+					textEncoding = csettings.get("textEncoding", t, env).val();
 				} else {
 					textEncoding = "UTF-8";
 				}
 
 				if(csettings.containsKey("blocking")) {
-					boolean blocking = ArgumentValidation.getBoolean(csettings.get("blocking", t), t);
+					boolean blocking = ArgumentValidation.getBoolean(csettings.get("blocking", t, env), t, env);
 					settings.setBlocking(blocking);
 				}
-				if(csettings.containsKey("log") && ArgumentValidation.getBoolean(csettings.get("log", t), t)) {
+				if(csettings.containsKey("log") && ArgumentValidation.getBoolean(csettings.get("log", t, env), t, env)) {
 					settings.setLogger(Logger.getLogger(Web.class.getName()));
 				}
 				settings.setAuthenticationDetails(username, password);
 			}
 
-			List<ConfigRuntimeException.StackTraceElement> st
-					= environment.getEnv(GlobalEnv.class).GetStackTraceManager().getCurrentStackTrace();
-			environment.getEnv(StaticRuntimeEnv.class).GetDaemonManager().activateThread(null);
+			List<StackTraceFrame> st
+					= env.getEnv(GlobalEnv.class).GetStackTraceManager().getCurrentStackTrace();
+			env.getEnv(StaticRuntimeEnv.class).GetDaemonManager().activateThread(null);
 			Runnable task = new Runnable() {
 
 				@Override
 				public void run() {
 					try {
 						HTTPResponse resp = WebUtility.GetPage(url, settings);
-						final CArray array = CArray.GetAssociativeArray(t);
+						final CArray array = CArray.GetAssociativeArray(t, null, env);
 						if(settings.getDownloadTo() == null) {
 							if(binary) {
-								array.set("data", CByteArray.wrap(resp.getContent(), t), t);
+								array.set("data", CByteArray.wrap(resp.getContent(), t), t, env);
 							} else {
 								try {
-									array.set("body", new CString(new String(resp.getContent(), textEncoding), t), t);
+									array.set("body", new CString(new String(resp.getContent(), textEncoding), t), t, env);
 								} catch (UnsupportedEncodingException ex) {
 									throw new CREFormatException("Unsupported encoding [" + textEncoding + "]", t, ex);
 								}
 							}
 						}
-						CArray headers = CArray.GetAssociativeArray(t);
+						CArray headers = CArray.GetAssociativeArray(t, null, env);
 						for(String key : resp.getHeaderObject().getHeaderNames()) {
 							CArray h = new CArray(t);
 							for(String val : resp.getHeaderObject().getHeaders(key)) {
-								h.push(new CString(val, t), t);
+								h.push(new CString(val, t), t, env);
 							}
-							headers.set(key, h, t);
+							headers.set(key, h, t, env);
 						}
-						array.set("headers", headers, t);
-						array.set("responseCode", new CInt(resp.getResponseCode(), t), t);
-						array.set("responseText", resp.getResponseText());
-						array.set("httpVersion", resp.getHttpVersion());
-						array.set("error", CBoolean.get(resp.getResponseCode() >= 400 && resp.getResponseCode() < 600), t);
+						array.set("headers", headers, t, env);
+						array.set("responseCode", new CInt(resp.getResponseCode(), t), t, env);
+						array.set("responseText", resp.getResponseText(), env);
+						array.set("httpVersion", resp.getHttpVersion(), env);
+						array.set("error", CBoolean.get(resp.getResponseCode() >= 400 && resp.getResponseCode() < 600), t, env);
 						if(arrayJar != null) {
-							getCookieJar(arrayJar, settings.getCookieJar(), t);
+							getCookieJar(arrayJar, settings.getCookieJar(), t, env);
 						}
 						if(settings.getBlocking()) {
-							executeFinish(success, array, t, environment);
+							executeFinish(success, array, t, env);
 						} else {
 							StaticLayer.GetConvertor().runOnMainThreadLater(
-									environment.getEnv(StaticRuntimeEnv.class).GetDaemonManager(),
-									() -> executeFinish(success, array, t, environment));
+									env.getEnv(StaticRuntimeEnv.class).GetDaemonManager(),
+									() -> executeFinish(success, array, t, env));
 						}
 					} catch (IOException e) {
 						final CREIOException ex = new CREIOException((e instanceof UnknownHostException ? "Unknown host: " : "")
 							+ e.getMessage(), t);
 						ex.setStackTraceElements(st);
 						if(error != null) {
-							final CArray cException = ObjectGenerator.GetGenerator().exception(ex, environment, t);
+							final CArray cException = ObjectGenerator.GetGenerator().exception(ex, env, t);
 							if(settings.getBlocking()) {
-								executeFinish(error, cException, t, environment);
+								executeFinish(error, cException, t, env);
 							} else {
 								StaticLayer.GetConvertor().runOnMainThreadLater(
-										environment.getEnv(StaticRuntimeEnv.class).GetDaemonManager(),
-										() -> executeFinish(error, cException, t, environment));
+										env.getEnv(StaticRuntimeEnv.class).GetDaemonManager(),
+										() -> executeFinish(error, cException, t, env));
 							}
 						} else {
-							ConfigRuntimeException.HandleUncaughtException(ex, environment);
+							ConfigRuntimeException.HandleUncaughtException(ex, env);
 						}
 					} catch (Exception e) {
 						e.printStackTrace();
 					} finally {
-						environment.getEnv(StaticRuntimeEnv.class).GetDaemonManager().deactivateThread(null);
+						env.getEnv(StaticRuntimeEnv.class).GetDaemonManager().deactivateThread(null);
 					}
 				}
 			};
@@ -521,7 +523,7 @@ public void run() {
 			return CVoid.VOID;
 		}
 
-		private void executeFinish(CClosure closure, Mixed arg, Target t, Environment environment) {
+		private void executeFinish(CClosure closure, Mixed arg, Target t, Environment env) {
 			try {
 				Mixed ret = closure.executeCallable(new Mixed[]{arg});
 				//Just ignore this if it's returning void. Otherwise, warn.
@@ -530,11 +532,10 @@ private void executeFinish(CClosure closure, Mixed arg, Target t, Environment en
 					MSLog.GetLogger().Log(MSLog.Tags.RUNTIME, LogLevel.WARNING, "Returning a value from the closure. The value is"
 							+ " being ignored.", t);
 				}
-			} catch (ProgramFlowManipulationException e) {
-				//This is an error
-				MSLog.GetLogger().Log(MSLog.Tags.RUNTIME, LogLevel.WARNING, "Only return may be used inside the closure.", t);
+			} catch (CancelCommandException e) {
+				// die() in the callback, just stop
 			} catch (ConfigRuntimeException e) {
-				ConfigRuntimeException.HandleUncaughtException(e, environment);
+				ConfigRuntimeException.HandleUncaughtException(e, env);
 			} catch (Throwable e) {
 				//Other throwables we just need to report
 				MSLog.GetLogger().Log(MSLog.Tags.RUNTIME, LogLevel.ERROR, "An unexpected exception has occurred. No extra"
@@ -637,9 +638,9 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
-			CArray array = ArgumentValidation.getArray(args[0], t);
-			CookieJar jar = getCookieJar(array, t);
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
+			CArray array = ArgumentValidation.getArray(args[0], t, env);
+			CookieJar jar = getCookieJar(array, t, env);
 			jar.clearSessionCookies();
 			return CVoid.VOID;
 		}
@@ -686,7 +687,7 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			try {
 				return new CString(URLEncoder.encode(args[0].val(), "UTF-8"), t);
 			} catch (UnsupportedEncodingException ex) {
@@ -743,7 +744,7 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			try {
 				return new CString(URLDecoder.decode(args[0].val(), "UTF-8"), t);
 			} catch (UnsupportedEncodingException ex) {
@@ -801,18 +802,18 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			// Argument processing
 			CArray options;
 			if(args.length == 1) {
-				options = ArgumentValidation.getArray(args[0], t);
+				options = ArgumentValidation.getArray(args[0], t, env);
 			} else {
 				// Load the profile for transport data, if specified.
 				String profileName = ArgumentValidation.getString(args[0], t);
-				options = CArray.GetAssociativeArray(t);
+				options = CArray.GetAssociativeArray(t, null, env);
 				Profiles.Profile p;
 				try {
-					p = environment.getEnv(StaticRuntimeEnv.class).getProfiles().getProfileById(profileName);
+					p = env.getEnv(StaticRuntimeEnv.class).getProfiles().getProfileById(profileName);
 				} catch (Profiles.InvalidProfileException ex) {
 					throw new CREFormatException(ex.getMessage(), t, ex);
 				}
@@ -821,13 +822,13 @@ public Mixed exec(Target t, Environment environment, Mixed... args) throws Confi
 				}
 				Map<String, Object> data = ((EmailProfile) p).getMap();
 				for(String key : data.keySet()) {
-					options.set(key, Construct.GetConstruct(data.get(key)), t);
+					options.set(key, Construct.GetConstruct(data.get(key)), t, env);
 				}
 				// Override any transport data that was also specified in the options, as
 				// well as adding the email settings here too.
-				CArray options2 = ArgumentValidation.getArray(args[1], t);
+				CArray options2 = ArgumentValidation.getArray(args[1], t, env);
 				for(String key : options2.stringKeySet()) {
-					options.set(key, options2.get(key, t), t);
+					options.set(key, options2.get(key, t, env), t, env);
 				}
 			}
 
@@ -835,10 +836,10 @@ public Mixed exec(Target t, Environment environment, Mixed... args) throws Confi
 			String host = ArgumentValidation.getItemFromArray(options, "host", t, new CString("localhost", t)).val();
 			final String mailUser = ArgumentValidation.getItemFromArray(options, "user", t, new CString("", t)).val();
 			final String mailPassword = ArgumentValidation.getItemFromArray(options, "password", t, new CString("", t)).val();
-			int mailPort = ArgumentValidation.getInt32(ArgumentValidation.getItemFromArray(options, "port", t, new CInt(587, t)), t);
-			boolean useSSL = ArgumentValidation.getBooleanObject(ArgumentValidation.getItemFromArray(options, "use_ssl", t, CBoolean.FALSE), t);
-			boolean useStartTLS = ArgumentValidation.getBooleanObject(ArgumentValidation.getItemFromArray(options, "use_start_tls", t, CBoolean.FALSE), t);
-			int timeout = ArgumentValidation.getInt32(ArgumentValidation.getItemFromArray(options, "timeout", t, new CInt(10000, t)), t);
+			int mailPort = ArgumentValidation.getInt32(ArgumentValidation.getItemFromArray(options, "port", t, new CInt(587, t)), t, env);
+			boolean useSSL = ArgumentValidation.getBooleanObject(ArgumentValidation.getItemFromArray(options, "use_ssl", t, CBoolean.FALSE), t, env);
+			boolean useStartTLS = ArgumentValidation.getBooleanObject(ArgumentValidation.getItemFromArray(options, "use_start_tls", t, CBoolean.FALSE), t, env);
+			int timeout = ArgumentValidation.getInt32(ArgumentValidation.getItemFromArray(options, "timeout", t, new CInt(10000, t)), t, env);
 
 			//Standard email options
 			String from = ArgumentValidation.getItemFromArray(options, "from", t, null).val();
@@ -846,13 +847,13 @@ public Mixed exec(Target t, Environment environment, Mixed... args) throws Confi
 			String body = ArgumentValidation.getItemFromArray(options, "body", t, new CString("", t)).val();
 			Mixed cto = ArgumentValidation.getItemFromArray(options, "to", t, null);
 			CArray to;
-			if(cto.isInstanceOf(CString.TYPE)) {
+			if(cto.isInstanceOf(CString.TYPE, null, env)) {
 				to = new CArray(t);
-				to.push(cto, t);
+				to.push(cto, t, env);
 			} else {
 				to = (CArray) cto;
 			}
-			CArray attachments = ArgumentValidation.getArray(ArgumentValidation.getItemFromArray(options, "attachments", t, new CArray(t)), t);
+			CArray attachments = ArgumentValidation.getArray(ArgumentValidation.getItemFromArray(options, "attachments", t, new CArray(t)), t, env);
 
 			// Setup and execution
 			Properties properties = System.getProperties();
@@ -893,16 +894,16 @@ protected PasswordAuthentication getPasswordAuthentication() {
 				message.setSubject(subject);
 
 				if(!"".equals(body)) {
-					CArray bodyAttachment = CArray.GetAssociativeArray(t);
-					bodyAttachment.set("type", "text/plain");
-					bodyAttachment.set("content", body);
-					attachments.push(bodyAttachment, 0, t);
+					CArray bodyAttachment = CArray.GetAssociativeArray(t, null, env);
+					bodyAttachment.set("type", "text/plain", env);
+					bodyAttachment.set("content", body, env);
+					attachments.push(bodyAttachment, 0, t, env);
 				}
 
-				for(Mixed c : to.asList()) {
+				for(Mixed c : to.asList(env)) {
 					Message.RecipientType type = Message.RecipientType.TO;
 					String address;
-					if(c.isInstanceOf(CArray.TYPE)) {
+					if(c.isInstanceOf(CArray.TYPE, null, env)) {
 						CArray ca = (CArray) c;
 						String stype = ArgumentValidation.getItemFromArray(ca, "type", t, new CString("TO", t)).val();
 						switch(stype) {
@@ -925,8 +926,8 @@ protected PasswordAuthentication getPasswordAuthentication() {
 					message.addRecipient(type, new InternetAddress(address));
 				}
 
-				if(attachments.size() == 1) {
-					CArray pattachment = ArgumentValidation.getArray(attachments.get(0, t), t);
+				if(attachments.size(env) == 1) {
+					CArray pattachment = ArgumentValidation.getArray(attachments.get(0, t, env), t, env);
 					String type = ArgumentValidation.getItemFromArray(pattachment, "type", t, null).val();
 					String fileName = ArgumentValidation.getItemFromArray(pattachment, "filename", t, new CString("", t)).val().trim();
 					String description = ArgumentValidation.getItemFromArray(pattachment, "description", t, new CString("", t)).val().trim();
@@ -941,16 +942,16 @@ protected PasswordAuthentication getPasswordAuthentication() {
 					if(!"".equals(disposition)) {
 						message.setDisposition(disposition);
 					}
-					message.setContent(getContent(content, t), type);
+					message.setContent(getContent(content, t, env), type);
 				} else {
 					Multipart mp = new MimeMultipart("alternative");
-					for(Mixed attachment : attachments.asList()) {
-						CArray pattachment = ArgumentValidation.getArray(attachment, t);
+					for(Mixed attachment : attachments.asList(env)) {
+						CArray pattachment = ArgumentValidation.getArray(attachment, t, env);
 						final String type = ArgumentValidation.getItemFromArray(pattachment, "type", t, null).val();
 						final String fileName = ArgumentValidation.getItemFromArray(pattachment, "filename", t, new CString("", t)).val().trim();
 						String description = ArgumentValidation.getItemFromArray(pattachment, "description", t, new CString("", t)).val().trim();
 						String disposition = ArgumentValidation.getItemFromArray(pattachment, "disposition", t, new CString("", t)).val().trim();
-						final Object content = getContent(ArgumentValidation.getItemFromArray(pattachment, "content", t, null), t);
+						final Object content = getContent(ArgumentValidation.getItemFromArray(pattachment, "content", t, null), t, env);
 						BodyPart bp = new MimeBodyPart();
 						if(!"".equals(fileName)) {
 							bp.setFileName(fileName);
@@ -1031,10 +1032,10 @@ public String getName() {
 		 * @param t
 		 * @return
 		 */
-		private Object getContent(Mixed c, Target t) {
-			if(c.isInstanceOf(CString.TYPE)) {
+		private Object getContent(Mixed c, Target t, Environment env) {
+			if(c.isInstanceOf(CString.TYPE, null, env)) {
 				return c.val();
-			} else if(c.isInstanceOf(CByteArray.TYPE)) {
+			} else if(c instanceof CByteArray) {
 				CByteArray cb = (CByteArray) c;
 				return cb.asByteArrayCopy();
 			} else {
diff --git a/src/main/java/com/laytonsmith/core/functions/World.java b/src/main/java/com/laytonsmith/core/functions/World.java
index a91c9db9d5..532ecada09 100644
--- a/src/main/java/com/laytonsmith/core/functions/World.java
+++ b/src/main/java/com/laytonsmith/core/functions/World.java
@@ -43,6 +43,7 @@
 import com.laytonsmith.core.constructs.CString;
 import com.laytonsmith.core.constructs.CVoid;
 import com.laytonsmith.core.constructs.Target;
+import com.laytonsmith.core.constructs.generics.GenericParameters;
 import com.laytonsmith.core.environments.CommandHelperEnvironment;
 import com.laytonsmith.core.environments.Environment;
 import com.laytonsmith.core.exceptions.CRE.CRECastException;
@@ -119,12 +120,12 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			MCWorld w;
 			if(args.length == 1) {
 				w = Static.getServer().getWorld(args[0].val());
 			} else {
-				MCPlayer p = environment.getEnv(CommandHelperEnvironment.class).GetPlayer();
+				MCPlayer p = env.getEnv(CommandHelperEnvironment.class).GetPlayer();
 				if(p == null) {
 					throw new CREInvalidWorldException("A world must be specified in a context with no player.", t);
 				}
@@ -156,19 +157,19 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			MCWorld w = null;
 			if(args.length == 1) {
-				MCPlayer p = environment.getEnv(CommandHelperEnvironment.class).GetPlayer();
+				MCPlayer p = env.getEnv(CommandHelperEnvironment.class).GetPlayer();
 				if(p != null) {
 					w = p.getWorld();
 				}
-				MCLocation l = ObjectGenerator.GetGenerator().location(args[0], w, t);
+				MCLocation l = ObjectGenerator.GetGenerator().location(args[0], w, t, env);
 				l.getWorld().setSpawnLocation(l);
 				return CVoid.VOID;
 			} else if(args.length == 2) {
 				w = Static.getServer().getWorld(args[0].val());
-				MCLocation l = ObjectGenerator.GetGenerator().location(args[1], w, t);
+				MCLocation l = ObjectGenerator.GetGenerator().location(args[1], w, t, env);
 				w.setSpawnLocation(l);
 				return CVoid.VOID;
 			}
@@ -177,18 +178,18 @@ public Mixed exec(Target t, Environment environment, Mixed... args) throws Confi
 			int y = 0;
 			int z = 0;
 			if(args.length == 3) {
-				MCPlayer p = environment.getEnv(CommandHelperEnvironment.class).GetPlayer();
+				MCPlayer p = env.getEnv(CommandHelperEnvironment.class).GetPlayer();
 				if(p != null) {
 					w = p.getWorld();
 				}
-				x = ArgumentValidation.getInt32(args[0], t);
-				y = ArgumentValidation.getInt32(args[1], t);
-				z = ArgumentValidation.getInt32(args[2], t);
+				x = ArgumentValidation.getInt32(args[0], t, env);
+				y = ArgumentValidation.getInt32(args[1], t, env);
+				z = ArgumentValidation.getInt32(args[2], t, env);
 			} else if(args.length == 4) {
 				w = Static.getServer().getWorld(args[0].val());
-				x = ArgumentValidation.getInt32(args[1], t);
-				y = ArgumentValidation.getInt32(args[2], t);
-				z = ArgumentValidation.getInt32(args[3], t);
+				x = ArgumentValidation.getInt32(args[1], t, env);
+				y = ArgumentValidation.getInt32(args[2], t, env);
+				z = ArgumentValidation.getInt32(args[3], t, env);
 			}
 			if(w == null) {
 				throw new CREInvalidWorldException("Invalid world given.", t);
@@ -260,22 +261,22 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
-			MCPlayer m = environment.getEnv(CommandHelperEnvironment.class).GetPlayer();
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
+			MCPlayer m = env.getEnv(CommandHelperEnvironment.class).GetPlayer();
 			MCWorld world;
 			int x;
 			int z;
 			if(args.length == 1) {
 				//Location array provided
-				MCLocation l = ObjectGenerator.GetGenerator().location(args[0], m != null ? m.getWorld() : null, t);
+				MCLocation l = ObjectGenerator.GetGenerator().location(args[0], m != null ? m.getWorld() : null, t, env);
 				world = l.getWorld();
 				x = l.getBlockX();
 				z = l.getBlockZ();
 			} else if(args.length == 2) {
 				//Either location array and world provided, or x and z. Test for array at pos 2
-				if(args[1].isInstanceOf(CArray.TYPE)) {
+				if(args[1].isInstanceOf(CArray.TYPE, null, env)) {
 					world = Static.getServer().getWorld(args[0].val());
-					MCLocation l = ObjectGenerator.GetGenerator().location(args[1], null, t);
+					MCLocation l = ObjectGenerator.GetGenerator().location(args[1], null, t, env);
 					x = l.getBlockX();
 					z = l.getBlockZ();
 				} else {
@@ -283,8 +284,8 @@ public Mixed exec(Target t, Environment environment, Mixed... args) throws Confi
 						throw new CREInvalidWorldException("No world specified", t);
 					}
 					world = m.getWorld();
-					x = ArgumentValidation.getInt32(args[0], t);
-					z = ArgumentValidation.getInt32(args[1], t);
+					x = ArgumentValidation.getInt32(args[0], t, env);
+					z = ArgumentValidation.getInt32(args[1], t, env);
 				}
 			} else {
 				//world, x and z provided
@@ -292,8 +293,8 @@ public Mixed exec(Target t, Environment environment, Mixed... args) throws Confi
 				if(world == null) {
 					throw new CREInvalidWorldException("World " + args[0].val() + " does not exist.", t);
 				}
-				x = ArgumentValidation.getInt32(args[1], t);
-				z = ArgumentValidation.getInt32(args[2], t);
+				x = ArgumentValidation.getInt32(args[1], t, env);
+				z = ArgumentValidation.getInt32(args[2], t, env);
 			}
 			world.refreshChunk(x, z);
 			return CVoid.VOID;
@@ -319,25 +320,25 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
-			MCPlayer m = environment.getEnv(CommandHelperEnvironment.class).GetPlayer();
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
+			MCPlayer m = env.getEnv(CommandHelperEnvironment.class).GetPlayer();
 			MCWorld world;
 			int x;
 			int z;
 			if(args.length == 1) {
 				//Location array provided
-				MCLocation l = ObjectGenerator.GetGenerator().location(args[0], m != null ? m.getWorld() : null, t);
+				MCLocation l = ObjectGenerator.GetGenerator().location(args[0], m != null ? m.getWorld() : null, t, env);
 				world = l.getWorld();
 				x = l.getBlockX();
 				z = l.getBlockZ();
 			} else if(args.length == 2) {
 				//Either location array and world provided, or x and z. Test for array at pos 2
-				if(args[1].isInstanceOf(CArray.TYPE)) {
+				if(args[1].isInstanceOf(CArray.TYPE, null, env)) {
 					world = Static.getServer().getWorld(args[0].val());
 					if(world == null) {
 						throw new CREInvalidWorldException("The given world (" + args[0].val() + ") does not exist.", t);
 					}
-					MCLocation l = ObjectGenerator.GetGenerator().location(args[1], null, t);
+					MCLocation l = ObjectGenerator.GetGenerator().location(args[1], null, t, env);
 					x = l.getBlockX();
 					z = l.getBlockZ();
 				} else {
@@ -345,8 +346,8 @@ public Mixed exec(Target t, Environment environment, Mixed... args) throws Confi
 						throw new CREInvalidWorldException("No world specified", t);
 					}
 					world = m.getWorld();
-					x = ArgumentValidation.getInt32(args[0], t);
-					z = ArgumentValidation.getInt32(args[1], t);
+					x = ArgumentValidation.getInt32(args[0], t, env);
+					z = ArgumentValidation.getInt32(args[1], t, env);
 				}
 			} else {
 				//world, x and z provided
@@ -354,8 +355,8 @@ public Mixed exec(Target t, Environment environment, Mixed... args) throws Confi
 				if(world == null) {
 					throw new CREInvalidWorldException("The given world (" + args[0].val() + ") does not exist.", t);
 				}
-				x = ArgumentValidation.getInt32(args[1], t);
-				z = ArgumentValidation.getInt32(args[2], t);
+				x = ArgumentValidation.getInt32(args[1], t, env);
+				z = ArgumentValidation.getInt32(args[2], t, env);
 			}
 			world.loadChunk(x, z);
 			return CVoid.VOID;
@@ -402,22 +403,22 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
-			MCPlayer m = environment.getEnv(CommandHelperEnvironment.class).GetPlayer();
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
+			MCPlayer m = env.getEnv(CommandHelperEnvironment.class).GetPlayer();
 			MCWorld world;
 			int x;
 			int z;
 			if(args.length == 1) {
 				//Location array provided
-				MCLocation l = ObjectGenerator.GetGenerator().location(args[0], m != null ? m.getWorld() : null, t);
+				MCLocation l = ObjectGenerator.GetGenerator().location(args[0], m != null ? m.getWorld() : null, t, env);
 				world = l.getWorld();
 				x = l.getBlockX();
 				z = l.getBlockZ();
 			} else if(args.length == 2) {
 				//Either location array and world provided, or x and z. Test for array at pos 2
-				if(args[1].isInstanceOf(CArray.TYPE)) {
+				if(args[1].isInstanceOf(CArray.TYPE, null, env)) {
 					world = Static.getServer().getWorld(args[0].val());
-					MCLocation l = ObjectGenerator.GetGenerator().location(args[1], null, t);
+					MCLocation l = ObjectGenerator.GetGenerator().location(args[1], null, t, env);
 					x = l.getBlockX();
 					z = l.getBlockZ();
 				} else {
@@ -425,14 +426,14 @@ public Mixed exec(Target t, Environment environment, Mixed... args) throws Confi
 						throw new CREInvalidWorldException("No world specified", t);
 					}
 					world = m.getWorld();
-					x = ArgumentValidation.getInt32(args[0], t);
-					z = ArgumentValidation.getInt32(args[1], t);
+					x = ArgumentValidation.getInt32(args[0], t, env);
+					z = ArgumentValidation.getInt32(args[1], t, env);
 				}
 			} else {
 				//world, x and z provided
 				world = Static.getServer().getWorld(args[0].val());
-				x = ArgumentValidation.getInt32(args[1], t);
-				z = ArgumentValidation.getInt32(args[2], t);
+				x = ArgumentValidation.getInt32(args[1], t, env);
+				z = ArgumentValidation.getInt32(args[2], t, env);
 			}
 			if(world == null) { // Happens when m is a fake console or null command sender.
 				throw new CREInvalidWorldException("No world specified", t);
@@ -483,8 +484,8 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
-			MCPlayer m = environment.getEnv(CommandHelperEnvironment.class).GetPlayer();
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
+			MCPlayer m = env.getEnv(CommandHelperEnvironment.class).GetPlayer();
 			MCWorld world;
 			if(args.length == 1) {
 				// World Provided
@@ -505,11 +506,11 @@ public Mixed exec(Target t, Environment environment, Mixed... args) throws Confi
 			}
 			CArray ret = new CArray(t);
 			for(MCChunk c : chunks) {
-				CArray chunk = CArray.GetAssociativeArray(t);
-				chunk.set("x", new CInt(c.getX(), t), t);
-				chunk.set("z", new CInt(c.getZ(), t), t);
-				chunk.set("world", c.getWorld().getName(), t);
-				ret.push(chunk, t);
+				CArray chunk = CArray.GetAssociativeArray(t, null, env);
+				chunk.set("x", new CInt(c.getX(), t), t, env);
+				chunk.set("z", new CInt(c.getZ(), t), t, env);
+				chunk.set("world", c.getWorld().getName(), t, env);
+				ret.push(chunk, t, env);
 			}
 			return ret;
 		}
@@ -557,34 +558,34 @@ public String docs() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
-			MCPlayer m = environment.getEnv(CommandHelperEnvironment.class).GetPlayer();
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
+			MCPlayer m = env.getEnv(CommandHelperEnvironment.class).GetPlayer();
 			MCWorld world;
 			int x;
 			int z;
 			boolean forced;
 			if(args.length == 2) {
-				MCLocation l = ObjectGenerator.GetGenerator().location(args[0], m != null ? m.getWorld() : null, t);
+				MCLocation l = ObjectGenerator.GetGenerator().location(args[0], m != null ? m.getWorld() : null, t, env);
 				world = l.getWorld();
 				x = l.getBlockX();
 				z = l.getBlockZ();
-				forced = ArgumentValidation.getBooleanObject(args[1], t);
+				forced = ArgumentValidation.getBooleanObject(args[1], t, env);
 			} else if(args.length == 3) {
 				if(m == null) {
 					throw new CREInvalidWorldException("No world specified", t);
 				}
 				world = m.getWorld();
-				x = ArgumentValidation.getInt32(args[0], t);
-				z = ArgumentValidation.getInt32(args[1], t);
-				forced = ArgumentValidation.getBooleanObject(args[2], t);
+				x = ArgumentValidation.getInt32(args[0], t, env);
+				z = ArgumentValidation.getInt32(args[1], t, env);
+				forced = ArgumentValidation.getBooleanObject(args[2], t, env);
 			} else {
 				world = Static.getServer().getWorld(args[0].val());
 				if(world == null) {
 					throw new CREInvalidWorldException("The given world (" + args[0].val() + ") does not exist.", t);
 				}
-				x = ArgumentValidation.getInt32(args[1], t);
-				z = ArgumentValidation.getInt32(args[2], t);
-				forced = ArgumentValidation.getBooleanObject(args[3], t);
+				x = ArgumentValidation.getInt32(args[1], t, env);
+				z = ArgumentValidation.getInt32(args[2], t, env);
+				forced = ArgumentValidation.getBooleanObject(args[3], t, env);
 			}
 			world.setChunkForceLoaded(x, z, forced);
 			return CVoid.VOID;
@@ -630,12 +631,12 @@ public String docs() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			MCWorld world;
 			if(args.length == 1) {
 				world = Static.getServer().getWorld(args[0].val());
 			} else {
-				MCPlayer m = environment.getEnv(CommandHelperEnvironment.class).GetPlayer();
+				MCPlayer m = env.getEnv(CommandHelperEnvironment.class).GetPlayer();
 				if(m == null) {
 					throw new CREInvalidWorldException("No world specified", t);
 				}
@@ -647,11 +648,11 @@ public Mixed exec(Target t, Environment environment, Mixed... args) throws Confi
 			MCChunk[] chunks = world.getForceLoadedChunks();
 			CArray ret = new CArray(t);
 			for(MCChunk c : chunks) {
-				CArray chunk = CArray.GetAssociativeArray(t);
-				chunk.set("x", new CInt(c.getX(), t), t);
-				chunk.set("z", new CInt(c.getZ(), t), t);
-				chunk.set("world", c.getWorld().getName(), t);
-				ret.push(chunk, t);
+				CArray chunk = CArray.GetAssociativeArray(t, null, env);
+				chunk.set("x", new CInt(c.getX(), t), t, env);
+				chunk.set("z", new CInt(c.getZ(), t), t, env);
+				chunk.set("world", c.getWorld().getName(), t, env);
+				ret.push(chunk, t, env);
 			}
 			return ret;
 		}
@@ -719,27 +720,27 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
-			MCPlayer m = environment.getEnv(CommandHelperEnvironment.class).GetPlayer();
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
+			MCPlayer m = env.getEnv(CommandHelperEnvironment.class).GetPlayer();
 			MCWorld world;
 			int x;
 			int z;
 
 			if(args.length == 1) {
 				//Location array provided
-				MCLocation l = ObjectGenerator.GetGenerator().location(args[0], m != null ? m.getWorld() : null, t);
+				MCLocation l = ObjectGenerator.GetGenerator().location(args[0], m != null ? m.getWorld() : null, t, env);
 
 				world = l.getWorld();
 				x = l.getBlockX() >> 4;
 				z = l.getBlockZ() >> 4;
 			} else if(args.length == 2) {
 				//Either location array and world provided, or x and z. Test for array at pos 1
-				if(args[0].isInstanceOf(CArray.TYPE)) {
+				if(args[0].isInstanceOf(CArray.TYPE, null, env)) {
 					world = Static.getServer().getWorld(args[1].val());
 					if(world == null) {
 						throw new CREInvalidWorldException("World " + args[1].val() + " does not exist.", t);
 					}
-					MCLocation l = ObjectGenerator.GetGenerator().location(args[0], null, t);
+					MCLocation l = ObjectGenerator.GetGenerator().location(args[0], null, t, env);
 
 					x = l.getBlockX() >> 4;
 					z = l.getBlockZ() >> 4;
@@ -749,13 +750,13 @@ public Mixed exec(Target t, Environment environment, Mixed... args) throws Confi
 					}
 
 					world = m.getWorld();
-					x = ArgumentValidation.getInt32(args[0], t);
-					z = ArgumentValidation.getInt32(args[1], t);
+					x = ArgumentValidation.getInt32(args[0], t, env);
+					z = ArgumentValidation.getInt32(args[1], t, env);
 				}
 			} else {
 				//world, x and z provided
-				x = ArgumentValidation.getInt32(args[0], t);
-				z = ArgumentValidation.getInt32(args[1], t);
+				x = ArgumentValidation.getInt32(args[0], t, env);
+				z = ArgumentValidation.getInt32(args[1], t, env);
 				world = Static.getServer().getWorld(args[2].val());
 				if(world == null) {
 					throw new CREInvalidWorldException("World " + args[2].val() + " does not exist.", t);
@@ -812,25 +813,25 @@ public Boolean runAsync() {
 		Random rnd = new Random();
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
-			MCPlayer m = environment.getEnv(CommandHelperEnvironment.class).GetPlayer();
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
+			MCPlayer m = env.getEnv(CommandHelperEnvironment.class).GetPlayer();
 			MCWorld world;
 			int x;
 			int z;
 			if(args.length == 1) {
 				//Location array provided
-				MCLocation l = ObjectGenerator.GetGenerator().location(args[0], m != null ? m.getWorld() : null, t);
+				MCLocation l = ObjectGenerator.GetGenerator().location(args[0], m != null ? m.getWorld() : null, t, env);
 				world = l.getWorld();
 				x = l.getBlockX() >> 4;
 				z = l.getBlockZ() >> 4;
 			} else if(args.length == 2) {
 				//Either location array and world provided, or x and z. Test for array at pos 1
-				if(args[0].isInstanceOf(CArray.TYPE)) {
+				if(args[0].isInstanceOf(CArray.TYPE, null, env)) {
 					world = Static.getServer().getWorld(args[1].val());
 					if(world == null) {
 						throw new CREInvalidWorldException("The given world (" + args[1].val() + ") does not exist.", t);
 					}
-					MCLocation l = ObjectGenerator.GetGenerator().location(args[0], null, t);
+					MCLocation l = ObjectGenerator.GetGenerator().location(args[0], null, t, env);
 					x = l.getBlockX() >> 4;
 					z = l.getBlockZ() >> 4;
 				} else {
@@ -838,13 +839,13 @@ public Mixed exec(Target t, Environment environment, Mixed... args) throws Confi
 						throw new CREInvalidWorldException("No world specified", t);
 					}
 					world = m.getWorld();
-					x = ArgumentValidation.getInt32(args[0], t);
-					z = ArgumentValidation.getInt32(args[1], t);
+					x = ArgumentValidation.getInt32(args[0], t, env);
+					z = ArgumentValidation.getInt32(args[1], t, env);
 				}
 			} else {
 				//world, x and z provided
-				x = ArgumentValidation.getInt32(args[0], t);
-				z = ArgumentValidation.getInt32(args[1], t);
+				x = ArgumentValidation.getInt32(args[0], t, env);
+				z = ArgumentValidation.getInt32(args[1], t, env);
 				world = Static.getServer().getWorld(args[2].val());
 				if(world == null) {
 					throw new CREInvalidWorldException("The given world (" + args[2].val() + ") does not exist.", t);
@@ -928,10 +929,10 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			MCWorld w = null;
-			if(environment.getEnv(CommandHelperEnvironment.class).GetPlayer() != null) {
-				w = environment.getEnv(CommandHelperEnvironment.class).GetPlayer().getWorld();
+			if(env.getEnv(CommandHelperEnvironment.class).GetPlayer() != null) {
+				w = env.getEnv(CommandHelperEnvironment.class).GetPlayer().getWorld();
 			}
 			if(args.length == 2) {
 				w = Static.getServer().getWorld(args[0].val());
@@ -1019,10 +1020,10 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			MCWorld w = null;
-			if(environment.getEnv(CommandHelperEnvironment.class).GetPlayer() != null) {
-				w = environment.getEnv(CommandHelperEnvironment.class).GetPlayer().getWorld();
+			if(env.getEnv(CommandHelperEnvironment.class).GetPlayer() != null) {
+				w = env.getEnv(CommandHelperEnvironment.class).GetPlayer().getWorld();
 			}
 			if(args.length == 1) {
 				w = Static.getServer().getWorld(args[0].val());
@@ -1073,10 +1074,10 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			MCWorld w = null;
-			if(environment.getEnv(CommandHelperEnvironment.class).GetPlayer() != null) {
-				w = environment.getEnv(CommandHelperEnvironment.class).GetPlayer().getWorld();
+			if(env.getEnv(CommandHelperEnvironment.class).GetPlayer() != null) {
+				w = env.getEnv(CommandHelperEnvironment.class).GetPlayer().getWorld();
 			}
 			if(args.length == 2) {
 				w = Static.getServer().getWorld(args[0].val());
@@ -1134,10 +1135,10 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			MCWorld w = null;
-			if(environment.getEnv(CommandHelperEnvironment.class).GetPlayer() != null) {
-				w = environment.getEnv(CommandHelperEnvironment.class).GetPlayer().getWorld();
+			if(env.getEnv(CommandHelperEnvironment.class).GetPlayer() != null) {
+				w = env.getEnv(CommandHelperEnvironment.class).GetPlayer().getWorld();
 			}
 			if(args.length == 1) {
 				w = Static.getServer().getWorld(args[0].val());
@@ -1168,7 +1169,7 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment env, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			MCWorldCreator creator = StaticLayer.GetConvertor().getWorldCreator(args[0].val());
 			if(args.length >= 3) {
 				MCWorldType type;
@@ -1177,18 +1178,18 @@ public Mixed exec(Target t, Environment env, Mixed... args) throws ConfigRuntime
 				} catch (IllegalArgumentException e) {
 					throw new CREFormatException(args[1].val() + " is not a valid world type.", t);
 				}
-				MCWorldEnvironment environment;
+				MCWorldEnvironment worldEnv;
 				try {
-					environment = MCWorldEnvironment.valueOf(args[2].val().toUpperCase());
+					worldEnv = MCWorldEnvironment.valueOf(args[2].val().toUpperCase());
 				} catch (IllegalArgumentException e) {
 					throw new CREFormatException(args[2].val() + " is not a valid environment type. Must be one of: "
 							+ StringUtils.Join(MCWorldEnvironment.values(), ", "), t);
 				}
-				creator.type(type).environment(environment);
+				creator.type(type).environment(worldEnv);
 			}
 			if((args.length >= 4) && !(args[3] instanceof CNull)) {
-				if(args[3].isInstanceOf(CInt.TYPE)) {
-					creator.seed(ArgumentValidation.getInt(args[3], t));
+				if(args[3].isInstanceOf(CInt.TYPE, null, env)) {
+					creator.seed(ArgumentValidation.getInt(args[3], t, env));
 				} else {
 					creator.seed(args[3].val().hashCode());
 				}
@@ -1248,7 +1249,7 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			CArray worlds = new CArray(t);
 			for(MCWorld w : Static.getServer().getWorlds()) {
 				worlds.push(new CString(w.getName(), t), t);
@@ -1291,7 +1292,7 @@ public Integer[] numArgs() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment env, Mixed... args) throws CancelCommandException, ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws CancelCommandException, ConfigRuntimeException {
 			MCCommandSender cs = env.getEnv(CommandHelperEnvironment.class).GetCommandSender();
 			MCPlayer p = null;
 			MCWorld w = null;
@@ -1309,8 +1310,8 @@ public Mixed exec(Target t, Environment env, Mixed... args) throws CancelCommand
 			}
 
 			if(args.length == 1) {
-				if(args[0].isInstanceOf(CArray.TYPE)) {
-					l = ObjectGenerator.GetGenerator().location(args[0], w, t);
+				if(args[0].isInstanceOf(CArray.TYPE, null, env)) {
+					l = ObjectGenerator.GetGenerator().location(args[0], w, t, env);
 				} else {
 					throw new CREFormatException("Expecting argument 1 of get_chunk_loc to be a location array", t);
 				}
@@ -1321,13 +1322,13 @@ public Mixed exec(Target t, Environment env, Mixed... args) throws CancelCommand
 				}
 			}
 
-			CArray chunk = CArray.GetAssociativeArray(t);
-			chunk.set(0, new CInt(l.getBlockX() >> 4, t), t);
-			chunk.set(1, new CInt(l.getBlockZ() >> 4, t), t);
-			chunk.set(2, new CString(l.getWorld().getName(), t), t);
-			chunk.set("x", new CInt(l.getBlockX() >> 4, t), t);
-			chunk.set("z", new CInt(l.getBlockZ() >> 4, t), t);
-			chunk.set("world", l.getWorld().getName(), t);
+			CArray chunk = CArray.GetAssociativeArray(t, null, env);
+			chunk.set(0, new CInt(l.getBlockX() >> 4, t), t, env);
+			chunk.set(1, new CInt(l.getBlockZ() >> 4, t), t, env);
+			chunk.set(2, new CString(l.getWorld().getName(), t), t, env);
+			chunk.set("x", new CInt(l.getBlockX() >> 4, t), t, env);
+			chunk.set("z", new CInt(l.getBlockZ() >> 4, t), t, env);
+			chunk.set("world", l.getWorld().getName(), t, env);
 			return chunk;
 		}
 
@@ -1378,9 +1379,9 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment env, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			MCPlayer p = env.getEnv(CommandHelperEnvironment.class).GetPlayer();
-			MCLocation loc = ObjectGenerator.GetGenerator().location(args[0], p != null ? p.getWorld() : null, t);
+			MCLocation loc = ObjectGenerator.GetGenerator().location(args[0], p != null ? p.getWorld() : null, t, env);
 
 			MCMaterial mat = StaticLayer.GetMaterial(args[1].val());
 			if(mat == null) {
@@ -1459,21 +1460,21 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			MCWorld w = Static.getServer().getWorld(args[0].val());
 			if(w == null) {
 				throw new CREInvalidWorldException("Unknown world: " + args[0], t);
 			}
-			CArray ret = CArray.GetAssociativeArray(t);
-			ret.set("name", new CString(w.getName(), t), t);
-			ret.set("uuid", new CString(w.getUniqueID().toString(), t), t);
-			ret.set("seed", new CInt(w.getSeed(), t), t);
-			ret.set("environment", new CString(w.getEnvironment().name(), t), t);
-			ret.set("generator", new CString(w.getGenerator(), t), t);
-			ret.set("worldtype", new CString(w.getWorldType().name(), t), t);
-			ret.set("sealevel", new CInt(w.getSeaLevel(), t), t);
-			ret.set("minheight", new CInt(w.getMinHeight(), t), t);
-			ret.set("maxheight", new CInt(w.getMaxHeight(), t), t);
+			CArray ret = CArray.GetAssociativeArray(t, null, env);
+			ret.set("name", new CString(w.getName(), t), t, env);
+			ret.set("uuid", new CString(w.getUniqueID().toString(), t), t, env);
+			ret.set("seed", new CInt(w.getSeed(), t), t, env);
+			ret.set("environment", new CString(w.getEnvironment().name(), t), t, env);
+			ret.set("generator", new CString(w.getGenerator(), t), t, env);
+			ret.set("worldtype", new CString(w.getWorldType().name(), t), t, env);
+			ret.set("sealevel", new CInt(w.getSeaLevel(), t), t, env);
+			ret.set("minheight", new CInt(w.getMinHeight(), t), t, env);
+			ret.set("maxheight", new CInt(w.getMaxHeight(), t), t, env);
 			return ret;
 		}
 
@@ -1519,10 +1520,10 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			boolean save = true;
 			if(args.length == 2) {
-				save = ArgumentValidation.getBoolean(args[1], t);
+				save = ArgumentValidation.getBoolean(args[1], t, env);
 			}
 			MCWorld world = Static.getServer().getWorld(args[0].val());
 			if(world == null) {
@@ -1593,7 +1594,7 @@ public Version since() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			MCWorld world = Static.getServer().getWorld(args[0].val());
 			if(world == null) {
 				throw new CREInvalidWorldException("Unknown world: " + args[0].val(), t);
@@ -1643,7 +1644,7 @@ public Version since() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			MCDifficulty difficulty;
 			if(args.length == 1) {
 				try {
@@ -1709,7 +1710,7 @@ public Version since() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			MCWorld world = Static.getServer().getWorld(args[0].val());
 			if(world == null) {
 				throw new CREInvalidWorldException("Unknown world: " + args[0].val(), t);
@@ -1758,9 +1759,9 @@ public Version since() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			if(args.length == 1) {
-				boolean pvp = ArgumentValidation.getBoolean(args[0], t);
+				boolean pvp = ArgumentValidation.getBoolean(args[0], t, env);
 				for(MCWorld world : Static.getServer().getWorlds()) {
 					world.setPVP(pvp);
 				}
@@ -1769,7 +1770,7 @@ public Mixed exec(Target t, Environment environment, Mixed... args) throws Confi
 				if(world == null) {
 					throw new CREInvalidWorldException("Unknown world: " + args[0].val(), t);
 				}
-				world.setPVP(ArgumentValidation.getBoolean(args[1], t));
+				world.setPVP(ArgumentValidation.getBoolean(args[1], t, env));
 			}
 			return CVoid.VOID;
 		}
@@ -1817,20 +1818,20 @@ public Version since() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			MCWorld world = Static.getServer().getWorld(args[0].val());
 			if(world == null) {
 				throw new CREInvalidWorldException("Unknown world: " + args[0].val(), t);
 			}
 			if(args.length == 1) {
-				CArray gameRules = CArray.GetAssociativeArray(t);
+				CArray gameRules = CArray.GetAssociativeArray(t, null, env);
 				for(String ruleName : world.getGameRules()) {
 					ruleName = ruleName.replace("minecraft:", ""); // Spigot adds this, but not Paper
 					Object value = world.getGameRuleValue(ruleName);
 					if(value instanceof Boolean bool) {
-						gameRules.set(ruleName, CBoolean.get(bool), t);
+						gameRules.set(ruleName, CBoolean.get(bool), t, env);
 					} else {
-						gameRules.set(ruleName, new CInt((int) value, t), t);
+						gameRules.set(ruleName, new CInt((int) value, t), t, env);
 					}
 				}
 				return gameRules;
@@ -1908,7 +1909,7 @@ public Version since() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			int offset = args.length - 2;
 			List<MCWorld> worlds = Static.getServer().getWorlds();
 			MCWorld world = worlds.get(0);
@@ -1930,9 +1931,9 @@ public Mixed exec(Target t, Environment environment, Mixed... args) throws Confi
 				boolean success = false;
 				Object value = world.getGameRuleValue(ruleName);
 				if(value instanceof Boolean) {
-					value = inverted != ArgumentValidation.getBooleanish(args[offset + 1], t);
+					value = inverted != ArgumentValidation.getBooleanish(args[offset + 1], t, env);
 				} else {
-					value = ArgumentValidation.getInt32(args[offset + 1], t);
+					value = ArgumentValidation.getInt32(args[offset + 1], t, env);
 				}
 				if(args.length == 2) {
 					for(MCWorld w : Static.getServer().getWorlds()) {
@@ -1982,12 +1983,12 @@ public Class<? extends CREThrowable>[] thrown() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			MCWorld world = Static.getServer().getWorld(args[0].val());
 			if(world == null) {
 				throw new CREInvalidWorldException("Unknown world: " + args[0].val(), t);
 			}
-			world.setKeepSpawnInMemory(ArgumentValidation.getBooleanObject(args[1], t));
+			world.setKeepSpawnInMemory(ArgumentValidation.getBooleanObject(args[1], t, env));
 			return CVoid.VOID;
 		}
 
@@ -2066,20 +2067,20 @@ public Version since() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment env, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			MCPlayer p = env.getEnv(CommandHelperEnvironment.class).GetPlayer();
-			MCLocation loc = ObjectGenerator.GetGenerator().location(args[0], p != null ? p.getWorld() : null, t);
+			MCLocation loc = ObjectGenerator.GetGenerator().location(args[0], p != null ? p.getWorld() : null, t, env);
 			double distance = 1;
 			boolean clamp = false;
 			if(args.length >= 3) {
-				distance = ArgumentValidation.getNumber(args[2], t);
+				distance = ArgumentValidation.getNumber(args[2], t, env);
 			}
 			if(args.length >= 4) {
-				clamp = ArgumentValidation.getBooleanish(args[3], t);
+				clamp = ArgumentValidation.getBooleanish(args[3], t, env);
 			}
 			Vector3D vector;
-			if(args[1].isInstanceOf(CArray.TYPE)) {
-				MCLocation to = ObjectGenerator.GetGenerator().location(args[1], loc.getWorld(), t);
+			if(args[1].isInstanceOf(CArray.TYPE, null, env)) {
+				MCLocation to = ObjectGenerator.GetGenerator().location(args[1], loc.getWorld(), t, env);
 				if(clamp) {
 					// Need to check if the shift would go beyond the target, if so, just return the final
 					// destination.
@@ -2154,12 +2155,12 @@ public Version since() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment env, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 
 			MCPlayer p = env.getEnv(CommandHelperEnvironment.class).GetPlayer();
 
-			MCLocation from = ObjectGenerator.GetGenerator().location(args[0], p != null ? p.getWorld() : null, t);
-			MCLocation to = ObjectGenerator.GetGenerator().location(args[1], p != null ? p.getWorld() : null, t);
+			MCLocation from = ObjectGenerator.GetGenerator().location(args[0], p != null ? p.getWorld() : null, t, env);
+			MCLocation to = ObjectGenerator.GetGenerator().location(args[1], p != null ? p.getWorld() : null, t, env);
 
 			MCLocation subtract;
 			try {
@@ -2221,12 +2222,12 @@ public Version since() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment env, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 
 			MCPlayer p = env.getEnv(CommandHelperEnvironment.class).GetPlayer();
 
-			MCLocation from = ObjectGenerator.GetGenerator().location(args[0], p != null ? p.getWorld() : null, t);
-			MCLocation to = ObjectGenerator.GetGenerator().location(args[1], p != null ? p.getWorld() : null, t);
+			MCLocation from = ObjectGenerator.GetGenerator().location(args[0], p != null ? p.getWorld() : null, t, env);
+			MCLocation to = ObjectGenerator.GetGenerator().location(args[1], p != null ? p.getWorld() : null, t, env);
 
 			MCLocation subtract = to.subtract(from);
 			double dX = subtract.getX();
@@ -2282,16 +2283,16 @@ public Version since() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment env, Mixed... args) throws ConfigRuntimeException {
-			CArray loc = ArgumentValidation.getArray(args[0], t);
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
+			CArray loc = ArgumentValidation.getArray(args[0], t, env);
 			double yaw;
 			double pitch;
 			if(loc.isAssociative()) {
-				yaw = ArgumentValidation.getDouble(loc.get("yaw", t), t);
-				pitch = ArgumentValidation.getDouble(loc.get("pitch", t), t);
+				yaw = ArgumentValidation.getDouble(loc.get("yaw", t, env), t, env);
+				pitch = ArgumentValidation.getDouble(loc.get("pitch", t, env), t, env);
 			} else {
-				yaw = ArgumentValidation.getDouble(loc.get(4, t), t);
-				pitch = ArgumentValidation.getDouble(loc.get(5, t), t);
+				yaw = ArgumentValidation.getDouble(loc.get(4, t, env), t, env);
+				pitch = ArgumentValidation.getDouble(loc.get(5, t, env), t, env);
 			}
 			yaw = java.lang.Math.toRadians(yaw);
 			pitch = java.lang.Math.toRadians(pitch);
@@ -2301,7 +2302,7 @@ public Mixed exec(Target t, Environment env, Mixed... args) throws ConfigRuntime
 			double z = java.lang.Math.cos(yaw) * cosPitch;
 			Vector3D v = new Vector3D(x, y, z);
 			if(args.length == 2) {
-				v = v.multiply(ArgumentValidation.getDouble(args[1], t));
+				v = v.multiply(ArgumentValidation.getDouble(args[1], t, env));
 			}
 			return ObjectGenerator.GetGenerator().vector(v);
 		}
@@ -2347,9 +2348,9 @@ public Version since() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment env, Mixed... args) throws ConfigRuntimeException {
-			MCLocation loc1 = ObjectGenerator.GetGenerator().location(args[0], null, t);
-			MCLocation loc2 = ObjectGenerator.GetGenerator().location(args[1], null, t);
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
+			MCLocation loc1 = ObjectGenerator.GetGenerator().location(args[0], null, t, env);
+			MCLocation loc2 = ObjectGenerator.GetGenerator().location(args[1], null, t, env);
 			try {
 				return new CDouble(loc1.distance(loc2), t);
 			} catch (IllegalArgumentException iae) {
@@ -2377,7 +2378,7 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			MCWorld world = Static.getWorld(args[0], t);
 			world.save();
 			return CVoid.VOID;
@@ -2424,13 +2425,13 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target target, Environment environment, Mixed... args) throws ConfigRuntimeException {
-			MCPlayer player = environment.getEnv(CommandHelperEnvironment.class).GetPlayer();
+		public Mixed exec(Target target, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
+			MCPlayer player = env.getEnv(CommandHelperEnvironment.class).GetPlayer();
 			MCWorld world = null;
 			if(player != null) {
 				world = player.getWorld();
 			}
-			MCLocation loc = ObjectGenerator.GetGenerator().location(args[0], world, target);
+			MCLocation loc = ObjectGenerator.GetGenerator().location(args[0], world, target, env);
 			return new CDouble(loc.getBlock().getTemperature(), target);
 		}
 
@@ -2474,19 +2475,19 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			MCWorld w = Static.getServer().getWorld(args[0].val());
 			if(w == null) {
 				throw new CREInvalidWorldException("Unknown world: " + args[0], t);
 			}
 			MCWorldBorder wb = w.getWorldBorder();
-			CArray ret = CArray.GetAssociativeArray(t);
-			ret.set("width", new CDouble(wb.getSize(), t), t);
-			ret.set("center", ObjectGenerator.GetGenerator().location(wb.getCenter(), false), t);
-			ret.set("damagebuffer", new CDouble(wb.getDamageBuffer(), t), t);
-			ret.set("damageamount", new CDouble(wb.getDamageAmount(), t), t);
-			ret.set("warningtime", new CInt(wb.getWarningTime(), t), t);
-			ret.set("warningdistance", new CInt(wb.getWarningDistance(), t), t);
+			CArray ret = CArray.GetAssociativeArray(t, null, env);
+			ret.set("width", new CDouble(wb.getSize(), t), t, env);
+			ret.set("center", ObjectGenerator.GetGenerator().location(wb.getCenter(), false), t, env);
+			ret.set("damagebuffer", new CDouble(wb.getDamageBuffer(), t), t, env);
+			ret.set("damageamount", new CDouble(wb.getDamageAmount(), t), t, env);
+			ret.set("warningtime", new CInt(wb.getWarningTime(), t), t, env);
+			ret.set("warningdistance", new CInt(wb.getWarningDistance(), t), t, env);
 			return ret;
 		}
 
@@ -2532,39 +2533,39 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			MCWorld w = Static.getServer().getWorld(args[0].val());
 			if(w == null) {
 				throw new CREInvalidWorldException("Unknown world: " + args[0], t);
 			}
 			MCWorldBorder wb = w.getWorldBorder();
 			Mixed c = args[1];
-			if(!(c.isInstanceOf(CArray.TYPE))) {
+			if(!(c.isInstanceOf(CArray.TYPE, null, env))) {
 				throw new CREFormatException("Expected array but given \"" + args[1].val() + "\"", t);
 			}
 			CArray params = (CArray) c;
 			if(params.containsKey("width")) {
 				if(params.containsKey("seconds")) {
-					wb.setSize(ArgumentValidation.getDouble(params.get("width", t), t),
-							ArgumentValidation.getInt32(params.get("seconds", t), t));
+					wb.setSize(ArgumentValidation.getDouble(params.get("width", t, env), t, env),
+							ArgumentValidation.getInt32(params.get("seconds", t, env), t, env));
 				} else {
-					wb.setSize(ArgumentValidation.getDouble(params.get("width", t), t));
+					wb.setSize(ArgumentValidation.getDouble(params.get("width", t, env), t, env));
 				}
 			}
 			if(params.containsKey("center")) {
-				wb.setCenter(ObjectGenerator.GetGenerator().location(params.get("center", t), w, t));
+				wb.setCenter(ObjectGenerator.GetGenerator().location(params.get("center", t, env), w, t, env));
 			}
 			if(params.containsKey("damagebuffer")) {
-				wb.setDamageBuffer(ArgumentValidation.getDouble(params.get("damagebuffer", t), t));
+				wb.setDamageBuffer(ArgumentValidation.getDouble(params.get("damagebuffer", t, env), t, env));
 			}
 			if(params.containsKey("damageamount")) {
-				wb.setDamageAmount(ArgumentValidation.getDouble(params.get("damageamount", t), t));
+				wb.setDamageAmount(ArgumentValidation.getDouble(params.get("damageamount", t, env), t, env));
 			}
 			if(params.containsKey("warningtime")) {
-				wb.setWarningTime(ArgumentValidation.getInt32(params.get("warningtime", t), t));
+				wb.setWarningTime(ArgumentValidation.getInt32(params.get("warningtime", t, env), t, env));
 			}
 			if(params.containsKey("warningdistance")) {
-				wb.setWarningDistance(ArgumentValidation.getInt32(params.get("warningdistance", t), t));
+				wb.setWarningDistance(ArgumentValidation.getInt32(params.get("warningdistance", t, env), t, env));
 			}
 			return CVoid.VOID;
 		}
@@ -2611,7 +2612,7 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			MCWorld w = Static.getServer().getWorld(args[0].val());
 			if(w == null) {
 				throw new CREInvalidWorldException("Unknown world: " + args[0].val(), t);
@@ -2659,9 +2660,9 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			if(args.length == 1) {
-				boolean autosave = ArgumentValidation.getBooleanish(args[0], t);
+				boolean autosave = ArgumentValidation.getBooleanish(args[0], t, env);
 				for(MCWorld world : Static.getServer().getWorlds()) {
 					world.setAutoSave(autosave);
 				}
@@ -2670,7 +2671,7 @@ public Mixed exec(Target t, Environment environment, Mixed... args) throws Confi
 				if(world == null) {
 					throw new CREInvalidWorldException("Unknown world: " + args[0].val(), t);
 				}
-				world.setAutoSave(ArgumentValidation.getBooleanish(args[1], t));
+				world.setAutoSave(ArgumentValidation.getBooleanish(args[1], t, env));
 			}
 			return CVoid.VOID;
 		}
diff --git a/src/main/java/com/laytonsmith/core/functions/XGUI.java b/src/main/java/com/laytonsmith/core/functions/XGUI.java
index 326cb11135..8457cbeb76 100644
--- a/src/main/java/com/laytonsmith/core/functions/XGUI.java
+++ b/src/main/java/com/laytonsmith/core/functions/XGUI.java
@@ -12,6 +12,7 @@
 import com.laytonsmith.core.constructs.CInt;
 import com.laytonsmith.core.constructs.CVoid;
 import com.laytonsmith.core.constructs.Target;
+import com.laytonsmith.core.constructs.generics.GenericParameters;
 import com.laytonsmith.core.environments.Environment;
 import com.laytonsmith.core.exceptions.CRE.CREFormatException;
 import com.laytonsmith.core.exceptions.CRE.CREIOException;
@@ -78,7 +79,7 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			JFrame frame = new JFrame();
 			int id = WINDOW_IDS.incrementAndGet();
 			String title = "";
@@ -148,7 +149,7 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			int id = ArgumentValidation.getInt32(args[0], t);
 			boolean show = true;
 			if(args.length > 1) {
@@ -202,7 +203,7 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			int windowID = ArgumentValidation.getInt32(args[0], t);
 			int x = ArgumentValidation.getInt32(args[1], t);
 			int y = ArgumentValidation.getInt32(args[2], t);
@@ -267,7 +268,7 @@ public Boolean runAsync() {
 		}
 
 		@Override
-		public Mixed exec(Target t, Environment environment, Mixed... args) throws ConfigRuntimeException {
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			String url = args[0].val();
 			try {
 				if(Desktop.isDesktopSupported()) {
diff --git a/src/main/java/com/laytonsmith/core/functions/asm/Cmdline.java b/src/main/java/com/laytonsmith/core/functions/asm/Cmdline.java
index 3daf163263..1b9eff9476 100644
--- a/src/main/java/com/laytonsmith/core/functions/asm/Cmdline.java
+++ b/src/main/java/com/laytonsmith/core/functions/asm/Cmdline.java
@@ -15,6 +15,7 @@
 import com.laytonsmith.core.asm.LLVMVersion;
 import com.laytonsmith.core.compiler.CompilerEnvironment;
 import com.laytonsmith.core.constructs.Target;
+import com.laytonsmith.core.constructs.generics.GenericParameters;
 import com.laytonsmith.core.environments.Environment;
 import com.laytonsmith.core.exceptions.CRE.CREThrowable;
 import com.laytonsmith.core.exceptions.ConfigCompileException;
@@ -30,7 +31,7 @@ public class Cmdline {
 	public static class exit extends LLVMFunction {
 
 		@Override
-		public IRData buildIR(IRBuilder builder, Target t, Environment env, ParseTree... nodes) throws ConfigCompileException {
+		public IRData buildIR(IRBuilder builder, Target t, Environment env, GenericParameters generics, ParseTree... nodes) throws ConfigCompileException {
 			OSUtils.OS os = env.getEnv(CompilerEnvironment.class).getTargetOS();
 			LLVMEnvironment llvmenv = env.getEnv(LLVMEnvironment.class);
 			String code = "i32 0";
@@ -72,7 +73,7 @@ public Version since() {
 	public static class sys_out extends LLVMFunction {
 
 		@Override
-		public IRData buildIR(IRBuilder builder, Target t, Environment env, ParseTree... nodes) throws ConfigCompileException {
+		public IRData buildIR(IRBuilder builder, Target t, Environment env, GenericParameters generics, ParseTree... nodes) throws ConfigCompileException {
 			OSUtils.OS os = env.getEnv(CompilerEnvironment.class).getTargetOS();
 			LLVMEnvironment llvmenv = env.getEnv(LLVMEnvironment.class);
 			List<String> lines = new ArrayList<>();
diff --git a/src/main/java/com/laytonsmith/core/functions/asm/Compiler.java b/src/main/java/com/laytonsmith/core/functions/asm/Compiler.java
index a0e73f70a3..7174825733 100644
--- a/src/main/java/com/laytonsmith/core/functions/asm/Compiler.java
+++ b/src/main/java/com/laytonsmith/core/functions/asm/Compiler.java
@@ -11,6 +11,7 @@
 import com.laytonsmith.core.asm.LLVMFunction;
 import com.laytonsmith.core.asm.LLVMVersion;
 import com.laytonsmith.core.constructs.Target;
+import com.laytonsmith.core.constructs.generics.GenericParameters;
 import com.laytonsmith.core.environments.Environment;
 import com.laytonsmith.core.exceptions.CRE.CREThrowable;
 import com.laytonsmith.core.exceptions.ConfigCompileException;
@@ -23,7 +24,7 @@ public class Compiler {
 	public static class __statements__ extends LLVMFunction {
 
 		@Override
-		public IRData buildIR(IRBuilder builder, Target t, Environment env, ParseTree... nodes) throws ConfigCompileException {
+		public IRData buildIR(IRBuilder builder, Target t, Environment env, GenericParameters generics, ParseTree... nodes) throws ConfigCompileException {
 			for(ParseTree node : nodes) {
 				AsmCompiler.getIR(builder, node, env);
 			}
@@ -56,7 +57,7 @@ public Version since() {
 	public static class dyn extends LLVMFunction {
 
 		@Override
-		public IRData buildIR(IRBuilder builder, Target t, Environment env, ParseTree... nodes) throws ConfigCompileException {
+		public IRData buildIR(IRBuilder builder, Target t, Environment env, GenericParameters generics, ParseTree... nodes) throws ConfigCompileException {
 			IRData data = AsmCompiler.getIR(builder, nodes[0], env);
 			LLVMEnvironment llvmenv = env.getEnv(LLVMEnvironment.class);
 			int alloca = llvmenv.getNewLocalVariableReference(data.getResultType());
diff --git a/src/main/java/com/laytonsmith/core/functions/asm/DataHandling.java b/src/main/java/com/laytonsmith/core/functions/asm/DataHandling.java
index 83c1f36237..ce82912167 100644
--- a/src/main/java/com/laytonsmith/core/functions/asm/DataHandling.java
+++ b/src/main/java/com/laytonsmith/core/functions/asm/DataHandling.java
@@ -14,6 +14,7 @@
 import com.laytonsmith.core.constructs.CClassType;
 import com.laytonsmith.core.constructs.IVariable;
 import com.laytonsmith.core.constructs.Target;
+import com.laytonsmith.core.constructs.generics.GenericParameters;
 import com.laytonsmith.core.environments.Environment;
 import com.laytonsmith.core.exceptions.CRE.CRECastException;
 import com.laytonsmith.core.exceptions.CRE.CREThrowable;
@@ -28,7 +29,7 @@ public class DataHandling {
 	public static class assign extends LLVMFunction {
 
 		@Override
-		public IRData buildIR(IRBuilder builder, Target t, Environment env, ParseTree... nodes) throws ConfigCompileException {
+		public IRData buildIR(IRBuilder builder, Target t, Environment env, GenericParameters generics, ParseTree... nodes) throws ConfigCompileException {
 			LLVMEnvironment llvmenv = env.getEnv(LLVMEnvironment.class);
 			int offset;
 			CClassType type;
diff --git a/src/main/java/com/laytonsmith/core/functions/asm/Math.java b/src/main/java/com/laytonsmith/core/functions/asm/Math.java
index 40d88372b1..89c4fdc4e3 100644
--- a/src/main/java/com/laytonsmith/core/functions/asm/Math.java
+++ b/src/main/java/com/laytonsmith/core/functions/asm/Math.java
@@ -15,6 +15,7 @@
 import com.laytonsmith.core.asm.LLVMVersion;
 import com.laytonsmith.core.compiler.CompilerEnvironment;
 import com.laytonsmith.core.constructs.Target;
+import com.laytonsmith.core.constructs.generics.GenericParameters;
 import com.laytonsmith.core.environments.Environment;
 import com.laytonsmith.core.exceptions.CRE.CREThrowable;
 import com.laytonsmith.core.exceptions.ConfigCompileException;
@@ -43,7 +44,7 @@ public void addStartupCode(IRBuilder builder, Environment startupEnv, Target t)
 		}
 
 		@Override
-		public IRData buildIR(IRBuilder builder, Target t, Environment env, ParseTree... nodes) throws ConfigCompileException {
+		public IRData buildIR(IRBuilder builder, Target t, Environment env, GenericParameters generics, ParseTree... nodes) throws ConfigCompileException {
 			LLVMEnvironment llvmenv = env.getEnv(LLVMEnvironment.class);
 			CompilerEnvironment cEnv = env.getEnv(CompilerEnvironment.class);
 			llvmenv.addGlobalDeclaration(AsmCommonLibTemplates.RAND, env);
diff --git a/src/main/java/com/laytonsmith/core/functions/asm/Meta.java b/src/main/java/com/laytonsmith/core/functions/asm/Meta.java
index 16f61e6483..0406499fbb 100644
--- a/src/main/java/com/laytonsmith/core/functions/asm/Meta.java
+++ b/src/main/java/com/laytonsmith/core/functions/asm/Meta.java
@@ -10,6 +10,7 @@
 import com.laytonsmith.core.asm.LLVMFunction;
 import com.laytonsmith.core.asm.LLVMVersion;
 import com.laytonsmith.core.constructs.Target;
+import com.laytonsmith.core.constructs.generics.GenericParameters;
 import com.laytonsmith.core.environments.Environment;
 import com.laytonsmith.core.exceptions.CRE.CREThrowable;
 import com.laytonsmith.core.exceptions.ConfigCompileException;
@@ -22,7 +23,7 @@ public class Meta {
 	public static class noop extends LLVMFunction {
 
 		@Override
-		public IRData buildIR(IRBuilder builder, Target t, Environment env, ParseTree... nodes)
+		public IRData buildIR(IRBuilder builder, Target t, Environment env, GenericParameters generics, ParseTree... nodes)
 				throws ConfigCompileException {
 			builder.appendLine(t, "add i1 0, 0 ; noop()");
 			return IRDataBuilder.asVoid();
diff --git a/src/main/java/com/laytonsmith/core/natives/interfaces/AbstractMixed.java b/src/main/java/com/laytonsmith/core/natives/interfaces/AbstractMixed.java
index 67150e8dd5..84d1c3b36d 100644
--- a/src/main/java/com/laytonsmith/core/natives/interfaces/AbstractMixed.java
+++ b/src/main/java/com/laytonsmith/core/natives/interfaces/AbstractMixed.java
@@ -6,6 +6,9 @@
 import com.laytonsmith.core.constructs.CClassType;
 import com.laytonsmith.core.constructs.Construct;
 import com.laytonsmith.core.constructs.Target;
+import com.laytonsmith.core.constructs.generics.GenericParameters;
+import com.laytonsmith.core.constructs.generics.LeftHandGenericUse;
+import com.laytonsmith.core.environments.Environment;
 import com.laytonsmith.core.objects.AccessModifier;
 import com.laytonsmith.core.objects.ObjectModifier;
 import java.net.URL;
@@ -60,12 +63,19 @@ public CClassType getContainingClass() {
 		return null;
 	}
 
+	/** @deprecated Use {@link #isInstanceOf(CClassType, LeftHandGenericUse, Environment)} instead. */
+	@Deprecated
 	@Override
 	public boolean isInstanceOf(CClassType type) {
+		return isInstanceOf(type, null, null);
+	}
+
+	@Override
+	public boolean isInstanceOf(CClassType type, LeftHandGenericUse lhsGenericParameters, Environment env) {
 		if(type.getNativeType() != null) {
 			return type.getNativeType().isAssignableFrom(this.getClass());
 		}
-		return Construct.isInstanceof(this, type);
+		return Construct.isInstanceof(this, type, env);
 	}
 
 	@Override
@@ -81,12 +91,24 @@ public boolean isInstanceOf(Class<? extends Mixed> type) {
 	 * This method may be overridden in special cases, such as dynamic types, but for most types, this
 	 * @return
 	 * @throws IllegalArgumentException If the class isn't public facing.
+	 * @deprecated Use {@link #typeof(Environment)} instead.
 	 */
+	@Deprecated
 	@Override
 	public CClassType typeof() {
+		return typeof(null);
+	}
+
+	@Override
+	public CClassType typeof(Environment env) {
 		return Construct.typeof(this);
 	}
 
+	@Override
+	public GenericParameters getGenericParameters() {
+		return null;
+	}
+
 	@Override
 	public URL getSourceJar() {
 		return ClassDiscovery.GetClassContainer(this.getClass());
diff --git a/src/main/java/com/laytonsmith/core/natives/interfaces/AbstractMixedInterfaceRunner.java b/src/main/java/com/laytonsmith/core/natives/interfaces/AbstractMixedInterfaceRunner.java
index 658ba2c1a0..bba8c3d008 100644
--- a/src/main/java/com/laytonsmith/core/natives/interfaces/AbstractMixedInterfaceRunner.java
+++ b/src/main/java/com/laytonsmith/core/natives/interfaces/AbstractMixedInterfaceRunner.java
@@ -10,6 +10,9 @@
 import com.laytonsmith.core.constructs.CClassType;
 import com.laytonsmith.core.constructs.Construct;
 import com.laytonsmith.core.constructs.Target;
+import com.laytonsmith.core.constructs.generics.GenericParameters;
+import com.laytonsmith.core.constructs.generics.LeftHandGenericUse;
+import com.laytonsmith.core.environments.Environment;
 import com.laytonsmith.core.objects.AccessModifier;
 import java.net.URL;
 import java.util.EnumSet;
@@ -113,15 +116,24 @@ public CClassType getContainingClass() {
 	 *
 	 * @return
 	 * @throws IllegalArgumentException If the class isn't public facing.
+	 * @deprecated Use {@link #typeof(Environment)} instead.
 	 */
+	@Deprecated
 	@Override
 	public final CClassType typeof() {
+		return typeof(null);
+	}
+
+	@Override
+	public final CClassType typeof(Environment env) {
 		return Construct.typeof(this);
 	}
 
+	/** @deprecated Use {@link #isInstanceOf(CClassType, LeftHandGenericUse, Environment)} instead. */
+	@Deprecated
 	@Override
 	public boolean isInstanceOf(CClassType type) {
-		return Construct.isInstanceof(this, type);
+		return isInstanceOf(type, null, null);
 	}
 
 	@Override
@@ -129,4 +141,14 @@ public boolean isInstanceOf(Class<? extends Mixed> type) {
 		return Construct.isInstanceof(this, type);
 	}
 
+	@Override
+	public boolean isInstanceOf(CClassType type, LeftHandGenericUse lhsGenericParameters, Environment env) {
+		return Construct.isInstanceof(this, type, env);
+	}
+
+	@Override
+	public GenericParameters getGenericParameters() {
+		return null;
+	}
+
 }
diff --git a/src/main/java/com/laytonsmith/core/natives/interfaces/ArrayAccess.java b/src/main/java/com/laytonsmith/core/natives/interfaces/ArrayAccess.java
index b9cdf4caa3..2e78caf9bb 100644
--- a/src/main/java/com/laytonsmith/core/natives/interfaces/ArrayAccess.java
+++ b/src/main/java/com/laytonsmith/core/natives/interfaces/ArrayAccess.java
@@ -4,6 +4,7 @@
 import com.laytonsmith.annotations.typeof;
 import com.laytonsmith.core.constructs.CClassType;
 import com.laytonsmith.core.constructs.Target;
+import com.laytonsmith.core.environments.Environment;
 import com.laytonsmith.core.exceptions.ConfigRuntimeException;
 import java.util.Set;
 
@@ -23,9 +24,21 @@ public interface ArrayAccess extends Booleanish {
 	 * @param index
 	 * @param t
 	 * @return
+	 * @deprecated Use {@link #get(String, Target, Environment)} instead.
 	 */
+	@Deprecated
 	public Mixed get(String index, Target t) throws ConfigRuntimeException;
 
+	/**
+	 * Return the mixed at this location, with environment context.
+	 *
+	 * @param index
+	 * @param t
+	 * @param env
+	 * @return
+	 */
+	Mixed get(String index, Target t, Environment env) throws ConfigRuntimeException;
+
 	/**
 	 * Returns the mixed at this location. This should throw an exception if the index does not exist. This method will
 	 * not be called if {@link #isAssociative()} returns true.
@@ -34,9 +47,22 @@ public interface ArrayAccess extends Booleanish {
 	 * @param t
 	 * @return
 	 * @throws ConfigRuntimeException
+	 * @deprecated Use {@link #get(int, Target, Environment)} instead.
 	 */
+	@Deprecated
 	public Mixed get(int index, Target t) throws ConfigRuntimeException;
 
+	/**
+	 * Returns the mixed at this location, with environment context.
+	 *
+	 * @param index
+	 * @param t
+	 * @param env
+	 * @return
+	 * @throws ConfigRuntimeException
+	 */
+	Mixed get(int index, Target t, Environment env) throws ConfigRuntimeException;
+
 	/**
 	 * Returns the mixed at this location. This should throw an exception if the index does not exist. This method may
 	 * be called whether or not it isAssociative returns true.
@@ -45,17 +71,40 @@ public interface ArrayAccess extends Booleanish {
 	 * @param t
 	 * @return
 	 * @throws ConfigRuntimeException
+	 * @deprecated Use {@link #get(Mixed, Target, Environment)} instead.
 	 */
+	@Deprecated
 	public Mixed get(Mixed index, Target t) throws ConfigRuntimeException;
 
+	/**
+	 * Returns the mixed at this location, with environment context.
+	 *
+	 * @param index
+	 * @param t
+	 * @param env
+	 * @return
+	 * @throws ConfigRuntimeException
+	 */
+	Mixed get(Mixed index, Target t, Environment env) throws ConfigRuntimeException;
+
 	/**
 	 * If {@link #isAssociative()} returns true, this should return a set of all keys. If {@link #isAssociative()}
 	 * returns false, this method will not be called.
 	 *
 	 * @return
+	 * @deprecated Use {@link #keySet(Environment)} instead.
 	 */
+	@Deprecated
 	public Set<Mixed> keySet();
 
+	/**
+	 * Returns the key set with environment context.
+	 *
+	 * @param env
+	 * @return
+	 */
+	Set<Mixed> keySet(Environment env);
+
 	/**
 	 * Unlike {@link #canBeAssociative()}, this is a runtime flag. If the underlying object is associative (that is, it
 	 * is an unordered, non numeric key set), this should return true. If this is true, then
@@ -80,23 +129,26 @@ public interface ArrayAccess extends Booleanish {
 	 * Returns a slice at the specified location. Should throw an exception if an element in the range doesn't exist.
 	 * The range is inclusive.
 	 *
-	 * @implNote In general, MethodScript supports undefined begin and end slices, as well as reverse slices. For
-	 * CArray type only, this is fully covered, but for other slice types, only negative slice numbers are converted,
-	 * and subclasses must handle both forward and reverse slices if applicable. A good way to handle that is as such:
-	 * <pre><code>
-	 * int start = Math.min(begin, end);
-	 * int stop = Math.max(begin, end);
-	 * int step = (begin &lt;= end) ? 1 : -1;
-	 * for(int i = start; i != stop; i += step) { ... }
-	 * </code></pre>
-	 *
 	 * @param begin
 	 * @param end
 	 * @param t
 	 * @return
+	 * @deprecated Use {@link #slice(int, int, Target, Environment)} instead.
 	 */
+	@Deprecated
 	public Mixed slice(int begin, int end, Target t);
 
+	/**
+	 * Returns a slice at the specified location, with environment context.
+	 *
+	 * @param begin
+	 * @param end
+	 * @param t
+	 * @param env
+	 * @return
+	 */
+	Mixed slice(int begin, int end, Target t, Environment env);
+
 
 	@Override
 	public String docs();
diff --git a/src/main/java/com/laytonsmith/core/natives/interfaces/ArrayAccessRunner.java b/src/main/java/com/laytonsmith/core/natives/interfaces/ArrayAccessRunner.java
index c9c09373dd..b934edf37d 100644
--- a/src/main/java/com/laytonsmith/core/natives/interfaces/ArrayAccessRunner.java
+++ b/src/main/java/com/laytonsmith/core/natives/interfaces/ArrayAccessRunner.java
@@ -4,6 +4,7 @@
 import com.laytonsmith.PureUtilities.Version;
 import com.laytonsmith.core.MSVersion;
 import com.laytonsmith.core.constructs.CClassType;
+import com.laytonsmith.core.constructs.generics.GenericParameters;
 
 /**
  *
@@ -32,4 +33,8 @@ public CClassType[] getInterfaces() {
 		return CClassType.EMPTY_CLASS_ARRAY;
 	}
 
+	@Override
+	public GenericParameters getGenericParameters() {
+		return null;
+	}
 }
diff --git a/src/main/java/com/laytonsmith/core/natives/interfaces/ArrayAccessSet.java b/src/main/java/com/laytonsmith/core/natives/interfaces/ArrayAccessSet.java
index 1fa79ea07b..63838ffc5b 100644
--- a/src/main/java/com/laytonsmith/core/natives/interfaces/ArrayAccessSet.java
+++ b/src/main/java/com/laytonsmith/core/natives/interfaces/ArrayAccessSet.java
@@ -3,6 +3,7 @@
 import com.laytonsmith.annotations.typeof;
 import com.laytonsmith.core.constructs.CClassType;
 import com.laytonsmith.core.constructs.Target;
+import com.laytonsmith.core.environments.Environment;
 
 /**
  * Things that implement this can set the value via square bracket notation. The generic type provided is the index
@@ -23,6 +24,18 @@ public interface ArrayAccessSet extends Mixed {
 	 * @param index The zero-based index.
 	 * @param value The value to set.
 	 * @param t The code target.
+	 * @deprecated Use {@link #set(Mixed, Mixed, Target, Environment)} instead.
 	 */
+	@Deprecated
 	public void set(Mixed index, Mixed value, Target t);
+
+	/**
+	 * Sets the value at the specified index in the object, with environment context.
+	 *
+	 * @param index The zero-based index.
+	 * @param value The value to set.
+	 * @param t The code target.
+	 * @param env The environment.
+	 */
+	void set(Mixed index, Mixed value, Target t, Environment env);
 }
diff --git a/src/main/java/com/laytonsmith/core/natives/interfaces/ArrayAccessSetRunner.java b/src/main/java/com/laytonsmith/core/natives/interfaces/ArrayAccessSetRunner.java
index 211c0150a9..752a6c1b18 100644
--- a/src/main/java/com/laytonsmith/core/natives/interfaces/ArrayAccessSetRunner.java
+++ b/src/main/java/com/laytonsmith/core/natives/interfaces/ArrayAccessSetRunner.java
@@ -4,6 +4,7 @@
 import com.laytonsmith.PureUtilities.Version;
 import com.laytonsmith.core.MSVersion;
 import com.laytonsmith.core.constructs.CClassType;
+import com.laytonsmith.core.constructs.generics.GenericParameters;
 
 /**
  *
@@ -31,4 +32,9 @@ public CClassType[] getSuperclasses() {
 	public CClassType[] getInterfaces() {
 		return CClassType.EMPTY_CLASS_ARRAY;
 	}
+
+	@Override
+	public GenericParameters getGenericParameters() {
+		return null;
+	}
 }
diff --git a/src/main/java/com/laytonsmith/core/natives/interfaces/Booleanish.java b/src/main/java/com/laytonsmith/core/natives/interfaces/Booleanish.java
index 8074cdd2ab..412ad2d3ea 100644
--- a/src/main/java/com/laytonsmith/core/natives/interfaces/Booleanish.java
+++ b/src/main/java/com/laytonsmith/core/natives/interfaces/Booleanish.java
@@ -4,7 +4,7 @@
 import com.laytonsmith.core.ArgumentValidation;
 import com.laytonsmith.core.constructs.CClassType;
 import com.laytonsmith.core.constructs.Target;
-
+import com.laytonsmith.core.environments.Environment;
 
 /**
  * A value that is Booleanish is a non-boolean value, that can be converted to Boolean.
@@ -28,6 +28,26 @@ public interface Booleanish extends Mixed {
 	 * @param t The code target, in case there are errors that are thrown, the correct target can be provided in the
 	 * error.
 	 * @return True if the value is trueish, false if it is falseish.
+	 * @deprecated Use {@link #getBooleanValue(Target, Environment)} instead.
 	 */
+	@Deprecated
 	boolean getBooleanValue(Target t);
+
+	/**
+	 * Returns true if this value is a trueish value. Each implementation is free to define this as they wish. In
+	 * general, code that supports Booleanish values should not use this method directly, use
+	 * {@link ArgumentValidation#getBooleanish(com.laytonsmith.core.natives.interfaces.Mixed,
+	 * com.laytonsmith.core.constructs.Target)}, which ensures that the error message, if this is not an actual
+	 * Booleanish value, is standardized. In general, methods should not accept a Booleanish value (with some critical
+	 * exceptions, such as if(), for(), etc) as in the future, this will prevent functions from being fully strongly
+	 * typed in strict mode. In non-strict mode (or strict mode with the auto keyword) Booleanish types will be cross
+	 * cast to a boolean first anyways, so there is no point in accepting Booleanish values.
+	 *
+	 * @param t The code target, in case there are errors that are thrown, the correct target can be provided in the
+	 * error.
+	 * @param env The environment.
+	 * @return True if the value is trueish, false if it is falseish.
+	 */
+	boolean getBooleanValue(Target t, Environment env);
+
 }
diff --git a/src/main/java/com/laytonsmith/core/natives/interfaces/BooleanishRunner.java b/src/main/java/com/laytonsmith/core/natives/interfaces/BooleanishRunner.java
index 0d81268be2..fa16cc40fb 100644
--- a/src/main/java/com/laytonsmith/core/natives/interfaces/BooleanishRunner.java
+++ b/src/main/java/com/laytonsmith/core/natives/interfaces/BooleanishRunner.java
@@ -10,6 +10,7 @@
 import com.laytonsmith.PureUtilities.Version;
 import com.laytonsmith.core.MSVersion;
 import com.laytonsmith.core.constructs.CClassType;
+import com.laytonsmith.core.constructs.generics.GenericParameters;
 
 /**
  *
@@ -40,4 +41,9 @@ public CClassType[] getInterfaces() {
 	public ObjectType getObjectType() {
 		return ObjectType.INTERFACE;
 	}
+
+	@Override
+	public GenericParameters getGenericParameters() {
+		return null;
+	}
 }
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 392d87e075..8020ba3aa9 100644
--- a/src/main/java/com/laytonsmith/core/natives/interfaces/Callable.java
+++ b/src/main/java/com/laytonsmith/core/natives/interfaces/Callable.java
@@ -1,12 +1,13 @@
 package com.laytonsmith.core.natives.interfaces;
 
 import com.laytonsmith.annotations.typeof;
+import com.laytonsmith.core.CallbackYield;
+import com.laytonsmith.core.ParseTree;
 import com.laytonsmith.core.constructs.CClassType;
 import com.laytonsmith.core.constructs.Target;
 import com.laytonsmith.core.environments.Environment;
 import com.laytonsmith.core.exceptions.CancelCommandException;
 import com.laytonsmith.core.exceptions.ConfigRuntimeException;
-import com.laytonsmith.core.exceptions.ProgramFlowManipulationException;
 
 /**
  * A Callable represents something that is executable.
@@ -21,24 +22,55 @@ 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.
 	 *
-	 * LoopManipulationExceptions will never bubble up past this point, because they are never allowed, so they are
-	 * handled automatically, but other ProgramFlowManipulationExceptions will, . ConfigRuntimeExceptions will also
-	 * 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 environment
+	 * <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 ProgramFlowManipulationException If any ProgramFlowManipulationException is thrown (other than a
-	 * LoopManipulationException) within the callable
+	 * @throws CancelCommandException If die() is called within the callable
+	 * @deprecated Functions that call closures should extend {@link CallbackYield}
+	 * instead of calling this directly, which re-enters eval() and defeats the iterative interpreter.
 	 */
-	Mixed executeCallable(Environment environment, Target t, Mixed... values)
-			throws ConfigRuntimeException, ProgramFlowManipulationException, CancelCommandException;
+	@Deprecated
+	Mixed executeCallable(Environment env, Target t, Mixed... values)
+			throws ConfigRuntimeException, CancelCommandException;
 
 	/**
 	 * Returns the environment associated with this callable.
 	 * @return
 	 */
 	Environment getEnv();
+
+	/**
+	 * Prepares this callable for evaluation on the shared EvalStack, without re-entering eval().
+	 * Returns a {@link PreparedCallable} containing the AST node and prepared environment,
+	 * or {@code null} if this callable cannot be prepared (the caller should fall back to
+	 * {@link #executeCallable}).
+	 *
+	 * <p>The caller is responsible for popping the stack trace element (via
+	 * {@link com.laytonsmith.core.exceptions.StackTraceManager#popStackTraceElement()})
+	 * from the returned environment when done.</p>
+	 *
+	 * @param callerEnv The caller's environment
+	 * @param t The call site target
+	 * @param values The argument values to bind
+	 * @return A {@link PreparedCallable}, or null for sync-only callables
+	 */
+	default PreparedCallable prepareForStack(Environment callerEnv, Target t, Mixed... values) {
+		return null;
+	}
+
+	/**
+	 * The result of {@link #prepareForStack}. Contains the AST node to evaluate
+	 * and the prepared environment with arguments bound.
+	 */
+	record PreparedCallable(ParseTree node, Environment env) {}
 }
diff --git a/src/main/java/com/laytonsmith/core/natives/interfaces/CallableRunner.java b/src/main/java/com/laytonsmith/core/natives/interfaces/CallableRunner.java
index 35d48fe12d..691f7b64ec 100644
--- a/src/main/java/com/laytonsmith/core/natives/interfaces/CallableRunner.java
+++ b/src/main/java/com/laytonsmith/core/natives/interfaces/CallableRunner.java
@@ -4,6 +4,7 @@
 import com.laytonsmith.PureUtilities.Version;
 import com.laytonsmith.core.MSVersion;
 import com.laytonsmith.core.constructs.CClassType;
+import com.laytonsmith.core.constructs.generics.GenericParameters;
 
 /**
  *
@@ -30,4 +31,9 @@ public CClassType[] getSuperclasses() {
 	public CClassType[] getInterfaces() {
 		return CClassType.EMPTY_CLASS_ARRAY;
 	}
+
+	@Override
+	public GenericParameters getGenericParameters() {
+		return null;
+	}
 }
diff --git a/src/main/java/com/laytonsmith/core/natives/interfaces/IterableRunner.java b/src/main/java/com/laytonsmith/core/natives/interfaces/IterableRunner.java
index 291b4ece1c..d1cc3c0c9f 100644
--- a/src/main/java/com/laytonsmith/core/natives/interfaces/IterableRunner.java
+++ b/src/main/java/com/laytonsmith/core/natives/interfaces/IterableRunner.java
@@ -10,6 +10,7 @@
 import com.laytonsmith.PureUtilities.Version;
 import com.laytonsmith.core.MSVersion;
 import com.laytonsmith.core.constructs.CClassType;
+import com.laytonsmith.core.constructs.generics.GenericParameters;
 
 /**
  *
@@ -43,4 +44,8 @@ public ObjectType getObjectType() {
 		return ObjectType.INTERFACE;
 	}
 
+	@Override
+	public GenericParameters getGenericParameters() {
+		return null;
+	}
 }
diff --git a/src/main/java/com/laytonsmith/core/natives/interfaces/MEnumType.java b/src/main/java/com/laytonsmith/core/natives/interfaces/MEnumType.java
index 2aa4e17be3..685224761c 100644
--- a/src/main/java/com/laytonsmith/core/natives/interfaces/MEnumType.java
+++ b/src/main/java/com/laytonsmith/core/natives/interfaces/MEnumType.java
@@ -15,6 +15,9 @@
 import com.laytonsmith.core.constructs.CClassType;
 import com.laytonsmith.core.constructs.Construct;
 import com.laytonsmith.core.constructs.Target;
+import com.laytonsmith.core.constructs.generics.GenericParameters;
+import com.laytonsmith.core.constructs.generics.LeftHandGenericUse;
+import com.laytonsmith.core.environments.Environment;
 import com.laytonsmith.core.exceptions.CRE.CREIllegalArgumentException;
 import com.laytonsmith.core.exceptions.CRE.CREIndexOverflowException;
 import com.laytonsmith.core.exceptions.CRE.CREUnsupportedOperationException;
@@ -137,9 +140,11 @@ public URL getSourceJar() {
 				return ClassDiscovery.GetClassContainer(enumClass);
 			}
 
+			/** @deprecated Use {@link #isInstanceOf(CClassType, LeftHandGenericUse, Environment)} instead. */
+			@Deprecated
 			@Override
 			public boolean isInstanceOf(CClassType type) {
-				return Mixed.TYPE.equals(type) || MEnumType.TYPE.equals(type) || this.typeof().equals(type);
+				return isInstanceOf(type, null, null);
 			}
 
 			@Override
@@ -147,8 +152,20 @@ public boolean isInstanceOf(Class<? extends Mixed> type) {
 				return type.isAssignableFrom(this.getClass());
 			}
 
+			@Override
+			public boolean isInstanceOf(CClassType type, LeftHandGenericUse lhsGenericParameters, Environment env) {
+				return Mixed.TYPE.equals(type) || MEnumType.TYPE.equals(type) || this.typeof(env).equals(type);
+			}
+
+			/** @deprecated Use {@link #typeof(Environment)} instead. */
+			@Deprecated
 			@Override
 			public CClassType typeof() {
+				return typeof(null);
+			}
+
+			@Override
+			public CClassType typeof(Environment env) {
 				try {
 					return CClassType.get(fqcn);
 				} catch (ClassNotFoundException ex) {
@@ -246,8 +263,15 @@ public String toString() {
 								return v.toString();
 							}
 
+							/** @deprecated Use {@link #typeof(Environment)} instead. */
+							@Deprecated
 							@Override
 							public CClassType typeof() {
+								return typeof(null);
+							}
+
+							@Override
+							public CClassType typeof(Environment env) {
 								try {
 									return CClassType.get(fqcn);
 								} catch (ClassNotFoundException ex) {
@@ -255,9 +279,11 @@ public CClassType typeof() {
 								}
 							}
 
+							/** @deprecated Use {@link #isInstanceOf(CClassType, LeftHandGenericUse, Environment)} instead. */
+							@Deprecated
 							@Override
 							public boolean isInstanceOf(CClassType type) {
-								return Construct.isInstanceof(this, type);
+								return isInstanceOf(type, null, null);
 							}
 
 							@Override
@@ -265,6 +291,16 @@ public boolean isInstanceOf(Class<? extends Mixed> type) {
 								return Construct.isInstanceof(this, type);
 							}
 
+							@Override
+							public boolean isInstanceOf(CClassType type, LeftHandGenericUse lhsGenericParameters, Environment env) {
+								return Construct.isInstanceof(this, type, env);
+							}
+
+							@Override
+							public GenericParameters getGenericParameters() {
+								return null;
+							}
+
 							@Override
 							public CClassType getContainingClass() {
 								return null;
@@ -327,8 +363,15 @@ public int size() {
 				};
 			}
 
+			/** @deprecated Use {@link #getBooleanValue(Target, Environment)} instead. */
+			@Deprecated
 			@Override
 			public boolean getBooleanValue(Target t) {
+				return getBooleanValue(t, null);
+			}
+
+			@Override
+			public boolean getBooleanValue(Target t, Environment env) {
 				return true;
 			}
 
@@ -428,9 +471,11 @@ public CClassType getContainingClass() {
 		return null;
 	}
 
+	/** @deprecated Use {@link #isInstanceOf(CClassType, LeftHandGenericUse, Environment)} instead. */
+	@Deprecated
 	@Override
 	public boolean isInstanceOf(CClassType type) {
-		return TYPE.equals(type);
+		return isInstanceOf(type, null, null);
 	}
 
 	@Override
@@ -438,11 +483,28 @@ public boolean isInstanceOf(Class<? extends Mixed> type) {
 		throw new UnsupportedOperationException("Not supported yet.");
 	}
 
+	@Override
+	public boolean isInstanceOf(CClassType type, LeftHandGenericUse lhsGenericParameters, Environment env) {
+		return TYPE.equals(type);
+	}
+
+	/** @deprecated Use {@link #typeof(Environment)} instead. */
+	@Deprecated
 	@Override
 	public CClassType typeof() {
+		return typeof(null);
+	}
+
+	@Override
+	public CClassType typeof(Environment env) {
 		return TYPE;
 	}
 
+	@Override
+	public GenericParameters getGenericParameters() {
+		return null;
+	}
+
 	@Override
 	public URL getSourceJar() {
 		return ClassDiscovery.GetClassContainer(MEnumType.class);
@@ -472,8 +534,15 @@ public List<MEnumTypeValue> values() {
 		}
 		return values;
 	}
+	/** @deprecated Use {@link #get(String, Target, Environment)} instead. */
+	@Deprecated
 	@Override
 	public Mixed get(String index, Target t) throws ConfigRuntimeException {
+		return get(index, t, null);
+	}
+
+	@Override
+	public Mixed get(String index, Target t, Environment env) throws ConfigRuntimeException {
 		for(MEnumTypeValue v : values()) {
 			if(v.name().equals(index)) {
 				return v;
@@ -482,26 +551,54 @@ public Mixed get(String index, Target t) throws ConfigRuntimeException {
 		throw new CREIllegalArgumentException(index + " cannot be found in " + typeof(), t);
 	}
 
+	/** @deprecated Use {@link #get(int, Target, Environment)} instead. */
+	@Deprecated
 	@Override
 	public Mixed get(int index, Target t) throws ConfigRuntimeException {
+		return get(index, t, null);
+	}
+
+	@Override
+	public Mixed get(int index, Target t, Environment env) throws ConfigRuntimeException {
 		if(index >= values().size()) {
 			throw new CREIndexOverflowException("The index " + index + " is out of bounds", t);
 		}
 		return values().get(index);
 	}
 
+	/** @deprecated Use {@link #get(Mixed, Target, Environment)} instead. */
+	@Deprecated
 	@Override
 	public Mixed get(Mixed index, Target t) throws ConfigRuntimeException {
-		return get(index.val(), t);
+		return get(index, t, null);
+	}
+
+	@Override
+	public Mixed get(Mixed index, Target t, Environment env) throws ConfigRuntimeException {
+		return get(index.val(), t, env);
 	}
 
+	/** @deprecated Use {@link #keySet(Environment)} instead. */
+	@Deprecated
 	@Override
 	public Set<Mixed> keySet() {
+		return keySet(null);
+	}
+
+	@Override
+	public Set<Mixed> keySet(Environment env) {
 		return values().stream().collect(Collectors.toSet());
 	}
 
+	/** @deprecated Use {@link #size(Environment)} instead. */
+	@Deprecated
 	@Override
 	public long size() {
+		return size(null);
+	}
+
+	@Override
+	public long size(Environment env) {
 		return values().size();
 	}
 
@@ -515,8 +612,15 @@ public boolean canBeAssociative() {
 		return true;
 	}
 
+	/** @deprecated Use {@link #slice(int, int, Target, Environment)} instead. */
+	@Deprecated
 	@Override
 	public Mixed slice(int begin, int end, Target t) {
+		return slice(begin, end, t, null);
+	}
+
+	@Override
+	public Mixed slice(int begin, int end, Target t, Environment env) {
 		throw new CREUnsupportedOperationException("Cannot slice an enum", t);
 	}
 
@@ -526,8 +630,15 @@ public Mixed slice(int begin, int end, Target t) {
 	 */
 	protected abstract List<MEnumTypeValue> getValues();
 
+	/** @deprecated Use {@link #getBooleanValue(Target, Environment)} instead. */
+	@Deprecated
 	@Override
 	public boolean getBooleanValue(Target t) {
+		return getBooleanValue(t, null);
+	}
+
+	@Override
+	public boolean getBooleanValue(Target t, Environment env) {
 		return true;
 	}
 
diff --git a/src/main/java/com/laytonsmith/core/natives/interfaces/MatrixRunner.java b/src/main/java/com/laytonsmith/core/natives/interfaces/MatrixRunner.java
index b6531ac269..d8edd9e6e6 100644
--- a/src/main/java/com/laytonsmith/core/natives/interfaces/MatrixRunner.java
+++ b/src/main/java/com/laytonsmith/core/natives/interfaces/MatrixRunner.java
@@ -4,6 +4,7 @@
 import com.laytonsmith.PureUtilities.Version;
 import com.laytonsmith.core.MSVersion;
 import com.laytonsmith.core.constructs.CClassType;
+import com.laytonsmith.core.constructs.generics.GenericParameters;
 
 /**
  *
@@ -34,4 +35,9 @@ public CClassType[] getSuperclasses() {
 	public CClassType[] getInterfaces() {
 		return CClassType.EMPTY_CLASS_ARRAY;
 	}
+
+	@Override
+	public GenericParameters getGenericParameters() {
+		return null;
+	}
 }
diff --git a/src/main/java/com/laytonsmith/core/natives/interfaces/Mixed.java b/src/main/java/com/laytonsmith/core/natives/interfaces/Mixed.java
index 3333761733..a654046807 100644
--- a/src/main/java/com/laytonsmith/core/natives/interfaces/Mixed.java
+++ b/src/main/java/com/laytonsmith/core/natives/interfaces/Mixed.java
@@ -10,6 +10,9 @@
 import com.laytonsmith.core.constructs.CClassType;
 import com.laytonsmith.core.constructs.Construct;
 import com.laytonsmith.core.constructs.Target;
+import com.laytonsmith.core.constructs.generics.GenericParameters;
+import com.laytonsmith.core.constructs.generics.LeftHandGenericUse;
+import com.laytonsmith.core.environments.Environment;
 import com.laytonsmith.core.objects.AccessModifier;
 import java.util.Set;
 
@@ -116,9 +119,22 @@ public interface Mixed extends Cloneable, Documentation {
 	 *
 	 * @param type
 	 * @return
+	 * @deprecated Use {@link #isInstanceOf(CClassType, LeftHandGenericUse, Environment)} instead.
 	 */
+	@Deprecated
 	public boolean isInstanceOf(CClassType type);
 
+	/**
+	 * Checks if this value is an instance of the given type, with environment context.
+	 * The lhsGenericParameters parameter is for future generic type checking and may be null.
+	 *
+	 * @param type
+	 * @param lhsGenericParameters
+	 * @param env
+	 * @return
+	 */
+	public boolean isInstanceOf(CClassType type, LeftHandGenericUse lhsGenericParameters, Environment env);
+
 	/**
 	 * Generally speaking, we cannot use Java's instanceof keyword to determine if something is an instanceof, because
 	 * user classes do not extend the hierarchy of objects in MethodScript. Essentially, we need to extend Java's
@@ -143,9 +159,27 @@ public interface Mixed extends Cloneable, Documentation {
 	 *
 	 * @return
 	 * @throws IllegalArgumentException If the class isn't public facing.
+	 * @deprecated Use {@link #typeof(Environment)} instead.
 	 */
+	@Deprecated
 	public CClassType typeof();
 
+	/**
+	 * Returns the typeof this value, as a CClassType object, with environment context.
+	 *
+	 * @param env
+	 * @return
+	 * @throws IllegalArgumentException If the class isn't public facing.
+	 */
+	public CClassType typeof(Environment env);
+
+	/**
+	 * Returns the generic parameters for this value, or null if none.
+	 *
+	 * @return
+	 */
+	public GenericParameters getGenericParameters();
+
 	/**
 	 * Casts the class to the specified type. This only works with Java types, and so for dynamic elements, this
 	 * may throw a RuntimeException. For dynamic types, use the other castTo.
diff --git a/src/main/java/com/laytonsmith/core/natives/interfaces/MixedRunner.java b/src/main/java/com/laytonsmith/core/natives/interfaces/MixedRunner.java
index 2d4eb1815a..04a712c64c 100644
--- a/src/main/java/com/laytonsmith/core/natives/interfaces/MixedRunner.java
+++ b/src/main/java/com/laytonsmith/core/natives/interfaces/MixedRunner.java
@@ -5,6 +5,7 @@
 import com.laytonsmith.PureUtilities.Version;
 import com.laytonsmith.core.MSVersion;
 import com.laytonsmith.core.constructs.CClassType;
+import com.laytonsmith.core.constructs.generics.GenericParameters;
 import com.laytonsmith.core.objects.AccessModifier;
 
 /**
@@ -45,4 +46,8 @@ public AccessModifier getAccessModifier() {
 		return AccessModifier.PUBLIC;
 	}
 
+	@Override
+	public GenericParameters getGenericParameters() {
+		return null;
+	}
 }
diff --git a/src/main/java/com/laytonsmith/core/natives/interfaces/Sizeable.java b/src/main/java/com/laytonsmith/core/natives/interfaces/Sizeable.java
index 33cee2f9cb..8fb7b97738 100644
--- a/src/main/java/com/laytonsmith/core/natives/interfaces/Sizeable.java
+++ b/src/main/java/com/laytonsmith/core/natives/interfaces/Sizeable.java
@@ -2,6 +2,7 @@
 
 import com.laytonsmith.annotations.typeof;
 import com.laytonsmith.core.constructs.CClassType;
+import com.laytonsmith.core.environments.Environment;
 
 /**
  * Any object that can report a size should implement this.
@@ -16,6 +17,16 @@ public interface Sizeable extends Mixed {
 	 * Returns the size of this object.
 	 *
 	 * @return
+	 * @deprecated Use {@link #size(Environment)} instead.
 	 */
+	@Deprecated
 	long size();
+
+	/**
+	 * Returns the size of this object, with environment context.
+	 *
+	 * @param env
+	 * @return
+	 */
+	long size(Environment env);
 }
diff --git a/src/main/java/com/laytonsmith/core/natives/interfaces/SizeableRunner.java b/src/main/java/com/laytonsmith/core/natives/interfaces/SizeableRunner.java
index a76c70ad17..8434a5ff3b 100644
--- a/src/main/java/com/laytonsmith/core/natives/interfaces/SizeableRunner.java
+++ b/src/main/java/com/laytonsmith/core/natives/interfaces/SizeableRunner.java
@@ -4,6 +4,7 @@
 import com.laytonsmith.PureUtilities.Version;
 import com.laytonsmith.core.MSVersion;
 import com.laytonsmith.core.constructs.CClassType;
+import com.laytonsmith.core.constructs.generics.GenericParameters;
 
 /**
  *
@@ -31,4 +32,8 @@ public CClassType[] getInterfaces() {
 		return CClassType.EMPTY_CLASS_ARRAY;
 	}
 
+	@Override
+	public GenericParameters getGenericParameters() {
+		return null;
+	}
 }
diff --git a/src/main/java/com/laytonsmith/core/natives/interfaces/ValueTypeInterfaceRunner.java b/src/main/java/com/laytonsmith/core/natives/interfaces/ValueTypeInterfaceRunner.java
index 6e6a977605..846d8af322 100644
--- a/src/main/java/com/laytonsmith/core/natives/interfaces/ValueTypeInterfaceRunner.java
+++ b/src/main/java/com/laytonsmith/core/natives/interfaces/ValueTypeInterfaceRunner.java
@@ -9,6 +9,7 @@
 import com.laytonsmith.PureUtilities.Version;
 import com.laytonsmith.core.MSVersion;
 import com.laytonsmith.core.constructs.CClassType;
+import com.laytonsmith.core.constructs.generics.GenericParameters;
 
 /**
  *
@@ -38,4 +39,9 @@ public CClassType[] getSuperclasses() {
 	public CClassType[] getInterfaces() {
 		return CClassType.EMPTY_CLASS_ARRAY;
 	}
+
+	@Override
+	public GenericParameters getGenericParameters() {
+		return null;
+	}
 }
diff --git a/src/main/java/com/laytonsmith/core/objects/UserObject.java b/src/main/java/com/laytonsmith/core/objects/UserObject.java
index f370fcd56e..c17160995d 100644
--- a/src/main/java/com/laytonsmith/core/objects/UserObject.java
+++ b/src/main/java/com/laytonsmith/core/objects/UserObject.java
@@ -9,6 +9,8 @@
 import com.laytonsmith.core.constructs.CNull;
 import com.laytonsmith.core.constructs.Construct;
 import com.laytonsmith.core.constructs.Target;
+import com.laytonsmith.core.constructs.generics.GenericParameters;
+import com.laytonsmith.core.constructs.generics.LeftHandGenericUse;
 import com.laytonsmith.core.environments.Environment;
 import com.laytonsmith.core.natives.interfaces.Mixed;
 import java.net.URL;
@@ -149,9 +151,11 @@ public CClassType getContainingClass() {
 		return objectDefinition.getContainingClass();
 	}
 
+	/** @deprecated Use {@link #isInstanceOf(CClassType, LeftHandGenericUse, Environment)} instead. */
+	@Deprecated
 	@Override
 	public boolean isInstanceOf(CClassType type) {
-		return Construct.isInstanceof(this, type);
+		return isInstanceOf(type, null, null);
 	}
 
 	@Override
@@ -159,11 +163,28 @@ public boolean isInstanceOf(Class<? extends Mixed> type) {
 		return Construct.isInstanceof(this, type);
 	}
 
+	@Override
+	public boolean isInstanceOf(CClassType type, LeftHandGenericUse lhsGenericParameters, Environment env) {
+		return Construct.isInstanceof(this, type, env);
+	}
+
+	/** @deprecated Use {@link #typeof(Environment)} instead. */
+	@Deprecated
 	@Override
 	public CClassType typeof() {
+		return typeof(null);
+	}
+
+	@Override
+	public CClassType typeof(Environment env) {
 		return objectDefinition.getType();
 	}
 
+	@Override
+	public GenericParameters getGenericParameters() {
+		return null;
+	}
+
 	@Override
 	public URL getSourceJar() {
 		return null;
diff --git a/src/main/java/com/laytonsmith/tools/Interpreter.java b/src/main/java/com/laytonsmith/tools/Interpreter.java
index 706ba3ef39..bf466e7a1a 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()) {
@@ -949,19 +1060,19 @@ public boolean doBuiltin(String script) {
 						a = new Construct[]{new CString(args.get(0), Target.UNKNOWN)};
 					}
 					try {
-						new Cmdline.cd().exec(Target.UNKNOWN, env, a);
+						new Cmdline.cd().exec(Target.UNKNOWN, env, null, a);
 					} catch (CREIOException ex) {
 						pl(RED + ex.getMessage());
 					}
 					return true;
 				case "pwd":
-					pl(new Cmdline.pwd().exec(Target.UNKNOWN, env).val());
+					pl(new Cmdline.pwd().exec(Target.UNKNOWN, env, null).val());
 					return true;
 				case "exit":
 					// We need previous code to intercept, we cannot do this here.
 					throw new Error("I should not run");
 				case "logout":
-					new Cmdline.exit().exec(Target.UNKNOWN, env, new CInt(0, Target.UNKNOWN));
+					new Cmdline.exit().exec(Target.UNKNOWN, env, null, new CInt(0, Target.UNKNOWN));
 					return true; // won't actually run
 				case "echo":
 					// TODO Probably need some variable interpolation maybe? Otherwise, I don't think this command
@@ -974,7 +1085,7 @@ public boolean doBuiltin(String script) {
 					}
 					String output = StringUtils.Join(args, " ");
 					if(colorize) {
-						output = new Echoes.colorize().exec(Target.UNKNOWN, env, new CString(output, Target.UNKNOWN)).val();
+						output = new Echoes.colorize().exec(Target.UNKNOWN, env, null, new CString(output, Target.UNKNOWN)).val();
 					}
 					pl(output);
 					return true;
diff --git a/src/main/java/com/laytonsmith/tools/Manager.java b/src/main/java/com/laytonsmith/tools/Manager.java
index 0f541a1573..245216a939 100644
--- a/src/main/java/com/laytonsmith/tools/Manager.java
+++ b/src/main/java/com/laytonsmith/tools/Manager.java
@@ -461,7 +461,7 @@ public static boolean doAddEdit(String key, String valueScript) {
 			Environment env = Environment.createEnvironment(gEnv, staticRuntimeEnv, new CommandHelperEnvironment());
 			Mixed c = MethodScriptCompiler.execute(MethodScriptCompiler.compile(
 					MethodScriptCompiler.lex(valueScript, env, null, true), env, null), env, null, null);
-			String value = Construct.json_encode(c, Target.UNKNOWN);
+			String value = Construct.json_encode(c, Target.UNKNOWN, env);
 			pl(CYAN + "Adding: " + WHITE + value);
 			String[] k = key.split("\\.");
 			DaemonManager dm = new DaemonManager();
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 0000000000..c50aa0b0c4
--- /dev/null
+++ b/src/main/java/com/laytonsmith/tools/debugger/DebugAuthenticator.java
@@ -0,0 +1,206 @@
+package com.laytonsmith.tools.debugger;
+
+import com.laytonsmith.PureUtilities.Common.SSHKeyPair;
+
+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.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: a digital signature of the nonce, plus its public key string</li>
+ *   <li>Server verifies: (a) the public key is in the authorized keys file,
+ *       (b) the signature is valid for the 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 {
+			SSHKeyPair keyPair = new SSHKeyPair(null, clientPublicKey);
+			if(!keyPair.verify(nonce, signature)) {
+				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 "type <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 0000000000..b722308873
--- /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 0000000000..b3c295cd66
--- /dev/null
+++ b/src/main/java/com/laytonsmith/tools/debugger/MSDebugServer.java
@@ -0,0 +1,1245 @@
+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;
+
+import com.laytonsmith.abstraction.StaticLayer;
+
+/**
+ * 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 boolean startedOnHostMainThread = 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;
+
+	/**
+	 * Sets whether this server is in managed execution mode. In managed mode,
+	 * the server does not own the process lifecycle - the host (e.g. Minecraft)
+	 * manages it. This affects thread registration, completion events, and
+	 * how execution resumes after breakpoints.
+	 */
+	public void setManagedExecution(boolean managed) {
+		this.managedExecution = managed;
+	}
+
+	/**
+	 * 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.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;
+		this.startedOnHostMainThread = managedExecution && StaticLayer.IsMainThread();
+		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);
+			boolean oldDynamic = gEnv.GetDynamicScriptingMode();
+			gEnv.SetDynamicScriptingMode(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.SetDynamicScriptingMode(oldDynamic);
+				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 if(startedOnHostMainThread) {
+			// Async mode, managed execution started on host main thread:
+			// resume on that thread so the host's main-thread contract is honored
+			Script.DebugSnapshot snapshot = asyncSnapshots.remove(threadId);
+			resumeOnHostMainThread(snapshot);
+		} else {
+			// Async mode, main thread: spawn a new thread to resume from snapshot
+			Script.DebugSnapshot snapshot = asyncSnapshots.remove(threadId);
+			spawnExecutionThread(() -> Script.resumeEval(snapshot));
+		}
+	}
+
+	/**
+	 * Resumes script execution on the host's main thread. Used in managed/embedded
+	 * mode when the script was originally running on the host's main thread (e.g.
+	 * Minecraft server thread). The host's convertor schedules the work via
+	 * {@link com.laytonsmith.abstraction.AbstractConvertor#runOnMainThreadLater}.
+	 */
+	private void resumeOnHostMainThread(Script.DebugSnapshot snapshot) {
+		StaticLayer.GetConvertor().runOnMainThreadLater(null, () -> {
+			try {
+				Mixed result = Script.resumeEval(snapshot);
+				if(!Script.isDebuggerPaused(result)) {
+					mainThreadFinished();
+					executionCompleted();
+				}
+			} catch(Exception e) {
+				sendOutput("error", "Script error: " + e.getMessage());
+				executionCompleted();
+			}
+		});
+	}
+
+	/**
+	 * 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/docgen/DocGenTemplates.java b/src/main/java/com/laytonsmith/tools/docgen/DocGenTemplates.java
index d3cb329ea1..1445e37850 100644
--- a/src/main/java/com/laytonsmith/tools/docgen/DocGenTemplates.java
+++ b/src/main/java/com/laytonsmith/tools/docgen/DocGenTemplates.java
@@ -735,7 +735,7 @@ public String generate(String... args) {
 		@Override
 		public String generate(String... args) {
 			String template = args[0];
-			return new Scheduling.simple_date().exec(Target.UNKNOWN, null, new CString(template, Target.UNKNOWN)).val();
+			return new Scheduling.simple_date().exec(Target.UNKNOWN, null, null, new CString(template, Target.UNKNOWN)).val();
 		}
 	};
 
@@ -772,7 +772,7 @@ public String generate(String... args) throws GenerateException {
 	public static final Generator CURRENTYEAR = new Generator() {
 		@Override
 		public String generate(String... args) throws GenerateException {
-			return new Scheduling.simple_date().exec(Target.UNKNOWN, null, new CString("yyyy", Target.UNKNOWN)).val();
+			return new Scheduling.simple_date().exec(Target.UNKNOWN, null, null, new CString("yyyy", Target.UNKNOWN)).val();
 		}
 	};
 
diff --git a/src/main/java/com/laytonsmith/tools/langserv/LangServ.java b/src/main/java/com/laytonsmith/tools/langserv/LangServ.java
index 4bfbaca67b..732dde98c0 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;
@@ -396,8 +397,11 @@ public CompletableFuture<InitializeResult> initialize(InitializeParams params) {
 		sc.setWorkspace(wsc);
 
 		sc.setDocumentSymbolProvider(true);
-		sc.setDeclarationProvider(true);
-		sc.setHoverProvider(true);
+		if(StaticAnalysis.enabled()) {
+			sc.setDeclarationProvider(true);
+			sc.setDefinitionProvider(true);
+			sc.setHoverProvider(true);
+		}
 //		sc.setTypeDefinitionProvider(true);
 
 		{
@@ -677,6 +681,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 e41e5daa2a..e640e9045e 100644
--- a/src/main/java/com/laytonsmith/tools/langserv/LangServModel.java
+++ b/src/main/java/com/laytonsmith/tools/langserv/LangServModel.java
@@ -56,6 +56,8 @@
 import java.util.concurrent.Executor;
 import org.eclipse.lsp4j.CompletionItem;
 import org.eclipse.lsp4j.CompletionItemKind;
+import org.eclipse.lsp4j.MarkupContent;
+import org.eclipse.lsp4j.MarkupKind;
 import org.eclipse.lsp4j.Diagnostic;
 import org.eclipse.lsp4j.DiagnosticSeverity;
 import org.eclipse.lsp4j.DidChangeTextDocumentParams;
@@ -248,8 +250,9 @@ 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);
 			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 +292,7 @@ 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));
+			parseTrees.put(uri, doCompilation(uri, staticAnalysis, env, exceptions));
 			staticAnalysisMap.put(uri, staticAnalysis);
 		}
 
@@ -442,8 +445,9 @@ public void startup() {
 								//					ci.setCommitCharacters(Arrays.asList("("));
 								ci.setKind(CompletionItemKind.Function);
 								ci.setDetail(di.ret);
-								ci.setDocumentation(di.originalArgs + "\n\n" + di.desc
-										+ (di.extendedDesc == null ? "" : "\n\n" + di.extendedDesc));
+								ci.setDocumentation(new MarkupContent(MarkupKind.MARKDOWN,
+										WikiToMarkdown.convert(di.originalArgs + "\n\n" + di.desc
+										+ (di.extendedDesc == null ? "" : "\n\n" + di.extendedDesc))));
 								list.add(ci);
 							}
 							functionCompletionItems = list;
@@ -489,7 +493,8 @@ public void startup() {
 									}
 									description.append("\n");
 								}
-								ci.setDocumentation(description.toString());
+								ci.setDocumentation(new MarkupContent(MarkupKind.MARKDOWN,
+										WikiToMarkdown.convert(description.toString())));
 								list.add(ci);
 							}
 							eventCompletionItems = list;
@@ -500,10 +505,11 @@ public void startup() {
 							for(FullyQualifiedClassName fqcn : NativeTypeList.getNativeTypeList()) {
 								try {
 									Mixed m = NativeTypeList.getInvalidInstanceForUse(fqcn);
-									CompletionItem ci = new CompletionItem(m.typeof().getSimpleName());
+									CompletionItem ci = new CompletionItem(m.typeof(null).getSimpleName());
 									ci.setKind(CompletionItemKind.TypeParameter);
 									ci.setDetail(m.getName());
-									ci.setDocumentation(m.docs());
+									ci.setDocumentation(new MarkupContent(MarkupKind.MARKDOWN,
+										WikiToMarkdown.convert(m.docs())));
 									ci.setCommitCharacters(Arrays.asList(" "));
 									list.add(ci);
 								} catch(Throwable ex) {
diff --git a/src/main/java/com/laytonsmith/tools/langserv/WikiToMarkdown.java b/src/main/java/com/laytonsmith/tools/langserv/WikiToMarkdown.java
new file mode 100644
index 0000000000..42017654c9
--- /dev/null
+++ b/src/main/java/com/laytonsmith/tools/langserv/WikiToMarkdown.java
@@ -0,0 +1,360 @@
+package com.laytonsmith.tools.langserv;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+
+/**
+ * Converts wiki markup (as used in MethodScript function documentation) to Markdown
+ * for display in LSP clients like VS Code.
+ */
+public final class WikiToMarkdown {
+
+	private WikiToMarkdown() {
+		// Utility class
+	}
+
+	/**
+	 * Converts a wiki-formatted documentation string to Markdown.
+	 * @param wiki The wiki-formatted string to convert.
+	 * @return The converted Markdown string.
+	 */
+	public static String convert(String wiki) {
+		if(wiki == null || wiki.isEmpty()) {
+			return wiki;
+		}
+
+		String result = wiki;
+
+		// Extract code from SimpleSyntaxHighlighter HTML blocks first (before other processing)
+		result = convertMethodScriptCodeBlocks(result);
+
+		// Convert <pre> blocks to fenced code blocks
+		result = convertPreBlocks(result);
+
+		// Convert <code> to inline code
+		result = convertCodeTags(result);
+
+		// Handle {{!}} escape (wiki escape for | in templates)
+		result = result.replace("{{!}}", "|");
+
+		// Wiki templates
+		result = convertTemplates(result);
+
+		// Wiki links
+		result = convertWikiLinks(result);
+		result = convertExternalLinks(result);
+
+		// Inline formatting (bold before italic, since ''' starts with '')
+		result = convertBoldItalic(result);
+
+		// Headings (most = to least, to avoid partial matches)
+		result = convertHeadings(result);
+
+		// Tables
+		result = convertTables(result);
+
+		// Numbered lists
+		result = convertNumberedLists(result);
+
+		// Horizontal rules
+		result = result.replaceAll("(?m)^-{4,}\\s*$", "---");
+
+		// Remaining HTML cleanup
+		result = convertRemainingHtml(result);
+
+		return result.trim();
+	}
+
+	/**
+	 * Extracts raw code from SimpleSyntaxHighlighter's methodscript_code divs
+	 * and replaces them with fenced code blocks.
+	 */
+	private static String convertMethodScriptCodeBlocks(String input) {
+		StringBuilder result = new StringBuilder(input);
+		String marker = "class=\"methodscript_code\"";
+		int pos = 0;
+		while((pos = result.indexOf(marker, pos)) >= 0) {
+			int divStart = result.lastIndexOf("<div", pos);
+			if(divStart < 0) {
+				break;
+			}
+
+			// Find the rawCode div content
+			String rawCodeMarker = "class=\"rawCode\"";
+			int rawCodePos = result.indexOf(rawCodeMarker, pos);
+			if(rawCodePos < 0) {
+				break;
+			}
+
+			int contentStart = result.indexOf(">", rawCodePos) + 1;
+			int contentEnd = result.indexOf("</div>", contentStart);
+			if(contentStart <= 0 || contentEnd < 0) {
+				break;
+			}
+
+			String rawCode = result.substring(contentStart, contentEnd);
+			rawCode = unescapeWikiEntities(rawCode);
+
+			// Find the end of the outer div by counting nesting
+			int depth = 1;
+			int searchPos = result.indexOf(">", divStart) + 1;
+			int outerEnd = -1;
+			while(depth > 0 && searchPos < result.length()) {
+				int nextOpen = result.indexOf("<div", searchPos);
+				int nextClose = result.indexOf("</div>", searchPos);
+				if(nextClose < 0) {
+					break;
+				}
+				if(nextOpen >= 0 && nextOpen < nextClose) {
+					depth++;
+					searchPos = nextOpen + 4;
+				} else {
+					depth--;
+					if(depth == 0) {
+						outerEnd = nextClose + "</div>".length();
+					}
+					searchPos = nextClose + "</div>".length();
+				}
+			}
+
+			if(outerEnd < 0) {
+				break;
+			}
+
+			String replacement = "\n```mscript\n" + rawCode + "\n```\n";
+			result.replace(divStart, outerEnd, replacement);
+			pos = divStart + replacement.length();
+		}
+		return result.toString();
+	}
+
+	private static String convertPreBlocks(String input) {
+		Pattern p = Pattern.compile("(?si)<pre[^>]*>(.*?)</pre>");
+		Matcher m = p.matcher(input);
+		StringBuilder sb = new StringBuilder();
+		while(m.find()) {
+			String code = unescapeWikiEntities(m.group(1));
+			m.appendReplacement(sb, Matcher.quoteReplacement("\n```\n" + code + "\n```\n"));
+		}
+		m.appendTail(sb);
+		return sb.toString();
+	}
+
+	private static String convertCodeTags(String input) {
+		Pattern p = Pattern.compile("(?si)<code>(.*?)</code>");
+		Matcher m = p.matcher(input);
+		StringBuilder sb = new StringBuilder();
+		while(m.find()) {
+			String code = unescapeWikiEntities(m.group(1));
+			m.appendReplacement(sb, Matcher.quoteReplacement("`" + code + "`"));
+		}
+		m.appendTail(sb);
+		return sb.toString();
+	}
+
+	private static String convertTemplates(String input) {
+		String result = input;
+
+		// {{function|name}} → `name()`
+		result = result.replaceAll("\\{\\{function\\|([^}]+)\\}\\}", "`$1()`");
+
+		// {{keyword|name}} → `name`
+		result = result.replaceAll("\\{\\{keyword\\|([^}]+)\\}\\}", "`$1`");
+
+		// {{object|name}} → `name`
+		result = result.replaceAll("\\{\\{object\\|([^}]+)\\}\\}", "`$1`");
+
+		// {{TakeNote|text=...}} → blockquote note
+		result = result.replaceAll("(?s)\\{\\{TakeNote\\|text=(.*?)\\}\\}", "\n> **Note:** $1\n");
+
+		// {{Warning|text=...}} → blockquote warning
+		result = result.replaceAll("(?s)\\{\\{Warning\\|text=(.*?)\\}\\}", "\n> **Warning:** $1\n");
+
+		// {{unimplemented}} → warning
+		result = result.replace("{{unimplemented}}", "\n> **Warning:** This feature is not yet implemented.\n");
+
+		// {{LearningTrail}} → empty (navigation aid, not useful in tooltips)
+		result = result.replace("{{LearningTrail}}", "");
+
+		return result;
+	}
+
+	private static String convertWikiLinks(String input) {
+		// [[Page#anchor|label]] or [[Page|label]] → label
+		String result = input;
+		result = result.replaceAll("\\[\\[(?:[^|\\]]*?)\\|([^\\]]+?)\\]\\]", "$1");
+		// [[Page]] → Page
+		result = result.replaceAll("\\[\\[([^\\]]+?)\\]\\]", "$1");
+		return result;
+	}
+
+	private static String convertExternalLinks(String input) {
+		// [http://url label] → [label](url)
+		return input.replaceAll("\\[(https?://\\S+)\\s+([^\\]]+)\\]", "[$2]($1)");
+	}
+
+	private static String convertBoldItalic(String input) {
+		String result = input;
+		// Bold must be before italic since ''' starts with ''
+		result = result.replaceAll("'''(.*?)'''", "**$1**");
+		result = result.replaceAll("''(.*?)''", "*$1*");
+		return result;
+	}
+
+	private static String convertHeadings(String input) {
+		String result = input;
+		result = result.replaceAll("(?m)^======\\s*(.*?)\\s*======\\s*$", "###### $1");
+		result = result.replaceAll("(?m)^=====\\s*(.*?)\\s*=====\\s*$", "##### $1");
+		result = result.replaceAll("(?m)^====\\s*(.*?)\\s*====\\s*$", "#### $1");
+		result = result.replaceAll("(?m)^===\\s*(.*?)\\s*===\\s*$", "### $1");
+		result = result.replaceAll("(?m)^==\\s*(.*?)\\s*==\\s*$", "## $1");
+		return result;
+	}
+
+	private static String convertTables(String input) {
+		Pattern tablePattern = Pattern.compile("(?s)\\{\\|[^\n]*\n(.*?)\\|\\}");
+		Matcher m = tablePattern.matcher(input);
+		StringBuilder sb = new StringBuilder();
+		while(m.find()) {
+			String tableContent = m.group(1);
+			String mdTable = convertTableContent(tableContent);
+			m.appendReplacement(sb, Matcher.quoteReplacement(mdTable));
+		}
+		m.appendTail(sb);
+		return sb.toString();
+	}
+
+	private static String convertTableContent(String tableContent) {
+		List<String[]> rows = new ArrayList<>();
+		boolean hasHeader = false;
+		String[] currentRow = null;
+
+		for(String line : tableContent.split("\n")) {
+			line = line.trim();
+			if(line.isEmpty() || line.startsWith("{|") || line.startsWith("|}")) {
+				continue;
+			}
+			if(line.equals("|-")) {
+				if(currentRow != null) {
+					rows.add(currentRow);
+				}
+				currentRow = null;
+				continue;
+			}
+			if(line.startsWith("!")) {
+				hasHeader = true;
+				String headerLine = line.substring(1).trim();
+				currentRow = splitTableCells(headerLine, "!!");
+			} else if(line.startsWith("|")) {
+				String dataLine = line.substring(1).trim();
+				currentRow = splitTableCells(dataLine, "\\|\\|");
+			}
+		}
+		if(currentRow != null) {
+			rows.add(currentRow);
+		}
+
+		if(rows.isEmpty()) {
+			return "";
+		}
+
+		int cols = 0;
+		for(String[] row : rows) {
+			if(row.length > cols) {
+				cols = row.length;
+			}
+		}
+
+		StringBuilder sb = new StringBuilder("\n");
+		for(int i = 0; i < rows.size(); i++) {
+			String[] row = rows.get(i);
+			sb.append("|");
+			for(int j = 0; j < cols; j++) {
+				String cell = j < row.length ? row[j].trim() : "";
+				sb.append(" ").append(cell).append(" |");
+			}
+			sb.append("\n");
+
+			if(i == 0) {
+				sb.append("|");
+				for(int j = 0; j < cols; j++) {
+					sb.append("---|");
+				}
+				sb.append("\n");
+			}
+		}
+		sb.append("\n");
+		return sb.toString();
+	}
+
+	private static String[] splitTableCells(String line, String separator) {
+		String[] cells = line.split(separator);
+		for(int i = 0; i < cells.length; i++) {
+			cells[i] = cells[i].trim();
+			// Cell might have format: style="..." | actual content (HTML attributes)
+			if(cells[i].contains("|")) {
+				cells[i] = cells[i].substring(cells[i].lastIndexOf("|") + 1).trim();
+			}
+		}
+		return cells;
+	}
+
+	private static String convertNumberedLists(String input) {
+		// # item → 1. item (wiki numbered list syntax)
+		return input.replaceAll("(?m)^#\\s+", "1. ");
+	}
+
+	private static String convertRemainingHtml(String input) {
+		String result = input;
+
+		// Convert HTML formatting tags to markdown (safe everywhere)
+		result = result.replaceAll("(?si)<strong>(.*?)</strong>", "**$1**");
+		result = result.replaceAll("(?si)<em>(.*?)</em>", "*$1*");
+		result = result.replaceAll("(?i)<br\\s*/?>", "\n");
+		result = result.replaceAll("(?i)<hr\\s*/?>", "\n---\n");
+
+		// Strip remaining HTML tags and unescape entities, but only outside code blocks
+		StringBuilder sb = new StringBuilder();
+		boolean inFencedBlock = false;
+		for(String line : result.split("\n", -1)) {
+			if(line.startsWith("```")) {
+				inFencedBlock = !inFencedBlock;
+				sb.append(line).append("\n");
+			} else if(inFencedBlock) {
+				sb.append(line).append("\n");
+			} else {
+				String processed = line.replaceAll("<[^>]+>", "");
+				processed = unescapeWikiEntities(processed);
+				sb.append(processed).append("\n");
+			}
+		}
+		if(sb.length() > 0 && sb.charAt(sb.length() - 1) == '\n') {
+			sb.setLength(sb.length() - 1);
+		}
+		return sb.toString();
+	}
+
+	/**
+	 * Reverses the escapeWiki() encoding from DocGenTemplates, plus standard HTML entities.
+	 */
+	static String unescapeWikiEntities(String input) {
+		String result = input;
+		result = result.replace("&lsqb;", "[");
+		result = result.replace("&rsqb;", "]");
+		result = result.replace("&lpar;", "(");
+		result = result.replace("&rpar;", ")");
+		result = result.replace("&lcub;", "{");
+		result = result.replace("&rcub;", "}");
+		result = result.replace("&ast;", "*");
+		result = result.replace("&verbar;", "|");
+		result = result.replace("&equals;", "=");
+		result = result.replace("&num;", "#");
+		result = result.replace("&lt;", "<");
+		result = result.replace("&gt;", ">");
+		result = result.replace("&quot;", "\"");
+		result = result.replace("&amp;", "&"); // Must be last
+		return result;
+	}
+}
diff --git a/src/main/java/com/laytonsmith/tools/pnviewer/PNViewer.java b/src/main/java/com/laytonsmith/tools/pnviewer/PNViewer.java
index 8f3f57e30a..571b72e798 100644
--- a/src/main/java/com/laytonsmith/tools/pnviewer/PNViewer.java
+++ b/src/main/java/com/laytonsmith/tools/pnviewer/PNViewer.java
@@ -338,7 +338,7 @@ public void run() {
 			} catch (MarshalException ex) {
 				Logger.getLogger(PNViewer.class.getName()).log(Level.SEVERE, null, ex);
 			}
-			valueTypeLabel.setText(new DataHandling.typeof().exec(Target.UNKNOWN, null, c).val());
+			valueTypeLabel.setText(new DataHandling.typeof().exec(Target.UNKNOWN, null, null, c).val());
 			valueTextArea.setText(c.val());
 		}
 	}
diff --git a/src/main/resources/apps.methodscript.com/package-lock.json b/src/main/resources/apps.methodscript.com/package-lock.json
index 388fba2afe..a72d6afa7e 100644
--- a/src/main/resources/apps.methodscript.com/package-lock.json
+++ b/src/main/resources/apps.methodscript.com/package-lock.json
@@ -8,51 +8,381 @@
       "name": "apps.methodscript.com",
       "version": "1.0.0",
       "dependencies": {
-        "@typespec/compiler": "*",
-        "@typespec/http": "^0.55.0",
-        "@typespec/openapi": "^0.55.0",
-        "@typespec/openapi3": "^0.55.0",
-        "@typespec/versioning": "^0.55.0"
+        "@typespec/compiler": "latest",
+        "@typespec/http": "^1.10.0",
+        "@typespec/openapi": "^1.10.0",
+        "@typespec/openapi3": "^1.10.0",
+        "@typespec/versioning": "^0.80.0"
       }
     },
     "node_modules/@babel/code-frame": {
-      "version": "7.24.2",
-      "resolved": "https://registry.npmjs.org/@babel/code-frame/-/code-frame-7.24.2.tgz",
-      "integrity": "sha512-y5+tLQyV8pg3fsiln67BVLD1P13Eg4lh5RW9mF0zUuvLrv9uIQ4MCL+CRT+FTsBlBjcIan6PGsLcBN0m3ClUyQ==",
+      "version": "7.29.0",
+      "resolved": "https://registry.npmjs.org/@babel/code-frame/-/code-frame-7.29.0.tgz",
+      "integrity": "sha512-9NhCeYjq9+3uxgdtp20LSiJXJvN0FeCtNGpJxuMFZ1Kv3cWUNb6DOhJwUvcVCzKGR66cw4njwM6hrJLqgOwbcw==",
+      "license": "MIT",
       "dependencies": {
-        "@babel/highlight": "^7.24.2",
-        "picocolors": "^1.0.0"
+        "@babel/helper-validator-identifier": "^7.28.5",
+        "js-tokens": "^4.0.0",
+        "picocolors": "^1.1.1"
       },
       "engines": {
         "node": ">=6.9.0"
       }
     },
     "node_modules/@babel/helper-validator-identifier": {
-      "version": "7.24.5",
-      "resolved": "https://registry.npmjs.org/@babel/helper-validator-identifier/-/helper-validator-identifier-7.24.5.tgz",
-      "integrity": "sha512-3q93SSKX2TWCG30M2G2kwaKeTYgEUp5Snjuj8qm729SObL6nbtUldAi37qbxkD5gg3xnBio+f9nqpSepGZMvxA==",
+      "version": "7.28.5",
+      "resolved": "https://registry.npmjs.org/@babel/helper-validator-identifier/-/helper-validator-identifier-7.28.5.tgz",
+      "integrity": "sha512-qSs4ifwzKJSV39ucNjsvc6WVHs6b7S03sOh2OcHF9UHfVPqWWALUsNUVzhSBiItjRZoLHx7nIarVjqKVusUZ1Q==",
+      "license": "MIT",
       "engines": {
         "node": ">=6.9.0"
       }
     },
-    "node_modules/@babel/highlight": {
-      "version": "7.24.5",
-      "resolved": "https://registry.npmjs.org/@babel/highlight/-/highlight-7.24.5.tgz",
-      "integrity": "sha512-8lLmua6AVh/8SLJRRVD6V8p73Hir9w5mJrhE+IPpILG31KKlI9iz5zmBYKcWPS59qSfgP9RaSBQSHHE81WKuEw==",
+    "node_modules/@inquirer/ansi": {
+      "version": "2.0.4",
+      "resolved": "https://registry.npmjs.org/@inquirer/ansi/-/ansi-2.0.4.tgz",
+      "integrity": "sha512-DpcZrQObd7S0R/U3bFdkcT5ebRwbTTC4D3tCc1vsJizmgPLxNJBo+AAFmrZwe8zk30P2QzgzGWZ3Q9uJwWuhIg==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=23.5.0 || ^22.13.0 || ^21.7.0 || ^20.12.0"
+      }
+    },
+    "node_modules/@inquirer/checkbox": {
+      "version": "5.1.2",
+      "resolved": "https://registry.npmjs.org/@inquirer/checkbox/-/checkbox-5.1.2.tgz",
+      "integrity": "sha512-PubpMPO2nJgMufkoB3P2wwxNXEMUXnBIKi/ACzDUYfaoPuM7gSTmuxJeMscoLVEsR4qqrCMf5p0SiYGWnVJ8kw==",
+      "license": "MIT",
       "dependencies": {
-        "@babel/helper-validator-identifier": "^7.24.5",
-        "chalk": "^2.4.2",
-        "js-tokens": "^4.0.0",
-        "picocolors": "^1.0.0"
+        "@inquirer/ansi": "^2.0.4",
+        "@inquirer/core": "^11.1.7",
+        "@inquirer/figures": "^2.0.4",
+        "@inquirer/type": "^4.0.4"
       },
       "engines": {
-        "node": ">=6.9.0"
+        "node": ">=23.5.0 || ^22.13.0 || ^21.7.0 || ^20.12.0"
+      },
+      "peerDependencies": {
+        "@types/node": ">=18"
+      },
+      "peerDependenciesMeta": {
+        "@types/node": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/@inquirer/confirm": {
+      "version": "6.0.10",
+      "resolved": "https://registry.npmjs.org/@inquirer/confirm/-/confirm-6.0.10.tgz",
+      "integrity": "sha512-tiNyA73pgpQ0FQ7axqtoLUe4GDYjNCDcVsbgcA5anvwg2z6i+suEngLKKJrWKJolT//GFPZHwN30binDIHgSgQ==",
+      "license": "MIT",
+      "dependencies": {
+        "@inquirer/core": "^11.1.7",
+        "@inquirer/type": "^4.0.4"
+      },
+      "engines": {
+        "node": ">=23.5.0 || ^22.13.0 || ^21.7.0 || ^20.12.0"
+      },
+      "peerDependencies": {
+        "@types/node": ">=18"
+      },
+      "peerDependenciesMeta": {
+        "@types/node": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/@inquirer/core": {
+      "version": "11.1.7",
+      "resolved": "https://registry.npmjs.org/@inquirer/core/-/core-11.1.7.tgz",
+      "integrity": "sha512-1BiBNDk9btIwYIzNZpkikIHXWeNzNncJePPqwDyVMhXhD1ebqbpn1mKGctpoqAbzywZfdG0O4tvmsGIcOevAPQ==",
+      "license": "MIT",
+      "dependencies": {
+        "@inquirer/ansi": "^2.0.4",
+        "@inquirer/figures": "^2.0.4",
+        "@inquirer/type": "^4.0.4",
+        "cli-width": "^4.1.0",
+        "fast-wrap-ansi": "^0.2.0",
+        "mute-stream": "^3.0.0",
+        "signal-exit": "^4.1.0"
+      },
+      "engines": {
+        "node": ">=23.5.0 || ^22.13.0 || ^21.7.0 || ^20.12.0"
+      },
+      "peerDependencies": {
+        "@types/node": ">=18"
+      },
+      "peerDependenciesMeta": {
+        "@types/node": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/@inquirer/editor": {
+      "version": "5.0.10",
+      "resolved": "https://registry.npmjs.org/@inquirer/editor/-/editor-5.0.10.tgz",
+      "integrity": "sha512-VJx4XyaKea7t8hEApTw5dxeIyMtWXre2OiyJcICCRZI4hkoHsMoCnl/KbUnJJExLbH9csLLHMVR144ZhFE1CwA==",
+      "license": "MIT",
+      "dependencies": {
+        "@inquirer/core": "^11.1.7",
+        "@inquirer/external-editor": "^2.0.4",
+        "@inquirer/type": "^4.0.4"
+      },
+      "engines": {
+        "node": ">=23.5.0 || ^22.13.0 || ^21.7.0 || ^20.12.0"
+      },
+      "peerDependencies": {
+        "@types/node": ">=18"
+      },
+      "peerDependenciesMeta": {
+        "@types/node": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/@inquirer/expand": {
+      "version": "5.0.10",
+      "resolved": "https://registry.npmjs.org/@inquirer/expand/-/expand-5.0.10.tgz",
+      "integrity": "sha512-fC0UHJPXsTRvY2fObiwuQYaAnHrp3aDqfwKUJSdfpgv18QUG054ezGbaRNStk/BKD5IPijeMKWej8VV8O5Q/eQ==",
+      "license": "MIT",
+      "dependencies": {
+        "@inquirer/core": "^11.1.7",
+        "@inquirer/type": "^4.0.4"
+      },
+      "engines": {
+        "node": ">=23.5.0 || ^22.13.0 || ^21.7.0 || ^20.12.0"
+      },
+      "peerDependencies": {
+        "@types/node": ">=18"
+      },
+      "peerDependenciesMeta": {
+        "@types/node": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/@inquirer/external-editor": {
+      "version": "2.0.4",
+      "resolved": "https://registry.npmjs.org/@inquirer/external-editor/-/external-editor-2.0.4.tgz",
+      "integrity": "sha512-Prenuv9C1PHj2Itx0BcAOVBTonz02Hc2Nd2DbU67PdGUaqn0nPCnV34oDyyoaZHnmfRxkpuhh/u51ThkrO+RdA==",
+      "license": "MIT",
+      "dependencies": {
+        "chardet": "^2.1.1",
+        "iconv-lite": "^0.7.2"
+      },
+      "engines": {
+        "node": ">=23.5.0 || ^22.13.0 || ^21.7.0 || ^20.12.0"
+      },
+      "peerDependencies": {
+        "@types/node": ">=18"
+      },
+      "peerDependenciesMeta": {
+        "@types/node": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/@inquirer/figures": {
+      "version": "2.0.4",
+      "resolved": "https://registry.npmjs.org/@inquirer/figures/-/figures-2.0.4.tgz",
+      "integrity": "sha512-eLBsjlS7rPS3WEhmOmh1znQ5IsQrxWzxWDxO51e4urv+iVrSnIHbq4zqJIOiyNdYLa+BVjwOtdetcQx1lWPpiQ==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=23.5.0 || ^22.13.0 || ^21.7.0 || ^20.12.0"
+      }
+    },
+    "node_modules/@inquirer/input": {
+      "version": "5.0.10",
+      "resolved": "https://registry.npmjs.org/@inquirer/input/-/input-5.0.10.tgz",
+      "integrity": "sha512-nvZ6qEVeX/zVtZ1dY2hTGDQpVGD3R7MYPLODPgKO8Y+RAqxkrP3i/3NwF3fZpLdaMiNuK0z2NaYIx9tPwiSegQ==",
+      "license": "MIT",
+      "dependencies": {
+        "@inquirer/core": "^11.1.7",
+        "@inquirer/type": "^4.0.4"
+      },
+      "engines": {
+        "node": ">=23.5.0 || ^22.13.0 || ^21.7.0 || ^20.12.0"
+      },
+      "peerDependencies": {
+        "@types/node": ">=18"
+      },
+      "peerDependenciesMeta": {
+        "@types/node": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/@inquirer/number": {
+      "version": "4.0.10",
+      "resolved": "https://registry.npmjs.org/@inquirer/number/-/number-4.0.10.tgz",
+      "integrity": "sha512-Ht8OQstxiS3APMGjHV0aYAjRAysidWdwurWEo2i8yI5xbhOBWqizT0+MU1S2GCcuhIBg+3SgWVjEoXgfhY+XaA==",
+      "license": "MIT",
+      "dependencies": {
+        "@inquirer/core": "^11.1.7",
+        "@inquirer/type": "^4.0.4"
+      },
+      "engines": {
+        "node": ">=23.5.0 || ^22.13.0 || ^21.7.0 || ^20.12.0"
+      },
+      "peerDependencies": {
+        "@types/node": ">=18"
+      },
+      "peerDependenciesMeta": {
+        "@types/node": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/@inquirer/password": {
+      "version": "5.0.10",
+      "resolved": "https://registry.npmjs.org/@inquirer/password/-/password-5.0.10.tgz",
+      "integrity": "sha512-QbNyvIE8q2GTqKLYSsA8ATG+eETo+m31DSR0+AU7x3d2FhaTWzqQek80dj3JGTo743kQc6mhBR0erMjYw5jQ0A==",
+      "license": "MIT",
+      "dependencies": {
+        "@inquirer/ansi": "^2.0.4",
+        "@inquirer/core": "^11.1.7",
+        "@inquirer/type": "^4.0.4"
+      },
+      "engines": {
+        "node": ">=23.5.0 || ^22.13.0 || ^21.7.0 || ^20.12.0"
+      },
+      "peerDependencies": {
+        "@types/node": ">=18"
+      },
+      "peerDependenciesMeta": {
+        "@types/node": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/@inquirer/prompts": {
+      "version": "8.3.2",
+      "resolved": "https://registry.npmjs.org/@inquirer/prompts/-/prompts-8.3.2.tgz",
+      "integrity": "sha512-yFroiSj2iiBFlm59amdTvAcQFvWS6ph5oKESls/uqPBect7rTU2GbjyZO2DqxMGuIwVA8z0P4K6ViPcd/cp+0w==",
+      "license": "MIT",
+      "dependencies": {
+        "@inquirer/checkbox": "^5.1.2",
+        "@inquirer/confirm": "^6.0.10",
+        "@inquirer/editor": "^5.0.10",
+        "@inquirer/expand": "^5.0.10",
+        "@inquirer/input": "^5.0.10",
+        "@inquirer/number": "^4.0.10",
+        "@inquirer/password": "^5.0.10",
+        "@inquirer/rawlist": "^5.2.6",
+        "@inquirer/search": "^4.1.6",
+        "@inquirer/select": "^5.1.2"
+      },
+      "engines": {
+        "node": ">=23.5.0 || ^22.13.0 || ^21.7.0 || ^20.12.0"
+      },
+      "peerDependencies": {
+        "@types/node": ">=18"
+      },
+      "peerDependenciesMeta": {
+        "@types/node": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/@inquirer/rawlist": {
+      "version": "5.2.6",
+      "resolved": "https://registry.npmjs.org/@inquirer/rawlist/-/rawlist-5.2.6.tgz",
+      "integrity": "sha512-jfw0MLJ5TilNsa9zlJ6nmRM0ZFVZhhTICt4/6CU2Dv1ndY7l3sqqo1gIYZyMMDw0LvE1u1nzJNisfHEhJIxq5w==",
+      "license": "MIT",
+      "dependencies": {
+        "@inquirer/core": "^11.1.7",
+        "@inquirer/type": "^4.0.4"
+      },
+      "engines": {
+        "node": ">=23.5.0 || ^22.13.0 || ^21.7.0 || ^20.12.0"
+      },
+      "peerDependencies": {
+        "@types/node": ">=18"
+      },
+      "peerDependenciesMeta": {
+        "@types/node": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/@inquirer/search": {
+      "version": "4.1.6",
+      "resolved": "https://registry.npmjs.org/@inquirer/search/-/search-4.1.6.tgz",
+      "integrity": "sha512-3/6kTRae98hhDevENScy7cdFEuURnSpM3JbBNg8yfXLw88HgTOl+neUuy/l9W0No5NzGsLVydhBzTIxZP7yChQ==",
+      "license": "MIT",
+      "dependencies": {
+        "@inquirer/core": "^11.1.7",
+        "@inquirer/figures": "^2.0.4",
+        "@inquirer/type": "^4.0.4"
+      },
+      "engines": {
+        "node": ">=23.5.0 || ^22.13.0 || ^21.7.0 || ^20.12.0"
+      },
+      "peerDependencies": {
+        "@types/node": ">=18"
+      },
+      "peerDependenciesMeta": {
+        "@types/node": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/@inquirer/select": {
+      "version": "5.1.2",
+      "resolved": "https://registry.npmjs.org/@inquirer/select/-/select-5.1.2.tgz",
+      "integrity": "sha512-kTK8YIkHV+f02y7bWCh7E0u2/11lul5WepVTclr3UMBtBr05PgcZNWfMa7FY57ihpQFQH/spLMHTcr0rXy50tA==",
+      "license": "MIT",
+      "dependencies": {
+        "@inquirer/ansi": "^2.0.4",
+        "@inquirer/core": "^11.1.7",
+        "@inquirer/figures": "^2.0.4",
+        "@inquirer/type": "^4.0.4"
+      },
+      "engines": {
+        "node": ">=23.5.0 || ^22.13.0 || ^21.7.0 || ^20.12.0"
+      },
+      "peerDependencies": {
+        "@types/node": ">=18"
+      },
+      "peerDependenciesMeta": {
+        "@types/node": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/@inquirer/type": {
+      "version": "4.0.4",
+      "resolved": "https://registry.npmjs.org/@inquirer/type/-/type-4.0.4.tgz",
+      "integrity": "sha512-PamArxO3cFJZoOzspzo6cxVlLeIftyBsZw/S9bKY5DzxqJVZgjoj1oP8d0rskKtp7sZxBycsoer1g6UeJV1BBA==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=23.5.0 || ^22.13.0 || ^21.7.0 || ^20.12.0"
+      },
+      "peerDependencies": {
+        "@types/node": ">=18"
+      },
+      "peerDependenciesMeta": {
+        "@types/node": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/@isaacs/fs-minipass": {
+      "version": "4.0.1",
+      "resolved": "https://registry.npmjs.org/@isaacs/fs-minipass/-/fs-minipass-4.0.1.tgz",
+      "integrity": "sha512-wgm9Ehl2jpeqP3zw/7mo3kRHFp5MEDhqAdwy1fTGkHAwnkGOVsgpvQhL8B5n1qlb01jV3n/bI0ZfZp5lWA1k4w==",
+      "license": "ISC",
+      "dependencies": {
+        "minipass": "^7.0.4"
+      },
+      "engines": {
+        "node": ">=18.0.0"
       }
     },
     "node_modules/@nodelib/fs.scandir": {
       "version": "2.1.5",
       "resolved": "https://registry.npmjs.org/@nodelib/fs.scandir/-/fs.scandir-2.1.5.tgz",
       "integrity": "sha512-vq24Bq3ym5HEQm2NKCr3yXDwjc7vTsEThRDnkp2DK9p1uqLR+DHurm/NOTo0KG7HYHU7eppKZj3MyqYuMBf62g==",
+      "license": "MIT",
       "dependencies": {
         "@nodelib/fs.stat": "2.0.5",
         "run-parallel": "^1.1.9"
@@ -65,6 +395,7 @@
       "version": "2.0.5",
       "resolved": "https://registry.npmjs.org/@nodelib/fs.stat/-/fs.stat-2.0.5.tgz",
       "integrity": "sha512-RkhPPp2zrqDAQA/2jNhnztcPAlv64XdhIp7a7454A5ovI7Bukxgt7MX7udwAu3zg1DcpPU0rz3VV1SeaqvY4+A==",
+      "license": "MIT",
       "engines": {
         "node": ">= 8"
       }
@@ -73,6 +404,7 @@
       "version": "1.2.8",
       "resolved": "https://registry.npmjs.org/@nodelib/fs.walk/-/fs.walk-1.2.8.tgz",
       "integrity": "sha512-oGB+UxlgWcgQkgwo8GcEGwemoTFt3FIO9ababBmaGwXIoBKZ+GTy0pP185beGg7Llih/NSHSV2XAs1lnznocSg==",
+      "license": "MIT",
       "dependencies": {
         "@nodelib/fs.scandir": "2.1.5",
         "fastq": "^1.6.0"
@@ -81,10 +413,79 @@
         "node": ">= 8"
       }
     },
+    "node_modules/@scalar/helpers": {
+      "version": "0.2.18",
+      "resolved": "https://registry.npmjs.org/@scalar/helpers/-/helpers-0.2.18.tgz",
+      "integrity": "sha512-w1d4tpNEVZ293oB2BAgLrS0kVPUtG3eByNmOCJA5eK9vcT4D3cmsGtWjUaaqit0BQCsBFHK51rasGvSWnApYTw==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=20"
+      }
+    },
+    "node_modules/@scalar/json-magic": {
+      "version": "0.11.7",
+      "resolved": "https://registry.npmjs.org/@scalar/json-magic/-/json-magic-0.11.7.tgz",
+      "integrity": "sha512-GVz9E0vXu+ecypkdn0biK1gbQVkK4QTTX1Hq3eMgxlLQC91wwiqWfCqwfhuX0LRu+Z5OmYhLhufDJEEh56rVgA==",
+      "license": "MIT",
+      "dependencies": {
+        "@scalar/helpers": "0.2.18",
+        "pathe": "^2.0.3",
+        "yaml": "^2.8.0"
+      },
+      "engines": {
+        "node": ">=20"
+      }
+    },
+    "node_modules/@scalar/openapi-parser": {
+      "version": "0.24.17",
+      "resolved": "https://registry.npmjs.org/@scalar/openapi-parser/-/openapi-parser-0.24.17.tgz",
+      "integrity": "sha512-aM9UVrzlMreC3X/sZbyj+7XDZmat3ecGC3RpU8dqEO/HIH+CEX0xMLuP+41DhePCYg5+9TtDomSfWuMq4x1Z1A==",
+      "license": "MIT",
+      "dependencies": {
+        "@scalar/helpers": "0.2.18",
+        "@scalar/json-magic": "0.11.7",
+        "@scalar/openapi-types": "0.5.4",
+        "@scalar/openapi-upgrader": "0.1.11",
+        "ajv": "^8.17.1",
+        "ajv-draft-04": "^1.0.0",
+        "ajv-formats": "^3.0.1",
+        "jsonpointer": "^5.0.1",
+        "leven": "^4.0.0",
+        "yaml": "^2.8.0"
+      },
+      "engines": {
+        "node": ">=20"
+      }
+    },
+    "node_modules/@scalar/openapi-types": {
+      "version": "0.5.4",
+      "resolved": "https://registry.npmjs.org/@scalar/openapi-types/-/openapi-types-0.5.4.tgz",
+      "integrity": "sha512-2pEbhprh8lLGDfUI6mNm9EV104pjb3+aJsXrFaqfgOSre7r6NlgM5HcSbsLjzDAnTikjJhJ3IMal1Rz8WVwiOw==",
+      "license": "MIT",
+      "dependencies": {
+        "zod": "^4.3.5"
+      },
+      "engines": {
+        "node": ">=20"
+      }
+    },
+    "node_modules/@scalar/openapi-upgrader": {
+      "version": "0.1.11",
+      "resolved": "https://registry.npmjs.org/@scalar/openapi-upgrader/-/openapi-upgrader-0.1.11.tgz",
+      "integrity": "sha512-ngJcHGoCHmpWgYtNy08vmzFfLdQEkMpvaCQqNPPMNKq0QEXOv89e/rn+TZJZgPnRlY7fDIoIhn9lNgr+azBW+w==",
+      "license": "MIT",
+      "dependencies": {
+        "@scalar/openapi-types": "0.5.4"
+      },
+      "engines": {
+        "node": ">=20"
+      }
+    },
     "node_modules/@sindresorhus/merge-streams": {
-      "version": "2.3.0",
-      "resolved": "https://registry.npmjs.org/@sindresorhus/merge-streams/-/merge-streams-2.3.0.tgz",
-      "integrity": "sha512-LtoMMhxAlorcGhmFYI+LhPgbPZCkgP6ra1YL604EeF6U98pLlQ3iWIGMdWSC+vWmPBWBNgmDBAhnAobLROJmwg==",
+      "version": "4.0.0",
+      "resolved": "https://registry.npmjs.org/@sindresorhus/merge-streams/-/merge-streams-4.0.0.tgz",
+      "integrity": "sha512-tlqY9xq5ukxTUZBmoOp+m61cqwQD5pHJtFY3Mn8CA8ps6yghLH/Hw8UPdqg4OLmFW3IFlcXnQNmo/dh8HzXYIQ==",
+      "license": "MIT",
       "engines": {
         "node": ">=18"
       },
@@ -92,122 +493,218 @@
         "url": "https://github.com/sponsors/sindresorhus"
       }
     },
+    "node_modules/@typespec/asset-emitter": {
+      "version": "0.79.1",
+      "resolved": "https://registry.npmjs.org/@typespec/asset-emitter/-/asset-emitter-0.79.1.tgz",
+      "integrity": "sha512-53s3GLu5BwNkl7Itr/OizfhymTV2u7k5/cwjUOAt03AUDfiKlwbsp+iCIsq1vccJuoDOiXOceJOfL8rAf4/9LQ==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=20.0.0"
+      },
+      "peerDependencies": {
+        "@typespec/compiler": "latest"
+      }
+    },
     "node_modules/@typespec/compiler": {
-      "version": "0.55.0",
-      "resolved": "https://registry.npmjs.org/@typespec/compiler/-/compiler-0.55.0.tgz",
-      "integrity": "sha512-JxBkP7fTc3yzDYZ+Ms+ZHYlL2Ym22oloLDl6107SGaShNJBdQlabgE0aV8WvYRRBYt8g0RNb+sDLEcjvahj6Gw==",
-      "dependencies": {
-        "@babel/code-frame": "~7.24.2",
-        "ajv": "~8.12.0",
-        "change-case": "~5.4.3",
-        "globby": "~14.0.1",
+      "version": "1.10.0",
+      "resolved": "https://registry.npmjs.org/@typespec/compiler/-/compiler-1.10.0.tgz",
+      "integrity": "sha512-R6BATDkughntPpaxeESJF+wxma5PEjgmnnKvH0/ByqUH8VyhIckQWE9kkP0Uc/EJ0o0VYhe8qCwWQvV70k5lTw==",
+      "license": "MIT",
+      "dependencies": {
+        "@babel/code-frame": "~7.29.0",
+        "@inquirer/prompts": "^8.0.1",
+        "ajv": "~8.18.0",
+        "change-case": "~5.4.4",
+        "env-paths": "^4.0.0",
+        "globby": "~16.1.0",
+        "is-unicode-supported": "^2.1.0",
         "mustache": "~4.2.0",
-        "picocolors": "~1.0.0",
-        "prettier": "~3.2.5",
-        "prompts": "~2.4.2",
-        "semver": "^7.6.0",
+        "picocolors": "~1.1.1",
+        "prettier": "~3.8.0",
+        "semver": "^7.7.1",
+        "tar": "^7.5.2",
+        "temporal-polyfill": "^0.3.0",
         "vscode-languageserver": "~9.0.1",
-        "vscode-languageserver-textdocument": "~1.0.11",
-        "yaml": "~2.4.1",
-        "yargs": "~17.7.2"
+        "vscode-languageserver-textdocument": "~1.0.12",
+        "yaml": "~2.8.2",
+        "yargs": "~18.0.0"
       },
       "bin": {
         "tsp": "cmd/tsp.js",
         "tsp-server": "cmd/tsp-server.js"
       },
       "engines": {
-        "node": ">=18.0.0"
+        "node": ">=20.0.0"
       }
     },
     "node_modules/@typespec/http": {
-      "version": "0.55.0",
-      "resolved": "https://registry.npmjs.org/@typespec/http/-/http-0.55.0.tgz",
-      "integrity": "sha512-r30RWzMTJgbyRpdtZxezlvXI/nkAvgilX1OM+s3A039lGLA+JRukgvKIZ3LaNr3lNXHiqeWQDrIZNhqBnpW1zw==",
+      "version": "1.10.0",
+      "resolved": "https://registry.npmjs.org/@typespec/http/-/http-1.10.0.tgz",
+      "integrity": "sha512-/fj55fmUj4m/FmNdfH0V52menVrmS2r5Xj9d1H+pnjQbxvvaxS906RSRcoF8kbg3PvlibP/Py5u82TAk53AyqA==",
+      "license": "MIT",
       "engines": {
-        "node": ">=18.0.0"
+        "node": ">=20.0.0"
       },
       "peerDependencies": {
-        "@typespec/compiler": "~0.55.0"
+        "@typespec/compiler": "latest",
+        "@typespec/streams": "^0.80.0"
+      },
+      "peerDependenciesMeta": {
+        "@typespec/streams": {
+          "optional": true
+        }
       }
     },
     "node_modules/@typespec/openapi": {
-      "version": "0.55.0",
-      "resolved": "https://registry.npmjs.org/@typespec/openapi/-/openapi-0.55.0.tgz",
-      "integrity": "sha512-5T4VuJSOGfMFSs+1dOl3U3BC6VhKAxSTBrwcQDIEEygnqCSbj/tMFDhNfzKYKARRDotgM8ESOrZU6XH5srVR7A==",
+      "version": "1.10.0",
+      "resolved": "https://registry.npmjs.org/@typespec/openapi/-/openapi-1.10.0.tgz",
+      "integrity": "sha512-tukmyp+c9CFlA2FdF61XfT9eTe5WXWz6J8pOrJ9+IYg0BcBwhJkvDj6BYpDD6SjxbRr1wO5ZL2Whe6MequsyVw==",
+      "license": "MIT",
       "engines": {
-        "node": ">=18.0.0"
+        "node": ">=20.0.0"
       },
       "peerDependencies": {
-        "@typespec/compiler": "~0.55.0",
-        "@typespec/http": "~0.55.0"
+        "@typespec/compiler": "latest",
+        "@typespec/http": "^1.10.0"
       }
     },
     "node_modules/@typespec/openapi3": {
-      "version": "0.55.0",
-      "resolved": "https://registry.npmjs.org/@typespec/openapi3/-/openapi3-0.55.0.tgz",
-      "integrity": "sha512-dfn/wrKSF4Ls1dWMpAguQggoc4HGx2tf3FN2xhBln6EtahNZNgN5sOE+XY0hGPI4MCE5QexMUlXSiXpxzlNA/A==",
+      "version": "1.10.0",
+      "resolved": "https://registry.npmjs.org/@typespec/openapi3/-/openapi3-1.10.0.tgz",
+      "integrity": "sha512-G2UTfsDuUprvhFIymHiLKly6FoA9UkRmTImqgmROP4JkKCdY/Mo6Xo03sufY8urywVjIWE3dryXpy5DjpOt9Eg==",
+      "license": "MIT",
       "dependencies": {
-        "yaml": "~2.4.1"
+        "@scalar/json-magic": "^0.11.5",
+        "@scalar/openapi-parser": "^0.24.1",
+        "@scalar/openapi-types": "^0.5.0",
+        "@typespec/asset-emitter": "^0.79.1",
+        "yaml": "~2.8.2"
+      },
+      "bin": {
+        "tsp-openapi3": "cmd/tsp-openapi3.js"
       },
       "engines": {
-        "node": ">=18.0.0"
+        "node": ">=20.0.0"
       },
       "peerDependencies": {
-        "@typespec/compiler": "~0.55.0",
-        "@typespec/http": "~0.55.0",
-        "@typespec/openapi": "~0.55.0",
-        "@typespec/versioning": "~0.55.0"
+        "@typespec/compiler": "latest",
+        "@typespec/events": "^0.80.0",
+        "@typespec/http": "^1.10.0",
+        "@typespec/json-schema": "^1.10.0",
+        "@typespec/openapi": "^1.10.0",
+        "@typespec/sse": "^0.80.0",
+        "@typespec/streams": "^0.80.0",
+        "@typespec/versioning": "^0.80.0"
+      },
+      "peerDependenciesMeta": {
+        "@typespec/events": {
+          "optional": true
+        },
+        "@typespec/json-schema": {
+          "optional": true
+        },
+        "@typespec/sse": {
+          "optional": true
+        },
+        "@typespec/streams": {
+          "optional": true
+        },
+        "@typespec/versioning": {
+          "optional": true
+        },
+        "@typespec/xml": {
+          "optional": true
+        }
       }
     },
     "node_modules/@typespec/versioning": {
-      "version": "0.55.0",
-      "resolved": "https://registry.npmjs.org/@typespec/versioning/-/versioning-0.55.0.tgz",
-      "integrity": "sha512-89LTgkA3IBLnaaM4D4qfsrcEU0g3gasE1MmkrQ2HG21fYX88zKbmR1cKWeUxQx9MIXFOH4cPC9KhA/uLknRVMQ==",
+      "version": "0.80.0",
+      "resolved": "https://registry.npmjs.org/@typespec/versioning/-/versioning-0.80.0.tgz",
+      "integrity": "sha512-WQCT0jN2lSRfwOy+Cd1KUYzenpKR5TdoX0uW6zQdvxQ9nQZIXoaSaReh9/ldhmSV4xv3p2dqF9oq1cdbVGfJTg==",
+      "license": "MIT",
       "engines": {
-        "node": ">=18.0.0"
+        "node": ">=20.0.0"
       },
       "peerDependencies": {
-        "@typespec/compiler": "~0.55.0"
+        "@typespec/compiler": "latest"
       }
     },
     "node_modules/ajv": {
-      "version": "8.12.0",
-      "resolved": "https://registry.npmjs.org/ajv/-/ajv-8.12.0.tgz",
-      "integrity": "sha512-sRu1kpcO9yLtYxBKvqfTeh9KzZEwO3STyX1HT+4CaDzC6HpTGYhIhPIzj9XuKU7KYDwnaeh5hcOwjy1QuJzBPA==",
+      "version": "8.18.0",
+      "resolved": "https://registry.npmjs.org/ajv/-/ajv-8.18.0.tgz",
+      "integrity": "sha512-PlXPeEWMXMZ7sPYOHqmDyCJzcfNrUr3fGNKtezX14ykXOEIvyK81d+qydx89KY5O71FKMPaQ2vBfBFI5NHR63A==",
+      "license": "MIT",
       "dependencies": {
-        "fast-deep-equal": "^3.1.1",
+        "fast-deep-equal": "^3.1.3",
+        "fast-uri": "^3.0.1",
         "json-schema-traverse": "^1.0.0",
-        "require-from-string": "^2.0.2",
-        "uri-js": "^4.2.2"
+        "require-from-string": "^2.0.2"
       },
       "funding": {
         "type": "github",
         "url": "https://github.com/sponsors/epoberezkin"
       }
     },
+    "node_modules/ajv-draft-04": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmjs.org/ajv-draft-04/-/ajv-draft-04-1.0.0.tgz",
+      "integrity": "sha512-mv00Te6nmYbRp5DCwclxtt7yV/joXJPGS7nM+97GdxvuttCOfgI3K4U25zboyeX0O+myI8ERluxQe5wljMmVIw==",
+      "license": "MIT",
+      "peerDependencies": {
+        "ajv": "^8.5.0"
+      },
+      "peerDependenciesMeta": {
+        "ajv": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/ajv-formats": {
+      "version": "3.0.1",
+      "resolved": "https://registry.npmjs.org/ajv-formats/-/ajv-formats-3.0.1.tgz",
+      "integrity": "sha512-8iUql50EUR+uUcdRQ3HDqa6EVyo3docL8g5WJ3FNcWmu62IbkGUue/pEyLBW8VGKKucTPgqeks4fIU1DA4yowQ==",
+      "license": "MIT",
+      "dependencies": {
+        "ajv": "^8.0.0"
+      },
+      "peerDependencies": {
+        "ajv": "^8.0.0"
+      },
+      "peerDependenciesMeta": {
+        "ajv": {
+          "optional": true
+        }
+      }
+    },
     "node_modules/ansi-regex": {
-      "version": "5.0.1",
-      "resolved": "https://registry.npmjs.org/ansi-regex/-/ansi-regex-5.0.1.tgz",
-      "integrity": "sha512-quJQXlTSUGL2LH9SUXo8VwsY4soanhgo6LNSm84E1LBcE8s3O0wpdiRzyR9z/ZZJMlMWv37qOOb9pdJlMUEKFQ==",
+      "version": "6.2.2",
+      "resolved": "https://registry.npmjs.org/ansi-regex/-/ansi-regex-6.2.2.tgz",
+      "integrity": "sha512-Bq3SmSpyFHaWjPk8If9yc6svM8c56dB5BAtW4Qbw5jHTwwXXcTLoRMkpDJp6VL0XzlWaCHTXrkFURMYmD0sLqg==",
+      "license": "MIT",
       "engines": {
-        "node": ">=8"
+        "node": ">=12"
+      },
+      "funding": {
+        "url": "https://github.com/chalk/ansi-regex?sponsor=1"
       }
     },
     "node_modules/ansi-styles": {
-      "version": "3.2.1",
-      "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-3.2.1.tgz",
-      "integrity": "sha512-VT0ZI6kZRdTh8YyJw3SMbYm/u+NqfsAxEpWO0Pf9sq8/e94WxxOpPKx9FR1FlyCtOVDNOQ+8ntlqFxiRc+r5qA==",
-      "dependencies": {
-        "color-convert": "^1.9.0"
-      },
+      "version": "6.2.3",
+      "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-6.2.3.tgz",
+      "integrity": "sha512-4Dj6M28JB+oAH8kFkTLUo+a2jwOFkuqb3yucU0CANcRRUbxS0cP0nZYCGjcc3BNXwRIsUVmDGgzawme7zvJHvg==",
+      "license": "MIT",
       "engines": {
-        "node": ">=4"
+        "node": ">=12"
+      },
+      "funding": {
+        "url": "https://github.com/chalk/ansi-styles?sponsor=1"
       }
     },
     "node_modules/braces": {
       "version": "3.0.3",
       "resolved": "https://registry.npmjs.org/braces/-/braces-3.0.3.tgz",
       "integrity": "sha512-yQbXgO/OSZVD2IsiLlro+7Hf6Q18EJrKSEsdoMzKePKXct3gvD8oLcOQdIzGupr5Fj+EDe8gO/lxc1BzfMpxvA==",
+      "license": "MIT",
       "dependencies": {
         "fill-range": "^7.1.1"
       },
@@ -215,95 +712,146 @@
         "node": ">=8"
       }
     },
-    "node_modules/chalk": {
-      "version": "2.4.2",
-      "resolved": "https://registry.npmjs.org/chalk/-/chalk-2.4.2.tgz",
-      "integrity": "sha512-Mti+f9lpJNcwF4tWV8/OrTTtF1gZi+f8FqlyAdouralcFWFQWF2+NgCHShjkCb+IFBLq9buZwE1xckQU4peSuQ==",
-      "dependencies": {
-        "ansi-styles": "^3.2.1",
-        "escape-string-regexp": "^1.0.5",
-        "supports-color": "^5.3.0"
-      },
-      "engines": {
-        "node": ">=4"
-      }
-    },
     "node_modules/change-case": {
       "version": "5.4.4",
       "resolved": "https://registry.npmjs.org/change-case/-/change-case-5.4.4.tgz",
       "integrity": "sha512-HRQyTk2/YPEkt9TnUPbOpr64Uw3KOicFWPVBb+xiHvd6eBx/qPr9xqfBFDT8P2vWsvvz4jbEkfDe71W3VyNu2w=="
     },
-    "node_modules/cliui": {
-      "version": "8.0.1",
-      "resolved": "https://registry.npmjs.org/cliui/-/cliui-8.0.1.tgz",
-      "integrity": "sha512-BSeNnyus75C4//NQ9gQt1/csTXyo/8Sb+afLAkzAptFuMsod9HFokGNudZpi/oQV73hnVK+sR+5PVRMd+Dr7YQ==",
-      "dependencies": {
-        "string-width": "^4.2.0",
-        "strip-ansi": "^6.0.1",
-        "wrap-ansi": "^7.0.0"
-      },
+    "node_modules/chardet": {
+      "version": "2.1.1",
+      "resolved": "https://registry.npmjs.org/chardet/-/chardet-2.1.1.tgz",
+      "integrity": "sha512-PsezH1rqdV9VvyNhxxOW32/d75r01NY7TQCmOqomRo15ZSOKbpTFVsfjghxo6JloQUCGnH4k1LGu0R4yCLlWQQ==",
+      "license": "MIT"
+    },
+    "node_modules/chownr": {
+      "version": "3.0.0",
+      "resolved": "https://registry.npmjs.org/chownr/-/chownr-3.0.0.tgz",
+      "integrity": "sha512-+IxzY9BZOQd/XuYPRmrvEVjF/nqj5kgT4kEq7VofrDoM1MxoRjEWkrCC3EtLi59TVawxTAn+orJwFQcrqEN1+g==",
+      "license": "BlueOak-1.0.0",
       "engines": {
-        "node": ">=12"
+        "node": ">=18"
       }
     },
-    "node_modules/color-convert": {
-      "version": "1.9.3",
-      "resolved": "https://registry.npmjs.org/color-convert/-/color-convert-1.9.3.tgz",
-      "integrity": "sha512-QfAUtd+vFdAtFQcC8CCyYt1fYWxSqAiK2cSD6zDB8N3cpsEBAvRxp9zOGg6G/SHHJYAT88/az/IuDGALsNVbGg==",
-      "dependencies": {
-        "color-name": "1.1.3"
+    "node_modules/cli-width": {
+      "version": "4.1.0",
+      "resolved": "https://registry.npmjs.org/cli-width/-/cli-width-4.1.0.tgz",
+      "integrity": "sha512-ouuZd4/dm2Sw5Gmqy6bGyNNNe1qt9RpmxveLSO7KcgsTnU7RXfsw+/bukWGo1abgBiMAic068rclZsO4IWmmxQ==",
+      "license": "ISC",
+      "engines": {
+        "node": ">= 12"
       }
     },
-    "node_modules/color-name": {
-      "version": "1.1.3",
-      "resolved": "https://registry.npmjs.org/color-name/-/color-name-1.1.3.tgz",
-      "integrity": "sha512-72fSenhMw2HZMTVHeCA9KCmpEIbzWiQsjN+BHcBbS9vr1mtt+vJjPdksIBNUmKAW8TFUDPJK5SUU3QhE9NEXDw=="
+    "node_modules/cliui": {
+      "version": "9.0.1",
+      "resolved": "https://registry.npmjs.org/cliui/-/cliui-9.0.1.tgz",
+      "integrity": "sha512-k7ndgKhwoQveBL+/1tqGJYNz097I7WOvwbmmU2AR5+magtbjPWQTS1C5vzGkBC8Ym8UWRzfKUzUUqFLypY4Q+w==",
+      "license": "ISC",
+      "dependencies": {
+        "string-width": "^7.2.0",
+        "strip-ansi": "^7.1.0",
+        "wrap-ansi": "^9.0.0"
+      },
+      "engines": {
+        "node": ">=20"
+      }
     },
     "node_modules/emoji-regex": {
-      "version": "8.0.0",
-      "resolved": "https://registry.npmjs.org/emoji-regex/-/emoji-regex-8.0.0.tgz",
-      "integrity": "sha512-MSjYzcWNOA0ewAHpz0MxpYFvwg6yjy1NG3xteoqz644VCo/RPgnr1/GGt+ic3iJTzQ8Eu3TdM14SawnVUmGE6A=="
+      "version": "10.6.0",
+      "resolved": "https://registry.npmjs.org/emoji-regex/-/emoji-regex-10.6.0.tgz",
+      "integrity": "sha512-toUI84YS5YmxW219erniWD0CIVOo46xGKColeNQRgOzDorgBi1v4D71/OFzgD9GO2UGKIv1C3Sp8DAn0+j5w7A==",
+      "license": "MIT"
     },
-    "node_modules/escalade": {
-      "version": "3.1.2",
-      "resolved": "https://registry.npmjs.org/escalade/-/escalade-3.1.2.tgz",
-      "integrity": "sha512-ErCHMCae19vR8vQGe50xIsVomy19rg6gFu3+r3jkEO46suLMWBksvVyoGgQV+jOfl84ZSOSlmv6Gxa89PmTGmA==",
+    "node_modules/env-paths": {
+      "version": "4.0.0",
+      "resolved": "https://registry.npmjs.org/env-paths/-/env-paths-4.0.0.tgz",
+      "integrity": "sha512-pxP8eL2SwwaTRi/KHYwLYXinDs7gL3jxFcBYmEdYfZmZXbaVDvdppd0XBU8qVz03rDfKZMXg1omHCbsJjZrMsw==",
+      "license": "MIT",
+      "dependencies": {
+        "is-safe-filename": "^0.1.0"
+      },
       "engines": {
-        "node": ">=6"
+        "node": ">=20"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
       }
     },
-    "node_modules/escape-string-regexp": {
-      "version": "1.0.5",
-      "resolved": "https://registry.npmjs.org/escape-string-regexp/-/escape-string-regexp-1.0.5.tgz",
-      "integrity": "sha512-vbRorB5FUQWvla16U8R/qgaFIya2qGzwDrNmCZuYKrbdSUMG6I1ZCGQRefkRVhuOkIGVne7BQ35DSfo1qvJqFg==",
+    "node_modules/escalade": {
+      "version": "3.2.0",
+      "resolved": "https://registry.npmjs.org/escalade/-/escalade-3.2.0.tgz",
+      "integrity": "sha512-WUj2qlxaQtO4g6Pq5c29GTcWGDyd8itL8zTlipgECz3JesAiiOKotd8JU6otB3PACgG6xkJUyVhboMS+bje/jA==",
+      "license": "MIT",
       "engines": {
-        "node": ">=0.8.0"
+        "node": ">=6"
       }
     },
     "node_modules/fast-deep-equal": {
       "version": "3.1.3",
       "resolved": "https://registry.npmjs.org/fast-deep-equal/-/fast-deep-equal-3.1.3.tgz",
-      "integrity": "sha512-f3qQ9oQy9j2AhBe/H9VC91wLmKBCCU/gDOnKNAYG5hswO7BLKj09Hc5HYNz9cGI++xlpDCIgDaitVs03ATR84Q=="
+      "integrity": "sha512-f3qQ9oQy9j2AhBe/H9VC91wLmKBCCU/gDOnKNAYG5hswO7BLKj09Hc5HYNz9cGI++xlpDCIgDaitVs03ATR84Q==",
+      "license": "MIT"
     },
     "node_modules/fast-glob": {
-      "version": "3.3.2",
-      "resolved": "https://registry.npmjs.org/fast-glob/-/fast-glob-3.3.2.tgz",
-      "integrity": "sha512-oX2ruAFQwf/Orj8m737Y5adxDQO0LAB7/S5MnxCdTNDd4p6BsyIVsv9JQsATbTSq8KHRpLwIHbVlUNatxd+1Ow==",
+      "version": "3.3.3",
+      "resolved": "https://registry.npmjs.org/fast-glob/-/fast-glob-3.3.3.tgz",
+      "integrity": "sha512-7MptL8U0cqcFdzIzwOTHoilX9x5BrNqye7Z/LuC7kCMRio1EMSyqRK3BEAUD7sXRq4iT4AzTVuZdhgQ2TCvYLg==",
+      "license": "MIT",
       "dependencies": {
         "@nodelib/fs.stat": "^2.0.2",
         "@nodelib/fs.walk": "^1.2.3",
         "glob-parent": "^5.1.2",
         "merge2": "^1.3.0",
-        "micromatch": "^4.0.4"
+        "micromatch": "^4.0.8"
       },
       "engines": {
         "node": ">=8.6.0"
       }
     },
+    "node_modules/fast-string-truncated-width": {
+      "version": "3.0.3",
+      "resolved": "https://registry.npmjs.org/fast-string-truncated-width/-/fast-string-truncated-width-3.0.3.tgz",
+      "integrity": "sha512-0jjjIEL6+0jag3l2XWWizO64/aZVtpiGE3t0Zgqxv0DPuxiMjvB3M24fCyhZUO4KomJQPj3LTSUnDP3GpdwC0g==",
+      "license": "MIT"
+    },
+    "node_modules/fast-string-width": {
+      "version": "3.0.2",
+      "resolved": "https://registry.npmjs.org/fast-string-width/-/fast-string-width-3.0.2.tgz",
+      "integrity": "sha512-gX8LrtNEI5hq8DVUfRQMbr5lpaS4nMIWV+7XEbXk2b8kiQIizgnlr12B4dA3ZEx3308ze0O4Q1R+cHts8kyUJg==",
+      "license": "MIT",
+      "dependencies": {
+        "fast-string-truncated-width": "^3.0.2"
+      }
+    },
+    "node_modules/fast-uri": {
+      "version": "3.1.0",
+      "resolved": "https://registry.npmjs.org/fast-uri/-/fast-uri-3.1.0.tgz",
+      "integrity": "sha512-iPeeDKJSWf4IEOasVVrknXpaBV0IApz/gp7S2bb7Z4Lljbl2MGJRqInZiUrQwV16cpzw/D3S5j5Julj/gT52AA==",
+      "funding": [
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/fastify"
+        },
+        {
+          "type": "opencollective",
+          "url": "https://opencollective.com/fastify"
+        }
+      ],
+      "license": "BSD-3-Clause"
+    },
+    "node_modules/fast-wrap-ansi": {
+      "version": "0.2.0",
+      "resolved": "https://registry.npmjs.org/fast-wrap-ansi/-/fast-wrap-ansi-0.2.0.tgz",
+      "integrity": "sha512-rLV8JHxTyhVmFYhBJuMujcrHqOT2cnO5Zxj37qROj23CP39GXubJRBUFF0z8KFK77Uc0SukZUf7JZhsVEQ6n8w==",
+      "license": "MIT",
+      "dependencies": {
+        "fast-string-width": "^3.0.2"
+      }
+    },
     "node_modules/fastq": {
-      "version": "1.17.1",
-      "resolved": "https://registry.npmjs.org/fastq/-/fastq-1.17.1.tgz",
-      "integrity": "sha512-sRVD3lWVIXWg6By68ZN7vho9a1pQcN/WBFaAAsDDFzlJjvoGx0P8z7V1t72grFJfJhu3YPZBuu25f7Kaw2jN1w==",
+      "version": "1.20.1",
+      "resolved": "https://registry.npmjs.org/fastq/-/fastq-1.20.1.tgz",
+      "integrity": "sha512-GGToxJ/w1x32s/D2EKND7kTil4n8OVk/9mycTc4VDza13lOvpUZTGX3mFSCtV9ksdGBVzvsyAVLM6mHFThxXxw==",
+      "license": "ISC",
       "dependencies": {
         "reusify": "^1.0.4"
       }
@@ -312,6 +860,7 @@
       "version": "7.1.1",
       "resolved": "https://registry.npmjs.org/fill-range/-/fill-range-7.1.1.tgz",
       "integrity": "sha512-YsGpe3WHLK8ZYi4tWDg2Jy3ebRz2rXowDxnld4bkQB00cc/1Zw9AWnC0i9ztDJitivtQvaI9KaLyKrc+hBW0yg==",
+      "license": "MIT",
       "dependencies": {
         "to-regex-range": "^5.0.1"
       },
@@ -323,14 +872,28 @@
       "version": "2.0.5",
       "resolved": "https://registry.npmjs.org/get-caller-file/-/get-caller-file-2.0.5.tgz",
       "integrity": "sha512-DyFP3BM/3YHTQOCUL/w0OZHR0lpKeGrxotcHWcqNEdnltqFwXVfhEBQ94eIo34AfQpo0rGki4cyIiftY06h2Fg==",
+      "license": "ISC",
       "engines": {
         "node": "6.* || 8.* || >= 10.*"
       }
     },
+    "node_modules/get-east-asian-width": {
+      "version": "1.5.0",
+      "resolved": "https://registry.npmjs.org/get-east-asian-width/-/get-east-asian-width-1.5.0.tgz",
+      "integrity": "sha512-CQ+bEO+Tva/qlmw24dCejulK5pMzVnUOFOijVogd3KQs07HnRIgp8TGipvCCRT06xeYEbpbgwaCxglFyiuIcmA==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=18"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
     "node_modules/glob-parent": {
       "version": "5.1.2",
       "resolved": "https://registry.npmjs.org/glob-parent/-/glob-parent-5.1.2.tgz",
       "integrity": "sha512-AOIgSQCepiJYwP3ARnGx+5VnTu2HBYdzbGP45eLw1vr3zB3vZLeyed1sC9hnbcOc9/SrMyM5RPQrkGz4aS9Zow==",
+      "license": "ISC",
       "dependencies": {
         "is-glob": "^4.0.1"
       },
@@ -339,36 +902,46 @@
       }
     },
     "node_modules/globby": {
-      "version": "14.0.1",
-      "resolved": "https://registry.npmjs.org/globby/-/globby-14.0.1.tgz",
-      "integrity": "sha512-jOMLD2Z7MAhyG8aJpNOpmziMOP4rPLcc95oQPKXBazW82z+CEgPFBQvEpRUa1KeIMUJo4Wsm+q6uzO/Q/4BksQ==",
-      "dependencies": {
-        "@sindresorhus/merge-streams": "^2.1.0",
-        "fast-glob": "^3.3.2",
-        "ignore": "^5.2.4",
-        "path-type": "^5.0.0",
+      "version": "16.1.1",
+      "resolved": "https://registry.npmjs.org/globby/-/globby-16.1.1.tgz",
+      "integrity": "sha512-dW7vl+yiAJSp6aCekaVnVJxurRv7DCOLyXqEG3RYMYUg7AuJ2jCqPkZTA8ooqC2vtnkaMcV5WfFBMuEnTu1OQg==",
+      "license": "MIT",
+      "dependencies": {
+        "@sindresorhus/merge-streams": "^4.0.0",
+        "fast-glob": "^3.3.3",
+        "ignore": "^7.0.5",
+        "is-path-inside": "^4.0.0",
         "slash": "^5.1.0",
-        "unicorn-magic": "^0.1.0"
+        "unicorn-magic": "^0.4.0"
       },
       "engines": {
-        "node": ">=18"
+        "node": ">=20"
       },
       "funding": {
         "url": "https://github.com/sponsors/sindresorhus"
       }
     },
-    "node_modules/has-flag": {
-      "version": "3.0.0",
-      "resolved": "https://registry.npmjs.org/has-flag/-/has-flag-3.0.0.tgz",
-      "integrity": "sha512-sKJf1+ceQBr4SMkvQnBDNDtf4TXpVhVGateu0t918bl30FnbE2m4vNLX+VWe/dpjlb+HugGYzW7uQXH98HPEYw==",
+    "node_modules/iconv-lite": {
+      "version": "0.7.2",
+      "resolved": "https://registry.npmjs.org/iconv-lite/-/iconv-lite-0.7.2.tgz",
+      "integrity": "sha512-im9DjEDQ55s9fL4EYzOAv0yMqmMBSZp6G0VvFyTMPKWxiSBHUj9NW/qqLmXUwXrrM7AvqSlTCfvqRb0cM8yYqw==",
+      "license": "MIT",
+      "dependencies": {
+        "safer-buffer": ">= 2.1.2 < 3.0.0"
+      },
       "engines": {
-        "node": ">=4"
+        "node": ">=0.10.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/express"
       }
     },
     "node_modules/ignore": {
-      "version": "5.3.1",
-      "resolved": "https://registry.npmjs.org/ignore/-/ignore-5.3.1.tgz",
-      "integrity": "sha512-5Fytz/IraMjqpwfd34ke28PTVMjZjJG2MPn5t7OE4eUCUNf8BAa7b5WUS9/Qvr6mwOQS7Mk6vdsMno5he+T8Xw==",
+      "version": "7.0.5",
+      "resolved": "https://registry.npmjs.org/ignore/-/ignore-7.0.5.tgz",
+      "integrity": "sha512-Hs59xBNfUIunMFgWAbGX5cq6893IbWg4KnrjbYwX3tx0ztorVgTDA6B2sxf8ejHJ4wz8BqGUMYlnzNBer5NvGg==",
+      "license": "MIT",
       "engines": {
         "node": ">= 4"
       }
@@ -377,22 +950,16 @@
       "version": "2.1.1",
       "resolved": "https://registry.npmjs.org/is-extglob/-/is-extglob-2.1.1.tgz",
       "integrity": "sha512-SbKbANkN603Vi4jEZv49LeVJMn4yGwsbzZworEoyEiutsN3nJYdbO36zfhGJ6QEDpOZIFkDtnq5JRxmvl3jsoQ==",
+      "license": "MIT",
       "engines": {
         "node": ">=0.10.0"
       }
     },
-    "node_modules/is-fullwidth-code-point": {
-      "version": "3.0.0",
-      "resolved": "https://registry.npmjs.org/is-fullwidth-code-point/-/is-fullwidth-code-point-3.0.0.tgz",
-      "integrity": "sha512-zymm5+u+sCsSWyD9qNaejV3DFvhCKclKdizYaJUuHA83RLjb7nSuGnddCHGv0hk+KY7BMAlsWeK4Ueg6EV6XQg==",
-      "engines": {
-        "node": ">=8"
-      }
-    },
     "node_modules/is-glob": {
       "version": "4.0.3",
       "resolved": "https://registry.npmjs.org/is-glob/-/is-glob-4.0.3.tgz",
       "integrity": "sha512-xelSayHH36ZgE7ZWhli7pW34hNbNl8Ojv5KVmkJD4hBdD3th8Tfk9vYasLM+mXWOZhFkgZfxhLSnrwRr4elSSg==",
+      "license": "MIT",
       "dependencies": {
         "is-extglob": "^2.1.1"
       },
@@ -404,43 +971,85 @@
       "version": "7.0.0",
       "resolved": "https://registry.npmjs.org/is-number/-/is-number-7.0.0.tgz",
       "integrity": "sha512-41Cifkg6e8TylSpdtTpeLVMqvSBEVzTttHvERD741+pnZ8ANv0004MRL43QKPDlK9cGvNp6NZWZUBlbGXYxxng==",
+      "license": "MIT",
       "engines": {
         "node": ">=0.12.0"
       }
     },
+    "node_modules/is-path-inside": {
+      "version": "4.0.0",
+      "resolved": "https://registry.npmjs.org/is-path-inside/-/is-path-inside-4.0.0.tgz",
+      "integrity": "sha512-lJJV/5dYS+RcL8uQdBDW9c9uWFLLBNRyFhnAKXw5tVqLlKZ4RMGZKv+YQ/IA3OhD+RpbJa1LLFM1FQPGyIXvOA==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=12"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
+    "node_modules/is-safe-filename": {
+      "version": "0.1.1",
+      "resolved": "https://registry.npmjs.org/is-safe-filename/-/is-safe-filename-0.1.1.tgz",
+      "integrity": "sha512-4SrR7AdnY11LHfDKTZY1u6Ga3RuxZdl3YKWWShO5iyuG5h8QS4GD2tOb04peBJ5I7pXbR+CGBNEhTcwK+FzN3g==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=20"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
+    "node_modules/is-unicode-supported": {
+      "version": "2.1.0",
+      "resolved": "https://registry.npmjs.org/is-unicode-supported/-/is-unicode-supported-2.1.0.tgz",
+      "integrity": "sha512-mE00Gnza5EEB3Ds0HfMyllZzbBrmLOX3vfWoj9A9PEnTfratQ/BcaJOuMhnkhjXvb2+FkY3VuHqtAGpTPmglFQ==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=18"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
     "node_modules/js-tokens": {
       "version": "4.0.0",
       "resolved": "https://registry.npmjs.org/js-tokens/-/js-tokens-4.0.0.tgz",
-      "integrity": "sha512-RdJUflcE3cUzKiMqQgsCu06FPu9UdIJO0beYbPhHN4k6apgJtifcoCtT9bcxOpYBtpD2kCM6Sbzg4CausW/PKQ=="
+      "integrity": "sha512-RdJUflcE3cUzKiMqQgsCu06FPu9UdIJO0beYbPhHN4k6apgJtifcoCtT9bcxOpYBtpD2kCM6Sbzg4CausW/PKQ==",
+      "license": "MIT"
     },
     "node_modules/json-schema-traverse": {
       "version": "1.0.0",
       "resolved": "https://registry.npmjs.org/json-schema-traverse/-/json-schema-traverse-1.0.0.tgz",
-      "integrity": "sha512-NM8/P9n3XjXhIZn1lLhkFaACTOURQXjWhV4BA/RnOv8xvgqtqpAX9IO4mRQxSx1Rlo4tqzeqb0sOlruaOy3dug=="
+      "integrity": "sha512-NM8/P9n3XjXhIZn1lLhkFaACTOURQXjWhV4BA/RnOv8xvgqtqpAX9IO4mRQxSx1Rlo4tqzeqb0sOlruaOy3dug==",
+      "license": "MIT"
     },
-    "node_modules/kleur": {
-      "version": "3.0.3",
-      "resolved": "https://registry.npmjs.org/kleur/-/kleur-3.0.3.tgz",
-      "integrity": "sha512-eTIzlVOSUR+JxdDFepEYcBMtZ9Qqdef+rnzWdRZuMbOywu5tO2w2N7rqjoANZ5k9vywhL6Br1VRjUIgTQx4E8w==",
+    "node_modules/jsonpointer": {
+      "version": "5.0.1",
+      "resolved": "https://registry.npmjs.org/jsonpointer/-/jsonpointer-5.0.1.tgz",
+      "integrity": "sha512-p/nXbhSEcu3pZRdkW1OfJhpsVtW1gd4Wa1fnQc9YLiTfAjn0312eMKimbdIQzuZl9aa9xUGaRlP9T/CJE/ditQ==",
+      "license": "MIT",
       "engines": {
-        "node": ">=6"
+        "node": ">=0.10.0"
       }
     },
-    "node_modules/lru-cache": {
-      "version": "6.0.0",
-      "resolved": "https://registry.npmjs.org/lru-cache/-/lru-cache-6.0.0.tgz",
-      "integrity": "sha512-Jo6dJ04CmSjuznwJSS3pUeWmd/H0ffTlkXXgwZi+eq1UCmqQwCh+eLsYOYCwY991i2Fah4h1BEMCx4qThGbsiA==",
-      "dependencies": {
-        "yallist": "^4.0.0"
-      },
+    "node_modules/leven": {
+      "version": "4.1.0",
+      "resolved": "https://registry.npmjs.org/leven/-/leven-4.1.0.tgz",
+      "integrity": "sha512-KZ9W9nWDT7rF7Dazg8xyLHGLrmpgq2nVNFUckhqdW3szVP6YhCpp/RAnpmVExA9JvrMynjwSLVrEj3AepHR6ew==",
+      "license": "MIT",
       "engines": {
-        "node": ">=10"
+        "node": "^12.20.0 || ^14.13.1 || >=16.0.0"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
       }
     },
     "node_modules/merge2": {
       "version": "1.4.1",
       "resolved": "https://registry.npmjs.org/merge2/-/merge2-1.4.1.tgz",
       "integrity": "sha512-8q7VEgMJW4J8tcfVPy8g09NcQwZdbwFEqhe/WZkoIzjn/3TGDwtOCYtXGxA3O8tPzpczCCDgv+P2P5y00ZJOOg==",
+      "license": "MIT",
       "engines": {
         "node": ">= 8"
       }
@@ -449,6 +1058,7 @@
       "version": "4.0.8",
       "resolved": "https://registry.npmjs.org/micromatch/-/micromatch-4.0.8.tgz",
       "integrity": "sha512-PXwfBhYu0hBCPw8Dn0E+WDYb7af3dSLVWKi3HGv84IdF4TyFoC0ysxFd0Goxw7nSv4T/PzEJQxsYsEiFCKo2BA==",
+      "license": "MIT",
       "dependencies": {
         "braces": "^3.0.3",
         "picomatch": "^2.3.1"
@@ -457,6 +1067,27 @@
         "node": ">=8.6"
       }
     },
+    "node_modules/minipass": {
+      "version": "7.1.3",
+      "resolved": "https://registry.npmjs.org/minipass/-/minipass-7.1.3.tgz",
+      "integrity": "sha512-tEBHqDnIoM/1rXME1zgka9g6Q2lcoCkxHLuc7ODJ5BxbP5d4c2Z5cGgtXAku59200Cx7diuHTOYfSBD8n6mm8A==",
+      "license": "BlueOak-1.0.0",
+      "engines": {
+        "node": ">=16 || 14 >=14.17"
+      }
+    },
+    "node_modules/minizlib": {
+      "version": "3.1.0",
+      "resolved": "https://registry.npmjs.org/minizlib/-/minizlib-3.1.0.tgz",
+      "integrity": "sha512-KZxYo1BUkWD2TVFLr0MQoM8vUUigWD3LlD83a/75BqC+4qE0Hb1Vo5v1FgcfaNXvfXzr+5EhQ6ing/CaBijTlw==",
+      "license": "MIT",
+      "dependencies": {
+        "minipass": "^7.1.2"
+      },
+      "engines": {
+        "node": ">= 18"
+      }
+    },
     "node_modules/mustache": {
       "version": "4.2.0",
       "resolved": "https://registry.npmjs.org/mustache/-/mustache-4.2.0.tgz",
@@ -465,26 +1096,32 @@
         "mustache": "bin/mustache"
       }
     },
-    "node_modules/path-type": {
-      "version": "5.0.0",
-      "resolved": "https://registry.npmjs.org/path-type/-/path-type-5.0.0.tgz",
-      "integrity": "sha512-5HviZNaZcfqP95rwpv+1HDgUamezbqdSYTyzjTvwtJSnIH+3vnbmWsItli8OFEndS984VT55M3jduxZbX351gg==",
+    "node_modules/mute-stream": {
+      "version": "3.0.0",
+      "resolved": "https://registry.npmjs.org/mute-stream/-/mute-stream-3.0.0.tgz",
+      "integrity": "sha512-dkEJPVvun4FryqBmZ5KhDo0K9iDXAwn08tMLDinNdRBNPcYEDiWYysLcc6k3mjTMlbP9KyylvRpd4wFtwrT9rw==",
+      "license": "ISC",
       "engines": {
-        "node": ">=12"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/sindresorhus"
+        "node": "^20.17.0 || >=22.9.0"
       }
     },
+    "node_modules/pathe": {
+      "version": "2.0.3",
+      "resolved": "https://registry.npmjs.org/pathe/-/pathe-2.0.3.tgz",
+      "integrity": "sha512-WUjGcAqP1gQacoQe+OBJsFA7Ld4DyXuUIjZ5cc75cLHvJ7dtNsTugphxIADwspS+AraAUePCKrSVtPLFj/F88w==",
+      "license": "MIT"
+    },
     "node_modules/picocolors": {
-      "version": "1.0.0",
-      "resolved": "https://registry.npmjs.org/picocolors/-/picocolors-1.0.0.tgz",
-      "integrity": "sha512-1fygroTLlHu66zi26VoTDv8yRgm0Fccecssto+MhsZ0D/DGW2sm8E8AjW7NU5VVTRt5GxbeZ5qBuJr+HyLYkjQ=="
+      "version": "1.1.1",
+      "resolved": "https://registry.npmjs.org/picocolors/-/picocolors-1.1.1.tgz",
+      "integrity": "sha512-xceH2snhtb5M9liqDsmEw56le376mTZkEX/jEb/RxNFyegNul7eNslCXP9FDj/Lcu0X8KEyMceP2ntpaHrDEVA==",
+      "license": "ISC"
     },
     "node_modules/picomatch": {
-      "version": "2.3.1",
-      "resolved": "https://registry.npmjs.org/picomatch/-/picomatch-2.3.1.tgz",
-      "integrity": "sha512-JU3teHTNjmE2VCGFzuY8EXzCDVwEqB2a8fsIvwaStHhAWJEeVd1o1QD80CU6+ZdEXXSLbSsuLwJjkCBWqRQUVA==",
+      "version": "2.3.2",
+      "resolved": "https://registry.npmjs.org/picomatch/-/picomatch-2.3.2.tgz",
+      "integrity": "sha512-V7+vQEJ06Z+c5tSye8S+nHUfI51xoXIXjHQ99cQtKUkQqqO1kO/KCJUfZXuB47h/YBlDhah2H3hdUGXn8ie0oA==",
+      "license": "MIT",
       "engines": {
         "node": ">=8.6"
       },
@@ -493,9 +1130,10 @@
       }
     },
     "node_modules/prettier": {
-      "version": "3.2.5",
-      "resolved": "https://registry.npmjs.org/prettier/-/prettier-3.2.5.tgz",
-      "integrity": "sha512-3/GWa9aOC0YeD7LUfvOG2NiDyhOWRvt1k+rcKhOuYnMY24iiCphgneUfJDyFXd6rZCAnuLBv6UeAULtrhT/F4A==",
+      "version": "3.8.1",
+      "resolved": "https://registry.npmjs.org/prettier/-/prettier-3.8.1.tgz",
+      "integrity": "sha512-UOnG6LftzbdaHZcKoPFtOcCKztrQ57WkHDeRD9t/PTQtmT0NHSeWWepj6pS0z/N7+08BHFDQVUrfmfMRcZwbMg==",
+      "license": "MIT",
       "bin": {
         "prettier": "bin/prettier.cjs"
       },
@@ -506,26 +1144,6 @@
         "url": "https://github.com/prettier/prettier?sponsor=1"
       }
     },
-    "node_modules/prompts": {
-      "version": "2.4.2",
-      "resolved": "https://registry.npmjs.org/prompts/-/prompts-2.4.2.tgz",
-      "integrity": "sha512-NxNv/kLguCA7p3jE8oL2aEBsrJWgAakBpgmgK6lpPWV+WuOmY6r2/zbAVnP+T8bQlA0nzHXSJSJW0Hq7ylaD2Q==",
-      "dependencies": {
-        "kleur": "^3.0.3",
-        "sisteransi": "^1.0.5"
-      },
-      "engines": {
-        "node": ">= 6"
-      }
-    },
-    "node_modules/punycode": {
-      "version": "2.3.1",
-      "resolved": "https://registry.npmjs.org/punycode/-/punycode-2.3.1.tgz",
-      "integrity": "sha512-vYt7UD1U9Wg6138shLtLOvdAu+8DsC/ilFtEVHcH+wydcSpNE20AfSOduf6MkRFahL5FY7X1oU7nKVZFtfq8Fg==",
-      "engines": {
-        "node": ">=6"
-      }
-    },
     "node_modules/queue-microtask": {
       "version": "1.2.3",
       "resolved": "https://registry.npmjs.org/queue-microtask/-/queue-microtask-1.2.3.tgz",
@@ -543,28 +1161,23 @@
           "type": "consulting",
           "url": "https://feross.org/support"
         }
-      ]
-    },
-    "node_modules/require-directory": {
-      "version": "2.1.1",
-      "resolved": "https://registry.npmjs.org/require-directory/-/require-directory-2.1.1.tgz",
-      "integrity": "sha512-fGxEI7+wsG9xrvdjsrlmL22OMTTiHRwAMroiEeMgq8gzoLC/PQr7RsRDSTLUg/bZAZtF+TVIkHc6/4RIKrui+Q==",
-      "engines": {
-        "node": ">=0.10.0"
-      }
+      ],
+      "license": "MIT"
     },
     "node_modules/require-from-string": {
       "version": "2.0.2",
       "resolved": "https://registry.npmjs.org/require-from-string/-/require-from-string-2.0.2.tgz",
       "integrity": "sha512-Xf0nWe6RseziFMu+Ap9biiUbmplq6S9/p+7w7YXP/JBHhrUDDUhwa+vANyubuqfZWTveU//DYVGsDG7RKL/vEw==",
+      "license": "MIT",
       "engines": {
         "node": ">=0.10.0"
       }
     },
     "node_modules/reusify": {
-      "version": "1.0.4",
-      "resolved": "https://registry.npmjs.org/reusify/-/reusify-1.0.4.tgz",
-      "integrity": "sha512-U9nH88a3fc/ekCF1l0/UP1IosiuIjyTh7hBvXVMHYgVcfGvt897Xguj2UOLDeI5BG2m7/uwyaLVT6fbtCwTyzw==",
+      "version": "1.1.0",
+      "resolved": "https://registry.npmjs.org/reusify/-/reusify-1.1.0.tgz",
+      "integrity": "sha512-g6QUff04oZpHs0eG5p83rFLhHeV00ug/Yf9nZM6fLeUrPguBTkTQOdpAWWspMh55TZfVQDPaN3NQJfbVRAxdIw==",
+      "license": "MIT",
       "engines": {
         "iojs": ">=1.0.0",
         "node": ">=0.10.0"
@@ -588,17 +1201,22 @@
           "url": "https://feross.org/support"
         }
       ],
+      "license": "MIT",
       "dependencies": {
         "queue-microtask": "^1.2.2"
       }
     },
+    "node_modules/safer-buffer": {
+      "version": "2.1.2",
+      "resolved": "https://registry.npmjs.org/safer-buffer/-/safer-buffer-2.1.2.tgz",
+      "integrity": "sha512-YZo3K82SD7Riyi0E1EQPojLz7kpepnSQI9IyPbHHg1XXXevb5dJI7tpyN2ADxGcQbHG7vcyRHk0cbwqcQriUtg==",
+      "license": "MIT"
+    },
     "node_modules/semver": {
-      "version": "7.6.0",
-      "resolved": "https://registry.npmjs.org/semver/-/semver-7.6.0.tgz",
-      "integrity": "sha512-EnwXhrlwXMk9gKu5/flx5sv/an57AkRplG3hTK68W7FRDN+k+OWBj65M7719OkA82XLBxrcX0KSHj+X5COhOVg==",
-      "dependencies": {
-        "lru-cache": "^6.0.0"
-      },
+      "version": "7.7.4",
+      "resolved": "https://registry.npmjs.org/semver/-/semver-7.7.4.tgz",
+      "integrity": "sha512-vFKC2IEtQnVhpT78h1Yp8wzwrf8CM+MzKMHGJZfBtzhZNycRFnXsHk6E5TxIkkMsgNS7mdX3AGB7x2QM2di4lA==",
+      "license": "ISC",
       "bin": {
         "semver": "bin/semver.js"
       },
@@ -606,15 +1224,23 @@
         "node": ">=10"
       }
     },
-    "node_modules/sisteransi": {
-      "version": "1.0.5",
-      "resolved": "https://registry.npmjs.org/sisteransi/-/sisteransi-1.0.5.tgz",
-      "integrity": "sha512-bLGGlR1QxBcynn2d5YmDX4MGjlZvy2MRBDRNHLJ8VI6l6+9FUiyTFNJ0IveOSP0bcXgVDPRcfGqA0pjaqUpfVg=="
+    "node_modules/signal-exit": {
+      "version": "4.1.0",
+      "resolved": "https://registry.npmjs.org/signal-exit/-/signal-exit-4.1.0.tgz",
+      "integrity": "sha512-bzyZ1e88w9O1iNJbKnOlvYTrWPDl46O1bG0D3XInv+9tkPrxrN8jUUTiFlDkkmKWgn1M6CfIA13SuGqOa9Korw==",
+      "license": "ISC",
+      "engines": {
+        "node": ">=14"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/isaacs"
+      }
     },
     "node_modules/slash": {
       "version": "5.1.0",
       "resolved": "https://registry.npmjs.org/slash/-/slash-5.1.0.tgz",
       "integrity": "sha512-ZA6oR3T/pEyuqwMgAKT0/hAv8oAXckzbkmR0UkUosQ+Mc4RxGoJkRmwHgHufaenlyAgE1Mxgpdcrf75y6XcnDg==",
+      "license": "MIT",
       "engines": {
         "node": ">=14.16"
       },
@@ -623,44 +1249,73 @@
       }
     },
     "node_modules/string-width": {
-      "version": "4.2.3",
-      "resolved": "https://registry.npmjs.org/string-width/-/string-width-4.2.3.tgz",
-      "integrity": "sha512-wKyQRQpjJ0sIp62ErSZdGsjMJWsap5oRNihHhu6G7JVO/9jIB6UyevL+tXuOqrng8j/cxKTWyWUwvSTriiZz/g==",
+      "version": "7.2.0",
+      "resolved": "https://registry.npmjs.org/string-width/-/string-width-7.2.0.tgz",
+      "integrity": "sha512-tsaTIkKW9b4N+AEj+SVA+WhJzV7/zMhcSu78mLKWSk7cXMOSHsBKFWUs0fWwq8QyK3MgJBQRX6Gbi4kYbdvGkQ==",
+      "license": "MIT",
       "dependencies": {
-        "emoji-regex": "^8.0.0",
-        "is-fullwidth-code-point": "^3.0.0",
-        "strip-ansi": "^6.0.1"
+        "emoji-regex": "^10.3.0",
+        "get-east-asian-width": "^1.0.0",
+        "strip-ansi": "^7.1.0"
       },
       "engines": {
-        "node": ">=8"
+        "node": ">=18"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
       }
     },
     "node_modules/strip-ansi": {
-      "version": "6.0.1",
-      "resolved": "https://registry.npmjs.org/strip-ansi/-/strip-ansi-6.0.1.tgz",
-      "integrity": "sha512-Y38VPSHcqkFrCpFnQ9vuSXmquuv5oXOKpGeT6aGrr3o3Gc9AlVa6JBfUSOCnbxGGZF+/0ooI7KrPuUSztUdU5A==",
+      "version": "7.2.0",
+      "resolved": "https://registry.npmjs.org/strip-ansi/-/strip-ansi-7.2.0.tgz",
+      "integrity": "sha512-yDPMNjp4WyfYBkHnjIRLfca1i6KMyGCtsVgoKe/z1+6vukgaENdgGBZt+ZmKPc4gavvEZ5OgHfHdrazhgNyG7w==",
+      "license": "MIT",
       "dependencies": {
-        "ansi-regex": "^5.0.1"
+        "ansi-regex": "^6.2.2"
       },
       "engines": {
-        "node": ">=8"
+        "node": ">=12"
+      },
+      "funding": {
+        "url": "https://github.com/chalk/strip-ansi?sponsor=1"
       }
     },
-    "node_modules/supports-color": {
-      "version": "5.5.0",
-      "resolved": "https://registry.npmjs.org/supports-color/-/supports-color-5.5.0.tgz",
-      "integrity": "sha512-QjVjwdXIt408MIiAqCX4oUKsgU2EqAGzs2Ppkm4aQYbjm+ZEWEcW4SfFNTr4uMNZma0ey4f5lgLrkB0aX0QMow==",
+    "node_modules/tar": {
+      "version": "7.5.13",
+      "resolved": "https://registry.npmjs.org/tar/-/tar-7.5.13.tgz",
+      "integrity": "sha512-tOG/7GyXpFevhXVh8jOPJrmtRpOTsYqUIkVdVooZYJS/z8WhfQUX8RJILmeuJNinGAMSu1veBr4asSHFt5/hng==",
+      "license": "BlueOak-1.0.0",
       "dependencies": {
-        "has-flag": "^3.0.0"
+        "@isaacs/fs-minipass": "^4.0.0",
+        "chownr": "^3.0.0",
+        "minipass": "^7.1.2",
+        "minizlib": "^3.1.0",
+        "yallist": "^5.0.0"
       },
       "engines": {
-        "node": ">=4"
+        "node": ">=18"
+      }
+    },
+    "node_modules/temporal-polyfill": {
+      "version": "0.3.2",
+      "resolved": "https://registry.npmjs.org/temporal-polyfill/-/temporal-polyfill-0.3.2.tgz",
+      "integrity": "sha512-TzHthD/heRK947GNiSu3Y5gSPpeUDH34+LESnfsq8bqpFhsB79HFBX8+Z834IVX68P3EUyRPZK5bL/1fh437Eg==",
+      "license": "MIT",
+      "dependencies": {
+        "temporal-spec": "0.3.1"
       }
     },
+    "node_modules/temporal-spec": {
+      "version": "0.3.1",
+      "resolved": "https://registry.npmjs.org/temporal-spec/-/temporal-spec-0.3.1.tgz",
+      "integrity": "sha512-B4TUhezh9knfSIMwt7RVggApDRJZo73uZdj8AacL2mZ8RP5KtLianh2MXxL06GN9ESYiIsiuoLQhgVfwe55Yhw==",
+      "license": "ISC"
+    },
     "node_modules/to-regex-range": {
       "version": "5.0.1",
       "resolved": "https://registry.npmjs.org/to-regex-range/-/to-regex-range-5.0.1.tgz",
       "integrity": "sha512-65P7iz6X5yEr1cwcgvQxbbIw7Uk3gOy5dIdtZ4rDveLqhrdJP+Li/Hx6tyK0NEb+2GCyneCMJiGqrADCSNk8sQ==",
+      "license": "MIT",
       "dependencies": {
         "is-number": "^7.0.0"
       },
@@ -669,24 +1324,17 @@
       }
     },
     "node_modules/unicorn-magic": {
-      "version": "0.1.0",
-      "resolved": "https://registry.npmjs.org/unicorn-magic/-/unicorn-magic-0.1.0.tgz",
-      "integrity": "sha512-lRfVq8fE8gz6QMBuDM6a+LO3IAzTi05H6gCVaUpir2E1Rwpo4ZUog45KpNXKC/Mn3Yb9UDuHumeFTo9iV/D9FQ==",
+      "version": "0.4.0",
+      "resolved": "https://registry.npmjs.org/unicorn-magic/-/unicorn-magic-0.4.0.tgz",
+      "integrity": "sha512-wH590V9VNgYH9g3lH9wWjTrUoKsjLF6sGLjhR4sH1LWpLmCOH0Zf7PukhDA8BiS7KHe4oPNkcTHqYkj7SOGUOw==",
+      "license": "MIT",
       "engines": {
-        "node": ">=18"
+        "node": ">=20"
       },
       "funding": {
         "url": "https://github.com/sponsors/sindresorhus"
       }
     },
-    "node_modules/uri-js": {
-      "version": "4.4.1",
-      "resolved": "https://registry.npmjs.org/uri-js/-/uri-js-4.4.1.tgz",
-      "integrity": "sha512-7rKUyy33Q1yc98pQ1DAmLtwX109F7TIfWlW1Ydo8Wl1ii1SeHieeh0HHfPeL2fMXK6z0s8ecKs9frCuLJvndBg==",
-      "dependencies": {
-        "punycode": "^2.1.0"
-      }
-    },
     "node_modules/vscode-jsonrpc": {
       "version": "8.2.0",
       "resolved": "https://registry.npmjs.org/vscode-jsonrpc/-/vscode-jsonrpc-8.2.0.tgz",
@@ -716,9 +1364,10 @@
       }
     },
     "node_modules/vscode-languageserver-textdocument": {
-      "version": "1.0.11",
-      "resolved": "https://registry.npmjs.org/vscode-languageserver-textdocument/-/vscode-languageserver-textdocument-1.0.11.tgz",
-      "integrity": "sha512-X+8T3GoiwTVlJbicx/sIAF+yuJAqz8VvwJyoMVhwEMoEKE/fkDmrqUgDMyBECcM2A2frVZIUj5HI/ErRXCfOeA=="
+      "version": "1.0.12",
+      "resolved": "https://registry.npmjs.org/vscode-languageserver-textdocument/-/vscode-languageserver-textdocument-1.0.12.tgz",
+      "integrity": "sha512-cxWNPesCnQCcMPeenjKKsOCKQZ/L6Tv19DTRIGuLWe32lyzWhihGVJ/rcckZXJxfdKCFvRLS3fpBIsV/ZGX4zA==",
+      "license": "MIT"
     },
     "node_modules/vscode-languageserver-types": {
       "version": "3.17.5",
@@ -726,98 +1375,88 @@
       "integrity": "sha512-Ld1VelNuX9pdF39h2Hgaeb5hEZM2Z3jUrrMgWQAu82jMtZp7p3vJT3BzToKtZI7NgQssZje5o0zryOrhQvzQAg=="
     },
     "node_modules/wrap-ansi": {
-      "version": "7.0.0",
-      "resolved": "https://registry.npmjs.org/wrap-ansi/-/wrap-ansi-7.0.0.tgz",
-      "integrity": "sha512-YVGIj2kamLSTxw6NsZjoBxfSwsn0ycdesmc4p+Q21c5zPuZ1pl+NfxVdxPtdHvmNVOQ6XSYG4AUtyt/Fi7D16Q==",
+      "version": "9.0.2",
+      "resolved": "https://registry.npmjs.org/wrap-ansi/-/wrap-ansi-9.0.2.tgz",
+      "integrity": "sha512-42AtmgqjV+X1VpdOfyTGOYRi0/zsoLqtXQckTmqTeybT+BDIbM/Guxo7x3pE2vtpr1ok6xRqM9OpBe+Jyoqyww==",
+      "license": "MIT",
       "dependencies": {
-        "ansi-styles": "^4.0.0",
-        "string-width": "^4.1.0",
-        "strip-ansi": "^6.0.0"
+        "ansi-styles": "^6.2.1",
+        "string-width": "^7.0.0",
+        "strip-ansi": "^7.1.0"
       },
       "engines": {
-        "node": ">=10"
+        "node": ">=18"
       },
       "funding": {
         "url": "https://github.com/chalk/wrap-ansi?sponsor=1"
       }
     },
-    "node_modules/wrap-ansi/node_modules/ansi-styles": {
-      "version": "4.3.0",
-      "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-4.3.0.tgz",
-      "integrity": "sha512-zbB9rCJAT1rbjiVDb2hqKFHNYLxgtk8NURxZ3IZwD3F6NtxbXZQCnnSi1Lkx+IDohdPlFp222wVALIheZJQSEg==",
-      "dependencies": {
-        "color-convert": "^2.0.1"
-      },
-      "engines": {
-        "node": ">=8"
-      },
-      "funding": {
-        "url": "https://github.com/chalk/ansi-styles?sponsor=1"
-      }
-    },
-    "node_modules/wrap-ansi/node_modules/color-convert": {
-      "version": "2.0.1",
-      "resolved": "https://registry.npmjs.org/color-convert/-/color-convert-2.0.1.tgz",
-      "integrity": "sha512-RRECPsj7iu/xb5oKYcsFHSppFNnsj/52OVTRKb4zP5onXwVF3zVmmToNcOfGC+CRDpfK/U584fMg38ZHCaElKQ==",
-      "dependencies": {
-        "color-name": "~1.1.4"
-      },
-      "engines": {
-        "node": ">=7.0.0"
-      }
-    },
-    "node_modules/wrap-ansi/node_modules/color-name": {
-      "version": "1.1.4",
-      "resolved": "https://registry.npmjs.org/color-name/-/color-name-1.1.4.tgz",
-      "integrity": "sha512-dOy+3AuW3a2wNbZHIuMZpTcgjGuLU/uBL/ubcZF9OXbDo8ff4O8yVp5Bf0efS8uEoYo5q4Fx7dY9OgQGXgAsQA=="
-    },
     "node_modules/y18n": {
       "version": "5.0.8",
       "resolved": "https://registry.npmjs.org/y18n/-/y18n-5.0.8.tgz",
       "integrity": "sha512-0pfFzegeDWJHJIAmTLRP2DwHjdF5s7jo9tuztdQxAhINCdvS+3nGINqPd00AphqJR/0LhANUS6/+7SCb98YOfA==",
+      "license": "ISC",
       "engines": {
         "node": ">=10"
       }
     },
     "node_modules/yallist": {
-      "version": "4.0.0",
-      "resolved": "https://registry.npmjs.org/yallist/-/yallist-4.0.0.tgz",
-      "integrity": "sha512-3wdGidZyq5PB084XLES5TpOSRA3wjXAlIWMhum2kRcv/41Sn2emQ0dycQW4uZXLejwKvg6EsvbdlVL+FYEct7A=="
+      "version": "5.0.0",
+      "resolved": "https://registry.npmjs.org/yallist/-/yallist-5.0.0.tgz",
+      "integrity": "sha512-YgvUTfwqyc7UXVMrB+SImsVYSmTS8X/tSrtdNZMImM+n7+QTriRXyXim0mBrTXNeqzVF0KWGgHPeiyViFFrNDw==",
+      "license": "BlueOak-1.0.0",
+      "engines": {
+        "node": ">=18"
+      }
     },
     "node_modules/yaml": {
-      "version": "2.4.2",
-      "resolved": "https://registry.npmjs.org/yaml/-/yaml-2.4.2.tgz",
-      "integrity": "sha512-B3VqDZ+JAg1nZpaEmWtTXUlBneoGx6CPM9b0TENK6aoSu5t73dItudwdgmi6tHlIZZId4dZ9skcAQ2UbcyAeVA==",
+      "version": "2.8.3",
+      "resolved": "https://registry.npmjs.org/yaml/-/yaml-2.8.3.tgz",
+      "integrity": "sha512-AvbaCLOO2Otw/lW5bmh9d/WEdcDFdQp2Z2ZUH3pX9U2ihyUY0nvLv7J6TrWowklRGPYbB/IuIMfYgxaCPg5Bpg==",
+      "license": "ISC",
       "bin": {
         "yaml": "bin.mjs"
       },
       "engines": {
-        "node": ">= 14"
+        "node": ">= 14.6"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/eemeli"
       }
     },
     "node_modules/yargs": {
-      "version": "17.7.2",
-      "resolved": "https://registry.npmjs.org/yargs/-/yargs-17.7.2.tgz",
-      "integrity": "sha512-7dSzzRQ++CKnNI/krKnYRV7JKKPUXMEh61soaHKg9mrWEhzFWhFnxPxGl+69cD1Ou63C13NUPCnmIcrvqCuM6w==",
+      "version": "18.0.0",
+      "resolved": "https://registry.npmjs.org/yargs/-/yargs-18.0.0.tgz",
+      "integrity": "sha512-4UEqdc2RYGHZc7Doyqkrqiln3p9X2DZVxaGbwhn2pi7MrRagKaOcIKe8L3OxYcbhXLgLFUS3zAYuQjKBQgmuNg==",
+      "license": "MIT",
       "dependencies": {
-        "cliui": "^8.0.1",
+        "cliui": "^9.0.1",
         "escalade": "^3.1.1",
         "get-caller-file": "^2.0.5",
-        "require-directory": "^2.1.1",
-        "string-width": "^4.2.3",
+        "string-width": "^7.2.0",
         "y18n": "^5.0.5",
-        "yargs-parser": "^21.1.1"
+        "yargs-parser": "^22.0.0"
       },
       "engines": {
-        "node": ">=12"
+        "node": "^20.19.0 || ^22.12.0 || >=23"
       }
     },
     "node_modules/yargs-parser": {
-      "version": "21.1.1",
-      "resolved": "https://registry.npmjs.org/yargs-parser/-/yargs-parser-21.1.1.tgz",
-      "integrity": "sha512-tVpsJW7DdjecAiFpbIB1e3qxIQsE6NoPc5/eTdrbbIC4h0LVsWhnoa3g+m2HclBIujHzsxZ4VJVA+GUuc2/LBw==",
+      "version": "22.0.0",
+      "resolved": "https://registry.npmjs.org/yargs-parser/-/yargs-parser-22.0.0.tgz",
+      "integrity": "sha512-rwu/ClNdSMpkSrUb+d6BRsSkLUq1fmfsY6TOpYzTwvwkg1/NRG85KBy3kq++A8LKQwX6lsu+aWad+2khvuXrqw==",
+      "license": "ISC",
       "engines": {
-        "node": ">=12"
+        "node": "^20.19.0 || ^22.12.0 || >=23"
+      }
+    },
+    "node_modules/zod": {
+      "version": "4.3.6",
+      "resolved": "https://registry.npmjs.org/zod/-/zod-4.3.6.tgz",
+      "integrity": "sha512-rftlrkhHZOcjDwkGlnUtZZkvaPHCsDATp4pGpuOOMDaTdDDXF91wuVDJoWoPsKX/3YPQ5fHuF3STjcYyKr+Qhg==",
+      "license": "MIT",
+      "funding": {
+        "url": "https://github.com/sponsors/colinhacks"
       }
     }
   }
diff --git a/src/main/resources/apps.methodscript.com/package.json b/src/main/resources/apps.methodscript.com/package.json
index 508f70ee38..fc899c5ff4 100644
--- a/src/main/resources/apps.methodscript.com/package.json
+++ b/src/main/resources/apps.methodscript.com/package.json
@@ -4,10 +4,10 @@
   "type": "module",
   "dependencies": {
     "@typespec/compiler": "latest",
-    "@typespec/http": "^0.55.0",
-    "@typespec/openapi": "^0.55.0",
-    "@typespec/openapi3": "^0.55.0",
-    "@typespec/versioning": "^0.55.0"
+    "@typespec/http": "^1.10.0",
+    "@typespec/openapi": "^1.10.0",
+    "@typespec/openapi3": "^1.10.0",
+    "@typespec/versioning": "^0.80.0"
   },
   "private": true
 }
diff --git a/src/main/resources/docs/Debugging b/src/main/resources/docs/Debugging
index 56915eb847..235b0dd0cf 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 9e26f692c0..eb86c39682 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 c93059f445..96c0987892 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/PureUtilities/RSAEncryptTest.java b/src/test/java/com/laytonsmith/PureUtilities/RSAEncryptTest.java
deleted file mode 100644
index b034123d9a..0000000000
--- a/src/test/java/com/laytonsmith/PureUtilities/RSAEncryptTest.java
+++ /dev/null
@@ -1,56 +0,0 @@
-package com.laytonsmith.PureUtilities;
-
-import com.laytonsmith.PureUtilities.Common.RSAEncrypt;
-import org.junit.After;
-import org.junit.AfterClass;
-import static org.junit.Assert.assertEquals;
-import org.junit.Before;
-import org.junit.BeforeClass;
-import org.junit.Test;
-
-/**
- *
- */
-public class RSAEncryptTest {
-
-	RSAEncrypt enc;
-	byte[] data;
-	String sData;
-
-	public RSAEncryptTest() {
-	}
-
-	@BeforeClass
-	public static void setUpClass() {
-	}
-
-	@AfterClass
-	public static void tearDownClass() {
-	}
-
-	@Before
-	public void setUp() throws Exception {
-		enc = RSAEncrypt.generateKey("label@label");
-		sData = "the test string";
-		data = sData.getBytes("UTF-8");
-	}
-
-	@After
-	public void tearDown() {
-	}
-
-	@Test
-	public void testPubToPriv() throws Exception {
-		byte[] c = enc.encryptWithPublic(data);
-		String s = new String(enc.decryptWithPrivate(c), "UTF-8");
-		assertEquals(sData, s);
-	}
-
-	@Test
-	public void testPrivToPub() throws Exception {
-		byte[] c = enc.encryptWithPrivate(data);
-		String s = new String(enc.decryptWithPublic(c), "UTF-8");
-		assertEquals(sData, s);
-	}
-
-}
diff --git a/src/test/java/com/laytonsmith/PureUtilities/SSHKeyPairTest.java b/src/test/java/com/laytonsmith/PureUtilities/SSHKeyPairTest.java
new file mode 100644
index 0000000000..a2e2680820
--- /dev/null
+++ b/src/test/java/com/laytonsmith/PureUtilities/SSHKeyPairTest.java
@@ -0,0 +1,96 @@
+package com.laytonsmith.PureUtilities;
+
+import com.laytonsmith.PureUtilities.Common.SSHKeyPair;
+import com.laytonsmith.PureUtilities.Common.SSHKeyPair.KeyType;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertTrue;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
+import org.junit.runners.Parameterized.Parameters;
+import java.util.Arrays;
+import java.util.Collection;
+
+/**
+ * Tests for SSHKeyPair supporting RSA, Ed25519, and ECDSA key types.
+ */
+@RunWith(Parameterized.class)
+public class SSHKeyPairTest {
+
+	@Parameters(name = "{0}")
+	public static Collection<Object[]> keyTypes() {
+		return Arrays.asList(new Object[][]{
+			{KeyType.RSA},
+			{KeyType.ED25519},
+			{KeyType.ECDSA_256},
+		});
+	}
+
+	private final KeyType keyType;
+
+	public SSHKeyPairTest(KeyType keyType) {
+		this.keyType = keyType;
+	}
+
+	@Test
+	public void testSignAndVerify() throws Exception {
+		SSHKeyPair pair = SSHKeyPair.generateKey(keyType, "test@host");
+		byte[] data = "test data".getBytes("UTF-8");
+		byte[] sig = pair.sign(data);
+		assertTrue(pair.verify(data, sig));
+	}
+
+	@Test
+	public void testRoundTripThroughSerialization() throws Exception {
+		SSHKeyPair original = SSHKeyPair.generateKey(keyType, "label@host");
+		String privPem = original.getPrivateKeyPem();
+		String pubSsh = original.getPublicKeySsh();
+		assertTrue(pubSsh.startsWith(keyType.getSshName() + " "));
+		assertTrue(pubSsh.endsWith(" label@host"));
+
+		SSHKeyPair signer = new SSHKeyPair(privPem, null);
+		SSHKeyPair verifier = new SSHKeyPair(null, pubSsh);
+		byte[] data = "round trip test".getBytes("UTF-8");
+		byte[] sig = signer.sign(data);
+		assertTrue(verifier.verify(data, sig));
+	}
+
+	@Test
+	public void testKeyTypeDetectedFromPrivateKeyOnly() throws Exception {
+		SSHKeyPair pair = SSHKeyPair.generateKey(keyType, "test");
+		SSHKeyPair fromPriv = new SSHKeyPair(pair.getPrivateKeyPem(), null);
+		assertEquals(keyType, fromPriv.getKeyType());
+	}
+
+	@Test
+	public void testGetKeyType() {
+		SSHKeyPair pair = SSHKeyPair.generateKey(keyType, "test");
+		assertEquals(keyType, pair.getKeyType());
+	}
+
+	@Test
+	public void testGetLabel() {
+		SSHKeyPair pair = SSHKeyPair.generateKey(keyType, "user@example.com");
+		assertEquals("user@example.com", pair.getLabel());
+	}
+
+	@Test
+	public void testPrivateKeyPemFormat() {
+		SSHKeyPair pair = SSHKeyPair.generateKey(keyType, "test");
+		String pem = pair.getPrivateKeyPem();
+		assertTrue(pem.contains("-----BEGIN PRIVATE KEY-----"));
+		assertTrue(pem.contains("-----END PRIVATE KEY-----"));
+	}
+
+	@Test
+	public void testKeyTypeFromSshName() {
+		for(KeyType kt : KeyType.values()) {
+			assertEquals(kt, KeyType.fromSshName(kt.getSshName()));
+		}
+	}
+
+	@Test(expected = IllegalArgumentException.class)
+	public void testKeyTypeFromSshNameUnknown() {
+		KeyType.fromSshName("ssh-unknown");
+	}
+}
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 0000000000..96c8aa591e
--- /dev/null
+++ b/src/test/java/com/laytonsmith/core/DebugInfrastructureTest.java
@@ -0,0 +1,1413 @@
+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 org.eclipse.lsp4j.debug.EvaluateArguments;
+import org.eclipse.lsp4j.debug.EvaluateResponse;
+import org.eclipse.lsp4j.debug.ScopesArguments;
+import org.eclipse.lsp4j.debug.ScopesResponse;
+import org.eclipse.lsp4j.debug.StackTraceArguments;
+import org.eclipse.lsp4j.debug.StackTraceResponse;
+import org.eclipse.lsp4j.debug.StepInArguments;
+import org.eclipse.lsp4j.debug.StepOutArguments;
+import org.eclipse.lsp4j.debug.ThreadEventArguments;
+import org.eclipse.lsp4j.debug.ThreadsResponse;
+import org.eclipse.lsp4j.debug.VariablesArguments;
+import org.eclipse.lsp4j.debug.VariablesResponse;
+import org.eclipse.lsp4j.debug.DisconnectArguments;
+import org.eclipse.lsp4j.debug.StepInTargetsArguments;
+import org.eclipse.lsp4j.debug.StepInTargetsResponse;
+import org.eclipse.lsp4j.debug.SetExceptionBreakpointsArguments;
+
+import java.io.File;
+import java.net.Socket;
+import java.util.ArrayList;
+import java.util.Collections;
+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<>();
+		final List<ThreadEventArguments> threadEvents
+				= Collections.synchronizedList(new ArrayList<>());
+		final CountDownLatch threadExited = new CountDownLatch(1);
+		private boolean closed = false;
+		private boolean managed = false;
+
+		DAPTestHarness(String script, int[] breakpointLines,
+				DebugContext.ThreadingMode mode) throws Exception {
+			this(script, toSourceBreakpoints(breakpointLines), mode, false);
+		}
+
+		DAPTestHarness(String script, int[] breakpointLines,
+				DebugContext.ThreadingMode mode, boolean managedExecution) throws Exception {
+			this(script, toSourceBreakpoints(breakpointLines), mode, managedExecution);
+		}
+
+		DAPTestHarness(String script, SourceBreakpoint[] breakpoints,
+				DebugContext.ThreadingMode mode, boolean managedExecution) throws Exception {
+			this.managed = managedExecution;
+			// 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();
+				}
+
+				@Override
+				public void thread(ThreadEventArguments args) {
+					threadEvents.add(args);
+					if("exited".equals(args.getReason())) {
+						threadExited.countDown();
+					}
+				}
+			};
+
+			server = new MSDebugServer();
+			if(managedExecution) {
+				server.setManagedExecution(true);
+			}
+			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
+			sendBreakpoints(breakpoints);
+
+			// 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);
+		}
+
+		static SourceBreakpoint[] toSourceBreakpoints(int[] lines) {
+			SourceBreakpoint[] sbps = new SourceBreakpoint[lines.length];
+			for(int i = 0; i < lines.length; i++) {
+				sbps[i] = new SourceBreakpoint();
+				sbps[i].setLine(lines[i]);
+			}
+			return sbps;
+		}
+
+		void sendBreakpoints(SourceBreakpoint[] sbps) throws Exception {
+			SetBreakpointsArguments bpArgs = new SetBreakpointsArguments();
+			Source source = new Source();
+			source.setPath(TEST_FILE.getPath());
+			bpArgs.setSource(source);
+			bpArgs.setBreakpoints(sbps);
+			proxy.setBreakpoints(bpArgs).get(5, TimeUnit.SECONDS);
+		}
+
+		void setBreakpoints(int[] lines) throws Exception {
+			sendBreakpoints(toSourceBreakpoints(lines));
+		}
+
+		void setBreakpointsWithConditions(int[] lines, String[] conditions) throws Exception {
+			SourceBreakpoint[] sbps = toSourceBreakpoints(lines);
+			for(int i = 0; i < sbps.length; i++) {
+				if(conditions != null && i < conditions.length && conditions[i] != null) {
+					sbps[i].setCondition(conditions[i]);
+				}
+			}
+			sendBreakpoints(sbps);
+		}
+
+		void setBreakpointsWithHitCounts(int[] lines, String[] hitCounts) throws Exception {
+			SourceBreakpoint[] sbps = toSourceBreakpoints(lines);
+			for(int i = 0; i < sbps.length; i++) {
+				if(hitCounts != null && i < hitCounts.length && hitCounts[i] != null) {
+					sbps[i].setHitCondition(hitCounts[i]);
+				}
+			}
+			sendBreakpoints(sbps);
+		}
+
+		boolean awaitStop(int index, long seconds) throws InterruptedException {
+			return stopLatches.get(index).await(seconds, TimeUnit.SECONDS);
+		}
+
+		int lastStoppedThreadId() {
+			StoppedEventArguments args = lastStopArgs.get();
+			return args != null ? args.getThreadId() : 1;
+		}
+
+		void stepOver() throws Exception {
+			NextArguments args = new NextArguments();
+			args.setThreadId(lastStoppedThreadId());
+			proxy.next(args).get(5, TimeUnit.SECONDS);
+		}
+
+		void continue_() throws Exception {
+			ContinueArguments args = new ContinueArguments();
+			args.setThreadId(lastStoppedThreadId());
+			proxy.continue_(args).get(5, TimeUnit.SECONDS);
+		}
+
+		void stepIn() throws Exception {
+			StepInArguments args = new StepInArguments();
+			args.setThreadId(lastStoppedThreadId());
+			proxy.stepIn(args).get(5, TimeUnit.SECONDS);
+		}
+
+		void stepOut() throws Exception {
+			StepOutArguments args = new StepOutArguments();
+			args.setThreadId(lastStoppedThreadId());
+			proxy.stepOut(args).get(5, TimeUnit.SECONDS);
+		}
+
+		ThreadsResponse threads() throws Exception {
+			return proxy.threads().get(5, TimeUnit.SECONDS);
+		}
+
+		StackTraceResponse stackTrace() throws Exception {
+			StackTraceArguments args = new StackTraceArguments();
+			args.setThreadId(lastStoppedThreadId());
+			return proxy.stackTrace(args).get(5, TimeUnit.SECONDS);
+		}
+
+		ScopesResponse scopes() throws Exception {
+			StackTraceResponse st = stackTrace();
+			ScopesArguments args = new ScopesArguments();
+			args.setFrameId(st.getStackFrames()[0].getId());
+			return proxy.scopes(args).get(5, TimeUnit.SECONDS);
+		}
+
+		VariablesResponse variables(int variablesReference) throws Exception {
+			VariablesArguments args = new VariablesArguments();
+			args.setVariablesReference(variablesReference);
+			return proxy.variables(args).get(5, TimeUnit.SECONDS);
+		}
+
+		EvaluateResponse evaluate(String expression) throws Exception {
+			EvaluateArguments args = new EvaluateArguments();
+			args.setExpression(expression);
+			args.setContext("repl");
+			StackTraceResponse st = stackTrace();
+			args.setFrameId(st.getStackFrames()[0].getId());
+			return proxy.evaluate(args).get(5, TimeUnit.SECONDS);
+		}
+
+		void disconnect() throws Exception {
+			DisconnectArguments args = new DisconnectArguments();
+			proxy.disconnect(args).get(5, TimeUnit.SECONDS);
+		}
+
+		StepInTargetsResponse stepInTargets() throws Exception {
+			StackTraceResponse st = stackTrace();
+			StepInTargetsArguments args = new StepInTargetsArguments();
+			args.setFrameId(st.getStackFrames()[0].getId());
+			return proxy.stepInTargets(args).get(5, TimeUnit.SECONDS);
+		}
+
+		void setExceptionBreakpoints(String... filters) throws Exception {
+			SetExceptionBreakpointsArguments args = new SetExceptionBreakpointsArguments();
+			args.setFilters(filters);
+			proxy.setExceptionBreakpoints(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);
+	}
+
+	// ---- Managed execution mode tests ----
+
+	@Test
+	public void testManagedModeStepOverSync() throws Exception {
+		managedModeStepOver(DebugContext.ThreadingMode.SYNCHRONOUS);
+	}
+
+	@Test
+	public void testManagedModeStepOverAsync() throws Exception {
+		managedModeStepOver(DebugContext.ThreadingMode.ASYNCHRONOUS);
+	}
+
+	private void managedModeStepOver(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, true)) {
+			assertTrue("Breakpoint at line 1 was not hit",
+					h.awaitStop(0, 5));
+			// In managed mode, the stopped thread should NOT be 1 (main)
+			int stoppedId = h.lastStoppedThreadId();
+			assertTrue("Execution thread should have a non-main DAP ID in managed mode",
+					stoppedId > 1);
+			h.stepOver();
+			assertTrue("Step-over should pause at next line",
+					h.awaitStop(1, 5));
+			h.continue_();
+			assertTrue("Script should complete",
+					h.threadExited.await(5, TimeUnit.SECONDS));
+		}
+	}
+
+	@Test
+	public void testManagedModeThreadEvents() throws Exception {
+		String script = "@x = 1\n@y = 2";
+		try(DAPTestHarness h = new DAPTestHarness(script, new int[]{1},
+				DebugContext.ThreadingMode.SYNCHRONOUS, true)) {
+			assertTrue(h.awaitStop(0, 5));
+			// In managed mode, a thread-started event should have been sent
+			// for the execution thread
+			boolean foundStarted = false;
+			for(ThreadEventArguments tea : h.threadEvents) {
+				if("started".equals(tea.getReason())) {
+					foundStarted = true;
+					assertTrue("Execution thread DAP ID should be > 1",
+							tea.getThreadId() > 1);
+				}
+			}
+			assertTrue("Should have received thread-started event for execution thread",
+					foundStarted);
+			h.continue_();
+			h.threadExited.await(5, TimeUnit.SECONDS);
+		}
+	}
+
+	@Test
+	public void testManagedModeDisconnectKeepsServerAlive() throws Exception {
+		String script = "@x = 1\n@y = 2\n@z = 3";
+		try(DAPTestHarness h = new DAPTestHarness(script, new int[]{1},
+				DebugContext.ThreadingMode.SYNCHRONOUS, true)) {
+			assertTrue(h.awaitStop(0, 5));
+			// Disconnect while paused - in managed mode, this should resume
+			// execution and NOT terminate the server
+			h.disconnect();
+			// The script should complete (execution was resumed by disconnect)
+			assertTrue("Script should complete after managed disconnect",
+					h.threadExited.await(5, TimeUnit.SECONDS));
+		}
+	}
+
+	// ---- Threads, stack trace, scopes, and variables via DAP ----
+
+	@Test
+	public void testDAPThreadsList() throws Exception {
+		String script = "@x = 1\n@y = 2";
+		try(DAPTestHarness h = new DAPTestHarness(script, new int[]{1},
+				DebugContext.ThreadingMode.SYNCHRONOUS)) {
+			assertTrue(h.awaitStop(0, 5));
+			ThreadsResponse resp = h.threads();
+			assertNotNull(resp.getThreads());
+			assertTrue("Should have at least one thread",
+					resp.getThreads().length >= 1);
+			h.continue_();
+			h.terminated.await(5, TimeUnit.SECONDS);
+		}
+	}
+
+	@Test
+	public void testDAPStackTrace() throws Exception {
+		String script = "proc _inner() {\n"
+				+ "\t@a = 1\n"
+				+ "}\n"
+				+ "proc _outer() {\n"
+				+ "\t_inner()\n"
+				+ "}\n"
+				+ "_outer()";
+		try(DAPTestHarness h = new DAPTestHarness(script, new int[]{2},
+				DebugContext.ThreadingMode.SYNCHRONOUS)) {
+			assertTrue(h.awaitStop(0, 5));
+			StackTraceResponse resp = h.stackTrace();
+			org.eclipse.lsp4j.debug.StackFrame[] frames = resp.getStackFrames();
+			assertTrue("Should have at least 2 frames",
+					frames.length >= 2);
+			assertEquals("proc _inner", frames[0].getName());
+			assertEquals("proc _outer", frames[1].getName());
+			h.continue_();
+			h.terminated.await(5, TimeUnit.SECONDS);
+		}
+	}
+
+	@Test
+	public void testDAPScopesAndVariables() throws Exception {
+		String script = "@x = 42\n@y = 'hello'\n@z = 3";
+		try(DAPTestHarness h = new DAPTestHarness(script, new int[]{3},
+				DebugContext.ThreadingMode.SYNCHRONOUS)) {
+			assertTrue(h.awaitStop(0, 5));
+			ScopesResponse scopeResp = h.scopes();
+			assertNotNull(scopeResp.getScopes());
+			assertTrue("Should have at least one scope",
+					scopeResp.getScopes().length >= 1);
+			int localsRef = scopeResp.getScopes()[0].getVariablesReference();
+			assertTrue("Locals scope should have a variables reference",
+					localsRef > 0);
+			VariablesResponse varResp = h.variables(localsRef);
+			assertNotNull(varResp.getVariables());
+			// Find @x and @y
+			boolean foundX = false;
+			boolean foundY = false;
+			for(org.eclipse.lsp4j.debug.Variable v : varResp.getVariables()) {
+				if("@x".equals(v.getName())) {
+					assertEquals("42", v.getValue());
+					foundX = true;
+				}
+				if("@y".equals(v.getName())) {
+					assertEquals("hello", v.getValue());
+					foundY = true;
+				}
+			}
+			assertTrue("Should find @x in variables", foundX);
+			assertTrue("Should find @y in variables", foundY);
+			h.continue_();
+			h.terminated.await(5, TimeUnit.SECONDS);
+		}
+	}
+
+	// ---- CArray expansion via variables ----
+
+	@Test
+	public void testDAPVariablesIndexedArray() throws Exception {
+		String script = "@arr = array(10, 20, 30)\n@y = 1";
+		try(DAPTestHarness h = new DAPTestHarness(script, new int[]{2},
+				DebugContext.ThreadingMode.SYNCHRONOUS)) {
+			assertTrue(h.awaitStop(0, 5));
+			ScopesResponse scopeResp = h.scopes();
+			int localsRef = scopeResp.getScopes()[0].getVariablesReference();
+			VariablesResponse varResp = h.variables(localsRef);
+			// Find @arr - it should be expandable
+			org.eclipse.lsp4j.debug.Variable arrVar = null;
+			for(org.eclipse.lsp4j.debug.Variable v : varResp.getVariables()) {
+				if("@arr".equals(v.getName())) {
+					arrVar = v;
+					break;
+				}
+			}
+			assertNotNull("Should find @arr", arrVar);
+			assertTrue("Array should be expandable",
+					arrVar.getVariablesReference() > 0);
+			// Expand the array
+			VariablesResponse children = h.variables(arrVar.getVariablesReference());
+			assertEquals("Indexed array should have 3 elements",
+					3, children.getVariables().length);
+			assertEquals("10", children.getVariables()[0].getValue());
+			assertEquals("20", children.getVariables()[1].getValue());
+			assertEquals("30", children.getVariables()[2].getValue());
+			h.continue_();
+			h.terminated.await(5, TimeUnit.SECONDS);
+		}
+	}
+
+	@Test
+	public void testDAPVariablesAssociativeArray() throws Exception {
+		String script = "@map = array(a: 'x', b: 'y')\n@z = 1";
+		try(DAPTestHarness h = new DAPTestHarness(script, new int[]{2},
+				DebugContext.ThreadingMode.SYNCHRONOUS)) {
+			assertTrue(h.awaitStop(0, 5));
+			ScopesResponse scopeResp = h.scopes();
+			int localsRef = scopeResp.getScopes()[0].getVariablesReference();
+			VariablesResponse varResp = h.variables(localsRef);
+			org.eclipse.lsp4j.debug.Variable mapVar = null;
+			for(org.eclipse.lsp4j.debug.Variable v : varResp.getVariables()) {
+				if("@map".equals(v.getName())) {
+					mapVar = v;
+					break;
+				}
+			}
+			assertNotNull("Should find @map", mapVar);
+			assertTrue("Assoc array should be expandable",
+					mapVar.getVariablesReference() > 0);
+			VariablesResponse children = h.variables(mapVar.getVariablesReference());
+			assertEquals(2, children.getVariables().length);
+			// Check keys
+			boolean foundA = false;
+			boolean foundB = false;
+			for(org.eclipse.lsp4j.debug.Variable v : children.getVariables()) {
+				if("a".equals(v.getName())) {
+					assertEquals("x", v.getValue());
+					foundA = true;
+				}
+				if("b".equals(v.getName())) {
+					assertEquals("y", v.getValue());
+					foundB = true;
+				}
+			}
+			assertTrue("Should find key 'a'", foundA);
+			assertTrue("Should find key 'b'", foundB);
+			h.continue_();
+			h.terminated.await(5, TimeUnit.SECONDS);
+		}
+	}
+
+	@Test
+	public void testDAPVariablesNestedArray() throws Exception {
+		String script = "@nested = array(array(1, 2), array(3, 4))\n@z = 1";
+		try(DAPTestHarness h = new DAPTestHarness(script, new int[]{2},
+				DebugContext.ThreadingMode.SYNCHRONOUS)) {
+			assertTrue(h.awaitStop(0, 5));
+			ScopesResponse scopeResp = h.scopes();
+			int localsRef = scopeResp.getScopes()[0].getVariablesReference();
+			VariablesResponse varResp = h.variables(localsRef);
+			org.eclipse.lsp4j.debug.Variable nestedVar = null;
+			for(org.eclipse.lsp4j.debug.Variable v : varResp.getVariables()) {
+				if("@nested".equals(v.getName())) {
+					nestedVar = v;
+					break;
+				}
+			}
+			assertNotNull("Should find @nested", nestedVar);
+			assertTrue("Nested array should be expandable",
+					nestedVar.getVariablesReference() > 0);
+			// Expand outer array
+			VariablesResponse outerChildren = h.variables(nestedVar.getVariablesReference());
+			assertEquals(2, outerChildren.getVariables().length);
+			// First element should also be expandable
+			assertTrue("Inner array should be expandable",
+					outerChildren.getVariables()[0].getVariablesReference() > 0);
+			// Expand inner array
+			VariablesResponse innerChildren = h.variables(
+					outerChildren.getVariables()[0].getVariablesReference());
+			assertEquals(2, innerChildren.getVariables().length);
+			assertEquals("1", innerChildren.getVariables()[0].getValue());
+			assertEquals("2", innerChildren.getVariables()[1].getValue());
+			h.continue_();
+			h.terminated.await(5, TimeUnit.SECONDS);
+		}
+	}
+
+	// ---- Evaluate via DAP ----
+
+	@Test
+	public void testDAPEvaluateSimple() throws Exception {
+		String script = "@x = 42\n@y = 2";
+		try(DAPTestHarness h = new DAPTestHarness(script, new int[]{2},
+				DebugContext.ThreadingMode.SYNCHRONOUS)) {
+			assertTrue(h.awaitStop(0, 5));
+			EvaluateResponse resp = h.evaluate("1 + 2");
+			assertEquals("3", resp.getResult());
+			h.continue_();
+			h.terminated.await(5, TimeUnit.SECONDS);
+		}
+	}
+
+	@Test
+	public void testDAPEvaluateVariable() throws Exception {
+		String script = "@x = 42\n@y = 2";
+		try(DAPTestHarness h = new DAPTestHarness(script, new int[]{2},
+				DebugContext.ThreadingMode.SYNCHRONOUS)) {
+			assertTrue(h.awaitStop(0, 5));
+			EvaluateResponse resp = h.evaluate("@x");
+			assertEquals("42", resp.getResult());
+			h.continue_();
+			h.terminated.await(5, TimeUnit.SECONDS);
+		}
+	}
+
+	@Test
+	public void testDAPEvaluateError() throws Exception {
+		String script = "@x = 42\n@y = 2";
+		try(DAPTestHarness h = new DAPTestHarness(script, new int[]{2},
+				DebugContext.ThreadingMode.SYNCHRONOUS)) {
+			assertTrue(h.awaitStop(0, 5));
+			// Invalid expression should return error message, not throw
+			EvaluateResponse resp = h.evaluate("this is not valid");
+			assertNotNull(resp.getResult());
+			h.continue_();
+			h.terminated.await(5, TimeUnit.SECONDS);
+		}
+	}
+
+	// ---- Exception breakpoints via DAP ----
+
+	@Test
+	public void testDAPExceptionBreakpointsAll() throws Exception {
+		String script = "@x = 1\ntry {\n\tthrow(Exception, 'test')\n} catch(Exception @e) {\n\t@y = 1\n}";
+		try(DAPTestHarness h = new DAPTestHarness(script, new int[]{1},
+				DebugContext.ThreadingMode.SYNCHRONOUS)) {
+			// Pause at line 1 first, then set exception breakpoints before
+			// the throw executes, avoiding the race condition.
+			assertTrue(h.awaitStop(0, 5));
+			h.setExceptionBreakpoints("all");
+			h.setBreakpoints(new int[]{});
+			h.continue_();
+			// The throw should cause a stop
+			assertTrue("Should break on caught exception",
+					h.awaitStop(1, 5));
+			h.continue_();
+			h.terminated.await(5, TimeUnit.SECONDS);
+		}
+	}
+
+	@Test
+	public void testDAPExceptionBreakpointsUncaught() throws Exception {
+		String script = "@x = 1\ntry {\n\tthrow(Exception, 'test')\n} catch(Exception @e) {\n\t@y = 1\n}";
+		try(DAPTestHarness h = new DAPTestHarness(script, new int[]{1},
+				DebugContext.ThreadingMode.SYNCHRONOUS)) {
+			// Pause at line 1 first, then set exception breakpoints before
+			// the throw executes, avoiding the race condition.
+			assertTrue(h.awaitStop(0, 5));
+			h.setExceptionBreakpoints("uncaught");
+			h.setBreakpoints(new int[]{});
+			h.continue_();
+			// Caught exception should NOT trigger a break with "uncaught" filter
+			// Script should complete normally
+			assertTrue("Script should complete without breaking",
+					h.terminated.await(5, TimeUnit.SECONDS));
+		}
+	}
+
+	// ---- Conditional breakpoints via DAP ----
+
+	@Test
+	public void testDAPConditionalBreakpoint() throws Exception {
+		String script = "@x = 0\nforeach(range(5), @i,\n\t@x = @x + 1\n)";
+		SourceBreakpoint sbp = new SourceBreakpoint();
+		sbp.setLine(3);
+		sbp.setCondition("@x == 3");
+		try(DAPTestHarness h = new DAPTestHarness(script, new SourceBreakpoint[]{sbp},
+				DebugContext.ThreadingMode.SYNCHRONOUS, false)) {
+			assertTrue("Should hit conditional breakpoint",
+					h.awaitStop(0, 5));
+			h.stackTrace();
+			EvaluateResponse response = h.evaluate("@x");
+			assertEquals("3", response.getResult());
+			h.continue_();
+			h.terminated.await(5, TimeUnit.SECONDS);
+		}
+	}
+
+	// ---- Hit count breakpoints via DAP ----
+
+	@Test
+	public void testDAPHitCountBreakpoint() throws Exception {
+		String script = "@x = 0\nforeach(range(5), @i,\n\t@x = @x + 1\n)";
+		SourceBreakpoint sbp = new SourceBreakpoint();
+		sbp.setLine(3);
+		sbp.setHitCondition("4");
+		try(DAPTestHarness h = new DAPTestHarness(script, new SourceBreakpoint[]{sbp},
+				DebugContext.ThreadingMode.SYNCHRONOUS, false)) {
+			assertTrue("Should hit breakpoint on 4th iteration",
+					h.awaitStop(0, 5));
+			h.stackTrace();
+			EvaluateResponse response = h.evaluate("@x");
+			assertEquals("3", response.getResult());
+			h.continue_();
+			h.terminated.await(5, TimeUnit.SECONDS);
+		}
+	}
+
+	// ---- Step in / step out via DAP ----
+
+	@Test
+	public void testDAPStepIn() throws Exception {
+		String script = "proc _greet() {\n"
+				+ "\t@msg = 'hi'\n"
+				+ "}\n"
+				+ "_greet()";
+		try(DAPTestHarness h = new DAPTestHarness(script, new int[]{4},
+				DebugContext.ThreadingMode.SYNCHRONOUS)) {
+			assertTrue(h.awaitStop(0, 5));
+			h.stepIn();
+			assertTrue("Step-in should pause inside proc",
+					h.awaitStop(1, 5));
+			// Verify we're inside the proc by checking stack trace
+			StackTraceResponse stResp = h.stackTrace();
+			org.eclipse.lsp4j.debug.StackFrame[] frames = stResp.getStackFrames();
+			assertTrue("Should have multiple frames when inside proc",
+					frames.length >= 2);
+			assertEquals("proc _greet", frames[0].getName());
+			h.continue_();
+			h.terminated.await(5, TimeUnit.SECONDS);
+		}
+	}
+
+	@Test
+	public void testDAPStepOut() throws Exception {
+		String script = "proc _inner() {\n"
+				+ "\t@a = 1\n"
+				+ "\t@b = 2\n"
+				+ "}\n"
+				+ "@before = 0\n"
+				+ "_inner()\n"
+				+ "@after = 0";
+		try(DAPTestHarness h = new DAPTestHarness(script, new int[]{2},
+				DebugContext.ThreadingMode.SYNCHRONOUS)) {
+			assertTrue(h.awaitStop(0, 5));
+			// We're inside _inner at line 2. Step out should return to caller.
+			h.stepOut();
+			assertTrue("Step-out should pause after returning from proc",
+					h.awaitStop(1, 5));
+			// Verify we're back at the top level
+			StackTraceResponse stResp = h.stackTrace();
+			org.eclipse.lsp4j.debug.StackFrame[] frames = stResp.getStackFrames();
+			assertEquals("Should be back at top level (1 frame)",
+					1, frames.length);
+			h.continue_();
+			h.terminated.await(5, TimeUnit.SECONDS);
+		}
+	}
+
+	@Test
+	public void testDAPStepInTargets() throws Exception {
+		String script = "proc _bar() {\n"
+				+ "\treturn(10)\n"
+				+ "}\n"
+				+ "proc _foo() {\n"
+				+ "\treturn(20)\n"
+				+ "}\n"
+				+ "@result = _bar() + _foo()";
+		try(DAPTestHarness h = new DAPTestHarness(script, new int[]{7},
+				DebugContext.ThreadingMode.SYNCHRONOUS)) {
+			assertTrue(h.awaitStop(0, 5));
+			StepInTargetsResponse resp = h.stepInTargets();
+			assertNotNull(resp.getTargets());
+			assertTrue("Should have at least 2 step-in targets",
+					resp.getTargets().length >= 2);
+			h.continue_();
+			h.terminated.await(5, TimeUnit.SECONDS);
+		}
+	}
+
+	// ---- Disconnect resumes execution ----
+
+	@Test
+	public void testDAPDisconnectResumesExecution() throws Exception {
+		String script = "@x = 1\n@y = 2\n@z = 3";
+		try(DAPTestHarness h = new DAPTestHarness(script, new int[]{1},
+				DebugContext.ThreadingMode.SYNCHRONOUS)) {
+			assertTrue(h.awaitStop(0, 5));
+			h.disconnect();
+			// Script should resume and complete after disconnect
+			assertTrue("Script should complete after disconnect",
+					h.terminated.await(5, TimeUnit.SECONDS));
+		}
+	}
+}
diff --git a/src/test/java/com/laytonsmith/core/MethodScriptCompilerTest.java b/src/test/java/com/laytonsmith/core/MethodScriptCompilerTest.java
index 1a34c87960..eab2aa39a9 100644
--- a/src/test/java/com/laytonsmith/core/MethodScriptCompilerTest.java
+++ b/src/test/java/com/laytonsmith/core/MethodScriptCompilerTest.java
@@ -29,7 +29,9 @@
 import org.junit.AfterClass;
 import org.junit.Before;
 import org.junit.Ignore;
+import org.junit.Rule;
 import org.junit.Test;
+import org.junit.rules.Timeout;
 
 import java.io.File;
 import java.net.URI;
@@ -63,6 +65,9 @@
 //@PowerMockIgnore({"javax.xml.parsers.*", "com.sun.org.apache.xerces.internal.jaxp.*"})
 public class MethodScriptCompilerTest extends AbstractIntegrationTest {
 
+	@Rule
+	public Timeout globalTimeout = Timeout.seconds(10);
+
 	MCServer fakeServer;
 	MCPlayer fakePlayer;
 	com.laytonsmith.core.environments.Environment env;
diff --git a/src/test/java/com/laytonsmith/core/OptimizationTest.java b/src/test/java/com/laytonsmith/core/OptimizationTest.java
index bab80532f5..7a8db75ab2 100644
--- a/src/test/java/com/laytonsmith/core/OptimizationTest.java
+++ b/src/test/java/com/laytonsmith/core/OptimizationTest.java
@@ -332,9 +332,9 @@ public void testInnerIfWithExistingAnd() throws Exception {
 
 	@Test
 	public void testForWithPostfix() throws Exception {
-		assertEquals("__statements__(for(assign(@i,0),lt(@i,5),inc(@i),msg('')))",
+		assertEquals("__statements__(forelse(assign(@i,0),lt(@i,5),inc(@i),msg(''),null))",
 				optimize("for(@i = 0, @i < 5, @i++, msg(''))"));
-		assertEquals("__statements__(for(assign(@i,0),lt(@i,5),dec(@i),msg('')))",
+		assertEquals("__statements__(forelse(assign(@i,0),lt(@i,5),dec(@i),msg(''),null))",
 				optimize("for(@i = 0, @i < 5, @i--, msg(''))"));
 	}
 
@@ -761,9 +761,9 @@ public void testSmartStringToDumbStringRewriteWithEscapes() throws Exception {
 
 	@Test
 	public void testForIsSelfStatement() throws Exception {
-		assertEquals("__statements__(for(__unsafe_assign__(ms.lang.int,@i,0),lt(@i,10),inc(@i),__statements__(msg(@i))))",
+		assertEquals("__statements__(forelse(__unsafe_assign__(ms.lang.int,@i,0),lt(@i,10),inc(@i),__statements__(msg(@i)),null))",
 				optimize("for(int @i = 0, @i < 10, @i++) { msg(@i); }"));
-		assertEquals("__statements__(while(true,__statements__(msg(''),for(__unsafe_assign__(ms.lang.int,@i,0),lt(@i,10),inc(@i),__statements__(msg(@i))))))",
+		assertEquals("__statements__(while(true,__statements__(msg(''),forelse(__unsafe_assign__(ms.lang.int,@i,0),lt(@i,10),inc(@i),__statements__(msg(@i)),null))))",
 				optimize("while(true) { msg('') for(int @i = 0, @i < 10, @i++) { msg(@i); }}"));
 	}
 
diff --git a/src/test/java/com/laytonsmith/core/constructs/CFixedArrayTest.java b/src/test/java/com/laytonsmith/core/constructs/CFixedArrayTest.java
index 0432151cfe..c217b9a26e 100644
--- a/src/test/java/com/laytonsmith/core/constructs/CFixedArrayTest.java
+++ b/src/test/java/com/laytonsmith/core/constructs/CFixedArrayTest.java
@@ -34,7 +34,7 @@ public void testBasic1() {
 		assertEquals(10, fa.size());
 		assertEquals(false, fa.canBeAssociative());
 		assertEquals(CNull.NULL, fa.get(0, Target.UNKNOWN));
-		fa.set(0, new CInt(10, Target.UNKNOWN), Target.UNKNOWN);
+		fa.set(0, new CInt(10, Target.UNKNOWN), Target.UNKNOWN, null);
 		assertEquals(10, ((CInt) fa.get(0, Target.UNKNOWN)).val);
 	}
 }
diff --git a/src/test/java/com/laytonsmith/core/functions/ArrayHandlingTest.java b/src/test/java/com/laytonsmith/core/functions/ArrayHandlingTest.java
index d72a113913..69d0c2b820 100644
--- a/src/test/java/com/laytonsmith/core/functions/ArrayHandlingTest.java
+++ b/src/test/java/com/laytonsmith/core/functions/ArrayHandlingTest.java
@@ -64,7 +64,7 @@ public void testDocs() {
 	public void testArraySize() throws Exception, CancelCommandException {
 		ArrayHandling.array_size a = new ArrayHandling.array_size();
 		CArray arr = commonArray;
-		Mixed ret = a.exec(Target.UNKNOWN, env, arr);
+		Mixed ret = a.exec(Target.UNKNOWN, env, null, arr);
 		assertReturn(ret, C.INT);
 		assertCEquals(C.onstruct(3), ret);
 	}
@@ -72,7 +72,7 @@ public void testArraySize() throws Exception, CancelCommandException {
 	@Test(expected = Exception.class, timeout = 10000)
 	public void testArraySizeEx() throws CancelCommandException {
 		ArrayHandling.array_size a = new ArrayHandling.array_size();
-		a.exec(Target.UNKNOWN, env, C.Int(0));
+		a.exec(Target.UNKNOWN, env, null, C.Int(0));
 	}
 
 	@Test//(timeout = 10000)
@@ -121,46 +121,46 @@ public void testArrayReferenceBeingCorrectWithArrayGet() throws Exception {
 	@Test(timeout = 10000)
 	public void testArrayContains() throws CancelCommandException {
 		ArrayHandling.array_contains a = new ArrayHandling.array_contains();
-		assertCEquals(C.onstruct(true), a.exec(Target.UNKNOWN, env, commonArray, C.onstruct(1)));
-		assertCEquals(C.onstruct(false), a.exec(Target.UNKNOWN, env, commonArray, C.onstruct(55)));
+		assertCEquals(C.onstruct(true), a.exec(Target.UNKNOWN, env, null, commonArray, C.onstruct(1)));
+		assertCEquals(C.onstruct(false), a.exec(Target.UNKNOWN, env, null, commonArray, C.onstruct(55)));
 	}
 
 	@Test(timeout = 10000)
 	public void testArraySContains() throws CancelCommandException {
 		ArrayHandling.array_scontains a = new ArrayHandling.array_scontains();
-		assertCEquals(C.onstruct(true), a.exec(Target.UNKNOWN, env, commonArray, C.onstruct(1)));
-		assertCEquals(C.onstruct(false), a.exec(Target.UNKNOWN, env, commonArray, C.onstruct(55)));
-		assertCEquals(C.onstruct(false), a.exec(Target.UNKNOWN, env, commonArray, new CString("2", Target.UNKNOWN)));
+		assertCEquals(C.onstruct(true), a.exec(Target.UNKNOWN, env, null, commonArray, C.onstruct(1)));
+		assertCEquals(C.onstruct(false), a.exec(Target.UNKNOWN, env, null, commonArray, C.onstruct(55)));
+		assertCEquals(C.onstruct(false), a.exec(Target.UNKNOWN, env, null, commonArray, new CString("2", Target.UNKNOWN)));
 	}
 
 	@Test(expected = Exception.class, timeout = 10000)
 	public void testArrayContainsEx() throws CancelCommandException {
 		ArrayHandling.array_contains a = new ArrayHandling.array_contains();
-		a.exec(Target.UNKNOWN, env, C.Int(0), C.Int(1));
+		a.exec(Target.UNKNOWN, env, null, C.Int(0), C.Int(1));
 	}
 
 	@Test(timeout = 10000)
 	public void testArrayGet() throws CancelCommandException {
 		ArrayHandling.array_get a = new ArrayHandling.array_get();
-		assertCEquals(C.onstruct(1), a.exec(Target.UNKNOWN, env, commonArray, C.onstruct(0)));
+		assertCEquals(C.onstruct(1), a.exec(Target.UNKNOWN, env, null, commonArray, C.onstruct(0)));
 	}
 
 	@Test(expected = Exception.class, timeout = 10000)
 	public void testArrayGetEx() throws CancelCommandException {
 		ArrayHandling.array_get a = new ArrayHandling.array_get();
-		a.exec(Target.UNKNOWN, env, C.Int(0), C.Int(1));
+		a.exec(Target.UNKNOWN, env, null, C.Int(0), C.Int(1));
 	}
 
 	@Test(expected = ConfigRuntimeException.class, timeout = 10000)
 	public void testArrayGetBad() throws CancelCommandException {
 		ArrayHandling.array_get a = new ArrayHandling.array_get();
-		a.exec(Target.UNKNOWN, env, commonArray, C.onstruct(55));
+		a.exec(Target.UNKNOWN, env, null, commonArray, C.onstruct(55));
 	}
 
 	@Test(timeout = 10000)
 	public void testArrayPush() throws CancelCommandException {
 		ArrayHandling.array_push a = new ArrayHandling.array_push();
-		assertReturn(a.exec(Target.UNKNOWN, env, commonArray, C.onstruct(4)), C.VOID);
+		assertReturn(a.exec(Target.UNKNOWN, env, null, commonArray, C.onstruct(4)), C.VOID);
 		assertCEquals(C.onstruct(1), commonArray.get(0, Target.UNKNOWN));
 		assertCEquals(C.onstruct(2), commonArray.get(1, Target.UNKNOWN));
 		assertCEquals(C.onstruct(3), commonArray.get(2, Target.UNKNOWN));
@@ -178,7 +178,7 @@ public void testArrayPush2() throws Exception {
 	@Test(expected = Exception.class)
 	public void testArrayPushEx() throws CancelCommandException {
 		ArrayHandling.array_push a = new ArrayHandling.array_push();
-		a.exec(Target.UNKNOWN, env, C.Int(0), C.Int(1));
+		a.exec(Target.UNKNOWN, env, null, C.Int(0), C.Int(1));
 	}
 
 	@Test(timeout = 10000)
@@ -301,6 +301,30 @@ public void testAssociativeArraySort() throws Exception {
 		verify(fakePlayer).sendMessage("{1, 002, 03}");
 	}
 
+	@Test
+	public void testArraySortCustomClosure() throws Exception {
+		Run("@a = array(3, 1, 4, 1, 5, 9);\n"
+				+ "array_sort(@a, closure(@l, @r){ return(@l - @r); });\n"
+				+ "msg(@a);", fakePlayer);
+		verify(fakePlayer).sendMessage("{1, 1, 3, 4, 5, 9}");
+	}
+
+	@Test
+	public void testArraySortCustomClosureReverse() throws Exception {
+		Run("@a = array(3, 1, 4, 1, 5, 9);\n"
+				+ "array_sort(@a, closure(@l, @r){ return(@r - @l); });\n"
+				+ "msg(@a);", fakePlayer);
+		verify(fakePlayer).sendMessage("{9, 5, 4, 3, 1, 1}");
+	}
+
+	@Test
+	public void testArraySortCustomClosureBoolean() throws Exception {
+		Run("@a = array(5, 2, 8, 1);\n"
+				+ "array_sort(@a, closure(@l, @r){ return(@l > @r); });\n"
+				+ "msg(@a);", fakePlayer);
+		verify(fakePlayer).sendMessage("{1, 2, 5, 8}");
+	}
+
 	@Test
 	public void testArrayImplode1() throws Exception {
 		Run("msg(array_implode(array(1,2,3,4,5,6,7,8,9,1,2,3,4,5)))", fakePlayer);
@@ -518,6 +542,51 @@ public void testArrayMap() throws Exception {
 		verify(fakePlayer).sendMessage("{1, 16, 64}");
 	}
 
+	@Test
+	public void testArrayFilterNormal() throws Exception {
+		Run("@array = array(1, 2, 3, 4, 5);\n"
+				+ "@odds = array_filter(@array, closure(@key, @value){\n"
+				+ "\treturn(@value % 2 == 1);\n"
+				+ "});\n"
+				+ "msg(@odds);", fakePlayer);
+		verify(fakePlayer).sendMessage("{1, 3, 5}");
+	}
+
+	@Test
+	public void testArrayFilterAssociative() throws Exception {
+		Run("@array = array(a: 1, b: 2, c: 3);\n"
+				+ "@result = array_filter(@array, closure(@key, @value){\n"
+				+ "\treturn(@value > 1);\n"
+				+ "});\n"
+				+ "msg(@result);", fakePlayer);
+		verify(fakePlayer).sendMessage("{b: 2, c: 3}");
+	}
+
+	@Test
+	public void testArrayFilterEmpty() throws Exception {
+		Run("@array = array();\n"
+				+ "@result = array_filter(@array, closure(@key, @value){\n"
+				+ "\treturn(true);\n"
+				+ "});\n"
+				+ "msg(@result);", fakePlayer);
+		verify(fakePlayer).sendMessage("{}");
+	}
+
+	@Test
+	public void testArrayReduceEmpty() throws Exception {
+		assertEquals("null", SRun("array_reduce(array(), closure(@a, @b){ return(@a + @b); })", fakePlayer));
+	}
+
+	@Test
+	public void testArrayReduceSingle() throws Exception {
+		assertEquals("5", SRun("array_reduce(array(5), closure(@a, @b){ return(@a + @b); })", fakePlayer));
+	}
+
+	@Test
+	public void testArrayReduceRightSingle() throws Exception {
+		assertEquals("5", SRun("array_reduce_right(array(5), closure(@a, @b){ return(@a + @b); })", fakePlayer));
+	}
+
 	@Test
 	public void testArrayReverse() throws Exception {
 		Run("@array = array(1, 2, 3, 4);\n"
@@ -557,6 +626,38 @@ public void testArrayIntersect() throws Exception {
 
 	}
 
+	@Test
+	public void testArraySubtractHash() throws Exception {
+		assertThat(SRun("array_subtract(array(1, 2, 3, 4), array(2, 4))", fakePlayer), is("{1, 3}"));
+	}
+
+	@Test
+	public void testArraySubtractEquals() throws Exception {
+		assertThat(SRun("array_subtract(array(1, 2, 3), array(2, 3, 4), 'EQUALS')", fakePlayer), is("{1}"));
+	}
+
+	@Test
+	public void testArraySubtractAssociative() throws Exception {
+		assertThat(SRun("array_subtract(array(a: 1, b: 2, c: 3), array(b: 99, d: 4))", fakePlayer), is("{a: 1, c: 3}"));
+	}
+
+	@Test
+	public void testArraySubtractClosure() throws Exception {
+		assertThat(SRun("array_subtract(array(1, 2, 3, 4), array(10, 20), closure(@a, @b){ return(@a * 10 == @b); })",
+				fakePlayer), is("{3, 4}"));
+	}
+
+	@Test
+	public void testArraySubtractNoOverlap() throws Exception {
+		assertThat(SRun("array_subtract(array(1, 2, 3), array(4, 5, 6))", fakePlayer), is("{1, 2, 3}"));
+	}
+
+	@Test
+	public void testArrayIntersectClosurePartial() throws Exception {
+		assertThat(SRun("array_intersect(array(1, 2, 3, 4), array(10, 30), closure(@a, @b){ return(@a * 10 == @b); })",
+				fakePlayer), is("{1, 3}"));
+	}
+
 	@Test
 	public void testMapImplode() throws Exception {
 		assertThat(SRun("map_implode(array('a': 'b'), '=', '&')", null), is("a=b"));
diff --git a/src/test/java/com/laytonsmith/core/functions/BasicLogicTest.java b/src/test/java/com/laytonsmith/core/functions/BasicLogicTest.java
index 5fc508e83c..396e293112 100644
--- a/src/test/java/com/laytonsmith/core/functions/BasicLogicTest.java
+++ b/src/test/java/com/laytonsmith/core/functions/BasicLogicTest.java
@@ -205,48 +205,48 @@ public void testOr2() throws Exception {
 	@Test(timeout = 10000)
 	public void testNot() throws CancelCommandException {
 		BasicLogic.not a = new BasicLogic.not();
-		assertCFalse(a.exec(Target.UNKNOWN, env, cTrue));
-		assertCTrue(a.exec(Target.UNKNOWN, env, cFalse));
+		assertCFalse(a.exec(Target.UNKNOWN, env, null, cTrue));
+		assertCTrue(a.exec(Target.UNKNOWN, env, null, cFalse));
 	}
 
 	@Test(timeout = 10000)
 	public void testGt() throws CancelCommandException {
 		BasicLogic.gt a = new BasicLogic.gt();
-		assertCFalse(a.exec(Target.UNKNOWN, env, argOne, argOne2));
-		assertCTrue(a.exec(Target.UNKNOWN, env, argTwo, argOne));
-		assertCFalse(a.exec(Target.UNKNOWN, env, argOne, argTwo));
-		assertCFalse(a.exec(Target.UNKNOWN, env, argNegOne, argOne));
-		assertCTrue(a.exec(Target.UNKNOWN, env, argOne, argNegOne));
+		assertCFalse(a.exec(Target.UNKNOWN, env, null, argOne, argOne2));
+		assertCTrue(a.exec(Target.UNKNOWN, env, null, argTwo, argOne));
+		assertCFalse(a.exec(Target.UNKNOWN, env, null, argOne, argTwo));
+		assertCFalse(a.exec(Target.UNKNOWN, env, null, argNegOne, argOne));
+		assertCTrue(a.exec(Target.UNKNOWN, env, null, argOne, argNegOne));
 	}
 
 	@Test(timeout = 10000)
 	public void testGte() throws CancelCommandException {
 		BasicLogic.gte a = new BasicLogic.gte();
-		assertCTrue(a.exec(Target.UNKNOWN, env, argOne, argOne2));
-		assertCTrue(a.exec(Target.UNKNOWN, env, argTwo, argOne));
-		assertCFalse(a.exec(Target.UNKNOWN, env, argOne, argTwo));
-		assertCFalse(a.exec(Target.UNKNOWN, env, argNegOne, argOne));
-		assertCTrue(a.exec(Target.UNKNOWN, env, argOne, argNegOne));
+		assertCTrue(a.exec(Target.UNKNOWN, env, null, argOne, argOne2));
+		assertCTrue(a.exec(Target.UNKNOWN, env, null, argTwo, argOne));
+		assertCFalse(a.exec(Target.UNKNOWN, env, null, argOne, argTwo));
+		assertCFalse(a.exec(Target.UNKNOWN, env, null, argNegOne, argOne));
+		assertCTrue(a.exec(Target.UNKNOWN, env, null, argOne, argNegOne));
 	}
 
 	@Test(timeout = 10000)
 	public void testLt() throws CancelCommandException {
 		BasicLogic.lt a = new BasicLogic.lt();
-		assertCFalse(a.exec(Target.UNKNOWN, env, argOne, argOne2));
-		assertCFalse(a.exec(Target.UNKNOWN, env, argTwo, argOne));
-		assertCTrue(a.exec(Target.UNKNOWN, env, argOne, argTwo));
-		assertCTrue(a.exec(Target.UNKNOWN, env, argNegOne, argOne));
-		assertCFalse(a.exec(Target.UNKNOWN, env, argOne, argNegOne));
+		assertCFalse(a.exec(Target.UNKNOWN, env, null, argOne, argOne2));
+		assertCFalse(a.exec(Target.UNKNOWN, env, null, argTwo, argOne));
+		assertCTrue(a.exec(Target.UNKNOWN, env, null, argOne, argTwo));
+		assertCTrue(a.exec(Target.UNKNOWN, env, null, argNegOne, argOne));
+		assertCFalse(a.exec(Target.UNKNOWN, env, null, argOne, argNegOne));
 	}
 
 	@Test(timeout = 10000)
 	public void testLte() throws CancelCommandException {
 		BasicLogic.lte a = new BasicLogic.lte();
-		assertCTrue(a.exec(Target.UNKNOWN, env, argOne, argOne2));
-		assertCFalse(a.exec(Target.UNKNOWN, env, argTwo, argOne));
-		assertCTrue(a.exec(Target.UNKNOWN, env, argOne, argTwo));
-		assertCTrue(a.exec(Target.UNKNOWN, env, argNegOne, argOne));
-		assertCFalse(a.exec(Target.UNKNOWN, env, argOne, argNegOne));
+		assertCTrue(a.exec(Target.UNKNOWN, env, null, argOne, argOne2));
+		assertCFalse(a.exec(Target.UNKNOWN, env, null, argTwo, argOne));
+		assertCTrue(a.exec(Target.UNKNOWN, env, null, argOne, argTwo));
+		assertCTrue(a.exec(Target.UNKNOWN, env, null, argNegOne, argOne));
+		assertCFalse(a.exec(Target.UNKNOWN, env, null, argOne, argNegOne));
 	}
 
 	@Test(timeout = 10000)
@@ -399,6 +399,11 @@ public void testDor2() throws Exception {
 		verify(fakePlayer).sendMessage("null");
 	}
 
+	@Test(expected = ConfigCompileException.class)
+	public void testDor3() throws Exception {
+		SRun("dor()", fakePlayer);
+	}
+
 	@Test
 	public void testDand() throws Exception {
 		SRun("msg(typeof(dand('a', 'b', false)))", fakePlayer);
diff --git a/src/test/java/com/laytonsmith/core/functions/ControlFlowTest.java b/src/test/java/com/laytonsmith/core/functions/ControlFlowTest.java
index 609059bd77..8685b554dc 100644
--- a/src/test/java/com/laytonsmith/core/functions/ControlFlowTest.java
+++ b/src/test/java/com/laytonsmith/core/functions/ControlFlowTest.java
@@ -160,7 +160,7 @@ public void testFor2() throws Exception {
 		SRun(script, fakePlayer);
 	}
 
-	@Test(timeout = 10000)
+	@Test//(timeout = 10000)
 	public void testForeach1() throws Exception {
 		String config = "/for = >>>\n"
 				+ " assign(@array, array(1, 2, 3, 4, 5))\n"
@@ -174,7 +174,7 @@ public void testForeach1() throws Exception {
 		verify(fakePlayer).sendMessage("{1, 2, 3, 4, 5}");
 	}
 
-	@Test(timeout = 10000)
+	@Test//(timeout = 10000)
 	public void testForeach2() throws Exception {
 		String config = "/for = >>>\n"
 				+ " assign(@array, array(1, 2, 3, 4, 5))\n"
@@ -360,4 +360,27 @@ public void testDoWhile() throws Exception {
 		SRun("assign(@i, 2) dowhile(@i-- msg('hi'), @i > 0)", fakePlayer);
 		verify(fakePlayer, times(2)).sendMessage("hi");
 	}
+
+	@Test(timeout = 10000)
+	public void testWhileContinueN() throws Exception {
+		// continue(2) skips 2 iterations, each of which evaluates the condition.
+		// Iteration 1: @i-- returns 3 (truthy, @i=2), body runs, msg('hi'), continue(2)
+		// Skip 1: @i-- returns 2 (truthy, @i=1), still skipping
+		// Skip 2: @i-- returns 1 (truthy, @i=0), done skipping, enter body, msg('hi'), continue(2)
+		// Skip 1: @i-- returns 0 (falsy), loop ends
+		SRun("@i = 3; while(@i--) { msg('hi'); continue(2); }", fakePlayer);
+		verify(fakePlayer, times(2)).sendMessage("hi");
+	}
+
+	@Test(timeout = 10000)
+	public void testDoWhileContinueN() throws Exception {
+		// dowhile runs body first, then checks condition.
+		// Body 1: msg('hi'), continue(2)
+		// Skip 1: @i-- returns 2 (truthy, @i=1), still skipping
+		// Skip 2: @i-- returns 1 (truthy, @i=0), done skipping, enter body
+		// Body 2: msg('hi'), continue(2)
+		// Skip 1: @i-- returns 0 (falsy), loop ends
+		SRun("@i = 3; do { msg('hi'); continue(2); } while(@i--);", fakePlayer);
+		verify(fakePlayer, times(2)).sendMessage("hi");
+	}
 }
diff --git a/src/test/java/com/laytonsmith/core/functions/DataHandlingTest.java b/src/test/java/com/laytonsmith/core/functions/DataHandlingTest.java
index acfb5044ab..6e1ce43554 100644
--- a/src/test/java/com/laytonsmith/core/functions/DataHandlingTest.java
+++ b/src/test/java/com/laytonsmith/core/functions/DataHandlingTest.java
@@ -86,7 +86,7 @@ public void testInclude() throws Exception {
 		File test = new File("unit_test_inc.ms");
 		FileUtil.write("msg('hello')", test);
 		MethodScriptCompiler.execute(MethodScriptCompiler.compile(MethodScriptCompiler
-				.lex(script, null, new File("./script.txt"), true), null, envs), env, null, null, null);
+				.lex(script, null, new File("./script.txt"), true), null, envs), env, null, null);
 		verify(fakePlayer).sendMessage("hello");
 		//delete the test file
 		test.delete();
@@ -340,6 +340,27 @@ public void testClosureReturnsFromExecute() throws Exception {
 		assertEquals("3", SRun("execute(closure(return(3)))", fakePlayer));
 	}
 
+	@Test
+	public void testExecuteArray() throws Exception {
+		assertEquals("3", SRun("execute_array(array(1, 2), closure(@a, @b){ return(@a + @b); })", fakePlayer));
+	}
+
+	@Test
+	public void testExecuteArrayEmpty() throws Exception {
+		assertEquals("hello", SRun("execute_array(array(), closure(){ return('hello'); })", fakePlayer));
+	}
+
+	@Test
+	public void testExecuteasRestoresContext() throws Exception {
+		MCPlayer fakePlayer2 = StaticTest.GetOnlinePlayer("Player02", fakeServer);
+		when(fakeServer.getPlayer("Player02")).thenReturn(fakePlayer2);
+		SRun("@c = closure(){msg(player())};\n"
+				+ "executeas('Player02', null, @c);\n"
+				+ "msg(player());", fakePlayer);
+		verify(fakePlayer2).sendMessage("Player02");
+		verify(fakePlayer).sendMessage(fakePlayer.getName());
+	}
+
 	@Test
 	public void testEmptyClosureFunction() throws Exception {
 		// This should not throw an exception
diff --git a/src/test/java/com/laytonsmith/core/functions/EchoesTest.java b/src/test/java/com/laytonsmith/core/functions/EchoesTest.java
index 5bcf2f94d6..03e1a2e0ea 100644
--- a/src/test/java/com/laytonsmith/core/functions/EchoesTest.java
+++ b/src/test/java/com/laytonsmith/core/functions/EchoesTest.java
@@ -68,7 +68,7 @@ public void testDocs() {
 	@Test(timeout = 10000)
 	public void testChat() throws CancelCommandException {
 		Echoes.chat a = new Echoes.chat();
-		a.exec(Target.UNKNOWN, env, C.onstruct("Hello World!"));
+		a.exec(Target.UNKNOWN, env, null, C.onstruct("Hello World!"));
 		verify(fakePlayer).chat("Hello World!");
 	}
 
@@ -78,7 +78,7 @@ public void testBroadcast() throws NoSuchFieldException, InstantiationException,
 		Echoes.broadcast a = new Echoes.broadcast();
 		when(fakePlayer.getServer()).thenReturn(fakeServer);
 		CommandHelperPlugin.myServer = fakeServer;
-		a.exec(Target.UNKNOWN, env, C.onstruct("Hello World!"));
+		a.exec(Target.UNKNOWN, env, null, C.onstruct("Hello World!"));
 		verify(fakeServer).broadcastMessage("Hello World!");
 	}
 
@@ -130,7 +130,7 @@ public void testRGBColor() throws Exception {
 	}
 
 	private static final String LOWERCASE_A =
-			new color().exec(Target.UNKNOWN, null, new CString("a", Target.UNKNOWN)).val();
+			new color().exec(Target.UNKNOWN, null, null, new CString("a", Target.UNKNOWN)).val();
 
 	@Test
 	public void testColorize1() throws Exception {
@@ -164,7 +164,7 @@ public void testColorize6() throws Exception {
 
 	@Test
 	public void testColorizeRGB() throws Exception {
-		String expectedColor = new color().exec(Target.UNKNOWN, null, new CString("#ff11aa", Target.UNKNOWN)).val();
+		String expectedColor = new color().exec(Target.UNKNOWN, null, null, new CString("#ff11aa", Target.UNKNOWN)).val();
 		assertEquals(expectedColor + "Hi", SRun("colorize('&#ff11aaHi', '&')", fakePlayer));
 	}
 
diff --git a/src/test/java/com/laytonsmith/core/functions/EventBindingTest.java b/src/test/java/com/laytonsmith/core/functions/EventBindingTest.java
new file mode 100644
index 0000000000..a377b929e5
--- /dev/null
+++ b/src/test/java/com/laytonsmith/core/functions/EventBindingTest.java
@@ -0,0 +1,100 @@
+package com.laytonsmith.core.functions;
+
+import com.laytonsmith.abstraction.MCPlayer;
+import com.laytonsmith.core.Static;
+import com.laytonsmith.core.events.EventUtils;
+import com.laytonsmith.core.exceptions.CRE.CRECastException;
+import com.laytonsmith.core.exceptions.ConfigCompileException;
+import com.laytonsmith.testing.AbstractIntegrationTest;
+import com.laytonsmith.testing.StaticTest;
+import static com.laytonsmith.testing.StaticTest.SRun;
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
+
+import static org.junit.Assert.assertNotNull;
+import static org.mockito.Mockito.verify;
+
+public class EventBindingTest extends AbstractIntegrationTest {
+
+	MCPlayer fakePlayer;
+
+	@Before
+	public void setUp() throws Exception {
+		fakePlayer = StaticTest.GetOnlinePlayer();
+		StaticTest.InstallFakeConvertor(fakePlayer);
+		Static.InjectPlayer(fakePlayer);
+	}
+
+	@After
+	public void tearDown() {
+		EventUtils.UnregisterAll();
+	}
+
+	@Test
+	public void testBindReturnsId() throws Exception {
+		SRun("assign(@id, bind('shutdown', null, null, @event, msg('hi')))\n"
+				+ "msg(is_string(@id))", fakePlayer);
+		verify(fakePlayer).sendMessage("true");
+	}
+
+	@Test
+	public void testBindRegistersEvent() throws Exception {
+		SRun("bind('shutdown', array(id: 'testRegisters'), null, @event, msg('hi'))", fakePlayer);
+		assertNotNull(EventUtils.GetEventById("testRegisters"));
+	}
+
+	@Test
+	public void testBindWithOptions() throws Exception {
+		String id = SRun("bind('shutdown', array(id: 'myid', priority: 'NORMAL'), null, @event, msg('hi'))", fakePlayer);
+		assertNotNull(EventUtils.GetEventById("myid"));
+	}
+
+	@Test
+	public void testBindWithCustomParams() throws Exception {
+		SRun("assign(@x, 'captured')\n"
+				+ "bind('shutdown', array(id: 'customTest'), null, @event, @x, msg(@x))", fakePlayer);
+		assertNotNull(EventUtils.GetEventById("customTest"));
+	}
+
+	@Test
+	public void testBindMultiple() throws Exception {
+		String id1 = SRun("bind('shutdown', array(id: 'first'), null, @event, msg('a'))", fakePlayer);
+		String id2 = SRun("bind('shutdown', array(id: 'second'), null, @event, msg('b'))", fakePlayer);
+		assertNotNull(EventUtils.GetEventById("first"));
+		assertNotNull(EventUtils.GetEventById("second"));
+	}
+
+	@Test(expected = ConfigCompileException.class)
+	public void testBindInvalidEvent() throws Exception {
+		SRun("bind('not_a_real_event', null, null, @event, msg('hi'))", fakePlayer);
+	}
+
+	@Test(expected = ConfigCompileException.class)
+	public void testBindTooFewArgs() throws Exception {
+		SRun("bind('shutdown', null, null)", fakePlayer);
+	}
+
+	@Test(expected = CRECastException.class)
+	public void testBindBadOptionsType() throws Exception {
+		SRun("bind('shutdown', 'bad', null, @event, msg('hi'))", fakePlayer);
+	}
+
+	@Test(expected = CRECastException.class)
+	public void testBindBadPrefilterType() throws Exception {
+		SRun("bind('shutdown', null, 'bad', @event, msg('hi'))", fakePlayer);
+	}
+
+	@Test
+	public void testBindResultUsedInMsg() throws Exception {
+		SRun("assign(@id, bind('shutdown', null, null, @event, msg('hi')))\n"
+				+ "msg(is_string(@id))", fakePlayer);
+		verify(fakePlayer).sendMessage("true");
+	}
+
+	@Test
+	public void testUnbindAfterBind() throws Exception {
+		SRun("assign(@id, bind('shutdown', null, null, @event, msg('hi')))\n"
+				+ "unbind(@id)", fakePlayer);
+	}
+}
diff --git a/src/test/java/com/laytonsmith/core/functions/MathTest.java b/src/test/java/com/laytonsmith/core/functions/MathTest.java
index a65e637e11..2ef7e9d1f7 100644
--- a/src/test/java/com/laytonsmith/core/functions/MathTest.java
+++ b/src/test/java/com/laytonsmith/core/functions/MathTest.java
@@ -74,28 +74,28 @@ public void tearDown() {
 	@Test(timeout = 10000)
 	public void testAbs() {
 		Math.abs a = new Math.abs();
-		assertCEquals(C.onstruct(5), a.exec(Target.UNKNOWN, env, C.onstruct(5)));
-		assertCEquals(C.onstruct(3), a.exec(Target.UNKNOWN, env, C.onstruct(-3)));
-		assertCEquals(C.onstruct(0), a.exec(Target.UNKNOWN, env, C.onstruct(0)));
-		assertCEquals(C.onstruct(3.5), a.exec(Target.UNKNOWN, env, C.onstruct(-3.5)));
+		assertCEquals(C.onstruct(5), a.exec(Target.UNKNOWN, env, null, C.onstruct(5)));
+		assertCEquals(C.onstruct(3), a.exec(Target.UNKNOWN, env, null, C.onstruct(-3)));
+		assertCEquals(C.onstruct(0), a.exec(Target.UNKNOWN, env, null, C.onstruct(0)));
+		assertCEquals(C.onstruct(3.5), a.exec(Target.UNKNOWN, env, null, C.onstruct(-3.5)));
 	}
 
 	@Test(timeout = 10000)
 	public void testAdd() {
 		Math.add a = new Math.add();
-		assertCEquals(C.onstruct(7), a.exec(Target.UNKNOWN, env, C.onstruct(5), C.onstruct(2)));
-		assertCEquals(C.onstruct(6), a.exec(Target.UNKNOWN, env, C.onstruct(3), C.onstruct(3)));
-		assertCEquals(C.onstruct(-4), a.exec(Target.UNKNOWN, env, C.onstruct(-3), C.onstruct(-1)));
-		assertCEquals(C.onstruct(1), a.exec(Target.UNKNOWN, env, C.onstruct(1), C.onstruct(0)));
-		assertCEquals(C.onstruct(562949953421310L), a.exec(Target.UNKNOWN, env, C.onstruct(281474976710655L), C.onstruct(281474976710655L)));
-		assertCEquals(C.onstruct(3.1415), a.exec(Target.UNKNOWN, env, C.onstruct(3), C.onstruct(0.1415)));
+		assertCEquals(C.onstruct(7), a.exec(Target.UNKNOWN, env, null, C.onstruct(5), C.onstruct(2)));
+		assertCEquals(C.onstruct(6), a.exec(Target.UNKNOWN, env, null, C.onstruct(3), C.onstruct(3)));
+		assertCEquals(C.onstruct(-4), a.exec(Target.UNKNOWN, env, null, C.onstruct(-3), C.onstruct(-1)));
+		assertCEquals(C.onstruct(1), a.exec(Target.UNKNOWN, env, null, C.onstruct(1), C.onstruct(0)));
+		assertCEquals(C.onstruct(562949953421310L), a.exec(Target.UNKNOWN, env, null, C.onstruct(281474976710655L), C.onstruct(281474976710655L)));
+		assertCEquals(C.onstruct(3.1415), a.exec(Target.UNKNOWN, env, null, C.onstruct(3), C.onstruct(0.1415)));
 	}
 
 	@Test(timeout = 10000)
 	public void testDec() throws Exception {
 		Math.dec a = new Math.dec();
-		IVariable v = (IVariable) a.exec(Target.UNKNOWN, env, new IVariable(Auto.TYPE, "var", C.onstruct(1), Target.UNKNOWN, env));
-		IVariable v2 = (IVariable) a.exec(Target.UNKNOWN, env, new IVariable(Auto.TYPE, "var2", C.onstruct(2.5), Target.UNKNOWN, env));
+		IVariable v = (IVariable) a.exec(Target.UNKNOWN, env, null, new IVariable(Auto.TYPE, "var", C.onstruct(1), Target.UNKNOWN, env));
+		IVariable v2 = (IVariable) a.exec(Target.UNKNOWN, env, null, new IVariable(Auto.TYPE, "var2", C.onstruct(2.5), Target.UNKNOWN, env));
 		assertCEquals(C.onstruct(0), v.ival());
 		assertCEquals(C.onstruct(1.5), v2.ival());
 		StaticTest.SRun("assign(@var, 0) dec(@var, 2) msg(@var)", fakePlayer);
@@ -105,16 +105,16 @@ public void testDec() throws Exception {
 	@Test(timeout = 10000)
 	public void testDivide() {
 		Math.divide a = new Math.divide();
-		assertCEquals(C.onstruct(2.5), a.exec(Target.UNKNOWN, env, C.onstruct(5), C.onstruct(2)));
-		assertCEquals(C.onstruct(1), a.exec(Target.UNKNOWN, env, C.onstruct(3), C.onstruct(3)));
-		assertCEquals(C.onstruct(3), a.exec(Target.UNKNOWN, env, C.onstruct(-3), C.onstruct(-1)));
+		assertCEquals(C.onstruct(2.5), a.exec(Target.UNKNOWN, env, null, C.onstruct(5), C.onstruct(2)));
+		assertCEquals(C.onstruct(1), a.exec(Target.UNKNOWN, env, null, C.onstruct(3), C.onstruct(3)));
+		assertCEquals(C.onstruct(3), a.exec(Target.UNKNOWN, env, null, C.onstruct(-3), C.onstruct(-1)));
 	}
 
 	@Test(timeout = 10000)
 	public void testInc() throws Exception {
 		Math.inc a = new Math.inc();
-		IVariable v = (IVariable) a.exec(Target.UNKNOWN, env, new IVariable(Auto.TYPE, "var", C.onstruct(1), Target.UNKNOWN, env));
-		IVariable v2 = (IVariable) a.exec(Target.UNKNOWN, env, new IVariable(Auto.TYPE, "var2", C.onstruct(2.5), Target.UNKNOWN, env));
+		IVariable v = (IVariable) a.exec(Target.UNKNOWN, env, null, new IVariable(Auto.TYPE, "var", C.onstruct(1), Target.UNKNOWN, env));
+		IVariable v2 = (IVariable) a.exec(Target.UNKNOWN, env, null, new IVariable(Auto.TYPE, "var2", C.onstruct(2.5), Target.UNKNOWN, env));
 		assertCEquals(C.onstruct(2), v.ival());
 		assertCEquals(C.onstruct(3.5), v2.ival());
 		StaticTest.SRun("assign(@var, 0) inc(@var, 2) msg(@var)", fakePlayer);
@@ -130,50 +130,50 @@ public void testArrayGetInc() throws Exception {
 	@Test(timeout = 10000)
 	public void testMod() {
 		Math.mod a = new Math.mod();
-		assertCEquals(C.onstruct(1), a.exec(Target.UNKNOWN, env, C.onstruct(5), C.onstruct(2)));
-		assertCEquals(C.onstruct(0), a.exec(Target.UNKNOWN, env, C.onstruct(3), C.onstruct(3)));
-		assertCEquals(C.onstruct(-1), a.exec(Target.UNKNOWN, env, C.onstruct(-3), C.onstruct(-2)));
+		assertCEquals(C.onstruct(1), a.exec(Target.UNKNOWN, env, null, C.onstruct(5), C.onstruct(2)));
+		assertCEquals(C.onstruct(0), a.exec(Target.UNKNOWN, env, null, C.onstruct(3), C.onstruct(3)));
+		assertCEquals(C.onstruct(-1), a.exec(Target.UNKNOWN, env, null, C.onstruct(-3), C.onstruct(-2)));
 	}
 
 	@Test(timeout = 10000)
 	public void testMultiply() {
 		Math.multiply a = new Math.multiply();
-		assertCEquals(C.onstruct(10), a.exec(Target.UNKNOWN, env, C.onstruct(5), C.onstruct(2)));
-		assertCEquals(C.onstruct(9), a.exec(Target.UNKNOWN, env, C.onstruct(3), C.onstruct(3)));
-		assertCEquals(C.onstruct(6), a.exec(Target.UNKNOWN, env, C.onstruct(-3), C.onstruct(-2)));
-		assertCEquals(C.onstruct(5), a.exec(Target.UNKNOWN, env, C.onstruct(10), C.onstruct(0.5)));
-		assertCEquals(C.onstruct(-562949953421311L), a.exec(Target.UNKNOWN, env, C.onstruct(281474976710655L), C.onstruct(281474976710655L)));
-		assertCEquals(C.onstruct(5312385410449346020L), a.exec(Target.UNKNOWN, env, C.onstruct(9876543210L), C.onstruct(9876543210L)));
+		assertCEquals(C.onstruct(10), a.exec(Target.UNKNOWN, env, null, C.onstruct(5), C.onstruct(2)));
+		assertCEquals(C.onstruct(9), a.exec(Target.UNKNOWN, env, null, C.onstruct(3), C.onstruct(3)));
+		assertCEquals(C.onstruct(6), a.exec(Target.UNKNOWN, env, null, C.onstruct(-3), C.onstruct(-2)));
+		assertCEquals(C.onstruct(5), a.exec(Target.UNKNOWN, env, null, C.onstruct(10), C.onstruct(0.5)));
+		assertCEquals(C.onstruct(-562949953421311L), a.exec(Target.UNKNOWN, env, null, C.onstruct(281474976710655L), C.onstruct(281474976710655L)));
+		assertCEquals(C.onstruct(5312385410449346020L), a.exec(Target.UNKNOWN, env, null, C.onstruct(9876543210L), C.onstruct(9876543210L)));
 	}
 
 	@Test(timeout = 10000)
 	public void testPow() {
 		Math.pow a = new Math.pow();
-		assertCEquals(C.onstruct(25), a.exec(Target.UNKNOWN, env, C.onstruct(5), C.onstruct(2)));
-		assertCEquals(C.onstruct(27), a.exec(Target.UNKNOWN, env, C.onstruct(3), C.onstruct(3)));
-		assertCEquals(C.onstruct(1), a.exec(Target.UNKNOWN, env, C.onstruct(-1), C.onstruct(-2)));
+		assertCEquals(C.onstruct(25), a.exec(Target.UNKNOWN, env, null, C.onstruct(5), C.onstruct(2)));
+		assertCEquals(C.onstruct(27), a.exec(Target.UNKNOWN, env, null, C.onstruct(3), C.onstruct(3)));
+		assertCEquals(C.onstruct(1), a.exec(Target.UNKNOWN, env, null, C.onstruct(-1), C.onstruct(-2)));
 	}
 
 	@Test(timeout = 10000)
 	public void testRand1() {
 		Math.rand a = new Math.rand();
 		for(int i = 0; i < 1000; i++) {
-			long j = ArgumentValidation.getInt(a.exec(Target.UNKNOWN, env, C.onstruct(10)), t);
+			long j = ArgumentValidation.getInt(a.exec(Target.UNKNOWN, env, null, C.onstruct(10)), t);
 			if(!(j < 10 && j >= 0)) {
 				fail("Expected a number between 0 and 10, but got " + j);
 			}
-			j = ArgumentValidation.getInt(a.exec(Target.UNKNOWN, env, C.onstruct(10), C.onstruct(20)), t);
+			j = ArgumentValidation.getInt(a.exec(Target.UNKNOWN, env, null, C.onstruct(10), C.onstruct(20)), t);
 			if(!(j < 20 && j >= 10)) {
 				fail("Expected a number between 10 and 20, but got " + j);
 			}
 		}
 		try {
-			a.exec(Target.UNKNOWN, env, C.onstruct(20), C.onstruct(10));
+			a.exec(Target.UNKNOWN, env, null, C.onstruct(20), C.onstruct(10));
 			fail("Didn't expect this test to pass");
 		} catch (ConfigRuntimeException e) {
 		}
 		try {
-			a.exec(Target.UNKNOWN, env, C.onstruct(-1));
+			a.exec(Target.UNKNOWN, env, null, C.onstruct(-1));
 			fail("Didn't expect this test to pass");
 		} catch (ConfigRuntimeException e) {
 		}
@@ -188,25 +188,25 @@ public void testRand2() throws Exception {
 	@Test(timeout = 10000)
 	public void testSubtract() {
 		Math.subtract a = new Math.subtract();
-		assertCEquals(C.onstruct(3), a.exec(Target.UNKNOWN, env, C.onstruct(5), C.onstruct(2)));
-		assertCEquals(C.onstruct(0), a.exec(Target.UNKNOWN, env, C.onstruct(3), C.onstruct(3)));
-		assertCEquals(C.onstruct(-1), a.exec(Target.UNKNOWN, env, C.onstruct(-3), C.onstruct(-2)));
-		assertCEquals(C.onstruct(3), a.exec(Target.UNKNOWN, env, C.onstruct(3.1415), C.onstruct(0.1415)));
-		assertCEquals(C.onstruct(281474976710655L), a.exec(Target.UNKNOWN, env, C.onstruct(562949953421310L), C.onstruct(281474976710655L)));
+		assertCEquals(C.onstruct(3), a.exec(Target.UNKNOWN, env, null, C.onstruct(5), C.onstruct(2)));
+		assertCEquals(C.onstruct(0), a.exec(Target.UNKNOWN, env, null, C.onstruct(3), C.onstruct(3)));
+		assertCEquals(C.onstruct(-1), a.exec(Target.UNKNOWN, env, null, C.onstruct(-3), C.onstruct(-2)));
+		assertCEquals(C.onstruct(3), a.exec(Target.UNKNOWN, env, null, C.onstruct(3.1415), C.onstruct(0.1415)));
+		assertCEquals(C.onstruct(281474976710655L), a.exec(Target.UNKNOWN, env, null, C.onstruct(562949953421310L), C.onstruct(281474976710655L)));
 	}
 
 	@Test(timeout = 10000)
 	public void testFloor() {
 		Math.floor a = new Math.floor();
-		assertCEquals(C.onstruct(3), a.exec(Target.UNKNOWN, env, C.onstruct(3.8415)));
-		assertCEquals(C.onstruct(-4), a.exec(Target.UNKNOWN, env, C.onstruct(-3.1415)));
+		assertCEquals(C.onstruct(3), a.exec(Target.UNKNOWN, env, null, C.onstruct(3.8415)));
+		assertCEquals(C.onstruct(-4), a.exec(Target.UNKNOWN, env, null, C.onstruct(-3.1415)));
 	}
 
 	@Test(timeout = 10000)
 	public void testCeil() {
 		Math.ceil a = new Math.ceil();
-		assertCEquals(C.onstruct(4), a.exec(Target.UNKNOWN, env, C.onstruct(3.1415)));
-		assertCEquals(C.onstruct(-3), a.exec(Target.UNKNOWN, env, C.onstruct(-3.1415)));
+		assertCEquals(C.onstruct(4), a.exec(Target.UNKNOWN, env, null, C.onstruct(3.1415)));
+		assertCEquals(C.onstruct(-3), a.exec(Target.UNKNOWN, env, null, C.onstruct(-3.1415)));
 	}
 
 	@Test(timeout = 10000)
@@ -233,13 +233,13 @@ public void testMax() throws Exception {
 
 	@Test
 	public void testChained() throws Exception {
-		assertEquals("8", SRun("2 + 2 + 2 + 2", null));
-		assertEquals("20", SRun("2 * 2 + 2 * 2 * 2 + 2 * 2 * 2", null));
+		assertEquals("8", SRun("dyn(2) + dyn(2) + dyn(2) + dyn(2)", null));
+		assertEquals("20", SRun("dyn(2) * dyn(2) + dyn(2) * dyn(2) * dyn(2) + dyn(2) * dyn(2) * dyn(2)", null));
 	}
 
 	@Test
 	public void testRound() throws Exception {
-		assertEquals("4.0", SRun("round(4.4)", null));
+		assertEquals("4.0", SRun("round(dyn(4.4))", null));
 		assertEquals("5.0", SRun("round(4.5)", null));
 		assertEquals("4.6", SRun("round(4.55, 1)", null));
 	}
diff --git a/src/test/java/com/laytonsmith/core/functions/MinecraftTest.java b/src/test/java/com/laytonsmith/core/functions/MinecraftTest.java
index 8765c06258..9a1f2e4e63 100644
--- a/src/test/java/com/laytonsmith/core/functions/MinecraftTest.java
+++ b/src/test/java/com/laytonsmith/core/functions/MinecraftTest.java
@@ -5,6 +5,7 @@
 import com.laytonsmith.abstraction.MCPlayer;
 import com.laytonsmith.abstraction.MCServer;
 import com.laytonsmith.abstraction.enums.MCVersion;
+import com.laytonsmith.core.MethodScriptCompiler;
 import com.laytonsmith.core.Static;
 import com.laytonsmith.core.environments.CommandHelperEnvironment;
 import com.laytonsmith.core.exceptions.ConfigCompileException;
@@ -81,4 +82,14 @@ public void testGetMCVersion() {
 		assertEquals(MCVersion.match(new String[]{"1", "8", "8"}), MCVersion.MC1_8_X);
 		assertEquals(MCVersion.match(new String[]{"3", "1", "4"}), MCVersion.MCX_X);
 	}
+
+	@Test
+	public void testMaterialInfoWithVariable() throws Exception {
+		// material_info's optimizeDynamic should not crash when the first
+		// argument is a variable (IVariable has no @typeof annotation).
+		String script = "assign(@mat, 'STONE') material_info(@mat, 'isBlock')";
+		MethodScriptCompiler.compile(
+				MethodScriptCompiler.lex(script, env, null, true),
+				env, env.getEnvClasses());
+	}
 }
diff --git a/src/test/java/com/laytonsmith/core/functions/StringHandlingTest.java b/src/test/java/com/laytonsmith/core/functions/StringHandlingTest.java
index 93aed265f5..35297f5e2f 100644
--- a/src/test/java/com/laytonsmith/core/functions/StringHandlingTest.java
+++ b/src/test/java/com/laytonsmith/core/functions/StringHandlingTest.java
@@ -41,16 +41,16 @@ public void tearDown() {
 	@Test(timeout = 10000)
 	public void testConcat() throws Exception {
 		StringHandling.concat a = new StringHandling.concat();
-		assertCEquals(C.onstruct("1234"), a.exec(Target.UNKNOWN, null, C.onstruct(1), C.onstruct(2), C.onstruct(3), C.onstruct(4)));
-		assertCEquals(C.onstruct("astring"), a.exec(Target.UNKNOWN, null, C.onstruct("a"), C.String("string")));
+		assertCEquals(C.onstruct("1234"), a.exec(Target.UNKNOWN, null, null, C.onstruct(1), C.onstruct(2), C.onstruct(3), C.onstruct(4)));
+		assertCEquals(C.onstruct("astring"), a.exec(Target.UNKNOWN, null, null, C.onstruct("a"), C.String("string")));
 		assertEquals("05", SRun("'0' . 5", null));
 	}
 
 	@Test(timeout = 10000)
 	public void testLength() {
 		StringHandling.length a = new StringHandling.length();
-		assertCEquals(C.onstruct(5), a.exec(Target.UNKNOWN, null, C.onstruct("12345")));
-		assertCEquals(C.onstruct(2), a.exec(Target.UNKNOWN, null, C.Array(C.onstruct(0), C.onstruct(1))));
+		assertCEquals(C.onstruct(5), a.exec(Target.UNKNOWN, null, null, C.onstruct("12345")));
+		assertCEquals(C.onstruct(2), a.exec(Target.UNKNOWN, null, null, C.Array(C.onstruct(0), C.onstruct(1))));
 	}
 
 	@Test//(timeout = 10000)
@@ -58,8 +58,8 @@ public void testParseArgs() throws Exception {
 		SRun("msg(parse_args('o \"\\\\t\"', true))", fakePlayer);
 		verify(fakePlayer).sendMessage("{o, \\t}");
 		StringHandling.parse_args a = new StringHandling.parse_args();
-		assertCEquals(C.Array(C.onstruct("one"), C.onstruct("two")), a.exec(Target.UNKNOWN, null, C.onstruct("one   two")));
-		assertCEquals(C.Array(C.onstruct("one"), C.onstruct("two")), a.exec(Target.UNKNOWN, null, C.onstruct("one two")));
+		assertCEquals(C.Array(C.onstruct("one"), C.onstruct("two")), a.exec(Target.UNKNOWN, null, null, C.onstruct("one   two")));
+		assertCEquals(C.Array(C.onstruct("one"), C.onstruct("two")), a.exec(Target.UNKNOWN, null, null, C.onstruct("one two")));
 		SRun("msg(parse_args('one \"two\"', true))", fakePlayer);
 		verify(fakePlayer).sendMessage("{one, two}");
 	}
@@ -71,9 +71,9 @@ public void testRead() {
 	@Test(timeout = 10000)
 	public void testReplace() {
 		StringHandling.replace a = new StringHandling.replace();
-		assertCEquals(C.onstruct("yay"), a.exec(Target.UNKNOWN, null, C.onstruct("yayathing"), C.onstruct("athing"), C.onstruct("")));
-		assertCEquals(C.onstruct("yaymonkey"), a.exec(Target.UNKNOWN, null, C.onstruct("yayathing"), C.onstruct("athing"), C.onstruct("monkey")));
-		assertCEquals(C.onstruct("yayathing"), a.exec(Target.UNKNOWN, null, C.onstruct("yayathing"), C.onstruct("wut"), C.onstruct("chicken")));
+		assertCEquals(C.onstruct("yay"), a.exec(Target.UNKNOWN, null, null, C.onstruct("yayathing"), C.onstruct("athing"), C.onstruct("")));
+		assertCEquals(C.onstruct("yaymonkey"), a.exec(Target.UNKNOWN, null, null, C.onstruct("yayathing"), C.onstruct("athing"), C.onstruct("monkey")));
+		assertCEquals(C.onstruct("yayathing"), a.exec(Target.UNKNOWN, null, null, C.onstruct("yayathing"), C.onstruct("wut"), C.onstruct("chicken")));
 	}
 
 	@Test(timeout = 10000)
@@ -86,30 +86,30 @@ public void testSconcat() throws Exception {
 	@Test(timeout = 10000)
 	public void testSubstr() {
 		StringHandling.substr a = new StringHandling.substr();
-		assertCEquals(C.onstruct("urge"), a.exec(Target.UNKNOWN, null, C.onstruct("hamburger"), C.onstruct(4), C.onstruct(8)));
-		assertCEquals(C.onstruct("mile"), a.exec(Target.UNKNOWN, null, C.onstruct("smiles"), C.onstruct(1), C.onstruct(5)));
-		assertCEquals(C.onstruct("ning"), a.exec(Target.UNKNOWN, null, C.onstruct("lightning"), C.onstruct(5)));
+		assertCEquals(C.onstruct("urge"), a.exec(Target.UNKNOWN, null, null, C.onstruct("hamburger"), C.onstruct(4), C.onstruct(8)));
+		assertCEquals(C.onstruct("mile"), a.exec(Target.UNKNOWN, null, null, C.onstruct("smiles"), C.onstruct(1), C.onstruct(5)));
+		assertCEquals(C.onstruct("ning"), a.exec(Target.UNKNOWN, null, null, C.onstruct("lightning"), C.onstruct(5)));
 	}
 
 	@Test(timeout = 10000)
 	public void testToUpper() {
 		StringHandling.to_upper a = new StringHandling.to_upper();
-		assertCEquals(C.onstruct("TESTING 123"), a.exec(Target.UNKNOWN, null, C.onstruct("testing 123")));
-		assertCEquals(C.onstruct("TESTING 123"), a.exec(Target.UNKNOWN, null, C.onstruct("TeStInG 123")));
+		assertCEquals(C.onstruct("TESTING 123"), a.exec(Target.UNKNOWN, null, null, C.onstruct("testing 123")));
+		assertCEquals(C.onstruct("TESTING 123"), a.exec(Target.UNKNOWN, null, null, C.onstruct("TeStInG 123")));
 	}
 
 	@Test(timeout = 10000)
 	public void testToLower() {
 		StringHandling.to_lower a = new StringHandling.to_lower();
-		assertCEquals(C.onstruct("testing 123"), a.exec(Target.UNKNOWN, null, C.onstruct("TESTING 123")));
-		assertCEquals(C.onstruct("testing 123"), a.exec(Target.UNKNOWN, null, C.onstruct("TeStInG 123")));
+		assertCEquals(C.onstruct("testing 123"), a.exec(Target.UNKNOWN, null, null, C.onstruct("TESTING 123")));
+		assertCEquals(C.onstruct("testing 123"), a.exec(Target.UNKNOWN, null, null, C.onstruct("TeStInG 123")));
 	}
 
 	@Test(timeout = 10000)
 	public void testTrim() {
 		StringHandling.trim a = new StringHandling.trim();
-		assertCEquals(C.onstruct("test 123"), a.exec(Target.UNKNOWN, null, C.onstruct("    test 123    ")));
-		assertCEquals(C.onstruct("test   123"), a.exec(Target.UNKNOWN, null, C.onstruct("test   123")));
+		assertCEquals(C.onstruct("test 123"), a.exec(Target.UNKNOWN, null, null, C.onstruct("    test 123    ")));
+		assertCEquals(C.onstruct("test   123"), a.exec(Target.UNKNOWN, null, null, C.onstruct("test   123")));
 	}
 
 	@Test
diff --git a/src/test/java/com/laytonsmith/testing/ProcedureTest.java b/src/test/java/com/laytonsmith/testing/ProcedureTest.java
index 7a093c7f10..263035829a 100644
--- a/src/test/java/com/laytonsmith/testing/ProcedureTest.java
+++ b/src/test/java/com/laytonsmith/testing/ProcedureTest.java
@@ -3,13 +3,20 @@
 import com.laytonsmith.abstraction.MCPlayer;
 import static com.laytonsmith.testing.StaticTest.SRun;
 
+import com.laytonsmith.core.environments.GlobalEnv;
+import com.laytonsmith.core.events.BindableEvent;
+import com.laytonsmith.core.events.Driver;
+import com.laytonsmith.core.events.EventUtils;
 import com.laytonsmith.core.exceptions.CRE.CRECastException;
+import com.laytonsmith.core.exceptions.CRE.CREStackOverflowError;
+import com.laytonsmith.core.exceptions.StackTraceManager;
 import org.bukkit.plugin.Plugin;
 import org.junit.Before;
 import org.junit.BeforeClass;
 import org.junit.Test;
 
 import static org.junit.Assert.fail;
+import static org.mockito.Mockito.atLeastOnce;
 import static org.mockito.Mockito.mock;
 import static org.mockito.Mockito.times;
 import static org.mockito.Mockito.verify;
@@ -133,4 +140,62 @@ public void testProcCalledMultipleTimesWithAssign() throws Exception {
 		verify(fakePlayer, times(3)).sendMessage("{1, 3, 5, 7}");
 	}
 
+	@Test
+	public void testInfiniteRecursionThrowsStackOverflow() throws Exception {
+		try {
+			SRun("proc _recurse() { _recurse() } _recurse()", fakePlayer);
+			fail("Expected CREStackOverflowError from infinite recursion");
+		} catch(CREStackOverflowError ex) {
+			// Test passed — infinite recursion was caught
+		}
+	}
+
+	@Test
+	public void testCustomCallDepthLimit() throws Exception {
+		try {
+			SRun("set_runtime_setting('system.max_call_depth', 10)"
+					+ " proc _recurse() { _recurse() } _recurse()", fakePlayer);
+			fail("Expected CREStackOverflowError from infinite recursion");
+		} catch(CREStackOverflowError ex) {
+			// Test passed — custom limit was enforced
+		} finally {
+			// Reset the runtime setting so it doesn't affect other tests
+			GlobalEnv gEnv = StaticTest.env.getEnv(GlobalEnv.class);
+			gEnv.SetRuntimeSetting(StackTraceManager.MAX_CALL_DEPTH_SETTING, null);
+		}
+	}
+
+	@Test
+	public void testProcVisibleInsideClosure() throws Exception {
+		SRun("proc _test() { msg('hello') } closure() { _test() }()", fakePlayer);
+		verify(fakePlayer).sendMessage("hello");
+	}
+
+	@Test
+	public void testProcVisibleInClosureExecutedFromBind() throws Exception {
+		try {
+			SRun("@callbacks = array()"
+					+ "\nbind('cmdline_test_event', null, null, @event, @callbacks) {"
+					+ "\n  foreach(@cb in @callbacks) {"
+					+ "\n    execute(@cb)"
+					+ "\n  }"
+					+ "\n}"
+					+ "\nproc _test() { msg('hello') }"
+					+ "\n@callbacks[] = closure() {"
+					+ "\n  _test()"
+					+ "\n}", fakePlayer);
+
+			EventUtils.TriggerListener(Driver.EXTENSION, "cmdline_test_event", new BindableEvent() {
+				@Override
+				public Object _GetObject() {
+					return new Object();
+				}
+			});
+
+			verify(fakePlayer, atLeastOnce()).sendMessage("hello");
+		} finally {
+			EventUtils.UnregisterAll();
+		}
+	}
+
 }
diff --git a/src/test/java/com/laytonsmith/testing/RandomTests.java b/src/test/java/com/laytonsmith/testing/RandomTests.java
index 553a00bf39..998db8df57 100644
--- a/src/test/java/com/laytonsmith/testing/RandomTests.java
+++ b/src/test/java/com/laytonsmith/testing/RandomTests.java
@@ -362,7 +362,7 @@ public void done(String output) {
 	public void testVoidAndReturnedVoidAreTheExactSame() throws Exception {
 		try {
 			Environment env = Static.GenerateStandaloneEnvironment(true);
-			Mixed returnedVoid = new ArrayHandling.array_insert().exec(Target.UNKNOWN, env,
+			Mixed returnedVoid = new ArrayHandling.array_insert().exec(Target.UNKNOWN, env, null,
 					C.Array(), C.String(""), C.Int(0));
 			Construct voidKeyword = Static.resolveConstruct("void", Target.UNKNOWN);
 			assertTrue(returnedVoid == voidKeyword);
diff --git a/src/test/java/com/laytonsmith/testing/StaticTest.java b/src/test/java/com/laytonsmith/testing/StaticTest.java
index 8a88f118f8..6d74f469cb 100644
--- a/src/test/java/com/laytonsmith/testing/StaticTest.java
+++ b/src/test/java/com/laytonsmith/testing/StaticTest.java
@@ -74,9 +74,6 @@
 import com.laytonsmith.core.exceptions.CancelCommandException;
 import com.laytonsmith.core.exceptions.ConfigRuntimeException;
 import com.laytonsmith.core.exceptions.EventException;
-import com.laytonsmith.core.exceptions.FunctionReturnException;
-import com.laytonsmith.core.exceptions.LoopBreakException;
-import com.laytonsmith.core.exceptions.LoopContinueException;
 import com.laytonsmith.core.extensions.ExtensionManager;
 import com.laytonsmith.core.functions.BasicLogic.equals;
 import com.laytonsmith.core.functions.Function;
@@ -180,8 +177,7 @@ public static void TestBoilerplate(FunctionBase ff, String name) throws Exceptio
 			TestExec(f, StaticTest.GetFakeConsoleCommandSender(), "fake console command sender");
 		}
 
-		//Let's make sure that if execs is defined in the class, useSpecialExec returns true.
-		//Same thing for optimize/canOptimize and optimizeDynamic/canOptimizeDynamic
+		//Let's make sure optimization declarations are consistent.
 		if(f instanceof Optimizable) {
 			Set<Optimizable.OptimizationOption> options = ((Optimizable) f).optimizationOptions();
 			if(options.contains(Optimizable.OptimizationOption.CONSTANT_OFFLINE) && options.contains(Optimizable.OptimizationOption.OPTIMIZE_CONSTANT)) {
@@ -189,12 +185,6 @@ public static void TestBoilerplate(FunctionBase ff, String name) throws Exceptio
 			}
 		}
 		for(Method method : f.getClass().getDeclaredMethods()) {
-			if(method.getName().equals("execs")) {
-				if(!f.useSpecialExec()) {
-					fail(f.getName() + " declares execs, but returns false for useSpecialExec.");
-				}
-			}
-
 			if(f instanceof Optimizable) {
 				Set<Optimizable.OptimizationOption> options = ((Optimizable) f).optimizationOptions();
 				if(method.getName().equals("optimize")) {
@@ -289,7 +279,7 @@ public static void TestExec(Function f, MCCommandSender p, String commandType) t
 					}
 				}
 				try {
-					f.exec(Target.UNKNOWN, env, con);
+					Function.ExecuteFunction(f, Target.UNKNOWN, env, con);
 				} catch (CancelCommandException e) {
 				} catch (ConfigRuntimeException e) {
 					if(f.getName().equals("throw")) {
@@ -313,15 +303,6 @@ public static void TestExec(Function f, MCCommandSender p, String commandType) t
 								+ name + ", but it did.");
 					}
 				} catch (Throwable e) {
-					if(e instanceof LoopBreakException && !f.getName().equals("break")) {
-						fail("Only break() can throw LoopBreakExceptions");
-					}
-					if(e instanceof LoopContinueException && !f.getName().equals("continue")) {
-						fail("Only continue() can throw LoopContinueExceptions");
-					}
-					if(e instanceof FunctionReturnException && !f.getName().equals("return")) {
-						fail("Only return() can throw FunctionReturnExceptions");
-					}
 					if(e instanceof NullPointerException) {
 						String error = (f.getName() + " breaks if you send it the following while using a " + commandType + ": " + Arrays.deepToString(con) + "\n");
 						error += ("Here is the first few stack trace lines:\n");
@@ -364,7 +345,7 @@ public static Object Val(Mixed c) {
 	 */
 	public static void assertCEquals(Mixed expected, Mixed actual) throws CancelCommandException {
 		equals e = new equals();
-		CBoolean ret = (CBoolean) e.exec(Target.UNKNOWN, null, expected, actual);
+		CBoolean ret = (CBoolean) e.exec(Target.UNKNOWN, null, null, expected, actual);
 		if(ret.getBoolean() == false) {
 			throw new AssertionError("Expected " + expected + " and " + actual + " to be equal to each other");
 		}
@@ -379,7 +360,7 @@ public static void assertCEquals(Mixed expected, Mixed actual) throws CancelComm
 	 */
 	public static void assertCNotEquals(Mixed expected, Mixed actual) throws CancelCommandException {
 		equals e = new equals();
-		CBoolean ret = (CBoolean) e.exec(Target.UNKNOWN, null, expected, actual);
+		CBoolean ret = (CBoolean) e.exec(Target.UNKNOWN, null, null, expected, actual);
 		if(ret.getBoolean() == true) {
 			throw new AssertionError("Did not expect " + expected + " and " + actual + " to be equal to each other");
 		}
@@ -545,6 +526,7 @@ public static void Run(String script, MCCommandSender player, MethodScriptComple
 			env = StaticTest.env;
 		}
 		env.getEnv(GlobalEnv.class).GetVarList().clear();
+		env.getEnv(GlobalEnv.class).GetStackTraceManager().clear();
 		env.getEnv(CommandHelperEnvironment.class).SetCommandSender(player);
 		StaticAnalysis analysis = new StaticAnalysis(true);
 		analysis.setLocalEnable(false);
diff --git a/src/test/java/com/laytonsmith/tools/langserv/WikiToMarkdownTest.java b/src/test/java/com/laytonsmith/tools/langserv/WikiToMarkdownTest.java
new file mode 100644
index 0000000000..f332b838d6
--- /dev/null
+++ b/src/test/java/com/laytonsmith/tools/langserv/WikiToMarkdownTest.java
@@ -0,0 +1,248 @@
+package com.laytonsmith.tools.langserv;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNull;
+import static org.junit.Assert.assertTrue;
+import org.junit.Test;
+
+public class WikiToMarkdownTest {
+
+	@Test
+	public void testNullAndEmpty() {
+		assertNull(WikiToMarkdown.convert(null));
+		assertEquals("", WikiToMarkdown.convert(""));
+	}
+
+	@Test
+	public void testBold() {
+		assertEquals("This is **bold** text", WikiToMarkdown.convert("This is '''bold''' text"));
+	}
+
+	@Test
+	public void testItalic() {
+		assertEquals("This is *italic* text", WikiToMarkdown.convert("This is ''italic'' text"));
+	}
+
+	@Test
+	public void testBoldAndItalic() {
+		assertEquals("**bold** and *italic*",
+				WikiToMarkdown.convert("'''bold''' and ''italic''"));
+	}
+
+	@Test
+	public void testHeadings() {
+		assertEquals("## Heading 2", WikiToMarkdown.convert("== Heading 2 =="));
+		assertEquals("### Heading 3", WikiToMarkdown.convert("=== Heading 3 ==="));
+		assertEquals("#### Heading 4", WikiToMarkdown.convert("==== Heading 4 ===="));
+		assertEquals("##### Heading 5", WikiToMarkdown.convert("===== Heading 5 ====="));
+		assertEquals("###### Heading 6", WikiToMarkdown.convert("====== Heading 6 ======"));
+	}
+
+	@Test
+	public void testWikiLinks() {
+		assertEquals("SomePage", WikiToMarkdown.convert("[[SomePage]]"));
+		assertEquals("Label", WikiToMarkdown.convert("[[SomePage|Label]]"));
+		assertEquals("Label", WikiToMarkdown.convert("[[SomePage#anchor|Label]]"));
+	}
+
+	@Test
+	public void testExternalLinks() {
+		assertEquals("[Click here](http://example.com)",
+				WikiToMarkdown.convert("[http://example.com Click here]"));
+		assertEquals("[Docs](https://docs.example.com/page)",
+				WikiToMarkdown.convert("[https://docs.example.com/page Docs]"));
+	}
+
+	@Test
+	public void testFunctionTemplate() {
+		assertEquals("Use `array_push()` to add elements",
+				WikiToMarkdown.convert("Use {{function|array_push}} to add elements"));
+	}
+
+	@Test
+	public void testKeywordTemplate() {
+		assertEquals("The `if` keyword",
+				WikiToMarkdown.convert("The {{keyword|if}} keyword"));
+	}
+
+	@Test
+	public void testObjectTemplate() {
+		assertEquals("Returns a `string`",
+				WikiToMarkdown.convert("Returns a {{object|string}}"));
+	}
+
+	@Test
+	public void testTakeNoteTemplate() {
+		String result = WikiToMarkdown.convert("{{TakeNote|text=This is important}}");
+		assertEquals("> **Note:** This is important", result);
+	}
+
+	@Test
+	public void testWarningTemplate() {
+		String result = WikiToMarkdown.convert("{{Warning|text=Be careful}}");
+		assertEquals("> **Warning:** Be careful", result);
+	}
+
+	@Test
+	public void testTemplateEscapePipe() {
+		assertEquals("string|array", WikiToMarkdown.convert("string{{!}}array"));
+	}
+
+	@Test
+	public void testPreBlock() {
+		String input = "<pre class=\"pre\">some code here</pre>";
+		String result = WikiToMarkdown.convert(input);
+		assertEquals("```\nsome code here\n```", result);
+	}
+
+	@Test
+	public void testCodeTag() {
+		assertEquals("Use `getValue` here", WikiToMarkdown.convert("Use <code>getValue</code> here"));
+	}
+
+	@Test
+	public void testHtmlStrong() {
+		assertEquals("This is **bold**", WikiToMarkdown.convert("This is <strong>bold</strong>"));
+	}
+
+	@Test
+	public void testHtmlEm() {
+		assertEquals("This is *italic*", WikiToMarkdown.convert("This is <em>italic</em>"));
+	}
+
+	@Test
+	public void testHorizontalRule() {
+		assertEquals("above\n---\nbelow", WikiToMarkdown.convert("above\n----\nbelow"));
+	}
+
+	@Test
+	public void testNumberedList() {
+		assertEquals("1. First\n1. Second", WikiToMarkdown.convert("# First\n# Second"));
+	}
+
+	@Test
+	public void testHtmlEntities() {
+		assertEquals("<tag>", WikiToMarkdown.convert("&lt;tag&gt;"));
+	}
+
+	@Test
+	public void testWikiEscapedEntities() {
+		String input = "&lsqb;optional&rsqb; &ast;bold&ast;";
+		String result = WikiToMarkdown.convert(input);
+		assertEquals("[optional] *bold*", result);
+	}
+
+	@Test
+	public void testSimpleTable() {
+		String input = "{| class=\"wikitable\"\n"
+				+ "|-\n"
+				+ "! Name !! Type\n"
+				+ "|-\n"
+				+ "| foo || string\n"
+				+ "|-\n"
+				+ "| bar || int\n"
+				+ "|}";
+		String result = WikiToMarkdown.convert(input);
+		assertTrue(result.contains("| Name | Type |"));
+		assertTrue(result.contains("|---|---|"));
+		assertTrue(result.contains("| foo | string |"));
+		assertTrue(result.contains("| bar | int |"));
+	}
+
+	@Test
+	public void testPreBlockUnescapesEntities() {
+		String input = "<pre class=\"pre\">&lt;profile&gt;\n\t&lt;type&gt;email&lt;/type&gt;\n&lt;/profile&gt;</pre>";
+		String result = WikiToMarkdown.convert(input);
+		assertTrue(result.contains("<profile>"));
+		assertTrue(result.contains("<type>email</type>"));
+	}
+
+	@Test
+	public void testMethodScriptCodeBlock() {
+		String input = "<div style=\"padding: 10px\" class=\"methodscript_code\">"
+				+ "<div class=\"rawCode\" style=\"display: none;\">"
+				+ "msg&lpar;&quot;hello&quot;&rpar;"
+				+ "</div>"
+				+ "<div class=\"copyButton\"><img src=\"images/clipboard.png\" alt=\"\"> Copy Code</div>"
+				+ "<span style=\"color:blue\">msg</span>"
+				+ "</div>";
+		String result = WikiToMarkdown.convert(input);
+		assertTrue(result.contains("```mscript"));
+		assertTrue(result.contains("msg(\"hello\")"));
+	}
+
+	@Test
+	public void testLearningTrailRemoved() {
+		assertEquals("Some text", WikiToMarkdown.convert("{{LearningTrail}}Some text"));
+	}
+
+	@Test
+	public void testUnimplementedTemplate() {
+		String result = WikiToMarkdown.convert("{{unimplemented}}");
+		assertTrue(result.contains("not yet implemented"));
+	}
+
+	@Test
+	public void testComplexDoc() {
+		String input = "Returns the value. See [[Functions|this page]] for details.\n"
+				+ "Use {{function|array_get}} to retrieve values.\n"
+				+ "'''Note:''' This is ''important''.";
+		String result = WikiToMarkdown.convert(input);
+		assertTrue(result.contains("this page"));
+		assertFalse(result.contains("[["));
+		assertTrue(result.contains("`array_get()`"));
+		assertTrue(result.contains("**Note:**"));
+		assertTrue(result.contains("*important*"));
+	}
+
+	@Test
+	public void testRealisticFunctionDoc() {
+		String input = "The settings object has fields:\n"
+				+ "{| class=\"wikitable\"\n"
+				+ "|-\n"
+				+ "! Key !! Type !! Default !! Description\n"
+				+ "|-\n"
+				+ "| method || string || null || One of the HTTP methods\n"
+				+ "|-\n"
+				+ "| success || closure || null || The {{keyword|closure}} called on success\n"
+				+ "|}\n"
+				+ "{{Warning|text=There are a limited number of slots.}}\n"
+				+ "Use {{function|http_request}} with '''caution'''.\n"
+				+ "See [[Networking|this page]] for details.\n"
+				+ "=== Example ===\n"
+				+ "<pre class=\"pre\">http_request&lpar;&amp;quot;http://example.com&amp;quot;&rpar;</pre>";
+		String result = WikiToMarkdown.convert(input);
+
+		// Table
+		assertTrue(result.contains("| Key | Type | Default | Description |"));
+		assertTrue(result.contains("|---|---|---|---|"));
+		assertTrue(result.contains("| method | string | null | One of the HTTP methods |"));
+
+		// Templates
+		assertTrue(result.contains("`closure`"));
+		assertTrue(result.contains("`http_request()`"));
+
+		// Warning
+		assertTrue(result.contains("> **Warning:**"));
+
+		// Bold
+		assertTrue(result.contains("**caution**"));
+
+		// Wiki link → label only
+		assertTrue(result.contains("this page"));
+		assertFalse(result.contains("[["));
+
+		// Heading
+		assertTrue(result.contains("### Example"));
+
+		// Pre block
+		assertTrue(result.contains("```"));
+
+		// No leftover wiki/HTML
+		assertFalse(result.contains("{{"));
+		assertFalse(result.contains("{|"));
+		assertFalse(result.contains("|}"));
+		assertFalse(result.contains("'''"));
+	}
+}