redscript-mc 1.0.0 → 1.1.0

package/dist/__tests__/e2e.test.js

@@ -306,7 +306,7 @@ fn test() {
             expect(fn).toContain('bossbar set ns:health visible true');
             expect(fn).toContain('bossbar set ns:health players @a');
             expect(fn).toContain('bossbar remove ns:health');
-            expect(fn).toMatch(/execute store result score \$t\d+ rs run bossbar get ns:health value/);
+            expect(fn).toMatch(/execute store result score \$_\d+ rs run bossbar get ns:health value/);
         });
         it('compiles team builtins', () => {
             const source = `
@@ -586,19 +586,19 @@ fn double_score() -> int {
             const source = 'fn test() { let x: int = random(1, 10); }';
             const files = compile(source);
             const fn = getFunction(files, 'test');
-            expect(fn).toContain('scoreboard players random $t0 rs 1 10');
+            expect(fn).toContain('scoreboard players random $_0 rs 1 10');
         });
         it('compiles random_native()', () => {
             const source = 'fn test() { let x: int = random_native(1, 6); }';
             const files = compile(source);
             const fn = getFunction(files, 'test');
-            expect(fn).toContain('execute store result score $t0 rs run random value 1 6');
+            expect(fn).toContain('execute store result score $_0 rs run random value 1 6');
         });
         it('compiles random_native() with zero min', () => {
             const source = 'fn test() { let x: int = random_native(0, 100); }';
             const files = compile(source);
             const fn = getFunction(files, 'test');
-            expect(fn).toContain('execute store result score $t0 rs run random value 0 100');
+            expect(fn).toContain('execute store result score $_0 rs run random value 0 100');
         });
         it('compiles random_sequence()', () => {
             const source = 'fn test() { random_sequence("loot"); random_sequence("loot", 9); }';
@@ -1079,7 +1079,7 @@ fn handle_claim() {
             expect(fn).toContain('if entity @s[tag=boss]');
         });
     });
-    describe('Real program: zombie_game.rs', () => {
+    describe('Real program: zombie_game.mcrs', () => {
         const source = `
 // A zombie survival game logic
 // Kills nearby zombies and tracks score
@@ -1525,4 +1525,145 @@ describe('for-range loop', () => {
         expect(subFn?.content).toContain('execute if score $x rs matches ..7 run function forloop2:test/__for_0');
     });
 });
