sandstone 1.0.0-beta.2 → 1.0.0-beta.3

package/dist/arguments/index.js

@@ -154,17 +154,15 @@ function randomUUID() {
   }
   return array;
 }
-function add(object) {
-  if (object === undefined) {
-    return {};
-  }
-  const output = {};
-  for (const [key, value] of object.entries()) {
+function add(obj) {
+  const filtered = {};
+  for (const key of Object.keys(obj)) {
+    const value = obj[key];
     if (value !== undefined) {
-      output[key] = value;
+      filtered[key] = value;
     }
   }
-  return output;
+  return filtered;
 }
 async function safeWrite(...args) {
   if (typeof args[0] !== "string")
@@ -182,6 +180,14 @@ function formatDebugString(className, args, body, currentIndent) {
     argsString = args;
   } else if (Array.isArray(args)) {
     argsString = args.map((arg) => util.inspect(arg, options)).join(", ");
+    if (argsString.includes(`
+`)) {
+      argsString = `
+${nextIndent}${args.map((arg) => util.inspect(arg, options).replaceAll(`
+`, `
+${nextIndent}`)).join(`,
+${nextIndent}`)}`;
+    }
   } else if (args && typeof args === "object") {
     argsString = Object.entries(args).map(([key, value]) => `${key}: ${util.inspect(value, options)}`).join(", ");
   } else {
@@ -294,7 +300,17 @@ class MacroArgument {
       try {
         currentMCFunctionName = sandstoneCore.getCurrentMCFunctionOrThrow().resource.name;
       } catch {}
-      return `$(${this.local.get(this.sandstoneCore.currentNode) || this.local.get(currentMCFunctionName)})`;
+      let result = this.local.get(this.sandstoneCore.currentNode) || this.local.get(currentMCFunctionName);
+      if (!result) {
+        let path = this.sandstoneCore.currentNode;
+        while (path.includes("/")) {
+          path = path.substring(0, path.lastIndexOf("/"));
+          result = this.local.get(path);
+          if (result)
+            break;
+        }
+      }
+      return `$(${result})`;
     };
   }
 }
@@ -334,6 +350,9 @@ var init_Macro = __esm(() => {
               result += `${macro}`;
             } else {
               result += macro.toMacro();
+              if (result.endsWith("}")) {
+                console.warn("what", macro);
+              }
             }
           }
         }
@@ -797,14 +816,14 @@ var init_damage = __esm(() => {
     from = (cause) => this.finalCommand(["from", targetParser(cause)]);
   };
   DamageSourceCommand = class DamageSourceCommand extends CommandArguments {
-    by = (entity) => this.subCommand(["by", targetParser(entity)], DamageCauseCommand);
+    by = (entity) => this.subCommand(["by", targetParser(entity)], DamageCauseCommand, true);
     at = (position) => this.finalCommand(["at", coordinatesParser(position)]);
   };
   DamageCommand = class DamageCommand extends CommandArguments {
     NodeType = DamageCommandNode;
     damage = (target, amount, damageType) => {
       validateIntegerRange(amount, "amount", 0, 1e6);
-      return this.subCommand([targetParser(target), amount, damageType], DamageSourceCommand);
+      return this.subCommand([targetParser(target), amount, damageType], DamageSourceCommand, true);
     };
   };
 });
@@ -1484,7 +1503,7 @@ function dynamicNBT(template, ...args) {
   const result = mixedArgs.map((element) => element instanceof NBTClass ? nbtStringifier(element) : element.toString()).join("");
   return parseNBT(NBT, result);
 }
