mlogjs 0.5.2 → 0.6.0

package/dist/{index.cjs → Compiler-7GMG4MDr.js}

@@ -1,26 +1,5 @@
-'use strict';
-
-var parser = require('@babel/parser');
-var es = require('@babel/types');
-
-function _interopNamespaceDefault(e) {
-    var n = Object.create(null);
-    if (e) {
-        Object.keys(e).forEach(function (k) {
-            if (k !== 'default') {
-                var d = Object.getOwnPropertyDescriptor(e, k);
-                Object.defineProperty(n, k, d.get ? d : {
-                    enumerable: true,
-                    get: function () { return e[k]; }
-                });
-            }
-        });
-    }
-    n.default = e;
-    return Object.freeze(n);
-}
-
-var es__namespace = /*#__PURE__*/_interopNamespaceDefault(es);
+import { parse } from '@babel/parser';
+import * as es from '@babel/types';
 
 class CompilerError extends Error {
     constructor(message, source) {
@@ -75,29 +54,34 @@ var EInstIntent;
     EInstIntent[EInstIntent["continue"] = 2] = "continue";
     EInstIntent[EInstIntent["return"] = 3] = "return";
     /**
-     * This is used by the `end` and `stop` instructions.
-     * Means that the processor will restart or shutdown.
+     * This is used by the `end` and `stop` instructions. Means that the processor
+     * will restart or shutdown.
      */
     EInstIntent[EInstIntent["exit"] = 4] = "exit";
 })(EInstIntent || (EInstIntent = {}));
 /** Defines the possible types of mutability of a value */
 var EMutability;
 (function (EMutability) {
-    /**
-     * The value can be changed by the user's code,
-     * by the mlog runtime, or us
-     */
+    /** The value can be changed by the user's code, by the mlog runtime, or us */
     EMutability[EMutability["mutable"] = 0] = "mutable";
     /**
-     * The value cannot be directly assigned,
-     * but it's still not safe from mutations coming from the runtime.
+     * The value cannot be directly assigned, but it's still not safe from
+     * mutations coming from the runtime.
      */
     EMutability[EMutability["readonly"] = 1] = "readonly";
-    /** Constant values, won't change during execution */
+    /** Compile-time constants. */
     EMutability[EMutability["constant"] = 2] = "constant";
     /** An immutable value that hasn't been initialized yet */
     EMutability[EMutability["init"] = 3] = "init";
+    /** A value unknown at compile-time that will not change after initialization */
+    EMutability[EMutability["immutable"] = 4] = "immutable";
 })(EMutability || (EMutability = {}));