+// ---------------------------------------------------------------------------
+// NBT Structured Parameters
+// ---------------------------------------------------------------------------
+describe('NBT parameters', () => {
+    it('compiles give with NBT struct', () => {
+        const src = `fn test() { give(@s, "minecraft:diamond_sword", 1, { display: { Name: "Excalibur" } }); }`;
+        const files = compile(src, 'nbtparam');
+        const fn = getFunction(files, 'test');
+        expect(fn).toContain('give @s minecraft:diamond_sword{display:{Name:"Excalibur"}} 1');
+    });
+    it('compiles give with nested NBT and arrays', () => {
+        const src = `fn test() { give(@s, "minecraft:stick", 1, { display: { Name: "Magic Wand" }, Enchantments: [{ id: "sharpness", lvl: 5 }] }); }`;
+        const files = compile(src, 'nbtparam2');
+        const fn = getFunction(files, 'test');
+        expect(fn).toContain('{display:{Name:"Magic Wand"},Enchantments:[{id:"sharpness",lvl:5}]}');
+    });
+    it('compiles summon with NBT', () => {
+        const src = `fn test() { summon("minecraft:zombie", 0, 64, 0, { CustomName: "Boss", NoAI: true }); }`;
+        const files = compile(src, 'nbtsummon');
+        const fn = getFunction(files, 'test');
+        expect(fn).toContain('summon minecraft:zombie 0 64 0 {CustomName:"Boss",NoAI:1b}');
+    });
+    it('compiles give with bool values in NBT', () => {
+        const src = `fn test() { give(@s, "minecraft:shield", 1, { Unbreakable: true }); }`;
+        const files = compile(src, 'nbtbool');
+        const fn = getFunction(files, 'test');
+        expect(fn).toContain('{Unbreakable:1b}');
+    });
+});
+// ---------------------------------------------------------------------------
+// Set Operations
+// ---------------------------------------------------------------------------
+describe('Set operations', () => {
+    it('creates a new set', () => {
+        const src = `fn test() { let s = set_new(); }`;
+        const files = compile(src, 'settest');
+        const fn = getFunction(files, 'test');
+        expect(fn).toContain('data modify storage rs:sets __set_0 set value []');
+    });
+    it('adds to a set with uniqueness check', () => {
+        const src = `fn test() { let s = set_new(); set_add(s, "apple"); }`;
+        const files = compile(src, 'setadd');
+        const fn = getFunction(files, 'test');
+        expect(fn).toContain('execute unless data storage rs:sets __set_0[{value:apple}] run data modify storage rs:sets __set_0 append value {value:apple}');
+    });
+    it('checks set membership', () => {
+        const src = `fn test() { let s = set_new(); set_add(s, "x"); let has = set_contains(s, "x"); }`;
+        const files = compile(src, 'setcontains');
+        const fn = getFunction(files, 'test');
+        expect(fn).toContain('if data storage rs:sets __set_0[{value:x}]');
+    });
+    it('removes from a set', () => {
+        const src = `fn test() { let s = set_new(); set_add(s, "y"); set_remove(s, "y"); }`;
+        const files = compile(src, 'setremove');
+        const fn = getFunction(files, 'test');
+        expect(fn).toContain('data remove storage rs:sets __set_0[{value:y}]');
+    });
+    it('clears a set', () => {
+        const src = `fn test() { let s = set_new(); set_clear(s); }`;
+        const files = compile(src, 'setclear');
+        const fn = getFunction(files, 'test');
+        expect(fn).toContain('data modify storage rs:sets __set_0 set value []');
+    });
+});
+// ---------------------------------------------------------------------------
+// Method Syntax Sugar
+// ---------------------------------------------------------------------------
+describe('Method syntax sugar', () => {
+    it('transforms obj.method() to method(obj)', () => {
+        const src = `fn test() { let s = set_new(); s.clear(); }`;
+        const files = compile(src, 'method1');
+        const fn = getFunction(files, 'test');
+        expect(fn).toContain('data modify storage rs:sets __set_0 set value []');
+    });
+    it('transforms obj.method(arg) to method(obj, arg)', () => {
+        const src = `fn test() { let s = set_new(); s.add("apple"); }`;
+        const files = compile(src, 'method2');
+        const fn = getFunction(files, 'test');
+        expect(fn).toContain('data modify storage rs:sets __set_0 append value {value:apple}');
+    });
+    it('transforms obj.method(arg) with contains', () => {
+        const src = `fn test() { let s = set_new(); s.add("x"); let r = s.contains("x"); }`;
+        const files = compile(src, 'method3');
+        const fn = getFunction(files, 'test');
+        expect(fn).toBeDefined();
+    });
+    it('works with multiple args', () => {
+        const src = `fn test() { let s = set_new(); s.add("a"); s.add("b"); s.remove("a"); }`;
+        const files = compile(src, 'method4');
+        const fn = getFunction(files, 'test');
+        expect(fn).toContain('data remove storage rs:sets __set_0[{value:a}]');
+    });
+});
+describe('Global variables', () => {
+    it('initializes global in __load', () => {
+        const src = `let x: int = 42;\nfn test() { say("hi"); }`;
+        const files = compile(src, 'globaltest');
+        const load = getFunction(files, '__load');
+        expect(load).toContain('scoreboard players set $x rs 42');
+    });
+    it('reads and writes global in function', () => {
+        const src = `let count: int = 0;\nfn inc() { count = count + 1; }`;
+        const files = compile(src, 'globalrw');
+        const fn = getFunction(files, 'inc');
+        expect(fn).toBeDefined();
+        // Global should be initialized in __load
+        const load = getFunction(files, '__load');
+        expect(load).toContain('scoreboard players set $count rs 0');
+    });
+    it('const cannot be reassigned', () => {
+        const src = `const X: int = 5;\nfn bad() { X = 10; }`;
+        expect(() => compile(src, 'constbad')).toThrow();
+    });
+});
+describe('@load decorator', () => {
+    it('calls @load function from __load.mcfunction', () => {
+        const src = `@load fn init() { say("Datapack loaded!"); }`;
+        const files = compile(src, 'loadtest');
+        const load = getFunction(files, '__load');
+        expect(load).toContain('function loadtest:init');
+    });
+    it('calls multiple @load functions in order', () => {
+        const src = `
+      @load fn setup() { say("setup"); }
+      @load fn init() { say("init"); }
+    `;
+        const files = compile(src, 'loadtest');
+        const load = getFunction(files, '__load');
+        const setupIdx = load.indexOf('function loadtest:setup');
+        const initIdx = load.indexOf('function loadtest:init');
+        expect(setupIdx).toBeGreaterThan(-1);
+        expect(initIdx).toBeGreaterThan(-1);
+        expect(setupIdx).toBeLessThan(initIdx);
+    });
+    it('generates the @load function body normally', () => {
+        const src = `@load fn init() { say("hi"); }`;
+        const files = compile(src, 'loadtest');
+        const fn = getFunction(files, 'init');
+        expect(fn).toContain('say hi');
+    });
+});
 //# sourceMappingURL=e2e.test.js.map

