redscript-mc 1.0.0 → 1.2.0

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`)
@@ -65,26 +84,26 @@ beforeAll(async () => {
   }
 
   // ── Write fixtures + use safe reloadData (no /reload confirm) ───────
-  // counter.rs
-  if (fs.existsSync(path.join(__dirname, '../examples/counter.rs'))) {
-    writeFixture(fs.readFileSync(path.join(__dirname, '../examples/counter.rs'), 'utf-8'), 'counter')
+  // counter.mcrs
+  if (fs.existsSync(path.join(__dirname, '../examples/counter.mcrs'))) {
+    writeFixture(fs.readFileSync(path.join(__dirname, '../examples/counter.mcrs'), 'utf-8'), 'counter')
   }
-  if (fs.existsSync(path.join(__dirname, '../examples/world_manager.rs'))) {
-    writeFixture(fs.readFileSync(path.join(__dirname, '../examples/world_manager.rs'), 'utf-8'), 'world_manager')
+  if (fs.existsSync(path.join(__dirname, '../examples/world_manager.mcrs'))) {
+    writeFixture(fs.readFileSync(path.join(__dirname, '../examples/world_manager.mcrs'), 'utf-8'), 'world_manager')
   }
   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')
@@ -154,12 +173,125 @@ beforeAll(async () => {
     }
   `, 'fill_test')
 
