redscript-mc 1.1.0 → 1.2.0

package/src/__tests__/lowering.test.ts

@@ -88,6 +88,43 @@ fn test() -> int {
       const call = getInstructions(specialized!).find(i => i.op === 'call') as any
       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 is IRInstr & { op: 'call' } => instr.op === 'call')
+      expect(calls.map(call => call.fn)).toEqual(['Timer_new', 'Timer_elapsed'])
+    })
   })
 
   describe('let statements', () => {
@@ -235,6 +272,25 @@ 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', () => {
@@ -282,6 +338,33 @@ 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', () => {
@@ -603,12 +686,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', () => {
@@ -682,6 +765,43 @@ fn test() {
       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')!
@@ -736,7 +856,7 @@ fn test() {
       const fn = getFunction(ir, 'test')!
       const rawCmds = getRawCommands(fn)
       expect(rawCmds.some(cmd =>
-        cmd.includes('run scoreboard players get @s score')
+        cmd.includes('run scoreboard players get @s test.score')
       )).toBe(true)
     })
 
@@ -744,7 +864,14 @@ fn test() {
       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', () => {
@@ -752,7 +879,7 @@ fn test() {
       const fn = getFunction(ir, 'test')!
       const rawCmds = getRawCommands(fn)
       expect(rawCmds.some(cmd =>
-        cmd.includes('run scoreboard players get @s score')
+        cmd.includes('run scoreboard players get @s test.score')
       )).toBe(true)
       expect(warnings).toContainEqual(expect.objectContaining({
         code: 'W_QUOTED_SELECTOR',
@@ -765,7 +892,7 @@ fn test() {
       const fn = getFunction(ir, 'test')!
       const rawCmds = getRawCommands(fn)
       expect(rawCmds.some(cmd =>
-        cmd.includes('run scoreboard players get #global total')
+        cmd.includes('run scoreboard players get #global test.total')
       )).toBe(true)
       expect(warnings).toHaveLength(0)
     })
@@ -782,6 +909,40 @@ 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', () => {
@@ -803,6 +964,14 @@ 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', () => {

package/src/__tests__/mc-integration.test.ts

@@ -19,6 +19,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: MCTestClient
@@ -54,9 +55,27 @@ function writeFixture(source: string, namespace: string): void {
   }
 }
 
+function writeFixtureFile(fileName: string, namespace: string): void {
+  writeFixture(
+    fs.readFileSync(path.join(FIXTURE_DIR, fileName), 'utf-8'),
+    namespace
+  )
+}
+
+async function waitForServer(client: MCTestClient, timeoutMs = 30000): Promise<boolean> {
+  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 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`)
@@ -75,16 +94,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')
@@ -95,31 +114,31 @@ 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();
@@ -130,16 +149,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')
@@ -157,10 +176,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')
@@ -172,7 +191,7 @@ beforeAll(async () => {
     }
     fn run_nested() {
       let a: int = triple(4);
-      scoreboard_set("#nested", "result", a);
+      scoreboard_set("#nested", #result, a);
     }
   `, 'nested_test')
 
@@ -180,10 +199,10 @@ beforeAll(async () => {
   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')
@@ -191,14 +210,14 @@ beforeAll(async () => {
   // 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')
@@ -206,17 +225,17 @@ beforeAll(async () => {
   // 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);
           }
         }
       }
@@ -238,34 +257,41 @@ 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')
@@ -682,3 +708,92 @@ describe('E2E Scenario Tests', () => {
   })
 
 })
+
+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)
+  })
+})

package/src/__tests__/optimizer-advanced.test.ts

@@ -28,12 +28,12 @@ fn turret_tick() {
     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')
   })
 })
 
@@ -51,7 +51,7 @@ fn read_twice() {
 
     const result = 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')