redscript-mc 2.4.1 → 2.6.0

package/src/__tests__/fixed.test.ts

@@ -0,0 +1,159 @@
+/**
+ * Tests for fixed (×10000 fixed-point) support in the RedScript compiler.
+ *
+ * RedScript fixed-point values are stored as ×10000 integers on MC scoreboards.
+ * 1.5 → 15000, 3.14 → 31400, etc.
+ */
+
+import { compile } from '../emit/compile'
+
+function getAllMcContent(files: { path: string; content: string }[]): string {
+  return files.filter(f => f.path.endsWith('.mcfunction')).map(f => f.content).join('\n')
+}
+
+describe('fixed literals (×10000 fixed-point)', () => {
+  test('1.5 literal compiles to scoreboard value 15000', () => {
+    const source = `fn t(): fixed { return 1.5; }`
+    const result = compile(source, { namespace: 'fixedtest' })
+    const all = getAllMcContent(result.files)
+    expect(all).toContain('15000')
+  })
+
+  test('3.14 literal compiles to scoreboard value 31400', () => {
+    const source = `fn t(): fixed { return 3.14; }`
+    const result = compile(source, { namespace: 'fixedtest' })
+    const all = getAllMcContent(result.files)
+    expect(all).toContain('31400')
+  })
+
+  test('2.0 literal compiles to 20000', () => {
+    const source = `fn t(): fixed { return 2.0; }`
+    const result = compile(source, { namespace: 'fixedtest' })
+    const all = getAllMcContent(result.files)
+    expect(all).toContain('20000')
+  })
+
+  test('0.5 literal compiles to 5000', () => {
+    const source = `fn t(): fixed { return 0.5; }`
+    const result = compile(source, { namespace: 'fixedtest' })
+    const all = getAllMcContent(result.files)
+    expect(all).toContain('5000')
+  })
+})
+
+describe('fixed addition', () => {
+  test('1.5 + 2.5 = 4.0 → result 40000 in output', () => {
+    // 15000 + 25000 = 40000 — addition needs no scale correction
+    const source = `
+      fn t(): fixed {
+        let a: fixed = 1.5;
+        let b: fixed = 2.5;
+        return a + b;
+      }
+    `
+    const result = compile(source, { namespace: 'fixedtest' })
+    const all = getAllMcContent(result.files)
+    // Constant folder folds 15000+25000=40000 — result must appear
+    expect(all).toContain('40000')
+  })
+
+  test('2.0 + 3.0 = 5.0 → result 50000', () => {
+    const source = `
+      fn t(): fixed {
+        let a: fixed = 2.0;
+        let b: fixed = 3.0;
+        return a + b;
+      }
+    `
+    const result = compile(source, { namespace: 'fixedtest' })
+    const all = getAllMcContent(result.files)
+    expect(all).toContain('50000')
+  })
+})
+
+describe('fixed multiplication (scale correction ÷10000)', () => {
+  test('2.0 * 3.0 = 6.0 → result 60000 (not 600000000)', () => {
+    // Without correction: 20000 * 30000 = 600000000 (wrong)
+    // With correction: 20000 * 30000 / 10000 = 60000 ✓
+    const source = `
+      fn t(): fixed {
+        let a: fixed = 2.0;
+        let b: fixed = 3.0;
+        return a * b;
+      }
+    `
+    const result = compile(source, { namespace: 'fixedtest' })
+    const all = getAllMcContent(result.files)
+    expect(all).toContain('60000')
+    // Must NOT contain the uncorrected result
+    expect(all).not.toContain('600000000')
+  })
+
+  test('1.5 * 2.0 = 3.0 → result 30000 (not 300000000)', () => {
+    // Without correction: 15000 * 20000 = 300000000 (wrong)
+    // With correction: 15000 * 20000 / 10000 = 30000 ✓
+    const source = `
+      fn t(): fixed {
+        let a: fixed = 1.5;
+        let b: fixed = 2.0;
+        return a * b;
+      }
+    `
+    const result = compile(source, { namespace: 'fixedtest' })
+    const all = getAllMcContent(result.files)
+    expect(all).toContain('30000')
+    expect(all).not.toContain('300000000')
+  })
+})
+
+describe('fixed division (scale correction ×10000)', () => {
+  test('6.0 / 2.0 = 3.0 → result 30000 (not 3)', () => {
+    // Without correction: 60000 / 20000 = 3 (wrong)
+    // With correction: 60000 * 10000 / 20000 = 30000 ✓
+    const source = `
+      fn t(): fixed {
+        let a: fixed = 6.0;
+        let b: fixed = 2.0;
+        return a / b;
+      }
+    `
+    const result = compile(source, { namespace: 'fixedtest' })
+    const all = getAllMcContent(result.files)
+    expect(all).toContain('30000')
+    // The uncorrected result would be 3 (without the trailing 0000)
+    expect(all).toMatch(/30000/)
+  })
+
+  test('10.0 / 4.0 = 2.5 → result 25000 (not 2)', () => {
+    // Without correction: 100000 / 40000 = 2 (wrong, loses precision)
+    // With correction: 100000 * 10000 / 40000 = 25000 ✓
+    const source = `
+      fn t(): fixed {
+        let a: fixed = 10.0;
+        let b: fixed = 4.0;
+        return a / b;
+      }
+    `
+    const result = compile(source, { namespace: 'fixedtest' })
+    const all = getAllMcContent(result.files)
+    expect(all).toContain('25000')
+  })
+})
+
+describe("'float' keyword deprecation", () => {
+  test("using 'float' as type emits a deprecation warning", () => {
+    const source = `fn t(): float { return 1.5; }`
+    const result = compile(source, { namespace: 'fixedtest' })
+    expect(result.warnings.some(w => w.includes('[DeprecatedType]'))).toBe(true)
+    expect(result.warnings.some(w => w.includes("'float' is deprecated"))).toBe(true)
+    expect(result.warnings.some(w => w.includes("use 'fixed' instead"))).toBe(true)
+  })
+
+  test("'float' still compiles correctly (acts as 'fixed')", () => {
+    const source = `fn t(): float { return 1.5; }`
+    const result = compile(source, { namespace: 'fixedtest' })
+    const all = getAllMcContent(result.files)
+    // 1.5 × 10000 = 15000
+    expect(all).toContain('15000')
+  })
+})

