redscript-mc 2.6.2 → 3.0.1

package/dist/__tests__/e2e.test.js

@@ -1,1847 +0,0 @@
-"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