redscript-mc 2.5.0 → 2.6.2

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

@@ -338,10 +338,10 @@ describe('MC Integration Tests', () => {
   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)
+    await mc.ticks(60) // Wait 3s (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}`)
+    console.log(`  counter/ticks after setup+60 ticks: ${count}`)
   })
 
   // ─── Test 3: setblock ────────────────────────────────────────────────
@@ -432,11 +432,11 @@ describe('MC Integration Tests', () => {
     
     // Reset counter
     await mc.command('/scoreboard players set #tick_counter ticks 0')
-    await mc.ticks(40) // 2s
+    await mc.ticks(60) // 3s
     
     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}`)
+    expect(ticks).toBeGreaterThanOrEqual(10) // At least 10 of 60 ticks fired
+    console.log(`  #tick_counter after 60 ticks: ${ticks}`)
   })
 
   // ─── Test 10: fullReset clears blocks ─────────────────────────────────
@@ -906,3 +906,887 @@ 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: string, namespace: string, librarySources: string[]): void {
+  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 = 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: string): Promise<any> {
+  const res = await fetch(`${BOT_URL}${endpoint}`)
+  return res.json()
+}
+
+async function botPost(endpoint: string, body: object = {}): Promise<any> {
+  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: string): Promise<number> {
+  const data = await botGet(`/inventory/count?name=${encodeURIComponent(name)}`)
+  return (data as any).count ?? 0
+}
+
+async function clearBotInventory(): Promise<void> {
+  await mc.command('clear TestBot')
+  await botPost('/wait', { ticks: 5 })
+}
+
+async function getNbt(storage: string, nbtPath: string): Promise<number | null> {
+  const res = await fetch(
+    `http://localhost:25561/nbt?storage=${encodeURIComponent(storage)}&path=${encodeURIComponent(nbtPath)}`
+  )
+  const data: any = 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: any = 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: any = 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() as { value: string }
+    // result should be [1, 2, 3, 4, 5, 6]
+    const nums = data.value.replace(/[\[\]]/g, '').split(',').map((s: string) => 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 || !botOnline) return  // requires TestBot as @s context
+
+    // 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)
+})
+
+// ===========================================================================
+// fft.mcrs — MC integration test for dft_real array param dynamic indexing
+// ===========================================================================
+describe('MC Integration - fft.mcrs dft_real', () => {
+  const NS = 'fft_mc_test'
+
+  beforeAll(async () => {
+    if (!serverOnline) return
+
+    const MATH_SRC = fs.readFileSync(path.join(__dirname, '../stdlib/math.mcrs'), 'utf-8')
+    const FFT_SRC  = fs.readFileSync(path.join(__dirname, '../stdlib/fft.mcrs'),  'utf-8')
+
+    const fftSrc = `
+      namespace fft_mc_test
+
+      @load fn __load() {
+        raw("scoreboard objectives add fft_obj dummy");
+        _math_init()
+      }
+
+      @keep fn test_dft_re0(): int {
+        let input: int[] = [10000, 10000, 10000, 10000]
+        let re: int[] = [0, 0, 0, 0]
+        let im: int[] = [0, 0, 0, 0]
+        dft_real(input, 4, re, im)
+        let v: int = re[0]
+        scoreboard_set("#dft_re0", "fft_obj", v)
+        return v
+      }
+
+      @keep fn test_dft_mag1(): int {
+        let input: int[] = [10000, 0, -10000, 0]
+        let re: int[] = [0, 0, 0, 0]
+        let im: int[] = [0, 0, 0, 0]
+        dft_real(input, 4, re, im)
+        let mag: int = dft_magnitude(re, im, 1)
+        scoreboard_set("#dft_mag1", "fft_obj", mag)
+        return mag
+      }
+    `
+
+    // Use compile directly with librarySources (writeFixture doesn't support libs)
+    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 fftResult = compile(fftSrc, { namespace: NS, librarySources: [MATH_SRC, FFT_SRC] })
+    for (const file of fftResult.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)
+      }
+    }
+
+    await mc.reload()
+    await mc.ticks(10)
+    await mc.command(`/function ${NS}:__load`).catch(() => {})
+    await mc.ticks(5)
+  })
+
+  test('dft_real DC input: re[0] == 40000', async () => {
+    if (!serverOnline) return
+    await mc.command(`/function ${NS}:test_dft_re0`)
+    await mc.ticks(3)
+    const val = await mc.scoreboard('#dft_re0', 'fft_obj')
+    expect(val).toBe(40000)
+  }, 20000)
+
+  test('dft_real quarter-wave: X[1] magnitude ≈ 20000', async () => {
+    if (!serverOnline) return
+    await mc.command(`/function ${NS}:test_dft_mag1`)
+    await mc.ticks(3)
+    const val = await mc.scoreboard('#dft_mag1', 'fft_obj')
+    expect(val).toBeGreaterThanOrEqual(19500)
+    expect(val).toBeLessThanOrEqual(20500)
+  }, 20000)
+})
+
+// ===========================================================================
+// events.mcrs — MC integration test for @on(EventType) event handler system
+// ===========================================================================
+describe('MC Integration - @on(EventType) event system', () => {
+  const NS = 'ev_mc_test'
+  let botOnline = false
+
+  beforeAll(async () => {
+    if (!serverOnline) return
+
+    const EVENTS_SRC = fs.readFileSync(path.join(__dirname, '../stdlib/events.mcrs'), 'utf-8')
+
+    const evSrc = `
+      namespace ev_mc_test
+
+      @on(PlayerJoin) fn on_join(p: Player) {
+        raw("scoreboard objectives add ev_obj dummy");
+        scoreboard_add(p, "ev_obj", 1)
+      }
+
+      @on(PlayerDeath) fn on_death(p: Player) {
+        raw("scoreboard objectives add ev_obj dummy");
+        scoreboard_add(p, "ev_obj", 100)
+      }
+    `
+
+    // Compile with events.mcrs as library source
+    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 evResult = compile(evSrc, { namespace: NS, librarySources: [EVENTS_SRC] })
+    for (const file of evResult.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)
+      }
+    }
+
+    await mc.reload()
+    await mc.ticks(20)
+
+    // Check if TestBot is online
+    const status = await mc.status()
+    botOnline = status.playerNames?.includes('TestBot') ?? false
+  })
+
+  test('events.mcrs dispatcher loads without error', async () => {
+    if (!serverOnline) return
+    // If we got here, reload succeeded
+    expect(serverOnline).toBe(true)
+  }, 10000)
+
+  test('PlayerJoin: removing rs.joined tag fires @on(PlayerJoin) handlers', async () => {
+    if (!serverOnline || !botOnline) return
+
+    // Reset score
+    await mc.command(`scoreboard objectives add ev_obj dummy`).catch(() => {})
+    await mc.command(`scoreboard players set TestBot ev_obj 0`)
+
+    // Simulate "join" by removing the rs.joined tag
+    await mc.command(`tag TestBot remove rs.joined`)
+    await mc.ticks(3)  // wait for @tick to fire
+
+    const score = await mc.scoreboard('TestBot', 'ev_obj')
+    expect(score).toBeGreaterThanOrEqual(1)
+    console.log(`  PlayerJoin handler fired: ev_obj = ${score} (expect >= 1) ✓`)
+  }, 20000)
+
+  test('PlayerDeath: killing TestBot fires @on(PlayerDeath) handlers', async () => {
+    if (!serverOnline || !botOnline) return
+
+    await mc.command(`scoreboard players set TestBot ev_obj 0`)
+    await mc.command(`kill TestBot`)
+    await mc.ticks(5)
+
+    const score = await mc.scoreboard('TestBot', 'ev_obj')
+    expect(score).toBeGreaterThanOrEqual(100)
+    console.log(`  PlayerDeath handler fired: ev_obj = ${score} (expect >= 100) ✓`)
+  }, 20000)
+})