redscript-mc 2.4.1 → 2.6.0

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

@@ -826,4 +826,668 @@ describe('MC Integration - Extended Coverage', () => {
         expect(await mc.scoreboard('#foreach_at_count', 'rs')).toBe(3);
     });
 });
+// ─── stdlib math integration ──────────────────────────────────────────────────
+const MATH_SRC = fs.readFileSync(path.join(__dirname, '../stdlib/math.mcrs'), 'utf-8');
+function writeFixtureWithLibs(fileName, namespace, librarySources) {
+    const source = fs.readFileSync(path.join(FIXTURE_DIR, fileName), 'utf-8');
+    fs.mkdirSync(DATAPACK_DIR, { recursive: true });
+    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, librarySources });
+    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 });
+        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);
+        }
+    }
+}
+describe('MC Integration - stdlib math', () => {
+    beforeAll(async () => {
+        if (!serverOnline)
+            return;
+        writeFixtureWithLibs('stdlib-math-integration.mcrs', 'stdmath', [MATH_SRC]);
+        await mc.reload();
+        await mc.command('/function stdmath:__load').catch(() => { });
+        await mc.ticks(5);
+    });
+    test('factorial(5) == 120', async () => {
+        if (!serverOnline)
+            return;
+        await mc.command('/function stdmath:test_math_basic');
+        await mc.ticks(5);
+        expect(await mc.scoreboard('#factorial_5', 'rs')).toBe(120);
+    });
+    test('combinations(5,2) == 10', async () => {
+        if (!serverOnline)
+            return;
+        await mc.command('/function stdmath:test_math_basic');
+        await mc.ticks(5);
+        expect(await mc.scoreboard('#combinations_5_2', 'rs')).toBe(10);
+    });
+    test('gcd(12,8) == 4', async () => {
+        if (!serverOnline)
+            return;
+        await mc.command('/function stdmath:test_math_basic');
+        await mc.ticks(5);
+        expect(await mc.scoreboard('#gcd_12_8', 'rs')).toBe(4);
+    });
+    test('isqrt(144) == 12', async () => {
+        if (!serverOnline)
+            return;
+        await mc.command('/function stdmath:test_math_basic');
+        await mc.ticks(5);
+        expect(await mc.scoreboard('#isqrt_144', 'rs')).toBe(12);
+    });
+    test('log2_int(1024) == 10', async () => {
+        if (!serverOnline)
+            return;
+        await mc.command('/function stdmath:test_math_basic');
+        await mc.ticks(5);
+        expect(await mc.scoreboard('#log2_1024', 'rs')).toBe(10);
+    });
+    test('pow_int(2,10) == 1024', async () => {
+        if (!serverOnline)
+            return;
+        await mc.command('/function stdmath:test_math_basic');
+        await mc.ticks(5);
+        expect(await mc.scoreboard('#pow_2_10', 'rs')).toBe(1024);
+    });
+    test('abs(-42) == 42', async () => {
+        if (!serverOnline)
+            return;
+        await mc.command('/function stdmath:test_math_basic');
+        await mc.ticks(5);
+        expect(await mc.scoreboard('#abs_neg42', 'rs')).toBe(42);
+    });
+    test('clamp(15,0,10) == 10', async () => {
+        if (!serverOnline)
+            return;
+        await mc.command('/function stdmath:test_math_basic');
+        await mc.ticks(5);
+        expect(await mc.scoreboard('#clamp_hi', 'rs')).toBe(10);
+    });
+    test('sqrt_fx(40000) == 20000', async () => {
+        if (!serverOnline)
+            return;
+        await mc.command('/function stdmath:test_math_sqrt');
+        await mc.ticks(5);
+        expect(await mc.scoreboard('#sqrt_fx_40000', 'rs')).toBe(20000);
+    });
+    test('cbrt_fx(27) == 3', async () => {
+        if (!serverOnline)
+            return;
+        await mc.command('/function stdmath:test_math_sqrt');
+        await mc.ticks(5);
+        expect(await mc.scoreboard('#cbrt_27', 'rs')).toBe(3);
+    });
+    test('approx_eq(100,103,5) == 1', async () => {
+        if (!serverOnline)
+            return;
+        await mc.command('/function stdmath:test_math_approx');
+        await mc.ticks(5);
+        expect(await mc.scoreboard('#apeq_yes', 'rs')).toBe(1);
+    });
+    test('approx_eq(100,110,5) == 0', async () => {
+        if (!serverOnline)
+            return;
+        await mc.command('/function stdmath:test_math_approx');
+        await mc.ticks(5);
+        expect(await mc.scoreboard('#apeq_no', 'rs')).toBe(0);
+    });
+});
+// ─── stdlib extra (random, bits, list_sort, bigint, math_hp) ─────────────────
+const RANDOM_SRC = fs.readFileSync(path.join(__dirname, '../stdlib/random.mcrs'), 'utf-8');
+const BITS_SRC = fs.readFileSync(path.join(__dirname, '../stdlib/bits.mcrs'), 'utf-8');
+const LIST_SRC = fs.readFileSync(path.join(__dirname, '../stdlib/list.mcrs'), 'utf-8');
+const BIGINT_SRC = fs.readFileSync(path.join(__dirname, '../stdlib/bigint.mcrs'), 'utf-8');
+const MATH_HP_SRC = fs.readFileSync(path.join(__dirname, '../stdlib/math_hp.mcrs'), 'utf-8');
+const HEAP_SRC = fs.readFileSync(path.join(__dirname, '../stdlib/heap.mcrs'), 'utf-8');
+const SORT_SRC = fs.readFileSync(path.join(__dirname, '../stdlib/sort.mcrs'), 'utf-8');
+describe('MC Integration - stdlib extra (random/bits/list/bigint)', () => {
+    beforeAll(async () => {
+        if (!serverOnline)
+            return;
+        writeFixtureWithLibs('stdlib-extra-test.mcrs', 'stdextra', [MATH_SRC, MATH_HP_SRC, RANDOM_SRC, BITS_SRC, LIST_SRC, BIGINT_SRC]);
+        await mc.reload();
+        await mc.ticks(10);
+        await mc.command('/function stdextra:__load').catch(() => { });
+        await mc.ticks(5);
+    });
+    test('next_lcg(12345) is deterministic and non-zero', async () => {
+        if (!serverOnline)
+            return;
+        await mc.command('/function stdextra:test_random');
+        await mc.ticks(5);
+        const v = await mc.scoreboard('#lcg_12345', 'rsex');
+        expect(typeof v).toBe('number');
+        expect(v).not.toBe(0);
+    });
+    test('two consecutive lcg calls produce different values', async () => {
+        if (!serverOnline)
+            return;
+        await mc.command('/function stdextra:test_random');
+        await mc.ticks(5);
+        expect(await mc.scoreboard('#lcg_different', 'rsex')).toBe(1);
+    });
+    test('random_range stays in [0, 10)', async () => {
+        if (!serverOnline)
+            return;
+        await mc.command('/function stdextra:test_random');
+        await mc.ticks(5);
+        expect(await mc.scoreboard('#rand_in_range', 'rsex')).toBe(1);
+    });
+    test('random_bool returns 0 or 1', async () => {
+        if (!serverOnline)
+            return;
+        await mc.command('/function stdextra:test_random');
+        await mc.ticks(5);
+        expect(await mc.scoreboard('#rand_bool_valid', 'rsex')).toBe(1);
+    });
+    test('bit_get(5, 0) == 1', async () => {
+        if (!serverOnline)
+            return;
+        await mc.command('/function stdextra:test_bits');
+        await mc.ticks(5);
+        expect(await mc.scoreboard('#bit_get_5_0', 'rsex')).toBe(1);
+    });
+    test('bit_get(5, 1) == 0', async () => {
+        if (!serverOnline)
+            return;
+        await mc.command('/function stdextra:test_bits');
+        await mc.ticks(5);
+        expect(await mc.scoreboard('#bit_get_5_1', 'rsex')).toBe(0);
+    });
+    test('bit_shl(1, 3) == 8', async () => {
+        if (!serverOnline)
+            return;
+        await mc.command('/function stdextra:test_bits');
+        await mc.ticks(5);
+        expect(await mc.scoreboard('#bit_shl_1_3', 'rsex')).toBe(8);
+    });
+    test('bit_shr(8, 2) == 2', async () => {
+        if (!serverOnline)
+            return;
+        await mc.command('/function stdextra:test_bits');
+        await mc.ticks(5);
+        expect(await mc.scoreboard('#bit_shr_8_2', 'rsex')).toBe(2);
+    });
+    test('popcount(7) == 3', async () => {
+        if (!serverOnline)
+            return;
+        await mc.command('/function stdextra:test_bits');
+        await mc.ticks(5);
+        expect(await mc.scoreboard('#popcount_7', 'rsex')).toBe(3);
+    });
+    test('popcount(0) == 0', async () => {
+        if (!serverOnline)
+            return;
+        await mc.command('/function stdextra:test_bits');
+        await mc.ticks(5);
+        expect(await mc.scoreboard('#popcount_0', 'rsex')).toBe(0);
+    });
+    test('sort3(30,10,20, 0) == 10 (min)', async () => {
+        if (!serverOnline)
+            return;
+        await mc.command('/function stdextra:test_list_sort');
+        await mc.ticks(5);
+        expect(await mc.scoreboard('#sort3_min', 'rsex')).toBe(10);
+    });
+    test('sort3(30,10,20, 2) == 30 (max)', async () => {
+        if (!serverOnline)
+            return;
+        await mc.command('/function stdextra:test_list_sort');
+        await mc.ticks(5);
+        expect(await mc.scoreboard('#sort3_max', 'rsex')).toBe(30);
+    });
+    test('sort4(40,10,30,20, 0) == 10 (min)', async () => {
+        if (!serverOnline)
+            return;
+        await mc.command('/function stdextra:test_list_sort');
+        await mc.ticks(5);
+        expect(await mc.scoreboard('#sort4_min', 'rsex')).toBe(10);
+    });
+    test('sort4(40,10,30,20, 3) == 40 (max)', async () => {
+        if (!serverOnline)
+            return;
+        await mc.command('/function stdextra:test_list_sort');
+        await mc.ticks(5);
+        expect(await mc.scoreboard('#sort4_max', 'rsex')).toBe(40);
+    });
+    test('list_min3(5,3,8) == 3', async () => {
+        if (!serverOnline)
+            return;
+        await mc.command('/function stdextra:test_list_sort');
+        await mc.ticks(5);
+        expect(await mc.scoreboard('#list_min3', 'rsex')).toBe(3);
+    });
+    test('list_max3(5,3,8) == 8', async () => {
+        if (!serverOnline)
+            return;
+        await mc.command('/function stdextra:test_list_sort');
+        await mc.ticks(5);
+        expect(await mc.scoreboard('#list_max3', 'rsex')).toBe(8);
+    });
+    test('avg3(10,20,30) == 20', async () => {
+        if (!serverOnline)
+            return;
+        await mc.command('/function stdextra:test_list_sort');
+        await mc.ticks(5);
+        expect(await mc.scoreboard('#avg3', 'rsex')).toBe(20);
+    });
+    test('bigint3_add_lo(9999, 1) == 0', async () => {
+        if (!serverOnline)
+            return;
+        await mc.command('/function stdextra:test_bigint');
+        await mc.ticks(5);
+        expect(await mc.scoreboard('#bi3_add_lo', 'rsex')).toBe(0);
+    });
+    test('bigint3_carry_lo(9999, 1) == 1', async () => {
+        if (!serverOnline)
+            return;
+        await mc.command('/function stdextra:test_bigint');
+        await mc.ticks(5);
+        expect(await mc.scoreboard('#bi3_carry_lo', 'rsex')).toBe(1);
+    });
+    test('bigint3_cmp([1,0,0] vs [0,9999,9999]) == 1', async () => {
+        if (!serverOnline)
+            return;
+        await mc.command('/function stdextra:test_bigint');
+        await mc.ticks(5);
+        expect(await mc.scoreboard('#bi3_cmp_gt', 'rsex')).toBe(1);
+    });
+    test('bigint3_cmp([0,9999,9999] vs [1,0,0]) == -1', async () => {
+        if (!serverOnline)
+            return;
+        await mc.command('/function stdextra:test_bigint');
+        await mc.ticks(5);
+        expect(await mc.scoreboard('#bi3_cmp_lt', 'rsex')).toBe(-1);
+    });
+    test('int32_to_bigint3_hi(1023456789) == 10', async () => {
+        if (!serverOnline)
+            return;
+        await mc.command('/function stdextra:test_bigint');
+        await mc.ticks(5);
+        expect(await mc.scoreboard('#bi3_hi', 'rsex')).toBe(10);
+    });
+    test('int32_to_bigint3_mid(1023456789) == 2345', async () => {
+        if (!serverOnline)
+            return;
+        await mc.command('/function stdextra:test_bigint');
+        await mc.ticks(5);
+        expect(await mc.scoreboard('#bi3_mid', 'rsex')).toBe(2345);
+    });
+    test('int32_to_bigint3_lo(1023456789) == 6789', async () => {
+        if (!serverOnline)
+            return;
+        await mc.command('/function stdextra:test_bigint');
+        await mc.ticks(5);
+        expect(await mc.scoreboard('#bi3_lo', 'rsex')).toBe(6789);
+    });
+});
+// ─── stdlib math_hp integration ───────────────────────────────────────────────
+describe('MC Integration - math_hp (ln_hp, double_mul_fixed)', () => {
+    beforeAll(async () => {
+        if (!serverOnline)
+            return;
+        // stdextra is already written with MATH_HP_SRC in the previous describe's beforeAll.
+        // Just need the scoreboard and a fresh reload.
+        await mc.command('/scoreboard objectives add rshp dummy').catch(() => { });
+        await mc.ticks(2);
+    });
+    // ─── ln_hp ─────────────────────────────────────────────────────────────────
+    test('ln_hp(10000) == 0  [ln(1) = 0]', async () => {
+        if (!serverOnline)
+            return;
+        await mc.command('/function stdextra:test_ln_hp');
+        await mc.ticks(5);
+        expect(await mc.scoreboard('#ln_1', 'rshp')).toBe(0);
+    });
+    test('ln_hp(27183) ≈ 10000  [ln(e) ≈ 1.0, tolerance ±10]', async () => {
+        if (!serverOnline)
+            return;
+        await mc.command('/function stdextra:test_ln_hp');
+        await mc.ticks(5);
+        const v = await mc.scoreboard('#ln_e', 'rshp');
+        expect(v).toBeGreaterThanOrEqual(9990);
+        expect(v).toBeLessThanOrEqual(10010);
+        console.log(`  ln_hp(27183) = ${v} (expect ≈10000) ✓`);
+    });
+    test('ln_hp(20000) ≈ 6931  [ln(2), tolerance ±10]', async () => {
+        if (!serverOnline)
+            return;
+        await mc.command('/function stdextra:test_ln_hp');
+        await mc.ticks(5);
+        const v = await mc.scoreboard('#ln_2', 'rshp');
+        expect(v).toBeGreaterThanOrEqual(6921);
+        expect(v).toBeLessThanOrEqual(6941);
+        console.log(`  ln_hp(20000) = ${v} (expect ≈6931) ✓`);
+    });
+    test('ln_hp(100000) ≈ 23026  [ln(10), tolerance ±20]', async () => {
+        if (!serverOnline)
+            return;
+        await mc.command('/function stdextra:test_ln_hp');
+        await mc.ticks(5);
+        const v = await mc.scoreboard('#ln_10', 'rshp');
+        expect(v).toBeGreaterThanOrEqual(23006);
+        expect(v).toBeLessThanOrEqual(23046);
+        console.log(`  ln_hp(100000) = ${v} (expect ≈23026) ✓`);
+    });
+    // ─── double_mul_fixed ───────────────────────────────────────────────────────
+    test('double_mul_fixed(2.0d, 15000) ≈ 30000  [2.0 × 1.5 = 3.0, as fixed]', async () => {
+        if (!serverOnline)
+            return;
+        // Set f=15000 (1.5 in ×10000 fixed) which the fixture reads via scoreboard_get
+        await mc.command('/scoreboard players set #dmul_f_in rshp 15000');
+        await mc.command('/function stdextra:test_double_mul_fixed');
+        await mc.ticks(5);
+        const v = await mc.scoreboard('#dmul_result', 'rshp');
+        // 2.0 × 1.5 = 3.0 → as fixed (×10000) = 30000
+        expect(v).toBeGreaterThanOrEqual(29990);
+        expect(v).toBeLessThanOrEqual(30010);
+        console.log(`  double_mul_fixed(2.0d, 15000) as fixed = ${v} (expect ≈30000) ✓`);
+    });
+});
+// ─── Bot API helpers ──────────────────────────────────────────────────────────
+const BOT_URL = 'http://localhost:25562';
+async function botGet(endpoint) {
+    const res = await fetch(`${BOT_URL}${endpoint}`);
+    return res.json();
+}
+async function botPost(endpoint, body = {}) {
+    const res = await fetch(`${BOT_URL}${endpoint}`, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify(body),
+    });
+    return res.json();
+}
+async function botItemCount(name) {
+    const data = await botGet(`/inventory/count?name=${encodeURIComponent(name)}`);
+    return data.count ?? 0;
+}
+async function clearBotInventory() {
+    await mc.command('clear TestBot');
+    await botPost('/wait', { ticks: 5 });
+}
+async function getNbt(storage, nbtPath) {
+    const res = await fetch(`http://localhost:25561/nbt?storage=${encodeURIComponent(storage)}&path=${encodeURIComponent(nbtPath)}`);
+    const data = await res.json();
+    return typeof data.value === 'number' ? data.value : null;
+}
+// ─── Player-facing tests ──────────────────────────────────────────────────────
+let botOnline = false;
+describe('player-facing: bot setup', () => {
+    beforeAll(async () => {
+        try {
+            const status = await botGet('/status');
+            botOnline = status.connected === true;
+        }
+        catch {
+            botOnline = false;
+        }
+    });
+    test('mineflayer TestBot is connected', () => {
+        if (!botOnline) {
+            console.warn('  ⚠ TestBot not running — skipping player-facing tests');
+        }
+        // Non-fatal: skip rather than fail if bot is not up
+        expect(typeof botOnline).toBe('boolean');
+    });
+});
+describe('player-facing: give items', () => {
+    beforeEach(async () => {
+        if (!botOnline || !serverOnline)
+            return;
+        await clearBotInventory();
+    });
+    test('give command delivers diamond to TestBot', async () => {
+        if (!botOnline || !serverOnline)
+            return;
+        await mc.command('give TestBot minecraft:diamond 5');
+        await botPost('/wait', { ticks: 10 });
+        const count = await botItemCount('diamond');
+        expect(count).toBe(5);
+        console.log(`  give TestBot diamond 5 → inventory count = ${count} ✓`);
+    });
+    test('give gold_ingot to TestBot', async () => {
+        if (!botOnline || !serverOnline)
+            return;
+        await mc.command('give TestBot minecraft:gold_ingot 3');
+        await botPost('/wait', { ticks: 10 });
+        const count = await botItemCount('gold_ingot');
+        expect(count).toBe(3);
+        console.log(`  give TestBot gold_ingot 3 → inventory count = ${count} ✓`);
+    });
+});
+describe('player-facing: effects', () => {
+    test('effect give speed applies to TestBot', async () => {
+        if (!botOnline || !serverOnline)
+            return;
+        await mc.command('effect clear TestBot');
+        await botPost('/wait', { ticks: 5 });
+        await mc.command('effect give TestBot minecraft:speed 30 1');
+        await botPost('/wait', { ticks: 10 });
+        const data = await botGet('/effects');
+        // Speed = MC effect id 1
+        // mineflayer uses 0-based effect ids (speed = 0), MC uses 1-based (speed = 1)
+        const hasSpeed = Array.isArray(data.effects) && data.effects.length > 0;
+        expect(hasSpeed).toBe(true);
+        console.log(`  effect give speed → effects: ${JSON.stringify(data.effects)} ✓`);
+    });
+});
+describe('double precision: NBT read/write via /nbt endpoint', () => {
+    test('write double to rs:d and read it back', async () => {
+        if (!serverOnline)
+            return;
+        await mc.command('data modify storage rs:d result set value 3.14159d');
+        await mc.ticks(2);
+        const val = await getNbt('rs:d', 'result');
+        expect(val).not.toBeNull();
+        expect(val).toBeCloseTo(3.14159, 4);
+        console.log(`  rs:d result = ${val} (expect ≈3.14159) ✓`);
+    });
+    test('write integer double and read back as 1.0', async () => {
+        if (!serverOnline)
+            return;
+        await mc.command('data modify storage rs:d result set value 1.0d');
+        await mc.ticks(2);
+        const val = await getNbt('rs:d', 'result');
+        expect(val).toBe(1.0);
+        console.log(`  rs:d result = ${val} (expect 1.0) ✓`);
+    });
+});
+// ─── @coroutine MC integration tests ─────────────────────────────────────────
+describe('@coroutine: tick-spreading via /tick freeze+step', () => {
+    const CORO_NS = 'coro_mc_test';
+    const OBJ = `__${CORO_NS}`;
+    beforeAll(async () => {
+        if (!serverOnline)
+            return;
+        writeFixtureFile('coroutine-mc-test.mcrs', CORO_NS);
+        await mc.reload();
+    });
+    test('sum(0..99) = 4950 with batch=10 after 15 ticks', async () => {
+        if (!serverOnline)
+            return;
+        // Reset accumulators
+        await mc.command(`scoreboard players set $coro_sum_acc ${OBJ} 0`);
+        await mc.command(`scoreboard players set $coro_done_count ${OBJ} 0`);
+        await mc.withTickControl(async (step) => {
+            // Trigger: call trigger_coro_sum function directly
+            await mc.command(`/function coro_mc_test:trigger_coro_sum`);
+            // batch=10, 100 iters → need 10 ticks; give 15 for safety
+            await step(15);
+        });
+        const result = await mc.scoreboard('$coro_sum_acc', OBJ);
+        const doneCount = await mc.scoreboard('$coro_done_count', OBJ);
+        expect(result).toBe(4950);
+        expect(doneCount).toBe(1);
+        console.log(`  coro sum(0..99) = ${result} (expect 4950), onDone = ${doneCount} ✓`);
+    }, 30000);
+    test('partial: batch=5 — not complete after 3 ticks', async () => {
+        if (!serverOnline)
+            return;
+        // Reset
+        await mc.command(`scoreboard players set $partial_acc ${OBJ} 0`);
+        await mc.command(`scoreboard players set $partial_done ${OBJ} 0`);
+        await mc.tickFreeze();
+        try {
+            // Trigger
+            await mc.command(`/function coro_mc_test:trigger_partial`);
+            // Step only 3 ticks (need 10 for 50 iters / batch=5)
+            await mc.tickStep(3);
+            const earlyDone = await mc.scoreboard('$partial_done', OBJ).catch(() => 0);
+            // onDone not yet fired — proves tick spreading
+            expect(earlyDone).toBe(0);
+            console.log(`  after 3 ticks: partial_done = ${earlyDone} (expect 0 — not yet complete) ✓`);
+            // Now advance enough to complete
+            await mc.tickStep(10);
+        }
+        finally {
+            await mc.tickUnfreeze();
+        }
+        const finalDone = await mc.scoreboard('$partial_done', OBJ);
+        const finalAcc = await mc.scoreboard('$partial_acc', OBJ);
+        expect(finalDone).toBe(1);
+        expect(finalAcc).toBe(1225); // sum(0..49) = 1225
+        console.log(`  after 13 ticks: partial_done = ${finalDone}, acc = ${finalAcc} (expect 1225) ✓`);
+    }, 30000);
+});
+// ─── heap & sort stdlib MC integration tests ──────────────────────────────────
+describe('MC Integration - heap & sort stdlib', () => {
+    beforeAll(async () => {
+        if (!serverOnline)
+            return;
+        writeFixtureWithLibs('heap-sort-mc-test.mcrs', 'heap_sort_mc_test', [HEAP_SRC, SORT_SRC]);
+        await mc.reload();
+        await mc.ticks(5);
+        await mc.command('/function heap_sort_mc_test:load_fn').catch(() => { });
+        await mc.ticks(3);
+    });
+    test('MinHeap push/pop: push 5,1,3,2,4 → first 3 pops = 1,2,3', async () => {
+        if (!serverOnline)
+            return;
+        await mc.command('/function heap_sort_mc_test:test_min_heap');
+        await mc.ticks(5);
+        const encoded = await mc.scoreboard('#heap_min_top3', 'hsmc');
+        expect(encoded).toBe(123); // 100*1 + 10*2 + 3
+        const sizeAfter = await mc.scoreboard('#heap_size_after_pop3', 'hsmc');
+        expect(sizeAfter).toBe(3); // 5 pushed, 2 pops (peek→pop→peek→pop→peek), 5-2=3
+        console.log(`  MinHeap top3 encoded=${encoded} (expect 123), size after 2 pops=${sizeAfter} (expect 3) ✓`);
+    }, 20000);
+    test('MaxHeap push/pop: push 3,1,4,1,5 → first pop = 5, second = 4', async () => {
+        if (!serverOnline)
+            return;
+        await mc.command('/function heap_sort_mc_test:test_max_heap');
+        await mc.ticks(5);
+        const top = await mc.scoreboard('#max_heap_top', 'hsmc');
+        expect(top).toBe(5);
+        const second = await mc.scoreboard('#max_heap_second', 'hsmc');
+        expect(second).toBe(4);
+        console.log(`  MaxHeap top=${top} (expect 5), second=${second} (expect 4) ✓`);
+    }, 20000);
+    test('insertion_sort ascending: [30,10,50,20,40] → [10,20,30,40,50]', async () => {
+        if (!serverOnline)
+            return;
+        await mc.command('/function heap_sort_mc_test:test_sort_asc');
+        await mc.ticks(5);
+        const ok = await mc.scoreboard('#sort_asc_ok', 'hsmc');
+        const first = await mc.scoreboard('#sort_asc_first', 'hsmc');
+        const last = await mc.scoreboard('#sort_asc_last', 'hsmc');
+        expect(ok).toBe(1);
+        expect(first).toBe(10);
+        expect(last).toBe(50);
+        console.log(`  sort_asc ok=${ok}, first=${first} (10), last=${last} (50) ✓`);
+    }, 15000);
+    test('insertion_sort descending: [30,10,50,20,40] → [50,...,10]', async () => {
+        if (!serverOnline)
+            return;
+        await mc.command('/function heap_sort_mc_test:test_sort_desc');
+        await mc.ticks(5);
+        const ok = await mc.scoreboard('#sort_desc_ok', 'hsmc');
+        expect(ok).toBe(1);
+        console.log(`  sort_desc ok=${ok} ✓`);
+    }, 15000);
+    test('sort_merge([1,3,5], [2,4,6]) → NBT result = [1,2,3,4,5,6]', async () => {
+        if (!serverOnline)
+            return;
+        await mc.command('/function heap_sort_mc_test:test_sort_merge');
+        await mc.ticks(5);
+        const ran = await mc.scoreboard('#sort_merge_ran', 'hsmc');
+        expect(ran).toBe(1);
+        // Read result array from NBT storage directly via fetch
+        const url = `http://localhost:25561/nbt?storage=${encodeURIComponent('heap_sort_mc_test:arrays')}&path=${encodeURIComponent('result')}`;
+        const resp = await fetch(url);
+        const data = await resp.json();
+        // result should be [1, 2, 3, 4, 5, 6]
+        const nums = data.value.replace(/[\[\]]/g, '').split(',').map((s) => parseInt(s.trim(), 10));
+        expect(nums).toEqual([1, 2, 3, 4, 5, 6]);
+        console.log(`  sort_merge result = ${data.value} (expect [1,2,3,4,5,6]) ✓`);
+    }, 15000);
+});
+// ---------------------------------------------------------------------------
+// Entity tag: @s.tag / @s.untag / @s.has_tag (requires execute as TestBot)
+// ---------------------------------------------------------------------------
+describe('MC Integration - entity tag methods (@s.tag/untag/has_tag)', () => {
+    const NS = 'entity_tag_test';
+    const OBJ = '__entity_tag_test';
+    beforeAll(async () => {
+        if (!serverOnline)
+            return;
+        writeFixture(`
+      namespace entity_tag_test
+
+      @load fn __load() {
+        raw("scoreboard objectives add etag_obj dummy");
+      }
+
+      // Must be called with "execute as <player> run function ..."
+      // so @s refers to the player entity.
+      @keep fn test_tag_ops() {
+        // 1. add tag
+        @s.tag("etag_vip")
+
+        // 2. has_tag should return 1
+        let has1: int = @s.has_tag("etag_vip")
+        scoreboard_set("#has_after_tag", "etag_obj", has1)
+
+        // 3. remove tag
+        @s.untag("etag_vip")
+
+        // 4. has_tag should return 0
+        let has2: int = @s.has_tag("etag_vip")
+        scoreboard_set("#has_after_untag", "etag_obj", has2)
+      }
+    `, NS);
+        await mc.reload();
+        await mc.ticks(10);
+        await mc.command(`/function ${NS}:__load`).catch(() => { });
+        await mc.ticks(5);
+    });
+    test('@s.tag adds tag, has_tag returns 1; @s.untag removes tag, has_tag returns 0', async () => {
+        if (!serverOnline)
+            return;
+        // Must run as TestBot so @s is an actual player entity
+        await mc.command(`/execute as TestBot run function ${NS}:test_tag_ops`);
+        await mc.ticks(5);
+        const hasAfterTag = await mc.scoreboard('#has_after_tag', 'etag_obj');
+        const hasAfterUntag = await mc.scoreboard('#has_after_untag', 'etag_obj');
+        expect(hasAfterTag).toBe(1);
+        expect(hasAfterUntag).toBe(0);
+        console.log(`  has_after_tag=${hasAfterTag} (expect 1) ✓`);
+        console.log(`  has_after_untag=${hasAfterUntag} (expect 0) ✓`);
+    }, 20000);
+});
 //# sourceMappingURL=mc-integration.test.js.map