redscript-mc 1.2.26 → 1.2.28

package/dist/lowering/index.js

@@ -39,7 +39,8 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Lowering = void 0;
+exports.Lowering = exports.LOWERING_OBJ = void 0;
+exports.setScoreboardObjective = setScoreboardObjective;
 const builder_1 = require("../ir/builder");
 const diagnostics_1 = require("../diagnostics");
 const path = __importStar(require("path"));
@@ -54,6 +55,13 @@ const entity_hierarchy_1 = require("../types/entity-hierarchy");
 // All builtins support macro parameters - any arg that's a function param
 // will automatically use MC 1.20.2+ macro syntax when needed
 // ---------------------------------------------------------------------------
+// Scoreboard Objective
+// Set per-compilation via setScoreboardObjective() — defaults to 'rs'.
+// ---------------------------------------------------------------------------
+/** Current scoreboard objective. Set once per compile() call. */
+exports.LOWERING_OBJ = 'rs';
+function setScoreboardObjective(obj) { exports.LOWERING_OBJ = obj; }
+// ---------------------------------------------------------------------------
 // Builtin Functions
 // ---------------------------------------------------------------------------
 const BUILTINS = {
@@ -73,9 +81,13 @@ const BUILTINS = {
         const pos = [x ?? '~', y ?? '~', z ?? '~'].join(' ');
         return nbt ? `summon ${type} ${pos} ${nbt}` : `summon ${type} ${pos}`;
     },
-    particle: ([name, x, y, z]) => {
+    particle: ([name, x, y, z, dx, dy, dz, speed, count]) => {
         const pos = [x ?? '~', y ?? '~', z ?? '~'].join(' ');
-        return `particle ${name} ${pos}`;
+        // dx/dy/dz/speed/count are optional; omit trailing undefineds
+        const extra = [dx, dy, dz, speed, count].filter(v => v !== undefined && v !== null);
+        return extra.length > 0
+            ? `particle ${name} ${pos} ${extra.join(' ')}`
+            : `particle ${name} ${pos}`;
     },
     playsound: ([sound, source, sel, x, y, z, volume, pitch, minVolume]) => ['playsound', sound, source, sel, x, y, z, volume, pitch, minVolume].filter(Boolean).join(' '),
     tp: () => null, // Special handling
@@ -130,6 +142,7 @@ const BUILTINS = {
     clearInterval: () => null, // Special handling
     storage_get_int: () => null, // Special handling (dynamic NBT array read via macro)
     storage_set_array: () => null, // Special handling (write literal NBT array to storage)
+    storage_set_int: () => null, // Special handling (dynamic NBT array write via macro)
 };
 function getSpan(node) {
     return node?.span;
@@ -339,12 +352,30 @@ class Lowering {
     }
     preScanExpr(expr, paramNames, macroParams) {
         if (expr.kind === 'call' && BUILTINS[expr.fn] !== undefined) {
-            // All ident args to macro-aware builtins that are params → macro params
-            for (const arg of expr.args) {
-                if (arg.kind === 'ident' && paramNames.has(arg.name)) {
-                    macroParams.add(arg.name);
+            // Only trigger macro param detection for builtins that actually emit
+            // MC commands with $(param) inline in the current function body.
+            // Special-handled builtins (storage_get_int / storage_set_int / etc.) are
+            // declared as `() => null` — they create their own sub-functions for macro
+            // indirection and do NOT require the surrounding function to be a macro.
+            const handler = BUILTINS[expr.fn];
+            const isSpecialHandled = (() => {
+                try {
+                    return handler() === null;
+                }
+                catch {
+                    return false;
+                }
+            })();
+            if (!isSpecialHandled) {
+                for (const arg of expr.args) {
+                    if (arg.kind === 'ident' && paramNames.has(arg.name)) {
+                        macroParams.add(arg.name);
+                    }
                 }
             }
+            // Always recurse into args for nested calls/expressions
+            for (const arg of expr.args)
+                this.preScanExpr(arg, paramNames, macroParams);
             return;
         }
         // Recurse into sub-expressions for other call types
@@ -434,6 +465,16 @@ class Lowering {
         if (expr.kind === 'struct_lit' || expr.kind === 'array_lit') {
             return { str: this.exprToSnbt(expr) };
         }
+        // Float literals: preserve the float value for MC commands that accept floats
+        // (particle spread, playsound volume/pitch, etc.)
+        // We do NOT truncate here — that only applies to scoreboard/IR contexts.
+        if (expr.kind === 'float_lit') {
+            return { str: expr.value.toString() };
+        }
+        // Unary minus applied to a float literal (e.g. -0.5)
+        if (expr.kind === 'unary' && expr.op === '-' && expr.operand.kind === 'float_lit') {
+            return { str: (-expr.operand.value).toString() };
+        }
         return { str: this.exprToString(expr) };
     }
     /**
@@ -447,10 +488,10 @@ class Lowering {
         for (let i = 0; i < loweredArgs.length; i++) {
             const operand = loweredArgs[i];
             if (operand.kind === 'const') {
-                this.builder.emitRaw(`scoreboard players set $p${i} rs ${operand.value}`);
+                this.builder.emitRaw(`scoreboard players set $p${i} ${exports.LOWERING_OBJ} ${operand.value}`);
             }
             else if (operand.kind === 'var') {
-                this.builder.emitRaw(`scoreboard players operation $p${i} rs = ${operand.name} rs`);
+                this.builder.emitRaw(`scoreboard players operation $p${i} ${exports.LOWERING_OBJ} = ${operand.name} ${exports.LOWERING_OBJ}`);
             }
         }
         // Set up NBT storage for each macro param
@@ -463,14 +504,14 @@ class Lowering {
                 this.builder.emitRaw(`data modify storage rs:macro_args ${macroParam} set value ${operand.value}`);
             }
             else if (operand.kind === 'var') {
-                this.builder.emitRaw(`execute store result storage rs:macro_args ${macroParam} int 1 run scoreboard players get ${operand.name} rs`);
+                this.builder.emitRaw(`execute store result storage rs:macro_args ${macroParam} int 1 run scoreboard players get ${operand.name} ${exports.LOWERING_OBJ}`);
             }
         }
         // Call with macro storage
         this.builder.emitRaw(`function ${this.namespace}:${fnName} with storage rs:macro_args`);
         // Copy return value (callers may use it)
         const dst = this.builder.freshTemp();
-        this.builder.emitRaw(`scoreboard players operation ${dst} rs = $ret rs`);
+        this.builder.emitRaw(`scoreboard players operation ${dst} ${exports.LOWERING_OBJ} = $ret ${exports.LOWERING_OBJ}`);
         return { kind: 'var', name: dst };
     }
     lower(program) {
@@ -704,7 +745,7 @@ class Lowering {
         const originalInstrs = [...entry.instrs];
         const originalTerm = entry.term;
         entry.instrs = [
-            { op: 'raw', cmd: `scoreboard players add ${counterVar} rs 1` },
+            { op: 'raw', cmd: `scoreboard players add ${counterVar} ${exports.LOWERING_OBJ} 1` },
         ];
         // Create conditional jump
         const bodyLabel = 'tick_body';
@@ -718,13 +759,13 @@ class Lowering {
         // Add check instruction
         entry.instrs.push({
             op: 'raw',
-            cmd: `execute store success score ${counterVar}_check rs if score ${counterVar} rs matches ${rate}..`,
+            cmd: `execute store success score ${counterVar}_check ${exports.LOWERING_OBJ} if score ${counterVar} ${exports.LOWERING_OBJ} matches ${rate}..`,
         });
         // Body block (original logic + counter reset)
         fn.blocks.push({
             label: bodyLabel,
             instrs: [
-                { op: 'raw', cmd: `scoreboard players set ${counterVar} rs 0` },
+                { op: 'raw', cmd: `scoreboard players set ${counterVar} ${exports.LOWERING_OBJ} 0` },
                 ...originalInstrs,
             ],
             term: originalTerm,
@@ -838,7 +879,7 @@ class Lowering {
                 }
                 else if (fieldValue.kind === 'var') {
                     // Copy from scoreboard to NBT
-                    this.builder.emitRaw(`execute store result storage ${path} int 1 run scoreboard players get ${fieldValue.name} rs`);
+                    this.builder.emitRaw(`execute store result storage ${path} int 1 run scoreboard players get ${fieldValue.name} ${exports.LOWERING_OBJ}`);
                 }
             }
             return;
@@ -871,7 +912,7 @@ class Lowering {
                 }
                 else if (elemValue.kind === 'var') {
                     this.builder.emitRaw(`data modify storage rs:heap ${stmt.name} append value 0`);
-                    this.builder.emitRaw(`execute store result storage rs:heap ${stmt.name}[-1] int 1 run scoreboard players get ${elemValue.name} rs`);
+                    this.builder.emitRaw(`execute store result storage rs:heap ${stmt.name}[-1] int 1 run scoreboard players get ${elemValue.name} ${exports.LOWERING_OBJ}`);
                 }
             }
             return;
@@ -917,7 +958,7 @@ class Lowering {
                         this.builder.emitRaw(`data modify storage ${path} set value ${fieldValue.value}`);
                     }
                     else if (fieldValue.kind === 'var') {
-                        this.builder.emitRaw(`execute store result storage ${path} int 1 run scoreboard players get ${fieldValue.name} rs`);
+                        this.builder.emitRaw(`execute store result storage ${path} int 1 run scoreboard players get ${fieldValue.name} ${exports.LOWERING_OBJ}`);
                     }
                 }
                 this.builder.emitReturn({ kind: 'const', value: 0 });
@@ -1084,10 +1125,10 @@ class Lowering {
         this.varMap.set(stmt.varName, loopVar);
         const startVal = this.lowerExpr(stmt.start);
         if (startVal.kind === 'const') {
-            this.builder.emitRaw(`scoreboard players set ${loopVar} rs ${startVal.value}`);
+            this.builder.emitRaw(`scoreboard players set ${loopVar} ${exports.LOWERING_OBJ} ${startVal.value}`);
         }
         else if (startVal.kind === 'var') {
-            this.builder.emitRaw(`scoreboard players operation ${loopVar} rs = ${startVal.name} rs`);
+            this.builder.emitRaw(`scoreboard players operation ${loopVar} ${exports.LOWERING_OBJ} = ${startVal.name} ${exports.LOWERING_OBJ}`);
         }
         // Call loop function
         this.builder.emitRaw(`function ${this.namespace}:${subFnName}`);
@@ -1104,11 +1145,11 @@ class Lowering {
         // Body
         this.lowerBlock(stmt.body);
         // Increment
-        this.builder.emitRaw(`scoreboard players add ${loopVar} rs 1`);
+        this.builder.emitRaw(`scoreboard players add ${loopVar} ${exports.LOWERING_OBJ} 1`);
         // Loop condition: execute if score matches ..<end-1> run function
         const endVal = this.lowerExpr(stmt.end);
         const endNum = endVal.kind === 'const' ? endVal.value - 1 : '?';
-        this.builder.emitRaw(`execute if score ${loopVar} rs matches ..${endNum} run function ${this.namespace}:${subFnName}`);
+        this.builder.emitRaw(`execute if score ${loopVar} ${exports.LOWERING_OBJ} matches ..${endNum} run function ${this.namespace}:${subFnName}`);
         if (!this.builder.isBlockSealed()) {
             this.builder.emitReturn();
         }
@@ -1198,12 +1239,12 @@ class Lowering {
                 matchCondition = String(patternValue.value);
             }
             const subFnName = `${this.currentFn}/match_${this.foreachCounter++}`;
-            this.builder.emitRaw(`execute if score ${matchedVar} rs matches ..0 if score ${subject} rs matches ${matchCondition} run function ${this.namespace}:${subFnName}`);
+            this.builder.emitRaw(`execute if score ${matchedVar} ${exports.LOWERING_OBJ} matches ..0 if score ${subject} ${exports.LOWERING_OBJ} matches ${matchCondition} run function ${this.namespace}:${subFnName}`);
             this.emitMatchArmSubFunction(subFnName, matchedVar, arm.body, true);
         }
         if (defaultArm) {
             const subFnName = `${this.currentFn}/match_${this.foreachCounter++}`;
-            this.builder.emitRaw(`execute if score ${matchedVar} rs matches ..0 run function ${this.namespace}:${subFnName}`);
+            this.builder.emitRaw(`execute if score ${matchedVar} ${exports.LOWERING_OBJ} matches ..0 run function ${this.namespace}:${subFnName}`);
             this.emitMatchArmSubFunction(subFnName, matchedVar, defaultArm.body, false);
         }
     }
@@ -1218,7 +1259,7 @@ class Lowering {
         this.blockPosVars = new Map(savedBlockPosVars);
         this.builder.startBlock('entry');
         if (setMatched) {
-            this.builder.emitRaw(`scoreboard players set ${matchedVar} rs 1`);
+            this.builder.emitRaw(`scoreboard players set ${matchedVar} ${exports.LOWERING_OBJ} 1`);
         }
         this.lowerBlock(body);
         if (!this.builder.isBlockSealed()) {
@@ -1250,7 +1291,7 @@ class Lowering {
         }
         this.builder.emitAssign(indexVar, { kind: 'const', value: 0 });
         this.builder.emitAssign(oneVar, { kind: 'const', value: 1 });
-        this.builder.emitRaw(`execute store result score ${lengthVar} rs run data get storage rs:heap ${arrayName}`);
+        this.builder.emitRaw(`execute store result score ${lengthVar} ${exports.LOWERING_OBJ} run data get storage rs:heap ${arrayName}`);
         const checkLabel = this.builder.freshLabel('foreach_array_check');
         const bodyLabel = this.builder.freshLabel('foreach_array_body');
         const exitLabel = this.builder.freshLabel('foreach_array_exit');
@@ -1263,7 +1304,7 @@ class Lowering {
         this.builder.emitAssign(bindingVar, element);
         this.lowerBlock(stmt.body);
         if (!this.builder.isBlockSealed()) {
-            this.builder.emitRaw(`scoreboard players operation ${indexVar} rs += ${oneVar} rs`);
+            this.builder.emitRaw(`scoreboard players operation ${indexVar} ${exports.LOWERING_OBJ} += ${oneVar} ${exports.LOWERING_OBJ}`);
             this.builder.emitJump(checkLabel);
         }
         this.builder.startBlock(exitLabel);
@@ -1577,7 +1618,7 @@ class Lowering {
             if (mapped && mapped.startsWith('@e[tag=__rs_obj_')) {
                 // World object field access → scoreboard get
                 const dst = this.builder.freshTemp();
-                this.builder.emitRaw(`scoreboard players operation ${dst} rs = ${mapped} rs`);
+                this.builder.emitRaw(`scoreboard players operation ${dst} ${exports.LOWERING_OBJ} = ${mapped} ${exports.LOWERING_OBJ}`);
                 return { kind: 'var', name: dst };
             }
             if (varType?.kind === 'struct') {
@@ -1585,13 +1626,13 @@ class Lowering {
                 const path = `rs:heap ${structName}_${expr.obj.name}.${expr.field}`;
                 const dst = this.builder.freshTemp();
                 // Read from NBT storage into scoreboard
-                this.builder.emitRaw(`execute store result score ${dst} rs run data get storage ${path}`);
+                this.builder.emitRaw(`execute store result score ${dst} ${exports.LOWERING_OBJ} run data get storage ${path}`);
                 return { kind: 'var', name: dst };
             }
             // Array length property
             if (varType?.kind === 'array' && expr.field === 'len') {
                 const dst = this.builder.freshTemp();
-                this.builder.emitRaw(`execute store result score ${dst} rs run data get storage rs:heap ${expr.obj.name}`);
+                this.builder.emitRaw(`execute store result score ${dst} ${exports.LOWERING_OBJ} run data get storage rs:heap ${expr.obj.name}`);
                 return { kind: 'var', name: dst };
             }
         }
@@ -1607,10 +1648,10 @@ class Lowering {
                 const value = this.lowerExpr(expr.value);
                 if (expr.op === '=') {
                     if (value.kind === 'const') {
-                        this.builder.emitRaw(`scoreboard players set ${mapped} rs ${value.value}`);
+                        this.builder.emitRaw(`scoreboard players set ${mapped} ${exports.LOWERING_OBJ} ${value.value}`);
                     }
                     else if (value.kind === 'var') {
-                        this.builder.emitRaw(`scoreboard players operation ${mapped} rs = ${value.name} rs`);
+                        this.builder.emitRaw(`scoreboard players operation ${mapped} ${exports.LOWERING_OBJ} = ${value.name} ${exports.LOWERING_OBJ}`);
                     }
                 }
                 else {
@@ -1620,10 +1661,10 @@ class Lowering {
                     if (value.kind === 'const') {
                         const constTemp = this.builder.freshTemp();
                         this.builder.emitAssign(constTemp, value);
-                        this.builder.emitRaw(`scoreboard players operation ${mapped} rs ${opMap[binOp]} ${constTemp} rs`);
+                        this.builder.emitRaw(`scoreboard players operation ${mapped} ${exports.LOWERING_OBJ} ${opMap[binOp]} ${constTemp} ${exports.LOWERING_OBJ}`);
                     }
                     else if (value.kind === 'var') {
-                        this.builder.emitRaw(`scoreboard players operation ${mapped} rs ${opMap[binOp]} ${value.name} rs`);
+                        this.builder.emitRaw(`scoreboard players operation ${mapped} ${exports.LOWERING_OBJ} ${opMap[binOp]} ${value.name} ${exports.LOWERING_OBJ}`);
                     }
                 }
                 return { kind: 'const', value: 0 };
@@ -1637,16 +1678,16 @@ class Lowering {
                         this.builder.emitRaw(`data modify storage ${path} set value ${value.value}`);
                     }
                     else if (value.kind === 'var') {
-                        this.builder.emitRaw(`execute store result storage ${path} int 1 run scoreboard players get ${value.name} rs`);
+                        this.builder.emitRaw(`execute store result storage ${path} int 1 run scoreboard players get ${value.name} ${exports.LOWERING_OBJ}`);
                     }
                 }
                 else {
                     // Compound assignment: read, modify, write back
                     const dst = this.builder.freshTemp();
-                    this.builder.emitRaw(`execute store result score ${dst} rs run data get storage ${path}`);
+                    this.builder.emitRaw(`execute store result score ${dst} ${exports.LOWERING_OBJ} run data get storage ${path}`);
                     const binOp = expr.op.slice(0, -1);
                     this.builder.emitBinop(dst, { kind: 'var', name: dst }, binOp, value);
-                    this.builder.emitRaw(`execute store result storage ${path} int 1 run scoreboard players get ${dst} rs`);
+                    this.builder.emitRaw(`execute store result storage ${path} int 1 run scoreboard players get ${dst} ${exports.LOWERING_OBJ}`);
                 }
                 return { kind: 'const', value: 0 };
             }
@@ -1675,14 +1716,14 @@ class Lowering {
                 this.builder.emitAssign(dst, left);
                 const rightVar = this.operandToVar(right);
                 // dst = dst && right → if dst != 0 then dst = right
-                this.builder.emitRaw(`execute if score ${dst} rs matches 1.. run scoreboard players operation ${dst} rs = ${rightVar} rs`);
+                this.builder.emitRaw(`execute if score ${dst} ${exports.LOWERING_OBJ} matches 1.. run scoreboard players operation ${dst} ${exports.LOWERING_OBJ} = ${rightVar} ${exports.LOWERING_OBJ}`);
             }
             else {
                 // Short-circuit OR
                 this.builder.emitAssign(dst, left);
                 const rightVar = this.operandToVar(right);
                 // dst = dst || right → if dst == 0 then dst = right
-                this.builder.emitRaw(`execute if score ${dst} rs matches ..0 run scoreboard players operation ${dst} rs = ${rightVar} rs`);
+                this.builder.emitRaw(`execute if score ${dst} ${exports.LOWERING_OBJ} matches ..0 run scoreboard players operation ${dst} ${exports.LOWERING_OBJ} = ${rightVar} ${exports.LOWERING_OBJ}`);
             }
             return { kind: 'var', name: dst };
         }
@@ -1700,16 +1741,16 @@ class Lowering {
                     // Divide by 1000 to correct for double scaling
                     const constDiv = this.builder.freshTemp();
                     this.builder.emitAssign(constDiv, { kind: 'const', value: 1000 });
-                    this.builder.emitRaw(`scoreboard players operation ${dst} rs /= ${constDiv} rs`);
+                    this.builder.emitRaw(`scoreboard players operation ${dst} ${exports.LOWERING_OBJ} /= ${constDiv} ${exports.LOWERING_OBJ}`);
                 }
                 else {
                     // Division: a * 1000 / b
                     const constMul = this.builder.freshTemp();
                     this.builder.emitAssign(constMul, { kind: 'const', value: 1000 });
                     this.builder.emitAssign(dst, left);
-                    this.builder.emitRaw(`scoreboard players operation ${dst} rs *= ${constMul} rs`);
+                    this.builder.emitRaw(`scoreboard players operation ${dst} ${exports.LOWERING_OBJ} *= ${constMul} ${exports.LOWERING_OBJ}`);
                     const rightVar = this.operandToVar(right);
-                    this.builder.emitRaw(`scoreboard players operation ${dst} rs /= ${rightVar} rs`);
+                    this.builder.emitRaw(`scoreboard players operation ${dst} ${exports.LOWERING_OBJ} /= ${rightVar} ${exports.LOWERING_OBJ}`);
                 }
                 return { kind: 'var', name: dst };
             }
@@ -1779,7 +1820,7 @@ class Lowering {
             const storagePath = this.getStringStoragePath(expr.args[0]);
             if (storagePath) {
                 const dst = this.builder.freshTemp();
-                this.builder.emitRaw(`execute store result score ${dst} rs run data get storage ${storagePath}`);
+                this.builder.emitRaw(`execute store result score ${dst} ${exports.LOWERING_OBJ} run data get storage ${storagePath}`);
                 return { kind: 'var', name: dst };
             }
             const staticString = this.resolveStaticString(expr.args[0]);
@@ -1813,7 +1854,7 @@ class Lowering {
             const entity = this.exprToString(expr.args[0]);
             const tagName = this.exprToString(expr.args[1]);
             const dst = this.builder.freshTemp();
-            this.builder.emitRaw(`execute store result score ${dst} rs if entity ${entity}[tag=${tagName}]`);
+            this.builder.emitRaw(`execute store result score ${dst} ${exports.LOWERING_OBJ} if entity ${entity}[tag=${tagName}]`);
             return { kind: 'var', name: dst };
         }
         // Handle array push
@@ -1828,7 +1869,7 @@ class Lowering {
                 }
                 else if (value.kind === 'var') {
                     this.builder.emitRaw(`data modify storage rs:heap ${arrName} append value 0`);
-                    this.builder.emitRaw(`execute store result storage rs:heap ${arrName}[-1] int 1 run scoreboard players get ${value.name} rs`);
+                    this.builder.emitRaw(`execute store result storage rs:heap ${arrName}[-1] int 1 run scoreboard players get ${value.name} ${exports.LOWERING_OBJ}`);
                 }
             }
             return { kind: 'const', value: 0 };
@@ -1837,7 +1878,7 @@ class Lowering {
             const arrName = this.getArrayStorageName(expr.args[0]);
             const dst = this.builder.freshTemp();
             if (arrName) {
-                this.builder.emitRaw(`execute store result score ${dst} rs run data get storage rs:heap ${arrName}[-1]`);
+                this.builder.emitRaw(`execute store result score ${dst} ${exports.LOWERING_OBJ} run data get storage rs:heap ${arrName}[-1]`);
                 this.builder.emitRaw(`data remove storage rs:heap ${arrName}[-1]`);
             }
             else {
@@ -2101,7 +2142,7 @@ class Lowering {
             const dst = this.builder.freshTemp();
             const min = args[0] ? this.exprToLiteral(args[0]) : '0';
             const max = args[1] ? this.exprToLiteral(args[1]) : '100';
-            this.builder.emitRaw(`scoreboard players random ${dst} rs ${min} ${max}`);
+            this.builder.emitRaw(`scoreboard players random ${dst} ${exports.LOWERING_OBJ} ${min} ${max}`);
             return { kind: 'var', name: dst };
         }
         // Special case: random_native - /random value (MC 1.20.3+)
@@ -2109,7 +2150,7 @@ class Lowering {
             const dst = this.builder.freshTemp();
             const min = args[0] ? this.exprToLiteral(args[0]) : '0';
             const max = args[1] ? this.exprToLiteral(args[1]) : '100';
-            this.builder.emitRaw(`execute store result score ${dst} rs run random value ${min} ${max}`);
+            this.builder.emitRaw(`execute store result score ${dst} ${exports.LOWERING_OBJ} run random value ${min} ${max}`);
             return { kind: 'var', name: dst };
         }
         // Special case: random_sequence - /random reset (MC 1.20.3+)
@@ -2124,7 +2165,7 @@ class Lowering {
             const dst = this.builder.freshTemp();
             const player = this.exprToTargetString(args[0]);
             const objective = this.resolveScoreboardObjective(args[0], args[1], callSpan);
-            this.builder.emitRaw(`execute store result score ${dst} rs run scoreboard players get ${player} ${objective}`);
+            this.builder.emitRaw(`execute store result score ${dst} ${exports.LOWERING_OBJ} run scoreboard players get ${player} ${objective}`);
             return { kind: 'var', name: dst };
         }
         // Special case: scoreboard_set — write to vanilla MC scoreboard
@@ -2138,7 +2179,7 @@ class Lowering {
             else if (value.kind === 'var') {
                 // Read directly from the computed scoreboard temp. Routing through a fresh
                 // temp here breaks once optimization removes the apparently-dead assign.
-                this.builder.emitRaw(`execute store result score ${player} ${objective} run scoreboard players get ${value.name} rs`);
+                this.builder.emitRaw(`execute store result score ${player} ${objective} run scoreboard players get ${value.name} ${exports.LOWERING_OBJ}`);
             }
             return { kind: 'const', value: 0 };
         }
@@ -2201,7 +2242,7 @@ class Lowering {
         }
         if (name === 'bossbar_get_value') {
             const dst = this.builder.freshTemp();
-            this.builder.emitRaw(`execute store result score ${dst} rs run bossbar get ${this.exprToString(args[0])} value`);
+            this.builder.emitRaw(`execute store result score ${dst} ${exports.LOWERING_OBJ} run bossbar get ${this.exprToString(args[0])} value`);
             return { kind: 'var', name: dst };
         }
         if (name === 'team_add') {
@@ -2242,7 +2283,7 @@ class Lowering {
                 : this.exprToString(args[1]);
             const path = this.exprToString(args[2]);
             const scale = args[3] ? this.exprToString(args[3]) : '1';
-            this.builder.emitRaw(`execute store result score ${dst} rs run data get ${targetType} ${target} ${path} ${scale}`);
+            this.builder.emitRaw(`execute store result score ${dst} ${exports.LOWERING_OBJ} run data get ${targetType} ${target} ${path} ${scale}`);
             return { kind: 'var', name: dst };
         }
         // storage_get_int(storage_ns, array_key, index) -> int
@@ -2251,7 +2292,7 @@ class Lowering {
         //   array_key  : e.g. "sin"
         //   index      : integer index (const or runtime)
         //
-        // Const index: execute store result score $dst rs run data get storage math:tables sin[N] 1
+        // Const index: execute store result score $dst ${LOWERING_OBJ} run data get storage math:tables sin[N] 1
         // Runtime index: macro sub-function via rs:heap, mirrors readArrayElement.
         if (name === 'storage_get_int') {
             const storageNs = this.exprToString(args[0]); // "math:tables"
@@ -2259,7 +2300,7 @@ class Lowering {
             const indexOperand = this.lowerExpr(args[2]);
             const dst = this.builder.freshTemp();
             if (indexOperand.kind === 'const') {
-                this.builder.emitRaw(`execute store result score ${dst} rs run data get storage ${storageNs} ${arrayKey}[${indexOperand.value}] 1`);
+                this.builder.emitRaw(`execute store result score ${dst} ${exports.LOWERING_OBJ} run data get storage ${storageNs} ${arrayKey}[${indexOperand.value}] 1`);
             }
             else {
                 // Runtime index: store the index into rs:heap under a unique key,
@@ -2269,13 +2310,13 @@ class Lowering {
                 const indexVar = indexOperand.kind === 'var'
                     ? indexOperand.name
                     : this.operandToVar(indexOperand);
-                this.builder.emitRaw(`execute store result storage rs:heap ${macroKey} int 1 run scoreboard players get ${indexVar} rs`);
+                this.builder.emitRaw(`execute store result storage rs:heap ${macroKey} int 1 run scoreboard players get ${indexVar} ${exports.LOWERING_OBJ}`);
                 this.builder.emitRaw(`function ${this.namespace}:${subFnName} with storage rs:heap`);
                 // Prefix \x01 is a sentinel for the MC macro '$' line-start marker.
                 // We avoid using literal '$execute' here so the pre-alloc pass
                 // doesn't mistakenly register 'execute' as a scoreboard variable.
                 // Codegen replaces \x01 → '$' when emitting the mc function file.
-                this.emitRawSubFunction(subFnName, `\x01execute store result score ${dst} rs run data get storage ${storageNs} ${arrayKey}[$(${macroKey})] 1`);
+                this.emitRawSubFunction(subFnName, `\x01execute store result score ${dst} ${exports.LOWERING_OBJ} run data get storage ${storageNs} ${arrayKey}[$(${macroKey})] 1`);
             }
             return { kind: 'var', name: dst };
         }
@@ -2289,6 +2330,54 @@ class Lowering {
             this.builder.emitRaw(`data modify storage ${storageNs} ${arrayKey} set value ${nbtLiteral}`);
             return { kind: 'const', value: 0 };
         }
+        // storage_set_int(storage_ns, array_key, index, value) -> void
+        // Writes one integer element into an NBT int-array stored in data storage.
+        //   storage_ns : e.g. "rs:bigint"
+        //   array_key  : e.g. "a"
+        //   index      : element index (const or runtime)
+        //   value      : integer value to write (const or runtime)
+        //
+        // Const index + const value:
+        //   execute store result storage <ns> <key>[N] int 1 run scoreboard players set $const_V ${LOWERING_OBJ} V
+        // Runtime index or value: macro sub-function via rs:heap
+        if (name === 'storage_set_int') {
+            const storageNs = this.exprToString(args[0]);
+            const arrayKey = this.exprToString(args[1]);
+            const indexOperand = this.lowerExpr(args[2]);
+            const valueOperand = this.lowerExpr(args[3]);
+            if (indexOperand.kind === 'const') {
+                // Static index — use execute store result to write to the fixed slot
+                const valVar = valueOperand.kind === 'var'
+                    ? valueOperand.name
+                    : this.operandToVar(valueOperand);
+                this.builder.emitRaw(`execute store result storage ${storageNs} ${arrayKey}[${indexOperand.value}] int 1 run scoreboard players get ${valVar} ${exports.LOWERING_OBJ}`);
+            }
+            else {
+                // Runtime index: we need a macro sub-function.
+                // Store index + value into rs:heap, call macro that does:
+                //   $data modify storage <ns> <key>[$(idx_key)] set value $(val_key)
+                const macroIdxKey = `__ssi_i_${this.foreachCounter++}`;
+                const macroValKey = `__ssi_v_${this.foreachCounter++}`; // kept to pin valVar in optimizer
+                const subFnName = `${this.currentFn}/__ssi_${this.foreachCounter++}`;
+                const indexVar = indexOperand.kind === 'var'
+                    ? indexOperand.name
+                    : this.operandToVar(indexOperand);
+                const valVar = valueOperand.kind === 'var'
+                    ? valueOperand.name
+                    : this.operandToVar(valueOperand);
+                this.builder.emitRaw(`execute store result storage rs:heap ${macroIdxKey} int 1 run scoreboard players get ${indexVar} ${exports.LOWERING_OBJ}`);
+                // Pin valVar in the optimizer's read-set so the assignment is not dead-code-eliminated.
+                // The value is stored to rs:heap but NOT used by the macro (the macro reads the scoreboard
+                // slot directly to avoid the MC 'data modify set value $(n)' macro substitution bug).
+                this.builder.emitRaw(`execute store result storage rs:heap ${macroValKey} int 1 run scoreboard players get ${valVar} ${exports.LOWERING_OBJ}`);
+                this.builder.emitRaw(`function ${this.namespace}:${subFnName} with storage rs:heap`);
+                // Use execute store result (not 'data modify set value $(val)') to avoid MC macro
+                // substitution bugs with numeric values. The scoreboard slot ${valVar} is hardcoded
+                // into the macro sub-function at compile time — only the array index is macro-substituted.
+                this.emitRawSubFunction(subFnName, `\x01execute store result storage ${storageNs} ${arrayKey}[$(${macroIdxKey})] int 1 run scoreboard players get ${valVar} ${exports.LOWERING_OBJ}`);
+            }
+            return { kind: 'const', value: 0 };
+        }
         // data_merge(target, nbt) — merge NBT into entity/block/storage
         // data_merge(@s, { Invisible: 1b, Silent: 1b })
         if (name === 'data_merge') {
@@ -2331,7 +2420,7 @@ class Lowering {
             const dst = this.builder.freshTemp();
             const setId = this.exprToString(args[0]);
             const value = this.exprToString(args[1]);
-            this.builder.emitRaw(`execute store result score ${dst} rs if data storage rs:sets ${setId}[{value:${value}}]`);
+            this.builder.emitRaw(`execute store result score ${dst} ${exports.LOWERING_OBJ} if data storage rs:sets ${setId}[{value:${value}}]`);
             return { kind: 'var', name: dst };
         }
         if (name === 'set_remove') {
@@ -2596,7 +2685,7 @@ class Lowering {
             components.push({ text: operand.value.toString() });
             return;
         }
-        components.push({ score: { name: this.operandToVar(operand), objective: 'rs' } });
+        components.push({ score: { name: this.operandToVar(operand), objective: exports.LOWERING_OBJ } });
     }
     exprToString(expr) {
         switch (expr.kind) {
@@ -2749,11 +2838,19 @@ class Lowering {
     }
     exprToScoreboardObjective(expr, span) {
         if (expr.kind === 'mc_name') {
-            return expr.value;
+            // 'rs' is the canonical token for the current RS scoreboard objective.
+            // Resolve to LOWERING_OBJ so it respects --scoreboard / namespace default.
+            return expr.value === 'rs' ? exports.LOWERING_OBJ : expr.value;
         }
         const objective = this.exprToString(expr);
         if (objective.startsWith('#') || objective.includes('.')) {
-            return objective.startsWith('#') ? objective.slice(1) : objective;
+            if (objective.startsWith('#')) {
+                const name = objective.slice(1);
+                // '#rs' is the canonical way to reference the current RS scoreboard objective.
+                // Resolve to LOWERING_OBJ so it tracks the --scoreboard option.
+                return name === 'rs' ? exports.LOWERING_OBJ : name;
+            }
+            return objective;
         }
         return `${this.getObjectiveNamespace(span)}.${objective}`;
     }
@@ -2769,7 +2866,7 @@ class Lowering {
         if (!filePath) {
             return this.namespace;
         }
-        return this.isStdlibFile(filePath) ? 'rs' : this.namespace;
+        return this.isStdlibFile(filePath) ? exports.LOWERING_OBJ : this.namespace;
     }
     tryGetStdlibInternalObjective(playerExpr, objectiveExpr, span) {
         if (!span || !this.currentStdlibCallSite || objectiveExpr.kind !== 'mc_name' || objectiveExpr.value !== 'rs') {
@@ -2784,7 +2881,7 @@ class Lowering {
             return null;
         }
         const hash = this.shortHash(this.serializeCallSite(this.currentStdlibCallSite));
-        return `rs._${resourceBase}_${hash}`;
+        return `${exports.LOWERING_OBJ}._${resourceBase}_${hash}`;
     }
     getStdlibInternalResourceBase(playerExpr) {
         if (!playerExpr || playerExpr.kind !== 'str_lit') {
@@ -3071,15 +3168,15 @@ class Lowering {
     readArrayElement(arrayName, index) {
         const dst = this.builder.freshTemp();
         if (index.kind === 'const') {
-            this.builder.emitRaw(`execute store result score ${dst} rs run data get storage rs:heap ${arrayName}[${index.value}]`);
+            this.builder.emitRaw(`execute store result score ${dst} ${exports.LOWERING_OBJ} run data get storage rs:heap ${arrayName}[${index.value}]`);
             return { kind: 'var', name: dst };
         }
         const macroKey = `__rs_index_${this.foreachCounter++}`;
         const subFnName = `${this.currentFn}/array_get_${this.foreachCounter++}`;
         const indexVar = index.kind === 'var' ? index.name : this.operandToVar(index);
-        this.builder.emitRaw(`execute store result storage rs:heap ${macroKey} int 1 run scoreboard players get ${indexVar} rs`);
+        this.builder.emitRaw(`execute store result storage rs:heap ${macroKey} int 1 run scoreboard players get ${indexVar} ${exports.LOWERING_OBJ}`);
         this.builder.emitRaw(`function ${this.namespace}:${subFnName} with storage rs:heap`);
-        this.emitRawSubFunction(subFnName, `\x01execute store result score ${dst} rs run data get storage rs:heap ${arrayName}[$(${macroKey})]`);
+        this.emitRawSubFunction(subFnName, `\x01execute store result score ${dst} ${exports.LOWERING_OBJ} run data get storage rs:heap ${arrayName}[$(${macroKey})]`);
         return { kind: 'var', name: dst };
     }
     emitRawSubFunction(name, ...commands) {

package/dist/mathtest.map.json

@@ -0,0 +1,6 @@
+{
+  "$b": "x",
+  "$a": "const:0",
+  "$c": "internal:p0",
+  "$f": "internal:ret"
+}

package/dist/mypack.map.json

@@ -0,0 +1,27 @@
+{
+  "$o": "x",
+  "$r": "execute",
+  "$u": "y",
+  "$aa": "ax",
+  "$ad": "ay",
+  "$ai": "swapped",
+  "$ak": "tmp",
+  "$al": "lo",
+  "$am": "hi",
+  "$ar": "mid",
+  "$as": "t",
+  "$ax": "theta",
+  "$a": "const:0",
+  "$b": "const:1",
+  "$c": "const:2",
+  "$d": "const:45",
+  "$e": "const:90",
+  "$f": "const:180",
+  "$g": "const:270",
+  "$h": "const:360",
+  "$i": "const:1000",
+  "$j": "const:46340",
+  "$k": "internal:ret",
+  "$n": "internal:p0",
+  "$t": "internal:p1"
+}

package/dist/optimizer/commands.d.ts

@@ -17,6 +17,7 @@ export interface CommandFunction {
     name: string;
     commands: IRCommand[];
 }
+export declare function setOptimizerObjective(obj: string): void;
 export declare function createEmptyOptimizationStats(): OptimizationStats;
 export declare function mergeOptimizationStats(base: OptimizationStats, delta: Partial<OptimizationStats>): void;
 export declare function applyLICM(functions: CommandFunction[]): {