redscript-mc 2.4.0 → 2.5.0

package/dist/__tests__/e2e.test.js

@@ -0,0 +1,1847 @@
+"use strict";
+/**
+ * End-to-End Tests
+ *
+ * Tests the complete pipeline: Source → Lexer → Parser → Lowering → Optimizer → CodeGen
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+const lexer_1 = require("../lexer");
+const parser_1 = require("../parser");
+const lowering_1 = require("../lowering");
+const typechecker_1 = require("../typechecker");
+const passes_1 = require("../optimizer/passes");
+const mcfunction_1 = require("../codegen/mcfunction");
+// ---------------------------------------------------------------------------
+// Test Helpers
+// ---------------------------------------------------------------------------
+function compile(source, namespace = 'test') {
+    const tokens = new lexer_1.Lexer(source).tokenize();
+    const ast = new parser_1.Parser(tokens).parse(namespace);
+    const ir = new lowering_1.Lowering(namespace).lower(ast);
+    const optimized = {
+        ...ir,
+        functions: ir.functions.map(fn => (0, passes_1.optimize)(fn)),
+    };
+    return (0, mcfunction_1.generateDatapack)(optimized);
+}
+function getFunction(files, name) {
+    const file = files.find(f => f.path.includes(`/${name}.mcfunction`));
+    return file?.content;
+}
+function getSubFunction(files, parent, sub) {
+    const file = files.find(f => f.path.includes(`/${parent}/${sub}.mcfunction`));
+    return file?.content;
+}
+function hasTickTag(files, namespace, fnName) {
+    // Check if the function is called from __tick.mcfunction
+    const tickFn = files.find(f => f.path.includes('__tick.mcfunction'));
+    if (!tickFn)
+        return false;
+    return tickFn.content.includes(`function ${namespace}:${fnName}`);
+}
+function typeCheck(source) {
+    const tokens = new lexer_1.Lexer(source).tokenize();
+    const ast = new parser_1.Parser(tokens, source).parse('test');
+    return new typechecker_1.TypeChecker(source).check(ast);
+}
+const cmdblock_1 = require("../codegen/cmdblock");
+// ---------------------------------------------------------------------------
+// Tests
+// ---------------------------------------------------------------------------
+describe('Command Block Target', () => {
+    it('generates cmdblock structure with load block', () => {
+        const result = (0, cmdblock_1.generateCommandBlocks)('mypack', false, true);
+        expect(result.format).toBe('redscript-cmdblock-v1');
+        expect(result.namespace).toBe('mypack');
+        expect(result.blocks).toHaveLength(1);
+        expect(result.blocks[0].type).toBe('impulse');
+        expect(result.blocks[0].command).toBe('function mypack:__load');
+        expect(result.blocks[0].auto).toBe(true);
+    });
+    it('generates cmdblock structure with tick block', () => {
+        const result = (0, cmdblock_1.generateCommandBlocks)('mypack', true, false);
+        expect(result.blocks).toHaveLength(1);
+        expect(result.blocks[0].type).toBe('repeat');
+        expect(result.blocks[0].command).toBe('function mypack:__tick');
+    });
+    it('generates cmdblock structure with both blocks', () => {
+        const result = (0, cmdblock_1.generateCommandBlocks)('game', true, true);
+        expect(result.namespace).toBe('game');
+        expect(result.blocks).toHaveLength(2);
+        // Load block first
+        expect(result.blocks[0].type).toBe('impulse');
+        expect(result.blocks[0].command).toBe('function game:__load');
+        expect(result.blocks[0].pos).toEqual([0, 0, 0]);
+        expect(result.blocks[0].auto).toBe(true);
+        // Tick block second
+        expect(result.blocks[1].type).toBe('repeat');
+        expect(result.blocks[1].command).toBe('function game:__tick');
+        expect(result.blocks[1].pos).toEqual([1, 0, 0]);
+    });
+    it('generates empty blocks when no tick or load', () => {
+        const result = (0, cmdblock_1.generateCommandBlocks)('empty', false, false);
+        expect(result.blocks).toHaveLength(0);
+    });
+    it('produces valid JSON structure', () => {
+        const result = (0, cmdblock_1.generateCommandBlocks)('test', true, true);
+        const json = JSON.stringify(result);
+        const parsed = JSON.parse(json);
+        expect(parsed.format).toBe('redscript-cmdblock-v1');
+        expect(Array.isArray(parsed.blocks)).toBe(true);
+    });
+});
+describe('E2E: Complete Pipeline', () => {
+    describe('const declarations', () => {
+        it('inlines consts in expressions and string interpolation', () => {
+            const files = compile(`
+const MAX_HP: int = 100
+const GAME_NAME: string = "Arena Battle"
+
+fn main() {
+    let hp: int = MAX_HP + 5;
+    announce("\${GAME_NAME}: \${hp}");
+}
+`);
+            const mainFn = getFunction(files, 'main');
+            expect(mainFn).toBeDefined();
+            expect(mainFn).toContain('scoreboard players set $main_hp rs 105');
+            expect(mainFn).toContain('Arena Battle');
+        });
+    });
+    describe('string stdlib helpers', () => {
+        it('lowers str_len for literal-backed string variables', () => {
+            const files = compile(`
+fn main() {
+    let name: string = "Player";
+    let n: int = str_len(name);
+    tell(@s, "\${n}");
+}
+`);
+            const mainFn = getFunction(files, 'main');
+            expect(mainFn).toBeDefined();
+            expect(mainFn).toContain('data modify storage rs:strings name set value "Player"');
+            expect(mainFn).toContain('run data get storage rs:strings name');
+            expect(mainFn).toContain('"objective":"rs"');
+        });
+    });
+    describe('timer builtins', () => {
+        it('generates scheduled timer helper functions', () => {
+            const files = compile(`
+fn main() {
+    let intervalId: int = setInterval(20, () => {
+        say("tick");
+    });
+    setTimeout(100, () => {
+        say("later");
+    });
+    clearInterval(intervalId);
+}
+`);
+            const mainFn = getFunction(files, 'main');
+            const intervalFn = getFunction(files, '__interval_0');
+            const intervalBodyFn = getFunction(files, '__interval_body_0');
+            const timeoutFn = getFunction(files, '__timeout_0');
+            expect(mainFn).toBeDefined();
+            expect(mainFn).toContain('schedule function test:__interval_0 20t');
+            expect(mainFn).toContain('schedule function test:__timeout_0 100t');
+            expect(mainFn).toContain('schedule clear test:__interval_0');
+            expect(intervalFn).toContain('function test:__interval_body_0');
+            expect(intervalFn).toContain('schedule function test:__interval_0 20t');
+            expect(intervalBodyFn).toContain('say tick');
+            expect(timeoutFn).toContain('say later');
+        });
+    });
+    describe('is type narrowing', () => {
+        it('type checks and compiles entity narrowing inside foreach blocks', () => {
+            const source = `
+fn main() {
+    foreach (e in @e) {
+        if (e is Player) {
+            kill(e);
+        }
+        if (e is Zombie) {
+            kill(e);
+        }
+    }
+}
+`;
+            expect(typeCheck(source)).toEqual([]);
+            const files = compile(source);
+            const mainFn = getFunction(files, 'main');
+            const foreachFn = getSubFunction(files, 'main', 'foreach_0');
+            const thenFiles = files.filter(file => file.path.includes('/main/then_') && file.content.includes('kill @s'));
+            expect(mainFn).toContain('execute as @e run function test:main/foreach_0');
+            expect(foreachFn).toContain('execute if entity @s[type=minecraft:player] run function test:main/then_');
+            expect(foreachFn).toContain('execute if entity @s[type=minecraft:zombie] run function test:main/then_');
+            expect(thenFiles).toHaveLength(2);
+        });
+    });
+    describe('impl blocks', () => {
+        it('compiles static and instance impl methods end to end', () => {
+            const source = `
+struct Point { x: int, y: int }
+
+impl Point {
+    fn new(x: int, y: int) -> Point {
+        return { x: x, y: y };
+    }
+
+    fn distance(self) -> int {
+        return self.x + self.y;
+    }
+}
+
+fn main() {
+    let p: Point = Point::new(1, 2);
+    let d: int = p.distance();
+    say("\${d}");
+}
+`;
+            expect(typeCheck(source)).toEqual([]);
+            const files = compile(source);
+            const mainFn = getFunction(files, 'main');
+            const staticFn = getFunction(files, 'Point_new');
+            const instanceFn = getFunction(files, 'Point_distance');
+            expect(mainFn).toContain('function test:Point_new');
+            expect(mainFn).toContain('function test:Point_distance');
+            expect(staticFn).toBeDefined();
+            expect(instanceFn).toBeDefined();
+        });
+    });
+    describe('namespace prefixing', () => {
+        it('prefixes user objectives but preserves mc_name and qualified objectives', () => {
+            const files = compile(`
+fn main() {
+    scoreboard_set("timer", #rs, 100);
+    scoreboard_set(@s, "timer", 100);
+    scoreboard_set(@s, #health, 20);
+    scoreboard_set(@s, "custom.timer", 1);
+}
+`, 'pack');
+            const mainFn = getFunction(files, 'main');
+            expect(mainFn).toContain('scoreboard players set timer rs 100');
+            expect(mainFn).toContain('scoreboard players set @s pack.timer 100');
+            expect(mainFn).toContain('scoreboard players set @s health 20');
+            expect(mainFn).toContain('scoreboard players set @s custom.timer 1');
+        });
+    });
+    describe('Timer OOP API', () => {
+        it('compiles the Timer impl API end to end', () => {
+            const source = `
+struct Timer {
+    _id: int,
+    _duration: int
+}
+
+impl Timer {
+    fn new(duration: int) -> Timer {
+        scoreboard_set("timer_ticks", #rs, 0);
+        scoreboard_set("timer_active", #rs, 0);
+        return { _id: 0, _duration: duration };
+    }
+
+    fn start(self) {
+        scoreboard_set("timer_active", #rs, 1);
+    }
+
+    fn pause(self) {
+        scoreboard_set("timer_active", #rs, 0);
+    }
+
+    fn reset(self) {
+        scoreboard_set("timer_ticks", #rs, 0);
+    }
+
+    fn done(self) -> bool {
+        let ticks: int = scoreboard_get("timer_ticks", #rs);
+        return ticks >= self._duration;
+    }
+
+    fn tick(self) {
+        let active: int = scoreboard_get("timer_active", #rs);
+        let ticks: int = scoreboard_get("timer_ticks", #rs);
+
+        if (active == 1) {
+            if (ticks < self._duration) {
+                scoreboard_set("timer_ticks", #rs, ticks + 1);
+            }
+        }
+    }
+}
+
+fn main() {
+    let t: Timer = Timer::new(100);
+    t.start();
+    t.tick();
+    let finished: bool = t.done();
+    if (finished) {
+        say("done");
+    }
+    t.pause();
+    t.reset();
+}
+`;
+            expect(typeCheck(source)).toEqual([]);
+            const files = compile(source, 'timerapi');
+            const mainFn = getFunction(files, 'main');
+            const newFn = getFunction(files, 'Timer_new');
+            const startFn = getFunction(files, 'Timer_start');
+            const tickFn = getFunction(files, 'Timer_tick');
+            const doneFn = getFunction(files, 'Timer_done');
+            const pauseFn = getFunction(files, 'Timer_pause');
+            const resetFn = getFunction(files, 'Timer_reset');
+            expect(mainFn).toContain('function timerapi:Timer_new');
+            expect(mainFn).toContain('function timerapi:Timer_start');
+            expect(mainFn).toContain('function timerapi:Timer_tick');
+            expect(mainFn).toContain('function timerapi:Timer_done');
+            expect(newFn).toContain('scoreboard players set timer_ticks rs 0');
+            expect(startFn).toContain('scoreboard players set timer_active rs 1');
+            expect(tickFn).toContain('scoreboard players get timer_active rs');
+            expect(doneFn).toContain('scoreboard players get timer_ticks rs');
+            expect(pauseFn).toContain('scoreboard players set timer_active rs 0');
+            expect(resetFn).toContain('scoreboard players set timer_ticks rs 0');
+        });
+    });
+    describe('advancement event decorators', () => {
+        it('generates advancement json with reward function path', () => {
+            const source = `
+@on_advancement("story/mine_diamond")
+fn on_mine_diamond() {
+    title(@s, "Diamond");
+}
+`;
+            const tokens = new lexer_1.Lexer(source).tokenize();
+            const ast = new parser_1.Parser(tokens).parse('test');
+            const ir = new lowering_1.Lowering('test').lower(ast);
+            const optimized = {
+                ...ir,
+                functions: ir.functions.map(fn => (0, passes_1.optimize)(fn)),
+            };
+            const generated = (0, mcfunction_1.generateDatapackWithStats)(optimized);
+            const advancement = generated.advancements.find(f => f.path === 'data/test/advancements/on_advancement_on_mine_diamond.json');
+            expect(advancement).toBeDefined();
+            const content = JSON.parse(advancement.content);
+            expect(content.criteria.trigger.trigger).toBe('minecraft:story/mine_diamond');
+            expect(content.rewards.function).toBe('test:on_mine_diamond');
+        });
+    });
+    describe('Test 1: Simple function (add)', () => {
+        const source = `
+fn add(a: int, b: int) -> int {
+    return a + b;
+}
+`;
+        it('generates mcfunction file', () => {
+            const files = compile(source);
+            const fn = getFunction(files, 'add');
+            expect(fn).toBeDefined();
+        });
+        it('copies params to named variables', () => {
+            const files = compile(source);
+            const fn = getFunction(files, 'add');
+            expect(fn).toContain('$a');
+            expect(fn).toContain('$p0');
+        });
+        it('performs addition', () => {
+            const files = compile(source);
+            const fn = getFunction(files, 'add');
+            expect(fn).toContain('+=');
+        });
+        it('returns result', () => {
+            const files = compile(source);
+            const fn = getFunction(files, 'add');
+            expect(fn).toMatch(/return/);
+        });
+    });
+    describe('Test 2: if/else (abs)', () => {
+        const source = `
+fn abs(x: int) -> int {
+    if (x < 0) {
+        return -x;
+    } else {
+        return x;
+    }
+}
+`;
+        it('generates main function and control flow blocks', () => {
+            const files = compile(source);
+            const fn = getFunction(files, 'abs');
+            expect(fn).toBeDefined();
+            // Should have conditional execution
+            expect(fn).toContain('execute if score');
+        });
+        it('has comparison logic', () => {
+            const files = compile(source);
+            const fn = getFunction(files, 'abs');
+            // Check for comparison with 0
+            expect(fn).toContain('$const_0');
+        });
+    });
+    describe('Test 3: @tick + say', () => {
+        const source = `
+@tick(rate=20)
+fn heartbeat() {
+    say("still alive");
+}
+`;
+        it('generates function with say command', () => {
+            const files = compile(source);
+            // Find the tick_body or main function that has the say command
+            const allContent = files.map(f => f.content).join('\n');
+            expect(allContent).toContain('say still alive');
+        });
+        it('is registered in tick tag', () => {
+            const files = compile(source);
+            expect(hasTickTag(files, 'test', 'heartbeat')).toBe(true);
+        });
+    });
+    describe('Builtins: command emission', () => {
+        it('compiles UI and broadcast builtins', () => {
+            const source = `
+fn test() {
+    actionbar(@a, "Fight!");
+    subtitle(@a, "Wave 2");
+    title_times(@a, 10, 60, 10);
+    announce("Arena live");
+}
+`;
+            const fn = getFunction(compile(source), 'test');
+            expect(fn).toContain('title @a actionbar {"text":"Fight!"}');
+            expect(fn).toContain('title @a subtitle {"text":"Wave 2"}');
+            expect(fn).toContain('title @a times 10 60 10');
+            expect(fn).toContain('tellraw @a {"text":"Arena live"}');
+        });
+        it('compiles world and utility builtins', () => {
+            const source = `
+fn test() {
+    tp(@s, (~1, ~0, ~-1));
+    tp(@s, @p);
+    tp(@a, (1, 64, 1));
+    clear(@s);
+    weather("clear");
+    time_set("noon");
+    gamerule("doWeatherCycle", "false");
+    setblock((0, 64, 0), "stone");
+    fill((0, 64, 0), (2, 66, 2), "glass");
+    clone((0, 64, 0), (2, 66, 2), (10, 64, 10));
+    xp_add(@s, 5);
+    xp_set(@s, 1, "levels");
+}
+`;
+            const fn = getFunction(compile(source), 'test');
+            expect(fn).toContain('tp @s ~1 ~ ~-1');
+            expect(fn).toContain('tp @s @p');
+            expect(fn).toContain('tp @a 1 64 1');
+            expect(fn).toContain('clear @s');
+            expect(fn).toContain('weather clear');
+            expect(fn).toContain('time set noon');
+            expect(fn).toContain('gamerule doWeatherCycle false');
+            expect(fn).toContain('setblock 0 64 0 stone');
+            expect(fn).toContain('fill 0 64 0 2 66 2 glass');
+            expect(fn).toContain('clone 0 64 0 2 66 2 10 64 10');
+            expect(fn).toContain('xp add @s 5 points');
+            expect(fn).toContain('xp set @s 1 levels');
+        });
+        it('compiles scoreboard display and objective builtins', () => {
+            const source = `
+fn test() {
+    scoreboard_display("sidebar", "kills");
+    scoreboard_display("list", "coins");
+    scoreboard_display("belowName", "hp");
+    scoreboard_hide("sidebar");
+    scoreboard_add_objective("kills", "playerKillCount", "Kill Count");
+    scoreboard_remove_objective("kills");
+}
+`;
+            const fn = getFunction(compile(source), 'test');
+            expect(fn).toContain('scoreboard objectives setdisplay sidebar test.kills');
+            expect(fn).toContain('scoreboard objectives setdisplay list test.coins');
+            expect(fn).toContain('scoreboard objectives setdisplay belowName test.hp');
+            expect(fn).toContain('scoreboard objectives setdisplay sidebar');
+            expect(fn).toContain('scoreboard objectives add test.kills playerKillCount "Kill Count"');
+            expect(fn).toContain('scoreboard objectives remove test.kills');
+        });
+        it('compiles bossbar builtins', () => {
+            const source = `
+fn test() {
+    bossbar_add("ns:health", "Boss Health");
+    bossbar_set_value("ns:health", 50);
+    bossbar_set_max("ns:health", 100);
+    bossbar_set_color("ns:health", "red");
+    bossbar_set_style("ns:health", "notched_10");
+    bossbar_set_visible("ns:health", true);
+    bossbar_set_players("ns:health", @a);
+    bossbar_remove("ns:health");
+    let current: int = bossbar_get_value("ns:health");
+}
+`;
+            const fn = getFunction(compile(source), 'test');
+            expect(fn).toContain('bossbar add ns:health {"text":"Boss Health"}');
+            expect(fn).toContain('bossbar set ns:health value 50');
+            expect(fn).toContain('bossbar set ns:health max 100');
+            expect(fn).toContain('bossbar set ns:health color red');
+            expect(fn).toContain('bossbar set ns:health style notched_10');
+            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 \$_\d+ rs run bossbar get ns:health value/);
+        });
+        it('compiles team builtins', () => {
+            const source = `
+fn test() {
+    team_add("red", "Red Team");
+    team_remove("red");
+    team_join("red", @a[tag=red_team]);
+    team_leave(@s);
+    team_option("red", "friendlyFire", "false");
+    team_option("red", "color", "red");
+    team_option("red", "prefix", "[Red] ");
+}
+`;
+            const fn = getFunction(compile(source), 'test');
+            expect(fn).toContain('team add red {"text":"Red Team"}');
+            expect(fn).toContain('team remove red');
+            expect(fn).toContain('team join red @a[tag=red_team]');
+            expect(fn).toContain('team leave @s');
+            expect(fn).toContain('team modify red friendlyFire false');
+            expect(fn).toContain('team modify red color red');
+            expect(fn).toContain('team modify red prefix {"text":"[Red] "}');
+        });
+    });
+    describe('Test 4: foreach', () => {
+        const source = `
+fn kill_zombies() {
+    foreach (z in @e[type=zombie, distance=..10]) {
+        kill(z);
+    }
+}
+`;
+        it('generates main function with execute as', () => {
+            const files = compile(source);
+            const fn = getFunction(files, 'kill_zombies');
+            expect(fn).toBeDefined();
+            expect(fn).toContain('execute as @e[type=minecraft:zombie,distance=..10]');
+            expect(fn).toContain('run function test:kill_zombies/foreach_0');
+        });
+        it('generates sub-function with kill @s', () => {
+            const files = compile(source);
+            // Look for the foreach sub-function
+            const subFn = files.find(f => f.path.includes('foreach_0'));
+            expect(subFn).toBeDefined();
+            expect(subFn?.content).toContain('kill @s');
+        });
+    });
+    describe('Test 5: while loop (countdown)', () => {
+        const source = `
+fn count_down() {
+    let i: int = 10;
+    while (i > 0) {
+        i = i - 1;
+    }
+}
+`;
+        it('generates function with loop structure', () => {
+            const files = compile(source);
+            const fn = getFunction(files, 'count_down');
+            expect(fn).toBeDefined();
+        });
+        it('initializes variable to 10', () => {
+            const files = compile(source);
+            const fn = getFunction(files, 'count_down');
+            expect(fn).toContain('10');
+        });
+        it('has comparison and conditional jumps', () => {
+            const files = compile(source);
+            const allContent = files
+                .filter(f => f.path.includes('count_down'))
+                .map(f => f.content)
+                .join('\n');
+            // Should have comparison with 0
+            expect(allContent).toContain('$const_0');
+            // Should have conditional execution
+            expect(allContent).toMatch(/execute if score/);
+        });
+    });
+    describe('Test 6: arrays', () => {
+        const source = `
+fn arrays() {
+    let arr: int[] = [1, 2, 3];
+    let first: int = arr[0];
+    let i: int = 1;
+    let second: int = arr[i];
+    let len: int = arr.len;
+    arr.push(4);
+    let last: int = arr.pop();
+    foreach (x in arr) {
+        say("loop");
+    }
+}
+`;
+        it('generates array storage commands', () => {
+            const files = compile(source);
+            const fn = getFunction(files, 'arrays');
+            expect(fn).toBeDefined();
+            expect(fn).toContain('data modify storage rs:heap arr set value []');
+            expect(fn).toContain('data modify storage rs:heap arr append value 1');
+            expect(fn).toContain('data modify storage rs:heap arr append value 4');
+            expect(fn).toContain('data remove storage rs:heap arr[-1]');
+        });
+        it('generates array access helpers', () => {
+            const files = compile(source);
+            const fn = getFunction(files, 'arrays');
+            expect(fn).toContain('run data get storage rs:heap arr[0]');
+            expect(fn).toContain('with storage rs:heap');
+            const helper = files.find(f => f.path.includes('array_get_'));
+            expect(helper?.content).toContain('arr[$(');
+        });
+        it('generates array foreach loop', () => {
+            const files = compile(source);
+            const allContent = files
+                .filter(f => f.path.includes('/arrays'))
+                .map(f => f.content)
+                .join('\n');
+            expect(allContent).toContain('foreach_array_check');
+            expect(allContent).toContain('say loop');
+        });
+    });
+    describe('Datapack structure', () => {
+        it('generates pack.mcmeta with proper format and description', () => {
+            const files = compile('fn test() {}');
+            const meta = files.find(f => f.path === 'pack.mcmeta');
+            expect(meta).toBeDefined();
+            const content = JSON.parse(meta.content);
+            expect(content.pack.pack_format).toBe(26);
+            expect(content.pack.description).toBe('test datapack — compiled by redscript');
+        });
+        it('generates __load.mcfunction with scoreboard setup', () => {
+            const files = compile('fn test() {}');
+            const load = files.find(f => f.path.includes('__load.mcfunction'));
+            expect(load).toBeDefined();
+            expect(load.content).toContain('# RedScript runtime init');
+            expect(load.content).toContain('scoreboard objectives add rs dummy');
+        });
+        it('generates minecraft:load tag pointing to __load', () => {
+            const files = compile('fn test() {}');
+            const tag = files.find(f => f.path === 'data/minecraft/tags/function/load.json');
+            expect(tag).toBeDefined();
+            const content = JSON.parse(tag.content);
+            expect(content.values).toContain('test:__load');
+        });
+        it('generates __tick.mcfunction for tick functions', () => {
+            const source = '@tick fn tick_fn() { say("tick"); }';
+            const files = compile(source);
+            const tickFn = files.find(f => f.path.includes('__tick.mcfunction'));
+            expect(tickFn).toBeDefined();
+            expect(tickFn.content).toContain('# RedScript tick dispatcher');
+            expect(tickFn.content).toContain('function test:tick_fn');
+        });
+        it('generates minecraft:tick tag pointing to __tick', () => {
+            const source = '@tick fn tick_fn() { say("tick"); }';
+            const files = compile(source);
+            const tag = files.find(f => f.path === 'data/minecraft/tags/function/tick.json');
+            expect(tag).toBeDefined();
+            const content = JSON.parse(tag.content);
+            expect(content.values).toContain('test:__tick');
+        });
+        it('does not generate tick infrastructure when no tick functions', () => {
+            const files = compile('fn test() {}');
+            const tickFn = files.find(f => f.path.includes('__tick.mcfunction'));
+            const tickTag = files.find(f => f.path.includes('tick.json'));
+            expect(tickFn).toBeUndefined();
+            expect(tickTag).toBeUndefined();
+        });
+    });
+    describe('Scoreboard interop', () => {
+        it('compiles scoreboard_get to read vanilla scores', () => {
+            const source = `
+fn test() -> int {
+    let kills: int = scoreboard_get("PlayerName", "kill_count");
+    return kills;
+}
+`;
+            const files = compile(source);
+            const fn = getFunction(files, 'test');
+            expect(fn).toBeDefined();
+            expect(fn).toContain('execute store result score');
+            expect(fn).toContain('scoreboard players get PlayerName test.kill_count');
+        });
+        it('compiles scoreboard_get with @s selector', () => {
+            const source = `
+fn test() -> int {
+    let my_kills: int = scoreboard_get("@s", "kill_count");
+    return my_kills;
+}
+`;
+            const files = compile(source);
+            const fn = getFunction(files, 'test');
+            expect(fn).toBeDefined();
+            expect(fn).toContain('scoreboard players get @s test.kill_count');
+        });
+        it('compiles scoreboard_set with constant value', () => {
+            const source = `
+fn test() {
+    scoreboard_set("PlayerName", "kill_count", 100);
+}
+`;
+            const files = compile(source);
+            const fn = getFunction(files, 'test');
+            expect(fn).toBeDefined();
+            expect(fn).toContain('scoreboard players set PlayerName test.kill_count 100');
+        });
+        it('compiles scoreboard_set with variable value', () => {
+            const source = `
+fn test() {
+    let value: int = 42;
+    scoreboard_set("@s", "score", value);
+}
+`;
+            const files = compile(source);
+            const allContent = files
+                .filter(f => f.path.includes('test'))
+                .map(f => f.content)
+                .join('\n');
+            expect(allContent).toContain('execute store result score @s test.score');
+        });
+        it('compiles score() as expression', () => {
+            const source = `
+fn test() -> int {
+    let level: int = score("@s", "minecraft.custom:minecraft.play_one_minute");
+    return level;
+}
+`;
+            const files = compile(source);
+            const fn = getFunction(files, 'test');
+            expect(fn).toBeDefined();
+            expect(fn).toContain('scoreboard players get @s minecraft.custom:minecraft.play_one_minute');
+        });
+        it('uses scoreboard values in expressions', () => {
+            const source = `
+fn double_score() -> int {
+    let s: int = scoreboard_get("@s", "points");
+    let doubled: int = s * 2;
+    scoreboard_set("@s", "points", doubled);
+    return doubled;
+}
+`;
+            const files = compile(source);
+            const fn = getFunction(files, 'double_score');
+            expect(fn).toBeDefined();
+            expect(fn).toContain('scoreboard players get @s test.points');
+        });
+    });
+    describe('Built-in functions', () => {
+        it('compiles give()', () => {
+            const source = 'fn test() { give(@p, "diamond", 64); }';
+            const files = compile(source);
+            const fn = getFunction(files, 'test');
+            expect(fn).toContain('give @p diamond 64');
+        });
+        it('compiles summon()', () => {
+            const source = 'fn test() { summon("zombie"); }';
+            const files = compile(source);
+            const fn = getFunction(files, 'test');
+            expect(fn).toContain('summon zombie');
+        });
+        it('compiles effect()', () => {
+            const source = 'fn test() { effect(@a, "speed", 60, 2); }';
+            const files = compile(source);
+            const fn = getFunction(files, 'test');
+            expect(fn).toContain('effect give @a speed 60 2');
+        });
+        it('compiles tp()', () => {
+            const source = 'fn test() { tp(@s, (0, 100, 0)); }';
+            const files = compile(source);
+            const fn = getFunction(files, 'test');
+            expect(fn).toContain('tp @s 0 100 0');
+        });
+        it('type checks tp selector destinations', () => {
+            const invalid = typeCheck('fn test() { tp(@s, @a); }');
+            expect(invalid.map(err => err.message)).toContain('tp destination must be a single-entity selector (@s, @p, @r, or limit=1)');
+            expect(typeCheck('fn test() { tp(@s, @p); }')).toHaveLength(0);
+            expect(typeCheck('fn test() { tp(@s, @e[limit=1, tag=target]); }')).toHaveLength(0);
+        });
+        it('compiles random()', () => {
+            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 $_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 $_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 $_0 rs run random value 0 100');
+        });
+        it('compiles random_sequence()', () => {
+            const source = 'fn test() { random_sequence("loot"); random_sequence("loot", 9); }';
+            const files = compile(source);
+            const fn = getFunction(files, 'test');
+            expect(fn).toContain('random reset loot 0');
+            expect(fn).toContain('random reset loot 9');
+        });
+    });
+    describe('Selectors', () => {
+        it('handles simple selectors', () => {
+            const source = 'fn test() { kill(@e); }';
+            const files = compile(source);
+            const fn = getFunction(files, 'test');
+            expect(fn).toContain('kill @e');
+        });
+        it('handles selectors with type filter', () => {
+            const source = 'fn test() { kill(@e[type=creeper]); }';
+            const files = compile(source);
+            const fn = getFunction(files, 'test');
+            expect(fn).toContain('kill @e[type=minecraft:creeper]');
+        });
+        it('handles selectors with multiple filters', () => {
+            const source = 'fn test() { kill(@e[type=zombie, distance=..5, limit=1]); }';
+            const files = compile(source);
+            const fn = getFunction(files, 'test');
+            expect(fn).toContain('type=minecraft:zombie');
+            expect(fn).toContain('distance=..5');
+            expect(fn).toContain('limit=1');
+        });
+        it('handles tag filters', () => {
+            const source = 'fn test() { kill(@e[tag=boss, tag=!friendly]); }';
+            const files = compile(source);
+            const fn = getFunction(files, 'test');
+            expect(fn).toContain('tag=boss');
+            expect(fn).toContain('tag=!friendly');
+        });
+    });
+    describe('For loop', () => {
+        it('compiles basic for loop', () => {
+            const source = `
+fn count() {
+    for (let i: int = 0; i < 10; i = i + 1) {
+        say("loop");
+    }
+}
+`;
+            const files = compile(source);
+            const allContent = files
+                .filter(f => f.path.includes('count'))
+                .map(f => f.content)
+                .join('\n');
+            // Should have initialization (set to 0)
+            expect(allContent).toContain('0');
+            // Should have say command
+            expect(allContent).toContain('say loop');
+            // Should have comparison
+            expect(allContent).toContain('$const_10');
+            // Should have loop structure
+            expect(allContent).toContain('for_check');
+        });
+        it('compiles for loop without init', () => {
+            const source = `
+fn count() {
+    let i: int = 5;
+    for (; i > 0; i = i - 1) {
+        say("counting");
+    }
+}
+`;
+            const files = compile(source);
+            const allContent = files
+                .filter(f => f.path.includes('count'))
+                .map(f => f.content)
+                .join('\n');
+            expect(allContent).toContain('say counting');
+            expect(allContent).toContain('for_check');
+        });
+        it('compiles for loop with compound step', () => {
+            const source = `
+fn double() {
+    for (let x: int = 1; x < 100; x = x * 2) {
+        say("doubling");
+    }
+}
+`;
+            const files = compile(source);
+            const fn = getFunction(files, 'double');
+            expect(fn).toBeDefined();
+        });
+        it('generates correct control flow blocks', () => {
+            const source = `
+fn loop_test() {
+    for (let i: int = 0; i < 5; i = i + 1) {
+        say("iteration");
+    }
+}
+`;
+            const files = compile(source);
+            // Should have for_check block
+            const checkBlock = files.find(f => f.path.includes('for_check'));
+            expect(checkBlock).toBeDefined();
+            // Should have for_body block
+            const bodyBlock = files.find(f => f.path.includes('for_body'));
+            expect(bodyBlock).toBeDefined();
+        });
+        it('compiles nested for loops', () => {
+            const source = `
+fn nested() {
+    for (let i: int = 0; i < 3; i = i + 1) {
+        for (let j: int = 0; j < 3; j = j + 1) {
+            say("nested");
+        }
+    }
+}
+`;
+            const files = compile(source);
+            const allContent = files
+                .filter(f => f.path.includes('nested'))
+                .map(f => f.content)
+                .join('\n');
+            expect(allContent).toContain('say nested');
+        });
+    });
+    describe('Control flow', () => {
+        it('handles nested if statements', () => {
+            const source = `
+fn nested(x: int, y: int) {
+    if (x > 0) {
+        if (y > 0) {
+            say("both positive");
+        }
+    }
+}
+`;
+            const files = compile(source);
+            const allContent = files
+                .filter(f => f.path.includes('nested'))
+                .map(f => f.content)
+                .join('\n');
+            expect(allContent).toContain('say both positive');
+        });
+        it('handles else-if chains', () => {
+            const source = `
+fn grade(score: int) {
+    if (score >= 90) {
+        say("A");
+    } else {
+        if (score >= 80) {
+            say("B");
+        } else {
+            say("C");
+        }
+    }
+}
+`;
+            const files = compile(source);
+            const allContent = files
+                .filter(f => f.path.includes('grade'))
+                .map(f => f.content)
+                .join('\n');
+            expect(allContent).toContain('say A');
+            expect(allContent).toContain('say B');
+            expect(allContent).toContain('say C');
+        });
+    });
+    describe('as/at blocks', () => {
+        it('compiles as block', () => {
+            const source = `
+fn greet_all() {
+    as @a {
+        say("Hello!");
+    }
+}
+`;
+            const files = compile(source);
+            const fn = getFunction(files, 'greet_all');
+            expect(fn).toContain('execute as @a');
+            expect(fn).toContain('run function test:greet_all/');
+        });
+        it('compiles at block', () => {
+            const source = `
+fn spawn_at_players() {
+    at @a {
+        summon("zombie");
+    }
+}
+`;
+            const files = compile(source);
+            const fn = getFunction(files, 'spawn_at_players');
+            expect(fn).toContain('execute at @a');
+            expect(fn).toContain('run function test:spawn_at_players/');
+        });
+    });
+    describe('Float type (fixed-point)', () => {
+        it('stores float as fixed-point × 1000', () => {
+            const source = `
+fn test() -> int {
+    let pi: float = 3.14;
+    return pi;
+}
+`;
+            const files = compile(source);
+            const allContent = files.map(f => f.content).join('\n');
+            // 3.14 * 1000 = 3140
+            expect(allContent).toContain('3140');
+        });
+        it('handles float addition correctly', () => {
+            const source = `
+fn test() -> int {
+    let a: float = 1.5;
+    let b: float = 2.5;
+    let c: float = a + b;
+    return c;
+}
+`;
+            const files = compile(source);
+            const allContent = files.map(f => f.content).join('\n');
+            // 1.5 * 1000 = 1500, 2.5 * 1000 = 2500
+            expect(allContent).toContain('1500');
+            expect(allContent).toContain('2500');
+            // Addition should use +=
+            expect(allContent).toContain('+=');
+        });
+        it('handles float multiplication with scaling', () => {
+            const source = `
+fn test() {
+    let a: float = 2.0;
+    let b: float = 3.0;
+    let c: float = a * b;
+}
+`;
+            const files = compile(source);
+            const allContent = files.map(f => f.content).join('\n');
+            // Should have 2000 and 3000 (the fixed-point values)
+            expect(allContent).toContain('2000');
+            expect(allContent).toContain('3000');
+            // Should divide after multiplication (for fixed-point correction)
+            expect(allContent).toContain('/=');
+        });
+        it('handles float division with scaling', () => {
+            const source = `
+fn test() {
+    let a: float = 10.0;
+    let b: float = 2.0;
+    let c: float = a / b;
+}
+`;
+            const files = compile(source);
+            const allContent = files.map(f => f.content).join('\n');
+            // Should multiply by 1000 before division
+            expect(allContent).toContain('*=');
+            // Should then divide
+            expect(allContent).toContain('/=');
+        });
+        it('handles small float literals', () => {
+            const source = `
+fn test() -> int {
+    let x: float = 0.001;
+    let y: float = 0.5;
+    let z: float = x + y;
+    return 0;
+}
+`;
+            const files = compile(source);
+            const allContent = files.map(f => f.content).join('\n');
+            // 0.001 * 1000 = 1, 0.5 * 1000 = 500
+            // Check that fixed-point values are present
+            expect(allContent).toContain('$const_1');
+            expect(allContent).toContain('500');
+        });
+        it('handles float in expressions', () => {
+            const source = `
+fn calc() {
+    let speed: float = 1.5;
+    let time: float = 2.0;
+    let distance: float = speed * time;
+}
+`;
+            const files = compile(source);
+            const fn = getFunction(files, 'calc');
+            expect(fn).toBeDefined();
+        });
+    });
+    describe('Optimization', () => {
+        it('folds constants', () => {
+            const source = 'fn test() -> int { return 2 + 3; }';
+            const files = compile(source);
+            const fn = getFunction(files, 'test');
+            // After constant folding, should have direct value 5
+            expect(fn).toContain('5');
+        });
+        it('propagates copies', () => {
+            const source = `
+fn test() -> int {
+    let x: int = 10;
+    let y: int = x;
+    return y;
+}
+`;
+            const files = compile(source);
+            const fn = getFunction(files, 'test');
+            // Should have 10 in the output (propagated)
+            expect(fn).toContain('10');
+        });
+    });
+    describe('Multiple functions', () => {
+        it('compiles multiple functions', () => {
+            const source = `
+fn helper() -> int {
+    return 42;
+}
+
+fn main() -> int {
+    return helper();
+}
+`;
+            const files = compile(source);
+            expect(getFunction(files, 'helper')).toBeDefined();
+            expect(getFunction(files, 'main')).toBeDefined();
+        });
+        it('generates function calls', () => {
+            const source = `
+fn helper() -> int {
+    return 42;
+}
+
+fn main() -> int {
+    return helper();
+}
+`;
+            const files = compile(source);
+            const main = getFunction(files, 'main');
+            expect(main).toContain('function test:helper');
+        });
+    });
+    describe('Raw commands', () => {
+        it('passes through raw commands', () => {
+            const source = 'fn test() { raw("gamemode creative @a"); }';
+            const files = compile(source);
+            const fn = getFunction(files, 'test');
+            expect(fn).toContain('gamemode creative @a');
+        });
+        it('preserves complex raw commands', () => {
+            const source = 'fn test() { raw("execute as @a at @s run particle flame ~ ~ ~ 0.5 0.5 0.5 0 10"); }';
+            const files = compile(source);
+            const fn = getFunction(files, 'test');
+            expect(fn).toContain('execute as @a at @s run particle flame');
+        });
+    });
+    describe('Compound assignment', () => {
+        it('compiles += operator', () => {
+            const source = `
+fn test() {
+    let x: int = 5;
+    x += 3;
+}
+`;
+            const files = compile(source);
+            const allContent = files.map(f => f.content).join('\n');
+            // Should have both 5 and 3, and addition
+            expect(allContent).toContain('5');
+            expect(allContent).toContain('3');
+        });
+        it('compiles all compound operators', () => {
+            const source = `
+fn test() {
+    let x: int = 10;
+    x += 1;
+    x -= 1;
+    x *= 2;
+    x /= 2;
+    x %= 3;
+}
+`;
+            const files = compile(source);
+            // Should compile without error
+            expect(getFunction(files, 'test')).toBeDefined();
+        });
+    });
+    describe('Trigger system', () => {
+        it('generates trigger objective in __load.mcfunction', () => {
+            const source = `
+@on_trigger("claim_reward")
+fn handle_claim() {
+    say("Claimed!");
+}
+`;
+            const files = compile(source);
+            const load = files.find(f => f.path.includes('__load.mcfunction'));
+            expect(load?.content).toContain('scoreboard objectives add claim_reward trigger');
+            expect(load?.content).toContain('scoreboard players enable @a claim_reward');
+        });
+        it('generates trigger check in __tick function', () => {
+            const source = `
+@on_trigger("claim_reward")
+fn handle_claim() {
+    say("Claimed!");
+}
+`;
+            const files = compile(source);
+            // Trigger checks are now in __tick.mcfunction
+            const tickFn = files.find(f => f.path.includes('__tick.mcfunction'));
+            expect(tickFn).toBeDefined();
+            expect(tickFn?.content).toContain('execute as @a[scores={claim_reward=1..}]');
+            expect(tickFn?.content).toContain('run function test:__trigger_claim_reward_dispatch');
+        });
+        it('generates trigger dispatch function', () => {
+            const source = `
+@on_trigger("claim_reward")
+fn handle_claim() {
+    say("Claimed!");
+}
+`;
+            const files = compile(source);
+            const dispatch = files.find(f => f.path.includes('__trigger_claim_reward_dispatch.mcfunction'));
+            expect(dispatch).toBeDefined();
+            expect(dispatch?.content).toContain('function test:handle_claim');
+            expect(dispatch?.content).toContain('scoreboard players set @s claim_reward 0');
+            expect(dispatch?.content).toContain('scoreboard players enable @s claim_reward');
+        });
+        it('registers __tick in tick tag when triggers exist', () => {
+            const source = `
+@on_trigger("claim_reward")
+fn handle_claim() {
+    say("Claimed!");
+}
+`;
+            const files = compile(source);
+            const tickTag = files.find(f => f.path === 'data/minecraft/tags/function/tick.json');
+            expect(tickTag).toBeDefined();
+            const content = JSON.parse(tickTag.content);
+            // All tick functionality is routed through __tick
+            expect(content.values).toContain('test:__tick');
+        });
+        it('combines tick functions and trigger check in __tick', () => {
+            const source = `
+@tick
+fn game_loop() {
+    say("tick");
+}
+
+@on_trigger("claim_reward")
+fn handle_claim() {
+    say("Claimed!");
+}
+`;
+            const files = compile(source);
+            // tick.json points to __tick
+            const tickTag = files.find(f => f.path === 'data/minecraft/tags/function/tick.json');
+            expect(tickTag).toBeDefined();
+            const content = JSON.parse(tickTag.content);
+            expect(content.values).toContain('test:__tick');
+            // __tick.mcfunction calls both tick functions and trigger checks
+            const tickFn = files.find(f => f.path.includes('__tick.mcfunction'));
+            expect(tickFn).toBeDefined();
+            expect(tickFn?.content).toContain('function test:game_loop');
+            expect(tickFn?.content).toContain('execute as @a[scores={claim_reward=1..}]');
+        });
+    });
+    describe('Entity tag methods', () => {
+        it('compiles entity.tag()', () => {
+            const source = 'fn test() { @s.tag("boss"); }';
+            const files = compile(source);
+            const fn = getFunction(files, 'test');
+            expect(fn).toContain('tag @s add boss');
+        });
+        it('compiles entity.untag()', () => {
+            const source = 'fn test() { @s.untag("boss"); }';
+            const files = compile(source);
+            const fn = getFunction(files, 'test');
+            expect(fn).toContain('tag @s remove boss');
+        });
+        it('compiles entity.has_tag()', () => {
+            const source = 'fn test() { let x: bool = @s.has_tag("boss"); }';
+            const files = compile(source);
+            const fn = getFunction(files, 'test');
+            expect(fn).toContain('if entity @s[tag=boss]');
+        });
+    });
+    describe('Real program: zombie_game.mcrs', () => {
+        const source = `
+// A zombie survival game logic
+// Kills nearby zombies and tracks score
+
+@tick(rate=20)
+fn check_zombies() {
+    foreach (z in @e[type=zombie, distance=..10]) {
+        kill(z);
+    }
+}
+
+@tick(rate=100)
+fn announce() {
+    say("Zombie check complete");
+}
+
+fn reward_player() {
+    give(@s, "minecraft:diamond", 1);
+    title(@s, "Zombie Slayer!");
+}
+
+@on_trigger("claim_reward")
+fn handle_claim() {
+    reward_player();
+}
+`;
+        it('compiles without errors', () => {
+            const files = compile(source, 'zombie');
+            expect(files.length).toBeGreaterThan(0);
+        });
+        it('generates check_zombies with foreach loop', () => {
+            const files = compile(source, 'zombie');
+            // With tick rate, the foreach is in tick_body block
+            const allContent = files
+                .filter(f => f.path.includes('check_zombies'))
+                .map(f => f.content)
+                .join('\n');
+            expect(allContent).toContain('execute as @e[type=minecraft:zombie,distance=..10]');
+        });
+        it('generates foreach sub-function with kill @s', () => {
+            const files = compile(source, 'zombie');
+            const subFn = files.find(f => f.path.includes('check_zombies/foreach_0'));
+            expect(subFn).toBeDefined();
+            expect(subFn?.content).toContain('kill @s');
+        });
+        it('generates announce function with say command', () => {
+            const files = compile(source, 'zombie');
+            const allContent = files
+                .filter(f => f.path.includes('announce'))
+                .map(f => f.content)
+                .join('\n');
+            expect(allContent).toContain('say Zombie check complete');
+        });
+        it('generates reward_player with give and title', () => {
+            const files = compile(source, 'zombie');
+            const fn = getFunction(files, 'reward_player');
+            expect(fn).toContain('give @s minecraft:diamond 1');
+            expect(fn).toContain('title @s title');
+            expect(fn).toContain('Zombie Slayer!');
+        });
+        it('registers __tick in tick tag and calls tick functions', () => {
+            const files = compile(source, 'zombie');
+            const tickTag = files.find(f => f.path === 'data/minecraft/tags/function/tick.json');
+            expect(tickTag).toBeDefined();
+            const content = JSON.parse(tickTag.content);
+            expect(content.values).toContain('zombie:__tick');
+            // __tick should call both tick functions
+            const tickFn = files.find(f => f.path.includes('__tick.mcfunction'));
+            expect(tickFn).toBeDefined();
+            expect(tickFn?.content).toContain('function zombie:check_zombies');
+            expect(tickFn?.content).toContain('function zombie:announce');
+        });
+        it('generates trigger infrastructure for claim_reward', () => {
+            const files = compile(source, 'zombie');
+            // Check __load.mcfunction has trigger objective
+            const load = files.find(f => f.path.includes('__load.mcfunction'));
+            expect(load?.content).toContain('scoreboard objectives add claim_reward trigger');
+            // Check dispatch function exists
+            const dispatch = files.find(f => f.path.includes('__trigger_claim_reward_dispatch'));
+            expect(dispatch).toBeDefined();
+            expect(dispatch?.content).toContain('function zombie:handle_claim');
+            // Check trigger_check is in __tick.mcfunction
+            const tickFn = files.find(f => f.path.includes('__tick.mcfunction'));
+            expect(tickFn).toBeDefined();
+            expect(tickFn?.content).toContain('execute as @a[scores={claim_reward=1..}]');
+        });
+        it('generates function call from handle_claim to reward_player', () => {
+            const files = compile(source, 'zombie');
+            const fn = getFunction(files, 'handle_claim');
+            expect(fn).toContain('function zombie:reward_player');
+        });
+    });
+    describe('Test 11: Struct types backed by NBT storage', () => {
+        const source = `
+struct Point { x: int, y: int }
+
+fn test_struct() {
+    let p: Point = { x: 10, y: 20 };
+    p.x = 30;
+    let val = p.x;
+}
+`;
+        it('generates struct field initialization with NBT storage', () => {
+            const files = compile(source, 'structs');
+            const fn = getFunction(files, 'test_struct');
+            expect(fn).toBeDefined();
+            expect(fn).toContain('data modify storage rs:heap point_p.x set value 10');
+            expect(fn).toContain('data modify storage rs:heap point_p.y set value 20');
+        });
+        it('generates struct field assignment', () => {
+            const files = compile(source, 'structs');
+            const fn = getFunction(files, 'test_struct');
+            expect(fn).toContain('data modify storage rs:heap point_p.x set value 30');
+        });
+        it('generates struct field read into scoreboard', () => {
+            const files = compile(source, 'structs');
+            const fn = getFunction(files, 'test_struct');
+            expect(fn).toContain('execute store result score');
+            expect(fn).toContain('data get storage rs:heap point_p.x');
+        });
+    });
+    describe('Test 12: Struct compound assignment', () => {
+        const source = `
+struct Counter { value: int }
+
+fn test_compound() {
+    let c: Counter = { value: 0 };
+    c.value += 10;
+    c.value -= 5;
+}
+`;
+        it('generates read-modify-write for compound assignment', () => {
+            const files = compile(source, 'compound');
+            const fn = getFunction(files, 'test_compound');
+            expect(fn).toBeDefined();
+            // Should read, add, write back
+            expect(fn).toContain('data get storage rs:heap counter_c.value');
+            expect(fn).toContain('+=');
+        });
+    });
+    describe('Test 13: int[] array type', () => {
+        const source = `
+fn test_array() {
+    let arr: int[] = [];
+    arr.push(42);
+    arr.push(100);
+    let first = arr[0];
+}
+`;
+        it('initializes empty array in NBT storage', () => {
+            const files = compile(source, 'arrays');
+            const fn = getFunction(files, 'test_array');
+            expect(fn).toBeDefined();
+            expect(fn).toContain('data modify storage rs:heap arr set value []');
+        });
+        it('generates array push', () => {
+            const files = compile(source, 'arrays');
+            const fn = getFunction(files, 'test_array');
+            expect(fn).toContain('data modify storage rs:heap arr append value 42');
+            expect(fn).toContain('data modify storage rs:heap arr append value 100');
+        });
+        it('generates array index access', () => {
+            const files = compile(source, 'arrays');
+            const fn = getFunction(files, 'test_array');
+            expect(fn).toContain('data get storage rs:heap arr[0]');
+        });
+    });
+    describe('Test 14: Array with initial values', () => {
+        const source = `
+fn test_init_array() {
+    let nums: int[] = [1, 2, 3];
+}
+`;
+        it('initializes array with values', () => {
+            const files = compile(source, 'initarr');
+            const fn = getFunction(files, 'test_init_array');
+            expect(fn).toBeDefined();
+            expect(fn).toContain('data modify storage rs:heap nums set value []');
+            expect(fn).toContain('data modify storage rs:heap nums append value 1');
+            expect(fn).toContain('data modify storage rs:heap nums append value 2');
+            expect(fn).toContain('data modify storage rs:heap nums append value 3');
+        });
+    });
+    describe('Test 15: World objects (armor stands)', () => {
+        const source = `
+fn test_spawn() {
+    let turret = spawn_object(10, 64, 20);
+    turret.health = 100;
+}
+`;
+        it('generates summon command for world object', () => {
+            const files = compile(source, 'world');
+            const fn = getFunction(files, 'test_spawn');
+            expect(fn).toBeDefined();
+            expect(fn).toContain('summon minecraft:armor_stand 10 64 20');
+            expect(fn).toContain('Invisible:1b');
+            expect(fn).toContain('Marker:1b');
+            expect(fn).toContain('NoGravity:1b');
+            expect(fn).toContain('Tags:["__rs_obj_');
+        });
+        it('generates scoreboard set for world object field', () => {
+            const files = compile(source, 'world');
+            const fn = getFunction(files, 'test_spawn');
+            expect(fn).toContain('scoreboard players set @e[tag=__rs_obj_');
+            expect(fn).toContain('rs 100');
+        });
+    });
+    describe('Test 16: World object compound operations', () => {
+        const source = `
+fn test_damage() {
+    let obj = spawn_object(0, 64, 0);
+    obj.health = 100;
+    obj.health -= 10;
+}
+`;
+        it('generates compound assignment on world object', () => {
+            const files = compile(source, 'damage');
+            const fn = getFunction(files, 'test_damage');
+            expect(fn).toBeDefined();
+            // Should have -= operation
+            expect(fn).toContain('scoreboard players operation @e[tag=__rs_obj_');
+            expect(fn).toContain('-=');
+        });
+    });
+    describe('Test 17: Kill world object', () => {
+        const source = `
+fn test_kill() {
+    let obj = spawn_object(0, 64, 0);
+    kill(obj);
+}
+`;
+        it('generates kill command for world object', () => {
+            const files = compile(source, 'killobj');
+            const fn = getFunction(files, 'test_kill');
+            expect(fn).toBeDefined();
+            expect(fn).toContain('kill @e[tag=__rs_obj_');
+        });
+    });
+});
+describe('#mc_name syntax', () => {
+    describe('scoreboard with #mc_name objective', () => {
+        const source = `
+fn heal(amount: int) {
+    let health: int = scoreboard_get(@p, #health);
+    let next: int = health + amount;
+    scoreboard_set(@p, #health, next);
+}
+`;
+        it('compiles #health to bare objective name (no quotes)', () => {
+            const files = compile(source, 'mcname');
+            const fn = getFunction(files, 'heal');
+            expect(fn).toBeDefined();
+            expect(fn).toContain('scoreboard players get @p health');
+        });
+        it('does not produce quoted "health" in output', () => {
+            const files = compile(source, 'mcname');
+            const fn = getFunction(files, 'heal');
+            expect(fn).not.toContain('"health"');
+        });
+    });
+    describe('backward compat: string objective still works', () => {
+        const source = `fn test() { let x: int = scoreboard_get(@s, "kills"); }`;
+        it('prefixes plain string objectives with the active namespace', () => {
+            const files = compile(source, 'compat');
+            const fn = getFunction(files, 'test');
+            expect(fn).toContain('scoreboard players get @s compat.kills');
+        });
+    });
+    describe('#mc_name with fake player target', () => {
+        const source = `
+fn tick_game() {
+    let timer: int = scoreboard_get(#game, #timer);
+    scoreboard_set(#game, #timer, timer - 1);
+}
+`;
+        it('compiles #game fake player and #timer objective correctly', () => {
+            const files = compile(source, 'fakeplay');
+            const fn = getFunction(files, 'tick_game');
+            expect(fn).toBeDefined();
+            expect(fn).toContain('scoreboard players get game timer');
+            expect(fn).toContain('game timer');
+        });
+    });
+    describe('tag_add with #mc_name', () => {
+        const source = `fn mark() { tag_add(@s, #hasKey); }`;
+        it('compiles tag_add with #mc_name', () => {
+            const files = compile(source, 'tagname');
+            const fn = getFunction(files, 'mark');
+            expect(fn).toBeDefined();
+            expect(fn).toContain('tag @s add hasKey');
+        });
+    });
+    describe('gamerule with #mc_name', () => {
+        const source = `fn setup() { gamerule(#keepInventory, true); }`;
+        it('compiles gamerule with #mc_name', () => {
+            const files = compile(source, 'gamerule');
+            const fn = getFunction(files, 'setup');
+            expect(fn).toBeDefined();
+            expect(fn).toContain('gamerule keepInventory');
+        });
+    });
+    describe('NBT literals', () => {
+        it('compiles byte literal', () => {
+            const files = compile('fn test() -> int { let x: byte = 20b; return x; }', 'nbt');
+            const fn = getFunction(files, 'test');
+            expect(fn).toBeDefined();
+            expect(fn).toContain('20');
+        });
+        it('compiles short literal', () => {
+            const files = compile('fn test() -> int { let x: short = 100s; return x; }', 'nbt');
+            const fn = getFunction(files, 'test');
+            expect(fn).toBeDefined();
+            expect(fn).toContain('100');
+        });
+        it('compiles long literal', () => {
+            const files = compile('fn test() -> int { let x: long = 1000L; return x; }', 'nbt');
+            const fn = getFunction(files, 'test');
+            expect(fn).toBeDefined();
+            expect(fn).toContain('1000');
+        });
+        it('compiles double literal', () => {
+            const files = compile('fn test() -> int { let x: double = 3.14d; return x; }', 'nbt');
+            const fn = getFunction(files, 'test');
+            expect(fn).toBeDefined();
+        });
+        it('compiles float literal with f suffix', () => {
+            const files = compile('fn test() -> int { let x: float = 2.5f; return x; }', 'nbt');
+            const fn = getFunction(files, 'test');
+            expect(fn).toBeDefined();
+        });
+        it('type-checks NBT literals without errors', () => {
+            const errors = typeCheck(`
+        fn test() {
+          let a = 20b;
+          let b = 100s;
+          let c = 1000L;
+          let d = 3.14d;
+          let e = 2.5f;
+        }
+      `);
+            expect(errors).toHaveLength(0);
+        });
+    });
+    // ---------------------------------------------------------------------------
+    // Type Inference
+    // ---------------------------------------------------------------------------
+    describe('Type inference', () => {
+        it('infers int type', () => {
+            const errors = typeCheck(`
+        fn test() {
+          let x = 5;
+          let y: int = x + 1;
+        }
+      `);
+            expect(errors).toHaveLength(0);
+        });
+        it('infers string type', () => {
+            const errors = typeCheck(`
+        fn test() {
+          let x = "hello";
+          let y: string = x;
+        }
+      `);
+            expect(errors).toHaveLength(0);
+        });
+        it('infers bool type', () => {
+            const errors = typeCheck(`
+        fn test() {
+          let x = true;
+          let y: bool = x;
+        }
+      `);
+            expect(errors).toHaveLength(0);
+        });
+        it('infers from function return', () => {
+            const errors = typeCheck(`
+        fn get_value() -> int { return 42; }
+        fn test() {
+          let x = get_value();
+          let y: int = x + 1;
+        }
+      `);
+            expect(errors).toHaveLength(0);
+        });
+        it('infers NBT types from suffix', () => {
+            const files = compile(`
+        fn test() {
+          let a = 20b;
+          let b = 100s;
+          let c = 1000L;
+          let d = 3.14d;
+        }
+      `);
+            expect(files.length).toBeGreaterThan(0);
+        });
+        it('detects type mismatch with inferred type', () => {
+            const errors = typeCheck(`
+        fn test() {
+          let x = 5;
+          let y: string = x;
+        }
+      `);
+            expect(errors.length).toBeGreaterThan(0);
+        });
+        it('compiles let without type annotation', () => {
+            const files = compile(`
+        fn test() {
+          let x = 5;
+          let y = x + 1;
+        }
+      `);
+            expect(files.length).toBeGreaterThan(0);
+        });
+    });
+});
+describe('for-range loop', () => {
+    it('compiles basic for-range loop', () => {
+        const src = `fn test() { for i in 0..5 { say("hi"); } }`;
+        const files = compile(src, 'forloop');
+        expect(files.some(f => f.path.includes('__for'))).toBe(true);
+    });
+    it('initializes loop variable', () => {
+        const src = `fn test() { for i in 0..5 { say("hi"); } }`;
+        const files = compile(src, 'forloop');
+        const fn = getFunction(files, 'test');
+        expect(fn).toContain('scoreboard players set $test_i rs 0');
+    });
+    it('generates loop sub-function with increment and condition', () => {
+        const src = `fn test() { for i in 0..5 { say("hi"); } }`;
+        const files = compile(src, 'forloop');
+        const subFn = files.find(f => f.path.includes('__for_0'));
+        expect(subFn).toBeDefined();
+        expect(subFn?.content).toContain('say hi');
+        expect(subFn?.content).toContain('scoreboard players add $test_i rs 1');
+        expect(subFn?.content).toContain('execute if score $test_i rs matches ..4 run function forloop:test/__for_0');
+    });
+    it('supports non-zero start', () => {
+        const src = `fn test() { for x in 3..8 { say("loop"); } }`;
+        const files = compile(src, 'forloop2');
+        const fn = getFunction(files, 'test');
+        expect(fn).toContain('scoreboard players set $test_x rs 3');
+        const subFn = files.find(f => f.path.includes('__for_0'));
+        expect(subFn?.content).toContain('execute if score $test_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