mlogjs 0.4.6 → 0.4.8

package/dist/index.mjs

@@ -69,6 +69,8 @@ var EMutability;
     EMutability[EMutability["readonly"] = 1] = "readonly";
     /** Constant values, won't change during execution */
     EMutability[EMutability["constant"] = 2] = "constant";
+    /** An immutable value that hasn't been initialized yet */
+    EMutability[EMutability["init"] = 3] = "init";
 })(EMutability || (EMutability = {}));
 
 const arithmeticBinaryOperators = [
@@ -148,24 +150,20 @@ const operators = [...leftRightOperators, ...singleOperators];
 
 class VoidValue {
     constructor() {
-        this.owner = null;
         this.mutability = EMutability.mutable;
         this.macro = false;
     }
-    eval(_scope) {
+    eval(_scope, _out) {
         throw new CompilerError(`${this} cannot eval.`);
     }
-    consume(_scope) {
-        throw new CompilerError(`${this} cannot be consumed.`);
-    }
-    call(_scope, _args) {
+    call(_scope, _args, _out) {
         throw new CompilerError(`${this} cannot call.`);
     }
     get(_scope, _name) {
         throw new CompilerError(`${this} cannot get.`);
     }
-    ensureOwned() {
-        throw new CompilerError(`${this} cannot be owned`);
+    paramOuts() {
+        return;
     }
     toString() {
         return "void";
@@ -203,6 +201,176 @@ class OperationInstruction extends InstructionBase {
     }
 }
 
+/**
+ * The prefix for internal variables inside the compiler output
+ */
+const internalPrefix = "&";
+const discardedName = `${internalPrefix}_`;
+const itemNames = [
+    "copper",
+    "lead",
+    "metaglass",
+    "graphite",
+    "sand",
+    "coal",
+    "titanium",
+    "thorium",
+    "scrap",
+    "silicon",
+    "plastanium",
+    "phaseFabric",
+    "surgeAlloy",
+    "sporePod",
+    "blastCompound",
+    "pyratite",
+    "beryllium",
+    "tungsten",
+    "oxide",
+    "carbide",
+    "fissileMatter",
+    "dormantCyst",
+];
+
+/**
+ * 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].
+ */
+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}`;
+    return `${line}:${column}`;
+}
+/**
+ * Converts a camel case string into a dash case one.
+ *
+ * As an example `camelCase` becomes `camel-case`
+ * @example
+ * ```
+ * 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
+function assign(obj, props) {
+    return Object.assign(obj, props);
+}
+
+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;
+}
+function withAlwaysRuns(valueInst, value) {
+    valueInst[1].forEach(inst => (inst.alwaysRuns = value));
+    return valueInst;
+}
+/** Removes jump instructions that point right to the next line */
+function hideRedundantJumps(inst) {
+    for (let i = 0; i < inst.length; i++) {
+        const instruction = inst[i];
+        if (!(instruction instanceof JumpInstruction))
+            continue;
+        const { address } = instruction;
+        let searchIndex = i + 1;
+        let current = inst[searchIndex];
+        while (current?.hidden) {
+            if (current instanceof AddressResolver &&
+                current.bonds.includes(address)) {
+                // only gets assigned if `current` is an adress resolver
+                // that resolves the jump adress
+                // and that is also right next to the jump,
+                // without any actual instructions in between
+                instruction.hidden = true;
+                break;
+            }
+            searchIndex++;
+            current = inst[searchIndex];
+        }
+    }
+}
+
+function isTemplateObjectArray(value) {
+    return (value instanceof ObjectValue &&
+        value.data.length instanceof LiteralValue &&
+        value.data.length.isNumber() &&
+        value.data.raw instanceof ObjectValue &&
+        value.data.raw.data.length instanceof LiteralValue &&
+        value.data.raw.data.length.isNumber());
+}
+function extractOutName(out) {
+    if (!out || typeof out === "string")
+        return out;
+    return out.name;
+}
+function extractDestrucuringOut(out, field) {
+    if (out === discardedName)
+        return out;
+    if (!(out instanceof DestructuringValue))
+        return;
+    return out.fields[field] ?? discardedName;
+}
+/** Asserts that `value` is a `LiteralValue` that contains a string */
+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`*/
+function assertLiteralOneOf(value, members, name) {
+    assertStringLiteral(value, name);
+    if (!members.includes(value.data))
+        throw new CompilerError(`${name} must be one of: ${members
+            .slice(0, -1)
+            .map(member => `"${member}"`)
+            .join(", ")} or "${members[members.length - 1]}"`);
+}
+/** Asserts that `value` is either a store or a literal */
+function assertIsRuntimeValue(value, name) {
+    if (!(value instanceof LiteralValue) && !(value instanceof StoreValue))
+        throw new CompilerError(`${name} must be a valid runtime value`);
+}
+/** Asserts that `value` is an `ObjectValue` */
+function assertIsObjectMacro(value, name) {
+    if (!(value instanceof ObjectValue))
+        throw new CompilerError(`${name} must be an object macro`);
+}
+/** Asserts that `value` is an `ObjectValue` that has a length property */
+function assertIsArrayMacro(value, name) {
+    if (value instanceof ObjectValue) {
+        const { length } = value.data;
+        if (length instanceof LiteralValue && length.isNumber())
+            return;
+    }
+    throw new CompilerError(`${name} must be an array macro`);
+}
+/** Asserts that all of the fields described are present on `value`*/
+function assertObjectFields(value, fields) {
+    const result = [];
+    for (const field of fields) {
+        const param = typeof field === "object" ? field : { key: field };
+        const item = value.data[param.key];
+        if (item) {
+            param.validate?.(item);
+            result.push(item);
+            continue;
+        }
+        if (param.default == undefined)
+            throw new CompilerError(`The field "${param.name ?? param.key}" must be present`);
+        result.push(param.default);
+    }
+    return result;
+}
+
 class SetInstruction extends InstructionBase {
     constructor(store, value) {
         super("set", store, value);
@@ -217,12 +385,12 @@ class SetInstruction extends InstructionBase {
         const { store, value } = this;
         return (this._hidden ||
             // assignment to discarded value
-            !store.owner ||
+            store.name === discardedName ||
             // self assignment of a store
-            (!!store.owner &&
+            (!!store.name &&
                 store instanceof StoreValue &&
                 value instanceof StoreValue &&
-                store.owner === value.owner));
+                store.name === value.name));
     }
 }
 
@@ -302,9 +470,9 @@ class ContinueInstruction extends JumpInstruction {
 }
 
 class BaseValue extends VoidValue {
-    "u-"(scope) {
-        const [that, inst] = this.consume(scope);
-        const temp = new StoreValue(scope);
+    "u-"(scope, out) {
+        const [that, inst] = this.eval(scope);
+        const temp = StoreValue.from(scope, out);
         return [
             temp,
             [
@@ -313,40 +481,37 @@ class BaseValue extends VoidValue {
             ],
         ];
     }
-    "u+"(scope) {
+    "u+"(scope, out) {
         // TODO: should it return 0 + this ?
-        return this.eval(scope);
+        return this.eval(scope, out);
     }
-    "!"(scope) {
-        const [that, inst] = this.consume(scope);
-        const temp = new StoreValue(scope);
+    "!"(scope, out) {
+        const [that, inst] = this.eval(scope);
+        const temp = StoreValue.from(scope, out);
         const falseLiteral = new LiteralValue(0);
         return [
             temp,
             [...inst, new OperationInstruction("equal", temp, that, falseLiteral)],
         ];
     }
-    "~"(scope) {
-        const [that, inst] = this.consume(scope);
-        const temp = new StoreValue(scope);
+    "~"(scope, out) {
+        const [that, inst] = this.eval(scope);
+        const temp = StoreValue.from(scope, out);
         return [temp, [...inst, new OperationInstruction("not", temp, that, null)]];
     }
     // requires special handling
     // the handler should give an object value to allow the lazy evaluation
-    "??"(scope, other) {
-        const [left, leftInst] = this.eval(scope);
+    "??"(scope, other, out) {
+        if (this instanceof LiteralValue) {
+            if (this.data === null)
+                return other.eval(scope, out);
+            return [this, []];
+        }
+        const result = SenseableValue.out(scope, out);
+        const [left, leftInst] = this.eval(scope, result);
+        const [right, rightInst] = other.eval(scope, result);
         const nullLiteral = new LiteralValue(null);
         const endAdress = new LiteralValue(null);
-        const [nullTest] = left["=="](scope, nullLiteral);
-        if (nullTest instanceof LiteralValue) {
-            if (nullTest.data)
-                return other.eval(scope);
-            else
-                return [left, leftInst];
-        }
-        const [right, rightInst] = other.eval(scope);
-        const result = new StoreValue(scope);
-        result.ensureOwned();
         return [
             result,
             [
@@ -386,10 +551,10 @@ const operatorMap$1 = {
 };
 for (const key in operatorMap$1) {
     const kind = operatorMap$1[key];
-    BaseValue.prototype[key] = function (scope, value) {
-        const [left, leftInst] = this.consume(scope);
-        const [right, rightInst] = value.consume(scope);
-        const temp = new StoreValue(scope);
+    BaseValue.prototype[key] = function (scope, value, out) {
+        const [left, leftInst] = this.eval(scope);
+        const [right, rightInst] = value.eval(scope);
+        const temp = StoreValue.from(scope, out);
         return [
             temp,
             [
@@ -417,19 +582,19 @@ const assignmentToBinary = {
     "||=": "||",
     "??=": "??",
 };
-for (const op in assignmentToBinary) {
+for (const k in assignmentToBinary) {
+    const op = k;
     BaseValue.prototype[op] = function (scope, value) {
-        this.ensureOwned();
-        const [opValue, opInst] = this[assignmentToBinary[op]](scope, value);
+        const [opValue, opInst] = this[assignmentToBinary[op]](scope, value, this);
         const [retValue, retInst] = this["="](scope, opValue);
         return [retValue, [...opInst, ...retInst]];
     };
 }
 for (const key of updateOperators) {
-    BaseValue.prototype[key] = function (scope, prefix) {
-        let [ret, inst] = this.consume(scope);
+    BaseValue.prototype[key] = function (scope, prefix, out) {
+        let [ret, inst] = this.eval(scope);
         if (!prefix) {
-            const temp = new StoreValue(scope);
+            const temp = StoreValue.out(scope, out);
             const [tempValue, tempInst] = temp["="](scope, ret);
             ret = tempValue;
             inst.push(...tempInst);
@@ -441,7 +606,7 @@ for (const key of updateOperators) {
 
 const literalMethods = {
     length: function () {
-        if (typeof this.data !== "string")
+        if (!this.isString())
             throw new CompilerError("Length method only works on string literal values.");
         return new LiteralValue(this.data.length);
     },
@@ -455,14 +620,11 @@ class LiteralValue extends BaseValue {
     eval(_scope) {
         return [this, []];
     }
-    consume(_scope) {
-        return [this, []];
-    }
     toString() {
         return JSON.stringify(this.data);
     }
     get(scope, name) {
-        if (!(name instanceof LiteralValue && typeof name.data === "string"))
+        if (!(name instanceof LiteralValue && name.isString()))
             return super.get(scope, name);
         const method = literalMethods[name.data];
         if (!method)
@@ -479,7 +641,12 @@ class LiteralValue extends BaseValue {
     typeof() {
         return [new LiteralValue("literal"), []];
     }
-    ensureOwned() { }
+    isString() {
+        return typeof this.data === "string";
+    }
+    isNumber() {
+        return typeof this.data === "number";
+    }
 }
 const operatorMap = {
     "==": (a, b) => +(a == b),
@@ -505,11 +672,22 @@ const operatorMap = {
     "&&": (a, b) => +(a && b),
     "||": (a, b) => +(a || b),
 };
-for (const key in operatorMap) {
+for (const k in operatorMap) {
+    const key = k;
     const fn = operatorMap[key];
-    LiteralValue.prototype[key] = function (scope, value) {
+    LiteralValue.prototype[key] = function (scope, value, out) {
+        if (key === "&&") {
+            if (this.data)
+                return [value, []];
+            return [new LiteralValue(0), []];
+        }
+        if (key === "||") {
+            if (!this.data)
+                return [value, []];
+            return [new LiteralValue(1), []];
+        }
         if (!(value instanceof LiteralValue)) {
-            return BaseValue.prototype[key].apply(this, [scope, value]);
+            return BaseValue.prototype[key].apply(this, [scope, value, out]);
         }
         return [new LiteralValue(fn(this.data, value.data)), []];
     };
@@ -527,162 +705,45 @@ for (const key in unaryOperatorMap) {
     };
 }
 
-/**
- * The prefix for internal variables inside the compiler output
- */
-const internalPrefix = "&";
-const discardedName = `${internalPrefix}_`;
-/**
- * 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].
- */
-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}`;
-    return `${line}:${column}`;
-}
-/**
- * Converts a camel case string into a dash case one.
- *
- * As an example `camelCase` becomes `camel-case`
- * @example
- * ```
- * camelToDashCase("camelCase") // returns "camel-case"
- * ```
- */
-function camelToDashCase(name) {
-    return name.replace(/[A-Z]/g, str => `-${str.toLowerCase()}`);
-}
-const itemNames = [
-    "copper",
-    "lead",
-    "metaglass",
-    "graphite",
-    "sand",
-    "coal",
-    "titanium",
-    "thorium",
-    "scrap",
-    "silicon",
-    "plastanium",
-    "phaseFabric",
-    "surgeAlloy",
-    "sporePod",
-    "blastCompound",
-    "pyratite",
-    "beryllium",
-    "tungsten",
-    "oxide",
-    "carbide",
-    "fissileMatter",
-    "dormantCyst",
-];
-/**
- * A more type safe version of `Object.assign`
- */
-// eslint-disable-next-line @typescript-eslint/ban-types
-function assign(obj, props) {
-    return Object.assign(obj, props);
-}
-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;
-}
-function withAlwaysRuns(valueInst, value) {
-    valueInst[1].forEach(inst => (inst.alwaysRuns = value));
-    return valueInst;
-}
-function isTemplateObjectArray(value) {
-    return (value instanceof ObjectValue &&
-        value.data.length instanceof LiteralValue &&
-        typeof value.data.length.data === "number" &&
-        value.data.raw instanceof ObjectValue &&
-        value.data.raw.data.length instanceof LiteralValue &&
-        typeof value.data.raw.data.length.data === "number");
-}
-
-class ValueOwner {
-    /**
-     * Creates a new `ValueOwner`, if `value` is already owned,
-     * `this` will be aliased to `value`, else `this` will own `value`
-     */
-    constructor({ scope, constant = false, value, identifier, name, }) {
-        this.scope = scope;
-        this.constant = constant;
-        this.value = value;
-        this.identifier = identifier;
-        this.name = name ?? scope.makeTempName();
-        this.persistent = !!name;
-        this.owned = new Set();
-        if (!value.owner?.persistent)
-            this.own(value);
-    }
-    own(target) {
-        target.owner = this;
-        this.owned.add(target);
-    }
-    replace(target) {
-        this.value.owner = null;
-        this.owned.delete(this.value);
-        this.value = target;
-        this.own(target);
-    }
-    moveInto(owner) {
-        this.owned.forEach(value => owner.own(value));
-        this.owned.clear();
-    }
-}
-
 /**
  * `StoreValue` represents values unknown at compile time,
  * mostly used with mutable variables and temporary values
  */
 class StoreValue extends BaseValue {
-    constructor(scope) {
+    constructor(name, mutability = EMutability.mutable) {
         super();
-        this.scope = scope;
-        this.mutability = EMutability.mutable;
+        this.name = name;
+        this.mutability = mutability;
+    }
+    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);
+    }
+    static out(scope, out, mutability = EMutability.mutable) {
+        if (!out || typeof out === "string") {
+            return new StoreValue(out ?? scope.makeTempName(), mutability);
+        }
+        return out;
     }
     typeof() {
         return [new LiteralValue("store"), []];
     }
     "="(scope, value) {
-        if (this.mutability !== EMutability.mutable)
+        if (this.mutability !== EMutability.mutable &&
+            this.mutability !== EMutability.init)
             throw new CompilerError(`Cannot assign to immutable store '${this}'.`);
-        if (this.owner) {
-            if (this.owner === value.owner && value instanceof StoreValue)
-                return [this, []];
-            if (!value.owner?.persistent) {
-                if (!value.owner)
-                    this.owner.own(value);
-                else
-                    value.owner.moveInto(this.owner);
-                if (value instanceof StoreValue)
-                    return [this, []];
-            }
-        }
-        const [evalValue, evalInst] = value.consume(scope);
+        if (this.name === value.name && value instanceof StoreValue)
+            return [this, []];
+        const [evalValue, evalInst] = value.eval(scope, this);
         return [this, [...evalInst, new SetInstruction(this, evalValue)]];
     }
     eval(_scope) {
         return [this, []];
     }
-    consume(_scope) {
-        this.ensureOwned();
-        return [this, []];
-    }
-    ensureOwned() {
-        this.owner ??= new ValueOwner({ scope: this.scope, value: this });
-    }
     toString() {
-        return this.owner?.name ?? discardedName;
+        return this.name;
     }
 }
 