package/src/__tests__/fixtures/coroutine-mc-test.mcrs

@@ -0,0 +1,58 @@
+namespace coro_mc_test
+
+// ── Test 1: basic sum ──────────────────────────────────────────────────────
+// batch=10, 100 iterations → needs 10 ticks minimum
+// sum(0..99) = 4950
+//
+// Variables stored in __coro_mc_test objective (auto-created by load fn):
+//   player $coro_sum_acc   — running accumulator
+//   player $coro_done_count — how many times onDone fired
+
+@coroutine(batch=10, onDone="on_sum_done")
+fn coro_sum_100() {
+  let i: int = 0
+  while (i < 100) {
+    let cur: int = scoreboard_get("$coro_sum_acc", "__coro_mc_test")
+    scoreboard_set("$coro_sum_acc", "__coro_mc_test", cur + i)
+    i = i + 1
+  }
+}
+
+fn on_sum_done() {
+  let done: int = scoreboard_get("$coro_done_count", "__coro_mc_test")
+  scoreboard_set("$coro_done_count", "__coro_mc_test", done + 1)
+}
+
+fn trigger_coro_sum() {
+  scoreboard_set("$coro_sum_acc", "__coro_mc_test", 0)
+  scoreboard_set("$coro_done_count", "__coro_mc_test", 0)
+  coro_sum_100()
+}
+
+// ── Test 2: partial result check ──────────────────────────────────────────
+// batch=5, sum 0..49 = 1225 (50 iters / batch=5 = 10 ticks)
+// After 3 ticks only 15 iters done — onDone not yet fired
+//
+// Variables:
+//   player $partial_acc  — running accumulator
+//   player $partial_done — 1 when onDone fires
+
+@coroutine(batch=5, onDone="on_partial_done")
+fn coro_partial() {
+  let i: int = 0
+  while (i < 50) {
+    let cur: int = scoreboard_get("$partial_acc", "__coro_mc_test")
+    scoreboard_set("$partial_acc", "__coro_mc_test", cur + i)
+    i = i + 1
+  }
+}
+
+fn on_partial_done() {
+  scoreboard_set("$partial_done", "__coro_mc_test", 1)
+}
+
+fn trigger_partial() {
+  scoreboard_set("$partial_acc", "__coro_mc_test", 0)
+  scoreboard_set("$partial_done", "__coro_mc_test", 0)
+  coro_partial()
+}

