redscript-mc 3.0.0 → 3.0.2

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

@@ -1,819 +0,0 @@
-"use strict";
-/**
- * RedScript MC Integration Tests
- *
- * Tests compiled datapacks against a real Paper 1.21.4 server.
- *
- * Prerequisites:
- *   - Paper server running with TestHarnessPlugin on port 25561
- *   - MC_SERVER_DIR env var pointing to server directory
- *
- * Run: MC_SERVER_DIR=~/mc-test-server npx jest mc-integration --testTimeout=120000
- */
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || (function () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
-    };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __setModuleDefault(result, mod);
-        return result;
-    };
-})();
-Object.defineProperty(exports, "__esModule", { value: true });
-const fs = __importStar(require("fs"));
-const path = __importStar(require("path"));
-const compile_1 = require("../compile");
-const client_1 = require("../mc-test/client");
-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.
- *  Merges minecraft tag files (tick.json / load.json) instead of overwriting. */
-function writeFixture(source, namespace) {
-    fs.mkdirSync(DATAPACK_DIR, { recursive: true });
-    // Write pack.mcmeta once
-    if (!fs.existsSync(path.join(DATAPACK_DIR, 'pack.mcmeta'))) {
-        fs.writeFileSync(path.join(DATAPACK_DIR, 'pack.mcmeta'), JSON.stringify({
-            pack: { pack_format: 48, description: 'RedScript integration tests' }
-        }));
-    }
-    const result = (0, compile_1.compile)(source, { namespace });
-    if (result.error)
-        throw new Error(`Compile error in ${namespace}: ${result.error}`);
-    for (const file of result.files ?? []) {
-        if (file.path === 'pack.mcmeta')
-            continue;
-        const filePath = path.join(DATAPACK_DIR, file.path);
-        fs.mkdirSync(path.dirname(filePath), { recursive: true });
-        // Merge minecraft tag files (tick.json, load.json) instead of overwriting
-        if (file.path.includes('data/minecraft/tags/') && fs.existsSync(filePath)) {
-            const existing = JSON.parse(fs.readFileSync(filePath, 'utf-8'));
-            const incoming = JSON.parse(file.content);
-            const merged = { values: [...new Set([...(existing.values ?? []), ...(incoming.values ?? [])])] };
-            fs.writeFileSync(filePath, JSON.stringify(merged, null, 2));
-        }
-        else {
-            fs.writeFileSync(filePath, file.content);
-        }
-    }
-}
-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 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`);
-        console.warn(`  Then restart the MC server and re-run tests.`);
-        return;
-    }
-    // ── Write fixtures + use safe reloadData (no /reload confirm) ───────
-    // 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.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);
-    }
-  `, 'tick_test');
-    writeFixture(`
-    fn check_score() {
-      let x: int = scoreboard_get("#check_x", #test_score);
-      if (x > 5) {
-        scoreboard_set("#check_x", #result, 1);
-      } else {
-        scoreboard_set("#check_x", #result, 0);
-      }
-    }
-  `, 'inline_test');
-    // ── E2E scenario fixtures ────────────────────────────────────────────
-    // Scenario A: mini game loop (timer countdown + ended flag)
-    writeFixture(`
-    @tick
-    fn game_tick() {
-      let time: int = scoreboard_get("#game", #timer);
-      if (time > 0) {
-        scoreboard_set("#game", #timer, time - 1);
-      }
-      if (time == 1) {
-        scoreboard_set("#game", #ended, 1);
-      }
-    }
-    fn start_game() {
-      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);
-    }
-    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);
-    }
-    fn run_both() {
-      calc_sum();
-      calc_product();
-    }
-  `, 'math_test');
-    // 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);
-    }
-    fn step2() {
-      let v: int = scoreboard_get("#chain", #val);
-      scoreboard_set("#chain", #val, v + 5);
-      step3();
-    }
-    fn step1() {
-      scoreboard_set("#chain", #val, 10);
-      step2();
-    }
-  `, 'call_chain');
-    // Scenario D: setblock batching optimizer — 4 adjacent setblocks → fill
-    writeFixture(`
-    fn build_row() {
-      setblock((0, 70, 0), "minecraft:stone");
-      setblock((1, 70, 0), "minecraft:stone");
-      setblock((2, 70, 0), "minecraft:stone");
-      setblock((3, 70, 0), "minecraft:stone");
-    }
-  `, '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',
-        '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');
-    await mc.command('/scoreboard players set #tick_counter ticks 0');
-    await mc.command('/scoreboard players set #check_x test_score 10');
-    await mc.command('/scoreboard players set #check_x result 99');
-    // Safe reload (Bukkit.reloadData — only datapacks, no plugin restart)
-    console.log('  Reloading datapacks (safe reloadData)...');
-    await mc.reload();
-    await new Promise(r => setTimeout(r, 5000)); // wall-clock wait for data reload
-    // Initialize __load functions
-    await mc.command('/function counter:__load').catch(() => { });
-    await mc.command('/function inline_test:__load').catch(() => { });
-    await mc.ticks(20);
-    console.log('  Setup complete.');
-}, 60000);
-describe('MC Integration Tests', () => {
-    // ─── Test 1: Server connectivity ─────────────────────────────────────
-    test('server is online and healthy', async () => {
-        if (!serverOnline)
-            return;
-        const status = await mc.status();
-        expect(status.online).toBe(true);
-        expect(status.tps_1m).toBeGreaterThan(10); // Allow recovery after reload
-        console.log(`  Server: ${status.version}, TPS: ${status.tps_1m.toFixed(1)}`);
-    });
-    // ─── Test 2: Counter tick ─────────────────────────────────────────────
-    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)
-        const count = await mc.scoreboard('counter', 'ticks');
-        expect(count).toBeGreaterThan(0);
-        console.log(`  counter/ticks after setup+40 ticks: ${count}`);
-    });
-    // ─── Test 3: setblock ────────────────────────────────────────────────
-    test('world_manager.mcrs: setblock places correct block', async () => {
-        if (!serverOnline)
-            return;
-        // Clear just the lobby area, keep other state
-        await mc.fullReset({ x1: -10, y1: 60, z1: -10, x2: 15, y2: 80, z2: 15, resetScoreboards: false });
-        await mc.command('/function world_manager:__load');
-        await mc.command('/function world_manager:reset_lobby_platform');
-        await mc.ticks(10);
-        const block = await mc.block(4, 65, 4);
-        expect(block.type).toBe('minecraft:gold_block');
-        console.log(`  Block at (4,65,4): ${block.type}`);
-    });
-    // ─── Test 4: fill ────────────────────────────────────────────────────
-    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);
-        expect(block.type).toBe('minecraft:smooth_stone');
-        console.log(`  Floor at (4,64,4): ${block.type}`);
-    });
-    // ─── Test 5: Scoreboard arithmetic ───────────────────────────────────
-    test('scoreboard arithmetic works via commands', async () => {
-        if (!serverOnline)
-            return;
-        await mc.command('/scoreboard players set TestA calc 10');
-        await mc.command('/scoreboard players set TestB calc 25');
-        await mc.command('/scoreboard players operation TestA calc += TestB calc');
-        await mc.ticks(2);
-        const result = await mc.scoreboard('TestA', 'calc');
-        expect(result).toBe(35);
-        console.log(`  10 + 25 = ${result}`);
-    });
-    // ─── Test 6: Scoreboard proxy for announce ────────────────────────────
-    test('scoreboard proxy test (chat logging not supported for /say)', async () => {
-        if (!serverOnline)
-            return;
-        await mc.command('/scoreboard objectives add announce_test dummy');
-        await mc.command('/scoreboard players set announce_marker announce_test 42');
-        await mc.ticks(2);
-        const marker = await mc.scoreboard('announce_marker', 'announce_test');
-        expect(marker).toBe(42);
-        console.log(`  Marker value: ${marker}`);
-    });
-    // ─── Test 7: if/else logic via inline script ──────────────────────────
-    test('inline rs: if/else (x=10 > 5) sets result=1', async () => {
-        if (!serverOnline)
-            return;
-        // #check_x test_score=10 was set in beforeAll, run check_score
-        await mc.command('/function inline_test:check_score');
-        await mc.ticks(5);
-        const result = await mc.scoreboard('#check_x', 'result');
-        expect(result).toBe(1);
-        console.log(`  if (10 > 5) → result: ${result}`);
-    });
-    // ─── Test 8: Entity counting ──────────────────────────────────────────
-    test('entity query: armor_stands survive peaceful mode', async () => {
-        if (!serverOnline)
-            return;
-        await mc.fullReset({ clearArea: false, killEntities: true, resetScoreboards: false });
-        await mc.command('/summon minecraft:armor_stand 0 65 0');
-        await mc.command('/summon minecraft:armor_stand 2 65 0');
-        await mc.command('/summon minecraft:armor_stand 4 65 0');
-        await mc.ticks(5);
-        const stands = await mc.entities('@e[type=minecraft:armor_stand]');
-        expect(stands.length).toBe(3);
-        console.log(`  Spawned 3 armor_stands, found: ${stands.length}`);
-        await mc.command('/kill @e[type=minecraft:armor_stand]');
-    });
-    // ─── Test 9: @tick dispatcher runs every tick ─────────────────────────
-    test('@tick: tick_test increments #tick_counter every tick', async () => {
-        if (!serverOnline)
-            return;
-        // Reset counter
-        await mc.command('/scoreboard players set #tick_counter ticks 0');
-        await mc.ticks(40); // 2s
-        const ticks = await mc.scoreboard('#tick_counter', 'ticks');
-        expect(ticks).toBeGreaterThanOrEqual(10); // At least 10 of 40 ticks fired
-        console.log(`  #tick_counter after 40 ticks: ${ticks}`);
-    });
-    // ─── Test 10: fullReset clears blocks ─────────────────────────────────
-    test('fullReset clears previously placed blocks', async () => {
-        if (!serverOnline)
-            return;
-        await mc.command('/setblock 5 65 5 minecraft:diamond_block');
-        await mc.ticks(2);
-        let block = await mc.block(5, 65, 5);
-        expect(block.type).toBe('minecraft:diamond_block');
-        await mc.fullReset({ x1: 0, y1: 60, z1: 0, x2: 10, y2: 75, z2: 10, resetScoreboards: false });
-        block = await mc.block(5, 65, 5);
-        expect(block.type).toBe('minecraft:air');
-        console.log(`  Block after reset: ${block.type} ✓`);
-    });
-});
-// ─── E2E Scenario Tests ───────────────────────────────────────────────────────
-describe('E2E Scenario Tests', () => {
-    // Scenario A: Mini game loop
-    // Verifies: @tick auto-runs, scoreboard read-modify-write, two if conditions
-    // in the same function, timer countdown converges to ended=1
-    test('A: game_loop timer countdown sets ended=1 after N ticks', async () => {
-        if (!serverOnline)
-            return;
-        // game_tick is @tick - it runs every server tick automatically.
-        // start_game sets timer=5, but game_tick may already decrement it by the
-        // time we query. Use a large timer and just verify it reaches 0 eventually.
-        await mc.command('/scoreboard players set #game timer 0');
-        await mc.command('/scoreboard players set #game ended 0');
-        await mc.ticks(2);
-        await mc.command('/function game_loop:__load');
-        await mc.command('/function game_loop:start_game'); // timer=5, ended=0
-        // Wait 25 ticks — enough for 5 decrements + margin
-        await mc.ticks(25);
-        const ended = await mc.scoreboard('#game', 'ended');
-        expect(ended).toBe(1);
-        const finalTimer = await mc.scoreboard('#game', 'timer');
-        expect(finalTimer).toBe(0);
-        console.log(`  timer hit 0 (final=${finalTimer}), ended=${ended} ✓`);
-    });
-    // Scenario B: No temp var collision between two functions called in sequence
-    // 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;
-        await mc.command('/function math_test:__load');
-        await mc.command('/scoreboard players set #math val_a 7');
-        await mc.command('/scoreboard players set #math val_b 3');
-        await mc.command('/scoreboard players set #math val_x 4');
-        await mc.command('/scoreboard players set #math val_y 5');
-        await mc.command('/function math_test:run_both'); // calc_sum() then calc_product()
-        await mc.ticks(5);
-        const sum = await mc.scoreboard('#math', 'sum');
-        const product = await mc.scoreboard('#math', 'product');
-        expect(sum).toBe(10); // 7 + 3
-        expect(product).toBe(20); // 4 × 5
-        console.log(`  sum=${sum} (expect 10), product=${product} (expect 20) ✓`);
-    });
-    // Scenario C: 3-deep call chain, shared state threaded through
-    // Verifies: function calls preserve scoreboard state across stack frames
-    // step1: val=10 → step2: val=10+5=15 → step3: val=15×2=30
-    test('C: 3-deep call chain preserves intermediate state (10→15→30)', async () => {
-        if (!serverOnline)
-            return;
-        await mc.command('/function call_chain:__load');
-        await mc.command('/scoreboard players set #chain val 0');
-        await mc.command('/function call_chain:step1');
-        await mc.ticks(5);
-        const val = await mc.scoreboard('#chain', 'val');
-        expect(val).toBe(30); // (10 + 5) * 2 = 30
-        console.log(`  call chain result: ${val} (expect 30) ✓`);
-    });
-    // Scenario D: Setblock batching optimizer — 4 adjacent setblocks compiled to fill
-    // Verifies: optimizer's fill-batching pass produces correct MC behavior
-    // (not just that the output says "fill", but that ALL 4 blocks are actually stone)
-    test('D: fill optimizer — 4 adjacent setblocks all placed correctly', async () => {
-        if (!serverOnline)
-            return;
-        await mc.fullReset({ x1: -5, y1: 65, z1: -5, x2: 10, y2: 75, z2: 10, resetScoreboards: false });
-        await mc.command('/function fill_test:__load');
-        await mc.command('/function fill_test:build_row');
-        await mc.ticks(5);
-        // All 4 blocks should be stone (optimizer batched into fill 0 70 0 3 70 0 stone)
-        for (let x = 0; x <= 3; x++) {
-            const block = await mc.block(x, 70, 0);
-            expect(block.type).toBe('minecraft:stone');
-        }
-        // Neighbors should still be air (fill didn't overshoot)
-        const before = await mc.block(-1, 70, 0);
-        const after = await mc.block(4, 70, 0);
-        expect(before.type).toBe('minecraft:air');
-        expect(after.type).toBe('minecraft:air');
-        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 correctly matches entity types', async () => {
-        if (!serverOnline)
-            return;
-        await mc.fullReset({ clearArea: false, killEntities: true, resetScoreboards: false });
-        await mc.command('/forceload add 0 0').catch(() => { }); // Ensure chunk is loaded
-        await mc.command('/scoreboard objectives add armor_stands dummy').catch(() => { });
-        await mc.command('/scoreboard objectives add items dummy').catch(() => { });
-        await mc.command('/scoreboard players set #is_check armor_stands 0');
-        await mc.command('/scoreboard players set #is_check items 0');
-        await mc.command('/function is_check_test:__load').catch(() => { });
-        // Spawn 2 armor_stands and 1 item (all persist without players)
-        await mc.command('/summon minecraft:armor_stand 0 65 0 {Tags:["is_check_target"],NoGravity:1b}');
-        await mc.command('/summon minecraft:armor_stand 2 65 0 {Tags:["is_check_target"],NoGravity:1b}');
-        await mc.command('/summon minecraft:item 4 65 0 {Tags:["is_check_target"],Item:{id:"minecraft:stone",count:1},Age:-32768}');
-        await mc.ticks(5);
-        await mc.command('/function is_check_test:check_types');
-        await mc.ticks(5);
-        const armorStands = await mc.scoreboard('#is_check', 'armor_stands');
-        const items = await mc.scoreboard('#is_check', 'items');
-        expect(armorStands).toBe(2); // 2 armor_stands matched
-        expect(items).toBe(1); // 1 item matched
-        await mc.command('/function is_check_test:cleanup').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);
-    });
-});
-describe('MC Integration - Extended Coverage', () => {
-    test('struct-test.mcrs: struct instantiation and field access', async () => {
-        if (!serverOnline)
-            return;
-        writeFixtureFile('struct-test.mcrs', 'struct_test');
-        await mc.reload();
-        await mc.command('/function struct_test:__load').catch(() => { });
-        await mc.command('/function struct_test:test_struct');
-        await mc.ticks(5);
-        expect(await mc.scoreboard('#struct_x', 'rs')).toBe(10);
-        expect(await mc.scoreboard('#struct_y', 'rs')).toBe(64);
-        expect(await mc.scoreboard('#struct_z', 'rs')).toBe(-5);
-        expect(await mc.scoreboard('#struct_x2', 'rs')).toBe(15); // 10+5
-        expect(await mc.scoreboard('#struct_z2', 'rs')).toBe(-10); // -5*2
-        expect(await mc.scoreboard('#struct_alive', 'rs')).toBe(1);
-        expect(await mc.scoreboard('#struct_score', 'rs')).toBe(100);
-    });
-    test('enum-test.mcrs: enum values and match', async () => {
-        if (!serverOnline)
-            return;
-        writeFixtureFile('enum-test.mcrs', 'enum_test');
-        await mc.reload();
-        await mc.command('/function enum_test:__load').catch(() => { });
-        await mc.command('/function enum_test:test_enum');
-        await mc.ticks(5);
-        expect(await mc.scoreboard('#enum_phase', 'rs')).toBe(2); // Playing=2
-        expect(await mc.scoreboard('#enum_match', 'rs')).toBe(2); // matched Playing
-        expect(await mc.scoreboard('#enum_rank', 'rs')).toBe(10); // Diamond=10
-        expect(await mc.scoreboard('#enum_high', 'rs')).toBe(1); // Diamond > Gold
-    });
-    test('array-test.mcrs: array operations', async () => {
-        if (!serverOnline)
-            return;
-        writeFixtureFile('array-test.mcrs', 'array_test');
-        await mc.reload();
-        await mc.command('/function array_test:__load').catch(() => { });
-        await mc.command('/function array_test:test_array');
-        await mc.ticks(5);
-        expect(await mc.scoreboard('#arr_0', 'rs')).toBe(10);
-        expect(await mc.scoreboard('#arr_2', 'rs')).toBe(30);
-        expect(await mc.scoreboard('#arr_4', 'rs')).toBe(50);
-        expect(await mc.scoreboard('#arr_len', 'rs')).toBe(5);
-        expect(await mc.scoreboard('#arr_sum', 'rs')).toBe(150); // 10+20+30+40+50
-        expect(await mc.scoreboard('#arr_push', 'rs')).toBe(4); // [1,2,3,4].len
-        expect(await mc.scoreboard('#arr_pop', 'rs')).toBe(4); // popped value
-    });
-    test('break-continue-test.mcrs: break and continue statements', async () => {
-        if (!serverOnline)
-            return;
-        writeFixtureFile('break-continue-test.mcrs', 'break_continue_test');
-        await mc.reload();
-        await mc.command('/function break_continue_test:__load').catch(() => { });
-        await mc.command('/function break_continue_test:test_break_continue');
-        await mc.ticks(10);
-        expect(await mc.scoreboard('#break_at', 'rs')).toBe(5);
-        expect(await mc.scoreboard('#sum_evens', 'rs')).toBe(20); // 0+2+4+6+8
-        expect(await mc.scoreboard('#while_break', 'rs')).toBe(7);
-        expect(await mc.scoreboard('#nested_break', 'rs')).toBe(3); // outer completes 3 times
-    });
-    test('match-range-test.mcrs: match with range patterns', async () => {
-        if (!serverOnline)
-            return;
-        writeFixtureFile('match-range-test.mcrs', 'match_range_test');
-        await mc.reload();
-        await mc.command('/function match_range_test:__load').catch(() => { });
-        await mc.command('/function match_range_test:test_match_range');
-        await mc.ticks(5);
-        expect(await mc.scoreboard('#grade', 'rs')).toBe(4); // score=85 → B
-        expect(await mc.scoreboard('#boundary_59', 'rs')).toBe(1); // 59 matches 0..59
-        expect(await mc.scoreboard('#boundary_60', 'rs')).toBe(2); // 60 matches 60..100
-        expect(await mc.scoreboard('#neg_range', 'rs')).toBe(1); // -5 matches ..0
-    });
-    test('foreach-at-test.mcrs: foreach with at @s context', async () => {
-        if (!serverOnline)
-            return;
-        writeFixtureFile('foreach-at-test.mcrs', 'foreach_at_test');
-        await mc.reload();
-        await mc.fullReset({ clearArea: false, killEntities: true, resetScoreboards: false });
-        await mc.command('/function foreach_at_test:setup').catch(() => { });
-        await mc.command('/function foreach_at_test:test_foreach_at');
-        await mc.ticks(10);
-        expect(await mc.scoreboard('#foreach_count', 'rs')).toBe(3);
-        expect(await mc.scoreboard('#foreach_at_count', 'rs')).toBe(3);
-    });
-});
-//# sourceMappingURL=mc-integration.test.js.map