@@ -704,10 +765,13 @@ class ObjectValue extends VoidValue {
         });
         return new ObjectValue(data);
     }
-    typeof() {
+    typeof(scope, out) {
+        const { $typeof } = this.data;
+        if ($typeof)
+            return $typeof.call(scope, [], out);
         return [new LiteralValue("object"), []];
     }
-    get(scope, key) {
+    get(scope, key, out) {
         // avoids naming collisions with keys like
         // constructor or toString
         if (Object.prototype.hasOwnProperty.call(this.data, key.data)) {
@@ -718,40 +782,45 @@ class ObjectValue extends VoidValue {
         const { $get } = this.data;
         if (!$get)
             throw new CompilerError("Cannot get undefined member.");
-        return $get.call(scope, [key]);
+        return $get.call(scope, [key], out);
     }
-    eval(scope) {
+    eval(scope, out) {
         const { $eval } = this.data;
         if (!$eval)
             return [this, []];
-        return $eval.call(scope, []);
-    }
-    consume(scope) {
-        const { $consume } = this.data;
-        if ($consume)
-            return $consume.call(scope, []);
-        const result = this.eval(scope);
-        // required by typescript
-        const res = result[0];
-        res.ensureOwned();
-        return result;
+        return $eval.call(scope, [], out);
     }
-    call(scope, args) {
+    call(scope, args, out) {
         const { $call } = this.data;
         if (!$call)
-            return super.call(scope, args);
-        return $call.call(scope, args);
+            return super.call(scope, args, out);
+        return $call.call(scope, args, out);
     }
-    ensureOwned() { }
 }
-for (const op of operators) {
-    ObjectValue.prototype[op] = function (...args) {
+for (const op of leftRightOperators) {
+    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}`];
-        // eslint-disable-next-line @typescript-eslint/ban-types, @typescript-eslint/no-unsafe-return
         if (!$)
-            return VoidValue.prototype[op].apply(this, args);
-        const [scope, ...fnArgs] = args;
-        return $.call(scope, fnArgs);
+            return VoidValue.prototype[op].apply(this, [scope, prefix, out]);
+        return $.call(scope, [new LiteralValue(+prefix)], out);
     };
 }
 
@@ -776,27 +845,37 @@ const senseableProps = ["controller"];
  * ```
  */
 class SenseableValue extends StoreValue {
-    constructor(scope) {
-        super(scope);
-        this.mutability = EMutability.constant;
+    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) {
-        if (prop instanceof LiteralValue && typeof prop.data === "string") {
+    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)
-                ? new SenseableValue(scope)
-                : new StoreValue(scope);
+                ? SenseableValue.from(scope, out, mutability)
+                : StoreValue.from(scope, out, mutability);
             return [
                 result,
                 [new InstructionBase("sensor", result, this, `@${name}`)],
             ];
         }
         if (prop instanceof StoreValue) {
-            const temp = assign(new SenseableValue(scope), {
-                mutability: EMutability.readonly,
-            });
+            const temp = SenseableValue.from(scope, out, mutability);
             return [temp, [new InstructionBase("sensor", temp, this, prop)]];
         }
         throw new CompilerError(`Cannot sense "${prop}" property`);
@@ -815,21 +894,34 @@ class DestructuringValue extends VoidValue {
         super();
         this.members = members;
         this.macro = true;
+        this.fields = {};
+        for (const [key, { value }] of this.members) {
+            if (key instanceof LiteralValue && (key.isString() || key.isNumber())) {
+                this.fields[key.data] = value;
+            }
+        }
     }
     "="(scope, right) {
         const inst = [];
-        for (const [key, value] of this.members) {
-            const [item, itemInst] = right.get(scope, key);
-            inst.push(...itemInst);
-            inst.push(...value["="](scope, item)[1]);
+        for (const [key, { value, handler }] of this.members) {
+            const [, handlerInst] = handler(() => right.get(scope, key, value));
+            inst.push(...handlerInst);
         }
         return [right, inst];
     }
     eval(_scope) {
         return [this, []];
     }
-    consume(_scope) {
-        return [this, []];
+}
+
+/**
+ * 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) {
+        super();
+        this.eval = evalutate;
     }
 }
 
@@ -866,46 +958,29 @@ class Scope {
         return false;
     }
     get(identifier) {
-        const owner = this.data[identifier];
-        if (owner)
-            return owner.value;
+        const value = this.data[identifier];
+        if (value)
+            return value;
         if (this.parent)
             return this.parent.get(identifier);
         throw new CompilerError(`${identifier} is not declared.`);
     }
-    set(...args) {
-        const name = args.length === 1 ? args[0].identifier : args[0];
-        if (!name)
-            throw new CompilerError("Values in a scope must have an identifier");
+    set(name, value) {
         if (name in this.data)
             throw new CompilerError(`${name} is already declared.`);
-        return this.hardSet(...args);
-    }
-    hardSet(...args) {
-        const owner = args.length === 1
-            ? args[0]
-            : new ValueOwner({
-                scope: this,
-                identifier: args[0],
-                name: args[0],
-                value: args[1],
-            });
-        const { identifier } = owner;
-        if (!identifier)
+        return this.hardSet(name, value);
+    }
+    hardSet(name, value) {
+        if (!name)
             throw new CompilerError("Values in a scope must have an identifier");
-        this.data[identifier] = owner;
-        return owner.value;
+        this.data[name] = value;
+        return value;
     }
     make(identifier, name) {
-        const owner = new ValueOwner({
-            scope: this,
-            value: assign(new SenseableValue(this), {
-                mutability: EMutability.mutable,
-            }),
-            identifier,
-            name,
+        const value = assign(new SenseableValue(name), {
+            mutability: EMutability.mutable,
         });
-        return this.set(owner);
+        return this.set(identifier, value);
     }
     makeTempName() {
         let result = `${internalPrefix}t${this.ntemp}`;
@@ -921,163 +996,222 @@ const Program = (c, scope, node) => {
 };
 
 const VariableDeclaration = (c, scope, node) => {
-    return c.handleMany(scope, node.declarations, child => VariableDeclarator(c, scope, child, node.kind));
+    return c.handleMany(scope, node.declarations, child => VariableDeclarator(c, scope, child, undefined, node.kind));
 };
-const VariableDeclarator = (c, scope, node, kind = "let") => {
-    const [init, inst] = node.init
-        ? c.handleEval(scope, node.init)
-        : [null, []];
-    inst.push(...Declare(c, scope, node.id, kind, init)[1]);
+const VariableDeclarator = (c, scope, node, out, kind = "let") => {
+    const { init } = node;
+    const [value, inst] = Declare(c, scope, node.id, kind);
+    if (init) {
+        const [result, resultInst] = c.handleEval(scope, init, value.out);
+        inst.push(...value.handler(result, resultInst)[1]);
+    }
+    else {
+        inst.push(...value.handler(null, [])[1]);
+    }
     return [null, inst];
 };
-const Declare = (c, scope, node, kind, init) => {
+const Declare = (c, scope, node, kind) => {
     return c.handle(scope, node, () => {
         switch (node.type) {
             case "Identifier":
-                return DeclareIdentifier(c, scope, node, kind, init);
+                return DeclareIdentifier(c, scope, node, kind);
             case "ArrayPattern":
-                return DeclareArrayPattern(c, scope, node, kind, init);
+                return DeclareArrayPattern(c, scope, node, kind);
             case "ObjectPattern":
-                return DeclareObjectPattern(c, scope, node, kind, init);
+                return DeclareObjectPattern(c, scope, node, kind);
             default:
                 throw new CompilerError(`Unsupported declaration type: ${node.type}`, node);
         }
     });
 };
-const DeclareIdentifier = (c, scope, node, kind, init) => {
+const DeclareIdentifier = (c, scope, node, kind) => {
     const { name: identifier } = node;
     const name = nodeName(node, !c.compactNames && identifier);
-    if (kind === "const" && !init)
-        throw new CompilerError("Constants must be initialized.", node);
-    if (kind === "const" && init?.mutability === EMutability.constant) {
-        const owner = new ValueOwner({
-            scope,
-            identifier,
-            name,
-            value: init,
-            constant: true,
-        });
-        scope.set(owner);
-        return [null, []];
-    }
-    else {
-        const value = scope.make(identifier, name);
-        const inst = [];
-        if (init) {
-            if (init.macro)
-                throw new CompilerError("Macro values must be held by constants", node);
-            inst.push(...value["="](scope, init)[1]);
-        }
-        if (kind === "const")
-            value.mutability = EMutability.constant;
-        return [null, inst];
-    }
+    const out = SenseableValue.from(scope, name, kind === "const" ? EMutability.init : EMutability.mutable);
+    const declarationValue = new DeclarationValue({
+        c,
+        scope,
+        node,
+        out,
+        handler(init, inst) {
+            if (kind === "const" && !init)
+                throw new CompilerError("Constants must be initialized.", node);
+            if (kind === "const" && init?.mutability === EMutability.constant) {
+                scope.set(identifier, init);
+                return [null, inst];
+            }
+            else {
+                const value = scope.make(identifier, name);
+                if (init) {
+                    if (init.macro)
+                        throw new CompilerError("Macro values must be held by constants", node);
+                    inst.push(...value["="](scope, init)[1]);
+                }
+                if (kind === "const")
+                    value.mutability = EMutability.constant;
+                return [null, inst];
+            }
+        },
+    });
+    return [declarationValue, []];
 };
-const DeclareArrayPattern = (c, scope, node, kind, init) => {
+const DeclareArrayPattern = (c, scope, node, kind) => {
+    const members = new Map();
     const { elements } = node;
-    if (!(init instanceof ObjectValue))
-        throw new CompilerError("The value being destructured must be an object value");
     const inst = [];
     for (let i = 0; i < elements.length; i++) {
         const element = elements[i];
         if (!element)
             continue;
-        const val = init.data[i];
-        if (!val)
-            throw new CompilerError(`The target object does not have a value at index ${i}`, element);
-        inst.push(...Declare(c, scope, element, kind, val)[1]);
+        const [value, valueInst] = Declare(c, scope, element, kind);
+        inst.push(...valueInst);
+        members.set(new LiteralValue(i), {
+            value: value.out,
+            handler(get) {
+                return c.handle(scope, element, () => {
+                    let [init, initInst] = [null, []];
+                    try {
+                        [init, initInst] = get();
+                    }
+                    catch (e) {
+                        // catches the "cannot get undefined member" error
+                        // TODO: refactor and add error codes
+                        // so we don't have to do string checks
+                        if (!(e instanceof CompilerError) ||
+                            !e.message.includes("undefined member"))
+                            throw e;
+                    }
+                    if (!init)
+                        throw new CompilerError(`The target object does not have a value at index ${i}`, element);
+                    return value.handler(init, initInst);
+                });
+            },
+        });
     }
-    return [null, inst];
+    const out = new DestructuringValue(members);
+    const value = new DeclarationValue({
+        c,
+        scope,
+        node,
+        out,
+        handler(init, initInst) {
+            if (!(init instanceof ObjectValue))
+                throw new CompilerError("The value being destructured must be an object value");
+            initInst.push(...out["="](scope, init)[1]);
+            return [null, initInst];
+        },
+    });
+    return [value, inst];
 };
-const DeclareObjectPattern = (c, scope, node, kind, base) => {
-    if (!base)
-        throw new CompilerError("Cannot use object destructuring without an initializer", node);
+const DeclareObjectPattern = (c, scope, node, kind) => {
+    const inst = [];
+    const members = new Map();
     const { properties } = node;
-    const [init, inst] = base.consume(scope);
     const propertiesInst = c.handleMany(scope, properties, prop => {
         if (prop.type === "RestElement")
             throw new CompilerError("The rest operator is not supported", prop);
-        const { key, value } = prop;
+        const { key, value: propValue } = prop;
         const keyInst = key.type === "Identifier" && !prop.computed
             ? [new LiteralValue(key.name), []]
-            : c.handleConsume(scope, prop.key);
-        const propInit = init.get(scope, keyInst[0]);
-        const declarationInst = Declare(c, scope, value, kind, propInit[0]);
-        return [null, [...keyInst[1], ...propInit[1], ...declarationInst[1]]];
+            : c.handleEval(scope, prop.key);
+        const [value, valueInst] = Declare(c, scope, propValue, kind);
+        members.set(keyInst[0], {
+            value: value.out,
+            handler(get) {
+                return c.handle(scope, propValue, () => {
+                    const [init, initInst] = get();
+                    return value.handler(init, initInst);
+                });
+            },
+        });
+        return [null, [...keyInst[1], ...valueInst]];
     });
-    return [null, [...inst, ...propertiesInst[1]]];
-};
+    const out = new DestructuringValue(members);
+    const declarationValue = new DeclarationValue({
+        c,
+        scope,
+        node,
+        out,
+        handler(init, initInst) {
+            if (!init)
+                throw new CompilerError("Cannot use object destructuring without an initializer", node);
+            initInst.push(...out["="](scope, init)[1]);
+            return [null, initInst];
+        },
+    });
+    return [declarationValue, [...inst, ...propertiesInst[1]]];
+};
+class DeclarationValue extends VoidValue {
+    constructor({ c, scope, node, out, handler, }) {
+        super();
+        this.out = out;
+        this.c = c;
+        this.scope = scope;
+        this.node = node;
+        this.handle = handler;
+    }
+    handler(init, inst) {
+        return this.c.handle(this.scope, this.node, () => this.handle(init, inst));
+    }
+}
 
 const Literal = (_c, scope, node) => [new LiteralValue(node.value), []];
 const NumericLiteral = Literal;
 const StringLiteral = Literal;
-const NullLiteral = () => [
-    new LiteralValue(null),
-    [],
-];
+const NullLiteral = () => [new LiteralValue(null), []];
 const BooleanLiteral = (_c, scope, node) => [new LiteralValue(+node.value), []];
 
-const LRExpression = (c, scope, node) => {
-    const [left, leftInst] = c.handleConsume(scope, node.left);
-    const [right, rightInst] = c.handleConsume(scope, node.right);
-    const [op, opInst] = left[node.operator](scope, right);
+const LRExpression = (c, scope, node, out) => {
+    const [left, leftInst] = c.handleEval(scope, node.left);
+    const [right, rightInst] = c.handleEval(scope, node.right);
+    const [op, opInst] = left[node.operator](scope, right, out);
     return [op, [...leftInst, ...rightInst, ...opInst]];
 };
 const BinaryExpression = LRExpression;
-const LogicalExpression = (c, scope, node) => {
+const LogicalExpression = (c, scope, node, out) => {
     if (node.operator !== "??")
-        return LRExpression(c, scope, node);
-    const other = lazyValue({
-        eval: scope => c.handleEval(scope, node.right),
-        consume: scope => c.handleConsume(scope, node.right),
-    });
+        return LRExpression(c, scope, node, undefined);
+    const other = new LazyValue((scope, out) => c.handleEval(scope, node.right, out));
     const [left, leftInst] = c.handleEval(scope, node.left);
-    const [result, resultInst] = left["??"](scope, other);
+    const [result, resultInst] = left["??"](scope, other, out);
     return [result, [...leftInst, ...resultInst]];
 };
 const AssignmentExpression = (c, scope, node) => {
     const [left, leftInst] = c.handle(scope, node.left);
-    // doesn't need to consume because the operators already do that
     const [right, rightInst] = node.operator !== "??="
-        ? c.handleEval(scope, node.right)
+        ? c.handleEval(scope, node.right, node.operator === "=" && left ? left : undefined)
         : [
-            lazyValue({
-                eval: scope => c.handleEval(scope, node.right),
-                consume: scope => c.handleConsume(scope, node.right),
-            }),
+            new LazyValue((scope, out) => c.handleEval(scope, node.right, out)),
             [],
         ];
     // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
     const [op, opInst] = left[node.operator](scope, right);
     return [op, [...leftInst, ...rightInst, ...opInst]];
 };
-const UnaryExpression = (c, scope, { argument, operator }) => {
-    const [arg, argInst] = c.handleConsume(scope, argument);
+const UnaryExpression = (c, scope, { argument, operator }, out) => {
+    const [arg, argInst] = c.handleEval(scope, argument);
     const operatorId = operator == "+" || operator == "-" ? `u${operator}` : operator;
     if (operatorId === "throw")
         throw new CompilerError("throw operator is not supported");
-    const [op, opInst] = arg[operatorId](scope);
+    const [op, opInst] = arg[operatorId](scope, out);
     return [op, [...argInst, ...opInst]];
 };
-const UpdateExpression = (c, scope, { argument, operator, prefix }) => {
+const UpdateExpression = (c, scope, { argument, operator, prefix }, out) => {
     const [arg, argInst] = c.handle(scope, argument);
     // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-    const [op, opInst] = arg[operator](scope, prefix);
+    const [op, opInst] = arg[operator](scope, prefix, out);
     return [op, [...argInst, ...opInst]];
 };
-const ConditionalExpression = (c, scope, node) => {
-    const [test, testInst] = c.handleConsume(scope, node.test);
+const ConditionalExpression = (c, scope, node, out) => {
+    const [test, testInst] = c.handleEval(scope, node.test);
     if (test instanceof LiteralValue) {
         if (test.data)
-            return c.handleEval(scope, node.consequent);
-        return c.handleEval(scope, node.alternate);
-    }
-    // TODO: this creates those annoying jumps on the
-    // temp counter, specially if you nest ternary operators
-    const result = new StoreValue(scope);
-    result.ensureOwned();
-    const consequent = c.handleEval(scope, node.consequent);
-    const alternate = c.handleEval(scope, node.alternate);
+            return c.handleEval(scope, node.consequent, out);
+        return c.handleEval(scope, node.alternate, out);
+    }
+    const result = SenseableValue.out(scope, out);
+    const consequent = c.handleEval(scope, node.consequent, result);
+    const alternate = c.handleEval(scope, node.alternate, result);
     const alternateStartAdress = new LiteralValue(null);
     const endExpressionAdress = new LiteralValue(null);
     return [
@@ -1094,20 +1228,14 @@ const ConditionalExpression = (c, scope, node) => {
             new AddressResolver(endExpressionAdress),
         ],
     ];
-};
-function lazyValue(options) {
-    const value = new VoidValue();
-    value.eval = options.eval;
-    value.consume = options.consume;
-    return value;
-}
+};
 
 const Identifier = (c, scope, node) => {
     return [scope.get(node.name), []];
 };
 
 const ExpressionStatement = (c, scope, node) => {
-    return c.handle(scope, node.expression);
+    return c.handle(scope, node.expression, undefined, discardedName);
 };
 const BreakStatement = (_, scope, node) => {
     const label = node.label?.name;
@@ -1123,11 +1251,12 @@ const ContinueStatement = (_, scope, node) => {
     target.continue.bind(addr);
     return [null, [new ContinueInstruction(addr)]];
 };
-const ReturnStatement = (c, scope, node) => {
-    const [arg, argInst] = node.argument
-        ? c.handle(scope, node.argument)
+const ReturnStatement = (c, scope, node, out) => {
+    const { argument } = node;
+    const [arg, argInst] = argument
+        ? [new LazyValue((scope, out) => c.handleEval(scope, argument, out)), []]
         : [null, []];
-    const [ret, retInst] = scope.function.return(scope, arg);
+    const [ret, retInst] = scope.function.return(scope, arg, out);
     return [ret, [...argInst, ...retInst]];
 };
 const LabeledStatement = (c, scope, node) => {
@@ -1150,7 +1279,7 @@ function findScopeLabel(scope, label) {
 
 const IfStatement = (c, scope, node) => {
     const inst = [];
-    const [test, testInst] = c.handleConsume(scope, node.test);
+    const [test, testInst] = c.handleEval(scope, node.test);
     if (test instanceof LiteralValue) {
         if (test.data)
             inst.push(...c.handle(scope, node.consequent)[1]);
@@ -1169,44 +1298,73 @@ const IfStatement = (c, scope, node) => {
 
 const SwitchStatement = (c, scope, node) => {
     const innerScope = scope.createScope();
-    const [ref, refInst] = c.handleConsume(scope, node.discriminant);
+    const [ref, refInst] = c.handleEval(scope, node.discriminant);
     const inst = [];
     const endAdress = new LiteralValue(null);
     const endLine = new AddressResolver(endAdress).bindBreak(innerScope);
     const caseJumps = [];
     let defaultJump;
+    // if there is a case that is guaranteed to run
+    let constantCase = false;
+    let onlyConstantTests = true;
     for (const scase of node.cases) {
         const [, bodyInst] = c.handleMany(innerScope, scase.consequent);
         const bodyAdress = new LiteralValue(null);
         const bodyLine = new AddressResolver(bodyAdress);
+        const canFallInto = !endsWithoutFalltrough(inst, endLine);
+        let includeJump = !constantCase;
+        const includeBody = !constantCase || canFallInto;
         if (!scase.test) {
-            [defaultJump] = c.handle(innerScope, scase, () => [
-                null,
-                [new JumpInstruction(bodyAdress, EJumpKind.Always)],
-            ])[1];
-            inst.push(bodyLine, ...bodyInst);
+            if (includeJump) {
+                [defaultJump] = c.handle(innerScope, scase, () => [
+                    null,
+                    [new JumpInstruction(bodyAdress, EJumpKind.Always)],
+                ])[1];
+            }
+            if (includeBody)
+                inst.push(bodyLine, ...bodyInst);
             continue;
         }
-        const [test, testInst] = c.handleConsume(innerScope, scase.test);
+        const [test, testInst] = c.handleEval(innerScope, scase.test);
+        if (onlyConstantTests)
+            onlyConstantTests = test.mutability === EMutability.constant;
+        let jump;
         // check if it can be evaluated at compile time
-        const [comp] = ref["=="](innerScope, test);
-        // if the constant expression resolves to false
-        // the whole case gets omitted
-        // otherwise it returns the instructions for
-        // the body of this case
+        // the scope copy prevents unecessary increases in the temp counter
+        const [comp] = ref["=="](innerScope.copy(), test);
         if (comp instanceof LiteralValue) {
-            if (comp.data)
-                return [null, bodyInst];
-            else
-                continue;
+            // whether other cases can falltrough and reach this one
+            const noFallInto = !canFallInto;
+            if (!comp.data) {
+                // this case is not accessible in any way
+                if (noFallInto)
+                    continue;
+                includeJump = false;
+            }
+            else {
+                // this case is only accessible via the comparison jump
+                // and all the other cases will never run
+                if (noFallInto &&
+                    onlyConstantTests &&
+                    endsWithoutFalltrough(bodyInst, endLine)) {
+                    return [null, [...bodyInst, endLine]];
+                }
+                jump = c.handle(innerScope, scase, () => [
+                    null,
+                    [new JumpInstruction(bodyAdress, EJumpKind.Always)],
+                ])[1];
+                constantCase = true;
+            }
         }
         // makes sourcemapping for the jump more specific
-        const [, jump] = c.handle(innerScope, scase, () => [
+        jump ??= c.handle(innerScope, scase, () => [
             null,
             [new JumpInstruction(bodyAdress, EJumpKind.StrictEqual, ref, test)],
-        ]);
-        caseJumps.push(...testInst, ...jump);
-        inst.push(bodyLine, ...bodyInst);
+        ])[1];
+        if (includeJump)
+            caseJumps.push(...testInst, ...jump);
+        if (includeBody)
+            inst.push(bodyLine, ...bodyInst);
     }
     // ensures that the processor exits
     // the switch if no cases match
@@ -1221,16 +1379,38 @@ const SwitchStatement = (c, scope, node) => {
         [
             ...refInst,
             ...caseJumps,
-            ...(caseJumps.length > 0 ? [defaultJump] : []),
+            ...(caseJumps.length > 0 && !constantCase ? [defaultJump] : []),
             ...inst,
             endLine,
         ],
     ];
-};
+};
+function endsWithoutFalltrough(inst, endLine) {
+    if (inst.length === 0)
+        return true;
+    for (let i = inst.length - 1; i >= 0; i--) {
+        const instruction = inst[i];
+        // this means that there is an instruction trying to reference
+        // the final function `set @counter` instruction
+        // of course this generates an unecessary
+        // `set @counter` in cases where a control flow
+        // structure contains a fallback return statement
+        // TODO: fix this with static analysis
+        if (instruction instanceof AddressResolver)
+            return false;
+        if (instruction.hidden)
+            continue;
+        return (instruction instanceof SetCounterInstruction ||
+            instruction.intent === EInstIntent.return ||
+            (instruction instanceof BreakInstruction &&
+                endLine.bonds.includes(instruction.address)));
+    }
+    return false;
+}
 
 const WhileStatement = (c, scope, node) => {
     const lines = [];
-    const [test, testLines] = c.handleConsume(scope, node.test);
+    const [test, testLines] = c.handleEval(scope, node.test);
     const childScope = scope.createScope();
     const startLoopAddr = new LiteralValue(null);
     const endLoopAddr = new LiteralValue(null);
@@ -1250,7 +1430,7 @@ const WhileStatement = (c, scope, node) => {
 };
 const DoWhileStatement = (c, scope, node) => {
     const lines = [];
-    const [test, testLines] = c.handleConsume(scope, node.test);
+    const [test, testLines] = c.handleEval(scope, node.test);
     const childScope = scope.createScope();
     const startLoopAddr = new LiteralValue(null);
     const startLoopLine = new AddressResolver(startLoopAddr).bindContinue(childScope);
@@ -1279,9 +1459,11 @@ const ForStatement = (c, parentScope, node) => {
     const scope = parentScope.createScope();
     const initInst = node.init ? c.handle(scope, node.init)[1] : [];
     const [test, testLines] = node.test
-        ? c.handleConsume(scope, node.test)
+        ? c.handleEval(scope, node.test)
         : [new LiteralValue(1), []];
-    const updateLines = node.update ? c.handle(scope, node.update)[1] : [];
+    const updateLines = node.update
+        ? c.handle(scope, node.update, undefined, discardedName)[1]
+        : [];
     const startLoopAddr = new LiteralValue(null);
     // continue statements jump here to run the loop update lines
     const beforeEndAddr = new LiteralValue(null);
@@ -1309,146 +1491,131 @@ const ForStatement = (c, parentScope, node) => {
 };
 
 class FunctionValue extends VoidValue {
-    constructor({ scope, params, body, c, }) {
+    constructor({ scope, params, body, c, out, }) {
         super();
         this.mutability = EMutability.constant;
         this.macro = true;
-        this.paramOwners = [];
+        this.paramValues = [];
+        this.paramNames = [];
         this.bundled = false;
         this.initialized = false;
         this.scope = scope;
         this.body = body;
         this.c = c;
         this.params = params;
+        this.out = out;
+        this.name = extractOutName(out) ?? scope.makeTempName();
     }
     typeof() {
         return [new LiteralValue("function"), []];
     }
-    initScope(name) {
-        this.childScope = this.scope.createFunction(name);
+    initScope() {
+        this.childScope = this.scope.createFunction(this.name);
         this.childScope.function = this;
         for (const id of this.params) {
             const name = nodeName(id, !this.c.compactNames && id.name);
-            const owner = new ValueOwner({
-                scope: this.childScope,
-                value: assign(new SenseableValue(this.childScope), {
-                    mutability: EMutability.mutable,
-                }),
-                identifier: id.name,
-                name,
-            });
-            this.childScope.set(owner);
-            this.paramOwners.push(owner);
+            const value = new SenseableValue(name, EMutability.mutable);
+            this.childScope.set(id.name, value);
+            this.paramValues.push(value);
+            this.paramNames.push(id.name);
         }
-        this.callSize = this.paramOwners.length + 2;
+        this.callSize = this.paramValues.length + 2;
     }
     ensureInit() {
-        if (!this.owner)
-            throw new CompilerError(`Functions must be owned by a variable`);
         if (this.initialized)
             return;
         this.initialized = true;
-        const { name } = this.owner;
-        this.initScope(name);
+        this.initScope();
         this.addr = new LiteralValue(null);
-        this.temp = new ValueOwner({
-            scope: this.childScope,
-            name: `${internalPrefix}f${name}`,
-            value: assign(new SenseableValue(this.childScope), {
-                mutability: EMutability.mutable,
-            }),
-        });
-        this.ret = new ValueOwner({
-            scope: this.childScope,
-            name: `${internalPrefix}r${name}`,
-            value: new StoreValue(this.childScope),
-        });
+        this.temp = new SenseableValue(`${internalPrefix}f${this.name}`, EMutability.mutable);
+        this.ret = new StoreValue(`${internalPrefix}r${this.name}`);
         this.inst = [
             new AddressResolver(this.addr),
             ...this.c.handle(this.childScope, this.body)[1],
         ];
         if (!endsWithReturn(this.inst)) {
-            this.inst.push(assign(new SetCounterInstruction(this.ret.value), {
+            this.inst.push(assign(new SetCounterInstruction(this.ret), {
                 intent: EInstIntent.return,
             }));
         }
     }
     normalReturn(scope, arg) {
-        const argInst = arg ? this.temp.value["="](scope, arg)[1] : [];
-        const returnInst = assign(new SetCounterInstruction(this.ret.value), {
+        const inst = [];
+        if (arg) {
+            const [value, valueInst] = arg.eval(scope, this.temp);
+            const argInst = this.temp["="](scope, value)[1];
+            inst.push(...valueInst);
+            inst.push(...argInst);
+        }
+        const returnInst = assign(new SetCounterInstruction(this.ret), {
             intent: EInstIntent.return,
         });
-        return [null, [...argInst, returnInst]];
+        return [null, [...inst, returnInst]];
     }
     // TODO: use static analysis to determine if
     // we can safely skip the temp value assignment
-    normalCall(scope, args) {
+    normalCall(scope, args, out) {
         if (!this.bundled)
             this.childScope.inst.push(...this.inst);
         this.bundled = true;
         const callAddressLiteral = new LiteralValue(null);
-        const temp = assign(new SenseableValue(scope), {
-            mutability: EMutability.mutable,
-        });
-        const inst = this.paramOwners
-            .map(({ value: param }, i) => param["="](scope, args[i])[1])
+        const temp = SenseableValue.from(scope, out, EMutability.mutable);
+        const inst = this.paramValues
+            .map((param, i) => param["="](scope, args[i])[1])
             .reduce((s, c) => s.concat(c), [])
-            .concat(...this.ret.value["="](scope, callAddressLiteral)[1], new JumpInstruction(this.addr, EJumpKind.Always), new AddressResolver(callAddressLiteral), 
+            .concat(...this.ret["="](scope, callAddressLiteral)[1], new JumpInstruction(this.addr, EJumpKind.Always), new AddressResolver(callAddressLiteral), 
         // ensures that functions can be called multiple times inside expressions
-        ...temp["="](scope, this.temp.value)[1]);
+        ...temp["="](scope, this.temp)[1]);
         return [temp, inst];
     }
     inlineReturn(scope, arg) {
-        const argInst = arg ? this.inlineTemp.value["="](scope, arg)[1] : [];
         if (!this.inlineEnd)
             throw new CompilerError("Error during inline attempt: missing inline end adress");
+        const inst = [];
+        if (arg) {
+            const [value, valueInst] = arg.eval(scope, this.inlineTemp);
+            const argInst = this.inlineTemp["="](scope, value)[1];
+            inst.push(...valueInst);
+            inst.push(...argInst);
+        }
         const jump = assign(new JumpInstruction(this.inlineEnd, EJumpKind.Always), {
             intent: EInstIntent.return,
+            intentSource: this,
         });
-        return [null, [...argInst, jump]];
+        return [null, [...inst, jump]];
     }
-    inlineCall(scope, args) {
+    inlineCall(scope, args, out) {
         // create return value
-        this.inlineTemp = new ValueOwner({
-            scope: this.childScope,
-            value: assign(new SenseableValue(scope), {
-                mutability: EMutability.mutable,
-            }),
-        });
+        this.inlineTemp = SenseableValue.from(this.childScope, out, EMutability.mutable);
         // make a copy of the function scope
         const fnScope = this.childScope.copy();
         // hard set variables within the function scope
-        this.paramOwners.forEach((owner, i) => {
-            const value = args[i];
-            if (!value.owner?.persistent)
-                owner.own(value);
-            fnScope.hardSet(new ValueOwner({
-                scope: fnScope,
-                value,
-                identifier: owner.identifier,
-                name: owner.name,
-            }));
+        this.paramNames.forEach((name, i) => {
+            fnScope.hardSet(name, args[i]);
         });
         this.inlineEnd = new LiteralValue(null);
         this.tryingInline = true;
         let inst = this.c.handle(fnScope, this.body)[1];
         this.tryingInline = false;
-        const returnIndex = inst.findIndex(i => i.alwaysRuns && i.intent === EInstIntent.return);
+        const returnIndex = inst.findIndex(i => i.alwaysRuns &&
+            i.intent === EInstIntent.return &&
+            i.intentSource === this);
         if (returnIndex !== -1)
             inst = inst.slice(0, returnIndex + 1);
         inst.push(new AddressResolver(this.inlineEnd));
         // return the function value
-        return [this.inlineTemp.value, inst];
+        return [this.inlineTemp, inst];
     }
-    call(scope, args) {
+    call(scope, args, out) {
         this.ensureInit();
-        if (args.length !== this.paramOwners.length)
+        if (args.length !== this.paramNames.length)
             throw new CompilerError("Cannot call: argument count not matching.");
-        const inlineCall = this.inlineCall(scope, args);
+        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;
-        return this.normalCall(scope, args);
+        return this.normalCall(scope, args, out);
     }
     return(scope, arg) {
         this.ensureInit();
@@ -1463,8 +1630,11 @@ class FunctionValue extends VoidValue {
     eval(_scope) {
         return [this, []];
     }
-    consume(_scope) {
-        return [this, []];
+    paramOuts() {
+        this.ensureInit();
+        if (this.inline || this.tryingInline)
+            return;
+        return this.paramValues;
     }
 }
 function endsWithReturn(inst) {
@@ -1485,7 +1655,7 @@ function endsWithReturn(inst) {
     return false;
 }
 
-function handleFunctionNode(c, scope, node) {
+function handleFunctionNode(c, scope, node, out) {
     let { params, body } = node;
     if (es.isExpression(body)) {
         const { loc } = body;
@@ -1500,46 +1670,44 @@ function handleFunctionNode(c, scope, node) {
             params: params,
             body,
             c,
+            out,
         }),
         [],
     ];
 }
-const ArrowFunctionExpression = (c, scope, node) => {
-    return handleFunctionNode(c, scope, node);
+const ArrowFunctionExpression = (c, scope, node, out) => {
+    return handleFunctionNode(c, scope, node, out);
 };
 const FunctionDeclaration = (c, scope, node) => {
     const identifier = node.id.name;
     const name = nodeName(node, !c.compactNames && identifier);
-    const functionIns = handleFunctionNode(c, scope, node);
-    const owner = new ValueOwner({
-        scope,
-        value: functionIns[0],
-        identifier,
-        name,
-    });
-    return [scope.set(owner), []];
+    const functionIns = handleFunctionNode(c, scope, node, name);
+    scope.set(identifier, functionIns[0]);
+    return functionIns;
 };
 const FunctionExpression = ArrowFunctionExpression;
 const ObjectMethod = ArrowFunctionExpression;
 
-const CallExpression = (c, scope, node) => {
+const CallExpression = (c, scope, node, out) => {
     const inst = [];
-    const args = node.arguments.map(node => {
+    const [callee, calleeInst] = c.handleEval(scope, node.callee);
+    inst.push(...calleeInst);
+    const paramOuts = callee.paramOuts();
+    const args = node.arguments.map((node, index) => {
         // TODO: this might be why t0 did not increment
         // TODO: figure out if the previous todo is still relevant
-        const [v, i] = c.handleConsume(scope, node);
+        const out = paramOuts?.[index];
+        const [v, i] = c.handleEval(scope, node, out);
         inst.push(...i);
         return v;
     });
-    const [callee, calleeInst] = c.handleConsume(scope, node.callee);
-    inst.push(...calleeInst);
-    const [callValue, callInst] = callee.call(scope, args);
+    const [callValue, callInst] = callee.call(scope, args, out);
     inst.push(...callInst);
     return [callValue, inst];
 };
 const NewExpression = CallExpression;
-const TaggedTemplateExpression = (c, scope, node) => {
-    const [tag, tagInst] = c.handleConsume(scope, node.tag);
+const TaggedTemplateExpression = (c, scope, node, out) => {
+    const [tag, tagInst] = c.handleEval(scope, node.tag);
     const template = node.quasi;
     const stringsObject = ObjectValue.fromArray(template.quasis.map(quasi => new LiteralValue(quasi.value.cooked ?? "")), {
         raw: ObjectValue.fromArray(template.quasis.map(quasi => new LiteralValue(quasi.value.raw))),
@@ -1547,15 +1715,15 @@ const TaggedTemplateExpression = (c, scope, node) => {
     const expressions = [];
     const expressionInsts = [];
     template.expressions.forEach(expression => {
-        const [value, inst] = c.handleConsume(scope, expression);
+        const [value, inst] = c.handleEval(scope, expression);
         expressions.push(value);
         expressionInsts.push(...inst);
     });
-    const [result, resultInst] = tag.call(scope, [stringsObject, ...expressions]);
+    const [result, resultInst] = tag.call(scope, [stringsObject, ...expressions], out);
     return [result, [...expressionInsts, ...tagInst, ...resultInst]];
 };
 
-const ObjectExpression = (c, scope, node) => {
+const ObjectExpression = (c, scope, node, out) => {
     const data = {};
     const inst = [];
     for (const prop of node.properties) {
@@ -1575,38 +1743,48 @@ const ObjectExpression = (c, scope, node) => {
         else {
             throw new CompilerError(`Unsupported object key type: ${key.type}`, key);
         }
-        const [member, memberInst] = c.handleEval(scope, value);
-        // TODO: use an approach that can be defined by each type
-        if (!member.owner && !(member instanceof LiteralValue)) {
-            new ValueOwner({
-                scope,
-                constant: true,
-                value: member,
-            });
-        }
+        const [member, memberInst] = c.handleEval(scope, value, extractDestrucuringOut(out, index));
         data[index] = member;
         inst.push(...memberInst);
     }
     return [new ObjectValue(data), inst];
 };
-const ArrayExpression = (c, scope, node) => {
+const ArrayExpression = (c, scope, node, out) => {
     const items = [];
     const inst = [];
-    node.elements.forEach(element => {
+    node.elements.forEach((element, i) => {
         const [value, valueInst] = element
-            ? c.handleEval(scope, element)
+            ? c.handleEval(scope, element, extractDestrucuringOut(out, i))
             : [undefined, []];
         items.push(value);
         inst.push(...valueInst);
     });
     return [ObjectValue.fromArray(items), inst];
 };
-const MemberExpression = (c, scope, node) => {
-    const [obj, objInst] = c.handleConsume(scope, node.object);
+const MemberExpression = (c, scope, node, out) => {
     const [prop, propInst] = node.computed
-        ? c.handleConsume(scope, node.property)
+        ? c.handleEval(scope, node.property)
         : [new LiteralValue(node.property.name), []];
-    const [got, gotInst] = obj.get(scope, prop);
+    if (!out) {
+        const [obj, objInst] = c.handleEval(scope, node.object);
+        const [got, gotInst] = obj.get(scope, prop);
+        return [got, [...objInst, ...propInst, ...gotInst]];
+    }
+    const temp = SenseableValue.out(scope, out);
+    const objOut = new DestructuringValue(new Map([
+        [
+            prop,
+            {
+                value: temp,
+                // a direct assignment should NOT happen
+                handler: () => {
+                    throw new CompilerError("Unexpected destructuring assignment");
+                },
+            },
+        ],
+    ]));
+    const [obj, objInst] = c.handleEval(scope, node.object, objOut);
+    const [got, gotInst] = obj.get(scope, prop, temp);
     return [got, [...objInst, ...propInst, ...gotInst]];
 };
 const ArrayPattern = (c, scope, node) => {
@@ -1616,11 +1794,21 @@ const ArrayPattern = (c, scope, node) => {
         const element = node.elements[i];
         if (!element)
             continue;
-        const valueInst = c.handle(scope, element);
-        if (!valueInst[0])
+        const [value, valueInst] = c.handle(scope, element);
+        if (!value)
             throw new CompilerError("Destructuring element must resolve to a value", element);
-        inst.push(...valueInst[1]);
-        members.set(new LiteralValue(i), valueInst[0]);
+        inst.push(...valueInst);
+        members.set(new LiteralValue(i), {
+            value,
+            handler(get) {
+                return c.handle(scope, element, () => {
+                    const inst = get();
+                    // assigns the output to the target value
+                    inst[1].push(...value["="](scope, inst[0])[1]);
+                    return inst;
+                });
+            },
+        });
     }
     return [new DestructuringValue(members), inst];
 };
@@ -1635,13 +1823,23 @@ const ObjectPattern = (c, scope, node) => {
         const { key } = prop;
         const keyInst = !prop.computed && key.type === "Identifier"
             ? [new LiteralValue(key.name), []]
-            : c.handleConsume(scope, prop.key);
+            : c.handleEval(scope, prop.key);
         inst.push(...keyInst[1]);
-        const valueInst = c.handle(scope, prop.value);
-        if (!valueInst[0])
+        const [value, valueInst] = c.handle(scope, prop.value);
+        if (!value)
             throw new CompilerError("Destructuring member must resolve to a value", prop.value);
-        inst.push(...valueInst[1]);
-        members.set(keyInst[0], valueInst[0]);
+        inst.push(...valueInst);
+        members.set(keyInst[0], {
+            value,
+            handler(get) {
+                return c.handle(scope, prop, () => {
+                    const inst = get();
+                    // assigns the output to the target value
+                    inst[1].push(...value["="](scope, inst[0])[1]);
+                    return inst;
+                });
+            },
+        });
     }
     return [new DestructuringValue(members), inst];
 };
@@ -1686,7 +1884,7 @@ const TSEnumDeclaration = (c, scope, node) => {
             : [new LiteralValue(counter)];
         if (!(value instanceof LiteralValue))
             throw new CompilerError("Enum members must contain literal values", member);
-        if (typeof value.data === "number") {
+        if (value.isNumber()) {
             lastType = "number";
             counter = value.data + 1;
         }
@@ -1696,13 +1894,9 @@ const TSEnumDeclaration = (c, scope, node) => {
         const name = member.id.type === "Identifier" ? member.id.name : member.id.value;
         data[name] = value;
     }
-    scope.set(new ValueOwner({
-        scope,
-        value: new ObjectValue(data),
-        constant: true,
-        identifier: node.id.name,
-        name: nodeName(node, !c.compactNames && node.id.name),
-    }));
+    const value = new ObjectValue(data);
+    value.name = nodeName(node, !c.compactNames && node.id.name);
+    scope.set(node.id.name, value);
     return [null, []];
 };
 const TSNonNullExpression = (c, scope, node) => {
@@ -1766,15 +1960,12 @@ class MacroFunction extends VoidValue {
         this.mutability = EMutability.constant;
         this.fn = fn;
     }
-    call(scope, args) {
-        return this.fn.apply(this, [scope, ...args]);
+    call(scope, args, out) {
+        return this.fn.apply(this, [scope, out, ...args]);
     }
     eval(_scope) {
         return [this, []];
     }
-    consume(_scope) {
-        return [this, []];
-    }
 }
 
 /* eslint-disable @typescript-eslint/no-non-null-assertion */
@@ -1798,49 +1989,39 @@ const mathOperations = {
     sqrt: a => Math.sqrt(a),
     rand: null,
 };
-function mathConstant(scope, name) {
-    return new ValueOwner({
-        scope,
-        constant: true,
-        name,
-        value: assign(new StoreValue(scope), {
-            mutability: EMutability.constant,
-        }),
-    }).value;
-}
-function createMacroMathOperations(scope) {
+function createMacroMathOperations() {
     const macroMathOperations = {
-        PI: mathConstant(scope, "@pi"),
-        E: mathConstant(scope, "@e"),
-        degToRad: mathConstant(scope, "@degToRad"),
-        radToDeg: mathConstant(scope, "@radToDeg"),
+        PI: new StoreValue("@pi", EMutability.constant),
+        E: new StoreValue("@e", EMutability.constant),
+        degToRad: new StoreValue("@degToRad", EMutability.constant),
+        radToDeg: new StoreValue("@radToDeg", EMutability.constant),
     };
     for (const key in mathOperations) {
         const fn = mathOperations[key];
-        macroMathOperations[key] = new MacroFunction((scope, a, b) => {
+        macroMathOperations[key] = new MacroFunction((scope, out, a, b) => {
             if (b) {
                 if (fn && a instanceof LiteralValue && b instanceof LiteralValue) {
-                    if (typeof a.data !== "number" || typeof b.data !== "number")
+                    if (!a.isNumber() || !b.isNumber())
                         throw new CompilerError("Cannot do math operation with non-numerical literals.");
                     return [new LiteralValue(fn(a.num, b.num)), []];
                 }
-                const temp = new StoreValue(scope);
+                const temp = StoreValue.from(scope, out);
                 return [temp, [new OperationInstruction(key, temp, a, b)]];
             }
             if (fn && a instanceof LiteralValue) {
-                if (typeof a.data !== "number")
+                if (!a.isNumber())
                     throw new CompilerError("Cannot do math operation with non-numerical literal.");
                 return [new LiteralValue(fn(a.num)), []];
             }
-            const temp = new StoreValue(scope);
+            const temp = StoreValue.from(scope, out);
             return [temp, [new OperationInstruction(key, temp, a, b)]];
         });
     }
     return macroMathOperations;
 }
 class MlogMath extends ObjectValue {
-    constructor(scope) {
-        super(createMacroMathOperations(scope));
+    constructor() {
+        super(createMacroMathOperations());
     }
 }
 // op angle result a b
@@ -1848,7 +2029,7 @@ class MlogMath extends ObjectValue {
 
 class Concat extends MacroFunction {
     constructor() {
-        super((scope, ...values) => {
+        super((scope, out, ...values) => {
             for (const value of values)
                 if (!(value instanceof LiteralValue))
                     throw new CompilerError("Concat arguments must all be literal values.");
@@ -1860,66 +2041,19 @@ class Concat extends MacroFunction {
     }
 }
 
-/** Asserts that `value` is a `LiteralValue` that contains a string */
-function assertStringLiteral(value, name) {
-    if (!(value instanceof LiteralValue) || typeof value.data !== "string")
-        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`*/
-function assertLiteralOneOf(value, members, name) {
-    assertStringLiteral(value, name);
-    if (!members.includes(value.data))
-        throw new CompilerError(`${name} must be one of: ${members
-            .slice(0, -1)
-            .map(member => `"${member}"`)
-            .join(", ")} or "${members[members.length - 1]}"`);
-}
-/** Asserts that `value` is either a store or a literal */
-function assertIsRuntimeValue(value, name) {
-    if (!(value instanceof LiteralValue) && !(value instanceof StoreValue))
-        throw new CompilerError(`${name} must be a valid runtime value`);
-}
-/** Asserts that `value` is an `ObjectValue` */
-function assertIsObjectMacro(value, name) {
-    if (!(value instanceof ObjectValue))
-        throw new CompilerError(`${name} must be an object macro`);
-}
-/** Asserts that `value` is an `ObjectValue` that has a length property */
-function assertIsArrayMacro(value, name) {
-    if (!(value instanceof ObjectValue) || !value.data.length)
-        throw new CompilerError(`${name} must be an array macro`);
-}
-/** Asserts that all of the fields described are present on `value`*/
-function assertObjectFields(value, fields) {
-    const result = [];
-    for (const field of fields) {
-        const param = typeof field === "object" ? field : { key: field };
-        const item = value.data[param.key];
-        if (item) {
-            param.validate?.(item);
-            result.push(item);
-            continue;
-        }
-        if (param.default == undefined)
-            throw new CompilerError(`The field "${param.name ?? param.key}" must be present`);
-        result.push(param.default);
-    }
-    return result;
-}
-
 /** Used to create namespaces that contain multiple methods that map into instructions */
 function createOverloadNamespace({ overloads, handler, }) {
     const result = {};
     for (const key in overloads) {
         const { named, args } = overloads[key];
         if (named) {
-            result[key] = new MacroFunction((scope, options) => {
+            result[key] = new MacroFunction((scope, out, options) => {
                 assertIsObjectMacro(options, named);
-                return handler(scope, key, ...assertObjectFields(options, args));
+                return handler(scope, key, out, ...assertObjectFields(options, args));
             });
             continue;
         }
-        result[key] = new MacroFunction((scope, ...params) => {
+        result[key] = new MacroFunction((scope, out, ...params) => {
             const handlerParams = [];
             // validate the paramters
             for (let i = 0; i < args.length; i++) {
@@ -1936,7 +2070,7 @@ function createOverloadNamespace({ overloads, handler, }) {
                 arg.validate?.(param);
                 handlerParams.push(param);
             }
-            return handler(scope, key, ...handlerParams);
+            return handler(scope, key, out, ...handlerParams);
         });
     }
     return result;
@@ -1981,7 +2115,7 @@ class Draw extends ObjectValue {
                     args: ["x", "y", "image", "size", "rotation"],
                 },
             },
-            handler(scope, overload, ...args) {
+            handler(scope, overload, out, ...args) {
                 return [null, [new InstructionBase("draw", overload, ...args)]];
             },
         });
@@ -1991,7 +2125,7 @@ class Draw extends ObjectValue {
 
 class Print extends MacroFunction {
     constructor() {
-        super((scope, ...values) => {
+        super((scope, out, ...values) => {
             const [first] = values;
             const inst = [];
             if (!isTemplateObjectArray(first)) {
@@ -2020,7 +2154,7 @@ class Print extends MacroFunction {
 const defaultTargetName$1 = "message1";
 class PrintFlush extends MacroFunction {
     constructor() {
-        super((scope, target) => {
+        super((scope, out, target) => {
             if (!target)
                 return [null, [new InstructionBase("printflush", defaultTargetName$1)]];
             if (!(target instanceof SenseableValue))
@@ -2033,7 +2167,7 @@ class PrintFlush extends MacroFunction {
 const defaultTargetName = "display1";
 class DrawFlush extends MacroFunction {
     constructor() {
-        super((scope, target) => {
+        super((scope, out, target) => {
             if (!target)
                 return [null, [new InstructionBase("drawflush", defaultTargetName)]];
             if (!(target instanceof SenseableValue))
@@ -2052,10 +2186,10 @@ class GetBlock extends ObjectValue {
                 block: { args: ["x", "y"] },
                 building: { args: ["x", "y"] },
             },
-            handler(scope, overload, x, y) {
+            handler(scope, overload, out, x, y) {
                 const output = overload === "building"
-                    ? new SenseableValue(scope)
-                    : new StoreValue(scope);
+                    ? SenseableValue.from(scope, out, EMutability.constant)
+                    : StoreValue.from(scope, out, EMutability.constant);
                 return [
                     output,
                     [new InstructionBase("getblock", overload, output, x, y)],
@@ -2068,11 +2202,11 @@ class GetBlock extends ObjectValue {
 
 class GetLink extends MacroFunction {
     constructor() {
-        super((scope, index) => {
+        super((scope, out, index) => {
             if (!(index instanceof StoreValue) &&
-                (!(index instanceof LiteralValue) || typeof index.data !== "number"))
+                (!(index instanceof LiteralValue) || !index.isNumber()))
                 throw new CompilerError("The getlink index must be a number literal or a store");
-            const outBuild = new SenseableValue(scope);
+            const outBuild = SenseableValue.from(scope, out, EMutability.constant);
             return [outBuild, [new InstructionBase("getlink", outBuild, index)]];
         });
     }
@@ -2094,11 +2228,10 @@ class Control extends ObjectValue {
                 config: { args: ["building", "value"] },
                 color: { args: ["building", "r", "g", "b"] },
             },
-            handler(scope, overload, ...args) {
+            handler(scope, overload, out, ...args) {
                 if (overload !== "color")
                     return [null, [new InstructionBase("control", overload, ...args)]];
-                const temp = new StoreValue(scope);
-                temp.ensureOwned();
+                const temp = StoreValue.from(scope);
                 // this "patch" is here for compatibility reasons
                 // I don't want to add another breaking change
                 // TODO: figure out if this patch should be removed later
@@ -2134,14 +2267,14 @@ const validRadarSorts = [
 ];
 class Radar extends MacroFunction {
     constructor() {
-        super((scope, options) => {
+        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");
             assertIsArrayMacro(filters, "filters");
             const { length } = filters.data;
-            if (!(length instanceof LiteralValue) || typeof length.data !== "number")
+            if (!(length instanceof LiteralValue) || !length.isNumber())
                 throw new CompilerError("The length of an array macro must be");
             if (length.data !== 3)
                 throw new CompilerError("The filters array must have 3 items");
@@ -2153,7 +2286,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 = new SenseableValue(scope);
+            const outUnit = SenseableValue.from(scope, out, EMutability.constant);
             return [
                 outUnit,
                 [
@@ -2166,14 +2299,12 @@ class Radar extends MacroFunction {
 
 class Sensor extends MacroFunction {
     constructor() {
-        super((scope, property, target) => {
+        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 = assign(new SenseableValue(scope), {
-                mutability: EMutability.readonly,
-            });
+            const temp = SenseableValue.from(scope, out, EMutability.readonly);
             return [temp, [new InstructionBase("sensor", temp, target, property)]];
         });
     }
@@ -2181,9 +2312,9 @@ class Sensor extends MacroFunction {
 
 class Wait extends MacroFunction {
     constructor() {
-        super((scope, seconds) => {
+        super((scope, out, seconds) => {
             if (!(seconds instanceof StoreValue) &&
-                !(seconds instanceof LiteralValue && typeof seconds.data === "number"))
+                !(seconds instanceof LiteralValue && seconds.isNumber()))
                 throw new CompilerError("The wait seconds must be either a number literal or a store");
             return [null, [new InstructionBase("wait", seconds)]];
         });
@@ -2199,8 +2330,8 @@ class Lookup extends ObjectValue {
                 item: { args: ["index"] },
                 liquid: { args: ["index"] },
             },
-            handler(scope, overload, index) {
-                const output = new StoreValue(scope);
+            handler(scope, overload, out, index) {
+                const output = StoreValue.from(scope, out);
                 return [
                     output,
                     [new InstructionBase("lookup", overload, output, index)],
@@ -2213,15 +2344,15 @@ class Lookup extends ObjectValue {
 
 class PackColor extends MacroFunction {
     constructor() {
-        super((scope, ...args) => {
+        super((scope, out, ...args) => {
             if (args.length !== 4) {
                 throw new CompilerError(`Expected 4 arguments, received ${args.length}`);
             }
             if (!args.every((value) => value instanceof StoreValue ||
-                (value instanceof LiteralValue && typeof value.data === "number"))) {
+                (value instanceof LiteralValue && value.isNumber()))) {
                 throw new CompilerError("packColor arguments must be either stores or number literals");
             }
-            const output = new StoreValue(scope);
+            const output = StoreValue.from(scope, out);
             return [output, [new InstructionBase("packcolor", output, ...args)]];
         });
     }
@@ -2244,7 +2375,7 @@ class SetBlock extends ObjectValue {
                     args: ["x", "y", "to", "team", { key: "rotation", default: "0" }],
                 },
             },
-            handler(scope, overload, x, y, to, team, rotation) {
+            handler(scope, overload, out, x, y, to, team, rotation) {
                 return [
                     null,
                     [
@@ -2259,14 +2390,14 @@ class SetBlock extends ObjectValue {
 
 class SpawnUnit extends MacroFunction {
     constructor() {
-        super((scope, options) => {
+        super((scope, out, options) => {
             assertIsObjectMacro(options, "The options");
             const { type, x, y, team, rotation } = options.data;
             assertIsRuntimeValue(type, "type");
             assertIsRuntimeValue(x, "x");
             assertIsRuntimeValue(y, "y");
             assertIsRuntimeValue(team, "team");
-            const output = new SenseableValue(scope);
+            const output = SenseableValue.from(scope, out, EMutability.constant);
             return [
                 output,
                 [
@@ -2285,7 +2416,7 @@ class Stop extends MacroFunction {
 
 class UnitBind extends MacroFunction {
     constructor() {
-        super((scope, type) => {
+        super((scope, out, type) => {
             if (!(type instanceof StoreValue))
                 throw new CompilerError("The unitBind type must be a store");
             return [null, [new InstructionBase("ubind", type)]];
@@ -2324,21 +2455,20 @@ class UnitControl extends ObjectValue {
                     args: ["x", "y", "radius"],
                 },
             },
-            handler(scope, overload, ...args) {
+            handler(scope, overload, out, ...args) {
                 let result = null;
                 let extraArgs = [];
                 switch (overload) {
                     case "getBlock": {
-                        const outType = new StoreValue(scope);
-                        const outBuilding = new SenseableValue(scope);
+                        const outType = StoreValue.from(scope, extractDestrucuringOut(out, 0));
+                        const outBuilding = SenseableValue.from(scope, extractDestrucuringOut(out, 1));
                         result = ObjectValue.fromArray([outType, outBuilding]);
                         extraArgs = [outType, outBuilding, new LiteralValue(0)];
                         break;
                     }
                     case "within": {
-                        const temp = new StoreValue(scope);
-                        result = temp;
-                        extraArgs = [temp, new LiteralValue(0)];
+                        result = StoreValue.from(scope, out);
+                        extraArgs = [result, new LiteralValue(0)];
                         break;
                     }
                 }
@@ -2354,12 +2484,12 @@ class UnitControl extends ObjectValue {
 
 class UnitRadar extends MacroFunction {
     constructor() {
-        super((scope, options) => {
+        super((scope, out, options) => {
             assertIsObjectMacro(options, "The radar options");
             const { filters, order, sort } = options.data;
             assertIsArrayMacro(filters, "filters");
             const { length } = filters.data;
-            if (!(length instanceof LiteralValue) || typeof length.data !== "number")
+            if (!(length instanceof LiteralValue) || !length.isNumber())
                 throw new CompilerError("The length of an array macro must be");
             if (length.data !== 3)
                 throw new CompilerError("The filters array must have 3 items");
@@ -2371,7 +2501,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 = new SenseableValue(scope);
+            const outUnit = SenseableValue.from(scope, out, EMutability.constant);
             return [
                 outUnit,
                 [
@@ -2409,11 +2539,11 @@ class UnitLocate extends ObjectValue {
                     args: [],
                 },
             },
-            handler(scope, overload, ...args) {
-                const outFound = new StoreValue(scope);
-                const outX = new StoreValue(scope);
-                const outY = new StoreValue(scope);
-                const outBuilding = new SenseableValue(scope);
+            handler(scope, overload, out, ...args) {
+                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 outArgs = [outX, outY, outFound, outBuilding];
                 let inputArgs = [];
                 switch (overload) {
@@ -2476,7 +2606,7 @@ class ApplyStatus extends ObjectValue {
                 },
                 clear: { args: ["status", "unit"] },
             },
-            handler(scope, overload, effect, unit, duration) {
+            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");
@@ -2494,7 +2624,7 @@ class ApplyStatus extends ObjectValue {
 
 class SpawnWave extends MacroFunction {
     constructor() {
-        super((scope, natural, x, y) => {
+        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");
@@ -2535,7 +2665,7 @@ class SetRule extends ObjectValue {
                 rtsMinWeight: { args: ["team", "value"] },
                 rtsMinSquad: { args: ["team", "value"] },
             },
-            handler(scope, overload, ...args) {
+            handler(scope, overload, out, ...args) {
                 const params = ["10", "0", "0", "100", "100"];
                 switch (overload) {
                     case "mapArea": {
@@ -2578,7 +2708,7 @@ class FlushMessage extends ObjectValue {
                 announce: { args: ["duration"] },
                 toast: { args: ["duration"] },
             },
-            handler(scope, overload, duration) {
+            handler(scope, overload, out, duration) {
                 return [null, [new InstructionBase("message", overload, duration)]];
             },
         });
@@ -2594,7 +2724,7 @@ class Cutscene extends ObjectValue {
                 zoom: { args: ["level"] },
                 stop: { args: [] },
             },
-            handler(scope, overload, ...args) {
+            handler(scope, overload, out, ...args) {
                 const params = Object.assign(["100", "100", "0.06", "0"], args);
                 return [null, [new InstructionBase("cutscene", overload, ...params)]];
             },
@@ -2605,7 +2735,7 @@ class Cutscene extends ObjectValue {
 
 class Explosion extends MacroFunction {
     constructor() {
-        super((scope, options) => {
+        super((scope, out, options) => {
             assertIsObjectMacro(options, "The options");
             const params = assertObjectFields(options, [
                 "team",
@@ -2624,7 +2754,7 @@ class Explosion extends MacroFunction {
 
 class SetRate extends MacroFunction {
     constructor() {
-        super((scope, ipt) => [null, [new InstructionBase("setrate", ipt)]]);
+        super((scope, out, ipt) => [null, [new InstructionBase("setrate", ipt)]]);
     }
 }
 
@@ -2641,8 +2771,8 @@ class Fetch extends ObjectValue {
                 build: { args: ["team", "index", "block"] },
                 buildCount: { args: ["team", "block"] },
             },
-            handler(scope, overload, team, ...rest) {
-                const output = new SenseableValue(scope);
+            handler(scope, overload, out, team, ...rest) {
+                const output = SenseableValue.from(scope, out, EMutability.constant);
                 const params = ["0", "@conveyor"];
                 if (overload === "buildCount") {
                     params[1] = rest[0];
@@ -2662,8 +2792,8 @@ class Fetch extends ObjectValue {
 
 class GetFlag extends MacroFunction {
     constructor() {
-        super((scope, flag) => {
-            const result = new StoreValue(scope);
+        super((scope, out, flag) => {
+            const result = StoreValue.from(scope, out);
             return [result, [new InstructionBase("getflag", result, flag)]];
         });
     }
@@ -2671,7 +2801,7 @@ class GetFlag extends MacroFunction {
 
 class SetFlag extends MacroFunction {
     constructor() {
-        super((scope, flag, value) => {
+        super((scope, out, flag, value) => {
             if (!flag)
                 throw new CompilerError("Missing flag argument");
             if (!value)
@@ -2690,28 +2820,17 @@ class MemoryEntry extends BaseValue {
         this.macro = true;
         this.store = null;
     }
-    eval(scope) {
+    eval(scope, out) {
         if (this.store)
             return [this.store, []];
-        const temp = new StoreValue(scope);
+        const temp = (this.store = StoreValue.from(scope, out));
         return [
             temp,
             [new InstructionBase("read", temp, this.mem.cell, this.prop)],
         ];
     }
-    consume(scope) {
-        if (this.store)
-            return [this.store, []];
-        this.ensureOwned();
-        this.store = new StoreValue(scope);
-        this.owner.own(this.store);
-        return [
-            this.store,
-            [new InstructionBase("read", this.store, this.mem.cell, this.prop)],
-        ];
-    }
     "="(scope, value) {
-        const [data, dataInst] = value.consume(scope);
+        const [data, dataInst] = value.eval(scope);
         return [
             data,
             [
@@ -2720,26 +2839,17 @@ class MemoryEntry extends BaseValue {
             ],
         ];
     }
-    ensureOwned() {
-        this.owner ??= new ValueOwner({ scope: this.scope, value: this });
-    }
-}
-for (const operator of operators) {
-    if (operator === "=")
-        continue;
-    MemoryEntry.prototype[operator] = function (...args) {
-        // eslint-disable-next-line @typescript-eslint/ban-types, @typescript-eslint/no-unsafe-return
-        return BaseValue.prototype[operator].apply(this, args);
-    };
 }
 class MemoryMacro extends ObjectValue {
     constructor(cell, size) {
         super({
-            $get: new MacroFunction((scope, prop) => {
-                if (prop instanceof LiteralValue && typeof prop.data !== "number")
+            $get: new MacroFunction((scope, out, prop) => {
+                if (prop instanceof LiteralValue && !prop.isNumber())
                     throw new CompilerError(`Invalid memory object property: "${prop.data}"`);
-                const obj = new MemoryEntry(scope, this, prop);
-                return [obj, []];
+                const entry = new MemoryEntry(scope, this, prop);
+                if (out)
+                    return entry.eval(scope, out);
+                return [entry, []];
             }),
             length: size,
             size,
@@ -2753,10 +2863,10 @@ class MemoryMacro extends ObjectValue {
 class MemoryBuilder extends ObjectValue {
     constructor() {
         super({
-            $call: new MacroFunction((scope, cell, size = new LiteralValue(64)) => {
+            $call: new MacroFunction((scope, out, cell, size = new LiteralValue(64)) => {
                 if (!(cell instanceof SenseableValue))
                     throw new CompilerError("Memory cell must be a senseable value.");
-                if (!(size instanceof LiteralValue && typeof size.data === "number"))
+                if (!(size instanceof LiteralValue && size.isNumber()))
                     throw new CompilerError("The memory size must be a number literal.");
                 return [new MemoryMacro(cell, size), []];
             }),
@@ -2768,8 +2878,8 @@ const dynamicVars = ["time", "tick"];
 class NamespaceMacro extends ObjectValue {
     constructor({ changeCasing = false } = {}) {
         super({
-            $get: new MacroFunction((scope, prop) => {
-                if (!(prop instanceof LiteralValue) || typeof prop.data !== "string")
+            $get: new MacroFunction((scope, out, prop) => {
+                if (!(prop instanceof LiteralValue) || !prop.isString())
                     throw new CompilerError("Cannot use dynamic properties on namespace macros");
                 const symbolName = this.changeCasing
                     ? camelToDashCase(prop.data)
@@ -2777,57 +2887,37 @@ class NamespaceMacro extends ObjectValue {
                 const mutability = dynamicVars.includes(symbolName)
                     ? EMutability.readonly
                     : EMutability.constant;
-                const owner = new ValueOwner({
-                    scope,
-                    value: assign(new StoreValue(scope), {
-                        mutability,
-                    }),
-                    name: `@${symbolName}`,
-                });
-                return [owner.value, []];
+                const result = new StoreValue(`@${symbolName}`, mutability);
+                return [result, []];
             }),
         });
         this.changeCasing = changeCasing;
     }
 }
 class VarsNamespace extends NamespaceMacro {
-    constructor(scope) {
+    constructor() {
         super();
         Object.assign(this.data, {
-            unit: new ValueOwner({
-                scope,
-                name: "@unit",
-                value: new SenseableValue(scope),
-            }).value,
-            this: new ValueOwner({
-                scope,
-                name: "@this",
-                value: new SenseableValue(scope),
-            }).value,
+            unit: new SenseableValue("@unit"),
+            this: new SenseableValue("@this"),
         });
     }
 }
 
 class GetGlobal extends MacroFunction {
     constructor(mutability) {
-        super((scope, name) => {
-            if (!(name instanceof LiteralValue) || typeof name.data !== "string")
+        super((scope, out, name) => {
+            if (!(name instanceof LiteralValue) || !name.isString())
                 throw new CompilerError("The name parameter must be a string literal.");
-            const owner = new ValueOwner({
-                scope,
-                name: name.data,
-                value: assign(new SenseableValue(scope), {
-                    mutability,
-                }),
-            });
-            return [owner.value, []];
+            const result = new SenseableValue(name.data, mutability);
+            return [result, []];
         });
     }
 }
 
 class Asm extends MacroFunction {
     constructor() {
-        super((scope, stringsArray, ...values) => {
+        super((scope, out, stringsArray, ...values) => {
             if (!isTemplateObjectArray(stringsArray))
                 throw new CompilerError("Expected to receive a template strings array");
             const args = [];
@@ -2905,7 +2995,7 @@ function validateInstructionArgs(args) {
 function initScope(scope) {
     // namespaces
     scope.hardSet("ControlKind", new NamespaceMacro());
-    scope.hardSet("Vars", new VarsNamespace(scope));
+    scope.hardSet("Vars", new VarsNamespace());
     scope.hardSet("Teams", new NamespaceMacro());
     scope.hardSet("Items", new NamespaceMacro({ changeCasing: true }));
     scope.hardSet("Liquids", new NamespaceMacro());
@@ -2917,7 +3007,7 @@ function initScope(scope) {
     scope.hardSet("getVar", new GetGlobal(EMutability.mutable));
     scope.hardSet("concat", new Concat());
     scope.hardSet("asm", new Asm());
-    scope.hardSet("Math", new MlogMath(scope));
+    scope.hardSet("Math", new MlogMath());
     scope.hardSet("Memory", new MemoryBuilder());
     // commands
     scope.hardSet("draw", new Draw());
@@ -3009,11 +3099,11 @@ class Compiler {
         }
         return result;
     }
-    handle(scope, node, handler = this.handlers[node.type]) {
+    handle(scope, node, handler = this.handlers[node.type], out) {
         try {
             if (!handler)
                 throw new CompilerError("Missing handler for " + node.type);
-            const result = handler(this, scope, node, null);
+            const result = handler(this, scope, node, out, null);
             if (this.sourcemap)
                 return appendSourceLocations(result, node);
             return result;
@@ -3025,21 +3115,11 @@ class Compiler {
             throw error;
         }
     }
-    handleEval(scope, node) {
-        const [res, inst] = this.handle(scope, node);
+    handleEval(scope, node, out) {
+        const [res, inst] = this.handle(scope, node, undefined, out);
         if (!res)
             throw new CompilerError("Cannot eval null", node);
-        const [evaluated, evaluatedInst] = res.eval(scope);
-        const result = [evaluated, [...inst, ...evaluatedInst]];
-        if (this.sourcemap)
-            return appendSourceLocations(result, node);
-        return result;
-    }
-    handleConsume(scope, node) {
-        const [res, inst] = this.handle(scope, node);
-        if (!res)
-            throw new CompilerError("Cannot consume null", node);
-        const [evaluated, evaluatedInst] = res.consume(scope);
+        const [evaluated, evaluatedInst] = res.eval(scope, out);
         const result = [evaluated, [...inst, ...evaluatedInst]];
         if (this.sourcemap)
             return appendSourceLocations(result, node);
@@ -3051,7 +3131,7 @@ class Compiler {
      * 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}, {@link handleConsume}
+     * handler methods ({@link handle}, {@link handleEval}
      * and {@link handleMany})
      *
      */
@@ -3064,30 +3144,6 @@ class Compiler {
         return [null, lines];
     }
 }
-/** Removes jump instructions that point right to the next line */
-function hideRedundantJumps(inst) {
-    for (let i = 0; i < inst.length; i++) {
-        const instruction = inst[i];
-        if (!(instruction instanceof JumpInstruction))
-            continue;
-        const { address } = instruction;
-        let searchIndex = i + 1;
-        let current = inst[searchIndex];
-        while (current.hidden) {
-            if (current instanceof AddressResolver &&
-                current.bonds.includes(address)) {
-                // only gets assigned if `current` is an adress resolver
-                // that resolves the jump adress
-                // and that is also right next to the jump,
-                // without any actual instructions in between
-                instruction.hidden = true;
-                break;
-            }
-            searchIndex++;
-            current = inst[searchIndex];
-        }
-    }
-}
 function* hoistedFunctionNodes(nodes) {
     // sorting is O(n long n) while this is just O(n)
     // besides, it's better not to modify the node array