package/src/__tests__/fixtures/for-range.mcrs

@@ -0,0 +1,15 @@
+namespace for_range_test
+fn sum_range(): int {
+  let total: int = 0
+  for i in 0..10 {
+    total = total + i
+  }
+  return total
+}
+fn sum_inclusive(): int {
+  let total: int = 0
+  for i in 1..=5 {
+    total = total + i
+  }
+  return total
+}

package/src/__tests__/fixtures/heap-sort-mc-test.mcrs

@@ -0,0 +1,87 @@
+// heap-sort-mc-test.mcrs — MC integration tests for heap and sort stdlib
+// heap.mcrs and sort.mcrs are injected as librarySources by writeFixtureWithLibs
+namespace heap_sort_mc_test
+
+@load fn load_fn() {
+  raw("scoreboard objectives add hsmc dummy")
+}
+
+// ── Test 1: MinHeap push/pop order ───────────────────────────────────────────
+// push 5,1,3,2,4 → pop order must be 1,2,3,4,5
+@keep fn test_min_heap() {
+  let h: int[] = heap_new()
+  h = heap_push(h, 5)
+  h = heap_push(h, 1)
+  h = heap_push(h, 3)
+  h = heap_push(h, 2)
+  h = heap_push(h, 4)
+
+  let v1: int = heap_peek(h)
+  h = heap_pop(h)
+  let v2: int = heap_peek(h)
+  h = heap_pop(h)
+  let v3: int = heap_peek(h)
+
+  // v1=1, v2=2, v3=3 → encode as 100*v1 + 10*v2 + v3
+  let encoded: int = v1 * 100 + v2 * 10 + v3
+  scoreboard_set("#heap_min_top3", "hsmc", encoded)
+
+  let final_size: int = heap_size(h)
+  scoreboard_set("#heap_size_after_pop3", "hsmc", final_size)
+}
+
+// ── Test 2: MaxHeap push/pop order ───────────────────────────────────────────
+// push 3,1,4,1,5 → first pop = 5
+@keep fn test_max_heap() {
+  let h: int[] = heap_new()
+  h = max_heap_push(h, 3)
+  h = max_heap_push(h, 1)
+  h = max_heap_push(h, 4)
+  h = max_heap_push(h, 1)
+  h = max_heap_push(h, 5)
+
+  let top: int = heap_peek(h)
+  scoreboard_set("#max_heap_top", "hsmc", top)
+
+  h = max_heap_pop(h)
+  let second: int = heap_peek(h)
+  scoreboard_set("#max_heap_second", "hsmc", second)
+}
+
+// ── Test 3: insertion_sort ascending ─────────────────────────────────────────
+@keep fn test_sort_asc() {
+  let arr: int[] = [30, 10, 50, 20, 40]
+  insertion_sort(arr, 5)
+  // expect [10, 20, 30, 40, 50]
+  let ok: int = 1
+  if (arr[0] != 10) { ok = 0 }
+  if (arr[1] != 20) { ok = 0 }
+  if (arr[2] != 30) { ok = 0 }
+  if (arr[3] != 40) { ok = 0 }
+  if (arr[4] != 50) { ok = 0 }
+  scoreboard_set("#sort_asc_ok", "hsmc", ok)
+  scoreboard_set("#sort_asc_first", "hsmc", arr[0])
+  scoreboard_set("#sort_asc_last", "hsmc", arr[4])
+}
+
+// ── Test 4: insertion_sort descending ────────────────────────────────────────
+@keep fn test_sort_desc() {
+  let arr: int[] = [30, 10, 50, 20, 40]
+  insertion_sort_desc(arr, 5)
+  // expect [50, 40, 30, 20, 10]
+  let ok: int = 1
+  if (arr[0] != 50) { ok = 0 }
+  if (arr[4] != 10) { ok = 0 }
+  scoreboard_set("#sort_desc_ok", "hsmc", ok)
+}
+
+// ── Test 5: sort_merge ────────────────────────────────────────────────────────
+// sort_merge is verified via the NBT /nbt endpoint: result = [1,2,3,4,5,6]
+// We trigger the merge and check via TestHarness /nbt rather than scoreboard.
+@keep fn test_sort_merge() {
+  let a: int[] = [1, 3, 5]
+  let b: int[] = [2, 4, 6]
+  let merged: int[] = sort_merge(a, 3, b, 3)
+  // Signal that function ran (merged array is in heap_sort_mc_test:arrays result)
+  scoreboard_set("#sort_merge_ran", "hsmc", 1)
+}

