redscript-mc 1.1.0 → 1.2.1

package/dist/__tests__/e2e.test.js

@@ -124,6 +124,184 @@ fn main() {
             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=player] run function test:main/then_');
+            expect(foreachFn).toContain('execute if entity @s[type=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 = `
@@ -276,12 +454,12 @@ fn test() {
 }
 `;
             const fn = getFunction(compile(source), 'test');
-            expect(fn).toContain('scoreboard objectives setdisplay sidebar kills');
-            expect(fn).toContain('scoreboard objectives setdisplay list coins');
-            expect(fn).toContain('scoreboard objectives setdisplay belowName hp');
+            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 kills playerKillCount "Kill Count"');
-            expect(fn).toContain('scoreboard objectives remove kills');
+            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 = `
@@ -485,7 +663,7 @@ fn test() -> int {
             const fn = getFunction(files, 'test');
             expect(fn).toBeDefined();
             expect(fn).toContain('execute store result score');
-            expect(fn).toContain('scoreboard players get PlayerName kill_count');
+            expect(fn).toContain('scoreboard players get PlayerName test.kill_count');
         });
         it('compiles scoreboard_get with @s selector', () => {
             const source = `
@@ -497,7 +675,7 @@ fn test() -> int {
             const files = compile(source);
             const fn = getFunction(files, 'test');
             expect(fn).toBeDefined();
-            expect(fn).toContain('scoreboard players get @s kill_count');
+            expect(fn).toContain('scoreboard players get @s test.kill_count');
         });
         it('compiles scoreboard_set with constant value', () => {
             const source = `
@@ -508,7 +686,7 @@ fn test() {
             const files = compile(source);
             const fn = getFunction(files, 'test');
             expect(fn).toBeDefined();
-            expect(fn).toContain('scoreboard players set PlayerName kill_count 100');
+            expect(fn).toContain('scoreboard players set PlayerName test.kill_count 100');
         });
         it('compiles scoreboard_set with variable value', () => {
             const source = `
@@ -522,7 +700,7 @@ fn test() {
                 .filter(f => f.path.includes('test'))
                 .map(f => f.content)
                 .join('\n');
-            expect(allContent).toContain('execute store result score @s score');
+            expect(allContent).toContain('execute store result score @s test.score');
         });
         it('compiles score() as expression', () => {
             const source = `
@@ -548,7 +726,7 @@ fn double_score() -> int {
             const files = compile(source);
             const fn = getFunction(files, 'double_score');
             expect(fn).toBeDefined();
-            expect(fn).toContain('scoreboard players get @s points');
+            expect(fn).toContain('scoreboard players get @s test.points');
         });
     });
     describe('Built-in functions', () => {
@@ -1342,10 +1520,10 @@ fn heal(amount: int) {
     });
     describe('backward compat: string objective still works', () => {
         const source = `fn test() { let x: int = scoreboard_get(@s, "kills"); }`;
-        it('compiles "kills" string to bare objective name', () => {
+        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 kills');
+            expect(fn).toContain('scoreboard players get @s compat.kills');
         });
     });
     describe('#mc_name with fake player target', () => {

package/dist/__tests__/lexer.test.js

@@ -10,10 +10,16 @@ function kinds(tokens) {
 describe('Lexer', () => {
     describe('keywords', () => {
         it('recognizes all keywords', () => {
-            const tokens = tokenize('fn let const if else while for foreach match return as at in struct enum trigger namespace');
+            const tokens = tokenize('fn let const if else while for foreach match return as at in is struct impl enum trigger namespace');
             expect(kinds(tokens)).toEqual([
                 'fn', 'let', 'const', 'if', 'else', 'while', 'for', 'foreach', 'match',
-                'return', 'as', 'at', 'in', 'struct', 'enum', 'trigger', 'namespace', 'eof'
+                'return', 'as', 'at', 'in', 'is', 'struct', 'impl', 'enum', 'trigger', 'namespace', 'eof'
+            ]);
+        });
+        it('tokenizes is-check and impl syntax with their dedicated keywords', () => {
+            const tokens = tokenize('if (e is Player) { } impl Point { }');
+            expect(kinds(tokens)).toEqual([
+                'if', '(', 'ident', 'is', 'ident', ')', '{', '}', 'impl', 'ident', '{', '}', 'eof',
             ]);
         });
         it('recognizes type keywords', () => {
@@ -72,6 +78,13 @@ describe('Lexer', () => {
                 ['eof', ''],
             ]);
         });
+        it('tokenizes f-strings as a dedicated token', () => {
+            const tokens = tokenize('f"Hello {name}!"');
+            expect(tokens.map(t => [t.kind, t.value])).toEqual([
+                ['f_string', 'Hello {name}!'],
+                ['eof', ''],
+            ]);
+        });
         it('tokenizes byte literals (b suffix)', () => {
             const tokens = tokenize('20b 0B 127b');
             expect(tokens.map(t => [t.kind, t.value])).toEqual([
@@ -146,8 +159,18 @@ describe('Lexer', () => {
     });
     describe('operators', () => {
         it('tokenizes arithmetic operators', () => {
-            const tokens = tokenize('+ - * / % ~ ^');
-            expect(kinds(tokens)).toEqual(['+', '-', '*', '/', '%', '~', '^', 'eof']);
+            const tokens = tokenize('+ - * / %');
+            expect(kinds(tokens)).toEqual(['+', '-', '*', '/', '%', 'eof']);
+        });
+        it('tokenizes relative and local coordinates', () => {
+            const tokens = tokenize('~ ~5 ~-3 ^ ^10 ^-2');
+            expect(kinds(tokens)).toEqual(['rel_coord', 'rel_coord', 'rel_coord', 'local_coord', 'local_coord', 'local_coord', 'eof']);
+            expect(tokens[0].value).toBe('~');
+            expect(tokens[1].value).toBe('~5');
+            expect(tokens[2].value).toBe('~-3');
+            expect(tokens[3].value).toBe('^');
+            expect(tokens[4].value).toBe('^10');
+            expect(tokens[5].value).toBe('^-2');
         });
         it('tokenizes comparison operators', () => {
             const tokens = tokenize('== != < <= > >=');
@@ -169,6 +192,10 @@ describe('Lexer', () => {
             const tokens = tokenize('=>');
             expect(kinds(tokens)).toEqual(['=>', 'eof']);
         });
+        it('tokenizes static method separators for impl methods', () => {
+            const tokens = tokenize('Point::new()');
+            expect(kinds(tokens)).toEqual(['ident', '::', 'ident', '(', ')', 'eof']);
+        });
     });
     describe('delimiters', () => {
         it('tokenizes all delimiters', () => {

package/dist/__tests__/lowering.test.js

@@ -77,6 +77,41 @@ fn test() -> int {
             const call = getInstructions(specialized).find(i => i.op === 'call');
             expect(call.fn).toBe('__lambda_0');
         });
+        it('lowers impl methods to prefixed function names', () => {
+            const ir = compile(`
+struct Timer { duration: int }
+
+impl Timer {
+  fn elapsed(self) -> int {
+    return self.duration;
+  }
+}
+`);
+            expect(getFunction(ir, 'Timer_elapsed')).toBeDefined();
+        });
+        it('lowers impl instance and static method calls', () => {
+            const ir = compile(`
+struct Timer { duration: int }
+
+impl Timer {
+  fn new(duration: int) -> Timer {
+    return { duration: duration };
+  }
+
+  fn elapsed(self) -> int {
+    return self.duration;
+  }
+}
+
+fn test() -> int {
+  let timer: Timer = Timer::new(10);
+  return timer.elapsed();
+}
+`);
+            const fn = getFunction(ir, 'test');
+            const calls = getInstructions(fn).filter((instr) => instr.op === 'call');
+            expect(calls.map(call => call.fn)).toEqual(['Timer_new', 'Timer_elapsed']);
+        });
     });
     describe('let statements', () => {
         it('inlines const values without allocating scoreboard variables', () => {
@@ -204,6 +239,23 @@ fn test() -> int {
             const fn = getFunction(ir, 'foo');
             expect(fn.blocks.length).toBeGreaterThanOrEqual(3); // entry, then, else, merge
         });
+        it('lowers entity is-checks to execute if entity type filters', () => {
+            const ir = compile(`
+fn scan() {
+  foreach (e in @e) {
+    if (e is Player) {
+      kill(e);
+    }
+  }
+}
+`);
+            const foreachFn = ir.functions.find(fn => fn.name.includes('scan/foreach'));
+            const rawCmds = getRawCommands(foreachFn);
+            const isCheckCmd = rawCmds.find(cmd => cmd.startsWith('execute if entity @s[type=player] run function test:scan/then_'));
+            expect(isCheckCmd).toBeDefined();
+            const thenFn = ir.functions.find(fn => fn.name.startsWith('scan/then_'));
+            expect(getRawCommands(thenFn)).toContain('kill @s');
+        });
     });
     describe('while statements', () => {
         it('creates loop structure', () => {
@@ -243,6 +295,31 @@ fn test() -> int {
             const rawCmds = getRawCommands(fn);
             expect(rawCmds.some(cmd => cmd.includes('data get storage rs:heap arr'))).toBe(true);
         });
+        it('lowers entity is-checks inside foreach bodies', () => {
+            const ir = compile(`
+fn test() {
+  foreach (e in @e) {
+    if (e is Player) {
+      give(@s, "diamond", 1);
+    }
+    if (e is Zombie) {
+      kill(@s);
+    }
+  }
+}
+`);
+            const mainFn = getFunction(ir, 'test');
+            const foreachFn = ir.functions.find(f => f.name === 'test/foreach_0');
+            const thenFns = ir.functions.filter(f => /^test\/then_/.test(f.name)).sort((a, b) => a.name.localeCompare(b.name));
+            const rawCmds = getRawCommands(foreachFn);
+            const [playerThenFn, zombieThenFn] = thenFns;
+            expect(getRawCommands(mainFn)).toContain('execute as @e run function test:test/foreach_0');
+            expect(thenFns).toHaveLength(2);
+            expect(rawCmds).toContain(`execute if entity @s[type=player] run function test:${playerThenFn.name}`);
+            expect(rawCmds).toContain(`execute if entity @s[type=zombie] run function test:${zombieThenFn.name}`);
+            expect(getRawCommands(playerThenFn).some(cmd => cmd.includes('give @s diamond 1'))).toBe(true);
+            expect(getRawCommands(zombieThenFn)).toContain('kill @s');
+        });
     });
     describe('match statements', () => {
         it('lowers match into guarded execute function calls', () => {
@@ -421,6 +498,14 @@ fn choose(dir: Direction) {
             const rawCmds = getRawCommands(fn);
             expect(rawCmds).toContain('tellraw @a ["",{"text":"You have "},{"score":{"name":"$score","objective":"rs"}},{"text":" points"}]');
         });
+        it('lowers f-string output builtins to tellraw/title JSON components', () => {
+            const ir = compile('fn test() { let score: int = 7; say(f"Score: {score}"); tellraw(@a, f"Score: {score}"); actionbar(@s, f"Score: {score}"); title(@s, f"Score: {score}"); }');
+            const fn = getFunction(ir, 'test');
+            const rawCmds = getRawCommands(fn);
+            expect(rawCmds).toContain('tellraw @a ["",{"text":"Score: "},{"score":{"name":"$score","objective":"rs"}}]');
+            expect(rawCmds).toContain('title @s actionbar ["",{"text":"Score: "},{"score":{"name":"$score","objective":"rs"}}]');
+            expect(rawCmds).toContain('title @s title ["",{"text":"Score: "},{"score":{"name":"$score","objective":"rs"}}]');
+        });
         it('lowers summon()', () => {
             const ir = compile('fn test() { summon("zombie"); }');
             const fn = getFunction(ir, 'test');
@@ -515,12 +600,12 @@ fn test() {
 `);
             const fn = getFunction(ir, 'test');
             const rawCmds = getRawCommands(fn);
-            expect(rawCmds).toContain('scoreboard objectives setdisplay sidebar kills');
-            expect(rawCmds).toContain('scoreboard objectives setdisplay list coins');
-            expect(rawCmds).toContain('scoreboard objectives setdisplay belowName hp');
+            expect(rawCmds).toContain('scoreboard objectives setdisplay sidebar test.kills');
+            expect(rawCmds).toContain('scoreboard objectives setdisplay list test.coins');
+            expect(rawCmds).toContain('scoreboard objectives setdisplay belowName test.hp');
             expect(rawCmds).toContain('scoreboard objectives setdisplay sidebar');
-            expect(rawCmds).toContain('scoreboard objectives add kills playerKillCount "Kill Count"');
-            expect(rawCmds).toContain('scoreboard objectives remove kills');
+            expect(rawCmds).toContain('scoreboard objectives add test.kills playerKillCount "Kill Count"');
+            expect(rawCmds).toContain('scoreboard objectives remove test.kills');
         });
         it('lowers bossbar management builtins', () => {
             const ir = compile(`
@@ -588,6 +673,40 @@ fn test() {
             const rawCmds = getRawCommands(fn);
             expect(rawCmds).toContain('random reset loot 42');
         });
+        it('lowers setTimeout() to a scheduled helper function', () => {
+            const ir = compile('fn test() { setTimeout(100, () => { say("hi"); }); }');
+            const fn = getFunction(ir, 'test');
+            const timeoutFn = getFunction(ir, '__timeout_0');
+            const rawCmds = getRawCommands(fn);
+            const timeoutCmds = getRawCommands(timeoutFn);
+            expect(rawCmds).toContain('schedule function test:__timeout_0 100t');
+            expect(timeoutCmds).toContain('say hi');
+        });
+        it('lowers setInterval() to a self-rescheduling helper function', () => {
+            const ir = compile('fn test() { setInterval(20, () => { say("tick"); }); }');
+            const fn = getFunction(ir, 'test');
+            const intervalFn = getFunction(ir, '__interval_0');
+            const intervalBodyFn = getFunction(ir, '__interval_body_0');
+            const rawCmds = getRawCommands(fn);
+            const intervalCmds = getRawCommands(intervalFn);
+            const intervalBodyCmds = getRawCommands(intervalBodyFn);
+            expect(rawCmds).toContain('schedule function test:__interval_0 20t');
+            expect(intervalCmds).toContain('function test:__interval_body_0');
+            expect(intervalCmds).toContain('schedule function test:__interval_0 20t');
+            expect(intervalBodyCmds).toContain('say tick');
+        });
+        it('lowers clearInterval() to schedule clear for the generated interval function', () => {
+            const ir = compile(`
+fn test() {
+  let intervalId: int = setInterval(20, () => { say("tick"); });
+  clearInterval(intervalId);
+}
+`);
+            const fn = getFunction(ir, 'test');
+            const rawCmds = getRawCommands(fn);
+            expect(rawCmds).toContain('schedule function test:__interval_0 20t');
+            expect(rawCmds).toContain('schedule clear test:__interval_0');
+        });
         it('lowers data_get from entity', () => {
             const ir = compile('fn test() { let item_count: int = data_get("entity", "@s", "SelectedItem.Count"); }');
             const fn = getFunction(ir, 'test');
@@ -628,19 +747,25 @@ fn test() {
             const ir = compile('fn test() { let score: int = scoreboard_get(@s, "score"); }');
             const fn = getFunction(ir, 'test');
             const rawCmds = getRawCommands(fn);
-            expect(rawCmds.some(cmd => cmd.includes('run scoreboard players get @s score'))).toBe(true);
+            expect(rawCmds.some(cmd => cmd.includes('run scoreboard players get @s test.score'))).toBe(true);
         });
         it('accepts bare selector targets in scoreboard_set', () => {
             const ir = compile('fn test() { scoreboard_set(@a, "kills", 0); }');
             const fn = getFunction(ir, 'test');
             const rawCmds = getRawCommands(fn);
-            expect(rawCmds).toContain('scoreboard players set @a kills 0');
+            expect(rawCmds).toContain('scoreboard players set @a test.kills 0');
+        });
+        it('skips prefixing raw mc_name objectives', () => {
+            const ir = compile('fn test() { scoreboard_set(@s, #health, 100); }');
+            const fn = getFunction(ir, 'test');
+            const rawCmds = getRawCommands(fn);
+            expect(rawCmds).toContain('scoreboard players set @s health 100');
         });
         it('warns on quoted selectors in scoreboard_get', () => {
             const { ir, warnings } = compileWithWarnings('fn test() { let score: int = scoreboard_get("@s", "score"); }');
             const fn = getFunction(ir, 'test');
             const rawCmds = getRawCommands(fn);
-            expect(rawCmds.some(cmd => cmd.includes('run scoreboard players get @s score'))).toBe(true);
+            expect(rawCmds.some(cmd => cmd.includes('run scoreboard players get @s test.score'))).toBe(true);
             expect(warnings).toContainEqual(expect.objectContaining({
                 code: 'W_QUOTED_SELECTOR',
                 message: 'Quoted selector "@s" is deprecated; pass @s without quotes',
@@ -650,7 +775,7 @@ fn test() {
             const { ir, warnings } = compileWithWarnings('fn test() { let total: int = scoreboard_get("#global", "total"); }');
             const fn = getFunction(ir, 'test');
             const rawCmds = getRawCommands(fn);
-            expect(rawCmds.some(cmd => cmd.includes('run scoreboard players get #global total'))).toBe(true);
+            expect(rawCmds.some(cmd => cmd.includes('run scoreboard players get #global test.total'))).toBe(true);
             expect(warnings).toHaveLength(0);
         });
         it('warns on quoted selectors in data_get entity targets', () => {
@@ -663,6 +788,37 @@ fn test() {
                 message: 'Quoted selector "@s" is deprecated; pass @s without quotes',
             }));
         });
+        it('keeps already-qualified scoreboard objectives unchanged', () => {
+            const ir = compile('fn test() { scoreboard_set(@s, "custom.timer", 5); }');
+            const fn = getFunction(ir, 'test');
+            const rawCmds = getRawCommands(fn);
+            expect(rawCmds).toContain('scoreboard players set @s custom.timer 5');
+        });
+    });
+    describe('timer builtins', () => {
+        it('lowers timer builtins into schedule commands and wrapper functions', () => {
+            const ir = compile(`
+fn test() {
+  let intervalId: int = setInterval(20, () => {
+    say("tick");
+  });
+  setTimeout(100, () => {
+    say("later");
+  });
+  clearInterval(intervalId);
+}
+`);
+            const fn = getFunction(ir, 'test');
+            const rawCmds = getRawCommands(fn);
+            expect(rawCmds).toContain('schedule function test:__interval_0 20t');
+            expect(rawCmds).toContain('schedule function test:__timeout_0 100t');
+            expect(rawCmds).toContain('schedule clear test:__interval_0');
+            const intervalFn = getFunction(ir, '__interval_0');
+            expect(getRawCommands(intervalFn)).toEqual([
+                'function test:__interval_body_0',
+                'schedule function test:__interval_0 20t',
+            ]);
+        });
     });
     describe('decorators', () => {
         it('marks @tick function', () => {
@@ -681,6 +837,13 @@ fn test() {
             const fn = getFunction(ir, 'handle_advancement');
             expect(fn.eventTrigger).toEqual({ kind: 'advancement', value: 'story/mine_diamond' });
         });
+        it('marks @on event functions and binds player to @s', () => {
+            const ir = compile('@on(PlayerDeath) fn handle_death(player: Player) { tp(player, @p); }');
+            const fn = getFunction(ir, 'handle_death');
+            expect(fn.eventHandler).toEqual({ eventType: 'PlayerDeath', tag: 'rs.just_died' });
+            expect(fn.params).toEqual([]);
+            expect(getRawCommands(fn)).toContain('tp @s @p');
+        });
     });
     describe('selectors', () => {
         it('converts selector with filters to string', () => {