+  // Scenario E: for-range loop — loop counter increments exactly N times
+  writeFixture(`
+    fn count_to_five() {
+      scoreboard_set("#range", #counter, 0);
+      for i in 0..5 {
+        let c: int = scoreboard_get("#range", #counter);
+        scoreboard_set("#range", #counter, c + 1);
+      }
+    }
+  `, 'range_test')
+
+  // Scenario F: function call with return value — verifies $ret propagation
+  writeFixture(`
+    fn triple(x: int) -> int {
+      return x * 3;
+    }
+    fn run_nested() {
+      let a: int = triple(4);
+      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); }
+      }
+    }
+  `, '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);
+      while (i > 0) {
+        let s: int = scoreboard_get("#wloop", #steps);
+        scoreboard_set("#wloop", #steps, s + 1);
+        i = i - 1;
+        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);
+      if (x > 100) {
+        scoreboard_set("#boundary", #tier, 3);
+      } else {
+        if (x > 50) {
+          scoreboard_set("#boundary", #tier, 2);
+        } else {
+          if (x > 0) {
+            scoreboard_set("#boundary", #tier, 1);
+          } else {
+            scoreboard_set("#boundary", #tier, 0);
+          }
+        }
+      }
+    }
+  `, 'boundary_test')
+
+  // Scenario J: entity management — summon via raw commands
+  writeFixture(`
+    fn tag_entities() {
+      raw("summon minecraft:armor_stand 10 65 10");
+      raw("summon minecraft:armor_stand 11 65 10");
+      raw("summon minecraft:armor_stand 12 65 10");
+    }
+  `, 'tag_test')
+
+  // Scenario K: mixed arithmetic — order of operations
+  writeFixture(`
+    fn math_order() {
+      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);
+      let d: int = 100;
+      let e: int = d / 3;
+      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);
+    }
+  `, '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']) {
+                     'timer', 'ended', 'val_a', 'val_b', 'sum', 'val_x', 'val_y', 'product', 'val',
+                     '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')
@@ -192,7 +324,7 @@ describe('MC Integration Tests', () => {
   })
 
   // ─── Test 2: Counter tick ─────────────────────────────────────────────
-  test('counter.rs: tick function increments scoreboard over time', async () => {
+  test('counter.mcrs: tick function increments scoreboard over time', async () => {
     if (!serverOnline) return
     
     await mc.ticks(40) // Wait 2s (counter was already init'd in beforeAll)
@@ -202,7 +334,7 @@ describe('MC Integration Tests', () => {
   })
 
   // ─── Test 3: setblock ────────────────────────────────────────────────
-  test('world_manager.rs: setblock places correct block', async () => {
+  test('world_manager.mcrs: setblock places correct block', async () => {
     if (!serverOnline) return
     
     // Clear just the lobby area, keep other state
@@ -217,7 +349,7 @@ describe('MC Integration Tests', () => {
   })
 
   // ─── Test 4: fill ────────────────────────────────────────────────────
-  test('world_manager.rs: fill creates smooth_stone floor', async () => {
+  test('world_manager.mcrs: fill creates smooth_stone floor', async () => {
     if (!serverOnline) return
     // Runs after test 3, floor should still be there
     const block = await mc.block(4, 64, 4)
@@ -344,7 +476,7 @@ describe('E2E Scenario Tests', () => {
   })
 
   // Scenario B: No temp var collision between two functions called in sequence
-  // Verifies: each function's $t0/$t1 temp vars are isolated per-call, not globally shared
+  // Verifies: each function's temp vars are isolated per-call via globally unique names
   // If there's a bug, calc_product would see sum's leftover $t vars and produce wrong result
   test('B: calc_sum + calc_product called in sequence — no temp var collision', async () => {
     if (!serverOnline) return
@@ -406,4 +538,262 @@ describe('E2E Scenario Tests', () => {
     console.log(`  fill_test: blocks [0-3,70,0]=stone, [-1]/[4]=air ✓`)
   })
 
+  // Scenario E: for-range loop executes body exactly N times
+  // Verifies: for i in 0..5 increments counter 5 times
+  test('E: for-range loop increments counter exactly 5 times', async () => {
+    if (!serverOnline) return
+
+    await mc.command('/function range_test:__load')
+    await mc.command('/function range_test:count_to_five')
+    await mc.ticks(10)
+
+    const counter = await mc.scoreboard('#range', 'counter')
+    expect(counter).toBe(5)
+    console.log(`  for-range 0..5 → counter=${counter} (expect 5) ✓`)
+  })
+
+  // Scenario F: function return value propagation
+  // Verifies: $ret from callee is correctly captured in caller's variable
+  test('F: function return value — triple(4) = 12', async () => {
+    if (!serverOnline) return
+
+    await mc.command('/function nested_test:__load')
+    await mc.command('/function nested_test:run_nested')
+    await mc.ticks(10)
+
+    const result = await mc.scoreboard('#nested', 'result')
+    expect(result).toBe(12) // triple(4) = 4*3 = 12
+    console.log(`  triple(4) = ${result} (expect 12) ✓`)
+  })
+
+  // Scenario G: match dispatches to correct branch
+  // Verifies: match statement selects right arm for values 1, 2, 3, and default
+  test('G: match statement dispatches to correct branch', async () => {
+    if (!serverOnline) return
+
+    await mc.command('/function match_test:__load')
+
+    // Test match on value 2
+    await mc.command('/scoreboard players set $p0 rs 2')
+    await mc.command('/function match_test:classify')
+    await mc.ticks(5)
+    let out = await mc.scoreboard('#match', 'out')
+    expect(out).toBe(20)
+    console.log(`  match(2) → out=${out} (expect 20) ✓`)
+
+    // Test match on value 3
+    await mc.command('/scoreboard players set $p0 rs 3')
+    await mc.command('/function match_test:classify')
+    await mc.ticks(5)
+    out = await mc.scoreboard('#match', 'out')
+    expect(out).toBe(30)
+    console.log(`  match(3) → out=${out} (expect 30) ✓`)
+
+    // Test default branch (value 99)
+    await mc.command('/scoreboard players set $p0 rs 99')
+    await mc.command('/function match_test:classify')
+    await mc.ticks(5)
+    out = await mc.scoreboard('#match', 'out')
+    expect(out).toBe(-1)
+    console.log(`  match(99) → out=${out} (expect -1, default) ✓`)
+  })
+
+  // Scenario H: while loop counts down from 10 to 0
+  // Verifies: while loop body executes correct number of iterations
+  test('H: while loop counts down 10 steps', async () => {
+    if (!serverOnline) return
+
+    await mc.command('/function while_test:__load')
+    await mc.command('/function while_test:countdown')
+    await mc.ticks(10)
+
+    const i = await mc.scoreboard('#wloop', 'i')
+    const steps = await mc.scoreboard('#wloop', 'steps')
+    expect(i).toBe(0)
+    expect(steps).toBe(10)
+    console.log(`  while countdown: i=${i} (expect 0), steps=${steps} (expect 10) ✓`)
+  })
+
+  // Scenario I: nested if/else boundary classification
+  // Verifies: correct branch taken at boundaries (0, 50, 100)
+  test('I: nested if/else boundary classification', async () => {
+    if (!serverOnline) return
+
+    await mc.command('/function boundary_test:__load')
+
+    // Test x=0 → tier 0
+    await mc.command('/scoreboard players set #boundary input 0')
+    await mc.command('/function boundary_test:classify_score')
+    await mc.ticks(5)
+    let tier = await mc.scoreboard('#boundary', 'tier')
+    expect(tier).toBe(0)
+    console.log(`  classify(0) → tier=${tier} (expect 0) ✓`)
+
+    // Test x=50 → tier 1 (> 0 but not > 50)
+    await mc.command('/scoreboard players set #boundary input 50')
+    await mc.command('/function boundary_test:classify_score')
+    await mc.ticks(5)
+    tier = await mc.scoreboard('#boundary', 'tier')
+    expect(tier).toBe(1)
+    console.log(`  classify(50) → tier=${tier} (expect 1) ✓`)
+
+    // Test x=51 → tier 2 (> 50 but not > 100)
+    await mc.command('/scoreboard players set #boundary input 51')
+    await mc.command('/function boundary_test:classify_score')
+    await mc.ticks(5)
+    tier = await mc.scoreboard('#boundary', 'tier')
+    expect(tier).toBe(2)
+    console.log(`  classify(51) → tier=${tier} (expect 2) ✓`)
+
+    // Test x=101 → tier 3
+    await mc.command('/scoreboard players set #boundary input 101')
+    await mc.command('/function boundary_test:classify_score')
+    await mc.ticks(5)
+    tier = await mc.scoreboard('#boundary', 'tier')
+    expect(tier).toBe(3)
+    console.log(`  classify(101) → tier=${tier} (expect 3) ✓`)
+  })
+
+  // Scenario J: entity summon and query
+  // Verifies: entities spawned via compiled function are queryable
+  test('J: summon entities via compiled function', async () => {
+    if (!serverOnline) return
+
+    await mc.command('/kill @e[type=minecraft:armor_stand]')
+    await mc.ticks(2)
+    await mc.command('/function tag_test:__load')
+    await mc.command('/function tag_test:tag_entities')
+    await mc.ticks(5)
+
+    const stands = await mc.entities('@e[type=minecraft:armor_stand]')
+    expect(stands.length).toBe(3)
+    console.log(`  Summoned 3 armor_stands via tag_test, found: ${stands.length} ✓`)
+
+    await mc.command('/kill @e[type=minecraft:armor_stand]')
+  })
+
+  // Scenario K: arithmetic order of operations
+  // Verifies: MC scoreboard arithmetic matches expected evaluation order
+  test('K: arithmetic order of operations', async () => {
+    if (!serverOnline) return
+
+    await mc.command('/function order_test:__load')
+    await mc.command('/function order_test:math_order')
+    await mc.ticks(10)
+
+    const r1 = await mc.scoreboard('#order', 'r1')
+    const r2 = await mc.scoreboard('#order', 'r2')
+    const r3 = await mc.scoreboard('#order', 'r3')
+    // a + b * c = 2 + 3*4 = 14 (if precedence respected) or (2+3)*4 = 20 (left-to-right)
+    // MC scoreboard does left-to-right, so compiler may emit either depending on lowering
+    // (a + b) * c = 5 * 4 = 20 (explicit parens)
+    expect(r2).toBe(20) // This one is unambiguous
+    // 100 / 3 = 33 (integer division)
+    expect(r3).toBe(33)
+    console.log(`  r1=${r1}, r2=${r2} (expect 20), r3=${r3} (expect 33) ✓`)
+  })
+
+  // Scenario L: scoreboard read-modify-write chain (1 → 2 → 4 → 8)
+  // Verifies: sequential RMW operations don't lose intermediate state
+  test('L: scoreboard RMW chain — 1*2*2*2 = 8', async () => {
+    if (!serverOnline) return
+
+    await mc.command('/function rmw_test:__load')
+    await mc.command('/function rmw_test:chain_rmw')
+    await mc.ticks(10)
+
+    const v = await mc.scoreboard('#rmw', 'v')
+    expect(v).toBe(8)
+    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)
+  })
 })

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

@@ -33,14 +33,14 @@ describe('MC Command Syntax Validation', () => {
   const validator = new MCCommandValidator(FIXTURE_PATH)
 
   test('counter example generates valid MC commands', () => {
-    const src = fs.readFileSync(path.join(__dirname, '..', 'examples', 'counter.rs'), 'utf-8')
+    const src = fs.readFileSync(path.join(__dirname, '..', 'examples', 'counter.mcrs'), 'utf-8')
     const errors = validateSource(validator, src, 'counter')
     expect(errors).toHaveLength(0)
   })
 
   EXAMPLES.forEach(name => {
-    test(`${name}.rs generates valid MC commands`, () => {
-      const src = fs.readFileSync(path.join(__dirname, '..', 'examples', `${name}.rs`), 'utf-8')
+    test(`${name}.mcrs generates valid MC commands`, () => {
+      const src = fs.readFileSync(path.join(__dirname, '..', 'examples', `${name}.mcrs`), 'utf-8')
       const errors = validateSource(validator, src, name)
 
       if (errors.length > 0) {

package/src/__tests__/nbt.test.ts

@@ -40,8 +40,8 @@ describe('NBT codec', () => {
 })
 
 describe('Structure generator', () => {
-  test('compiles counter.rs to a non-empty structure', () => {
-    const filePath = 'src/examples/counter.rs'
+  test('compiles counter.mcrs to a non-empty structure', () => {
+    const filePath = 'src/examples/counter.mcrs'
     const src = fs.readFileSync(filePath, 'utf-8')
     const { buffer, blockCount } = compileToStructure(src, 'counter', filePath)
 

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 $t0 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,10 +51,10 @@ 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 $t1 rs = $t0 rs')
+    expect(fn).toContain('scoreboard players operation $_1 rs = $_0 rs')
   })
 
   test('reuses duplicate arithmetic sequences', () => {
@@ -74,7 +74,7 @@ fn math() {
     const addMatches = fn.match(/\+= \$const_2 rs/g) ?? []
 
     expect(addMatches).toHaveLength(1)
-    expect(fn).toContain('scoreboard players operation $t1 rs = $t0 rs')
+    expect(fn).toContain('scoreboard players operation $_1 rs = $_0 rs')
   })
 })