+var EInlineType;
+(function (EInlineType) {
+    EInlineType[EInlineType["auto"] = 0] = "auto";
+    EInlineType[EInlineType["always"] = 1] = "always";
+    EInlineType[EInlineType["never"] = 2] = "never";
+})(EInlineType || (EInlineType = {}));
 
 const arithmeticBinaryOperators = [
     "*",
@@ -142,7 +126,7 @@ const arithmeticAssignmentOperators = [
     "-=",
     "/=",
 ];
-const logicalAssignmentOperators = ["&&=", "||=", "??="];
+const logicalAssignmentOperators$1 = ["&&=", "||=", "??="];
 const bitwiseAssignmentOperators = [
     "<<=",
     ">>=",
@@ -152,7 +136,7 @@ const bitwiseAssignmentOperators = [
 ];
 const assignmentOperators = [
     ...arithmeticAssignmentOperators,
-    ...logicalAssignmentOperators,
+    ...logicalAssignmentOperators$1,
     ...bitwiseAssignmentOperators,
     "=",
 ];
@@ -191,7 +175,7 @@ const operatorMap$2 = {
     "&": "and",
     "^": "xor",
     ">>": "shr",
-    ">>>": "shr",
+    ">>>": "ushr",
     "<<": "shl",
     "&&": "land",
     "||": "or",
@@ -209,10 +193,12 @@ const orderIndependentOperators = [
     "||",
 ];
 
+// eslint-disable-next-line @typescript-eslint/no-unsafe-declaration-merging
 class VoidValue {
     constructor() {
         this.mutability = EMutability.mutable;
         this.macro = false;
+        this.volatile = false;
     }
     eval(_scope, _out) {
         throw new CompilerError(`[${this.debugString()}] cannot be evaluated into a value.`);
@@ -236,7 +222,7 @@ class VoidValue {
     debugString() {
         return "VoidValue";
     }
-    toString() {
+    toMlogString() {
         return '"[macro VoidValue]"';
     }
 }
@@ -247,34 +233,7 @@ for (const key of operators) {
     };
 }
 
-class InstructionBase {
-    get hidden() {
-        return this._hidden;
-    }
-    set hidden(value) {
-        this._hidden = value;
-    }
-    constructor(...args) {
-        this.intent = EInstIntent.none;
-        this.alwaysRuns = true;
-        this._hidden = false;
-        this.args = args;
-    }
-    resolve(_i) { }
-    toString() {
-        return this.args.filter(arg => arg).join(" ");
-    }
-}
-
-class OperationInstruction extends InstructionBase {
-    constructor(kind, temp, left, right) {
-        super("op", kind, temp, left, right);
-    }
-}
-
-/**
- * The prefix for internal variables inside the compiler output
- */
+/** The prefix for internal variables inside the compiler output */
 const internalPrefix = "&";
 const discardedName = `${internalPrefix}_`;
 const itemNames = [
@@ -303,15 +262,21 @@ const itemNames = [
 ];
 /** The name of a special processor variable, controls the instruction pointer */
 const counterName = "@counter";
+const worldModuleName = "mlogjs:world";
+const mathConstants = {
+    E: Math.E,
+    PI: Math.PI,
+    radToDeg: 180 / Math.PI,
+    degToRad: Math.PI / 180,
+};
 
 /**
  * Returns a string that has the format: [line]:[column].
  *
- * If `name` is provided, and it is a string, the resulting string will
- * have the format: [name]:[line]:[column].
+ * If `name` is provided, and it is a string, the resulting string will have the
+ * format: [name]:[line]:[column].
  */
 function nodeName(node, name) {
-    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
     const { line, column } = node.loc.start;
     if (typeof name === "string")
         return `${name}:${line}:${column}`;
@@ -321,18 +286,16 @@ function nodeName(node, name) {
  * Converts a camel case string into a dash case one.
  *
  * As an example `camelCase` becomes `camel-case`
+ *
  * @example
- * ```
- * camelToDashCase("camelCase") // returns "camel-case"
- * ```
+ *   ```
+ *   camelToDashCase("camelCase") // returns "camel-case"
+ *   ```;
  */
 function camelToDashCase(name) {
     return name.replace(/[A-Z]/g, str => `-${str.toLowerCase()}`);
 }
-/**
- * A more type safe version of `Object.assign`
- */
-// eslint-disable-next-line @typescript-eslint/ban-types
+/** A more type safe version of `Object.assign` */
 function assign(obj, props) {
     return Object.assign(obj, props);
 }
@@ -344,7 +307,6 @@ function lazy(fn) {
 
 function appendSourceLocations(valueInst, node) {
     for (const inst of valueInst[1]) {
-        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
         inst.source ??= node.loc;
     }
     return valueInst;
@@ -377,7 +339,10 @@ function hideRedundantJumps(inst) {
         }
     }
 }
-/** A helper that appends the instructions from `value` into `inst` and returns it's `IValue` instance */
+/**
+ * A helper that appends the instructions from `value` into `inst` and returns
+ * it's `IValue` instance
+ */
 function pipeInsts(value, inst) {
     inst.push(...value[1]);
     return value[0];
@@ -391,6 +356,11 @@ function usesAddressResolver(resolver, instructions) {
     }
     return false;
 }
+function formatInstructionArgs(args) {
+    return args
+        .filter((value) => !!value)
+        .map(value => (typeof value === "string" ? value : value.toMlogString()));
+}
 
 function isTemplateObjectArray(value) {
     return (value instanceof ObjectValue &&
@@ -417,7 +387,10 @@ function assertStringLiteral(value, name) {
     if (!(value instanceof LiteralValue) || !value.isString())
         throw new CompilerError(`${name} must be a string literal`);
 }
-/** Asserts that `value` is a string literal that is part of a given set of `members`*/
+/**
+ * Asserts that `value` is a string literal that is part of a given set of
+ * `members`
+ */
 function assertLiteralOneOf(value, members, name) {
     assertStringLiteral(value, name);
     if (!members.includes(value.data))
@@ -445,7 +418,7 @@ function assertIsArrayMacro(value, name) {
     }
     throw new CompilerError(`${name} must be an array macro`);
 }
-/** Asserts that all of the fields described are present on `value`*/
+/** Asserts that all of the fields described are present on `value` */
 function assertObjectFields(value, fields) {
     const result = [];
     for (const field of fields) {
@@ -470,6 +443,32 @@ function isDiscardedOut(out) {
     return out.name === discardedName;
 }
 
+class InstructionBase {
+    get hidden() {
+        return this._hidden;
+    }
+    set hidden(value) {
+        this._hidden = value;
+    }
+    constructor(...args) {
+        this.intent = EInstIntent.none;
+        this.alwaysRuns = true;
+        this._hidden = false;
+        this.ignoredByParser = false;
+        this.args = args;
+    }
+    resolve(_i) { }
+    toString() {
+        return formatInstructionArgs(this.args).join(" ");
+    }
+}
+
+class OperationInstruction extends InstructionBase {
+    constructor(kind, temp, left, right) {
+        super("op", kind, temp, left, right);
+    }
+}
+
 class SetInstruction extends InstructionBase {
     constructor(store, value) {
         super("set", store, value);
@@ -543,8 +542,8 @@ class JumpInstruction extends InstructionBase {
         this.address = address;
     }
     /**
-     * Works with the `JumpOutValue` class to determine
-     * wether a jump should be added if the expression wasn't jump compressed.
+     * Works with the `JumpOutValue` class to determine whether a jump should be
+     * added if the expression wasn't jump compressed.
      */
     static or(test, out) {
         if (test === out)
@@ -561,12 +560,6 @@ class SetCounterInstruction extends InstructionBase {
     }
 }
 
-class ZeroSpaceInstruction extends InstructionBase {
-    toString() {
-        return this.args.join("");
-    }
-}
-
 class BreakInstruction extends JumpInstruction {
     constructor(address) {
         super(address, EJumpKind.Always);
@@ -624,7 +617,6 @@ class JumpOutValue extends VoidValue {
             kind = invertedOperatorMap[operator];
         }
         const jump = new JumpInstruction(this.address, kind, left, right);
-        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
         jump.source = this.node.loc;
         return jump;
     }
@@ -634,7 +626,7 @@ class JumpOutValue extends VoidValue {
     debugString() {
         return "JumpOutValue";
     }
-    toString() {
+    toMlogString() {
         return '"[macro JumpOutValue]"';
     }
 }
@@ -672,10 +664,10 @@ class BaseValue extends VoidValue {
     }
     // requires special handling
     // the handler should give an object value to allow the lazy evaluation
-    "??"(scope, other, out) {
-        const result = SenseableValue.from(scope, out, EMutability.mutable);
+    "??"(scope, other, out, endAddress) {
+        const result = StoreValue.from(scope, out);
         const nullLiteral = new LiteralValue(null);
-        const endAdress = new LiteralValue(null);
+        const targetAddress = endAddress ?? new LiteralValue(null);
         const [left, leftInst] = this.eval(scope, result);
         const [right, rightInst] = other.eval(scope, result);
         const [test, testInst] = left["==="](scope, nullLiteral);
@@ -685,10 +677,10 @@ class BaseValue extends VoidValue {
                 ...leftInst,
                 ...result["="](scope, left)[1],
                 ...testInst,
-                new JumpInstruction(endAdress, EJumpKind.Equal, test, new LiteralValue(0)),
+                new JumpInstruction(targetAddress, EJumpKind.Equal, test, new LiteralValue(0)),
                 ...rightInst,
                 ...result["="](scope, right)[1],
-                new AddressResolver(endAdress),
+                ...(endAddress ? [] : [new AddressResolver(targetAddress)]),
             ],
         ];
     }
@@ -702,8 +694,45 @@ class BaseValue extends VoidValue {
         const [result, resultInst] = equal["!"](scope, out);
         return [result, [...equalInst, ...resultInst]];
     }
+    "&&"(scope, value, out, endAddress) {
+        const temp = StoreValue.from(scope, out);
+        const [left, leftInst] = this.eval(scope, temp);
+        const [right, rightInst] = value.eval(scope, temp);
+        const targetAddress = endAddress ?? new LiteralValue(null);
+        return [
+            temp,
+            [
+                ...leftInst,
+                ...temp["="](scope, left)[1],
+                new JumpInstruction(targetAddress, EJumpKind.Equal, left, new LiteralValue(0)),
+                ...rightInst,
+                ...temp["="](scope, right)[1],
+                ...(endAddress ? [] : [new AddressResolver(targetAddress)]),
+            ],
+        ];
+    }
+    "||"(scope, value, out, endAddress) {
+        const temp = StoreValue.from(scope, out);
+        const [left, leftInst] = this.eval(scope, temp);
+        const [right, rightInst] = value.eval(scope, temp);
+        const targetAddress = endAddress ?? new LiteralValue(null);
+        return [
+            temp,
+            [
+                ...leftInst,
+                ...temp["="](scope, left)[1],
+                new JumpInstruction(targetAddress, EJumpKind.NotEqual, left, new LiteralValue(0)),
+                ...rightInst,
+                ...temp["="](scope, right)[1],
+                ...(endAddress ? [] : [new AddressResolver(targetAddress)]),
+            ],
+        ];
+    }
 }
-for (const key in operatorMap$2) {
+for (const k in operatorMap$2) {
+    const key = k;
+    if (key === "&&" || key == "||")
+        continue;
     const kind = operatorMap$2[key];
     BaseValue.prototype[key] = function (scope, value, out) {
         const [left, leftInst] = this.eval(scope);
@@ -774,19 +803,38 @@ class LiteralValue extends BaseValue {
         super();
         this.mutability = EMutability.constant;
         this.data = data;
-        this.name = this.toString();
+        this.name = JSON.stringify(this.data);
     }
     eval(_scope) {
         return [this, []];
     }
-    toString() {
-        return JSON.stringify(this.data);
+    toMlogString() {
+        const { data } = this;
+        // math constants are literal values
+        // so that the compiler can optimize them
+        // in operations
+        // this helps to print them in their global variable form
+        // instead of their literal value
+        switch (data) {
+            case mathConstants.E:
+                return "@e";
+            case mathConstants.PI:
+                return "@pi";
+            case mathConstants.degToRad:
+                return "@degToRad";
+            case mathConstants.radToDeg:
+                return "@radToDeg";
+        }
+        if (typeof data !== "string")
+            return JSON.stringify(data);
+        return formatMlogString(data);
     }
     get(scope, name) {
         if (!(name instanceof LiteralValue && name.isString()))
             return super.get(scope, name);
         const method = literalMethods[name.data];
-        if (!method)
+        if (!method ||
+            !Object.prototype.hasOwnProperty.call(literalMethods, name.data))
             throw new CompilerError(`The member [${name.debugString()}] does not exist on literal values.`);
         return [method.apply(this, [scope]), []];
     }
@@ -807,9 +855,6 @@ class LiteralValue extends BaseValue {
             return other.eval(scope, out);
         return [this, []];
     }
-    typeof() {
-        return [new LiteralValue("literal"), []];
-    }
     isString() {
         return typeof this.data === "string";
     }
@@ -817,7 +862,7 @@ class LiteralValue extends BaseValue {
         return typeof this.data === "number";
     }
     debugString() {
-        return this.toString();
+        return this.toMlogString();
     }
 }
 const operatorMap = {
@@ -835,12 +880,13 @@ const operatorMap = {
     "/": (a, b) => a / b,
     "%": (a, b) => a % b,
     "**": (a, b) => a ** b,
-    "|": (a, b) => a | b,
-    "&": (a, b) => a & b,
-    "^": (a, b) => a ^ b,
-    ">>": (a, b) => a >> b,
-    ">>>": (a, b) => a >> b,
-    "<<": (a, b) => a << b,
+    "|": bitwiseOp((a, b) => a | b),
+    "&": bitwiseOp((a, b) => a & b),
+    "^": bitwiseOp((a, b) => a ^ b),
+    // bit shifting only takes the lower 6 bits of the right operand
+    ">>": bitwiseOp((a, b) => a >> (b & 63n)),
+    "<<": bitwiseOp((a, b) => a << (b & 63n)),
+    ">>>": bitwiseOp((a, b) => BigInt.asUintN(64, a) >> (b & 63n)),
     "&&": (a, b) => +(a && b),
     "||": (a, b) => +(a || b),
 };
@@ -861,47 +907,99 @@ for (const k in operatorMap) {
         if (!(value instanceof LiteralValue)) {
             return BaseValue.prototype[key].apply(this, [scope, value, out]);
         }
-        return [new LiteralValue(fn(this.data, value.data)), []];
+        // patch constant string concatenation
+        // TODO: remove this in favor of the `concat` function
+        if (key === "+" && this.isString()) {
+            return [new LiteralValue(this.data + value.data), []];
+        }
+        return [new LiteralValue(fn(this.num, value.num)), []];
     };
 }
 const unaryOperatorMap = {
     "!": v => +!v,
-    "~": v => ~v,
+    "~": bitwiseOp(v => ~v),
     "u-": v => -v,
     "u+": v => +v,
 };
 for (const key in unaryOperatorMap) {
     LiteralValue.prototype[key] = function () {
         const fn = unaryOperatorMap[key];
-        return [new LiteralValue(fn(this.data)), []];
+        return [new LiteralValue(fn(this.num)), []];
+    };
+}
+/**
+ * Performs bitwise operations on 64-bit integers to ensure that the operations
+ * evaluated at compile time produce the same results as the mlog runtime.
+ *
+ * This is necessary because javascript converts its 64-bit floats into 32-bit
+ * integers to perform bitwise operations, however mlog casts 64-bit floats into
+ * 64-bit integers to achieve the same goal. This means that using javascript
+ * numbers to evaluate these operations at compile time can cause disparity
+ * between the compiler and the runtime for values bigger than `2^31-1`.
+ */
+function bitwiseOp(fn) {
+    return (...args) => {
+        const bigResult = fn(...args.map(BigInt));
+        // limit the result to 64 bits of precision (signed long)
+        // and convert it back into a number
+        return Number(BigInt.asIntN(64, bigResult));
     };
 }
+function formatMlogString(str) {
+    let result = '"';
+    for (let i = 0; i < str.length; i++) {
+        const char = str[i];
+        const code = str.charCodeAt(i);
+        if (char === '"') {
+            result += '\\"';
+        }
+        else if (char === "\\") {
+            result += "\\\\";
+        }
+        else if (char === "\n") {
+            result += "\\n";
+        }
+        else if (code < 0x20 || code >= 0x7f) {
+            result += `\\u${code.toString(16).padStart(4, "0")}`;
+        }
+        else {
+            result += char;
+        }
+    }
+    return result + '"';
+}
 
 /**
- * `StoreValue` represents values unknown at compile time,
- * mostly used with mutable variables and temporary values
+ * `StoreValue` represents values unknown at compile time, mostly used with
+ * mutable variables and temporary values.
+ *
+ * Stores are mutable by default.
  */
 class StoreValue extends BaseValue {
-    constructor(name, mutability = EMutability.mutable) {
+    constructor(name, mutability = EMutability.mutable, { temporary = false, volatile = false, } = {}) {
         super();
         this.name = name;
         this.mutability = mutability;
+        this.temporary = temporary;
+        this.volatile = volatile;
     }
     static from(scope, out, mutability = EMutability.mutable) {
         if (out instanceof StoreValue)
             return out;
-        const name = typeof out === "string" ? out : scope.makeTempName();
-        return new StoreValue(name, mutability);
+        const hasName = typeof out === "string";
+        const name = hasName ? out : scope.makeTempName();
+        return new StoreValue(name, mutability, {
+            temporary: !hasName,
+        });
     }
     static out(scope, out, mutability = EMutability.mutable) {
         if (!out || typeof out === "string") {
-            return new StoreValue(out ?? scope.makeTempName(), mutability);
+            return new StoreValue(out ?? scope.makeTempName(), mutability, {
+                temporary: !out,
+            });
         }
         return out;
     }
-    typeof() {
-        return [new LiteralValue("store"), []];
-    }
     "="(scope, value) {
         if (this.mutability !== EMutability.mutable &&
             this.mutability !== EMutability.init)
@@ -936,16 +1034,67 @@ class StoreValue extends BaseValue {
     eval(_scope) {
         return [this, []];
     }
+    get(scope, prop, out) {
+        const mutability = EMutability.readonly;
+        const thisCoordName = getThisCoordName(this, prop);
+        if (thisCoordName)
+            return [
+                new StoreValue(`@this${thisCoordName}`, EMutability.constant),
+                [],
+            ];
+        if (prop instanceof LiteralValue && prop.isString()) {
+            const result = StoreValue.from(scope, out, mutability);
+            // handle string length property
+            const propName = prop.data === "length" ? "size" : prop.data;
+            return [
+                result,
+                [
+                    new InstructionBase("sensor", result, this, formatSenseablePropName(propName)),
+                ],
+            ];
+        }
+        if (prop instanceof StoreValue) {
+            const temp = StoreValue.from(scope, out, mutability);
+            return [temp, [new InstructionBase("sensor", temp, this, prop)]];
+        }
+        throw new CompilerError(`The property [${prop.debugString()}] cannot be sensed`);
+    }
+    hasProperty(scope, prop) {
+        return ((prop instanceof LiteralValue && prop.isString()) ||
+            prop instanceof StoreValue);
+    }
     debugString() {
         return `StoreValue("${this.name}")`;
     }
-    toString() {
+    toMlogString() {
         return this.name;
     }
 }
+function formatSenseablePropName(name) {
+    if (itemNames.includes(name))
+        return "@" + camelToDashCase(name);
+    return "@" + name;
+}
 function compareStores(left, right) {
     return right instanceof StoreValue && right.name === left.name;
 }
+/**
+ * If `prop` is sensing on of the coordinates of `@this`, returns the coordinate
+ * name.
+ */
+function getThisCoordName(value, prop) {
+    if (value.name !== "@this")
+        return;
+    let name;
+    if (prop instanceof LiteralValue && prop.isString()) {
+        name = prop.data;
+    }
+    else if (prop instanceof StoreValue && prop.name.startsWith("@")) {
+        name = prop.name.slice(1);
+    }
+    if (name === "x" || name === "y")
+        return name;
+}
 
 class ObjectValue extends VoidValue {
     constructor(data = {}) {
@@ -965,25 +1114,18 @@ class ObjectValue extends VoidValue {
         });
         return new ObjectValue(data);
     }
-    typeof(scope, out) {
-        const { $typeof } = this.data;
-        if ($typeof)
-            return $typeof.call(scope, [], out);
-        return [new LiteralValue("object"), []];
-    }
     get(scope, key, out) {
         if (key instanceof LiteralValue && (key.isNumber() || key.isString())) {
             // avoids naming collisions with keys like
             // constructor or toString
             if (Object.prototype.hasOwnProperty.call(this.data, key.data)) {
-                // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-                return [this.data[key.data], []];
+                const member = this.data[key.data];
+                if (out)
+                    return member.eval(scope, out);
+                return [member, []];
             }
         }
-        const { $get } = this.data;
-        if (!$get)
-            throw new CompilerError(`The member [${key.debugString()}] is not present in [${this.debugString()}]`);
-        return $get.call(scope, [key], out);
+        throw new CompilerError(`The member [${key.debugString()}] is not present in [${this.debugString()}]`);
     }
     hasProperty(scope, prop) {
         if (prop instanceof LiteralValue && (prop.isNumber() || prop.isString())) {
@@ -992,22 +1134,10 @@ class ObjectValue extends VoidValue {
         }
         return false;
     }
-    eval(scope, out) {
-        const { $eval } = this.data;
-        if (!$eval)
-            return [this, []];
-        return $eval.call(scope, [], out);
-    }
-    call(scope, args, out) {
-        const { $call } = this.data;
-        if (!$call)
-            return super.call(scope, args, out);
-        return $call.call(scope, args, out);
+    eval() {
+        return [this, []];
     }
-    "??"(scope, other, out) {
-        const $ = this.data["$??"];
-        if ($)
-            return $.call(scope, [other], out);
+    "??"() {
         return [this, []];
     }
     debugString() {
@@ -1015,108 +1145,17 @@ class ObjectValue extends VoidValue {
             return `ObjectValue("${this.name}")`;
         return "ObjectValue";
     }
-    toString() {
+    toMlogString() {
         return '"[macro ObjectValue]"';
     }
 }
-for (const op of leftRightOperators) {
-    if (op === "??")
-        continue;
-    ObjectValue.prototype[op] = function (scope, value, out) {
-        const $ = this.data[`$${op}`];
-        if (!$)
-            return VoidValue.prototype[op].apply(this, [scope, value, out]);
-        return $.call(scope, [value], out);
-    };
-}
-for (const op of unaryOperators) {
-    if (op === "typeof")
-        continue;
-    ObjectValue.prototype[op] = function (scope, out) {
-        const $ = this.data[`$${op}`];
-        if (!$)
-            return VoidValue.prototype[op].apply(this, [scope, out]);
-        return $.call(scope, [], out);
-    };
-}
-for (const op of updateOperators) {
-    ObjectValue.prototype[op] = function (scope, prefix, out) {
-        const $ = this.data[`$${op}`];
-        if (!$)
-            return VoidValue.prototype[op].apply(this, [scope, prefix, out]);
-        return $.call(scope, [new LiteralValue(+prefix)], out);
-    };
-}
-
-/**
- * Properties that should return a new `SenseableValue`
- */
-const senseableProps = ["controller"];
-/**
- * Senseable values are "objects" in the mlog runtime that
- * have special properties that can be accessed
- * via the `sense` instruction.
- *
- * This class extends `StoreValue` to allow dynamic behavior
- * that is not possible with object macros.
- *
- * Note that these values are constant by default, so make sure
- * to set that field to `EMutability.mutable` if you want them to be assignable. Example:
- * ```
- * const value = new SenseableValue(name, EMutability.mutable);
- * ```
- */
-class SenseableValue extends StoreValue {
-    constructor(name, mutability = EMutability.constant) {
-        super(name, mutability);
-    }
-    static from(scope, out, mutability = EMutability.constant) {
-        if (out instanceof SenseableValue)
-            return out;
-        const name = typeof out === "string" ? out : scope.makeTempName();
-        return new SenseableValue(name, mutability);
-    }
-    static out(scope, out, mutability = EMutability.mutable) {
-        if (!out || typeof out === "string") {
-            return new SenseableValue(out ?? scope.makeTempName(), mutability);
-        }
-        return out;
-    }
-    get(scope, prop, out) {
-        const mutability = EMutability.readonly;
-        if (prop instanceof LiteralValue && prop.isString()) {
-            const name = itemNames.includes(prop.data)
-                ? camelToDashCase(prop.data)
-                : prop.data;
-            const result = senseableProps.includes(prop.data)
-                ? SenseableValue.from(scope, out, mutability)
-                : StoreValue.from(scope, out, mutability);
-            return [
-                result,
-                [new InstructionBase("sensor", result, this, `@${name}`)],
-            ];
-        }
-        if (prop instanceof StoreValue) {
-            const temp = SenseableValue.from(scope, out, mutability);
-            return [temp, [new InstructionBase("sensor", temp, this, prop)]];
-        }
-        throw new CompilerError(`The property [${prop.debugString()}] cannot be sensed`);
-    }
-    debugString() {
-        return `SenseableValue("${this.name}")`;
-    }
-    hasProperty(scope, prop) {
-        return ((prop instanceof LiteralValue && prop.isString()) ||
-            prop instanceof StoreValue);
-    }
-}
 
 /**
  * Specific case class, required on the ArrayPattern and ObjectPattern handlers
  * in order to keep the separation of concerns and make the code more modular.
  *
- * When it is assign a value, it will get it's own properties and recursively assign
- * each of them to their counterparts on the right hand value.
+ * When it is assign a value, it will get it's own properties and recursively
+ * assign each of them to their counterparts on the right hand value.
  */
 class DestructuringValue extends VoidValue {
     constructor(members) {
@@ -1143,14 +1182,14 @@ class DestructuringValue extends VoidValue {
     debugString() {
         return "DestructuringValue";
     }
-    toString() {
+    toMlogString() {
         return '"[macro DestructuringValue]"';
     }
 }
 
 /**
- * This class is used to handle some cases where the value
- * can't be directly evaluated by the node handler
+ * This class is used to handle some cases where the value can't be directly
+ * evaluated by the node handler
  */
 class LazyValue extends VoidValue {
     constructor(evalutate) {
@@ -1160,7 +1199,7 @@ class LazyValue extends VoidValue {
     debugString() {
         return "LazyValue";
     }
-    toString() {
+    toMlogString() {
         return '"[macro LazyValue]"';
     }
 }
@@ -1184,26 +1223,31 @@ class AssignmentValue extends VoidValue {
     debugString() {
         return "AssignmentValue";
     }
-    toString() {
+    toMlogString() {
         return '"[macro AssignmentValue]"';
     }
 }
 
 class Scope {
-    constructor(values, parent = null, stacked = false, ntemp = 0, name = "", inst = [], operationCache = {}, cacheDependencies = {}) {
+    constructor({ data = {}, parent = null, ntemp = 0, name = "", inst = [], operationCache = {}, cacheDependencies = {}, builtInModules = {}, } = {}) {
+        // Only `unchecked` is supposed to change this
+        this.checkIndexes = true;
+        this.data = data;
         this.parent = parent;
-        this.stacked = stacked;
         this.ntemp = ntemp;
         this.name = name;
         this.inst = inst;
         this.operationCache = operationCache;
         this.cacheDependencies = cacheDependencies;
-        // Only `unchecked` is supposed to change this
-        this.checkIndexes = true;
-        this.data = values;
+        this.builtInModules = builtInModules;
     }
     copy() {
-        const scope = new Scope({ ...this.data }, this.parent, this.stacked, this.ntemp, this.name, this.inst, { ...this.operationCache }, { ...this.cacheDependencies });
+        const scope = new Scope({
+            ...this,
+            data: { ...this.data },
+            operationCache: { ...this.operationCache },
+            cacheDependencies: { ...this.cacheDependencies },
+        });
         scope.break = this.break;
         scope.continue = this.continue;
         scope.function = this.function;
@@ -1217,8 +1261,14 @@ class Scope {
         scope.parent = this;
         return scope;
     }
-    createFunction(name, stacked = this.stacked) {
-        return new Scope({}, this, stacked, 0, name, this.inst);
+    createFunction(name) {
+        return new Scope({
+            data: {},
+            parent: this,
+            ntemp: 0,
+            name,
+            inst: this.inst,
+        });
     }
     has(identifier) {
         if (identifier in this.data)
@@ -1233,7 +1283,15 @@ class Scope {
             return value;
         if (this.parent)
             return this.parent.get(identifier);
-        throw new CompilerError(`${identifier} is not declared.`);
+        let message = `${identifier} is not declared.`;
+        const name = new LiteralValue(identifier);
+        for (const moduleName in this.builtInModules) {
+            const module = this.builtInModules[moduleName];
+            if (module.hasProperty(this, name)) {
+                message += ` Did you mean to use "${identifier}" exported from "${moduleName}"?`;
+            }
+        }
+        throw new CompilerError(message);
     }
     set(name, value) {
         if (name in this.data)
@@ -1247,9 +1305,7 @@ class Scope {
         return value;
     }
     make(identifier, name) {
-        const value = assign(new SenseableValue(name), {
-            mutability: EMutability.mutable,
-        });
+        const value = new StoreValue(name);
         return this.set(identifier, value);
     }
     makeTempName() {
@@ -1262,16 +1318,19 @@ class Scope {
     addCachedOperation(op, result, left, right) {
         if (!left.name || !result.name || (right && !right.name))
             return;
+        if (result.volatile || left.volatile || right?.volatile)
+            return;
         const id = formatCacheId(op, left, right);
         this.operationCache[id] = result;
         this.clearDependentCache(result);
         addCacheDependency(this, left.name, id);
-        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
         if (right)
             addCacheDependency(this, right.name, id);
         addCacheDependency(this, result.name, id);
     }
     getCachedOperation(op, left, right) {
+        if (left.volatile || right?.volatile)
+            return;
         const id = formatCacheId(op, left, right);
         const result = this.operationCache[id];
         if (result)
@@ -1310,6 +1369,9 @@ const VariableDeclaration = (c, scope, node) => {
 };
 const VariableDeclarator = (c, scope, node, out, kind = "let") => {
     const { init } = node;
+    if (es.isVoidPattern(node.id)) {
+        throw new CompilerError(`Cannot declare a variable with a void pattern`, node.id);
+    }
     const [value, inst] = Declare(c, scope, node.id, kind);
     if (init) {
         const [result, resultInst] = c.handleEval(scope, init, value.out);
@@ -1339,7 +1401,7 @@ const Declare = (c, scope, node, kind) => {
 const DeclareIdentifier = (c, scope, node, kind) => {
     const { name: identifier } = node;
     const name = nodeName(node, !c.compactNames && identifier);
-    const out = new SenseableValue(name, kind === "const" ? EMutability.init : EMutability.mutable);
+    const out = new StoreValue(name, kind === "const" ? EMutability.init : EMutability.mutable);
     const declarationValue = new DeclarationValue({
         c,
         scope,
@@ -1348,7 +1410,9 @@ const DeclareIdentifier = (c, scope, node, kind) => {
         handler(init, inst) {
             if (kind === "const" && !init)
                 throw new CompilerError("Constants must be initialized.", node);
-            if (kind === "const" && init?.mutability === EMutability.constant) {
+            if (kind === "const" &&
+                (init?.mutability === EMutability.constant ||
+                    init?.mutability === EMutability.immutable)) {
                 scope.set(identifier, init);
                 return [null, inst];
             }
@@ -1360,7 +1424,7 @@ const DeclareIdentifier = (c, scope, node, kind) => {
                     pipeInsts(value["="](scope, init), inst);
                 }
                 if (kind === "const")
-                    value.mutability = EMutability.constant;
+                    value.mutability = EMutability.immutable;
                 return [null, inst];
             }
         },
@@ -1474,7 +1538,7 @@ class DeclarationValue extends VoidValue {
     debugString() {
         return "DeclarationValue";
     }
-    toString() {
+    toMlogString() {
         return '"[macro DeclarationValue]"';
     }
 }
@@ -1508,23 +1572,92 @@ const LRExpression = (c, scope, node, out) => {
     return [op, [...leftInst, ...rightInst, ...opInst]];
 };
 const BinaryExpression = LRExpression;
-const LogicalExpression = (c, scope, node, out) => {
-    if (node.operator !== "??")
-        return LRExpression(c, scope, node, out);
-    const other = new LazyValue((scope, out) => c.handleEval(scope, node.right, out));
-    const [left, leftInst] = c.handleValue(scope, node.left);
-    const [result, resultInst] = left["??"](scope, other, out);
-    return [result, [...leftInst, ...resultInst]];
+const LogicalExpression = (c, scope, node, out, arg) => {
+    // TODO: these expressions can be optimized
+    // to skip some jump checks inside if statements.
+    // Remove this comment if this optimization is
+    // really not necessary
+    // patch to prevent the jump out value
+    // from being double-used later in the handler
+    if (out instanceof JumpOutValue) {
+        out = StoreValue.from(scope);
+    }
+    let leftNodeArg;
+    let rightNodeArg;
+    let operatorAddress;
+    let afterRightAddress;
+    let beforeRightAddress;
+    switch (node.operator) {
+        case "||": {
+            const { onFalsyAddress = new LiteralValue(null), onTruthyAddress = new LiteralValue(null), } = arg ?? {};
+            leftNodeArg = {
+                onTruthyAddress,
+                onFalsyAddress,
+            };
+            rightNodeArg = { onTruthyAddress };
+            operatorAddress = onTruthyAddress;
+            if (!arg?.onFalsyAddress)
+                beforeRightAddress = onFalsyAddress;
+            if (!arg?.onTruthyAddress)
+                afterRightAddress = onTruthyAddress;
+            break;
+        }
+        case "&&": {
+            const { onFalsyAddress = new LiteralValue(null), onTruthyAddress = new LiteralValue(null), } = arg ?? {};
+            leftNodeArg = { onTruthyAddress, onFalsyAddress };
+            rightNodeArg = { onFalsyAddress };
+            operatorAddress = onFalsyAddress;
+            if (!arg?.onTruthyAddress)
+                beforeRightAddress = onTruthyAddress;
+            if (!arg?.onFalsyAddress)
+                afterRightAddress = onFalsyAddress;
+            break;
+        }
+        case "??": {
+            const { onNonNullishAddress = new LiteralValue(null) } = arg ?? {};
+            leftNodeArg = {
+                onNonNullishAddress,
+                onTruthyAddress: onNonNullishAddress,
+            };
+            rightNodeArg = {
+                onNonNullishAddress,
+                onTruthyAddress: onNonNullishAddress,
+            };
+            operatorAddress = onNonNullishAddress;
+            if (!arg?.onNonNullishAddress)
+                afterRightAddress = onNonNullishAddress;
+            break;
+        }
+    }
+    const other = new LazyValue((scope, out) => {
+        const [value, inst] = c.handleEval(scope, node.right, out, node.right.type === "LogicalExpression" ? rightNodeArg : undefined);
+        if (!beforeRightAddress)
+            return [value, inst];
+        return [value, [new AddressResolver(beforeRightAddress), ...inst]];
+    });
+    const [left, leftInst] = c.handleEval(scope, node.left, out, node.left.type === "LogicalExpression" ? leftNodeArg : undefined);
+    // patch for situations where `left` is a temporary value and `out` is `undefined`
+    // since `out` is undefined there is potential for up to three temp values
+    // to be created. So to prevent that we will try to reuse `left` as an out value
+    // whenever possible
+    const resultOut = reuseTemporaryValue(left, out);
+    const [result, resultInst] = left[node.operator](scope, other, resultOut, operatorAddress);
+    return [
+        result,
+        [
+            ...leftInst,
+            ...resultInst,
+            ...(afterRightAddress ? [new AddressResolver(afterRightAddress)] : []),
+        ],
+    ];
 };
+const logicalAssignmentOperators = ["??=", "||=", "&&="];
 const AssignmentExpression = (c, scope, node) => {
     const [left, leftInst] = c.handleValue(scope, node.left);
     const leftOutput = left.toOut();
-    const [right, rightInst] = node.operator !== "??="
+    const [right, rightInst] = !logicalAssignmentOperators.includes(node.operator)
         ? c.handleEval(scope, node.right, node.operator === "=" ? leftOutput : undefined)
-        : [
-            new LazyValue((scope, out) => c.handleEval(scope, node.right, out)),
-            [],
-        ];
+        : [new LazyValue((scope, out) => c.handleEval(scope, node.right, out)), []];
     const [op, opInst] = left[node.operator](scope, right);
     scope.clearDependentCache(left);
     scope.clearDependentCache(leftOutput);
@@ -1548,7 +1681,60 @@ const UpdateExpression = (c, scope, { argument, operator, prefix }, out) => {
     const [op, opInst] = arg[operator](scope, prefix, out);
     return [op, [...argInst, ...opInst]];
 };
+const selectOperatorMap = {
+    "==": "equal",
+    "!=": "notEqual",
+    "<": "lessThan",
+    "<=": "lessThanEq",
+    ">": "greaterThan",
+    ">=": "greaterThanEq",
+    "===": "strictEqual",
+};
 const ConditionalExpression = (c, scope, node, out) => {
+    if (node.test.type === "BooleanLiteral" ||
+        node.test.type === "NumericLiteral" ||
+        node.test.type === "StringLiteral") {
+        if (node.test.value)
+            return c.handleEval(scope, node.consequent, out);
+        return c.handleEval(scope, node.alternate, out);
+    }
+    const result = StoreValue.from(scope, out);
+    const consequent = c.handleEval(scope, node.consequent, result);
+    const alternate = c.handleEval(scope, node.alternate, result);
+    if (consequent[1].length === 0 && alternate[1].length === 0) {
+        if (node.test.type === "BinaryExpression" &&
+            (node.test.operator in selectOperatorMap || node.test.operator === "!==")) {
+            const [left, leftInst] = c.handleEval(scope, node.test.left);
+            const [right, rightInst] = c.handleEval(scope, node.test.right);
+            const isStrictNotEqual = node.test.operator === "!==";
+            const op = isStrictNotEqual
+                ? "strictEqual"
+                : selectOperatorMap[node.test.operator];
+            const trueVal = isStrictNotEqual ? alternate[0] : consequent[0];
+            const falseVal = isStrictNotEqual ? consequent[0] : alternate[0];
+            return [
+                result,
+                [
+                    ...leftInst,
+                    ...rightInst,
+                    new InstructionBase("select", result, op, left, right, trueVal, falseVal),
+                ],
+            ];
+        }
+        const [test, testInst] = c.handleEval(scope, node.test);
+        if (test instanceof LiteralValue) {
+            if (test.data)
+                return [result, [...result["="](scope, consequent[0])[1]]];
+            return [result, [...result["="](scope, alternate[0])[1]]];
+        }
+        return [
+            result,
+            [
+                ...testInst,
+                new InstructionBase("select", result, "notEqual", test, "0", consequent[0], alternate[0]),
+            ],
+        ];
+    }
     const alternateStartAdress = new LiteralValue(null);
     const endExpressionAdress = new LiteralValue(null);
     const testOut = new JumpOutValue(node, alternateStartAdress, false);
@@ -1558,9 +1744,6 @@ const ConditionalExpression = (c, scope, node, out) => {
             return c.handleEval(scope, node.consequent, out);
         return c.handleEval(scope, node.alternate, out);
     }
-    const result = SenseableValue.from(scope, out, EMutability.mutable);
-    const consequent = c.handleEval(scope, node.consequent, result);
-    const alternate = c.handleEval(scope, node.alternate, result);
     return [
         result,
         [
@@ -1586,6 +1769,13 @@ const SequenceExpression = (c, scope, node, out) => {
     const value = pipeInsts(c.handleEval(scope, expressions[expressions.length - 1], out), inst);
     return [value, inst];
 };
+function reuseTemporaryValue(value, out) {
+    if (value instanceof StoreValue && value.temporary)
+        return new StoreValue(value.name, EMutability.mutable, {
+            temporary: true,
+        });
+    return out;
+}
 
 const Identifier = (c, scope, node) => {
     return [scope.get(node.name), []];
@@ -1669,8 +1859,9 @@ const IfStatement = (c, scope, node) => {
     return [null, inst];
 };
 /**
- * Returns `true` if the instruction array ends with an instruction
- * that already changes the control flow of the script (like `jump x always`, `end` , `stop`, etc)
+ * Returns `true` if the instruction array ends with an instruction that already
+ * changes the control flow of the script (like `jump x always`, `end` , `stop`,
+ * etc)
  */
 function endsWithControlFlow(inst) {
     for (let i = inst.length - 1; i >= 0; i--) {
@@ -1715,7 +1906,7 @@ const SwitchStatement = (c, scope, node) => {
         const bodyInst = lazy(() => c.handleMany(createCaseScope(innerScope), scase.consequent)[1]);
         const bodyAdress = new LiteralValue(null);
         const bodyLine = new AddressResolver(bodyAdress);
-        const canFallInto = !endsWithoutFalltrough(inst, endLine);
+        const canFallInto = !endsWithoutFalltrough(inst);
         let includeJump = !constantCase;
         const includeBody = !constantCase || canFallInto;
         if (!scase.test) {
@@ -1751,7 +1942,7 @@ const SwitchStatement = (c, scope, node) => {
                 // and all the other cases will never run
                 if (noFallInto &&
                     onlyConstantTests &&
-                    (isLastCase || endsWithoutFalltrough(bodyInst(), endLine))) {
+                    (isLastCase || endsWithoutFalltrough(bodyInst()))) {
                     return [null, [...bodyInst(), endLine]];
                 }
                 jump = c.handle(innerScope, scase, () => [
@@ -1789,7 +1980,7 @@ const SwitchStatement = (c, scope, node) => {
         ],
     ];
 };
-function endsWithoutFalltrough(inst, endLine) {
+function endsWithoutFalltrough(inst) {
     if (inst.length === 0)
         return true;
     for (let i = inst.length - 1; i >= 0; i--) {
@@ -1804,10 +1995,7 @@ function endsWithoutFalltrough(inst, endLine) {
             return false;
         if (instruction.hidden)
             continue;
-        return (instruction instanceof SetCounterInstruction ||
-            instruction.intent === EInstIntent.return ||
-            (instruction instanceof BreakInstruction &&
-                endLine.bonds.includes(instruction.address)));
+        return instruction.intent !== EInstIntent.none;
     }
     return false;
 }
@@ -1934,6 +2122,7 @@ const ForStatement = (c, parentScope, node) => {
         return [null, [...initInst]];
     }
     const isInfiniteLoop = test instanceof LiteralValue;
+    const [, bodyLines] = withAlwaysRuns(c.handle(scope, node.body), false);
     return [
         null,
         [
@@ -1941,17 +2130,19 @@ const ForStatement = (c, parentScope, node) => {
             startLoopLine,
             ...testLines,
             ...(isInfiniteLoop ? [] : JumpInstruction.or(test, testOut)),
-            ...withAlwaysRuns(c.handle(scope, node.body), false)[1],
+            ...bodyLines,
             beforeEndLine,
             ...updateLines,
             new JumpInstruction(startLoopAddr, EJumpKind.Always),
-            ...(isInfiniteLoop ? [] : [endLoopLine]),
+            ...(isInfiniteLoop && !usesAddressResolver(endLoopLine, bodyLines)
+                ? []
+                : [endLoopLine]),
         ],
     ];
 };
 
 class FunctionValue extends VoidValue {
-    constructor({ scope, params, body, c, out, }) {
+    constructor({ scope, params, body, c, out, inlineType, }) {
         super();
         this.mutability = EMutability.constant;
         this.macro = true;
@@ -1968,9 +2159,7 @@ class FunctionValue extends VoidValue {
         this.c = c;
         this.params = params;
         this.name = extractOutName(out) ?? scope.makeTempName();
-    }
-    typeof() {
-        return [new LiteralValue("function"), []];
+        this.inlineType = inlineType;
     }
     initScope() {
         this.childScope = this.scope.createFunction(this.name);
@@ -1991,8 +2180,10 @@ class FunctionValue extends VoidValue {
         this.initialized = true;
         this.initScope();
         this.addr = new LiteralValue(null);
-        this.temp = new SenseableValue(`${internalPrefix}f${this.name}`, EMutability.mutable);
+        this.temp = new StoreValue(`${internalPrefix}f${this.name}`);
         this.ret = new StoreValue(`${internalPrefix}r${this.name}`);
+        if (this.inlineType === EInlineType.always)
+            return;
         this.inst = [
             new AddressResolver(this.addr),
             ...this.c.handle(this.childScope, this.body)[1],
@@ -2026,9 +2217,7 @@ class FunctionValue extends VoidValue {
         const callAddressLiteral = new LiteralValue(null);
         // the value will be stored somewhere
         // no need to save it in a temporary variable
-        const temp = out
-            ? this.temp
-            : SenseableValue.from(scope, undefined, EMutability.mutable);
+        const temp = out ? this.temp : StoreValue.from(scope);
         const inst = this.paramValues
             .map((param, i) => param["="](scope, args[i] ?? new LiteralValue(null))[1])
             .reduce((s, c) => s.concat(c), [])
@@ -2053,7 +2242,7 @@ class FunctionValue extends VoidValue {
     }
     inlineCall(scope, args, out) {
         // create return value
-        this.inlineTemp = SenseableValue.from(this.childScope, out, EMutability.mutable);
+        this.inlineTemp = StoreValue.from(this.childScope, out);
         // make a copy of the function scope
         const fnScope = this.childScope.copy();
         this.tryingInline = true;
@@ -2084,20 +2273,24 @@ class FunctionValue extends VoidValue {
             throw new CompilerError(`Cannot call: expected ${min} arguments but got: ${args.length}`);
         }
         validateParameters(args, this.paramValues);
-        const inlineCall = this.inlineCall(scope, args, out);
-        hideRedundantJumps(inlineCall[1]);
-        const inlineSize = inlineCall[1].filter(i => !i.hidden).length;
-        if (this.inline || inlineSize <= this.callSize)
-            return inlineCall;
+        if (this.inlineType !== EInlineType.never) {
+            const inlineCall = this.inlineCall(scope, args, out);
+            hideRedundantJumps(inlineCall[1]);
+            if (this.inlineType === EInlineType.always)
+                return inlineCall;
+            const inlineSize = inlineCall[1].filter(i => !i.hidden).length;
+            if (inlineSize <= this.callSize)
+                return inlineCall;
+        }
         return this.normalCall(scope, args, out);
     }
     return(scope, arg) {
         this.ensureInit();
         if (arg && arg.macro) {
-            this.inline = true;
+            this.inlineType = EInlineType.always;
             return [null, []];
         }
-        if (this.inline || this.tryingInline)
+        if (this.tryingInline)
             return this.inlineReturn(scope, arg);
         return this.normalReturn(scope, arg);
     }
@@ -2106,21 +2299,21 @@ class FunctionValue extends VoidValue {
     }
     preCall() {
         this.ensureInit();
-        if (this.inline || this.tryingInline)
+        if (this.inlineType === EInlineType.always || this.tryingInline)
             return;
         return this.paramOuts;
     }
     debugString() {
         return `FunctionValue("${this.name}")`;
     }
-    toString() {
+    toMlogString() {
         return '"[macro FunctionValue]"';
     }
     unwrapParameter(param) {
         switch (param.type) {
             case "Identifier": {
                 const name = nodeName(param, !this.c.compactNames && param.name);
-                const value = new SenseableValue(name, EMutability.mutable);
+                const value = new StoreValue(name);
                 this.childScope.set(param.name, value);
                 this.paramNames.set(value, param.name);
                 return value;
@@ -2129,7 +2322,7 @@ class FunctionValue extends VoidValue {
                 const left = this.unwrapParameter(param.left);
                 const [rightValue, rightInst] = this.c.handleEval(this.childScope, param.right, left);
                 const right = new LazyValue(scope => {
-                    if (this.inline || this.tryingInline) {
+                    if (this.tryingInline) {
                         return this.c.handleEval(scope, param.right, left);
                     }
                     return [rightValue, [...rightInst]];
@@ -2202,7 +2395,7 @@ class FunctionValue extends VoidValue {
         }
     }
     hardSetParameter(scope, param, value = new LiteralValue(null)) {
-        if (param instanceof SenseableValue) {
+        if (param instanceof StoreValue) {
             const name = this.paramNames.get(param);
             scope.hardSet(name, value);
             return [];
@@ -2260,20 +2453,22 @@ function validateParameters(args, params) {
 
 function handleFunctionNode(c, scope, node, out) {
     let { params, body } = node;
-    if (es__namespace.isExpression(body)) {
+    if (es.isExpression(body)) {
         const { loc } = body;
-        const statement = es__namespace.returnStatement(body);
+        const statement = es.returnStatement(body);
         statement.loc = loc;
-        body = es__namespace.blockStatement([statement]);
+        body = es.blockStatement([statement]);
         body.loc = loc;
     }
+    const inlineType = getInlineType(body.directives);
     return [
         new FunctionValue({
             scope,
-            params: params,
+            params,
             body,
             c,
             out,
+            inlineType,
         }),
         [],
     ];
@@ -2290,6 +2485,20 @@ const FunctionDeclaration = (c, scope, node) => {
 };
 const FunctionExpression = ArrowFunctionExpression;
 const ObjectMethod = ArrowFunctionExpression;
+function getInlineType(directives) {
+    for (const directive of directives) {
+        const value = directive.value.value;
+        switch (value) {
+            case "inline":
+                return EInlineType.always;
+            case "inline never":
+                return EInlineType.never;
+            default:
+                throw new CompilerError(`Invalid function directive: "${value}"`);
+        }
+    }
+    return EInlineType.auto;
+}
 
 const CallExpression = (c, scope, node, out) => {
     const inst = [];
@@ -2342,7 +2551,20 @@ const ObjectExpression = (c, scope, node, out) => {
         }
         const memberOut = extractDestrucuringOut(out, index);
         const member = pipeInsts(c.handleEval(scope, value, memberOut), inst);
-        data[index] = member;
+        if (prop.type !== "ObjectMethod" || prop.kind === "method") {
+            data[index] = member;
+        }
+        else {
+            if (!(data[index] instanceof ObjectGetSetEntry))
+                data[index] = new ObjectGetSetEntry();
+            const entry = data[index];
+            if (prop.kind === "get") {
+                entry.getter = member;
+            }
+            else {
+                entry.setter = member;
+            }
+        }
     }
     return [new ObjectValue(data), inst];
 };
@@ -2351,7 +2573,7 @@ const ArrayExpression = (c, scope, node, out) => {
     const inst = [];
     node.elements.forEach((element, i) => {
         if (!element) {
-            items.push(undefined);
+            items.push(new LiteralValue(null));
             return;
         }
         const value = pipeInsts(c.handleEval(scope, element, extractDestrucuringOut(out, i)), inst);
@@ -2370,7 +2592,7 @@ const MemberExpression = (c, scope, node, out, optional = false) => {
         const [got, gotInst] = obj.get(scope, prop);
         return [got, [...objInst, ...propInst, ...gotInst]];
     }
-    const temp = SenseableValue.out(scope, out);
+    const temp = StoreValue.out(scope, out);
     const objOut = new DestructuringValue(new Map([
         [
             prop,
@@ -2455,6 +2677,24 @@ const AssignmentPattern = (c, scope, node) => {
     const right = new LazyValue((_, out) => c.handleEval(scope, node.right, out));
     return [new AssignmentValue(left, right), inst];
 };
+class ObjectGetSetEntry extends BaseValue {
+    constructor() {
+        super();
+        this.macro = true;
+    }
+    eval(scope, out) {
+        if (!this.getter)
+            throw new CompilerError("This property does not have a getter");
+        const [value, inst] = this.getter.call(scope, [], out);
+        return [value ?? new LiteralValue(null), inst];
+    }
+    "="(scope, value, out) {
+        if (!this.setter)
+            throw new CompilerError("This property does not have a setter");
+        const [, inst] = this.setter.call(scope, [value], out);
+        return [value, inst];
+    }
+}
 
 const TemplateLiteral = () => {
     throw new CompilerError("Template strings can only be used in tagged template literals. To inline mlog code use the asm function.");
@@ -2482,7 +2722,7 @@ const TSEnumDeclaration = (c, scope, node) => {
     let counter = 0;
     let lastType = "number";
     const data = {};
-    for (const member of node.members) {
+    for (const member of node.body.members) {
         if (lastType === "string" && !member.initializer)
             throw new CompilerError("This enum member must be initialized", member);
         const [value] = member.initializer
@@ -2510,6 +2750,41 @@ const TSNonNullExpression = (c, scope, node, out) => {
 };
 const TSSatisfiesExpression = (c, scope, node, out) => c.handle(scope, node.expression, undefined, out);
 
+const noExternalModuleErrorMessage = "Cannot import values from modules that are not built into the compiler";
+const ImportDeclaration = (c, scope, node) => {
+    if (node.importKind === "type")
+        return [null, []];
+    if (!(node.source.value in scope.builtInModules))
+        throw new CompilerError(noExternalModuleErrorMessage);
+    for (const specifier of node.specifiers) {
+        c.handle(scope, specifier, undefined, undefined, node.source.value);
+    }
+    return [null, []];
+};
+const ImportDefaultSpecifier = (c, scope, node, out, source) => {
+    if (!(source in scope.builtInModules))
+        return [null, []];
+    throw new CompilerError(`"${source}" does not have a default export`);
+};
+const ImportNamespaceSpecifier = (c, scope, node, out, source) => {
+    scope.set(node.local.name, scope.builtInModules[source]);
+    return [null, []];
+};
+const ImportSpecifier = (c, scope, node, out, source) => {
+    if (node.importKind === "type")
+        return [null, []];
+    const module = scope.builtInModules[source];
+    const { imported, local } = node;
+    const importedName = imported.type === "Identifier" ? imported.name : imported.value;
+    const key = new LiteralValue(importedName);
+    if (!module.hasProperty(scope, key)) {
+        throw new CompilerError(`The requested module '${source}' does not provide an export named '${importedName}'`);
+    }
+    const [value] = module.get(scope, key);
+    scope.set(local.name, value);
+    return [null, []];
+};
+
 var handlers = /*#__PURE__*/Object.freeze({
     __proto__: null,
     ArrayExpression: ArrayExpression,
@@ -2533,6 +2808,10 @@ var handlers = /*#__PURE__*/Object.freeze({
     FunctionExpression: FunctionExpression,
     Identifier: Identifier,
     IfStatement: IfStatement,
+    ImportDeclaration: ImportDeclaration,
+    ImportDefaultSpecifier: ImportDefaultSpecifier,
+    ImportNamespaceSpecifier: ImportNamespaceSpecifier,
+    ImportSpecifier: ImportSpecifier,
     LRExpression: LRExpression,
     LabeledStatement: LabeledStatement,
     LogicalExpression: LogicalExpression,
@@ -2585,14 +2864,14 @@ class MacroFunction extends VoidValue {
     debugString() {
         return "MacroFunction";
     }
-    toString() {
+    toMlogString() {
         return '"[macro MacroFunction]"';
     }
 }
 
-/* eslint-disable @typescript-eslint/no-non-null-assertion */
 const toRadians = (degrees) => (degrees * Math.PI) / 180;
 const toDegrees = (radians) => (radians * 180) / Math.PI;
+const mod = (f, n) => ((f % n) + n) % n;
 const mathOperations = {
     max: (a, b) => Math.max(a, b),
     min: (a, b) => Math.min(a, b),
@@ -2600,16 +2879,30 @@ const mathOperations = {
         const angle = toDegrees(Math.atan2(y, x));
         return angle < 0 ? angle + 360 : angle;
     },
+    angleDiff: (x, y) => {
+        const a = mod(x, 360);
+        const b = mod(y, 360);
+        return Math.min(a - b < 0 ? a - b + 360 : a - b, b - a < 0 ? b - a + 360 : b - a);
+    },
     len: (a, b) => Math.sqrt(a ** 2 + b ** 2),
     noise: null,
     abs: a => Math.abs(a),
+    sign: a => {
+        if (a > 0)
+            return 1;
+        if (a < 0)
+            return -1;
+        return 0;
+    },
     log: a => Math.log(a),
+    logn: (a, b) => Math.log(a) / Math.log(b),
     log10: a => Math.log10(a),
     sin: a => Math.sin(toRadians(a)),
     cos: a => Math.cos(toRadians(a)),
     tan: a => Math.tan(toRadians(a)),
     floor: a => Math.floor(a),
     ceil: a => Math.ceil(a),
+    round: a => Math.round(a),
     sqrt: a => Math.sqrt(a),
     asin: a => toDegrees(Math.asin(a)),
     acos: a => toDegrees(Math.acos(a)),
@@ -2617,23 +2910,139 @@ const mathOperations = {
     // yes, this doesn't work with negative numbers
     // but the game also implements it this way.
     idiv: (a, b) => Math.floor(a / b),
+    emod: (a, b) => mod(a, b),
     pow: (a, b) => Math.pow(a, b),
     rand: null,
 };
 const orderIndependentOperations = ["max", "min", "len"];
 function createMacroMathOperations() {
     const macroMathOperations = {
-        PI: new StoreValue("@pi", EMutability.constant),
-        E: new StoreValue("@e", EMutability.constant),
-        degToRad: new StoreValue("@degToRad", EMutability.constant),
-        radToDeg: new StoreValue("@radToDeg", EMutability.constant),
+        PI: new LiteralValue(mathConstants.PI),
+        E: new LiteralValue(mathConstants.E),
+        degToRad: new LiteralValue(mathConstants.degToRad),
+        radToDeg: new LiteralValue(mathConstants.radToDeg),
+        trunc: new MacroFunction((scope, out, x) => {
+            assertArgumentCount(+!!x, 1);
+            // subtracts the decimal part of a number from itself
+            // works with both positive and negative numbers,
+            // returning the integer part of the number
+            // return a - (a % 1);
+            const inst = [];
+            const one = new LiteralValue(1);
+            const rest = pipeInsts(x["%"](scope, one), inst);
+            const result = pipeInsts(x["-"](scope, rest, out), inst);
+            return [result, inst];
+        }),
+        exp: new MacroFunction((scope, out, x) => {
+            assertArgumentCount(+!!x, 1);
+            // return Math.E ** x;
+            const inst = [];
+            const { E } = macroMathOperations;
+            const result = pipeInsts(E["**"](scope, x, out), inst);
+            return [result, inst];
+        }),
+        expm1: new MacroFunction((scope, out, x) => {
+            assertArgumentCount(+!!x, 1);
+            // return Math.exp(x) - 1;
+            const inst = [];
+            const { exp } = macroMathOperations;
+            const ex = pipeInsts(exp.call(scope, [x]), inst);
+            const one = new LiteralValue(1);
+            const subtracted = pipeInsts(ex["-"](scope, one, out), inst);
+            return [subtracted, inst];
+        }),
+        cosh: new MacroFunction((scope, out, degrees) => {
+            assertArgumentCount(+!!degrees, 1);
+            // const x = degrees * Math.degToRad;
+            // return (Math.exp(x) + Math.exp(-x)) / 2;
+            const { exp, degToRad } = macroMathOperations;
+            const inst = [];
+            const x = pipeInsts(degrees["*"](scope, degToRad), inst);
+            const expx = pipeInsts(exp.call(scope, [x]), inst);
+            const negativeX = pipeInsts(x["u-"](scope), inst);
+            const expnegx = pipeInsts(exp.call(scope, [negativeX]), inst);
+            const sum = pipeInsts(expx["+"](scope, expnegx), inst);
+            const result = pipeInsts(sum["/"](scope, new LiteralValue(2), out), inst);
+            return [result, inst];
+        }),
+        acosh: new MacroFunction((scope, out, x) => {
+            assertArgumentCount(+!!x, 1);
+            // return Math.log(x + Math.sqrt(x ** 2 - 1)) * Math.radToDeg;
+            const { log, sqrt, radToDeg } = macroMathOperations;
+            const inst = [];
+            const x2 = pipeInsts(x["**"](scope, new LiteralValue(2)), inst);
+            const one = new LiteralValue(1);
+            const x2minus1 = pipeInsts(x2["-"](scope, one), inst);
+            const sqrtx2minus1 = pipeInsts(sqrt.call(scope, [x2minus1]), inst);
+            const sum = pipeInsts(x["+"](scope, sqrtx2minus1), inst);
+            const radians = pipeInsts(log.call(scope, [sum], out), inst);
+            const degrees = pipeInsts(radians["*"](scope, radToDeg), inst);
+            return [degrees, inst];
+        }),
+        sinh: new MacroFunction((scope, out, degrees) => {
+            assertArgumentCount(+!!degrees, 1);
+            // const x = degrees * Math.degToRad;
+            // return (Math.exp(x) - Math.exp(-x)) / 2;
+            const { exp, degToRad } = macroMathOperations;
+            const inst = [];
+            const x = pipeInsts(degrees["*"](scope, degToRad), inst);
+            const expx = pipeInsts(exp.call(scope, [x]), inst);
+            const negativeX = pipeInsts(x["u-"](scope), inst);
+            const expnegx = pipeInsts(exp.call(scope, [negativeX]), inst);
+            const sub = pipeInsts(expx["-"](scope, expnegx), inst);
+            const result = pipeInsts(sub["/"](scope, new LiteralValue(2)), inst);
+            return [result, inst];
+        }),
+        asinh: new MacroFunction((scope, out, x) => {
+            assertArgumentCount(+!!x, 1);
+            // return Math.log(x + Math.sqrt(x ** 2 + 1)) * Math.radToDeg;
+            const { log, sqrt, radToDeg } = macroMathOperations;
+            const inst = [];
+            const x2 = pipeInsts(x["**"](scope, new LiteralValue(2)), inst);
+            const x2plus1 = pipeInsts(x2["+"](scope, new LiteralValue(1)), inst);
+            const sqrtx2plus1 = pipeInsts(sqrt.call(scope, [x2plus1]), inst);
+            const sum = pipeInsts(x["+"](scope, sqrtx2plus1), inst);
+            const radians = pipeInsts(log.call(scope, [sum], out), inst);
+            const degrees = pipeInsts(radians["*"](scope, radToDeg), inst);
+            return [degrees, inst];
+        }),
+        tanh: new MacroFunction((scope, out, degrees) => {
+            assertArgumentCount(+!!degrees, 1);
+            // const x = degrees * Math.degToRad;
+            // return (Math.exp(x) - Math.exp(-x)) / (Math.exp(x) + Math.exp(-x));
+            const { exp, degToRad } = macroMathOperations;
+            const inst = [];
+            const x = pipeInsts(degrees["*"](scope, degToRad), inst);
+            const expx = pipeInsts(exp.call(scope, [x]), inst);
+            const negativeX = pipeInsts(x["u-"](scope), inst);
+            const expnegx = pipeInsts(exp.call(scope, [negativeX]), inst);
+            const sub = pipeInsts(expx["-"](scope, expnegx), inst);
+            const sum = pipeInsts(expx["+"](scope, expnegx), inst);
+            const result = pipeInsts(sub["/"](scope, sum, out), inst);
+            return [result, inst];
+        }),
+        atanh: new MacroFunction((scope, out, x) => {
+            assertArgumentCount(+!!x, 1);
+            // return (Math.log((1 + x) / (1 - x)) / 2) * Math.radToDeg;
+            const { log, radToDeg } = macroMathOperations;
+            const inst = [];
+            const one = new LiteralValue(1);
+            const two = new LiteralValue(2);
+            const sum = pipeInsts(one["+"](scope, x), inst);
+            const sub = pipeInsts(one["-"](scope, x), inst);
+            const div = pipeInsts(sum["/"](scope, sub), inst);
+            const logOfDiv = pipeInsts(log.call(scope, [div]), inst);
+            const radians = pipeInsts(logOfDiv["/"](scope, two, out), inst);
+            const degrees = pipeInsts(radians["*"](scope, radToDeg), inst);
+            return [degrees, inst];
+        }),
     };
     for (const key in mathOperations) {
         const fn = mathOperations[key];
         macroMathOperations[key] = new MacroFunction((scope, out, a, b) => {
             const argumentCount = +!!a + +!!b;
-            if (fn && argumentCount != fn.length) {
-                throw new CompilerError(`Expected ${fn.length} arguments, but got ${argumentCount}`);
+            if (fn) {
+                assertArgumentCount(argumentCount, fn.length);
             }
             const cacheKey = getCacheKey(key);
             if (b) {
@@ -2677,6 +3086,11 @@ function getCacheKey(key) {
         return "**";
     return key;
 }
+function assertArgumentCount(current, expected) {
+    if (current != expected) {
+        throw new CompilerError(`Expected ${expected} arguments, but got ${current}`);
+    }
+}
 class MlogMath extends ObjectValue {
     constructor() {
         super(createMacroMathOperations());
@@ -2716,7 +3130,10 @@ function assertLiterals(values, message) {
     }
 }
 
-/** Used to create namespaces that contain multiple methods that map into instructions */
+/**
+ * Used to create namespaces that contain multiple methods that map into
+ * instructions
+ */
 function createOverloadNamespace({ overloads, handler, }) {
     const result = {};
     for (const key in overloads) {
@@ -2792,6 +3209,20 @@ class Draw extends ObjectValue {
                     named: "options",
                     args: ["x", "y", "image", "size", "rotation"],
                 },
+                print: {
+                    named: "options",
+                    args: ["x", "y", "align"],
+                },
+                translate: {
+                    args: ["x", "y"],
+                },
+                scale: {
+                    args: ["x", "y"],
+                },
+                rotate: {
+                    args: ["degrees"],
+                },
+                reset: { args: [] },
             },
             handler(scope, overload, out, ...args) {
                 return [null, [new InstructionBase("draw", overload, ...args)]];
@@ -2803,31 +3234,72 @@ class Draw extends ObjectValue {
 
 class Print extends MacroFunction {
     constructor() {
-        super((scope, out, ...values) => {
-            const [first] = values;
+        super((scope, out, ...args) => {
             const inst = [];
-            if (!isTemplateObjectArray(first)) {
-                for (const value of values) {
+            const values = getPrintValues(scope, args).filter(value => !(value instanceof LiteralValue) ||
+                !value.isString() ||
+                value.data.length > 0);
+            if (!needsFormatString(values)) {
+                for (let i = 0; i < values.length; i++) {
+                    const value = values[i];
                     inst.push(new InstructionBase("print", value));
                 }
-                return [null, inst];
             }
-            // `first` is likely a template strings array
-            // maybe this should be checked in another way?
-            const { length } = first.data;
-            for (let i = 1; i < values.length; i++) {
-                const [string] = first.get(scope, new LiteralValue(i - 1));
-                if (string.data)
-                    inst.push(new InstructionBase("print", string));
-                inst.push(new InstructionBase("print", values[i]));
+            else {
+                let formatString = "";
+                for (let i = 0; i < values.length; i++) {
+                    const value = values[i];
+                    if (value instanceof LiteralValue) {
+                        formatString += value.data;
+                    }
+                    else {
+                        // mlog replaces the first occurrence of {0}
+                        // so we don't need to increment the placeholder
+                        // number
+                        formatString += "{0}";
+                    }
+                }
+                inst.push(new InstructionBase("print", new LiteralValue(formatString)));
+                for (let i = 0; i < values.length; i++) {
+                    const value = values[i];
+                    if (value instanceof LiteralValue)
+                        continue;
+                    inst.push(new InstructionBase("format", value));
+                }
             }
-            const [tail] = first.get(scope, new LiteralValue(length.data - 1));
-            if (tail.data)
-                inst.push(new InstructionBase("print", tail));
             return [null, inst];
         });
     }
 }
+function getPrintValues(scope, args) {
+    const first = args[0];
+    if (!isTemplateObjectArray(first)) {
+        return args;
+    }
+    const values = [];
+    const rest = args.slice(1);
+    // the number of strings in the template object array
+    // is always one more than the number of values
+    // this loop intercalates the values and the strings
+    // into the values array
+    for (let i = 0; i <= rest.length; i++) {
+        const [string] = first.get(scope, new LiteralValue(i));
+        values.push(string);
+        if (i < rest.length)
+            values.push(rest[i]);
+    }
+    return values;
+}
+function needsFormatString(values) {
+    for (let i = 0; i < values.length; i++) {
+        const value = values[i];
+        if (!(value instanceof LiteralValue))
+            continue;
+        if (!value.isString() || value.data.length > 0)
+            return true;
+    }
+    return false;
+}
 
 const defaultTargetName$1 = "message1";
 class PrintFlush extends MacroFunction {
@@ -2835,8 +3307,8 @@ class PrintFlush extends MacroFunction {
         super((scope, out, target) => {
             if (!target)
                 return [null, [new InstructionBase("printflush", defaultTargetName$1)]];
-            if (!(target instanceof SenseableValue))
-                throw new CompilerError("The printflush target must be a senseable value");
+            if (!(target instanceof StoreValue))
+                throw new CompilerError("The printflush target must be a store value");
             return [null, [new InstructionBase("printflush", target)]];
         });
     }
@@ -2848,8 +3320,8 @@ class DrawFlush extends MacroFunction {
         super((scope, out, target) => {
             if (!target)
                 return [null, [new InstructionBase("drawflush", defaultTargetName)]];
-            if (!(target instanceof SenseableValue))
-                throw new CompilerError("The drawflush target must be a senseable value");
+            if (!(target instanceof StoreValue))
+                throw new CompilerError("The drawflush target must be a store value");
             return [null, [new InstructionBase("drawflush", target)]];
         });
     }
@@ -2865,9 +3337,7 @@ class GetBlock extends ObjectValue {
                 building: { args: ["x", "y"] },
             },
             handler(scope, overload, out, x, y) {
-                const output = overload === "building"
-                    ? SenseableValue.from(scope, out, EMutability.constant)
-                    : StoreValue.from(scope, out, EMutability.constant);
+                const output = StoreValue.from(scope, out);
                 return [
                     output,
                     [new InstructionBase("getblock", overload, output, x, y)],
@@ -2884,7 +3354,7 @@ class GetLink extends MacroFunction {
             if (!(index instanceof StoreValue) &&
                 (!(index instanceof LiteralValue) || !index.isNumber()))
                 throw new CompilerError("The getlink index must be a number literal or a store");
-            const outBuild = SenseableValue.from(scope, out, EMutability.constant);
+            const outBuild = StoreValue.from(scope, out);
             return [outBuild, [new InstructionBase("getlink", outBuild, index)]];
         });
     }
@@ -2935,8 +3405,8 @@ class Radar extends MacroFunction {
         super((scope, out, options) => {
             assertIsObjectMacro(options, "The radar options");
             const { building, filters, order, sort } = options.data;
-            if (!(building instanceof SenseableValue))
-                throw new CompilerError("The building must a senseable value");
+            if (!(building instanceof StoreValue))
+                throw new CompilerError("The building must a store value");
             assertIsArrayMacro(filters, "filters");
             const { length } = filters.data;
             if (!(length instanceof LiteralValue) || !length.isNumber())
@@ -2951,7 +3421,7 @@ class Radar extends MacroFunction {
             if (!(order instanceof LiteralValue || order instanceof StoreValue))
                 throw new CompilerError("The radar order must be a literal or a store");
             assertLiteralOneOf(sort, validRadarSorts, "The radar sort");
-            const outUnit = SenseableValue.from(scope, out, EMutability.constant);
+            const outUnit = StoreValue.from(scope, out);
             return [
                 outUnit,
                 [
@@ -2967,9 +3437,9 @@ class Sensor extends MacroFunction {
         super((scope, out, property, target) => {
             if (!(property instanceof StoreValue))
                 throw new CompilerError("The sensor property must be a store");
-            if (!(target instanceof SenseableValue))
-                throw new CompilerError("The sensor target must be a senseable value");
-            const temp = SenseableValue.from(scope, out, EMutability.readonly);
+            if (!(target instanceof StoreValue))
+                throw new CompilerError("The sensor target must be a store value");
+            const temp = StoreValue.from(scope, out);
             return [temp, [new InstructionBase("sensor", temp, target, property)]];
         });
     }
@@ -2994,6 +3464,7 @@ class Lookup extends ObjectValue {
                 unit: { args: ["index"] },
                 item: { args: ["index"] },
                 liquid: { args: ["index"] },
+                team: { args: ["index"] },
             },
             handler(scope, overload, out, index) {
                 const output = StoreValue.from(scope, out);
@@ -3057,16 +3528,16 @@ class SpawnUnit extends MacroFunction {
     constructor() {
         super((scope, out, options) => {
             assertIsObjectMacro(options, "The options");
-            const { type, x, y, team, rotation } = options.data;
+            const { type, x, y, team, rotation, effect } = options.data;
             assertIsRuntimeValue(type, "type");
             assertIsRuntimeValue(x, "x");
             assertIsRuntimeValue(y, "y");
             assertIsRuntimeValue(team, "team");
-            const output = SenseableValue.from(scope, out, EMutability.constant);
+            const output = StoreValue.from(scope, out);
             return [
                 output,
                 [
-                    new InstructionBase("spawn", type, x, y, rotation ?? "0", team, output),
+                    new InstructionBase("spawn", type, x, y, rotation ?? "0", team, output, effect ?? "true"),
                 ],
             ];
         });
@@ -3104,8 +3575,9 @@ class UnitControl extends ObjectValue {
                 stop: { args: [] },
                 move: { args: ["x", "y"] },
                 approach: { named: "options", args: ["x", "y", "radius"] },
+                pathfind: { args: ["x", "y"] },
+                autoPathfind: { args: [] },
                 boost: { args: ["enable"] },
-                pathfind: { args: [] },
                 target: { named: "options", args: ["x", "y", "shoot"] },
                 targetp: { named: "options", args: ["unit", "shoot"] },
                 itemDrop: { args: ["target", "amount"] },
@@ -3119,6 +3591,9 @@ class UnitControl extends ObjectValue {
                     named: "options",
                     args: ["x", "y", "block", "rotation", { key: "config", default: "" }],
                 },
+                deconstruct: {
+                    args: ["x", "y"],
+                },
                 getBlock: {
                     args: ["x", "y"],
                 },
@@ -3136,7 +3611,7 @@ class UnitControl extends ObjectValue {
                 switch (overload) {
                     case "getBlock": {
                         const outType = StoreValue.from(scope, extractDestrucuringOut(out, 0));
-                        const outBuilding = SenseableValue.from(scope, extractDestrucuringOut(out, 1));
+                        const outBuilding = StoreValue.from(scope, extractDestrucuringOut(out, 1));
                         const outFloor = StoreValue.from(scope, extractDestrucuringOut(out, 2));
                         result = ObjectValue.fromArray([outType, outBuilding, outFloor]);
                         extraArgs = [outType, outBuilding, outFloor];
@@ -3177,7 +3652,7 @@ class UnitRadar extends MacroFunction {
             if (!(order instanceof LiteralValue || order instanceof StoreValue))
                 throw new CompilerError("The radar order must be a literal or a store");
             assertLiteralOneOf(sort, validRadarSorts, "The radar sort");
-            const outUnit = SenseableValue.from(scope, out, EMutability.constant);
+            const outUnit = StoreValue.from(scope, out);
             return [
                 outUnit,
                 [
@@ -3219,7 +3694,7 @@ class UnitLocate extends ObjectValue {
                 const outFound = StoreValue.from(scope, extractDestrucuringOut(out, 0));
                 const outX = StoreValue.from(scope, extractDestrucuringOut(out, 1));
                 const outY = StoreValue.from(scope, extractDestrucuringOut(out, 2));
-                const outBuilding = SenseableValue.from(scope, overload === "ore" ? discardedName : extractDestrucuringOut(out, 3));
+                const outBuilding = StoreValue.from(scope, overload === "ore" ? discardedName : extractDestrucuringOut(out, 3));
                 const outArgs = [outX, outY, outFound, outBuilding];
                 let inputArgs = [];
                 switch (overload) {
@@ -3258,20 +3733,29 @@ class UnitLocate extends ObjectValue {
 }
 
 const validEffects = [
+    "none",
     "burning",
     "freezing",
     "unmoving",
+    "slow",
+    "fast",
     "wet",
+    "muddy",
     "melting",
     "sapped",
-    "electrified",
-    "spore-slowed",
     "tarred",
     "overdrive",
     "overclock",
-    "boss",
+    "shielded",
     "shocked",
     "blasted",
+    "corroded",
+    "boss",
+    "spore-slowed",
+    "disarmed",
+    "electrified",
+    "invincible",
+    "dynamic",
 ];
 class ApplyStatus extends ObjectValue {
     constructor() {
@@ -3283,15 +3767,25 @@ class ApplyStatus extends ObjectValue {
                 clear: { args: ["status", "unit"] },
             },
             handler(scope, overload, out, effect, unit, duration) {
-                if (!(effect instanceof LiteralValue))
-                    throw new CompilerError("The status effect must be a string literal");
-                assertLiteralOneOf(effect, validEffects, "The status effect");
-                return [
-                    null,
-                    [
-                        new InstructionBase("status", String(overload !== "apply"), effect.data, unit, duration),
-                    ],
+                let effectValue = effect;
+                if (effect instanceof LiteralValue && effect.isString()) {
+                    if (effect.data.startsWith("@status-")) {
+                        effectValue = effect.data;
+                    }
+                    else {
+                        assertLiteralOneOf(effect, validEffects, "The status effect");
+                        effectValue = `@status-${effect.data}`;
+                    }
+                }
+                const instArgs = [
+                    "status",
+                    String(overload !== "apply"),
+                    effectValue,
+                    unit,
                 ];
+                if (duration)
+                    instArgs.push(duration);
+                return [null, [new InstructionBase(...instArgs)]];
             },
         });
         super(data);
@@ -3301,14 +3795,9 @@ class ApplyStatus extends ObjectValue {
 class SpawnWave extends MacroFunction {
     constructor() {
         super((scope, out, natural, x, y) => {
-            if (!(natural instanceof LiteralValue) ||
-                (natural.data !== 1 && natural.data !== 0))
-                throw new CompilerError("The 'natural' argument must be a boolean literal");
             return [
                 null,
-                [
-                    new InstructionBase("spawnwave", x ?? "10", y ?? "10", String(!!natural.data)),
-                ],
+                [new InstructionBase("spawnwave", x ?? "null", y ?? "null", natural)],
             ];
         });
     }
@@ -3330,16 +3819,25 @@ class SetRule extends ObjectValue {
                 unitCap: { args: ["cap"] },
                 mapArea: { named: "options", args: ["x", "y", "width", "height"] },
                 lighting: { args: ["enabled"] },
+                canGameOver: { args: ["enabled"] },
                 ambientLight: { args: ["rgbaData"] },
                 solarMultiplier: { args: ["multiplier"] },
+                dragMultiplier: { args: ["multiplier"] },
+                ban: { args: ["content"] },
+                unban: { args: ["content"] },
                 buildSpeed: { args: ["team", "multiplier"] },
+                unitHealth: { args: ["team", "multiplier"] },
                 unitBuildSpeed: { args: ["team", "multiplier"] },
+                unitMineSpeed: { args: ["team", "multiplier"] },
                 unitCost: { args: ["team", "multiplier"] },
                 unitDamage: { args: ["team", "multiplier"] },
                 blockHealth: { args: ["team", "multiplier"] },
                 blockDamage: { args: ["team", "multiplier"] },
                 rtsMinWeight: { args: ["team", "value"] },
                 rtsMinSquad: { args: ["team", "value"] },
+                unitLight: { args: ["enabled"] },
+                pauseDisabled: { args: ["enabled"] },
+                musicVolume: { args: ["volume"] },
             },
             handler(scope, overload, out, ...args) {
                 const params = ["10", "0", "0", "100", "100"];
@@ -3353,7 +3851,9 @@ class SetRule extends ObjectValue {
                         break;
                     }
                     case "buildSpeed":
+                    case "unitHealth":
                     case "unitBuildSpeed":
+                    case "unitMineSpeed":
                     case "unitCost":
                     case "unitDamage":
                     case "blockHealth":
@@ -3383,9 +3883,34 @@ class FlushMessage extends ObjectValue {
                 mission: { args: [] },
                 announce: { args: ["duration"] },
                 toast: { args: ["duration"] },
+                notifySync: { args: [] },
+                missionSync: { args: [] },
+                announceSync: { args: ["duration"] },
+                toastSync: { args: ["duration"] },
             },
             handler(scope, overload, out, duration) {
-                return [null, [new InstructionBase("message", overload, duration)]];
+                let result = null;
+                let arg = "0";
+                switch (overload) {
+                    case "announce":
+                    case "toast":
+                    case "mission":
+                    case "notify":
+                        result = StoreValue.from(scope, out);
+                        arg = result;
+                        break;
+                    case "announceSync":
+                    case "missionSync":
+                    case "toastSync":
+                    case "notifySync":
+                        result = null;
+                        arg = "@wait";
+                        break;
+                }
+                return [
+                    result,
+                    [new InstructionBase("message", overload, duration, arg)],
+                ];
             },
         });
         super(data);
@@ -3399,8 +3924,19 @@ class Cutscene extends ObjectValue {
                 pan: { named: "options", args: ["x", "y", "speed"] },
                 zoom: { args: ["level"] },
                 stop: { args: [] },
+                active: { args: [] },
+                shake: { args: ["amount", "duration"] },
+                getHud: { args: [] },
+                setHud: { args: ["shown"] },
             },
             handler(scope, overload, out, ...args) {
+                if (overload === "active" || overload === "getHud") {
+                    const result = StoreValue.from(scope, out);
+                    return [
+                        result,
+                        [new InstructionBase("cutscene", overload, result, "0", "0", "0")],
+                    ];
+                }
                 const params = Object.assign(["100", "100", "0.06", "0"], args);
                 return [null, [new InstructionBase("cutscene", overload, ...params)]];
             },
@@ -3438,8 +3974,10 @@ class Fetch extends ObjectValue {
     constructor() {
         const data = createOverloadNamespace({
             overloads: {
-                unit: { args: ["team", "index"] },
-                unitCount: { args: ["team"] },
+                unit: {
+                    args: ["team", "index", { key: "type", default: "null" }],
+                },
+                unitCount: { args: ["team", { key: "type", default: "null" }] },
                 player: { args: ["team", "index"] },
                 playerCount: { args: ["team"] },
                 core: { args: ["team", "index"] },
@@ -3448,9 +3986,9 @@ class Fetch extends ObjectValue {
                 buildCount: { args: ["team", "block"] },
             },
             handler(scope, overload, out, team, ...rest) {
-                const output = SenseableValue.from(scope, out, EMutability.constant);
+                const output = StoreValue.from(scope, out);
                 const params = ["0", "@conveyor"];
-                if (overload === "buildCount") {
+                if (overload === "buildCount" || overload === "unitCount") {
                     params[1] = rest[0];
                 }
                 else {
@@ -3487,6 +4025,373 @@ class SetFlag extends MacroFunction {
     }
 }
 
+class SetProp extends MacroFunction {
+    constructor() {
+        super((scope, out, target) => {
+            if (!target)
+                throw new CompilerError("Missing argument: target");
+            return [new Settable(target), []];
+        });
+    }
+}
+class SettableEntry extends VoidValue {
+    constructor(target, prop) {
+        super();
+        this.target = target;
+        this.prop = prop;
+        this.macro = true;
+    }
+    eval(scope, out) {
+        return this.target.get(scope, this.prop, out);
+    }
+    "="(scope, value) {
+        let prop = this.prop;
+        if (prop instanceof LiteralValue && prop.isString())
+            prop = formatSenseablePropName(prop.data);
+        return [value, [new InstructionBase("setprop", prop, this.target, value)]];
+    }
+    debugString() {
+        return "SettableEntry";
+    }
+    toMlogString() {
+        return "[macro SettableEntry]";
+    }
+}
+class Settable extends ObjectValue {
+    constructor(target) {
+        super({});
+        this.target = target;
+    }
+    get(scope, key, out) {
+        const entry = new SettableEntry(this.target, key);
+        if (out)
+            return entry.eval(scope, out);
+        return [entry, []];
+    }
+}
+
+class SyncLock extends ObjectValue {
+    constructor(value) {
+        super({
+            value,
+            sendToClients: new MacroFunction(() => {
+                return [null, [new InstructionBase("sync", this.value)]];
+            }),
+        });
+        this.value = value;
+    }
+}
+class SyncLockConstructor extends MacroFunction {
+    constructor() {
+        super((scope, out, init) => {
+            const inst = [];
+            const value = StoreValue.from(scope, out, EMutability.mutable);
+            if (init) {
+                if (!(init instanceof StoreValue || init instanceof LiteralValue)) {
+                    throw new CompilerError("Expected a store value or a literal value");
+                }
+                pipeInsts(value["="](scope, init), inst);
+            }
+            return [new SyncLock(value), inst];
+        });
+    }
+    preCall(scope, out) {
+        if (out)
+            return [out];
+    }
+}
+
+class Effect extends ObjectValue {
+    constructor() {
+        const data = createOverloadNamespace({
+            overloads: {
+                warn: { args: ["x", "y"] },
+                cross: { args: ["x", "y"] },
+                blockFall: { args: ["x", "y", "data"] },
+                placeBlock: { args: ["x", "y", "size"] },
+                placeBlockSpark: { args: ["x", "y", "size"] },
+                breakBlock: { args: ["x", "y", "size"] },
+                spawn: { args: ["x", "y"] },
+                trail: { args: ["x", "y", "color", "size"], named: "options" },
+                breakPop: { args: ["x", "y", "color", "size"], named: "options" },
+                breakProp: { args: ["x", "y", "color", "size"], named: "options" },
+                smokeCloud: { args: ["x", "y", "color"] },
+                vapor: { args: ["x", "y", "color"] },
+                hit: { args: ["x", "y", "color"] },
+                hitSquare: { args: ["x", "y", "color"] },
+                shootSmall: { args: ["x", "y", "color", "rotation"], named: "options" },
+                shootBig: { args: ["x", "y", "color", "rotation"], named: "options" },
+                smokeSmall: { args: ["x", "y", "rotation"] },
+                smokeBig: { args: ["x", "y", "rotation"] },
+                smokeColor: { args: ["x", "y", "color", "rotation"], named: "options" },
+                smokeSquare: {
+                    args: ["x", "y", "color", "rotation"],
+                    named: "options",
+                },
+                smokeSquareBig: {
+                    args: ["x", "y", "color", "rotation"],
+                    named: "options",
+                },
+                spark: { args: ["x", "y", "color"] },
+                sparkBig: { args: ["x", "y", "color"] },
+                sparkShoot: { args: ["x", "y", "color", "rotation"], named: "options" },
+                sparkShootBig: {
+                    args: ["x", "y", "color", "rotation"],
+                    named: "options",
+                },
+                drill: { args: ["x", "y", "color"] },
+                drillBig: { args: ["x", "y", "color"] },
+                lightBlock: { args: ["x", "y", "color", "size"], named: "options" },
+                explosion: { args: ["x", "y", "size"] },
+                smokePuff: { args: ["x", "y", "color"] },
+                sparkExplosion: { args: ["x", "y", "color"] },
+                crossExplosion: { args: ["x", "y", "color", "size"], named: "options" },
+                wave: { args: ["x", "y", "color", "size"], named: "options" },
+                bubble: { args: ["x", "y"] },
+            },
+            handler(scope, overload, out, ...args) {
+                const params = ["0", "0", "2", "%ffaaff", ""];
+                params[0] = args[0];
+                params[1] = args[1];
+                switch (overload) {
+                    case "blockFall":
+                        params[4] = args[2];
+                        break;
+                    case "placeBlock":
+                    case "smokeSmall":
+                    case "smokeBig":
+                    case "explosion":
+                        params[2] = args[2];
+                        break;
+                    case "trail":
+                    case "breakPop":
+                    case "breakProp":
+                    case "shootSmall":
+                    case "shootBig":
+                    case "smokeColor":
+                    case "smokeSquare":
+                    case "smokeSquareBig":
+                    case "sparkShoot":
+                    case "sparkShootBig":
+                    case "lightBlock":
+                    case "crossExplosion":
+                    case "wave":
+                        params[3] = args[2];
+                        params[2] = args[3];
+                        break;
+                    case "smokeCloud":
+                    case "vapor":
+                    case "hit":
+                    case "hitSquare":
+                    case "spark":
+                    case "sparkBig":
+                    case "drill":
+                    case "drillBig":
+                    case "smokePuff":
+                    case "sparkExplosion":
+                        params[3] = args[2];
+                        break;
+                }
+                return [
+                    null,
+                    [
+                        new InstructionBase("effect", overload === "breakPop" ? "breakProp" : overload, ...params),
+                    ],
+                ];
+            },
+        });
+        super(data);
+    }
+}
+
+class LocalePrint extends MacroFunction {
+    constructor() {
+        super((scope, out, name) => {
+            return [null, [new InstructionBase("localeprint", name)]];
+        });
+    }
+}
+
+class WeatherSense extends MacroFunction {
+    constructor() {
+        super((scope, out, weather) => {
+            const state = StoreValue.from(scope, out);
+            return [state, [new InstructionBase("weathersense", state, weather)]];
+        });
+    }
+}
+
+class WeatherSet extends MacroFunction {
+    constructor() {
+        super((scope, out, weather, state) => {
+            return [null, [new InstructionBase("weatherset", weather, state)]];
+        });
+    }
+}
+
+class PlaySound extends ObjectValue {
+    constructor() {
+        const data = createOverloadNamespace({
+            overloads: {
+                positional: {
+                    named: "options",
+                    args: ["sound", "volume", "pitch", "x", "y", "limit"],
+                },
+                global: {
+                    named: "options",
+                    args: ["sound", "volume", "pitch", "pan", "limit"],
+                },
+            },
+            //playsound false @sfx-pew 12 0.1 globalyespan @thisx @thisy true
+            // wait 1
+            handler(scope, overload, out, ...args) {
+                let sound = "0";
+                let volume = "0";
+                let pitch = "0";
+                let pan = "0";
+                let x = "0";
+                let y = "0";
+                let limit = "0";
+                // let volume =
+                switch (overload) {
+                    case "positional": {
+                        // playsound true id volume pitch _pan x y limit
+                        [sound, volume, pitch, x, y, limit] = args;
+                        break;
+                    }
+                    case "global": {
+                        // playsound false id volume pitch pan _x _y limit
+                        [sound, volume, pitch, pan, limit] = args;
+                        break;
+                    }
+                }
+                return [
+                    null,
+                    [
+                        new InstructionBase("playsound", String(overload === "positional"), sound, volume, pitch, pan, x, y, limit),
+                    ],
+                ];
+            },
+        });
+        super(data);
+    }
+}
+
+class PrintChar extends MacroFunction {
+    constructor() {
+        super((scope, out, character) => {
+            return [null, [new InstructionBase("printchar", character)]];
+        });
+    }
+}
+
+class UnpackColor extends MacroFunction {
+    constructor() {
+        super((scope, out, color) => {
+            if (!color) {
+                throw new CompilerError(`Missing argument: color`);
+            }
+            const outR = StoreValue.from(scope, extractDestrucuringOut(out, "r"));
+            const outG = StoreValue.from(scope, extractDestrucuringOut(out, "g"));
+            const outB = StoreValue.from(scope, extractDestrucuringOut(out, "b"));
+            const outA = StoreValue.from(scope, extractDestrucuringOut(out, "a"));
+            return [
+                new ObjectValue({
+                    r: outR,
+                    g: outG,
+                    b: outB,
+                    a: outA,
+                }),
+                [new InstructionBase("unpackcolor", outR, outG, outB, outA, color)],
+            ];
+        });
+    }
+}
+
+class Format extends MacroFunction {
+    constructor() {
+        super((scope, out, value) => {
+            return [null, [new InstructionBase("format", value)]];
+        });
+    }
+}
+
+class Query extends ObjectValue {
+    constructor() {
+        const data = createOverloadNamespace({
+            overloads: {
+                circle: {
+                    named: "options",
+                    args: ["type", { key: "team", default: "null" }, "x", "y", "radius"],
+                },
+                rect: {
+                    named: "options",
+                    args: [
+                        "type",
+                        { key: "team", default: "null" },
+                        "x",
+                        "y",
+                        "width",
+                        "height",
+                    ],
+                },
+            },
+            handler(scope, overload, out, ...args) {
+                if (overload === "circle") {
+                    const [type, team, x, y, radius] = args;
+                    return [
+                        null,
+                        [
+                            new InstructionBase("query", "circle", type, team, x, y, radius, "0"),
+                        ],
+                    ];
+                }
+                const [type, team, x, y, width, height] = args;
+                return [
+                    null,
+                    [
+                        new InstructionBase("query", "rect", type, team, x, y, width, height),
+                    ],
+                ];
+            },
+        });
+        super(data);
+    }
+}
+
+class SpawnBullet extends MacroFunction {
+    constructor() {
+        super((scope, out, options) => {
+            assertIsObjectMacro(options, "The options");
+            const { from, index, x, y, rotation, team, owner, damage, velocityScl, lifeScl, aimX, aimY, } = options.data;
+            assertIsRuntimeValue(from, "from");
+            assertIsRuntimeValue(x, "x");
+            assertIsRuntimeValue(y, "y");
+            assertIsRuntimeValue(rotation, "rotation");
+            assertIsRuntimeValue(team, "team");
+            const output = StoreValue.from(scope, out);
+            return [
+                output,
+                [
+                    new InstructionBase("bullet", output, from, index ?? "0", x, y, rotation, team, owner ?? "null", damage ?? "-1", velocityScl ?? "1", lifeScl ?? "1", aimX ?? "-1", aimY ?? "-1"),
+                ],
+            ];
+        });
+    }
+}
+
+class PlayMusic extends MacroFunction {
+    constructor() {
+        super((scope, out, name, interrupt) => {
+            assertIsRuntimeValue(name, "name");
+            return [
+                null,
+                [new InstructionBase("playmusic", name, interrupt ?? "true")],
+            ];
+        });
+    }
+}
+
 class MemoryEntry extends BaseValue {
     constructor(scope, mem, prop) {
         super();
@@ -3518,7 +4423,7 @@ class MemoryEntry extends BaseValue {
     debugString() {
         return "MemoryEntry";
     }
-    toString() {
+    toMlogString() {
         return '"[macro MemoryEntry]"';
     }
 }
@@ -3547,33 +4452,108 @@ class MemoryMacro extends ObjectValue {
         return super.hasProperty(scope, prop);
     }
     debugString() {
-        return `Memory("${this.cell.toString()}")`;
+        return `Memory("${this.cell.toMlogString()}")`;
     }
-    toString() {
+    toMlogString() {
         return '"[macro Memory]"';
     }
 }
 class MemoryBuilder extends MacroFunction {
     constructor() {
         super((scope, out, cell, size = new LiteralValue(64)) => {
-            if (!(cell instanceof SenseableValue))
-                throw new CompilerError("Memory cell must be a senseable value.");
+            if (!(cell instanceof StoreValue))
+                throw new CompilerError("Memory cell must be a store value.");
             if (!(size instanceof LiteralValue && size.isNumber()) &&
                 !(size instanceof StoreValue))
                 throw new CompilerError("The memory size must be a number literal or a store.");
-            if (size.mutability === EMutability.constant) {
+            if (size.mutability === EMutability.constant ||
+                size.mutability === EMutability.immutable) {
                 return [new MemoryMacro(cell, size), []];
             }
             const name = extractOutName(out) ?? scope.makeTempName();
             const store = new StoreValue(`${name}.&len`);
             const [, inst] = store["="](scope, size);
-            store.mutability = EMutability.constant;
+            store.mutability = EMutability.immutable;
             return [new MemoryMacro(cell, store), inst];
         });
     }
 }
 
-const dynamicVars = ["time", "tick"];
+class QueriesMacro extends ObjectValue {
+    constructor() {
+        super({
+            at: new MacroFunction((scope, out, index) => {
+                if (!index) {
+                    throw new CompilerError("Expected index argument for queries.at()");
+                }
+                const outValue = StoreValue.from(scope, out);
+                return [
+                    outValue,
+                    [new InstructionBase("read", outValue, "@queries", index)],
+                ];
+            }),
+        });
+        this.queriesStore = new StoreValue("@queries", EMutability.readonly);
+    }
+    get(scope, key, out) {
+        if (super.hasProperty(scope, key))
+            return super.get(scope, key, out);
+        if (key instanceof LiteralValue && key.isString()) {
+            if (key.data === "length") {
+                const outValue = StoreValue.from(scope, out);
+                return [
+                    outValue,
+                    [new InstructionBase("sensor", outValue, "@queries", "@size")],
+                ];
+            }
+            if (key.data === "value") {
+                return [this.queriesStore, []];
+            }
+        }
+        if ((key instanceof LiteralValue && key.isNumber()) ||
+            !(key instanceof LiteralValue)) {
+            const outValue = StoreValue.from(scope, out);
+            return [
+                outValue,
+                [new InstructionBase("read", outValue, "@queries", key)],
+            ];
+        }
+        throw new CompilerError(`The member [${key.debugString()}] is not present in QueriesView`);
+    }
+    hasProperty(scope, prop) {
+        if ((prop instanceof LiteralValue &&
+            (prop.isNumber() || prop.data === "length" || prop.data === "value")) ||
+            !(prop instanceof LiteralValue)) {
+            return true;
+        }
+        return super.hasProperty(scope, prop);
+    }
+    debugString() {
+        return "QueriesView";
+    }
+    toMlogString() {
+        return '"[macro QueriesView]"';
+    }
+}
+
+const dynamicVars = [
+    "unit",
+    "tick",
+    "time",
+    "second",
+    "minute",
+    "waveNumber",
+    "waveTime",
+    "server",
+    "client",
+    "clientLocale",
+    "clientUnit",
+    "clientName",
+    "clientTeam",
+    "clientMobile",
+    "clientMusicPlaying",
+    "clientCurrentMusic",
+];
 class NamespaceMacro extends ObjectValue {
     constructor({ changeCasing = false } = {}) {
         super();
@@ -3585,11 +4565,15 @@ class NamespaceMacro extends ObjectValue {
         if (!(key instanceof LiteralValue) || !key.isString())
             throw new CompilerError("Cannot use dynamic properties on namespace macros");
         const symbolName = this.changeCasing ? camelToDashCase(key.data) : key.data;
-        const mutability = dynamicVars.includes(symbolName)
-            ? EMutability.readonly
-            : EMutability.constant;
-        const result = new StoreValue(`@${symbolName}`, mutability);
-        return [result, []];
+        if (dynamicVars.includes(symbolName)) {
+            return [
+                new StoreValue(`@${symbolName}`, EMutability.readonly, {
+                    volatile: true,
+                }),
+                [],
+            ];
+        }
+        return [new StoreValue(`@${symbolName}`, EMutability.constant), []];
     }
     hasProperty(scope, prop) {
         return prop instanceof LiteralValue && prop.isString();
@@ -3598,16 +4582,59 @@ class NamespaceMacro extends ObjectValue {
 class VarsNamespace extends NamespaceMacro {
     constructor() {
         super();
-        Object.assign(this.data, {
-            unit: new SenseableValue("@unit"),
-            this: new SenseableValue("@this"),
-        });
+    }
+}
+class ColorsNamespace extends NamespaceMacro {
+    constructor() {
+        super();
+    }
+    get(scope, key, out) {
+        if (!(key instanceof LiteralValue) || !key.isString())
+            return super.get(scope, key, out);
+        const plainName = key.data;
+        const name = `@color${plainName[0].toUpperCase()}${plainName.slice(1)}`;
+        const result = new StoreValue(name, EMutability.constant);
+        return [result, []];
+    }
+}
+class SoundsNamespace extends NamespaceMacro {
+    constructor() {
+        super();
+    }
+    get(scope, key, out) {
+        if (!(key instanceof LiteralValue) || !key.isString())
+            return super.get(scope, key, out);
+        const result = new StoreValue(`@sfx-${key.data}`, EMutability.constant);
+        return [result, []];
+    }
+}
+class StatusEffectsNamespace extends NamespaceMacro {
+    constructor() {
+        super({ changeCasing: true });
+    }
+    get(scope, key, out) {
+        if (!(key instanceof LiteralValue) || !key.isString())
+            return super.get(scope, key, out);
+        const name = `@status-${camelToDashCase(key.data)}`;
+        const result = new StoreValue(name, EMutability.constant);
+        return [result, []];
+    }
+}
+class PVarsNamespace extends NamespaceMacro {
+    constructor() {
+        super();
+    }
+    get(scope, key, out) {
+        if (key instanceof LiteralValue && key.data === "queries") {
+            return [new QueriesMacro(), []];
+        }
+        return super.get(scope, key, out);
     }
 }
 
 /**
- * The size of a dynamic array iteration item.
- * Includes the set counter instruction
+ * The size of a dynamic array iteration item. Includes the set counter
+ * instruction
  */
 const itemSize = 2;
 class DynamicArray extends ObjectValue {
@@ -3762,8 +4789,8 @@ class DynamicArray extends ObjectValue {
         this.scope = scope;
         this.name = name;
         this.values = values;
-        this.getterTemp = new SenseableValue(getterName, EMutability.mutable);
-        this.setterTemp = new SenseableValue(setterName, EMutability.mutable);
+        this.getterTemp = new StoreValue(getterName);
+        this.setterTemp = new StoreValue(setterName);
         this.returnTemp = new StoreValue(returnName);
         if (dynamic)
             this.lengthStore = lengthStore;
@@ -3847,7 +4874,7 @@ class DynamicArray extends ObjectValue {
         const id = this.dynamic ? "DynamicArray" : "MutableArray";
         return `${id}("${this.name}")`;
     }
-    toString() {
+    toMlogString() {
         const id = this.dynamic ? "DynamicArray" : "MutableArray";
         return `"[macro ${id}]"`;
     }
@@ -3878,7 +4905,7 @@ class DynamicArrayEntry extends BaseValue {
             ? out
             : out
                 ? getterTemp
-                : SenseableValue.from(scope, undefined, EMutability.mutable);
+                : StoreValue.from(scope);
         // used in checked mode, jumps to this address
         // if the index is out of bounds
         const failAddr = this.failAddress ?? new LiteralValue(null);
@@ -3949,7 +4976,7 @@ class DynamicArrayEntry extends BaseValue {
         const name = this.array.dynamic ? "DynamicArray" : "MutableArray";
         return `${name}Entry`;
     }
-    toString() {
+    toMlogString() {
         const name = this.array.dynamic ? "DynamicArray" : "MutableArray";
         return `"[macro ${name}Entry]"`;
     }
@@ -3972,7 +4999,7 @@ class DynamicArrayConstructor extends MacroFunction {
                 throw new CompilerError("The dynamic array initializer must be an array macro or a number literal");
             }
             for (let i = 0; i < length; i++) {
-                values.push(new SenseableValue(`${name}->${i}`, EMutability.mutable));
+                values.push(new StoreValue(`${name}->${i}`));
             }
             if (init instanceof ObjectValue) {
                 const length = init.data.length.data;
@@ -4013,17 +5040,234 @@ class Unchecked extends MacroFunction {
     }
 }
 
+class GetBuildings extends MacroFunction {
+    constructor() {
+        super(() => [new BuildingsMacro(), []]);
+    }
+}
+class BuildingsMacro extends ObjectValue {
+    hasProperty(scope, prop) {
+        if (isKeyBuildingName(prop)) {
+            return true;
+        }
+        return super.hasProperty(scope, prop);
+    }
+    get(scope, key, out) {
+        if (super.hasProperty(scope, key))
+            return super.get(scope, key, out);
+        if (!isKeyBuildingName(key)) {
+            throw new CompilerError(`[${key.debugString()}] is not a valid building name`);
+        }
+        return [new StoreValue(key.data, EMutability.constant), []];
+    }
+}
+function isKeyBuildingName(key) {
+    if (!(key instanceof LiteralValue) || !key.isString())
+        return false;
+    const regex = /^\w+$/;
+    return regex.test(key.data);
+}
+
 class GetGlobal extends MacroFunction {
     constructor(mutability) {
         super((scope, out, name) => {
             if (!(name instanceof LiteralValue) || !name.isString())
                 throw new CompilerError("The name parameter must be a string literal.");
-            const result = new SenseableValue(name.data, mutability);
+            const result = new StoreValue(name.data, mutability);
             return [result, []];
         });
     }
 }
 
+class GetColor extends MacroFunction {
+    constructor() {
+        super((scope, out, color) => {
+            if (!(color instanceof LiteralValue) || !color.isString())
+                throw new CompilerError("The color parameter must be a string literal.");
+            return [new StoreValue(`%${color.data}`, EMutability.constant), []];
+        });
+    }
+}
+
+class MarkerConstructor extends ObjectValue {
+    constructor() {
+        const data = createOverloadNamespace({
+            overloads: {
+                of: { args: ["id"] },
+                shapeText: {
+                    named: "options",
+                    args: ["id", "x", "y", "replace"],
+                },
+                point: {
+                    named: "options",
+                    args: ["id", "x", "y", "replace"],
+                },
+                shape: {
+                    named: "options",
+                    args: ["id", "x", "y", "replace"],
+                },
+                line: {
+                    named: "options",
+                    args: ["id", "x", "y", "replace"],
+                },
+                text: {
+                    named: "options",
+                    args: ["id", "x", "y", "replace"],
+                },
+                texture: {
+                    named: "options",
+                    args: ["id", "x", "y", "replace"],
+                },
+                quad: {
+                    named: "options",
+                    args: ["id", "x", "y", "replace"],
+                },
+            },
+            handler(scope, overload, out, ...args) {
+                // makemarker id line x y replace
+                const inst = [];
+                let id = args[0];
+                const rest = args.slice(1);
+                if (!(id instanceof LiteralValue)) {
+                    // prevent mutations to the source
+                    // from affecting the object's internal value
+                    const store = StoreValue.from(scope);
+                    pipeInsts(store["="](scope, id), inst);
+                    id = store;
+                }
+                const marker = new MarkerMacro(id);
+                if (overload !== "of") {
+                    inst.push(new InstructionBase("makemarker", overload, id, ...rest));
+                }
+                return [marker, inst];
+            },
+        });
+        super(data);
+    }
+}
+class MarkerMacro extends ObjectValue {
+    constructor(id) {
+        super({
+            remove: new MacroFunction(() => [null, [setmarker(id, "remove")]]),
+            world: new MarkerMacroSetter(id, "world"),
+            minimap: new MarkerMacroSetter(id, "minimap"),
+            light: new MarkerMacroSetter(id, "light"),
+            autoscale: new MarkerMacroSetter(id, "autoscale"),
+            pos: new MarkerMacroSetter(id, "pos", ["x", "y"]),
+            endPos: new MarkerMacroSetter(id, "endPos", ["x", "y"]),
+            drawLayer: new MarkerMacroSetter(id, "drawLayer"),
+            color: new MarkerMacroSetter(id, "color"),
+            radius: new MarkerMacroSetter(id, "radius"),
+            stroke: new MarkerMacroSetter(id, "stroke"),
+            rotation: new MarkerMacroSetter(id, "rotation"),
+            shape: new MarkerMacroSetter(id, "shape", ["sides", "fill", "outline"]),
+            arc: new MarkerMacroSetter(id, "arc", ["start", "end"]),
+            flushText: new MacroFunction((scope, out, options) => {
+                assertIsObjectMacro(options, "options");
+                const [fetch] = assertObjectFields(options, ["fetch"]);
+                return [null, [setmarker(id, "flushText", fetch)]];
+            }),
+            fontSize: new MarkerMacroSetter(id, "fontSize"),
+            textAlign: new MarkerMacroSetter(id, "textAlign"),
+            lineAlign: new MarkerMacroSetter(id, "lineAlign"),
+            textHeight: new MarkerMacroSetter(id, "textHeight"),
+            outline: new MarkerMacroSetter(id, "outline"),
+            labelFlags: new MarkerMacroSetter(id, "labelFlags", [
+                "background",
+                "outline",
+            ]),
+            texture: new MarkerMacroSetter(id, "texture", [], args => ["0", ...args]),
+            flushTexture: new MacroFunction(() => [
+                null,
+                [setmarker(id, "texture", "1")],
+            ]),
+            textureSize: new MarkerMacroSetter(id, "textureSize", [
+                "width",
+                "height",
+            ]),
+            posi: new MarkerMacroSetter(id, "posi", ["index", "x", "y"]),
+            uvi: new MarkerMacroSetter(id, "uvi", ["index", "x", "y"]),
+            colori: new MarkerMacroSetter(id, "colori", ["index", "color"]),
+        });
+    }
+}
+class MarkerMacroSetter extends VoidValue {
+    constructor(id, prop, keys = [], modifyArgs) {
+        super();
+        this.id = id;
+        this.prop = prop;
+        this.keys = keys;
+        this.modifyArgs = modifyArgs;
+    }
+    "="(scope, value) {
+        const inst = [];
+        let args = [];
+        if (this.keys.length === 0) {
+            args.push(value);
+        }
+        else {
+            for (const key of this.keys) {
+                const member = pipeInsts(value.get(scope, new LiteralValue(key)), inst);
+                args.push(member);
+            }
+        }
+        if (this.modifyArgs) {
+            args = this.modifyArgs(args);
+        }
+        inst.push(setmarker(this.id, this.prop, ...args));
+        return [value, inst];
+    }
+}
+function setmarker(id, prop, ...args) {
+    return new InstructionBase("setmarker", prop, id, ...args);
+}
+
+class StringView extends ObjectValue {
+    constructor(string) {
+        super();
+        this.string = string;
+    }
+    get(scope, key, out) {
+        if (super.hasProperty(scope, key))
+            return super.get(scope, key, out);
+        if (key instanceof LiteralValue) {
+            if (key.data === "length") {
+                return this.string.get(scope, key, out);
+            }
+            if (!key.isNumber())
+                throw new CompilerError(`The member [${key.debugString()}] is not present in [${this.debugString()}]`);
+            if (this.string instanceof LiteralValue && this.string.isString()) {
+                const char = this.string.data.charCodeAt(key.data);
+                return [new LiteralValue(char), []];
+            }
+        }
+        const outValue = StoreValue.from(scope, out);
+        return [
+            outValue,
+            [new InstructionBase("read", outValue, this.string, key)],
+        ];
+    }
+    hasProperty(scope, prop) {
+        if ((prop instanceof LiteralValue && prop.isNumber()) ||
+            prop instanceof StoreValue)
+            return true;
+        return super.hasProperty(scope, prop);
+    }
+    debugString() {
+        return `StringView(${this.string.debugString()})`;
+    }
+    toMlogString() {
+        return '"[macro StringView]"';
+    }
+}
+class StringViewBuilder extends MacroFunction {
+    constructor() {
+        super((scope, out, string) => {
+            return [new StringView(string), []];
+        });
+    }
+}
+
 class Asm extends MacroFunction {
     constructor() {
         super((scope, out, stringsArray, ...values) => {
@@ -4055,7 +5299,7 @@ function formatInstructions(args) {
         const segments = arg.split("\n");
         const params = [...buffer, segments[0]];
         if (validateInstructionArgs(params)) {
-            instructions.push(new ZeroSpaceInstruction(...params));
+            instructions.push(new AsmInstruction(...params));
             buffer = [];
         }
         // iterates over all segments except the first and last
@@ -4067,18 +5311,21 @@ function formatInstructions(args) {
             const trimmed = segments[i].trim();
             if (trimmed.length == 0)
                 continue;
-            instructions.push(new ZeroSpaceInstruction(trimmed));
+            instructions.push(new AsmInstruction(trimmed));
         }
         if (segments.length > 1) {
             buffer.push(segments[segments.length - 1]);
         }
     }
     if (buffer.length > 0 && validateInstructionArgs(buffer)) {
-        instructions.push(new ZeroSpaceInstruction(...buffer));
+        instructions.push(new AsmInstruction(...buffer));
     }
     return instructions;
 }
-/** Determines if an asm line should be generated and trims it at the start and end */
+/**
+ * Determines if an asm line should be generated and trims it at the start and
+ * end
+ */
 function validateInstructionArgs(args) {
     if (args.length === 0)
         return false;
@@ -4097,11 +5344,29 @@ function validateInstructionArgs(args) {
         args[args.length - 1] = last.trimEnd();
     return true;
 }
+class AsmInstruction extends InstructionBase {
+    constructor(...args) {
+        super(...args);
+        const [first] = args;
+        if (typeof first === "string") {
+            this.ignoredByParser = /^\s*(#|\S+:)/.test(first);
+        }
+    }
+    toString() {
+        return formatInstructionArgs(this.args).join("");
+    }
+}
 
 /**
- * Adds all the compiler globals to `scope`
+ * Creates the global scope of the user's script, contains all built-ins that
+ * are not privileged
  */
-function initScope(scope) {
+function createGlobalScope() {
+    const scope = new Scope({
+        builtInModules: {
+            [worldModuleName]: createWordModule(),
+        },
+    });
     scope.hardSet("undefined", new LiteralValue(null));
     // namespaces
     scope.hardSet("ControlKind", new NamespaceMacro());
@@ -4112,19 +5377,30 @@ function initScope(scope) {
     scope.hardSet("Units", new NamespaceMacro({ changeCasing: true }));
     scope.hardSet("LAccess", new NamespaceMacro());
     scope.hardSet("Blocks", new NamespaceMacro({ changeCasing: true }));
+    scope.hardSet("Colors", new ColorsNamespace());
+    scope.hardSet("StatusEffects", new StatusEffectsNamespace());
     // helper methods
     scope.hardSet("getBuilding", new GetGlobal(EMutability.constant));
+    scope.hardSet("getBuildings", new GetBuildings());
     scope.hardSet("getVar", new GetGlobal(EMutability.mutable));
+    scope.hardSet("getColor", new GetColor());
     scope.hardSet("concat", new Concat());
     scope.hardSet("asm", new Asm());
     scope.hardSet("Math", new MlogMath());
     scope.hardSet("Memory", new MemoryBuilder());
+    scope.hardSet("MemoryView", new MemoryBuilder());
+    scope.hardSet("StringView", new StringViewBuilder());
     scope.hardSet("MutableArray", new DynamicArrayConstructor(false));
     scope.hardSet("DynamicArray", new DynamicArrayConstructor(true));
     scope.hardSet("unchecked", new Unchecked());
+    scope.hardSet("Align", new NamespaceMacro());
+    scope.hardSet("Weathers", new NamespaceMacro({ changeCasing: true }));
+    scope.hardSet("Sounds", new SoundsNamespace());
     // commands
     scope.hardSet("draw", new Draw());
     scope.hardSet("print", new Print());
+    scope.hardSet("format", new Format());
+    scope.hardSet("printChar", new PrintChar());
     scope.hardSet("printFlush", new PrintFlush());
     scope.hardSet("drawFlush", new DrawFlush());
     scope.hardSet("getLink", new GetLink());
@@ -4134,33 +5410,50 @@ function initScope(scope) {
     scope.hardSet("wait", new Wait());
     scope.hardSet("lookup", new Lookup());
     scope.hardSet("packColor", new PackColor());
+    scope.hardSet("unpackColor", new UnpackColor());
     scope.hardSet("endScript", new End());
     scope.hardSet("stopScript", new Stop());
     scope.hardSet("unitBind", new UnitBind());
     scope.hardSet("unitControl", new UnitControl());
     scope.hardSet("unitRadar", new UnitRadar());
     scope.hardSet("unitLocate", new UnitLocate());
-    // world processor commands
-    scope.hardSet("getBlock", new GetBlock());
-    scope.hardSet("setBlock", new SetBlock());
-    scope.hardSet("spawnUnit", new SpawnUnit());
-    scope.hardSet("applyStatus", new ApplyStatus());
-    scope.hardSet("spawnWave", new SpawnWave());
-    scope.hardSet("setRule", new SetRule());
-    scope.hardSet("flushMessage", new FlushMessage());
-    scope.hardSet("cutscene", new Cutscene());
-    scope.hardSet("explosion", new Explosion());
     scope.hardSet("setRate", new SetRate());
-    scope.hardSet("fetch", new Fetch());
-    scope.hardSet("getFlag", new GetFlag());
-    scope.hardSet("setFlag", new SetFlag());
+    return scope;
+}
+function createWordModule() {
+    const module = new ObjectValue({
+        PVars: new PVarsNamespace(),
+        getBlock: new GetBlock(),
+        setBlock: new SetBlock(),
+        spawnUnit: new SpawnUnit(),
+        spawnBullet: new SpawnBullet(),
+        applyStatus: new ApplyStatus(),
+        spawnWave: new SpawnWave(),
+        setRule: new SetRule(),
+        flushMessage: new FlushMessage(),
+        cutscene: new Cutscene(),
+        explosion: new Explosion(),
+        setRate: new SetRate(),
+        fetch: new Fetch(),
+        getFlag: new GetFlag(),
+        setFlag: new SetFlag(),
+        setProp: new SetProp(),
+        SyncLock: new SyncLockConstructor(),
+        effect: new Effect(),
+        localePrint: new LocalePrint(),
+        Marker: new MarkerConstructor(),
+        senseWeather: new WeatherSense(),
+        setWeather: new WeatherSet(),
+        playSound: new PlaySound(),
+        playMusic: new PlayMusic(),
+        query: new Query(),
+    });
+    return module;
 }
 
 class Compiler {
-    constructor({ stackName, compactNames = false, sourcemap = false, } = {}) {
+    constructor({ compactNames = false, sourcemap = false, } = {}) {
         this.handlers = handlers;
-        this.usingStack = !!stackName;
-        this.stackName = stackName;
         this.compactNames = compactNames;
         this.sourcemap = sourcemap;
     }
@@ -4169,8 +5462,10 @@ class Compiler {
         let sourcemaps;
         try {
             const program = this.parse(script);
-            const scope = new Scope({});
-            initScope(scope);
+            const globalScope = createGlobalScope();
+            // this allows the user to shadow global variables inside
+            // the script, since it is treated as a module
+            const scope = globalScope.createScope();
             const valueInst = this.handle(scope, program);
             if (needsEndInstruction(valueInst[1], scope)) {
                 valueInst[1].push(new EndInstruction());
@@ -4193,18 +5488,20 @@ class Compiler {
         let i = 0;
         for (const inst of valueInst[1]) {
             inst.resolve(i);
-            if (!inst.hidden)
+            if (!inst.hidden && !inst.ignoredByParser)
                 i++;
         }
     }
     serialize(resLines) {
         const [, inst] = resLines;
+        // eslint-disable-next-line @typescript-eslint/no-base-to-string
         return inst.filter(l => !l.hidden).join("\n");
     }
     parse(script) {
-        return parser.parse(script, {
+        return parse(script, {
             ranges: true,
             plugins: ["typescript"],
+            sourceType: "module",
         });
     }
     mapSources(valueInst) {
@@ -4215,11 +5512,11 @@ class Compiler {
         }
         return result;
     }
-    handle(scope, node, handler = this.handlers[node.type], out) {
+    handle(scope, node, handler = this.handlers[node.type], out, arg) {
         try {
             if (!handler)
                 throw new CompilerError("Missing handler for " + node.type);
-            const result = handler(this, scope, node, out, null);
+            const result = handler(this, scope, node, out, arg);
             if (this.sourcemap)
                 return appendSourceLocations(result, node);
             return result;
@@ -4232,14 +5529,14 @@ class Compiler {
         }
     }
     /** Handles the node and asserts that it resolves to a value. */
-    handleValue(scope, node, handler = this.handlers[node.type], out) {
-        const result = this.handle(scope, node, handler, out);
+    handleValue(scope, node, handler = this.handlers[node.type], out, arg) {
+        const result = this.handle(scope, node, handler, out, arg);
         if (!result[0])
             throw new CompilerError(`This node (${node.type}) did not return a value`, node);
         return result;
     }
-    handleEval(scope, node, out) {
-        const [res, inst] = this.handleValue(scope, node, undefined, out);
+    handleEval(scope, node, out, arg) {
+        const [res, inst] = this.handleValue(scope, node, undefined, out, arg);
         const [evaluated, evaluatedInst] = res.eval(scope, out);
         const result = [evaluated, [...inst, ...evaluatedInst]];
         if (this.sourcemap)
@@ -4249,12 +5546,10 @@ class Compiler {
     /**
      * Handles many nodes in order.
      *
-     * The usage of this method over a regular loop over an array of nodes
-     * is only required if the code inside the loop generates
-     * instructions that are not tracked by the compiler
-     * handler methods ({@link handle}, {@link handleEval}
+     * The usage of this method over a regular loop over an array of nodes is only
+     * required if the code inside the loop generates instructions that are not
+     * tracked by the compiler handler methods ({@link handle}, {@link handleEval}
      * and {@link handleMany})
-     *
      */
     handleMany(scope, nodes, handler) {
         const lines = [];
@@ -4285,5 +5580,4 @@ function needsEndInstruction(inst, scope) {
     return scope.inst.length > 0;
 }
 
-exports.Compiler = Compiler;
-exports.CompilerError = CompilerError;
+export { Compiler as C, CompilerError as a };