package/dist/__tests__/formatter.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/__tests__/formatter.test.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const formatter_1 = require("../formatter");
+describe('formatter', () => {
+    it('normalizes indentation to 4 spaces', () => {
+        const input = 'fn main() {\n  let x: int = 1;\n}';
+        const result = (0, formatter_1.format)(input);
+        expect(result).toBe('fn main() {\n    let x: int = 1;\n}\n');
+    });
+    it('handles nested blocks', () => {
+        const input = 'fn main() {\nif true {\nlet x: int = 1;\n}\n}';
+        const result = (0, formatter_1.format)(input);
+        expect(result).toBe('fn main() {\n    if true {\n        let x: int = 1;\n    }\n}\n');
+    });
+    it('trims trailing whitespace', () => {
+        const input = 'fn main() {   \n    let x: int = 1;   \n}   ';
+        const result = (0, formatter_1.format)(input);
+        expect(result).toBe('fn main() {\n    let x: int = 1;\n}\n');
+    });
+    it('ensures single newline at end of file', () => {
+        const input = 'fn main() {\n}\n\n\n';
+        const result = (0, formatter_1.format)(input);
+        expect(result).toBe('fn main() {\n}\n');
+    });
+    it('preserves blank lines', () => {
+        const input = 'fn a() {\n}\n\nfn b() {\n}';
+        const result = (0, formatter_1.format)(input);
+        expect(result).toBe('fn a() {\n}\n\nfn b() {\n}\n');
+    });
+    it('handles already formatted code', () => {
+        const input = 'fn main() {\n    let x: int = 1;\n}\n';
+        const result = (0, formatter_1.format)(input);
+        expect(result).toBe(input);
+    });
+    it('handles empty input', () => {
+        expect((0, formatter_1.format)('')).toBe('\n');
+        expect((0, formatter_1.format)('\n\n')).toBe('\n');
+    });
+});
+//# sourceMappingURL=formatter.test.js.map

package/dist/__tests__/lowering.test.js