package/src/__tests__/fixtures/impl-test.mcrs

@@ -1,46 +1,15 @@
-struct timer {
-    _id: int,
-    _duration: int
+namespace impl_test
+struct Counter {
+  value: int
 }
-
-impl timer {
-    fn new(duration: int) -> timer {
-        scoreboard_set("timer_ticks", #rs, 0);
-        scoreboard_set("timer_active", #rs, 0);
-        return { _id: 0, _duration: duration };
-    }
-
-    fn start(self) {
-        scoreboard_set("timer_active", #rs, 1);
-    }
-
-    fn tick(self) {
-        let active: int = scoreboard_get("timer_active", #rs);
-        let ticks: int = scoreboard_get("timer_ticks", #rs);
-
-        if (active == 1) {
-            if (ticks < self._duration) {
-                scoreboard_set("timer_ticks", #rs, ticks + 1);
-            }
-        }
-    }
-
-    fn done(self) -> bool {
-        let ticks: int = scoreboard_get("timer_ticks", #rs);
-        return ticks >= 3;
-    }
-}
-
-fn test() {
-    let timer_value: timer = timer::new(3);
-    timer_value.start();
-    timer_value.tick();
-    timer_value.tick();
-    timer_value.tick();
-    let finished: bool = timer_value.done();
-    if (finished) {
-        scoreboard_set("#impl", #done, 1);
-        return;
-    }
-    scoreboard_set("#impl", #done, 1);
+impl Counter {
+  fn increment(self): Counter {
+    return Counter { value: self.value + 1 }
+  }
+  fn add(self, n: int): Counter {
+    return Counter { value: self.value + n }
+  }
+  fn get(self): int {
+    return self.value
+  }
 }

package/src/__tests__/fixtures/stdlib-extra-test.mcrs

@@ -0,0 +1,226 @@
+// stdlib-extra-test.mcrs — MC integration tests for random, bits, list_sort, bigint, math_hp
+
+@load fn __load() {
+    raw("scoreboard objectives add rsex dummy");
+    raw("scoreboard objectives add rshp dummy");
+}
+
+// ─── random.mcrs ─────────────────────────────────────────────────────────────
+
+@keep fn test_random() {
+    // LCG: next_lcg(12345) should produce deterministic result
+    scoreboard_set("#lcg_12345", "rsex", next_lcg(12345));
+
+    // Two consecutive calls should differ
+    let s1: int = next_lcg(99999);
+    let s2: int = next_lcg(s1);
+    // s1 != s2 → set 1 if different
+    let diff: int = s1 - s2;
+    if (diff < 0) { diff = 0 - diff; }
+    if (diff > 0) {
+        scoreboard_set("#lcg_different", "rsex", 1);
+    }
+
+    // random_range should stay in [0, 10)
+    let seed: int = next_lcg(42);
+    let r: int = random_range(seed, 0, 10);
+    if (r >= 0) {
+        if (r < 10) {
+            scoreboard_set("#rand_in_range", "rsex", 1);
+        }
+    }
+
+    // random_bool returns 0 or 1
+    let b: int = random_bool(seed);
+    if (b >= 0) {
+        if (b <= 1) {
+            scoreboard_set("#rand_bool_valid", "rsex", 1);
+        }
+    }
+}
+
+// ─── bits.mcrs ───────────────────────────────────────────────────────────────
+
+@keep fn test_bits() {
+    // bit_get(5, 0) = 1  (5 = 101 binary, bit 0 = 1)
+    scoreboard_set("#bit_get_5_0", "rsex", bit_get(5, 0));
+
+    // bit_get(5, 1) = 0  (bit 1 = 0)
+    scoreboard_set("#bit_get_5_1", "rsex", bit_get(5, 1));
+
+    // bit_get(5, 2) = 1  (bit 2 = 1)
+    scoreboard_set("#bit_get_5_2", "rsex", bit_get(5, 2));
+
+    // bit_shl(1, 3) = 8  (1 << 3)
+    scoreboard_set("#bit_shl_1_3", "rsex", bit_shl(1, 3));
+
+    // bit_shr(8, 2) = 2  (8 >> 2)
+    scoreboard_set("#bit_shr_8_2", "rsex", bit_shr(8, 2));
+
+    // popcount(7) = 3  (7 = 111, 3 bits set)
+    scoreboard_set("#popcount_7", "rsex", popcount(7));
+
+    // popcount(0) = 0
+    scoreboard_set("#popcount_0", "rsex", popcount(0));
+}
+
+// ─── list.mcrs (sort) ────────────────────────────────────────────────────────
+
+@keep fn test_list_sort() {
+    // sort3(30, 10, 20) → min=10, mid=20, max=30
+    scoreboard_set("#sort3_min", "rsex", sort3(30, 10, 20, 0));
+    scoreboard_set("#sort3_mid", "rsex", sort3(30, 10, 20, 1));
+    scoreboard_set("#sort3_max", "rsex", sort3(30, 10, 20, 2));
+
+    // sort4(40, 10, 30, 20) → sorted: 10, 20, 30, 40
+    scoreboard_set("#sort4_min", "rsex", sort4(40, 10, 30, 20, 0));
+    scoreboard_set("#sort4_max", "rsex", sort4(40, 10, 30, 20, 3));
+
+    // list_min3(5, 3, 8) = 3
+    scoreboard_set("#list_min3", "rsex", list_min3(5, 3, 8));
+
+    // list_max3(5, 3, 8) = 8
+    scoreboard_set("#list_max3", "rsex", list_max3(5, 3, 8));
+
+    // avg3(10, 20, 30) = 20
+    scoreboard_set("#avg3", "rsex", avg3(10, 20, 30));
+}
+
+// ─── bigint.mcrs ─────────────────────────────────────────────────────────────
+
+@keep fn test_bigint() {
+    // bigint3_add: chunks [9999, 9999] + [0, 1] = carry=1, result=[0, 0]
+    scoreboard_set("#bi3_add_lo", "rsex",    bigint3_add_lo(9999, 1));     // (9999+1) % 10000 = 0
+    scoreboard_set("#bi3_carry_lo", "rsex",  bigint3_carry_lo(9999, 1));   // (9999+1) / 10000 = 1
+    scoreboard_set("#bi3_add_mid", "rsex",   bigint3_add_mid(9999, 0, 1)); // (9999+0+1) % 10000 = 0
+    scoreboard_set("#bi3_carry_mid", "rsex", bigint3_carry_mid(9999, 0, 1)); // (9999+0+1) / 10000 = 1
+
+    // bigint3_cmp: [1,0,0] vs [0,9999,9999] → 1 (greater)
+    scoreboard_set("#bi3_cmp_gt", "rsex", bigint3_cmp(1, 0, 0, 0, 9999, 9999));
+
+    // bigint3_cmp: [0,9999,9999] vs [1,0,0] → -1 (less)
+    scoreboard_set("#bi3_cmp_lt", "rsex", bigint3_cmp(0, 9999, 9999, 1, 0, 0));
+
+    // int32_to_bigint3 decomposition: 1023456789
+    // = 1*100000000 + 234*10000 + 5678... wait let me calc:
+    // 1023456789 / 100000000 = 10 (hi) → but int32 max is 2.1B so 10_2345_6789
+    // hi = 10, mid = 2345, lo = 6789
+    scoreboard_set("#bi3_hi", "rsex",  int32_to_bigint3_hi(1023456789));   // 10
+    scoreboard_set("#bi3_mid", "rsex", int32_to_bigint3_mid(1023456789));  // 2345
+    scoreboard_set("#bi3_lo", "rsex",  int32_to_bigint3_lo(1023456789));   // 6789
+}
+
+// ─── math_hp.mcrs: ln_hp ─────────────────────────────────────────────────────
+
+@keep fn test_ln_hp() {
+    // ln_hp(10000) == 0  (ln(1) = 0, input ×10000 so 10000 = 1.0)
+    scoreboard_set("#ln_1", "rshp", ln_hp(10000));
+
+    // ln_hp(27183) ≈ 10000  (ln(e) ≈ 1.0, e≈2.71828 → 27183 in ×10000)
+    scoreboard_set("#ln_e", "rshp", ln_hp(27183));
+
+    // ln_hp(20000) ≈ 6931  (ln(2) ≈ 0.6931, 2.0 = 20000)
+    scoreboard_set("#ln_2", "rshp", ln_hp(20000));
+
+    // ln_hp(100000) ≈ 23026  (ln(10) ≈ 2.3026, 10.0 = 100000)
+    scoreboard_set("#ln_10", "rshp", ln_hp(100000));
+}
+
+// ─── math_hp.mcrs: double_mul_fixed ──────────────────────────────────────────
+
+@keep fn test_double_mul_fixed() {
+    // double_mul_fixed(2.0d, 15000) ≈ 3.0  (2.0 × 1.5 = 3.0)
+    // After call, __dp0 holds d×(f/10000); read it back as ×10000 fixed directly.
+    let d: double = 2.0d;
+    let f: int = scoreboard_get("#dmul_f_in", "rshp");
+    double_mul_fixed(d, f);
+    // Read __dp0 directly to avoid 'as fixed' temp var rename bug
+    raw("execute store result score #dmul_result rshp run data get storage rs:d __dp0 10000.0");
+}
+
+// ─── list.mcrs: dynamic aggregates ──────────────────────────────────────────
+
+@keep fn test_list_aggregates() {
+    let arr: int[] = [10, 30, 20, 50, 40];
+    let len: int = 5;
+
+    // list_sum([10,30,20,50,40]) = 150
+    scoreboard_set("#list_sum", "rsex", list_sum(arr, len));
+
+    // list_avg([10,30,20,50,40]) = 30 * 10000 = 300000 (×10000 fixed)
+    scoreboard_set("#list_avg", "rsex", list_avg(arr, len));
+
+    // list_min([10,30,20,50,40]) = 10
+    scoreboard_set("#list_min", "rsex", list_min(arr, len));
+
+    // list_max([10,30,20,50,40]) = 50
+    scoreboard_set("#list_max", "rsex", list_max(arr, len));
+
+    // list_contains: 20 is in array → 1
+    scoreboard_set("#list_contains_1", "rsex", list_contains(arr, len, 20));
+
+    // list_contains: 99 is NOT in array → 0
+    scoreboard_set("#list_contains_0", "rsex", list_contains(arr, len, 99));
+
+    // list_index_of: 20 is at index 2
+    scoreboard_set("#list_idx_20", "rsex", list_index_of(arr, len, 20));
+
+    // list_index_of: 99 not found → -1
+    scoreboard_set("#list_idx_miss", "rsex", list_index_of(arr, len, 99));
+}
+
+@keep fn test_list_dedup() {
+    // [1, 2, 1, 3, 2] has 3 unique values
+    let arr: int[] = [1, 2, 1, 3, 2];
+    scoreboard_set("#list_dedup", "rsex", list_dedup_count(arr, 5));
+}
+
+// ─── random.mcrs: statistical distributions ──────────────────────────────────
+
+@keep fn test_binomial() {
+    // binomial_sample(10, 10000, 42): p=1.0 → all 10 should succeed
+    scoreboard_set("#binom_p1", "rsex", binomial_sample(10, 10000, 42));
+
+    // binomial_sample(10, 0, 42): p=0.0 → 0 successes
+    scoreboard_set("#binom_p0", "rsex", binomial_sample(10, 0, 42));
+
+    // binomial_sample with p=5000 (50%): result in [0, 10]
+    let b: int = binomial_sample(10, 5000, 12345);
+    if (b >= 0) {
+        if (b <= 10) {
+            scoreboard_set("#binom_valid", "rsex", 1);
+        }
+    }
+}
+
+@keep fn test_hypergeometric() {
+    // Pop=10, success=10, draws=3 → always 3 successes
+    scoreboard_set("#hyper_all", "rsex", hypergeometric_sample(10, 10, 3, 99));
+
+    // Pop=10, success=0, draws=3 → always 0 successes
+    scoreboard_set("#hyper_none", "rsex", hypergeometric_sample(10, 0, 3, 99));
+
+    // Pop=10, success=5, draws=4: result in [0, 4]
+    let h: int = hypergeometric_sample(10, 5, 4, 42);
+    if (h >= 0) {
+        if (h <= 4) {
+            scoreboard_set("#hyper_valid", "rsex", 1);
+        }
+    }
+}
+
+// ─── color.mcrs: rgb_to_hex ──────────────────────────────────────────────────
+
+@keep fn test_rgb_to_hex() {
+    // rgb_to_hex(255, 0, 0) = 0xFF0000 = 16711680
+    scoreboard_set("#hex_red", "rsex", rgb_to_hex(255, 0, 0));
+
+    // rgb_to_hex(0, 255, 0) = 0x00FF00 = 65280
+    scoreboard_set("#hex_green", "rsex", rgb_to_hex(0, 255, 0));
+
+    // rgb_to_hex(0, 0, 255) = 0x0000FF = 255
+    scoreboard_set("#hex_blue", "rsex", rgb_to_hex(0, 0, 255));
+
+    // rgb_to_hex(255, 255, 255) = 0xFFFFFF = 16777215
+    scoreboard_set("#hex_white", "rsex", rgb_to_hex(255, 255, 255));
+}

package/src/__tests__/fixtures/stdlib-math-integration.mcrs

@@ -0,0 +1,28 @@
+// stdlib math integration test
+// Uses librarySources so no import needed
+
+@load fn __load() {
+    scoreboard_add("rs");
+}
+
+@keep fn test_math_basic() {
+    scoreboard_set("#factorial_5", "rs", factorial(5));
+    scoreboard_set("#combinations_5_2", "rs", combinations(5, 2));
+    scoreboard_set("#gcd_12_8", "rs", gcd(12, 8));
+    scoreboard_set("#isqrt_144", "rs", isqrt(144));
+    scoreboard_set("#log2_1024", "rs", log2_int(1024));
+    scoreboard_set("#pow_2_10", "rs", pow_int(2, 10));
+    scoreboard_set("#abs_neg42", "rs", abs(-42));
+    scoreboard_set("#clamp_hi", "rs", clamp(15, 0, 10));
+}
+
+@keep fn test_math_sqrt() {
+    scoreboard_set("#sqrt_fx_40000", "rs", sqrt_fx(40000));
+    scoreboard_set("#cbrt_27", "rs", cbrt_fx(27));
+    scoreboard_set("#cbrt_1000", "rs", cbrt_fx(1000));
+}
+
+@keep fn test_math_approx() {
+    scoreboard_set("#apeq_yes", "rs", approx_eq(100, 103, 5));
+    scoreboard_set("#apeq_no", "rs", approx_eq(100, 110, 5));
+}