redscript-mc 1.1.0 → 1.2.0

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', () => {
@@ -515,12 +592,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 +665,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 +739,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 +767,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 +780,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 +829,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', () => {

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

@@ -52,6 +52,7 @@ const MC_HOST = process.env.MC_HOST ?? 'localhost';
 const MC_PORT = parseInt(process.env.MC_PORT ?? '25561');
 const MC_SERVER_DIR = process.env.MC_SERVER_DIR ?? path.join(process.env.HOME, 'mc-test-server');
 const DATAPACK_DIR = path.join(MC_SERVER_DIR, 'world', 'datapacks', 'redscript-test');
+const FIXTURE_DIR = path.join(__dirname, 'fixtures');
 let serverOnline = false;
 let mc;
 /** Write compiled RedScript source into the shared test datapack directory.
@@ -84,9 +85,22 @@ function writeFixture(source, namespace) {
         }
     }
 }
+function writeFixtureFile(fileName, namespace) {
+    writeFixture(fs.readFileSync(path.join(FIXTURE_DIR, fileName), 'utf-8'), namespace);
+}
+async function waitForServer(client, timeoutMs = 30000) {
+    const deadline = Date.now() + timeoutMs;
+    while (Date.now() < deadline) {
+        if (await client.isOnline()) {
+            return true;
+        }
+        await new Promise(resolve => setTimeout(resolve, 1000));
+    }
+    return false;
+}
 beforeAll(async () => {
     mc = new client_1.MCTestClient(MC_HOST, MC_PORT);
-    serverOnline = await mc.isOnline();
+    serverOnline = await waitForServer(mc);
     if (!serverOnline) {
         console.warn(`⚠ MC server not running at ${MC_HOST}:${MC_PORT} — skipping integration tests`);
         console.warn(`  Run: MC_SERVER_DIR=~/mc-test-server npx ts-node src/mc-test/setup.ts`);
@@ -104,16 +118,16 @@ beforeAll(async () => {
     writeFixture(`
     @tick
     fn on_tick() {
-      scoreboard_set("#tick_counter", "ticks", scoreboard_get("#tick_counter", "ticks") + 1);
+      scoreboard_set("#tick_counter", #ticks, scoreboard_get("#tick_counter", #ticks) + 1);
     }
   `, 'tick_test');
     writeFixture(`
     fn check_score() {
-      let x: int = scoreboard_get("#check_x", "test_score");
+      let x: int = scoreboard_get("#check_x", #test_score);
       if (x > 5) {
-        scoreboard_set("#check_x", "result", 1);
+        scoreboard_set("#check_x", #result, 1);
       } else {
-        scoreboard_set("#check_x", "result", 0);
+        scoreboard_set("#check_x", #result, 0);
       }
     }
   `, 'inline_test');
@@ -122,30 +136,30 @@ beforeAll(async () => {
     writeFixture(`
     @tick
     fn game_tick() {
-      let time: int = scoreboard_get("#game", "timer");
+      let time: int = scoreboard_get("#game", #timer);
       if (time > 0) {
-        scoreboard_set("#game", "timer", time - 1);
+        scoreboard_set("#game", #timer, time - 1);
       }
       if (time == 1) {
-        scoreboard_set("#game", "ended", 1);
+        scoreboard_set("#game", #ended, 1);
       }
     }
     fn start_game() {
-      scoreboard_set("#game", "timer", 5);
-      scoreboard_set("#game", "ended", 0);
+      scoreboard_set("#game", #timer, 5);
+      scoreboard_set("#game", #ended, 0);
     }
   `, 'game_loop');
     // Scenario B: two functions, same temp var namespace — verify no collision
     writeFixture(`
     fn calc_sum() {
-      let a: int = scoreboard_get("#math", "val_a");
-      let b: int = scoreboard_get("#math", "val_b");
-      scoreboard_set("#math", "sum", a + b);
+      let a: int = scoreboard_get("#math", #val_a);
+      let b: int = scoreboard_get("#math", #val_b);
+      scoreboard_set("#math", #sum, a + b);
     }
     fn calc_product() {
-      let x: int = scoreboard_get("#math", "val_x");
-      let y: int = scoreboard_get("#math", "val_y");
-      scoreboard_set("#math", "product", x * y);
+      let x: int = scoreboard_get("#math", #val_x);
+      let y: int = scoreboard_get("#math", #val_y);
+      scoreboard_set("#math", #product, x * y);
     }
     fn run_both() {
       calc_sum();
@@ -155,16 +169,16 @@ beforeAll(async () => {
     // Scenario C: 3-deep call chain, each step modifies shared state
     writeFixture(`
     fn step3() {
-      let v: int = scoreboard_get("#chain", "val");
-      scoreboard_set("#chain", "val", v * 2);
+      let v: int = scoreboard_get("#chain", #val);
+      scoreboard_set("#chain", #val, v * 2);
     }
     fn step2() {
-      let v: int = scoreboard_get("#chain", "val");
-      scoreboard_set("#chain", "val", v + 5);
+      let v: int = scoreboard_get("#chain", #val);
+      scoreboard_set("#chain", #val, v + 5);
       step3();
     }
     fn step1() {
-      scoreboard_set("#chain", "val", 10);
+      scoreboard_set("#chain", #val, 10);
       step2();
     }
   `, 'call_chain');
@@ -180,10 +194,10 @@ beforeAll(async () => {
     // Scenario E: for-range loop — loop counter increments exactly N times
     writeFixture(`
     fn count_to_five() {
-      scoreboard_set("#range", "counter", 0);
+      scoreboard_set("#range", #counter, 0);
       for i in 0..5 {
-        let c: int = scoreboard_get("#range", "counter");
-        scoreboard_set("#range", "counter", c + 1);
+        let c: int = scoreboard_get("#range", #counter);
+        scoreboard_set("#range", #counter, c + 1);
       }
     }
   `, 'range_test');
@@ -194,48 +208,48 @@ beforeAll(async () => {
     }
     fn run_nested() {
       let a: int = triple(4);
-      scoreboard_set("#nested", "result", a);
+      scoreboard_set("#nested", #result, a);
     }
   `, 'nested_test');
     // Scenario G: match statement dispatches to correct branch
     writeFixture(`
     fn classify(x: int) {
       match (x) {
-        1 => { scoreboard_set("#match", "out", 10); }
-        2 => { scoreboard_set("#match", "out", 20); }
-        3 => { scoreboard_set("#match", "out", 30); }
-        _ => { scoreboard_set("#match", "out", -1); }
+        1 => { scoreboard_set("#match", #out, 10); }
+        2 => { scoreboard_set("#match", #out, 20); }
+        3 => { scoreboard_set("#match", #out, 30); }
+        _ => { scoreboard_set("#match", #out, -1); }
       }
     }
   `, 'match_test');
     // Scenario H: while loop counts down
     writeFixture(`
     fn countdown() {
-      scoreboard_set("#wloop", "i", 10);
-      scoreboard_set("#wloop", "steps", 0);
-      let i: int = scoreboard_get("#wloop", "i");
+      scoreboard_set("#wloop", #i, 10);
+      scoreboard_set("#wloop", #steps, 0);
+      let i: int = scoreboard_get("#wloop", #i);
       while (i > 0) {
-        let s: int = scoreboard_get("#wloop", "steps");
-        scoreboard_set("#wloop", "steps", s + 1);
+        let s: int = scoreboard_get("#wloop", #steps);
+        scoreboard_set("#wloop", #steps, s + 1);
         i = i - 1;
-        scoreboard_set("#wloop", "i", i);
+        scoreboard_set("#wloop", #i, i);
       }
     }
   `, 'while_test');
     // Scenario I: multiple if/else branches (boundary test)
     writeFixture(`
     fn classify_score() {
-      let x: int = scoreboard_get("#boundary", "input");
+      let x: int = scoreboard_get("#boundary", #input);
       if (x > 100) {
-        scoreboard_set("#boundary", "tier", 3);
+        scoreboard_set("#boundary", #tier, 3);
       } else {
         if (x > 50) {
-          scoreboard_set("#boundary", "tier", 2);
+          scoreboard_set("#boundary", #tier, 2);
         } else {
           if (x > 0) {
-            scoreboard_set("#boundary", "tier", 1);
+            scoreboard_set("#boundary", #tier, 1);
           } else {
-            scoreboard_set("#boundary", "tier", 0);
+            scoreboard_set("#boundary", #tier, 0);
           }
         }
       }
@@ -255,31 +269,37 @@ beforeAll(async () => {
       let a: int = 2;
       let b: int = 3;
       let c: int = 4;
-      scoreboard_set("#order", "r1", a + b * c);
-      scoreboard_set("#order", "r2", (a + b) * c);
+      scoreboard_set("#order", #r1, a + b * c);
+      scoreboard_set("#order", #r2, (a + b) * c);
       let d: int = 100;
       let e: int = d / 3;
-      scoreboard_set("#order", "r3", e);
+      scoreboard_set("#order", #r3, e);
     }
   `, 'order_test');
     // Scenario L: scoreboard read-modify-write chain
     writeFixture(`
     fn chain_rmw() {
-      scoreboard_set("#rmw", "v", 1);
-      let v: int = scoreboard_get("#rmw", "v");
-      scoreboard_set("#rmw", "v", v * 2);
-      v = scoreboard_get("#rmw", "v");
-      scoreboard_set("#rmw", "v", v * 2);
-      v = scoreboard_get("#rmw", "v");
-      scoreboard_set("#rmw", "v", v * 2);
+      scoreboard_set("#rmw", #v, 1);
+      let v: int = scoreboard_get("#rmw", #v);
+      scoreboard_set("#rmw", #v, v * 2);
+      v = scoreboard_get("#rmw", #v);
+      scoreboard_set("#rmw", #v, v * 2);
+      v = scoreboard_get("#rmw", #v);
+      scoreboard_set("#rmw", #v, v * 2);
     }
   `, 'rmw_test');
+    writeFixtureFile('impl-test.mcrs', 'impl_test');
+    writeFixtureFile('timeout-test.mcrs', 'timeout_test');
+    writeFixtureFile('interval-test.mcrs', 'interval_test');
+    writeFixtureFile('is-check-test.mcrs', 'is_check_test');
+    writeFixtureFile('event-test.mcrs', 'event_test');
     // ── Full reset + safe data reload ────────────────────────────────────
     await mc.fullReset();
     // Pre-create scoreboards
     for (const obj of ['ticks', 'seconds', 'test_score', 'result', 'calc', 'rs',
         'timer', 'ended', 'val_a', 'val_b', 'sum', 'val_x', 'val_y', 'product', 'val',
-        'counter', 'out', 'i', 'steps', 'input', 'tier', 'r1', 'r2', 'r3', 'v']) {
+        'counter', 'out', 'i', 'steps', 'input', 'tier', 'r1', 'r2', 'r3', 'v',
+        'done', 'fired', 'players', 'zombies']) {
         await mc.command(`/scoreboard objectives add ${obj} dummy`).catch(() => { });
     }
     await mc.command('/scoreboard players set counter ticks 0');
@@ -637,4 +657,78 @@ describe('E2E Scenario Tests', () => {
         console.log(`  RMW chain: 1→2→4→8, got ${v} (expect 8) ✓`);
     });
 });
+describe('MC Integration - New Features', () => {
+    test('impl-test.mcrs: Timer::new/start/tick/done works in-game', async () => {
+        if (!serverOnline)
+            return;
+        await mc.command('/scoreboard players set #impl done 0');
+        await mc.command('/scoreboard players set timer_ticks rs 0');
+        await mc.command('/scoreboard players set timer_active rs 0');
+        await mc.command('/function impl_test:__load').catch(() => { });
+        await mc.command('/function impl_test:test');
+        await mc.ticks(5);
+        const done = await mc.scoreboard('#impl', 'done');
+        const ticks = await mc.scoreboard('timer_ticks', 'rs');
+        expect(done).toBe(1);
+        expect(ticks).toBe(3);
+    });
+    test('timeout-test.mcrs: setTimeout executes after delay', async () => {
+        if (!serverOnline)
+            return;
+        await mc.command('/scoreboard players set #timeout fired 0');
+        await mc.command('/function timeout_test:__load').catch(() => { });
+        await mc.command('/function timeout_test:start');
+        await mc.ticks(10);
+        expect(await mc.scoreboard('#timeout', 'fired')).toBe(0);
+        await mc.ticks(15);
+        expect(await mc.scoreboard('#timeout', 'fired')).toBe(1);
+    });
+    test('interval-test.mcrs: setInterval repeats on schedule', async () => {
+        if (!serverOnline)
+            return;
+        await mc.command('/scoreboard players set #interval ticks 0');
+        await mc.command('/function interval_test:__load').catch(() => { });
+        await mc.command('/function interval_test:start');
+        await mc.ticks(70);
+        const count = await mc.scoreboard('#interval', 'ticks');
+        expect(count).toBeGreaterThanOrEqual(3);
+        expect(count).toBeLessThanOrEqual(3);
+    });
+    test('is-check-test.mcrs: foreach is-narrowing only matches zombie entities', async () => {
+        if (!serverOnline)
+            return;
+        await mc.fullReset({ clearArea: false, killEntities: true, resetScoreboards: false });
+        await mc.command('/scoreboard players set #is_check players 0');
+        await mc.command('/scoreboard players set #is_check zombies 0');
+        await mc.command('/function is_check_test:__load').catch(() => { });
+        await mc.command('/summon minecraft:zombie 0 65 0');
+        await mc.command('/tag @e[type=minecraft:zombie,sort=nearest,limit=1] add is_check_target');
+        await mc.command('/summon minecraft:armor_stand 2 65 0');
+        await mc.command('/tag @e[type=minecraft:armor_stand,sort=nearest,limit=1] add is_check_target');
+        await mc.command('/function is_check_test:check_types');
+        await mc.ticks(5);
+        const zombies = await mc.scoreboard('#is_check', 'zombies');
+        const players = await mc.scoreboard('#is_check', 'players');
+        const zombieEntities = await mc.entities('@e[type=minecraft:zombie,tag=is_check_target]');
+        const standEntities = await mc.entities('@e[type=minecraft:armor_stand,tag=is_check_target]');
+        expect(zombies).toBe(1);
+        expect(players).toBe(0);
+        expect(zombieEntities).toHaveLength(0);
+        expect(standEntities).toHaveLength(1);
+        await mc.command('/kill @e[tag=is_check_target]').catch(() => { });
+    });
+    test('event-test.mcrs: @on(PlayerDeath) compiles and loads', async () => {
+        if (!serverOnline)
+            return;
+        // Verify the event system compiles correctly
+        await mc.command('/function event_test:__load').catch(() => { });
+        await mc.ticks(5);
+        // Verify the trigger function exists
+        const result = await mc.command('/function event_test:trigger_fake_death');
+        expect(result.ok).toBe(true);
+        // Verify __tick exists (event dispatcher)
+        const tickResult = await mc.command('/function event_test:__tick').catch(() => ({ ok: false }));
+        expect(tickResult.ok).toBe(true);
+    });
+});
 //# sourceMappingURL=mc-integration.test.js.map

package/dist/__tests__/optimizer-advanced.test.js

@@ -26,11 +26,11 @@ fn turret_tick() {
         const result = (0, index_1.compile)(source, { namespace: 'test' });
         const parent = getFileContent(result.files, 'data/test/function/turret_tick.mcfunction');
         const loopBody = getFileContent(result.files, 'data/test/function/turret_tick/foreach_0.mcfunction');
-        const hoistedRead = 'execute store result score $_0 rs run scoreboard players get config turret_range';
+        const hoistedRead = 'execute store result score $_0 rs run scoreboard players get config test.turret_range';
         const executeCall = 'execute as @e[tag=turret] run function test:turret_tick/foreach_0';
         expect(parent).toContain(hoistedRead);
         expect(parent.indexOf(hoistedRead)).toBeLessThan(parent.indexOf(executeCall));
-        expect(loopBody).not.toContain('scoreboard players get config turret_range');
+        expect(loopBody).not.toContain('scoreboard players get config test.turret_range');
     });
 });
 describe('CSE', () => {
@@ -46,7 +46,7 @@ fn read_twice() {
 `;
         const result = (0, index_1.compile)(source, { namespace: 'test' });
         const fn = getFileContent(result.files, 'data/test/function/read_twice.mcfunction');
-        const readMatches = fn.match(/scoreboard players get @s coins/g) ?? [];
+        const readMatches = fn.match(/scoreboard players get @s test\.coins/g) ?? [];
         expect(readMatches).toHaveLength(1);
         expect(fn).toContain('scoreboard players operation $_1 rs = $_0 rs');
     });