@@ -546,7 +546,7 @@ fn test() {
             expect(rawCmds).toContain('bossbar set ns:health visible true');
             expect(rawCmds).toContain('bossbar set ns:health players @a');
             expect(rawCmds).toContain('bossbar remove ns:health');
-            expect(rawCmds.some(cmd => /^execute store result score \$t\d+ rs run bossbar get ns:health value$/.test(cmd))).toBe(true);
+            expect(rawCmds.some(cmd => /^execute store result score \$_\d+ rs run bossbar get ns:health value$/.test(cmd))).toBe(true);
         });
         it('lowers team management builtins', () => {
             const ir = compile(`
@@ -574,13 +574,13 @@ fn test() {
             const ir = compile('fn test() { let x: int = random(1, 100); }');
             const fn = getFunction(ir, 'test');
             const rawCmds = getRawCommands(fn);
-            expect(rawCmds).toContain('scoreboard players random $t0 rs 1 100');
+            expect(rawCmds).toContain('scoreboard players random $_0 rs 1 100');
         });
         it('lowers random_native()', () => {
             const ir = compile('fn test() { let x: int = random_native(1, 6); }');
             const fn = getFunction(ir, 'test');
             const rawCmds = getRawCommands(fn);
-            expect(rawCmds).toContain('execute store result score $t0 rs run random value 1 6');
+            expect(rawCmds).toContain('execute store result score $_0 rs run random value 1 6');
         });
         it('lowers random_sequence()', () => {
             const ir = compile('fn test() { random_sequence("loot", 42); }');
@@ -815,5 +815,38 @@ fn count_down() {
             expect(bodyBlock).toBeDefined();
         });
     });
+    describe('Global variables', () => {
+        it('registers global in IR globals with init value', () => {
+            const ir = compile('let x: int = 42;\nfn test() { say("hi"); }');
+            expect(ir.globals).toContainEqual({ name: '$x', init: 42 });
+        });
+        it('reads global variable in function body', () => {
+            const ir = compile('let count: int = 0;\nfn test() { let y: int = count; }');
+            const fn = getFunction(ir, 'test');
+            const instrs = getInstructions(fn);
+            expect(instrs.some(i => i.op === 'assign' && i.dst === '$y' && i.src.kind === 'var' && i.src.name === '$count')).toBe(true);
+        });
+        it('writes global variable in function body', () => {
+            const ir = compile('let count: int = 0;\nfn inc() { count = 5; }');
+            const fn = getFunction(ir, 'inc');
+            const instrs = getInstructions(fn);
+            expect(instrs.some(i => i.op === 'assign' && i.dst === '$count' && i.src.kind === 'const' && i.src.value === 5)).toBe(true);
+        });
+        it('compound assignment on global variable', () => {
+            const ir = compile('let count: int = 0;\nfn inc() { count += 1; }');
+            const fn = getFunction(ir, 'inc');
+            const instrs = getInstructions(fn);
+            expect(instrs.some(i => i.op === 'binop' && i.lhs.name === '$count' && i.bop === '+' && i.rhs.value === 1)).toBe(true);
+        });
+        it('const cannot be reassigned', () => {
+            const src = 'const X: int = 5;\nfn bad() { X = 10; }';
+            expect(() => compile(src)).toThrow(/Cannot assign to constant/);
+        });
+        it('multiple globals with different init values', () => {
+            const ir = compile('let a: int = 10;\nlet b: int = 20;\nfn test() { a = b; }');
+            expect(ir.globals).toContainEqual({ name: '$a', init: 10 });
+            expect(ir.globals).toContainEqual({ name: '$b', init: 20 });
+        });
+    });
 });
 //# sourceMappingURL=lowering.test.js.map

package/dist/__tests__/mc-integration.test.js

@@ -94,12 +94,12 @@ beforeAll(async () => {
         return;
     }
     // ── Write fixtures + use safe reloadData (no /reload confirm) ───────
-    // counter.rs
-    if (fs.existsSync(path.join(__dirname, '../examples/counter.rs'))) {
-        writeFixture(fs.readFileSync(path.join(__dirname, '../examples/counter.rs'), 'utf-8'), 'counter');
+    // counter.mcrs
+    if (fs.existsSync(path.join(__dirname, '../examples/counter.mcrs'))) {
+        writeFixture(fs.readFileSync(path.join(__dirname, '../examples/counter.mcrs'), 'utf-8'), 'counter');
     }
-    if (fs.existsSync(path.join(__dirname, '../examples/world_manager.rs'))) {
-        writeFixture(fs.readFileSync(path.join(__dirname, '../examples/world_manager.rs'), 'utf-8'), 'world_manager');
+    if (fs.existsSync(path.join(__dirname, '../examples/world_manager.mcrs'))) {
+        writeFixture(fs.readFileSync(path.join(__dirname, '../examples/world_manager.mcrs'), 'utf-8'), 'world_manager');
     }
     writeFixture(`
     @tick
@@ -177,11 +177,109 @@ beforeAll(async () => {
       setblock((3, 70, 0), "minecraft:stone");
     }
   `, 'fill_test');
+    // Scenario E: for-range loop — loop counter increments exactly N times
+    writeFixture(`
+    fn count_to_five() {
+      scoreboard_set("#range", "counter", 0);
+      for i in 0..5 {
+        let c: int = scoreboard_get("#range", "counter");
+        scoreboard_set("#range", "counter", c + 1);
+      }
+    }
+  `, 'range_test');
+    // Scenario F: function call with return value — verifies $ret propagation
+    writeFixture(`
+    fn triple(x: int) -> int {
+      return x * 3;
+    }
+    fn run_nested() {
+      let a: int = triple(4);
+      scoreboard_set("#nested", "result", a);
+    }
+  `, 'nested_test');
+    // Scenario G: match statement dispatches to correct branch
+    writeFixture(`
+    fn classify(x: int) {
+      match (x) {
+        1 => { scoreboard_set("#match", "out", 10); }
+        2 => { scoreboard_set("#match", "out", 20); }
+        3 => { scoreboard_set("#match", "out", 30); }
+        _ => { scoreboard_set("#match", "out", -1); }
+      }
+    }
+  `, 'match_test');
+    // Scenario H: while loop counts down
+    writeFixture(`
+    fn countdown() {
+      scoreboard_set("#wloop", "i", 10);
+      scoreboard_set("#wloop", "steps", 0);
+      let i: int = scoreboard_get("#wloop", "i");
+      while (i > 0) {
+        let s: int = scoreboard_get("#wloop", "steps");
+        scoreboard_set("#wloop", "steps", s + 1);
+        i = i - 1;
+        scoreboard_set("#wloop", "i", i);
+      }
+    }
+  `, 'while_test');
+    // Scenario I: multiple if/else branches (boundary test)
+    writeFixture(`
+    fn classify_score() {
+      let x: int = scoreboard_get("#boundary", "input");
+      if (x > 100) {
+        scoreboard_set("#boundary", "tier", 3);
+      } else {
+        if (x > 50) {
+          scoreboard_set("#boundary", "tier", 2);
+        } else {
+          if (x > 0) {
+            scoreboard_set("#boundary", "tier", 1);
+          } else {
+            scoreboard_set("#boundary", "tier", 0);
+          }
+        }
+      }
+    }
+  `, 'boundary_test');
+    // Scenario J: entity management — summon via raw commands
+    writeFixture(`
+    fn tag_entities() {
+      raw("summon minecraft:armor_stand 10 65 10");
+      raw("summon minecraft:armor_stand 11 65 10");
+      raw("summon minecraft:armor_stand 12 65 10");
+    }
+  `, 'tag_test');
+    // Scenario K: mixed arithmetic — order of operations
+    writeFixture(`
+    fn math_order() {
+      let a: int = 2;
+      let b: int = 3;
+      let c: int = 4;
+      scoreboard_set("#order", "r1", a + b * c);
+      scoreboard_set("#order", "r2", (a + b) * c);
+      let d: int = 100;
+      let e: int = d / 3;
+      scoreboard_set("#order", "r3", e);
+    }
+  `, 'order_test');
+    // Scenario L: scoreboard read-modify-write chain
+    writeFixture(`
+    fn chain_rmw() {
+      scoreboard_set("#rmw", "v", 1);
+      let v: int = scoreboard_get("#rmw", "v");
+      scoreboard_set("#rmw", "v", v * 2);
+      v = scoreboard_get("#rmw", "v");
+      scoreboard_set("#rmw", "v", v * 2);
+      v = scoreboard_get("#rmw", "v");
+      scoreboard_set("#rmw", "v", v * 2);
+    }
+  `, 'rmw_test');
     // ── Full reset + safe data reload ────────────────────────────────────
     await mc.fullReset();
     // Pre-create scoreboards
     for (const obj of ['ticks', 'seconds', 'test_score', 'result', 'calc', 'rs',
-        'timer', 'ended', 'val_a', 'val_b', 'sum', 'val_x', 'val_y', 'product', 'val']) {
+        'timer', 'ended', 'val_a', 'val_b', 'sum', 'val_x', 'val_y', 'product', 'val',
+        'counter', 'out', 'i', 'steps', 'input', 'tier', 'r1', 'r2', 'r3', 'v']) {
         await mc.command(`/scoreboard objectives add ${obj} dummy`).catch(() => { });
     }
     await mc.command('/scoreboard players set counter ticks 0');
@@ -209,7 +307,7 @@ describe('MC Integration Tests', () => {
         console.log(`  Server: ${status.version}, TPS: ${status.tps_1m.toFixed(1)}`);
     });
     // ─── Test 2: Counter tick ─────────────────────────────────────────────
-    test('counter.rs: tick function increments scoreboard over time', async () => {
+    test('counter.mcrs: tick function increments scoreboard over time', async () => {
         if (!serverOnline)
             return;
         await mc.ticks(40); // Wait 2s (counter was already init'd in beforeAll)
@@ -218,7 +316,7 @@ describe('MC Integration Tests', () => {
         console.log(`  counter/ticks after setup+40 ticks: ${count}`);
     });
     // ─── Test 3: setblock ────────────────────────────────────────────────
-    test('world_manager.rs: setblock places correct block', async () => {
+    test('world_manager.mcrs: setblock places correct block', async () => {
         if (!serverOnline)
             return;
         // Clear just the lobby area, keep other state
@@ -231,7 +329,7 @@ describe('MC Integration Tests', () => {
         console.log(`  Block at (4,65,4): ${block.type}`);
     });
     // ─── Test 4: fill ────────────────────────────────────────────────────
-    test('world_manager.rs: fill creates smooth_stone floor', async () => {
+    test('world_manager.mcrs: fill creates smooth_stone floor', async () => {
         if (!serverOnline)
             return;
         // Runs after test 3, floor should still be there
@@ -337,7 +435,7 @@ describe('E2E Scenario Tests', () => {
         console.log(`  timer hit 0 (final=${finalTimer}), ended=${ended} ✓`);
     });
     // Scenario B: No temp var collision between two functions called in sequence
-    // Verifies: each function's $t0/$t1 temp vars are isolated per-call, not globally shared
+    // Verifies: each function's temp vars are isolated per-call via globally unique names
     // If there's a bug, calc_product would see sum's leftover $t vars and produce wrong result
     test('B: calc_sum + calc_product called in sequence — no temp var collision', async () => {
         if (!serverOnline)
@@ -391,5 +489,152 @@ describe('E2E Scenario Tests', () => {
         expect(after.type).toBe('minecraft:air');
         console.log(`  fill_test: blocks [0-3,70,0]=stone, [-1]/[4]=air ✓`);
     });
+    // Scenario E: for-range loop executes body exactly N times
+    // Verifies: for i in 0..5 increments counter 5 times
+    test('E: for-range loop increments counter exactly 5 times', async () => {
+        if (!serverOnline)
+            return;
+        await mc.command('/function range_test:__load');
+        await mc.command('/function range_test:count_to_five');
+        await mc.ticks(10);
+        const counter = await mc.scoreboard('#range', 'counter');
+        expect(counter).toBe(5);
+        console.log(`  for-range 0..5 → counter=${counter} (expect 5) ✓`);
+    });
+    // Scenario F: function return value propagation
+    // Verifies: $ret from callee is correctly captured in caller's variable
+    test('F: function return value — triple(4) = 12', async () => {
+        if (!serverOnline)
+            return;
+        await mc.command('/function nested_test:__load');
+        await mc.command('/function nested_test:run_nested');
+        await mc.ticks(10);
+        const result = await mc.scoreboard('#nested', 'result');
+        expect(result).toBe(12); // triple(4) = 4*3 = 12
+        console.log(`  triple(4) = ${result} (expect 12) ✓`);
+    });
+    // Scenario G: match dispatches to correct branch
+    // Verifies: match statement selects right arm for values 1, 2, 3, and default
+    test('G: match statement dispatches to correct branch', async () => {
+        if (!serverOnline)
+            return;
+        await mc.command('/function match_test:__load');
+        // Test match on value 2
+        await mc.command('/scoreboard players set $p0 rs 2');
+        await mc.command('/function match_test:classify');
+        await mc.ticks(5);
+        let out = await mc.scoreboard('#match', 'out');
+        expect(out).toBe(20);
+        console.log(`  match(2) → out=${out} (expect 20) ✓`);
+        // Test match on value 3
+        await mc.command('/scoreboard players set $p0 rs 3');
+        await mc.command('/function match_test:classify');
+        await mc.ticks(5);
+        out = await mc.scoreboard('#match', 'out');
+        expect(out).toBe(30);
+        console.log(`  match(3) → out=${out} (expect 30) ✓`);
+        // Test default branch (value 99)
+        await mc.command('/scoreboard players set $p0 rs 99');
+        await mc.command('/function match_test:classify');
+        await mc.ticks(5);
+        out = await mc.scoreboard('#match', 'out');
+        expect(out).toBe(-1);
+        console.log(`  match(99) → out=${out} (expect -1, default) ✓`);
+    });
+    // Scenario H: while loop counts down from 10 to 0
+    // Verifies: while loop body executes correct number of iterations
+    test('H: while loop counts down 10 steps', async () => {
+        if (!serverOnline)
+            return;
+        await mc.command('/function while_test:__load');
+        await mc.command('/function while_test:countdown');
+        await mc.ticks(10);
+        const i = await mc.scoreboard('#wloop', 'i');
+        const steps = await mc.scoreboard('#wloop', 'steps');
+        expect(i).toBe(0);
+        expect(steps).toBe(10);
+        console.log(`  while countdown: i=${i} (expect 0), steps=${steps} (expect 10) ✓`);
+    });
+    // Scenario I: nested if/else boundary classification
+    // Verifies: correct branch taken at boundaries (0, 50, 100)
+    test('I: nested if/else boundary classification', async () => {
+        if (!serverOnline)
+            return;
+        await mc.command('/function boundary_test:__load');
+        // Test x=0 → tier 0
+        await mc.command('/scoreboard players set #boundary input 0');
+        await mc.command('/function boundary_test:classify_score');
+        await mc.ticks(5);
+        let tier = await mc.scoreboard('#boundary', 'tier');
+        expect(tier).toBe(0);
+        console.log(`  classify(0) → tier=${tier} (expect 0) ✓`);
+        // Test x=50 → tier 1 (> 0 but not > 50)
+        await mc.command('/scoreboard players set #boundary input 50');
+        await mc.command('/function boundary_test:classify_score');
+        await mc.ticks(5);
+        tier = await mc.scoreboard('#boundary', 'tier');
+        expect(tier).toBe(1);
+        console.log(`  classify(50) → tier=${tier} (expect 1) ✓`);
+        // Test x=51 → tier 2 (> 50 but not > 100)
+        await mc.command('/scoreboard players set #boundary input 51');
+        await mc.command('/function boundary_test:classify_score');
+        await mc.ticks(5);
+        tier = await mc.scoreboard('#boundary', 'tier');
+        expect(tier).toBe(2);
+        console.log(`  classify(51) → tier=${tier} (expect 2) ✓`);
+        // Test x=101 → tier 3
+        await mc.command('/scoreboard players set #boundary input 101');
+        await mc.command('/function boundary_test:classify_score');
+        await mc.ticks(5);
+        tier = await mc.scoreboard('#boundary', 'tier');
+        expect(tier).toBe(3);
+        console.log(`  classify(101) → tier=${tier} (expect 3) ✓`);
+    });
+    // Scenario J: entity summon and query
+    // Verifies: entities spawned via compiled function are queryable
+    test('J: summon entities via compiled function', async () => {
+        if (!serverOnline)
+            return;
+        await mc.command('/kill @e[type=minecraft:armor_stand]');
+        await mc.ticks(2);
+        await mc.command('/function tag_test:__load');
+        await mc.command('/function tag_test:tag_entities');
+        await mc.ticks(5);
+        const stands = await mc.entities('@e[type=minecraft:armor_stand]');
+        expect(stands.length).toBe(3);
+        console.log(`  Summoned 3 armor_stands via tag_test, found: ${stands.length} ✓`);
+        await mc.command('/kill @e[type=minecraft:armor_stand]');
+    });
+    // Scenario K: arithmetic order of operations
+    // Verifies: MC scoreboard arithmetic matches expected evaluation order
+    test('K: arithmetic order of operations', async () => {
+        if (!serverOnline)
+            return;
+        await mc.command('/function order_test:__load');
+        await mc.command('/function order_test:math_order');
+        await mc.ticks(10);
+        const r1 = await mc.scoreboard('#order', 'r1');
+        const r2 = await mc.scoreboard('#order', 'r2');
+        const r3 = await mc.scoreboard('#order', 'r3');
+        // a + b * c = 2 + 3*4 = 14 (if precedence respected) or (2+3)*4 = 20 (left-to-right)
+        // MC scoreboard does left-to-right, so compiler may emit either depending on lowering
+        // (a + b) * c = 5 * 4 = 20 (explicit parens)
+        expect(r2).toBe(20); // This one is unambiguous
+        // 100 / 3 = 33 (integer division)
+        expect(r3).toBe(33);
+        console.log(`  r1=${r1}, r2=${r2} (expect 20), r3=${r3} (expect 33) ✓`);
+    });
+    // Scenario L: scoreboard read-modify-write chain (1 → 2 → 4 → 8)
+    // Verifies: sequential RMW operations don't lose intermediate state
+    test('L: scoreboard RMW chain — 1*2*2*2 = 8', async () => {
+        if (!serverOnline)
+            return;
+        await mc.command('/function rmw_test:__load');
+        await mc.command('/function rmw_test:chain_rmw');
+        await mc.ticks(10);
+        const v = await mc.scoreboard('#rmw', 'v');
+        expect(v).toBe(8);
+        console.log(`  RMW chain: 1→2→4→8, got ${v} (expect 8) ✓`);
+    });
 });
 //# sourceMappingURL=mc-integration.test.js.map

package/dist/__tests__/mc-syntax.test.js

@@ -57,13 +57,13 @@ function validateSource(validator, source, namespace) {
 describe('MC Command Syntax Validation', () => {
     const validator = new mc_validator_1.MCCommandValidator(FIXTURE_PATH);
     test('counter example generates valid MC commands', () => {
-        const src = fs.readFileSync(path.join(__dirname, '..', 'examples', 'counter.rs'), 'utf-8');
+        const src = fs.readFileSync(path.join(__dirname, '..', 'examples', 'counter.mcrs'), 'utf-8');
         const errors = validateSource(validator, src, 'counter');
         expect(errors).toHaveLength(0);
     });
     EXAMPLES.forEach(name => {
-        test(`${name}.rs generates valid MC commands`, () => {
-            const src = fs.readFileSync(path.join(__dirname, '..', 'examples', `${name}.rs`), 'utf-8');
+        test(`${name}.mcrs generates valid MC commands`, () => {
+            const src = fs.readFileSync(path.join(__dirname, '..', 'examples', `${name}.mcrs`), 'utf-8');
             const errors = validateSource(validator, src, name);
             if (errors.length > 0) {
                 console.log('Invalid commands:', errors);

package/dist/__tests__/nbt.test.js

@@ -66,8 +66,8 @@ describe('NBT codec', () => {
     });
 });
 describe('Structure generator', () => {
-    test('compiles counter.rs to a non-empty structure', () => {
-        const filePath = 'src/examples/counter.rs';
+    test('compiles counter.mcrs to a non-empty structure', () => {
+        const filePath = 'src/examples/counter.mcrs';
         const src = fs.readFileSync(filePath, 'utf-8');
         const { buffer, blockCount } = (0, structure_1.compileToStructure)(src, 'counter', filePath);
         expect(buffer.length).toBeGreaterThan(100);