-var N_B_T_CLASS_BRAND, NBTClass, N_B_T_PRIMITIVE_BRAND, NBTPrimitive, NBTLong, NBTByte, NBTShort, NBTFloat, NBTInt, NBTDouble, N_B_T_TYPED_ARRAY_BRAND, NBTTypedArray, NBTLongArray, NBTByteArray, NBTIntArray, NotNBT, NBTAnyValue, NBT, nbtStringifier = (nbt) => {
+var N_B_T_CLASS_BRAND, NBTClass, N_B_T_PRIMITIVE_BRAND, NBTPrimitive, NBTLong, NBTByte, NBTShort, NBTFloat, NBTInt, NBTDouble, NBTTypedArray, NBTLongArray, NBTByteArray, NBTIntArray, NotNBT, NBTAnyValue, NBT, nbtStringifier = (nbt) => {
   if (nbt === null || nbt === undefined) {
     throw new Error("Nullish nbt values are not allowed");
   }
@@ -1562,6 +1581,9 @@ var init_NBTs = __esm(() => {
       this.value = value;
       this.unit = unit;
     }
+    toJSON() {
+      return this.value;
+    }
     [util3.inspect.custom] = () => `${this.value}${this.unit}`;
     static [Symbol.hasInstance](instance) {
       return (typeof instance === "object" || typeof instance === "function") && instance !== null && instance[N_B_T_PRIMITIVE_BRAND] === true;
@@ -1597,9 +1619,7 @@ var init_NBTs = __esm(() => {
       super(value, "d");
     }
   };
-  N_B_T_TYPED_ARRAY_BRAND = Symbol.for("sandstone.NBTTypedArray");
   NBTTypedArray = class NBTTypedArray extends NBTClass {
-    [N_B_T_TYPED_ARRAY_BRAND] = true;
     values;
     unit;
     constructor(values, unit) {
@@ -1607,10 +1627,10 @@ var init_NBTs = __esm(() => {
       this.values = values;
       this.unit = unit;
     }
-    [util3.inspect.custom] = () => `[${this.unit};${this.values.length === 0 ? "" : this.values.join(",")}]`;
-    static [Symbol.hasInstance](instance) {
-      return (typeof instance === "object" || typeof instance === "function") && instance !== null && instance[N_B_T_TYPED_ARRAY_BRAND] === true;
+    toJSON() {
+      return this.values;
     }
+    [util3.inspect.custom] = () => `[${this.unit};${this.values.length === 0 ? "" : this.values.join(",")}]`;
   };
   NBTLongArray = class NBTLongArray extends NBTTypedArray {
     constructor(values) {
@@ -1714,6 +1734,9 @@ var init_Score = __esm(() => {
     ]));
     unaryOperation(operation, operator, ...args) {
       if (typeof args[0] === "number") {
+        if (args[0] < 0 && operation !== "set") {
+          return this.binaryOperation(operator, args[0]);
+        }
         this.commands.scoreboard.players[operation](this, args[0]);
       } else if (args[0] instanceof Score) {
         this.commands.scoreboard.players.operation(this, operator, args[0].target, args[0].objective);
@@ -1730,7 +1753,7 @@ var init_Score = __esm(() => {
       let objective = args[1] ?? this.objective;
       if (typeof args[0] === "number") {
         this.sandstonePack.registerNewConstant(args[0]);
-        objective = "sandstone_const";
+        objective = "__sandstone";
       }
       this.commands.scoreboard.players.operation(this, operator, args[0], objective);
       return this;
@@ -1886,7 +1909,99 @@ Warning: Score.match() will have to create ${maximum - minimum} mcfunction files
       }
       return MCFunction(`__sandstone:score_match/${matcher}`, [score], () => Macro.returnCmd.run.functionCmd(Macro`__sandstone:score_match/${matcher}/${score}`));
     };
-    [util4.inspect.custom](depth, options) {
+    getDecomposer(size, splitsOrCount, componentCount = 31, includeSign = true) {
+      if (typeof this.target !== "string" || this.target.search(/-|@/) !== -1) {
+        throw new Error("[Score#getDecomposer] Must use a fake-player Score for decomposition.");
+      }
+      const { MCFunction, _, commands } = this.sandstonePack;
+      const { execute, returnCmd } = commands;
+      const newScore = this.objective.ScoreHolder;
+      const components = [];
+      const sign = includeSign ? newScore(`${this.target}._32`) : undefined;
+      let decompose;
+      if (size === "bit" || size === undefined) {
+        for (let i = 1;i <= componentCount; i++) {
+          components.push(newScore(`${this.target}._${i}`));
+        }
+        decompose = MCFunction(`__sandstone:score/decompose_bits/${componentCount}_${splitsOrCount === undefined ? 0 : splitsOrCount.size}/${this.target.replaceAll(".", "/").toLowerCase()}`, () => {
+          const resetBits = execute.store.result(components[0]);
+          for (const component of components.slice(1, -1)) {
+            resetBits.store.result(component);
+            resetBits.nestedExecute(["\\\n "], false);
+          }
+          if (includeSign) {
+            resetBits.store.result(components.at(-1));
+            resetBits.nestedExecute(["\\\n "], false);
+            resetBits.run(() => sign["="](0));
+          } else {
+            resetBits.run(() => components.at(-1)["="](0));
+          }
+          const input = newScore(`${this.target}._bf_iterator`);
+          const splits = splitsOrCount ?? new Set;
+          const bitExecute = (bit) => execute.store.success(components[bit - 1]);
+          input["="](this);
+          _.if(this["=="](0), () => {
+            returnCmd(1);
+          });
+          if (includeSign) {
+            execute.store.success(sign).if.score(input, "matches", [null, -1]).run(() => {
+              input["*="](-1);
+            });
+          }
+          input.decomposeBits(splits, componentCount, bitExecute);
+        }, {
+          creator: "sandstone",
+          onConflict: "rename",
+          addToSandstoneCore: true
+        });
+      } else {
+        throw new Error("[Score#getDecomposer(byte)] Byte decomposition is not yet supported");
+      }
+      const result = {
+        components,
+        ...add({ sign })
+      };
+      return {
+        ...result,
+        decompose: () => {
+          decompose();
+          return result;
+        }
+      };
+    }
+    decomposeBits(splits, componentCount, bitExecute, extra) {
+      const { _ } = this.sandstonePack;
+      const sortedSplits = [...splits].filter((s) => s > 0 && s < componentCount).sort((a, b) => b - a);
+      const boundaries = [componentCount, ...sortedSplits, 0];
+      const processRange = (high, low) => {
+        let halvedAgain = 2 ** high;
+        for (let bit = high;bit >= low; bit--) {
+          halvedAgain /= 2;
+          bitExecute(bit, halvedAgain).if.score(this, "matches", [halvedAgain, null]).run(() => {
+            this["-="](halvedAgain);
+            extra?.(bit, halvedAgain);
+          });
+        }
+      };
+      const buildNested = (rangeIndex) => {
+        const high = boundaries[rangeIndex];
+        const low = boundaries[rangeIndex + 1] + 1;
+        if (rangeIndex > 0) {
+          const higherMinValue = 2 ** boundaries[rangeIndex];
+          _.if(this.matches([higherMinValue, null]), () => {
+            buildNested(rangeIndex - 1);
+          });
+        }
+        processRange(high, low);
+      };
+      if (splits.size === 0) {
+        processRange(componentCount, 1);
+      } else {
+        const lowestRangeIndex = boundaries.length - 2;
+        buildNested(lowestRangeIndex);
+      }
+    }
+    [util4.inspect.custom](_depth, options) {
       return formatDebugString(this.constructor.name, {
         target: this.target,
         display: this.display,
@@ -1946,7 +2061,9 @@ class TargetlessDataClass {
     this.sandstonePack = sandstonePack;
     this.type = type;
   }
-  target = (target) => new DataClass(this.sandstonePack, this.type, target);
+  target = (target) => {
+    return new DataClass(this.sandstonePack, this.type, target);
+  };
   select = (...path) => new TargetlessDataPointClass(this.sandstonePack, this.type, path);
 }
 
@@ -1959,7 +2076,9 @@ class TargetlessDataPointClass {
     this.type = type;
     this.path = NBTpathToString(sandstonePack, path);
   }
-  target = (target) => new DataPointClass(this.sandstonePack, this.type, target, [this.path]);
+  target = (target) => {
+    return new DataPointClass(this.sandstonePack, this.type, target, [this.path]);
+  };
   select = (...path) => new TargetlessDataPointClass(this.sandstonePack, this.type, [this.path, ...path]);
 }
 
@@ -2047,7 +2166,9 @@ var init_Data = __esm(() => {
     append = (value) => this.modify((data) => data.append, value);
     prepend = (value) => this.modify((data) => data.prepend, value);
     insert = (value, index) => this.modify((data) => data.insert(index), value);
-    remove = () => this.sandstonePack.commands.data.remove[this.type](this.currentTarget, this.path);
+    remove = () => {
+      return this.sandstonePack.commands.data.remove[this.type](this.currentTarget, this.path);
+    };
     slice = (start, end) => new StringDataPointClass(this.sandstonePack, this.type, this.currentTarget, this.path, start, end);
     _toMinecraftCondition = () => new this.sandstonePack.conditions.DataPointExists(this.sandstonePack.core, this);
     equals = (value) => new this.sandstonePack.conditions.DataPointEquals(this.sandstonePack.core, this, value);
@@ -2093,20 +2214,16 @@ function hasContext() {
 var _context;
 
 // src/core/resources/resource.ts
-function jsonStringify(json) {
-  return JSON.stringify(json, (_key, value) => {
-    if (value instanceof NBTPrimitive) {
-      return value.value;
-    }
-    if (value instanceof NBTTypedArray) {
-      return value.values;
+function jsonStringify(json, resourceType) {
+  return JSON.stringify(json, function(key, value) {
+    if ((typeof value === "object" || typeof value === "function") && value.constructor.name !== "Object" && "toResourceJSON" in value) {
+      return value.toResourceJSON(key, this, resourceType, json);
     }
     return value;
   }, 2);
 }
 var RESOURCE_CLASS_BRAND, ResourceClass, CallableResourceClass, ResourceNodesMap;
 var init_resource = __esm(() => {
-  init_NBTs();
   init_arguments();
   RESOURCE_CLASS_BRAND = Symbol.for("sandstone.ResourceClass");
   ResourceClass = class ResourceClass {
@@ -2210,6 +2327,9 @@ var init_resource = __esm(() => {
     toNBT() {
       return this.name;
     }
+    toJSON() {
+      return this.name;
+    }
     static [Symbol.hasInstance](instance) {
       return (typeof instance === "object" || typeof instance === "function") && instance !== null && instance[RESOURCE_CLASS_BRAND] === true;
     }
@@ -2272,7 +2392,7 @@ function isTagClass(v) {
 }
 function objectToString(value) {
   if (isMCFunctionClass(value)) {
-    if (value.node.resource.env) {
+    if (value.env && value.callback.length < 2) {
       return value.node.sandstoneCore.pack.MCFunction(`${value.name}/_env`, () => value(), {
         creator: "sandstone",
         onConflict: "rename"
@@ -2288,7 +2408,7 @@ function objectToString(value) {
   }
   if (typeof value === "object") {
     if (isMCFunctionClass(value.id)) {
-      if (value.id.node.resource.env) {
+      if (value.id.env && value.id.callback.length < 2) {
         return {
           id: value.id.node.sandstoneCore.pack.MCFunction(`${value.id.name}/_env`, () => value.id(), { creator: "sandstone", onConflict: "rename" }).name,
           required: value.required
@@ -2322,7 +2442,7 @@ var init_tag = __esm(() => {
       super(sandstoneCore);
       this.resource = resource;
     }
-    getValue = () => jsonStringify(this.resource.tagJSON);
+    getValue = () => jsonStringify(this.resource.tagJSON, this.resource._resourceType);
   };
   TAG_CLASS_BRAND = Symbol.for("sandstone.TagClass");
   TagClass = class TagClass extends ResourceClass {
@@ -2415,7 +2535,7 @@ var init_model = __esm(() => {
       super(sandstoneCore);
       this.resource = resource;
     }
-    getValue = () => jsonStringify(this.resource.modelJSON);
+    getValue = () => jsonStringify(this.resource.modelJSON, this.resource._resourceType);
   };
   MODEL_CLASS_BRAND = Symbol.for("sandstone.ModelClass");
   ModelClass = class ModelClass extends ResourceClass {
@@ -2619,7 +2739,7 @@ var init_itemDefinition = __esm(() => {
       super(sandstoneCore);
       this.resource = resource;
     }
-    getValue = () => jsonStringify(this.resource.itemDefinitionJSON);
+    getValue = () => jsonStringify(this.resource.itemDefinitionJSON, this.resource._resourceType);
   };
   ItemModelDefinitionClass = class ItemModelDefinitionClass extends ResourceClass {
     static resourceType = "item_definition";
@@ -2787,7 +2907,12 @@ var init_DataSets = __esm(() => {
   init_Data();
   init_Score();
   IterableDataClass = class IterableDataClass extends ConditionalDataPointPickClass {
-    iterator(_callback) {
+    iteratorType;
+    constructor(sandstoneCore, iteratorType) {
+      super(sandstoneCore);
+      this.iteratorType = iteratorType;
+    }
+    iterator(_callback, _direction = "normal") {
       throw new Error("Not implemented");
     }
     size() {
@@ -2796,24 +2921,30 @@ var init_DataSets = __esm(() => {
     last() {
       throw new Error("Not implemented");
     }
-    get continue() {
+    continue(direction = "normal") {
       throw new Error("Not implemented");
     }
   };
   DataIndexMapClass = class DataIndexMapClass extends IterableDataClass {
     pack;
-    initialize;
     entries = {};
     dataPoint;
     constructor(pack, initialize, dataPoint) {
-      super(pack.core);
+      super(pack.core, "map");
       this.pack = pack;
-      this.initialize = initialize;
       if (dataPoint) {
         this.dataPoint = dataPoint;
       } else {
         this.dataPoint = this.pack.DataVariable(undefined, "IndexMap");
       }
+      if (pack.core.currentMCFunction) {
+        this.init(initialize);
+      } else {
+        const init = this.init;
+        pack.initMCFunction.push(() => init(initialize));
+      }
+    }
+    init(initialize) {
       for (const [i, [key, value]] of Object.entries(initialize).entries()) {
         this.dataPoint.select("Index").select(key).set(i);
         this.dataPoint.select("Entries").append([]);
@@ -2824,21 +2955,22 @@ var init_DataSets = __esm(() => {
       }
     }
     __entryIterator;
-    get entryIterator() {
+    entryIterator(direction) {
       if (!this.__entryIterator) {
-        this.__entryIterator = this.pack.DataVariable(this.dataPoint.select("Entries")).select("[-1]");
+        this.__entryIterator = this.pack.DataVariable(this.dataPoint.select("Entries")).select(`[${direction === "normal" ? 0 : -1}]`);
       }
       return this.__entryIterator;
     }
-    iterator(callback) {
+    iterator(callback, direction = "normal") {
       this.__entryIterator = undefined;
+      const entryIterator = this.entryIterator(direction);
       return () => {
-        callback([this.entryIterator.select("[0]").slice(0), this.entryIterator.select("[1]")]);
-        this.entryIterator.remove();
+        callback([entryIterator.select("[0]").slice(0), entryIterator.select("[1]")]);
+        entryIterator.remove();
       };
     }
-    get continue() {
-      return this.entryIterator._toMinecraftCondition();
+    continue(direction = "normal") {
+      return this.entryIterator(direction)._toMinecraftCondition();
     }
     size = () => this.dataPoint.select("Entries");
     last = () => [this.dataPoint.select("Entries[-1][0]").slice(0), this.dataPoint.select("Entries[-1][1]")];
@@ -2947,33 +3079,42 @@ var init_DataSets = __esm(() => {
     pack;
     dataPoint;
     constructor(pack, initialize, dataPoint) {
-      super(pack.core);
+      super(pack.core, "list");
       this.pack = pack;
       if (dataPoint) {
         this.dataPoint = dataPoint;
       } else {
         this.dataPoint = this.pack.DataVariable([], "Array");
       }
+      if (pack.core.currentMCFunction) {
+        this.init(initialize);
+      } else {
+        const init = this.init;
+        pack.initMCFunction.push(() => init(initialize));
+      }
+    }
+    init(initialize) {
       for (const entry of initialize) {
         this.dataPoint.append(entry);
       }
     }
     __entryIterator;
-    get entryIterator() {
+    entryIterator(direction) {
       if (!this.__entryIterator) {
-        this.__entryIterator = this.pack.DataVariable(this.dataPoint).select("[-1]");
+        this.__entryIterator = this.pack.DataVariable(this.dataPoint).select(`[${direction === "normal" ? 0 : -1}]`);
       }
       return this.__entryIterator;
     }
-    iterator(callback) {
+    iterator(callback, direction = "normal") {
       this.__entryIterator = undefined;
+      const entryIterator = this.entryIterator(direction);
       return () => {
-        callback([this.entryIterator]);
-        this.entryIterator.remove();
+        callback([entryIterator]);
+        entryIterator.remove();
       };
     }
-    get continue() {
-      return this.entryIterator._toMinecraftCondition();
+    continue(direction = "normal") {
+      return this.entryIterator(direction)._toMinecraftCondition();
     }
     size = () => this.dataPoint;
     last = () => this.dataPoint.select("[-1]");
@@ -3081,7 +3222,7 @@ var init_advancement = __esm(() => {
       super(sandstoneCore);
       this.resource = resource;
     }
-    getValue = () => jsonStringify(this.resource.advancementJSON);
+    getValue = () => jsonStringify(this.resource.advancementJSON, this.resource._resourceType);
   };
   ADVANCEMENT_CLASS_BRAND = Symbol.for("sandstone.AdvancementClass");
   AdvancementClass = class AdvancementClass extends ResourceClass {
@@ -3139,7 +3280,7 @@ var init_bannerPattern = __esm(() => {
       super(sandstoneCore);
       this.resource = resource;
     }
-    getValue = () => jsonStringify(this.resource.bannerPatternJSON);
+    getValue = () => jsonStringify(this.resource.bannerPatternJSON, this.resource._resourceType);
   };
   BannerPatternClass = class BannerPatternClass extends ResourceClass {
     static resourceType = "banner_pattern";
@@ -3164,7 +3305,7 @@ var init_chatType = __esm(() => {
       super(sandstoneCore);
       this.resource = resource;
     }
-    getValue = () => jsonStringify(this.resource.chatTypeJSON);
+    getValue = () => jsonStringify(this.resource.chatTypeJSON, this.resource._resourceType);
   };
   ChatTypeClass = class ChatTypeClass extends ResourceClass {
     static resourceType = "chat_type";
@@ -3190,7 +3331,7 @@ var init_damageType = __esm(() => {
       super(sandstoneCore);
       this.resource = resource;
     }
-    getValue = () => jsonStringify(this.resource.damageTypeJSON);
+    getValue = () => jsonStringify(this.resource.damageTypeJSON, this.resource._resourceType);
   };
   DamageTypeClass = class DamageTypeClass extends ResourceClass {
     static resourceType = "damage_type";
@@ -3252,7 +3393,7 @@ var init_dialog = __esm(() => {
       super(sandstoneCore);
       this.resource = resource;
     }
-    getValue = () => jsonStringify(this.resource.dialogJSON);
+    getValue = () => jsonStringify(this.resource.dialogJSON, this.resource._resourceType);
   };
   DialogClass = class DialogClass extends ResourceClass {
     static resourceType = "dialog";
@@ -3277,7 +3418,7 @@ var init_enchantment = __esm(() => {
       super(sandstoneCore);
       this.resource = resource;
     }
-    getValue = () => jsonStringify(this.resource.enchantmentJSON);
+    getValue = () => jsonStringify(this.resource.enchantmentJSON, this.resource._resourceType);
   };
   EnchantmentClass = class EnchantmentClass extends ResourceClass {
     static resourceType = "enchantment";
@@ -3294,7 +3435,7 @@ var init_enchantment = __esm(() => {
       super(sandstoneCore);
       this.resource = resource;
     }
-    getValue = () => jsonStringify(this.resource.enchantmentProviderJSON);
+    getValue = () => jsonStringify(this.resource.enchantmentProviderJSON, this.resource._resourceType);
   };
   EnchantmentProviderClass = class EnchantmentProviderClass extends ResourceClass {
     static resourceType = "enchantment_provider";
@@ -3319,7 +3460,7 @@ var init_gametest = __esm(() => {
       super(sandstoneCore);
       this.resource = resource;
     }
-    getValue = () => jsonStringify(this.resource.testEnvironmentJSON);
+    getValue = () => jsonStringify(this.resource.testEnvironmentJSON, this.resource._resourceType);
   };
   TestEnvironmentClass = class TestEnvironmentClass extends ResourceClass {
     static resourceType = "test_environment";
@@ -3336,7 +3477,7 @@ var init_gametest = __esm(() => {
       super(sandstoneCore);
       this.resource = resource;
     }
-    getValue = () => jsonStringify(this.resource.testInstanceJSON);
+    getValue = () => jsonStringify(this.resource.testInstanceJSON, this.resource._resourceType);
   };
   TestInstanceClass = class TestInstanceClass extends ResourceClass {
     static resourceType = "test_instance";
@@ -3361,7 +3502,7 @@ var init_instrument = __esm(() => {
       super(sandstoneCore);
       this.resource = resource;
     }
-    getValue = () => jsonStringify(this.resource.instrumentJSON);
+    getValue = () => jsonStringify(this.resource.instrumentJSON, this.resource._resourceType);
   };
   InstrumentClass = class InstrumentClass extends ResourceClass {
     static resourceType = "instrument";
@@ -3387,7 +3528,7 @@ var init_itemModifier = __esm(() => {
       super(sandstoneCore);
       this.resource = resource;
     }
-    getValue = () => jsonStringify(this.resource.itemModifierJSON);
+    getValue = () => jsonStringify(this.resource.itemModifierJSON, this.resource._resourceType);
   };
   ITEM_MODIFIER_CLASS_BRAND = Symbol.for("sandstone.ItemModifierClass");
   ItemModifierClass = class ItemModifierClass extends ResourceClass {
@@ -3463,7 +3604,7 @@ var init_jukeboxSong = __esm(() => {
       super(sandstoneCore);
       this.resource = resource;
     }
-    getValue = () => jsonStringify(this.resource.jukeboxSongJSON);
+    getValue = () => jsonStringify(this.resource.jukeboxSongJSON, this.resource._resourceType);
   };
   JukeboxSongClass = class JukeboxSongClass extends ResourceClass {
     static resourceType = "jukebox_song";
@@ -3488,7 +3629,7 @@ var init_lootTable = __esm(() => {
       super(sandstoneCore);
       this.resource = resource;
     }
-    getValue = () => jsonStringify(this.resource.lootTableJSON);
+    getValue = () => jsonStringify(this.resource.lootTableJSON, this.resource._resourceType);
   };
   LootTableClass = class LootTableClass extends ResourceClass {
     static resourceType = "loot_table";
@@ -3714,7 +3855,7 @@ var init_mcfunction = __esm(() => {
       return this.body.filter((node) => node.getValue() !== null).map((node) => node.getValue()).join(`
 `);
     };
-    [util7.inspect.custom](depth, options) {
+    [util7.inspect.custom](_depth, options) {
       return formatDebugString(this.constructor.name, {
         name: this.resource.name
       }, this.body, options.indent);
@@ -3730,6 +3871,7 @@ var init_mcfunction = __esm(() => {
     tags;
     lazy;
     env;
+    macroPoint;
     constructor(core, name, args, env) {
       if (name.startsWith("./")) {
         const currentMCFunctionName = core.currentMCFunction?.resource.name;
@@ -3752,11 +3894,16 @@ var init_mcfunction = __esm(() => {
       this.lazy = !!args.lazy;
       this.addToSandstoneCore = !!args.addToSandstoneCore;
       this.tags = args.tags;
-      if (env) {
+      if (env && env.length !== 0) {
         this.env = env;
       }
+      if (this.env || this.callback.length > 1) {
+        this.macroPoint = core.pack.DataVariable();
+      } else {
+        this.macroPoint = undefined;
+      }
       if (args.runOnLoad) {
-        if (env) {
+        if (this.env) {
           core.pack.loadTags.load.push(core.pack.MCFunction(`load_${this.name.split(":")[1]}`, () => {
             this.__call__();
           }));
@@ -3810,21 +3957,25 @@ var init_mcfunction = __esm(() => {
     __call__ = (..._params) => {
       if (this.env || _params.length !== 0) {
         const args = {};
+        if (this.env) {
+          for (const [i, env] of this.env.entries()) {
+            args[`env_${i}`] = ResolveNBTPart(env);
+            env.local.set(this.name, `env_${i}`);
+          }
+        }
         if (_params.length !== 0) {
           for (const [i, param] of _params.entries()) {
             args[`param_${i}`] = ResolveNBTPart(param);
             param.local.set(this.name, `param_${i}`);
           }
           this.node.body = [];
+          this.core.enterMCFunction(this);
           this.core.insideContext(this.node, () => this.callback(makeCallable(this, this.__call__.bind(undefined, ..._params)), ..._params), false);
+          this.core.exitMCFunction();
+        } else if (this.callback.length > 1) {
+          throw new Error(`[MCFunctionClass] Function ${this.name} expects ${this.callback.length - 1} params at the call-site`);
         }
-        if (this.env) {
-          for (const [i, env] of this.env.entries()) {
-            args[`env_${i}`] = ResolveNBTPart(env);
-            env.local.set(this.name, `env_${i}`);
-          }
-        }
-        return this.commands.functionCmd(this.name, "with", this.pack.ResolveNBT(args).dataPoint);
+        return this.commands.functionCmd(this.name, "with", this.pack.ResolveNBT(args, this.macroPoint).dataPoint);
       }
       return this.commands.functionCmd(this.name);
     };
@@ -3854,12 +4005,14 @@ var init_mcfunction = __esm(() => {
       });
       if (contents[0] instanceof _RawMCFunctionClass) {
         for (const mcfunction of contents) {
+          mcfunction.generate();
           this.node.body.unshift(...mcfunction.node.body);
         }
       } else {
         this.core.enterMCFunction(fake);
         this.core.insideContext(fake.node, contents[0], false);
         this.core.exitMCFunction();
+        fake.generate();
         this.node.body.unshift(...fake.node.body);
       }
     }
@@ -3872,12 +4025,14 @@ var init_mcfunction = __esm(() => {
       const fullBody = [];
       if (contents[0] instanceof _RawMCFunctionClass) {
         for (const mcfunction of contents) {
+          mcfunction.generate();
           fullBody.push(...mcfunction.node.body);
         }
       } else {
         this.core.enterMCFunction(fake);
         this.core.insideContext(fake.node, contents[0], false);
         this.core.exitMCFunction();
+        fake.generate();
         fullBody.push(...fake.node.body);
       }
       this.node.body.splice(start, removeItems === "auto" ? fullBody.length : removeItems, ...fullBody);
@@ -3904,7 +4059,7 @@ var init_predicate = __esm(() => {
       super(sandstoneCore);
       this.resource = resource;
     }
-    getValue = () => jsonStringify(this.resource.predicateJSON);
+    getValue = () => jsonStringify(this.resource.predicateJSON, this.resource._resourceType);
   };
   PREDICATE_CLASS_BRAND = Symbol.for("sandstone.PredicateClass");
   PredicateClass = class PredicateClass extends ResourceClass {
@@ -3974,7 +4129,7 @@ var init_recipe = __esm(() => {
       super(sandstoneCore);
       this.resource = resource;
     }
-    getValue = () => jsonStringify(this.resource.recipeJSON);
+    getValue = () => jsonStringify(this.resource.recipeJSON, this.resource._resourceType);
   };
   RecipeClass = class RecipeClass extends ResourceClass {
     static resourceType = "recipe";
@@ -4212,7 +4367,7 @@ var init_structure = __esm(() => {
                   blockPos: [layer[0], row[0], entry[0]],
                   nbt: {
                     id: entity.id,
-                    ...add(entity.nbt)
+                    ...add({ ...entity.nbt })
                   }
                 });
               }
@@ -4292,7 +4447,7 @@ var init_timeline = __esm(() => {
       super(sandstoneCore);
       this.resource = resource;
     }
-    getValue = () => jsonStringify(this.resource.timelineJSON);
+    getValue = () => jsonStringify(this.resource.timelineJSON, this.resource._resourceType);
   };
   TimelineClass = class TimelineClass extends ResourceClass {
     static resourceType = "timeline";
@@ -4309,7 +4464,7 @@ var init_timeline = __esm(() => {
       super(sandstoneCore);
       this.resource = resource;
     }
-    getValue = () => jsonStringify(this.resource.worldClockJSON);
+    getValue = () => jsonStringify(this.resource.worldClockJSON, this.resource._resourceType);
   };
   WorldClockClass = class WorldClockClass extends ResourceClass {
     static resourceType = "world_clock";
@@ -4337,7 +4492,7 @@ var init_trialSpawner = __esm(() => {
       super(sandstoneCore);
       this.resource = resource;
     }
-    getValue = () => jsonStringify(this.resource.trialSpawnerJSON);
+    getValue = () => jsonStringify(this.resource.trialSpawnerJSON, this.resource._resourceType);
   };
   TrialSpawnerClass = class TrialSpawnerClass extends ResourceClass {
     static resourceType = "trial_spawner";
@@ -4362,7 +4517,7 @@ var init_trimMaterial = __esm(() => {
       super(sandstoneCore);
       this.resource = resource;
     }
-    getValue = () => jsonStringify(this.resource.trimMaterialJSON);
+    getValue = () => jsonStringify(this.resource.trimMaterialJSON, this.resource._resourceType);
   };
   TrimMaterialClass = class TrimMaterialClass extends ResourceClass {
     static resourceType = "trim_material";
@@ -4390,7 +4545,7 @@ var init_trimPattern = __esm(() => {
       super(sandstoneCore);
       this.resource = resource;
     }
-    getValue = () => jsonStringify(this.resource.trimPatternJSON);
+    getValue = () => jsonStringify(this.resource.trimPatternJSON, this.resource._resourceType);
   };
   TrimPatternClass = class TrimPatternClass extends ResourceClass {
     static resourceType = "trim_pattern";
@@ -4414,7 +4569,7 @@ var init_variant = __esm(() => {
       super(sandstoneCore);
       this.resource = resource;
     }
-    getValue = () => jsonStringify(this.resource.variantJSON);
+    getValue = () => jsonStringify(this.resource.variantJSON, this.resource._resourceType);
   };
   VariantClass = class VariantClass extends ResourceClass {
     variantType;
@@ -4441,7 +4596,7 @@ var init_villagerTrade = __esm(() => {
       super(sandstoneCore);
       this.resource = resource;
     }
-    getValue = () => jsonStringify(this.resource.villagerTradeJSON);
+    getValue = () => jsonStringify(this.resource.villagerTradeJSON, this.resource._resourceType);
   };
   VillagerTradeClass = class VillagerTradeClass extends ResourceClass {
     static resourceType = "villager_trade";
@@ -4458,7 +4613,7 @@ var init_villagerTrade = __esm(() => {
       super(sandstoneCore);
       this.resource = resource;
     }
-    getValue = () => jsonStringify(this.resource.tradeSetJSON);
+    getValue = () => jsonStringify(this.resource.tradeSetJSON, this.resource._resourceType);
   };
   TradeSetClass = class TradeSetClass extends ResourceClass {
     static resourceType = "trade_set";
@@ -4509,7 +4664,7 @@ var init_atlas = __esm(() => {
       super(sandstoneCore);
       this.resource = resource;
     }
-    getValue = () => jsonStringify(this.resource.atlasJSON);
+    getValue = () => jsonStringify(this.resource.atlasJSON, this.resource._resourceType);
   };
   ATLAS_CLASS_BRAND = Symbol.for("sandstone.AtlasClass");
   AtlasClass = class AtlasClass extends ResourceClass {
@@ -4557,7 +4712,7 @@ var init_blockstate = __esm(() => {
       super(sandstoneCore);
       this.resource = resource;
     }
-    getValue = () => jsonStringify(this.resource.blockStateJSON);
+    getValue = () => jsonStringify(this.resource.blockStateJSON, this.resource._resourceType);
   };
   BLOCK_STATE_CLASS_BRAND = Symbol.for("sandstone.BlockStateClass");
   BlockStateClass = class BlockStateClass extends ResourceClass {
@@ -4638,7 +4793,7 @@ var init_equipment = __esm(() => {
       super(sandstoneCore);
       this.resource = resource;
     }
-    getValue = () => jsonStringify(this.resource.equipmentJSON);
+    getValue = () => jsonStringify(this.resource.equipmentJSON, this.resource._resourceType);
   };
   EquipmentClass = class EquipmentClass extends ResourceClass {
     static resourceType = "equipment";
@@ -4663,7 +4818,7 @@ var init_font = __esm(() => {
       super(sandstoneCore);
       this.resource = resource;
     }
-    getValue = () => jsonStringify(this.resource.fontJSON);
+    getValue = () => jsonStringify(this.resource.fontJSON, this.resource._resourceType);
   };
   FONT_CLASS_BRAND = Symbol.for("sandstone.FontClass");
   FontClass = class FontClass extends ResourceClass {
@@ -4711,7 +4866,7 @@ var init_language = __esm(() => {
       super(sandstoneCore);
       this.resource = resource;
     }
-    getValue = () => jsonStringify(this.resource.languageJSON);
+    getValue = () => jsonStringify(this.resource.languageJSON, this.resource._resourceType);
   };
   LANGUAGE_CLASS_BRAND = Symbol.for("sandstone.LanguageClass");
   LanguageClass = class LanguageClass extends ResourceClass {
@@ -4763,7 +4918,7 @@ var init_particle = __esm(() => {
       super(sandstoneCore);
       this.resource = resource;
     }
-    getValue = () => jsonStringify(this.resource.particleJSON);
+    getValue = () => jsonStringify(this.resource.particleJSON, this.resource._resourceType);
   };
   ParticleClass = class ParticleClass extends ResourceClass {
     static resourceType = "particle";
@@ -4788,7 +4943,7 @@ var init_postEffect = __esm(() => {
       super(sandstoneCore);
       this.resource = resource;
     }
-    getValue = () => jsonStringify(this.resource.postEffectJSON);
+    getValue = () => jsonStringify(this.resource.postEffectJSON, this.resource._resourceType);
   };
   PostEffectClass = class PostEffectClass extends ResourceClass {
     static resourceType = "post_effect";
@@ -4813,7 +4968,7 @@ var init_shader = __esm(() => {
       super(sandstoneCore);
       this.resource = resource;
     }
-    getValue = () => jsonStringify(this.resource.shaderJSON);
+    getValue = () => jsonStringify(this.resource.shaderJSON, this.resource._resourceType);
   };
   ShaderClass = class ShaderClass extends ResourceClass {
     static resourceType = "shader";
@@ -4875,7 +5030,7 @@ var init_sound = __esm(() => {
       super(sandstoneCore);
       this.resource = resource;
     }
-    getValue = () => jsonStringify(this.resource.soundsJSON);
+    getValue = () => jsonStringify(this.resource.soundsJSON, this.resource._resourceType);
   };
   SOUNDS_CLASS_BRAND = Symbol.for("sandstone.SoundsClass");
   SoundsClass = class SoundsClass extends ResourceClass {
@@ -5105,7 +5260,7 @@ var init_waypointStyle = __esm(() => {
       super(sandstoneCore);
       this.resource = resource;
     }
-    getValue = () => jsonStringify(this.resource.waypointStyleJSON);
+    getValue = () => jsonStringify(this.resource.waypointStyleJSON, this.resource._resourceType);
   };
   WaypointStyleClass = class WaypointStyleClass extends ResourceClass {
     static resourceType = "waypoint_style";
@@ -5674,7 +5829,18 @@ class SandstoneCore {
         _path.splice(1, 0, packType.resourceSubFolder);
       }
       const resourcePath = path4.join(..._path);
-      const value = await node.getValue();
+      let value;
+      try {
+        value = await node.getValue();
+      } catch (e) {
+        console.log(`
+
+
+
+`);
+        console.log(node);
+        throw e;
+      }
       if (cliOptions.verbose) {
         console.log(`Path: ${resourcePath}.${fileExtension}
 
@@ -5723,7 +5889,11 @@ var init_JSONTextComponentClass = __esm(() => {
       this.jsonTextComponent = jsonTextComponent;
     }
     toString() {
-      return JSON.stringify(toComponent(this.jsonTextComponent), function(key, value) {
+      const component = toComponent(this.jsonTextComponent);
+      if (typeof component === "string") {
+        return `"${component}"`;
+      }
+      return JSON.stringify(component, function(key, value) {
         if (Array.isArray(this)) {
           const realValue = this[Number.parseInt(key, 10)];
           return toComponent(realValue);
@@ -5938,14 +6108,52 @@ var init_Label = __esm(() => {
   LabelClass = makeClassCallable(_RawLabelClass);
 });
 
+// src/commands/implementations/server/function.ts
+var FUNCTION_COMMAND_NODE_BRAND, FunctionCommandNode, FunctionCommand;
+var init_function = __esm(() => {
+  init_nodes();
+  init_tag();
+  init_NBTs();
+  FUNCTION_COMMAND_NODE_BRAND = Symbol.for("sandstone.FunctionCommandNode");
+  FunctionCommandNode = class FunctionCommandNode extends CommandNode {
+    [FUNCTION_COMMAND_NODE_BRAND] = true;
+    command = "function";
+    static [Symbol.hasInstance](instance) {
+      return (typeof instance === "object" || typeof instance === "function") && instance !== null && instance[FUNCTION_COMMAND_NODE_BRAND] === true;
+    }
+  };
+  FunctionCommand = class FunctionCommand extends CommandArguments {
+    NodeType = FunctionCommandNode;
+    function(mcFunction, params, pointOrType, target, path5) {
+      const args = [];
+      if (params) {
+        if (params === "with" && pointOrType) {
+          args.push("with");
+          if (typeof pointOrType === "string") {
+            args.push(pointOrType, target, path5 ?? "{}");
+          } else {
+            const point = Object.hasOwn(pointOrType, "_toDataPoint") ? pointOrType._toDataPoint : pointOrType;
+            args.push(point.type, point.currentTarget, point.path);
+          }
+        } else {
+          args.push(typeof params === "object" && params.toMacro ? params : nbtStringifier(params));
+        }
+      }
+      return this.finalCommand([mcFunction instanceof TagClass ? `#${mcFunction}` : mcFunction, ...args]);
+    }
+  };
+});
+
 // src/variables/Loop.ts
 var LOOP_ARGUMENT_BRAND, LoopArgument;
 var init_Loop = __esm(() => {
+  init_function();
   init_nodes();
   LOOP_ARGUMENT_BRAND = Symbol.for("sandstone.LoopArgument");
   LoopArgument = class LoopArgument extends Node {
     pack;
     [LOOP_ARGUMENT_BRAND] = true;
+    loopIfNode = null;
     constructor(pack) {
       super(pack.core);
       this.pack = pack;
@@ -5955,7 +6163,15 @@ var init_Loop = __esm(() => {
       return this.toLoop();
     }
     toLoop() {
-      return `function ${this.pack.core.currentNode}`;
+      const loopExecute = this.loopIfNode?.resultingExecuteNode;
+      if (loopExecute?.createdMCFunction) {
+        const funcNode = new FunctionCommandNode(this.pack, loopExecute.createdMCFunction.name);
+        if (loopExecute.macroStorage) {
+          funcNode.args.push("with", "storage", loopExecute.macroStorage.currentTarget, loopExecute.macroStorage.path);
+        }
+        return funcNode.getValue();
+      }
+      return new FunctionCommandNode(this.pack, this.pack.core.currentNode);
     }
     static [Symbol.hasInstance](instance) {
       return (typeof instance === "object" || typeof instance === "function") && instance !== null && instance[LOOP_ARGUMENT_BRAND] === true;
@@ -5995,7 +6211,6 @@ var init_Objective = __esm(() => {
       return formatDebugString(this.constructor.name, {
         name: this.name,
         criteria: this.criteria,
-        display: this.display,
         creator: this.creator
       }, undefined, options.indent);
     }
@@ -6051,13 +6266,13 @@ var init_Sleep = __esm(() => {
         const { execute } = commands;
         const name = `__sandstone:asyncTimer.${currentFunction.resource.name.replace(/[:/]/g, ".")}`;
         const timer = new ObjectiveClass(core.pack, name.replace(":", "."), "dummy", undefined, { creator: "sandstone" });
-        execute.store.result.score(timer("@s")).run.time.query("gametime");
+        execute.store.result(timer("@s")).run.time.query("gametime");
         timer("@s").add(Duration);
         const label = Label(name);
         label("@s").add();
         this.mcfunction.unshift(() => label("@s").remove());
         schedule = MCFunction(`${this.mcfunction.name}/_context`, () => {
-          execute.store.result.score(timer("#current")).run.time.query("gametime");
+          execute.store.result(timer("#current")).run.time.query("gametime");
           execute.as(Selector("@e", { tag: label.fullName })).if.score(timer("@s"), "=", timer("#current")).at("@s").run.functionCmd(this.mcfunction);
         }, {
           packType: currentFunction.resource.packType
@@ -6151,42 +6366,6 @@ var init_setblock = __esm(() => {
   };
 });
 
-// src/commands/implementations/server/function.ts
-var FUNCTION_COMMAND_NODE_BRAND, FunctionCommandNode, FunctionCommand;
-var init_function = __esm(() => {
-  init_nodes();
-  init_tag();
-  init_NBTs();
-  FUNCTION_COMMAND_NODE_BRAND = Symbol.for("sandstone.FunctionCommandNode");
-  FunctionCommandNode = class FunctionCommandNode extends CommandNode {
-    [FUNCTION_COMMAND_NODE_BRAND] = true;
-    command = "function";
-    static [Symbol.hasInstance](instance) {
-      return (typeof instance === "object" || typeof instance === "function") && instance !== null && instance[FUNCTION_COMMAND_NODE_BRAND] === true;
-    }
-  };
-  FunctionCommand = class FunctionCommand extends CommandArguments {
-    NodeType = FunctionCommandNode;
-    function(mcFunction, params, pointOrType, target, path5) {
-      const args = [];
-      if (params) {
-        if (params === "with" && pointOrType) {
-          args.push("with");
-          if (typeof pointOrType === "string") {
-            args.push(pointOrType, target, path5 ?? "{}");
-          } else {
-            const point = Object.hasOwn(pointOrType, "_toDataPoint") ? pointOrType._toDataPoint : pointOrType;
-            args.push(point.type, point.currentTarget, point.path);
-          }
-        } else {
-          args.push(typeof params === "object" && params.toMacro ? params : nbtStringifier(params));
-        }
-      }
-      return this.finalCommand([mcFunction instanceof TagClass ? `#${mcFunction}` : mcFunction, ...args]);
-    }
-  };
-});
-
 // src/commands/implementations/entity/execute.ts
 function createDeferredMacroExecute(pack, executeChain, options) {
   const { childFunctionName, prependArgs } = options;
@@ -6209,7 +6388,7 @@ function createDeferredMacroExecute(pack, executeChain, options) {
             childFunctionNode = childFunction.node;
           } else {
             const childFunction = pack.MCFunction(`${currentFunction.resource.name}/${childFunctionName}`, () => {}, { creator: "sandstone", onConflict: "rename" });
-            pack.commands.functionCmd(childFunction.name, "with", "storage", options.macroStorage);
+            pack.commands.functionCmd(childFunction.name, "with", "storage", options.macroStorage.currentTarget, options.macroStorage.path);
             childFunctionNode = childFunction.node;
           }
           childFunctionNode.body.push(macroNode);
@@ -6293,15 +6472,15 @@ var init_execute = __esm(() => {
     isSingleExecute;
     givenCallbackName;
     macroStorage;
-    constructor(sandstonePack, args = [], { isFake = false, isSingleExecute = true, givenCallbackName = undefined, body = [], macroStorage = undefined } = {}) {
+    pendingCommit;
+    createdMCFunction = null;
+    constructor(sandstonePack, args = [], { isFake = false, isSingleExecute = true, givenCallbackName = undefined, body = [], macroStorage = undefined, pendingCommit = false } = {}) {
       super(sandstonePack, ...args);
       this.givenCallbackName = givenCallbackName;
       this.isSingleExecute = isSingleExecute;
       this.isFake = isFake;
       this.macroStorage = macroStorage;
-      if (macroStorage) {
-        this.isMacro = true;
-      }
+      this.pendingCommit = pendingCommit;
       this.append(...body);
     }
     get callbackName() {
@@ -6312,6 +6491,9 @@ var init_execute = __esm(() => {
         this.body.push(node);
         if (this.isSingleExecute) {
           this.sandstoneCore.getCurrentMCFunctionOrThrow().exitContext();
+          if (this.pendingCommit && !this.commited) {
+            this.commit();
+          }
         }
       }
       return nodes2.length === 1 ? nodes2[0] : nodes2;
@@ -6360,9 +6542,10 @@ var init_execute = __esm(() => {
       });
       const mcFunctionNode = mcFunction.node;
       mcFunctionNode.body = this.body;
+      this.createdMCFunction = mcFunction;
       const mcFunctionCall = new FunctionCommandNode(this.sandstonePack, mcFunction);
       if (this.macroStorage) {
-        mcFunctionCall.args.push("with", "storage", this.macroStorage, "");
+        mcFunctionCall.args.push("with", "storage", this.macroStorage.currentTarget, this.macroStorage.path);
       }
       this.body = [mcFunctionCall];
       return { node: this, mcFunction: mcFunctionNode };
@@ -6375,20 +6558,30 @@ var init_execute = __esm(() => {
     block = (targetPos, path5, type, scale) => this.nestedExecute(["block", coordinatesParser(targetPos), path5, type, scale]);
     bossbar = (id2, type) => this.nestedExecute(["bossbar", id2, type]);
     entity = (target, path5, type, scale) => this.nestedExecute(["entity", targetParser(target), path5, type, scale]);
-    score(...args) {
-      if (isScore(args[0])) {
-        return this.nestedExecute(["score", args[0]]);
-      }
-      return this.nestedExecute(["score", targetParser(args[0]), args[1]]);
-    }
+    score = (targets, objective) => this.nestedExecute(["score", targetParser(targets), objective]);
     storage = (target, path5, type, scale = 1) => this.nestedExecute(["storage", target, path5, type, scale]);
   };
   ExecuteStoreCommand = class ExecuteStoreCommand extends ExecuteCommandPart {
+    _storeCallable(cmd, target, type, scale) {
+      if (isScore(target)) {
+        return cmd.score(target.target, target.objective);
+      }
+      const resolvedType = type ?? "int";
+      if (target.type === "block") {
+        return cmd.block(coordinatesParser(target.currentTarget), target.path, resolvedType, scale);
+      }
+      if (target.type === "entity") {
+        return cmd.entity(target.currentTarget, target.path, resolvedType, scale);
+      }
+      return cmd.storage(target.currentTarget, target.path, resolvedType, scale);
+    }
     get result() {
-      return this.subCommand([["result"]], ExecuteStoreArgsCommand, false);
+      const cmd = this.subCommand([["result"]], ExecuteStoreArgsCommand, false);
+      return makeCallable(cmd, (target, type, scale) => this._storeCallable(cmd, target, type, scale), true);
     }
     get success() {
-      return this.subCommand([["success"]], ExecuteStoreArgsCommand, false);
+      const cmd = this.subCommand([["success"]], ExecuteStoreArgsCommand, false);
+      return makeCallable(cmd, (target, type, scale) => this._storeCallable(cmd, target, type, scale), true);
     }
   };
   ExecuteDataArgsCommand = class ExecuteDataArgsCommand extends ExecuteCommandPart {
@@ -6513,6 +6706,9 @@ var init_execute = __esm(() => {
       const node = this.getNode();
       const commands = new Proxy(this.sandstonePack.commands, {
         get: (_t, p, _r) => {
+          if (!node.commited) {
+            node.pendingCommit = true;
+          }
           this.sandstoneCore.getCurrentMCFunctionOrThrow().enterContext(node, false);
           return this.sandstonePack.commands[p];
         }
@@ -6523,7 +6719,7 @@ var init_execute = __esm(() => {
           node.givenCallbackName = args[0];
         }
         node.isSingleExecute = false;
-        this.sandstoneCore.insideContext(node, callback, false);
+        this.sandstoneCore.insideContext(node, callback, !node.commited);
         return new FinalCommandOutput(node);
       }, true);
     }
@@ -6743,7 +6939,7 @@ class UUIDClass {
     }
     if (this.data || this.scores) {
       const pack = this.core.pack;
-      const { MCFunction, getTempStorage, commands: commands2 } = pack;
+      const { MCFunction, getTempStorage, commands: commands2, Macro: Macro2, Data } = pack;
       const { data } = commands2;
       let sourceData = this.data;
       if (!sourceData && this.scores) {
@@ -6757,15 +6953,15 @@ class UUIDClass {
       tempUUID.set(sourceData);
       const cacheKeyVar = this.primarySource === "scores" && this.scores ? this.scores[0] : tempUUID;
       const currentFunction = this.core.getCurrentMCFunctionOrThrow();
-      const lookupFunction = MCFunction(`${currentFunction.resource.name}/__uuid_lookup`, [cacheKeyVar], () => {
-        data.modify.storage("__sandstone:temp", "uuid_string").set.from.storage(UUID_CACHE.STORAGE, '"$(env_0)"');
-      }, { creator: "sandstone", onConflict: "rename" });
-      lookupFunction();
+      const uuidLookup = Data("storage", "__sandstone:temp", "uuid_lookup");
+      MCFunction(`${currentFunction.resource.name}/__uuid_lookup`, [cacheKeyVar], () => {
+        Macro2.data.modify(uuidLookup.select("uuid_string")).set.from.storage(UUID_CACHE.STORAGE, Macro2`"${cacheKeyVar}"`);
+      }, { creator: "sandstone", onConflict: "rename" })();
       const deferredExecute = new ExecuteCommand(pack, undefined, false);
       return createDeferredMacroExecute(pack, deferredExecute, {
         childFunctionName: "__uuid_execute",
         prependArgs: () => [["as", "$(uuid_string)"]],
-        macroStorage: "__sandstone:temp"
+        macroStorage: uuidLookup
       });
     }
     throw new Error("Cannot use execute on a UUID with no available source. " + "The UUID must have at least one of: known value, selector, data, or scores.");
@@ -7790,7 +7986,7 @@ var init_reload = __esm(() => {
 });
 
 // src/commands/implementations/server/return.ts
-var RETURN_RUN_COMMAND_NODE_BRAND, ReturnRunCommandNode, ReturnArgumentsCommand, ReturnCommandNode, ReturnCommand;
+var RETURN_RUN_COMMAND_NODE_BRAND, ReturnRunCommandNode, ReturnArgumentsCommand, RETURN_COMMAND_NODE_BRAND, ReturnCommandNode, ReturnCommand;
 var init_return = __esm(() => {
   init_nodes();
   init_utils();
@@ -7800,9 +7996,11 @@ var init_return = __esm(() => {
     [RETURN_RUN_COMMAND_NODE_BRAND] = true;
     command = "return";
     isSingleExecute;
-    constructor(sandstonePack, args = [], { isSingleExecute = true, body = [] } = {}) {
+    isFlowControl;
+    constructor(sandstonePack, args = [], { isSingleExecute = true, body = [], isFlowControl = false } = {}) {
       super(sandstonePack, ...args);
       this.isSingleExecute = isSingleExecute;
+      this.isFlowControl = isFlowControl;
       this.append(...body);
     }
     getValue = () => {
@@ -7862,8 +8060,13 @@ var init_return = __esm(() => {
       }, true);
     }
   };
+  RETURN_COMMAND_NODE_BRAND = Symbol.for("sandstone.ReturnCommandNode");
   ReturnCommandNode = class ReturnCommandNode extends CommandNode {
+    [RETURN_COMMAND_NODE_BRAND] = true;
     command = "return";
+    static [Symbol.hasInstance](instance) {
+      return (typeof instance === "object" || typeof instance === "function") && instance !== null && instance[RETURN_COMMAND_NODE_BRAND] === true;
+    }
   };
   ReturnCommand = class ReturnCommand extends CommandArguments {
     NodeType = ReturnCommandNode;
@@ -8045,8 +8248,8 @@ var init_version = __esm(() => {
 // src/commands/implementations/world/data.ts
 var DataCommandNode, DataCommand, DataGetCommand, DataMergeCommand, DataModifyFromCommand, DataModifyValuesCommand, DataModifyTypeCommand, DataModifyCommand, DataRemoveCommand;
 var init_data = __esm(() => {
-  init_core();
   init_nodes();
+  init_utils();
   init_NBTs();
   init_parsers();
   DataCommandNode = class DataCommandNode extends CommandNode {
@@ -8055,22 +8258,55 @@ var init_data = __esm(() => {
   DataCommand = class DataCommand extends CommandArguments {
     NodeType = DataCommandNode;
     get get() {
-      return this.subCommand(["get"], DataGetCommand, false);
+      const cmd = this.subCommand(["get"], DataGetCommand, false);
+      return makeCallable(cmd, (dataPoint, scale) => {
+        if (dataPoint.type === "block") {
+          return cmd.block(coordinatesParser(dataPoint.currentTarget), dataPoint.path, scale);
+        }
+        if (dataPoint.type === "entity") {
+          return cmd.entity(dataPoint.currentTarget, dataPoint.path, scale);
+        }
+        return cmd.storage(dataPoint.currentTarget, dataPoint.path, scale);
+      });
     }
     get merge() {
       return this.subCommand(["merge"], DataMergeCommand, false);
     }
     get modify() {
-      return this.subCommand(["modify"], DataModifyCommand, false);
+      const cmd = this.subCommand(["modify"], DataModifyCommand, false);
+      return makeCallable(cmd, (dataPoint) => {
+        if (dataPoint.type === "block") {
+          return cmd.block(coordinatesParser(dataPoint.currentTarget), dataPoint.path);
+        }
+        if (dataPoint.type === "entity") {
+          return cmd.entity(dataPoint.currentTarget, dataPoint.path);
+        }
+        return cmd.storage(dataPoint.currentTarget, dataPoint.path);
+      });
     }
     get remove() {
-      return this.subCommand(["remove"], DataRemoveCommand, false);
+      const cmd = this.subCommand(["remove"], DataRemoveCommand, false);
+      return makeCallable(cmd, (dataPoint) => {
+        if (dataPoint.type === "block") {
+          return cmd.block(coordinatesParser(dataPoint.currentTarget), dataPoint.path);
+        }
+        if (dataPoint.type === "entity") {
+          return cmd.entity(dataPoint.currentTarget, dataPoint.path);
+        }
+        return cmd.storage(dataPoint.currentTarget, dataPoint.path);
+      });
     }
   };
   DataGetCommand = class DataGetCommand extends CommandArguments {
-    block = (targetPos, path5, scale) => this.finalCommand(["block", coordinatesParser(targetPos), path5, scale]);
-    entity = (target, path5, scale) => this.finalCommand(["entity", targetParser(target), path5, scale]);
-    storage = (target, path5, scale) => this.finalCommand(["storage", target, path5, scale]);
+    block = (targetPos, path5, scale) => {
+      return this.finalCommand(["block", coordinatesParser(targetPos), path5, scale]);
+    };
+    entity = (target, path5, scale) => {
+      return this.finalCommand(["entity", targetParser(target), path5, scale]);
+    };
+    storage = (target, path5, scale) => {
+      return this.finalCommand(["storage", target, path5, scale]);
+    };
   };
   DataMergeCommand = class DataMergeCommand extends CommandArguments {
     block = (targetPos, nbt2) => this.finalCommand(["block", coordinatesParser(targetPos), nbtStringifier(nbt2)]);
@@ -8080,20 +8316,22 @@ var init_data = __esm(() => {
   DataModifyFromCommand = class DataModifyFromCommand extends CommandArguments {
     block = (sourcePosition, sourcePath) => this.finalCommand(["block", coordinatesParser(sourcePosition), sourcePath]);
     entity = (source, sourcePath) => this.finalCommand(["entity", targetParser(source), sourcePath]);
-    storage(source, sourcePath) {
-      let storageArg;
-      if (isMacroArgument(this.sandstoneCore, source) || typeof source === "string") {
-        storageArg = source;
-      } else {
-        const dataPoint = source;
-        storageArg = `${dataPoint.currentTarget} ${dataPoint.path}`;
-      }
-      return this.finalCommand(["storage", storageArg, sourcePath]);
-    }
+    storage = (source, sourcePath) => {
+      return this.finalCommand(["storage", source, sourcePath]);
+    };
   };
   DataModifyValuesCommand = class DataModifyValuesCommand extends CommandArguments {
     get from() {
-      return this.subCommand(["from"], DataModifyFromCommand, false);
+      const cmd = this.subCommand(["from"], DataModifyFromCommand, false);
+      return makeCallable(cmd, (dataPoint) => {
+        if (dataPoint.type === "block") {
+          return cmd.block(coordinatesParser(dataPoint.currentTarget), dataPoint.path);
+        }
+        if (dataPoint.type === "entity") {
+          return cmd.entity(dataPoint.currentTarget, dataPoint.path);
+        }
+        return cmd.storage(dataPoint.currentTarget, dataPoint.path);
+      });
     }
     string = {
       block: (sourcePosition, sourcePath, start, end) => {
@@ -8152,14 +8390,26 @@ var init_data = __esm(() => {
     }
   };
   DataModifyCommand = class DataModifyCommand extends CommandArguments {
-    block = (targetPos, targetPath) => this.subCommand(["block", coordinatesParser(targetPos), targetPath], DataModifyTypeCommand, false);
-    entity = (target, targetPath) => this.subCommand(["entity", targetParser(target), targetPath], DataModifyTypeCommand, false);
-    storage = (target, targetPath) => this.subCommand(["storage", target, targetPath], DataModifyTypeCommand, false);
+    block = (targetPos, targetPath) => {
+      return this.subCommand(["block", coordinatesParser(targetPos), targetPath], DataModifyTypeCommand, false);
+    };
+    entity = (target, targetPath) => {
+      return this.subCommand(["entity", targetParser(target), targetPath], DataModifyTypeCommand, false);
+    };
+    storage = (target, targetPath) => {
+      return this.subCommand(["storage", target, targetPath], DataModifyTypeCommand, false);
+    };
   };
   DataRemoveCommand = class DataRemoveCommand extends CommandArguments {
-    block = (targetPos, targetPath) => this.finalCommand(["block", coordinatesParser(targetPos), targetPath]);
-    entity = (target, targetPath) => this.finalCommand(["entity", targetParser(target), targetPath]);
-    storage = (target, targetPath) => this.finalCommand(["storage", target, targetPath]);
+    block = (targetPos, targetPath) => {
+      return this.finalCommand(["block", coordinatesParser(targetPos), targetPath]);
+    };
+    entity = (target, targetPath) => {
+      return this.finalCommand(["entity", targetParser(target), targetPath]);
+    };
+    storage = (target, targetPath) => {
+      return this.finalCommand(["storage", target, targetPath]);
+    };
   };
 });
 
@@ -9045,11 +9295,11 @@ var init_dataPoint = __esm(() => {
       const { execute: execute2 } = commands2;
       const anon = DataVariable(this.dataPoint);
       this.conditional = Variable();
-      execute2.store.result.score(this.conditional).run(() => anon.set(this.value));
+      execute2.store.result(this.conditional).run(() => anon.set(this.value));
     }
     getValue = (negated) => (negated ? ["if", ...this.getCondition()] : ["unless", ...this.getCondition()]).join(" ");
     getCondition() {
-      return ["score", "matches", "0.."];
+      return ["score", this.conditional, "matches", "0.."];
     }
   };
 });
@@ -9136,7 +9386,7 @@ var init_command = __esm(() => {
       this.result = result;
       const store = sandstoneCore2.pack.commands.execute.store[type];
       this.variable = sandstoneCore2.pack.Variable(undefined, "condition");
-      command(store.score(this.variable));
+      command(store(this.variable));
     }
     getCondition() {
       if (this.type === "success") {
@@ -9188,11 +9438,13 @@ var init_loaded = __esm(() => {
 });
 
 // src/flow/conditions/variables/score.ts
-var ScoreConditionNode;
+var SCORE_CONDITION_NODE_BRAND, ScoreConditionNode;
 var init_score = __esm(() => {
   init_condition();
+  SCORE_CONDITION_NODE_BRAND = Symbol.for("sandstone.ScoreConditionNode");
   ScoreConditionNode = class ScoreConditionNode extends SingleConditionNode {
     args;
+    [SCORE_CONDITION_NODE_BRAND] = true;
     constructor(sandstoneCore2, args) {
       super(sandstoneCore2);
       this.args = args;
@@ -9200,6 +9452,9 @@ var init_score = __esm(() => {
     getCondition() {
       return ["score", ...this.args];
     }
+    static [Symbol.hasInstance](instance) {
+      return (typeof instance === "object" || typeof instance === "function") && instance !== null && instance[SCORE_CONDITION_NODE_BRAND] === true;
+    }
   };
 });
 
@@ -9302,7 +9557,7 @@ class IfStatement {
     this.node = new IfNode(sandstoneCore2, condition2, callback);
   }
   elseIf = (condition2, callback) => {
-    const statement = new IfStatement(this.sandstoneCore, this.sandstoneCore.pack.flow.conditionToNode(condition2), callback);
+    const statement = new IfStatement(this.sandstoneCore, conditionToNode(condition2), callback);
     this.node.nextFlowNode = statement.getNode();
     statement.node._isElseIf = true;
     return statement;
@@ -9330,6 +9585,7 @@ var IF_NODE_BRAND, IfNode, ELSE_NODE_BRAND, ElseNode;
 var init_if_else = __esm(() => {
   init_core();
   init_utils();
+  init_Flow();
   IF_NODE_BRAND = Symbol.for("sandstone.IfNode");
   IfNode = class IfNode extends ContainerNode {
     condition;
@@ -9337,10 +9593,14 @@ var init_if_else = __esm(() => {
     [IF_NODE_BRAND] = true;
     nextFlowNode;
     _isElseIf = false;
-    constructor(sandstoneCore2, condition2, callback) {
+    parentMCFunction;
+    givenCallbackName;
+    resultingExecuteNode;
+    constructor(sandstoneCore2, condition2, callback, parentMCFunction) {
       super(sandstoneCore2);
       this.condition = condition2;
       this.callback = callback;
+      this.parentMCFunction = parentMCFunction ?? sandstoneCore2.getCurrentMCFunctionOrThrow();
       if (callback && callback.toString() !== "() => {}") {
         this.sandstoneCore.insideContext(this, callback, true);
       }
@@ -9382,26 +9642,6 @@ ${indent}${nextFormatting}`;
 });
 
 // src/flow/loops/binary_for.ts
-function binaryFor(flow, from, to, callback, maximum = 128) {
-  if (typeof from === "number" && typeof to === "number") {
-    callback(to - from);
-  }
-  const { Variable } = flow.sandstoneCore.pack;
-  const realStart = from instanceof Score ? from : Variable(from);
-  const realEnd = to instanceof Score ? to : Variable(to);
-  const iterations = realEnd.minus(realStart);
-  const _ = flow;
-  _.while(iterations.lessThan(maximum), () => {
-    callback(maximum);
-    iterations.remove(maximum);
-  });
-  for (let i = 1;i < maximum; i *= 2) {
-    _.if(iterations.moduloBy(2).equalTo(1), () => {
-      callback(i);
-    });
-    iterations.dividedBy(2);
-  }
-}
 var init_binary_for = __esm(() => {
   init_variables();
 });
@@ -9411,16 +9651,18 @@ var LoopNode;
 var init_loop = __esm(() => {
   init_core();
   LoopNode = class LoopNode extends ContainerNode {
-    executeArgs;
+    condition;
     callback;
     loopback;
-    constructor(sandstoneCore2, executeArgs, callback, loopback) {
+    parentMCFunction;
+    constructor(sandstoneCore2, condition2, callback, loopback) {
       super(sandstoneCore2);
-      this.executeArgs = executeArgs;
+      this.condition = condition2;
       this.callback = callback;
       this.loopback = loopback;
+      const currentNode = this.sandstoneCore.getCurrentMCFunctionOrThrow();
+      this.parentMCFunction = currentNode;
       if (callback.toString() !== "() => {}") {
-        const currentNode = this.sandstoneCore.getCurrentMCFunctionOrThrow();
         currentNode.enterContext(this);
         this.callback();
         this.loopback();
@@ -9433,6 +9675,75 @@ var init_loop = __esm(() => {
   };
 });
 
+// src/flow/loops/staticAnalysis.ts
+function valueMatchesRange(value, rangeStr) {
+  if (rangeStr.includes("..")) {
+    const [minStr, maxStr] = rangeStr.split("..");
+    const min = minStr !== "" ? parseInt(minStr, 10) : Number.NEGATIVE_INFINITY;
+    const max = maxStr !== "" ? parseInt(maxStr, 10) : Number.POSITIVE_INFINITY;
+    return value >= min && value <= max;
+  }
+  return value === parseInt(rangeStr, 10);
+}
+function analyzeCondition(condition2, targetScore, value, negated = false) {
+  if (condition2 instanceof ScoreConditionNode) {
+    const args = condition2.args;
+    if (args.length >= 4 && args[2] === "matches") {
+      const [target, objective, , rangeStr] = args;
+      if (target !== `${targetScore.target}` || objective !== `${targetScore.objective}`) {
+        return { canAnalyze: false };
+      }
+      let result = valueMatchesRange(value, rangeStr);
+      if (negated)
+        result = !result;
+      return { canAnalyze: true, result };
+    }
+    return { canAnalyze: false };
+  }
+  if (condition2 instanceof AndNode) {
+    for (const subCondition of condition2.conditions) {
+      const subResult = analyzeCondition(subCondition, targetScore, value, negated);
+      if (!subResult.canAnalyze)
+        return { canAnalyze: false };
+      if (!subResult.result)
+        return { canAnalyze: true, result: false };
+    }
+    return { canAnalyze: true, result: true };
+  }
+  if (condition2 instanceof OrNode) {
+    let anyTrue = false;
+    for (const subCondition of condition2.conditions) {
+      const subResult = analyzeCondition(subCondition, targetScore, value, negated);
+      if (!subResult.canAnalyze)
+        return { canAnalyze: false };
+      if (subResult.result)
+        anyTrue = true;
+    }
+    return { canAnalyze: true, result: anyTrue };
+  }
+  if (condition2 instanceof NotNode) {
+    return analyzeCondition(condition2.condition, targetScore, value, !negated);
+  }
+  return { canAnalyze: false };
+}
+function getDeclarationLocation() {
+  const stack = new Error().stack;
+  const locationMatch = stack?.split(`
+`).find((line) => line.includes(".ts:") && !line.includes("/loops/") && !line.includes("node_modules"));
+  return locationMatch?.trim() || "unknown location";
+}
+function warnStaticallyFalseCondition(loopType, details) {
+  const location = getDeclarationLocation();
+  console.warn(`[Sandstone] Warning: ${loopType} loop condition is statically false (${details}). ` + `The loop body will never execute. If this is intentional, you can ignore this warning.
+` + `  at ${location}`);
+}
+var init_staticAnalysis = __esm(() => {
+  init_score();
+  init_and();
+  init_or();
+  init_not();
+});
+
 // src/flow/loops/for_i.ts
 class ForIStatement {
   sandstoneCore;
@@ -9453,43 +9764,64 @@ class ForIStatement {
 }
 var ForINode;
 var init_for_i = __esm(() => {
-  init_commands2();
   init_variables();
+  init_flow();
+  init_if_else();
   init_loop();
+  init_staticAnalysis();
   ForINode = class ForINode extends LoopNode {
     constructor(sandstoneCore2, initialValue, endCondition, iterate, callback) {
       const iterator = sandstoneCore2.pack.Variable(initialValue, "loop_iterator");
-      const condition2 = sandstoneCore2.pack._.conditionToNode(endCondition(iterator));
-      const value = condition2.getValue().split(" ");
-      const conditionValue = [value[0], value.slice(1).join(" ")];
-      const _continue = () => sandstoneCore2.pack.commands.returnCmd.run(() => new ExecuteCommandNode(sandstoneCore2.pack, [conditionValue], {
-        body: [new LoopArgument(sandstoneCore2.pack)]
-      }));
-      callback(iterator, _continue);
-      iterate(iterator);
-      super(sandstoneCore2, [conditionValue], () => callback(iterator, _continue), () => {
+      const condition2 = conditionToNode(endCondition(iterator));
+      const _continue = () => sandstoneCore2.pack.commands.returnCmd.run(() => new IfStatement(sandstoneCore2, condition2, () => new LoopArgument(sandstoneCore2.pack)));
+      const analysisResult = typeof initialValue === "number" ? analyzeCondition(condition2, iterator, initialValue) : { canAnalyze: false };
+      if (analysisResult.canAnalyze) {
+        if (analysisResult.result) {
+          callback(iterator, _continue);
+          iterate(iterator);
+        } else {
+          warnStaticallyFalseCondition("for", `initial value ${initialValue} does not satisfy condition`);
+        }
+      }
+      super(sandstoneCore2, condition2, () => callback(iterator, _continue), () => {
         iterate(iterator);
-        return new ExecuteCommandNode(sandstoneCore2.pack, [conditionValue], {
-          body: [new LoopArgument(sandstoneCore2.pack)]
-        });
+        new IfStatement(sandstoneCore2, condition2, () => new LoopArgument(sandstoneCore2.pack));
       });
     }
   };
 });
 
 // src/flow/loops/for_of.ts
+function isMultipleVariable(iteratorType) {
+  if (Array.isArray(iteratorType)) {
+    return true;
+  }
+  return false;
+}
+function isMapIterator(iteratorType, iterable) {
+  if (isMultipleVariable(iteratorType) && iteratorType[0] === "key") {
+    if (iterable.iteratorType === "map") {
+      return true;
+    }
+    throw new Error('Attempt to use "for key value" loop with a List iterable; this is not supported. (Hint: use "for entry" or "for i entry" instead)');
+  }
+  return false;
+}
+
 class ForOfStatement {
   sandstoneCore;
   iteratorType;
+  direction;
   iterable;
   callback;
   node;
-  constructor(sandstoneCore2, iteratorType, iterable, callback) {
+  constructor(sandstoneCore2, iteratorType, direction, iterable, callback) {
     this.sandstoneCore = sandstoneCore2;
     this.iteratorType = iteratorType;
+    this.direction = direction;
     this.iterable = iterable;
     this.callback = callback;
-    this.node = new ForOfNode(sandstoneCore2, iteratorType, iterable, callback);
+    this.node = new ForOfNode(sandstoneCore2, iteratorType, direction, iterable, callback);
   }
   getNode = () => this.node;
 }
@@ -9499,35 +9831,31 @@ var init_for_of = __esm(() => {
   init_if_else();
   init_loop();
   ForOfNode = class ForOfNode extends LoopNode {
-    constructor(sandstoneCore2, iteratorType, iterable, callback) {
-      const _iterable = iterable._toDataPoint();
-      let startCondition;
+    constructor(sandstoneCore2, iteratorType, direction, iterable, callback) {
       let iterate;
-      let continueCondition;
-      if (Array.isArray(iteratorType)) {
-        if (iteratorType[0] === "key") {
-          startCondition = ["if", "data", _iterable.type, `${_iterable.path}{}`];
+      if (isMultipleVariable(iteratorType)) {
+        if (isMapIterator(iteratorType, iterable)) {
           iterate = iterable.iterator((dataPoints) => {
-            if (dataPoints.length === 1) {
-              throw new Error('Error: Attempt to use "for key value" loop with an Array dataset; this is not supported. (Hint: use "for entry" or "for i entry" instead)');
-            }
             callback(...[dataPoints[0], dataPoints[1]]);
-          });
+          }, direction);
         } else {
-          startCondition = ["if", "data", _iterable.type, `${_iterable.path}{}`];
-          const _iterator = sandstoneCore2.pack.Variable();
-          _iterator.set(iterable.size());
-          continueCondition = _iterator["!="](-1);
+          const _iterator = sandstoneCore2.pack.Variable(direction === "normal" ? -1 : undefined);
+          if (direction === "reverse") {
+            _iterator.set(iterable.size());
+          }
           iterate = iterable.iterator((dataPoints) => {
-            _iterator.decrease();
+            if (direction === "normal") {
+              _iterator.increase();
+            } else {
+              _iterator.decrease();
+            }
             if (dataPoints.length === 1) {
               return callback(...[_iterator, dataPoints[0]]);
             }
             return callback(...[_iterator, dataPoints[1]]);
-          });
+          }, direction);
         }
       } else {
-        startCondition = ["if", "data", _iterable.type, `${_iterable.path}{}`];
         iterate = iterable.iterator((dataPoints) => {
           if (dataPoints.length === 1) {
             return callback(...[dataPoints[0]]);
@@ -9535,8 +9863,8 @@ var init_for_of = __esm(() => {
           return callback(...[dataPoints[1]]);
         });
       }
-      iterate();
-      super(sandstoneCore2, [startCondition], () => iterate, () => new IfStatement(sandstoneCore2, continueCondition || iterable.continue, () => new LoopArgument(sandstoneCore2.pack)));
+      const continueCondition = iterable.continue(direction);
+      super(sandstoneCore2, continueCondition, () => iterate, () => new IfStatement(sandstoneCore2, continueCondition, () => new LoopArgument(sandstoneCore2.pack)));
     }
   };
 });
@@ -9558,11 +9886,12 @@ var WhileNode;
 var init_while = __esm(() => {
   init_variables();
   init_if_else();
+  init_flow();
   init_loop();
   WhileNode = class WhileNode extends LoopNode {
     constructor(sandstoneCore2, condition2, callback) {
-      const _condition = sandstoneCore2.pack._.conditionToNode(condition2);
-      super(sandstoneCore2, [_condition.getValue().split(" ")], callback, () => new IfStatement(sandstoneCore2, _condition, () => new LoopArgument(sandstoneCore2.pack)));
+      const _condition = conditionToNode(condition2);
+      super(sandstoneCore2, _condition, callback, () => new IfStatement(sandstoneCore2, _condition, () => new LoopArgument(sandstoneCore2.pack)));
     }
   };
 });
@@ -9576,29 +9905,77 @@ var init_loops = __esm(() => {
 });
 
 // src/flow/switch_case.ts
-var CASE_STATEMENT_BRAND, CaseStatement;
+function isConditionCase(c) {
+  return typeof c === "function";
+}
+function executeSwitch(sandstoneCore2, value, _cases) {
+  let staticCaseEntries = [];
+  let conditionCaseEntries = [];
+  let _default;
+  if (_cases instanceof CaseStatement) {
+    staticCaseEntries = _cases.getStaticCases();
+    conditionCaseEntries = _cases.getConditionCases();
+  } else if (Array.isArray(_cases)) {
+    for (const _case of _cases) {
+      if (_case[0] === "default") {
+        _default = _case;
+        continue;
+      }
+      const [, condition2, callback] = _case;
+      if (isConditionCase(condition2)) {
+        conditionCaseEntries.push({ type: "condition", condition: condition2, callback });
+      } else {
+        staticCaseEntries.push({ type: "static", value: condition2, callback });
+      }
+    }
+  } else {
+    for (const _case of _cases.entries) {
+      if (_case.type === "condition") {
+        conditionCaseEntries.push(_case);
+      } else {
+        staticCaseEntries.push(_case);
+      }
+    }
+    if (_cases.default) {
+      _default = ["default", _cases.default];
+    }
+  }
+  const staticCaseNodes = staticCaseEntries.map((c) => new StaticCaseNode(sandstoneCore2, c.value, c.callback));
+  const conditionCaseNodes = conditionCaseEntries.map((c) => new ConditionCaseNode(sandstoneCore2, c.condition, c.callback));
+  const defaultCaseNode = _default ? new DefaultCaseNode(sandstoneCore2, _default[1]) : undefined;
+  new SwitchNode(sandstoneCore2, value, staticCaseNodes, conditionCaseNodes, defaultCaseNode);
+}
+var CASE_STATEMENT_BRAND, CaseStatement, SwitchNode, StaticCaseNode, ConditionCaseNode, DefaultCaseNode;
 var init_switch_case = __esm(() => {
+  init_core();
   CASE_STATEMENT_BRAND = Symbol.for("sandstone.CaseStatement");
   CaseStatement = class CaseStatement {
-    value;
-    callback;
-    previous;
+    entries;
     [CASE_STATEMENT_BRAND] = true;
-    constructor(value, callback, previous) {
-      this.value = value;
-      this.callback = callback;
-      this.previous = previous;
+    constructor(entries = []) {
+      this.entries = entries;
     }
-    getCases = () => this.previous ? [...this.previous, this] : [this];
-    getValue() {
-      return ["case", this.value, this.callback];
+    getStaticCases() {
+      return this.entries.filter((e) => e.type === "static");
+    }
+    getConditionCases() {
+      return this.entries.filter((e) => e.type === "condition");
     }
-    case(value, callback) {
-      return new CaseStatement(value, callback, this.getCases());
+    case(valueOrCondition, callback) {
+      if (typeof valueOrCondition === "function") {
+        return new CaseStatement([
+          ...this.entries,
+          { type: "condition", condition: valueOrCondition, callback }
+        ]);
+      }
+      return new CaseStatement([
+        ...this.entries,
+        { type: "static", value: valueOrCondition, callback }
+      ]);
     }
     default(callback) {
       return {
-        cases: this.getCases(),
+        entries: this.entries,
         default: callback
       };
     }
@@ -9606,24 +9983,83 @@ var init_switch_case = __esm(() => {
       return (typeof instance === "object" || typeof instance === "function") && instance !== null && instance[CASE_STATEMENT_BRAND] === true;
     }
   };
+  SwitchNode = class SwitchNode extends ContainerNode {
+    value;
+    staticCases;
+    conditionCases;
+    defaultCase;
+    parentMCFunction;
+    constructor(sandstoneCore2, value, staticCases, conditionCases, defaultCase) {
+      super(sandstoneCore2);
+      this.value = value;
+      this.staticCases = staticCases;
+      this.conditionCases = conditionCases;
+      this.defaultCase = defaultCase;
+      this.parentMCFunction = sandstoneCore2.getCurrentMCFunctionOrThrow();
+      this.parentMCFunction.enterContext(this);
+      for (const caseNode of [...staticCases, ...conditionCases]) {
+        this.parentMCFunction.enterContext(caseNode);
+        caseNode.callback();
+        this.parentMCFunction.exitContext();
+      }
+      if (defaultCase) {
+        this.parentMCFunction.enterContext(defaultCase);
+        defaultCase.callback();
+        this.parentMCFunction.exitContext();
+      }
+      this.parentMCFunction.exitContext();
+    }
+    getValue = () => {
+      throw new Error("SwitchNode must be transformed by SwitchTransformationVisitor");
+    };
+  };
+  StaticCaseNode = class StaticCaseNode extends ContainerNode {
+    value;
+    callback;
+    constructor(sandstoneCore2, value, callback) {
+      super(sandstoneCore2);
+      this.value = value;
+      this.callback = callback;
+    }
+    getValue = () => null;
+  };
+  ConditionCaseNode = class ConditionCaseNode extends ContainerNode {
+    condition;
+    callback;
+    constructor(sandstoneCore2, condition2, callback) {
+      super(sandstoneCore2);
+      this.condition = condition2;
+      this.callback = callback;
+    }
+    getValue = () => null;
+  };
+  DefaultCaseNode = class DefaultCaseNode extends ContainerNode {
+    callback;
+    constructor(sandstoneCore2, callback) {
+      super(sandstoneCore2);
+      this.callback = callback;
+    }
+    getValue = () => null;
+  };
 });
 
 // src/flow/Flow.ts
+function conditionToNode(condition2) {
+  if (!(condition2 instanceof ConditionNode)) {
+    return condition2._toMinecraftCondition();
+  }
+  return condition2;
+}
+
 class Flow {
   sandstoneCore;
   constructor(sandstoneCore2) {
     this.sandstoneCore = sandstoneCore2;
   }
-  conditionToNode(condition2) {
-    if (!(condition2 instanceof ConditionNode)) {
-      return condition2._toMinecraftCondition();
-    }
-    return condition2;
-  }
-  if = (condition2, callback) => new IfStatement(this.sandstoneCore, this.conditionToNode(condition2), callback);
-  and = (...conditions) => new AndNode(this.sandstoneCore, conditions.map((condition2) => this.conditionToNode(condition2)));
-  or = (...conditions) => new OrNode(this.sandstoneCore, conditions.map((condition2) => this.conditionToNode(condition2)));
-  not = (condition2) => new NotNode(this.sandstoneCore, this.conditionToNode(condition2));
+  if = (condition2, callback) => new IfStatement(this.sandstoneCore, conditionToNode(condition2), callback);
+  and = (...conditions) => new AndNode(this.sandstoneCore, conditions.map((condition2) => conditionToNode(condition2)));
+  or = (...conditions) => new OrNode(this.sandstoneCore, conditions.map((condition2) => conditionToNode(condition2)));
+  not = (condition2) => new NotNode(this.sandstoneCore, conditionToNode(condition2));
   get return() {
     return this.sandstoneCore.pack.commands.returnCmd;
   }
@@ -9646,77 +10082,56 @@ Sandstone Pack Error:
     if (broadcast !== false) {
       tellraw2(broadcast || "@a", fullError);
     }
-    const errorString = parseJSONText(this.sandstoneCore, fullError);
+    const errorSerializable = parseJSONText(this.sandstoneCore, fullError);
     if (dataPoint2 !== false) {
       let point;
       if (dataPoint2 === undefined) {
-        point = DataVariable(parseJSONText(this.sandstoneCore, fullError));
+        point = DataVariable(errorSerializable.toJSON());
       } else {
-        point = dataPoint2.set(errorString);
+        point = dataPoint2.set(errorSerializable.toJSON());
       }
       returnCmd.fail();
       return point;
     }
     returnCmd.fail();
-    return errorString;
+    return errorSerializable;
   }
   while(condition2, callback) {
-    return new WhileStatement(this.sandstoneCore, this.conditionToNode(condition2), callback);
+    return new WhileStatement(this.sandstoneCore, conditionToNode(condition2), callback);
   }
   doWhile(condition2, callback) {
     callback();
-    return new WhileStatement(this.sandstoneCore, this.conditionToNode(condition2), callback);
+    return new WhileStatement(this.sandstoneCore, conditionToNode(condition2), callback);
   }
   for(arg1, arg2, arg3, arg4) {
     if (typeof arg1 === "number" || arg1 instanceof Score) {
       return new ForIStatement(this.sandstoneCore, arg1, arg2, arg3, arg4);
     }
     if (arg1 === "entry") {
-      return new ForOfStatement(this.sandstoneCore, arg1, arg3, arg4);
+      return new ForOfStatement(this.sandstoneCore, arg1, arg2 === "of-reverse" ? "reverse" : "normal", arg3, arg4);
     }
     if (arg1[0] === "key") {
-      return new ForOfStatement(this.sandstoneCore, arg1, arg3, arg4);
+      return new ForOfStatement(this.sandstoneCore, arg1, arg2 === "of-reverse" ? "reverse" : "normal", arg3, arg4);
     }
     if (typeof arg1[0] === "number" || arg1[0] instanceof Score) {
       if (arg2 === "iterate") {
         return new ForIStatement(this.sandstoneCore, arg1[0], (i) => i["<="](arg1[1]), (i) => i["++"], arg3);
       }
-      return binaryFor(this, arg1[0], arg1[1], arg3, arg1[2]);
     }
-    return new ForOfStatement(this.sandstoneCore, arg1, arg3, arg4);
+    return new ForOfStatement(this.sandstoneCore, arg1, arg2 === "of-reverse" ? "reverse" : "normal", arg3, arg4);
   }
-  switch(value, _cases, _default) {
-    let cases;
-    if (_cases instanceof CaseStatement) {
-      cases = _cases.getCases().map((c) => c.getValue());
-    } else if (Array.isArray(_cases)) {
-      cases = _cases;
-    } else {
-      cases = _cases.cases.map((c) => c.getValue());
-      _default = ["default", _cases.default];
-    }
-    const { Data: Data2, initMCFunction, MCFunction, Macro: Macro2 } = this.sandstoneCore.pack;
-    const id2 = switches++;
-    const values = Data2("storage", `__sandstone:switch_${id2}`, "Values");
-    initMCFunction.push(() => values.set(cases.map(([_, v, callback], i) => {
-      MCFunction(`__sandstone:switch_${id2}_case_${i}`, [], () => callback());
-      return { Value: v, Index: i };
-    })));
-    const flow = this;
-    MCFunction(`__sandstone:switch_${id2}`, [value], () => {
-      const index = Data2("storage", `__sandstone:switch_${id2}`, "Index");
-      Macro2.data.modify.storage(index.currentTarget, "Index").set.from.storage(values.currentTarget, Macro2`Values[{Value:${value}}}].Index`);
-      const _if = flow.if(index, () => {
-        MCFunction(`__sandstone:switch_${id2}_inner`, [index], () => {
-          Macro2.functionCmd(Macro2`__sandstone:switch_${id2}_case_${index}`);
-        })();
-      });
-      if (_default)
-        _if.else(() => _default?.[1]());
-    })();
+  switch(value, cases) {
+    executeSwitch(this.sandstoneCore, value, cases);
   }
   case(value, callback) {
-    return new CaseStatement(value, callback);
+    if (typeof value === "function") {
+      return new CaseStatement([
+        { type: "condition", condition: value, callback }
+      ]);
+    }
+    return new CaseStatement([
+      { type: "static", value, callback }
+    ]);
   }
   biome = (coordinates, biome2) => {
     return new SandstoneConditions.Biome(this.sandstoneCore, coordinates, biome2);
@@ -9758,7 +10173,6 @@ Sandstone Pack Error:
     return new SandstoneConditions.Predicate(this.sandstoneCore, predicate3.name);
   };
 }
-var switches = 0;
 var init_Flow = __esm(() => {
   init_variables();
   init_conditions();
@@ -9773,6 +10187,7 @@ var init_flow = __esm(() => {
   init_Flow();
   init_if_else();
   init_loop();
+  init_switch_case();
 });
 
 // src/core/visitors.ts
@@ -9855,6 +10270,10 @@ var init_visitor = __esm(() => {
     visitIfNode;
     visitElseNode;
     visitLoopNode;
+    visitSwitchNode;
+    visitStaticCaseNode;
+    visitConditionCaseNode;
+    visitDefaultCaseNode;
     visitLoopArgumentNode;
     visitAdvancementCommandNode;
     visitAttributeCommandNode;
@@ -9884,6 +10303,7 @@ var init_addAwaitBodyToMCFunctions = __esm(() => {
 // src/pack/visitors/containerCommandsToMCFunction.ts
 var ContainerCommandsToMCFunctionVisitor;
 var init_containerCommandsToMCFunction = __esm(() => {
+  init_commands2();
   init_core();
   init_visitor();
   ContainerCommandsToMCFunctionVisitor = class ContainerCommandsToMCFunctionVisitor extends GenericSandstoneVisitor {
@@ -9903,6 +10323,14 @@ var init_containerCommandsToMCFunction = __esm(() => {
       this.currentMCFunction = node;
       this.core.currentNode = node.resource.name;
       const result = this.genericVisit(node);
+      if (node.resource.creator === "sandstone" && node.body.length > 0) {
+        const lastNode = node.body.at(-1);
+        if (lastNode instanceof FunctionCommandNode) {
+          const returnRunNode = new ReturnRunCommandNode(this.pack, ["run"]);
+          returnRunNode.body = [lastNode];
+          node.body[node.body.length - 1] = returnRunNode;
+        }
+      }
       this.core.currentNode = prev?.resource.name ?? "";
       this.currentMCFunction = prev;
       return result;
@@ -9945,7 +10373,7 @@ function* flattenIfNode(node) {
     yield next;
   }
 }
-function handleMultipleNodes(visitor, nodes2) {
+function handleMultipleNodes(visitor, nodes2, macroStorage) {
   return nodes2.flatMap((node, i) => {
     const { body } = node;
     if (node instanceof IfNode) {
@@ -9956,25 +10384,32 @@ function handleMultipleNodes(visitor, nodes2) {
         if (Array.isArray(child)) {
           actualBody = child;
         } else {
-          return new ExecuteCommandNode(visitor.pack, [[node.condition.getValue()]], {
+          return visitor.visit(new ExecuteCommandNode(visitor.pack, [[node.condition.getValue()]], {
             isSingleExecute: false,
             givenCallbackName: callbackName,
-            body: [i === nodes2.length - 1 ? child : new ReturnCommandNode(visitor.pack, [`run ${child.getValue()}`])]
-          });
+            body: [i === nodes2.length - 1 ? child : new ReturnRunCommandNode(visitor.pack, ["run"], {
+              isSingleExecute: false,
+              isFlowControl: true,
+              body: [child]
+            })],
+            macroStorage
+          }));
         }
       }
-      return new ExecuteCommandNode(visitor.pack, [[node.condition.getValue()]], {
+      return visitor.visit(new ExecuteCommandNode(visitor.pack, [[node.condition.getValue()]], {
         isSingleExecute: false,
         givenCallbackName: `${i}_${callbackName}`,
         body: [
           new ReturnRunCommandNode(visitor.pack, ["run"], {
             isSingleExecute: false,
+            isFlowControl: true,
             body: actualBody
           })
-        ]
-      });
+        ],
+        macroStorage
+      }));
     }
-    return body;
+    return body.flatMap((n) => visitor.visit(n));
   });
 }
 var IfElseTransformationVisitor;
@@ -9988,19 +10423,30 @@ var init_ifElseTransformationVisitor = __esm(() => {
         return [];
       }
       const nodes2 = Array.from(flattenIfNode(node_));
+      const { parentMCFunction, condition: condition2, givenCallbackName, body } = node_;
+      const callbackName = givenCallbackName ?? "if";
+      const macroStorage = parentMCFunction.resource.macroPoint;
       if (nodes2.length === 1) {
-        return this.visit(new ExecuteCommandNode(this.pack, [[node_.condition.getValue()]], {
+        const executeNode = new ExecuteCommandNode(this.pack, [[condition2.getValue()]], {
           isSingleExecute: false,
-          givenCallbackName: "if",
-          body: node_.body
-        }));
+          givenCallbackName: callbackName,
+          body,
+          macroStorage
+        });
+        node_.resultingExecuteNode = executeNode;
+        return this.visit(executeNode);
+      }
+      if (nodes2.at(-1) === parentMCFunction.body.at(-1)) {
+        return handleMultipleNodes(this, nodes2, macroStorage);
       }
       const wrapper = new ExecuteCommandNode(this.pack, [], {
         isFake: true,
         isSingleExecute: false,
-        givenCallbackName: "if",
-        body: handleMultipleNodes(this, nodes2)
+        givenCallbackName: callbackName,
+        body: handleMultipleNodes(this, nodes2, macroStorage),
+        macroStorage
       });
+      node_.resultingExecuteNode = wrapper;
       return this.visit(wrapper);
     };
   };
@@ -10009,19 +10455,15 @@ var init_ifElseTransformationVisitor = __esm(() => {
 // src/pack/visitors/initConstantsVisitor.ts
 var InitConstantsVisitor;
 var init_initConstantsVisitor = __esm(() => {
+  init_commands2();
   init_visitor();
   InitConstantsVisitor = class InitConstantsVisitor extends GenericSandstoneVisitor {
     onStart = () => {
       const { pack } = this;
-      const { scoreboard: scoreboard2 } = pack.commands;
-      let constants = [...pack.constants.values()];
-      constants = constants.filter((item2, index) => constants.indexOf(item2) === index);
-      if (constants.length !== 0) {
-        pack.initMCFunction.unshift(() => {
-          for (const constant of constants) {
-            scoreboard2.players.set(constant, pack.rootObjective, constant);
-          }
-        });
+      if (pack.constants.size !== 0) {
+        for (const constant of pack.constants) {
+          pack.initMCFunction.node.body.push(new ScoreboardCommandNode(pack, "players", "set", constant, pack.rootObjective, constant));
+        }
       }
     };
   };
@@ -10097,15 +10539,24 @@ var init_inlineFunctionCallVisitor = __esm(() => {
 // src/pack/visitors/loopTransformationVisitor.ts
 var LoopTransformationVisitor;
 var init_loopTransformationVisitor = __esm(() => {
-  init_commands2();
+  init_flow();
   init_visitor();
   LoopTransformationVisitor = class LoopTransformationVisitor extends GenericSandstoneVisitor {
+    currentLoopIfNode = null;
     visitLoopNode = (node_) => {
-      return new ExecuteCommandNode(this.pack, node_.executeArgs, {
-        isSingleExecute: false,
-        givenCallbackName: "loop",
-        body: node_.body.map((node) => this.genericVisit(node))
-      });
+      const ifNode = new IfNode(this.core, node_.condition, undefined, node_.parentMCFunction);
+      ifNode.givenCallbackName = "loop";
+      const previousLoopIfNode = this.currentLoopIfNode;
+      this.currentLoopIfNode = ifNode;
+      ifNode.body = node_.body.flatMap((node) => this.visit(node));
+      this.currentLoopIfNode = previousLoopIfNode;
+      return ifNode;
+    };
+    visitLoopArgument = (node_) => {
+      if (this.currentLoopIfNode) {
+        node_.loopIfNode = this.currentLoopIfNode;
+      }
+      return node_;
     };
     visitWhileNode = this.visitLoopNode;
     visitForINode = this.visitLoopNode;
@@ -10204,7 +10655,7 @@ var init_simplifyExecuteFunction = __esm(() => {
         return this.genericVisit(node);
       }
       const mcFunction = functionNode.args[0];
-      if (typeof mcFunction === "string") {
+      if (typeof mcFunction === "string" || !mcFunction?.node) {
         return this.genericVisit(node);
       }
       const mcFunctionNode = mcFunction.node;
@@ -10216,11 +10667,33 @@ var init_simplifyExecuteFunction = __esm(() => {
           return this.genericVisit(node);
         }
       }
+      if (command instanceof LoopArgument) {
+        const loopExecute = command.loopIfNode?.resultingExecuteNode;
+        const loopFunctionName = loopExecute?.createdMCFunction?.name;
+        if (loopFunctionName) {
+          node.body = [new FunctionCommandNode(this.pack, loopFunctionName)];
+          if (mcFunction.creator === "sandstone") {
+            this.core.resourceNodes.delete(mcFunctionNode);
+          }
+          return this.genericVisit(node);
+        }
+        return this.genericVisit(node);
+      }
       if (!(command instanceof CommandNode)) {
         return this.genericVisit(node);
       }
-      if (command instanceof LoopArgument) {
-        return new FunctionCommandNode(this.pack, mcFunctionNode.resource.name);
+      if (command instanceof ReturnRunCommandNode) {
+        if (mcFunction.creator === "sandstone") {
+          this.core.resourceNodes.delete(mcFunctionNode);
+        }
+        if (command.isFlowControl) {
+          node.body = [this.genericVisit(command)];
+        } else {
+          const returnCmd = this.visit(command);
+          node.body = returnCmd.body;
+          return this.visitExecuteCommandNode(node);
+        }
+        return this.genericVisit(node);
       }
       if (command instanceof FunctionCommandNode) {
         const innerMCFunction = command.args[0];
@@ -10263,17 +10736,24 @@ var init_simplifyReturnRunFunction = __esm(() => {
   init_nodes();
   init_flow();
   init_visitor();
+  init_Macro();
   SimplifyReturnRunFunctionVisitor = class SimplifyReturnRunFunctionVisitor extends GenericSandstoneVisitor {
     visitReturnRunCommandNode = (node) => {
       if (node.body.length === 0 || node.body.length > 1) {
         return this.genericVisit(node);
       }
-      const functionNode = node.body[0];
-      if (!(functionNode instanceof FunctionCommandNode)) {
+      const childNode = node.body[0];
+      if (!(childNode instanceof FunctionCommandNode)) {
+        if (childNode instanceof ReturnRunCommandNode) {
+          return this.visitReturnRunCommandNode(childNode);
+        }
+        if (childNode instanceof ReturnCommandNode) {
+          return this.genericVisit(childNode);
+        }
         return this.genericVisit(node);
       }
-      const mcFunction = functionNode.args[0];
-      if (typeof mcFunction === "string") {
+      const mcFunction = childNode.args[0];
+      if (typeof mcFunction === "string" || isMacroArgument(this.core, mcFunction)) {
         return this.genericVisit(node);
       }
       const mcFunctionNode = mcFunction.node;
@@ -10289,10 +10769,6 @@ var init_simplifyReturnRunFunction = __esm(() => {
         return this.genericVisit(node);
       }
       if (command instanceof FunctionCommandNode) {
-        const innerMCFunction = command.args[0];
-        if (typeof innerMCFunction === "string") {
-          return this.genericVisit(node);
-        }
         node.body = [command];
         if (mcFunction.creator === "sandstone") {
           this.core.resourceNodes.delete(mcFunctionNode);
@@ -10300,7 +10776,18 @@ var init_simplifyReturnRunFunction = __esm(() => {
         return this.genericVisit(node);
       }
       if (command instanceof ReturnRunCommandNode) {
-        return this.genericVisit(node);
+        node.body = command.body;
+        node.isFlowControl = node.isFlowControl || command.isFlowControl;
+        if (mcFunction.creator === "sandstone") {
+          this.core.resourceNodes.delete(mcFunctionNode);
+        }
+        return this.visitReturnRunCommandNode(node);
+      }
+      if (command instanceof ReturnCommandNode) {
+        if (mcFunction.creator === "sandstone") {
+          this.core.resourceNodes.delete(mcFunctionNode);
+        }
+        return this.genericVisit(command);
       }
       node.body = [this.genericVisit(command)];
       if (mcFunction.creator === "sandstone") {
@@ -10311,6 +10798,233 @@ var init_simplifyReturnRunFunction = __esm(() => {
   };
 });
 
+// src/pack/visitors/switchTransformationVisitor.ts
+var SwitchTransformationVisitor;
+var init_switchTransformationVisitor = __esm(() => {
+  init_commands2();
+  init_core();
+  init_flow();
+  init_variables();
+  init_visitor();
+  SwitchTransformationVisitor = class SwitchTransformationVisitor extends GenericSandstoneVisitor {
+    visitSwitchNode = (node) => {
+      const { value, staticCases, conditionCases, defaultCase, parentMCFunction } = node;
+      const { Data: Data2, initMCFunction, Macro: Macro2, commands: commands2 } = this.pack;
+      const { functionCmd } = commands2;
+      const parentName = parentMCFunction?.resource.name ?? "__sandstone:switch";
+      const hasStaticCases = staticCases.length > 0;
+      const switchMCFunction = new MCFunctionClass(this.core, `${parentName}/switch`, {
+        addToSandstoneCore: true,
+        creator: "sandstone",
+        onConflict: "rename"
+      }, hasStaticCases ? [value] : undefined);
+      const storageKey = `__sandstone:${switchMCFunction.name.replace(/[:/]/g, "_")}`;
+      const values = Data2("storage", storageKey, "Values");
+      if (hasStaticCases) {
+        const isScoreSwitch = value instanceof Score;
+        if (typeof value.local?.set === "function") {
+          value.local.set(switchMCFunction.name, "env_0");
+        }
+        this.core.enterMCFunction(switchMCFunction);
+        if (isScoreSwitch) {
+          for (const caseNode of staticCases) {
+            const caseMCFunction = new MCFunctionClass(this.core, `${switchMCFunction.name}/case_${caseNode.value}`, {
+              addToSandstoneCore: true,
+              creator: "sandstone",
+              onConflict: "rename"
+            });
+            caseMCFunction.node.body = caseNode.body.flatMap((n) => this.visit(n));
+          }
+          const hasFallback = conditionCases.length > 0 || defaultCase !== undefined;
+          if (hasFallback) {
+            const tryCaseMCFunction = new MCFunctionClass(this.core, `${switchMCFunction.name}/try_case`, {
+              addToSandstoneCore: true,
+              creator: "sandstone",
+              onConflict: "rename"
+            });
+            this.core.enterMCFunction(tryCaseMCFunction);
+            Macro2.returnCmd.run.functionCmd(Macro2`${switchMCFunction.name}/case_${value}`);
+            this.core.exitMCFunction();
+            const successScore = this.pack.rootObjective("$switch_success");
+            const resultScore = this.pack.rootObjective("$switch_result");
+            commands2.execute.store.success(successScore).store.result(resultScore).run.functionCmd(tryCaseMCFunction.name, "with", switchMCFunction.macroPoint);
+            commands2.execute.if.score(successScore, "matches", 1).run.returnCmd.run.scoreboard.players.get(resultScore);
+            this.buildFallback(undefined, value, conditionCases, defaultCase, switchMCFunction);
+          } else {
+            const dispatchMCFunction = new MCFunctionClass(this.core, `${switchMCFunction.name}/dispatch`, {
+              addToSandstoneCore: true,
+              creator: "sandstone",
+              onConflict: "rename"
+            });
+            this.core.enterMCFunction(dispatchMCFunction);
+            Macro2.returnCmd.run.functionCmd(Macro2`${switchMCFunction.name}/case_${value}`);
+            this.core.exitMCFunction();
+            commands2.returnCmd.run.functionCmd(dispatchMCFunction.name, "with", switchMCFunction.macroPoint);
+          }
+          const macroPoint = switchMCFunction.macroPoint;
+          const env0Point = macroPoint.select("env_0");
+          commands2.execute.store.result.storage(env0Point.currentTarget, env0Point.path, "int").run.scoreboard.players.get(value);
+          const copyNode = switchMCFunction.node.body.pop();
+          switchMCFunction.node.body.unshift(copyNode);
+          const canInline = parentMCFunction && node === parentMCFunction.body.at(-1);
+          if (canInline) {
+            this.core.exitMCFunction();
+            this.core.resourceNodes.delete(switchMCFunction.node);
+            return switchMCFunction.node.body;
+          }
+        } else {
+          const index = switchMCFunction.macroPoint.select("Index");
+          index.local.set(switchMCFunction.name, "Index");
+          index.remove();
+          Macro2.data.modify.storage(index.currentTarget, index.path).set.from.storage(values.currentTarget, Macro2`Values[{Value:${value}}].Index`);
+          const caseData = [];
+          for (let i = 0;i < staticCases.length; i++) {
+            const caseNode = staticCases[i];
+            const caseMCFunction = new MCFunctionClass(this.core, `${switchMCFunction.name}/case_${i}`, {
+              addToSandstoneCore: true,
+              creator: "sandstone",
+              onConflict: "rename"
+            });
+            caseMCFunction.node.body = caseNode.body.flatMap((n) => this.visit(n));
+            caseData.push({
+              Value: caseNode.value,
+              Index: NBT.int(i)
+            });
+          }
+          initMCFunction.push(() => values.set(caseData));
+          const innerMCFunction = new MCFunctionClass(this.core, `${switchMCFunction.name}/inner`, {
+            addToSandstoneCore: true,
+            creator: "sandstone",
+            onConflict: "rename"
+          });
+          this.core.enterMCFunction(innerMCFunction);
+          Macro2.returnCmd.run.functionCmd(Macro2`${switchMCFunction.name}/case_${index}`);
+          this.core.exitMCFunction();
+          const hasFallback = conditionCases.length > 0 || defaultCase !== undefined;
+          if (hasFallback) {
+            const ifNode = new IfNode(this.core, index._toMinecraftCondition(), undefined, switchMCFunction.node);
+            switchMCFunction.node.enterContext(ifNode, false);
+            functionCmd(innerMCFunction.name, "with", switchMCFunction.macroPoint);
+            switchMCFunction.node.exitContext();
+            switchMCFunction.node.body.push(ifNode);
+            this.buildFallback(ifNode, value, conditionCases, defaultCase, switchMCFunction);
+          } else {
+            this.pack.commands.execute.if.data.storage(index.currentTarget, index.path).run.returnCmd.run.functionCmd(innerMCFunction.name, "with", switchMCFunction.macroPoint);
+          }
+        }
+        this.core.exitMCFunction();
+      } else {
+        this.core.enterMCFunction(switchMCFunction);
+        this.buildFallback(undefined, value, conditionCases, defaultCase, switchMCFunction);
+        this.core.exitMCFunction();
+        const canInline = parentMCFunction && node === parentMCFunction.body.at(-1);
+        if (canInline) {
+          this.core.resourceNodes.delete(switchMCFunction.node);
+          for (const bodyNode of switchMCFunction.node.body) {
+            if (bodyNode instanceof IfNode) {
+              bodyNode.parentMCFunction = parentMCFunction;
+              let lastIfNode = bodyNode;
+              while (lastIfNode.nextFlowNode instanceof IfNode) {
+                lastIfNode.nextFlowNode.parentMCFunction = parentMCFunction;
+                lastIfNode = lastIfNode.nextFlowNode;
+              }
+              if (lastIfNode !== bodyNode) {
+                switchMCFunction.node.body.push(lastIfNode);
+              }
+            }
+          }
+          return switchMCFunction.node.body;
+        }
+      }
+      const isLastNode = parentMCFunction && node === parentMCFunction.body.at(-1);
+      if (hasStaticCases && !(value instanceof Score)) {
+        const macroPoint = switchMCFunction.macroPoint;
+        const resolvedValue = value instanceof DataPointPickClass ? value._toDataPoint() : value;
+        const env0Point = macroPoint.select("env_0");
+        const copyNode = new DataCommandNode(this.pack);
+        copyNode.args = [
+          "modify",
+          "storage",
+          env0Point.currentTarget,
+          env0Point.path,
+          "set",
+          "from",
+          resolvedValue.type,
+          resolvedValue.currentTarget,
+          resolvedValue.path
+        ];
+        const funcNode2 = new FunctionCommandNode(this.pack, switchMCFunction.name);
+        funcNode2.args.push("with", macroPoint.type, macroPoint.currentTarget, macroPoint.path);
+        if (isLastNode) {
+          const callNode = new ReturnRunCommandNode(this.pack, ["run"]);
+          callNode.body = [funcNode2];
+          return [copyNode, callNode].flatMap((n) => this.visit(n));
+        }
+        return [copyNode, funcNode2].flatMap((n) => this.visit(n));
+      }
+      const funcNode = new FunctionCommandNode(this.pack, switchMCFunction.name);
+      if (isLastNode) {
+        const callNode = new ReturnRunCommandNode(this.pack, ["run"]);
+        callNode.body = [funcNode];
+        return this.visit(callNode);
+      }
+      return this.visit(funcNode);
+    };
+    buildFallback(_if, value, conditionCases, defaultCase, switchMCFunction, targetBody) {
+      if (conditionCases.length === 0 && !defaultCase)
+        return;
+      const body = targetBody ?? switchMCFunction.node.body;
+      if (conditionCases.length > 0) {
+        const firstCondition = conditionCases[0].condition(value);
+        const firstConditionNode = conditionToNode(firstCondition);
+        let currentIfNode;
+        if (_if === undefined) {
+          currentIfNode = new IfNode(this.core, firstConditionNode, undefined, switchMCFunction.node);
+          currentIfNode.body = conditionCases[0].body.flatMap((n) => this.visit(n));
+          body.push(currentIfNode);
+        } else {
+          currentIfNode = new IfNode(this.core, firstConditionNode, undefined, switchMCFunction.node);
+          currentIfNode._isElseIf = true;
+          _if.nextFlowNode = currentIfNode;
+          currentIfNode.body = conditionCases[0].body.flatMap((n) => this.visit(n));
+        }
+        for (let i = 1;i < conditionCases.length; i++) {
+          const condition2 = conditionCases[i].condition(value);
+          const conditionNode = conditionToNode(condition2);
+          const nextIfNode = new IfNode(this.core, conditionNode, undefined, switchMCFunction.node);
+          nextIfNode._isElseIf = true;
+          currentIfNode.nextFlowNode = nextIfNode;
+          nextIfNode.body = conditionCases[i].body.flatMap((n) => this.visit(n));
+          currentIfNode = nextIfNode;
+        }
+        if (defaultCase) {
+          const elseNode = new ElseNode(this.core, () => {});
+          elseNode._body = defaultCase.body.flatMap((n) => this.visit(n));
+          currentIfNode.nextFlowNode = elseNode;
+        }
+      } else if (defaultCase) {
+        if (_if === undefined) {
+          const visitedNodes = defaultCase.body.flatMap((n) => this.visit(n));
+          body.push(...visitedNodes);
+        } else {
+          const elseNode = new ElseNode(this.core, () => {});
+          elseNode._body = defaultCase.body.flatMap((n) => this.visit(n));
+          _if.nextFlowNode = elseNode;
+        }
+      }
+    }
+    visitStaticCaseNode = (_node) => {
+      return [];
+    };
+    visitConditionCaseNode = (_node) => {
+      return [];
+    };
+    visitDefaultCaseNode = (_node) => {
+      return [];
+    };
+  };
+});
+
 // src/pack/visitors/unifyChainedExecutes.ts
 var UnifyChainedExecutesVisitor;
 var init_unifyChainedExecutes = __esm(() => {
@@ -10326,6 +11040,10 @@ var init_unifyChainedExecutes = __esm(() => {
         node.body = chainedCommand.body;
         node.args.push(...chainedCommand.args);
       }
+      const flattenedArgs = node.args.flat(1).filter((a) => a !== undefined && a !== null);
+      if (flattenedArgs.length === 0 && node.body.length === 1) {
+        return this.genericVisit(node.body[0]);
+      }
       return this.genericVisit(node);
     };
   };
@@ -10343,6 +11061,7 @@ var init_visitors2 = __esm(() => {
   init_orTransformationVisitor();
   init_simplifyExecuteFunction();
   init_simplifyReturnRunFunction();
+  init_switchTransformationVisitor();
   init_unifyChainedExecutes();
 });
 
@@ -10412,6 +11131,8 @@ class SandstonePack {
     this.__rootObjective = undefined;
     this.__initMCFunction = undefined;
     this.objectives.clear();
+    this.anonymousDataId = 0;
+    this.anonymousScoreId = 0;
     this.constants.clear();
     this.tickedLoops = {};
     this.dependencies.clear();
@@ -10474,7 +11195,7 @@ class SandstonePack {
     return [namespace, ...resourceFolders, ...fullPath];
   };
   get _() {
-    return new Flow(this.core);
+    return this.flow;
   }
   registerNewObjective = (objective) => {
     this.objectives.add(objective);
@@ -10513,7 +11234,7 @@ class SandstonePack {
       return this.Variable(undefined, name2).set(nbt2, scale);
     }
     const [initialValue, name] = args;
-    const anonymousScore = score2(`${name ?? "anon"}_${this.packUid}_${this.anonymousScoreId++}`);
+    const anonymousScore = score2(`${name ?? "anon"}_${this.packUid}${name === undefined ? `_${this.anonymousScoreId++}` : ""}`);
     if (initialValue === undefined) {
       return anonymousScore;
     }
@@ -10557,7 +11278,7 @@ class SandstonePack {
       return this.DataVariable(undefined, name2).set(score2, storeType || "int", scale || 1);
     }
     const [initialValue, name] = args;
-    const anonymousData = data2.select(`${name ?? "anon"}_${this.packUid}_${this.anonymousDataId++}`);
+    const anonymousData = data2.select(`${name ?? "anon"}_${this.packUid}${name === undefined ? `_${this.anonymousDataId++}` : ""}`);
     if (initialValue === undefined) {
       return anonymousData;
     }
@@ -10960,6 +11681,7 @@ class SandstonePack {
         new InitConstantsVisitor(this),
         new GenerateLazyMCFunction(this),
         new LoopTransformationVisitor(this),
+        new SwitchTransformationVisitor(this),
         new OrTransformationVisitor(this),
         new IfElseTransformationVisitor(this),
         new ContainerCommandsToMCFunctionVisitor(this),
@@ -11010,7 +11732,7 @@ var init_pack = __esm(() => {
     }
     handleOutput = async (type, readFile, writeFile) => {
       if (type === "output") {
-        await writeFile("pack.mcmeta", JSON.stringify(this.packMcmeta));
+        await writeFile("pack.mcmeta", JSON.stringify(this.packMcmeta, null, 2));
       }
     };
   };
@@ -11031,7 +11753,7 @@ var init_pack = __esm(() => {
     }
     handleOutput = async (type, readFile, writeFile) => {
       if (type === "output") {
-        await writeFile("pack.mcmeta", JSON.stringify(this.packMcmeta));
+        await writeFile("pack.mcmeta", JSON.stringify(this.packMcmeta, null, 2));
       }
     };
   };
@@ -11106,7 +11828,11 @@ var init_src = __esm(() => {
       return new Proxy(fn, {
         get(_target, subProp) {
           const method = sandstonePack[prop];
-          return method[subProp];
+          const value = method[subProp];
+          if (typeof value === "function") {
+            return value.bind(method);
+          }
+          return value;
         },
         apply(_target, _thisArg, args) {
           const method = sandstonePack[prop];