redscript-mc 2.5.0 → 2.6.2

package/src/__tests__/e2e/stdlib-e2e.test.ts

@@ -28,6 +28,10 @@ const VEC_SRC = fs.readFileSync(
   path.join(__dirname, '../../stdlib/vec.mcrs'),
   'utf-8',
 )
+const ODE_SRC = fs.readFileSync(
+  path.join(__dirname, '../../stdlib/ode.mcrs'),
+  'utf-8',
+)
 
 /** Compile source with math stdlib, load into MCRuntime, init objective */
 function makeRuntime(source: string, libs: string[] = [MATH_SRC]): MCRuntime {
@@ -346,3 +350,1951 @@ describe('stdlib e2e: vec3d length & distance', () => {
     expect(val).toBeLessThanOrEqual(1733)
   })
 })
+
+// ===========================================================================
+// Additional stdlib: load sources
+// ===========================================================================
+
+const RANDOM_SRC = fs.readFileSync(
+  path.join(__dirname, '../../stdlib/random.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 EASING_SRC = fs.readFileSync(
+  path.join(__dirname, '../../stdlib/easing.mcrs'),
+  'utf-8',
+)
+const NOISE_SRC = fs.readFileSync(
+  path.join(__dirname, '../../stdlib/noise.mcrs'),
+  'utf-8',
+)
+const SIGNAL_SRC = fs.readFileSync(
+  path.join(__dirname, '../../stdlib/signal.mcrs'),
+  'utf-8',
+)
+const ADVANCED_SRC = fs.readFileSync(
+  path.join(__dirname, '../../stdlib/advanced.mcrs'),
+  'utf-8',
+)
+const VEC_SRC_FULL = fs.readFileSync(
+  path.join(__dirname, '../../stdlib/vec.mcrs'),
+  'utf-8',
+)
+const PARABOLA_SRC = fs.readFileSync(
+  path.join(__dirname, '../../stdlib/parabola.mcrs'),
+  'utf-8',
+)
+const QUAT_SRC = fs.readFileSync(
+  path.join(__dirname, '../../stdlib/quaternion.mcrs'),
+  'utf-8',
+)
+const MATH_HP_SRC = fs.readFileSync(
+  path.join(__dirname, '../../stdlib/math_hp.mcrs'),
+  'utf-8',
+)
+const EXPR_SRC = fs.readFileSync(
+  path.join(__dirname, '../../stdlib/expr.mcrs'),
+  'utf-8',
+)
+const GEOM_SRC = fs.readFileSync(
+  path.join(__dirname, '../../stdlib/geometry.mcrs'),
+  'utf-8',
+)
+const COLOR_SRC = fs.readFileSync(
+  path.join(__dirname, '../../stdlib/color.mcrs'),
+  'utf-8',
+)
+const WORLD_SRC = fs.readFileSync(
+  path.join(__dirname, '../../stdlib/world.mcrs'),
+  'utf-8',
+)
+
+// ===========================================================================
+// math.mcrs — runtime execution (extended)
+// ===========================================================================
+
+describe('math.mcrs — runtime execution', () => {
+  const rt = makeRuntime(`
+    fn test_abs_neg42(): int { return abs(-42); }
+    fn test_min_3_7(): int { return min(3, 7); }
+    fn test_max_3_7(): int { return max(3, 7); }
+    fn test_clamp_15(): int { return clamp(15, 0, 10); }
+    fn test_clamp_neg5(): int { return clamp(-5, 0, 10); }
+    fn test_isqrt_144(): int { return isqrt(144); }
+    fn test_isqrt_2(): int { return isqrt(2); }
+    fn test_gcd_12_8(): int { return gcd(12, 8); }
+    fn test_lcm_4_6(): int { return lcm(4, 6); }
+    fn test_pow_2_10(): int { return pow_int(2, 10); }
+    fn test_comb_5_2(): int { return combinations(5, 2); }
+    fn test_comb_10_3(): int { return combinations(10, 3); }
+    fn test_factorial_5(): int { return factorial(5); }
+    fn test_log2_8(): int { return log2_int(8); }
+    fn test_log2_1024(): int { return log2_int(1024); }
+    fn test_sqrt_fx_40000(): int { return sqrt_fx(40000); }
+    fn test_cbrt_fx_27(): int { return cbrt_fx(27); }
+    fn test_cbrt_fx_1000(): int { return cbrt_fx(1000); }
+    fn test_approx_eq_1(): int { return approx_eq(100, 103, 5); }
+    fn test_approx_eq_0(): int { return approx_eq(100, 110, 5); }
+  `)
+
+  test('abs(-42) == 42', () => expect(callAndGetRet(rt, 'test_abs_neg42')).toBe(42))
+  test('min(3,7) == 3', () => expect(callAndGetRet(rt, 'test_min_3_7')).toBe(3))
+  test('max(3,7) == 7', () => expect(callAndGetRet(rt, 'test_max_3_7')).toBe(7))
+  test('clamp(15,0,10) == 10', () => expect(callAndGetRet(rt, 'test_clamp_15')).toBe(10))
+  test('clamp(-5,0,10) == 0', () => expect(callAndGetRet(rt, 'test_clamp_neg5')).toBe(0))
+  test('isqrt(144) == 12', () => expect(callAndGetRet(rt, 'test_isqrt_144')).toBe(12))
+  test('isqrt(2) == 1', () => expect(callAndGetRet(rt, 'test_isqrt_2')).toBe(1))
+  test('gcd(12,8) == 4', () => expect(callAndGetRet(rt, 'test_gcd_12_8')).toBe(4))
+  test('lcm(4,6) == 12', () => expect(callAndGetRet(rt, 'test_lcm_4_6')).toBe(12))
+  test('pow_int(2,10) == 1024', () => expect(callAndGetRet(rt, 'test_pow_2_10')).toBe(1024))
+  test('combinations(5,2) == 10', () => expect(callAndGetRet(rt, 'test_comb_5_2')).toBe(10))
+  test('combinations(10,3) == 120', () => expect(callAndGetRet(rt, 'test_comb_10_3')).toBe(120))
+  test('factorial(5) == 120', () => expect(callAndGetRet(rt, 'test_factorial_5')).toBe(120))
+  test('log2_int(8) == 3', () => expect(callAndGetRet(rt, 'test_log2_8')).toBe(3))
+  test('log2_int(1024) == 10', () => expect(callAndGetRet(rt, 'test_log2_1024')).toBe(10))
+  test('sqrt_fx(40000) == 20000 (√4.0 × 10000 scale, fixed)', () => {
+    // sqrt_fx(40000) = √(40000/10000) × 10000 = √4 × 10000 = 20000
+    // Implementation: isqrt(40000) * 100 = 200 * 100 = 20000
+    const val = callAndGetRet(rt, 'test_sqrt_fx_40000')
+    expect(val).toBe(20000)
+  })
+  test('cbrt_fx(27) == 3', () => expect(callAndGetRet(rt, 'test_cbrt_fx_27')).toBe(3))
+  test('cbrt_fx(1000) == 10', () => expect(callAndGetRet(rt, 'test_cbrt_fx_1000')).toBe(10))
+  test('approx_eq(100, 103, 5) == 1', () => expect(callAndGetRet(rt, 'test_approx_eq_1')).toBe(1))
+  test('approx_eq(100, 110, 5) == 0', () => expect(callAndGetRet(rt, 'test_approx_eq_0')).toBe(0))
+})
+
+// ===========================================================================
+// random.mcrs — runtime
+// ===========================================================================
+
+describe('random.mcrs — runtime', () => {
+  const rt = makeRuntime(`
+    fn test_lcg_a(): int { return next_lcg(12345); }
+    fn test_lcg_b(): int { return next_lcg(next_lcg(12345)); }
+    fn test_rrange(): int { return random_range(next_lcg(99999), 0, 100); }
+    fn test_rbool(): int { return random_bool(next_lcg(42)); }
+  `, [MATH_SRC, RANDOM_SRC])
+
+  test('next_lcg produces different values each call', () => {
+    const a = callAndGetRet(rt, 'test_lcg_a')
+    const b = callAndGetRet(rt, 'test_lcg_b')
+    expect(a).not.toBe(b)
+  })
+  test('random_range stays in bounds [0,100)', () => {
+    const val = callAndGetRet(rt, 'test_rrange')
+    expect(val).toBeGreaterThanOrEqual(0)
+    expect(val).toBeLessThan(100)
+  })
+  test('random_bool returns 0 or 1', () => {
+    const val = callAndGetRet(rt, 'test_rbool')
+    expect([0, 1]).toContain(val)
+  })
+})
+
+// ===========================================================================
+// list.mcrs — runtime
+// ===========================================================================
+
+describe('list.mcrs — runtime', () => {
+  const rt = makeRuntime(`
+    fn test_sort3_min(): int { return sort3(30, 10, 20, 0); }
+    fn test_sort3_max(): int { return sort3(30, 10, 20, 2); }
+    fn test_sort4_min(): int { return sort4(40, 10, 30, 20, 0); }
+    fn test_list_min3(): int { return list_min3(5, 3, 8); }
+    fn test_list_max3(): int { return list_max3(5, 3, 8); }
+    fn test_avg3(): int { return avg3(10, 20, 30); }
+    fn test_weighted2(): int { return weighted2(12345, 1, 1); }
+  `, [MATH_SRC, LIST_SRC])
+
+  test('sort3(30,10,20, 0) == 10 (min)', () => expect(callAndGetRet(rt, 'test_sort3_min')).toBe(10))
+  test('sort3(30,10,20, 2) == 30 (max)', () => expect(callAndGetRet(rt, 'test_sort3_max')).toBe(30))
+  test('sort4(40,10,30,20, 0) == 10', () => expect(callAndGetRet(rt, 'test_sort4_min')).toBe(10))
+  test('list_min3(5,3,8) == 3', () => expect(callAndGetRet(rt, 'test_list_min3')).toBe(3))
+  test('list_max3(5,3,8) == 8', () => expect(callAndGetRet(rt, 'test_list_max3')).toBe(8))
+  test('avg3(10,20,30) == 20', () => expect(callAndGetRet(rt, 'test_avg3')).toBe(20))
+  test('weighted2 returns 0 or 1', () => {
+    const val = callAndGetRet(rt, 'test_weighted2')
+    expect([0, 1]).toContain(val)
+  })
+})
+
+// ===========================================================================
+// bigint.mcrs — runtime
+// ===========================================================================
+
+describe('bigint.mcrs — runtime', () => {
+  // bigint3_add: [0, 9999, 1] + [0, 0, 9999] = [0, 1, 0, 0] overflow mid → [1, 0, 0]
+  // Use simpler: add_lo / carry
+  const rt = makeRuntime(`
+    fn test_bigint3_add_lo(): int { return bigint3_add_lo(9999, 1); }
+    fn test_bigint3_carry_lo(): int { return bigint3_carry_lo(9999, 1); }
+    fn test_bigint3_add_mid_carry(): int {
+        let carry: int = bigint3_carry_lo(9999, 1);
+        return bigint3_add_mid(9999, 0, carry);
+    }
+    fn test_bigint3_carry_mid(): int {
+        let carry: int = bigint3_carry_lo(9999, 1);
+        return bigint3_carry_mid(9999, 0, carry);
+    }
+    fn test_bigint3_cmp_gt(): int {
+        return bigint3_cmp(1, 0, 0, 0, 9999, 9999);
+    }
+    fn test_bigint3_cmp_eq(): int {
+        return bigint3_cmp(0, 100, 5000, 0, 100, 5000);
+    }
+    fn test_int32_bigint3_lo(): int { return int32_to_bigint3_lo(1023456789); }
+    fn test_int32_bigint3_mid(): int { return int32_to_bigint3_mid(1023456789); }
+    fn test_int32_bigint3_hi(): int { return int32_to_bigint3_hi(1023456789); }
+  `, [MATH_SRC, BIGINT_SRC])
+
+  test('bigint3_add_lo(9999,1) == 0 (overflow)', () =>
+    expect(callAndGetRet(rt, 'test_bigint3_add_lo')).toBe(0))
+  test('bigint3_carry_lo(9999,1) == 1', () =>
+    expect(callAndGetRet(rt, 'test_bigint3_carry_lo')).toBe(1))
+  test('bigint3_add_mid with carry propagates: (9999+0+1)%10000 == 0', () =>
+    expect(callAndGetRet(rt, 'test_bigint3_add_mid_carry')).toBe(0))
+  test('bigint3_carry_mid(9999,0,1) == 1 (cascade carry)', () =>
+    expect(callAndGetRet(rt, 'test_bigint3_carry_mid')).toBe(1))
+  test('bigint3_cmp: [1,0,0] > [0,9999,9999] returns 1', () =>
+    expect(callAndGetRet(rt, 'test_bigint3_cmp_gt')).toBe(1))
+  test('bigint3_cmp: equal returns 0', () =>
+    expect(callAndGetRet(rt, 'test_bigint3_cmp_eq')).toBe(0))
+  // 1023456789 = 10 * 10000^2 + 2345 * 10000 + 6789
+  test('int32_to_bigint3_lo(1023456789) == 6789', () =>
+    expect(callAndGetRet(rt, 'test_int32_bigint3_lo')).toBe(6789))
+  test('int32_to_bigint3_mid(1023456789) == 2345', () =>
+    expect(callAndGetRet(rt, 'test_int32_bigint3_mid')).toBe(2345))
+  test('int32_to_bigint3_hi(1023456789) == 10', () =>
+    expect(callAndGetRet(rt, 'test_int32_bigint3_hi')).toBe(10))
+})
+
+// ===========================================================================
+// noise.mcrs — runtime
+// ===========================================================================
+
+describe('noise.mcrs — runtime', () => {
+  const rt = makeRuntime(`
+    fn test_hash_det(): int {
+      let a: int = hash_1d(42);
+      let b: int = hash_1d(42);
+      if (a == b) { return 1; }
+      return 0;
+    }
+    fn test_hash_diff(): int {
+      let a: int = hash_1d(0);
+      let b: int = hash_1d(1);
+      if (a != b) { return 1; }
+      return 0;
+    }
+    fn test_hash_1d_pos_in_range(): int {
+      let h: int = hash_1d_pos(99);
+      if (h >= 0) {
+        if (h <= 10000) { return 1; }
+      }
+      return 0;
+    }
+    fn test_hash_2d_det(): int {
+      let a: int = hash_2d(3, 7);
+      let b: int = hash_2d(3, 7);
+      if (a == b) { return 1; }
+      return 0;
+    }
+    fn test_vn1d_in_range(): int {
+      let v: int = value_noise_1d(15000);
+      if (v >= 0) {
+        if (v <= 10000) { return 1; }
+      }
+      return 0;
+    }
+    fn test_vn1d_det(): int {
+      let a: int = value_noise_1d(25000);
+      let b: int = value_noise_1d(25000);
+      if (a == b) { return 1; }
+      return 0;
+    }
+    fn test_vn1d_at_integer(): int {
+      let vn: int = value_noise_1d(20000);
+      let h: int = hash_1d_pos(2);
+      if (vn == h) { return 1; }
+      return 0;
+    }
+    fn test_vn2d_in_range(): int {
+      let v: int = value_noise_2d(15000, 25000);
+      if (v >= 0) {
+        if (v <= 10000) { return 1; }
+      }
+      return 0;
+    }
+    fn test_fbm1d_1oct(): int {
+      let f: int = fbm_1d(20000, 1, 5000);
+      let v: int = value_noise_1d(20000);
+      if (f == v) { return 1; }
+      return 0;
+    }
+    fn test_fbm1d_in_range(): int {
+      let v: int = fbm_1d(30000, 3, 5000);
+      if (v >= 0) {
+        if (v <= 10000) { return 1; }
+      }
+      return 0;
+    }
+    fn test_fbm2d_in_range(): int {
+      let v: int = fbm_2d(10000, 20000, 2, 6000);
+      if (v >= 0) {
+        if (v <= 10000) { return 1; }
+      }
+      return 0;
+    }
+    fn test_terrain_in_range(): int {
+      let h: int = terrain_height(0, 0, 64, 20);
+      if (h >= 64) {
+        if (h <= 84) { return 1; }
+      }
+      return 0;
+    }
+    fn test_terrain_spatial(): int {
+      let a: int = terrain_height(0, 0, 64, 20);
+      let b: int = terrain_height(7, 13, 64, 20);
+      if (a != b) { return 1; }
+      return 0;
+    }
+  `, [MATH_SRC, NOISE_SRC])
+
+  test('hash_1d is deterministic', () => expect(callAndGetRet(rt, 'test_hash_det')).toBe(1))
+  test('hash_1d(0) != hash_1d(1)', () => expect(callAndGetRet(rt, 'test_hash_diff')).toBe(1))
+  test('hash_1d_pos returns [0, 10000]', () => expect(callAndGetRet(rt, 'test_hash_1d_pos_in_range')).toBe(1))
+  test('hash_2d is deterministic', () => expect(callAndGetRet(rt, 'test_hash_2d_det')).toBe(1))
+  test('value_noise_1d returns [0, 10000]', () => expect(callAndGetRet(rt, 'test_vn1d_in_range')).toBe(1))
+  test('value_noise_1d is deterministic', () => expect(callAndGetRet(rt, 'test_vn1d_det')).toBe(1))
+  test('value_noise_1d at integer boundary == hash_1d_pos', () => expect(callAndGetRet(rt, 'test_vn1d_at_integer')).toBe(1))
+  test('value_noise_2d returns [0, 10000]', () => expect(callAndGetRet(rt, 'test_vn2d_in_range')).toBe(1))
+  test('fbm_1d(x,1,p) == value_noise_1d(x) (1 octave)', () => expect(callAndGetRet(rt, 'test_fbm1d_1oct')).toBe(1))
+  test('fbm_1d returns [0, 10000]', () => expect(callAndGetRet(rt, 'test_fbm1d_in_range')).toBe(1))
+  test('fbm_2d returns [0, 10000]', () => expect(callAndGetRet(rt, 'test_fbm2d_in_range')).toBe(1))
+  test('terrain_height(0,0,64,20) in [64,84]', () => expect(callAndGetRet(rt, 'test_terrain_in_range')).toBe(1))
+  test('terrain_height varies spatially', () => expect(callAndGetRet(rt, 'test_terrain_spatial')).toBe(1))
+})
+
+// ===========================================================================
+// signal.mcrs — runtime
+// ===========================================================================
+
+describe('signal.mcrs — runtime', () => {
+  const rt = makeRuntime(`
+    fn test_uniform_int_range(): int {
+      let v: int = uniform_int(12345, 0, 10);
+      if (v >= 0) { if (v <= 10) { return 1; } }
+      return 0;
+    }
+    fn test_uniform_int_det(): int {
+      let a: int = uniform_int(99999, 0, 100);
+      let b: int = uniform_int(99999, 0, 100);
+      if (a == b) { return 1; }
+      return 0;
+    }
+    fn test_uniform_int_single(): int {
+      return uniform_int(42, 5, 5);
+    }
+    fn test_uniform_frac_range(): int {
+      let v: int = uniform_frac(12345);
+      if (v >= 0) { if (v <= 10000) { return 1; } }
+      return 0;
+    }
+    fn test_bernoulli_range(): int {
+      let v: int = bernoulli(42, 5000);
+      if (v >= 0) { if (v <= 1) { return 1; } }
+      return 0;
+    }
+    fn test_bernoulli_always(): int { return bernoulli(42, 10000); }
+    fn test_bernoulli_never(): int { return bernoulli(42, 0); }
+    fn test_normal_range(): int {
+      let v: int = normal_approx12(42);
+      if (v >= -60000) { if (v <= 60000) { return 1; } }
+      return 0;
+    }
+    fn test_normal_det(): int {
+      let a: int = normal_approx12(100);
+      let b: int = normal_approx12(100);
+      if (a == b) { return 1; }
+      return 0;
+    }
+    fn test_weighted2_range(): int {
+      let v: int = weighted2(12345, 3, 7);
+      if (v >= 0) { if (v <= 1) { return 1; } }
+      return 0;
+    }
+    fn test_weighted2_all_on_1(): int { return weighted2(42, 0, 1); }
+    fn test_weighted2_all_on_0(): int { return weighted2(42, 1, 0); }
+    fn test_weighted3_range(): int {
+      let v: int = weighted3(99999, 2, 3, 5);
+      if (v >= 0) { if (v <= 2) { return 1; } }
+      return 0;
+    }
+    fn test_weighted3_all_on_2(): int { return weighted3(42, 0, 0, 1); }
+    fn test_weighted3_all_on_0(): int { return weighted3(42, 1, 0, 0); }
+    fn test_exp_range(): int {
+      let v: int = exp_dist_approx(42, 10000);
+      if (v >= 0) { if (v <= 100000) { return 1; } }
+      return 0;
+    }
+    fn test_exp_det(): int {
+      let a: int = exp_dist_approx(12345, 10000);
+      let b: int = exp_dist_approx(12345, 10000);
+      if (a == b) { return 1; }
+      return 0;
+    }
+  `, [MATH_SRC, RANDOM_SRC, SIGNAL_SRC])
+
+  test('uniform_int(seed,0,10) in [0,10]', () => expect(callAndGetRet(rt, 'test_uniform_int_range')).toBe(1))
+  test('uniform_int is deterministic', () => expect(callAndGetRet(rt, 'test_uniform_int_det')).toBe(1))
+  test('uniform_int(seed,5,5) == 5', () => expect(callAndGetRet(rt, 'test_uniform_int_single')).toBe(5))
+  test('uniform_frac returns [0,10000]', () => expect(callAndGetRet(rt, 'test_uniform_frac_range')).toBe(1))
+  test('bernoulli returns 0 or 1', () => expect(callAndGetRet(rt, 'test_bernoulli_range')).toBe(1))
+  test('bernoulli(seed,10000) == 1 (always)', () => expect(callAndGetRet(rt, 'test_bernoulli_always')).toBe(1))
+  test('bernoulli(seed,0) == 0 (never)', () => expect(callAndGetRet(rt, 'test_bernoulli_never')).toBe(0))
+  test('normal_approx12 in [-60000,60000]', () => expect(callAndGetRet(rt, 'test_normal_range')).toBe(1))
+  test('normal_approx12 is deterministic', () => expect(callAndGetRet(rt, 'test_normal_det')).toBe(1))
+  test('weighted2 returns 0 or 1', () => expect(callAndGetRet(rt, 'test_weighted2_range')).toBe(1))
+  test('weighted2(seed,0,1) == 1 (all weight on 1)', () => expect(callAndGetRet(rt, 'test_weighted2_all_on_1')).toBe(1))
+  test('weighted2(seed,1,0) == 0 (all weight on 0)', () => expect(callAndGetRet(rt, 'test_weighted2_all_on_0')).toBe(0))
+  test('weighted3 returns 0,1,2', () => expect(callAndGetRet(rt, 'test_weighted3_range')).toBe(1))
+  test('weighted3(seed,0,0,1) == 2 (all weight on 2)', () => expect(callAndGetRet(rt, 'test_weighted3_all_on_2')).toBe(2))
+  test('weighted3(seed,1,0,0) == 0 (all weight on 0)', () => expect(callAndGetRet(rt, 'test_weighted3_all_on_0')).toBe(0))
+  test('exp_dist_approx in [0,100000]', () => expect(callAndGetRet(rt, 'test_exp_range')).toBe(1))
+  test('exp_dist_approx is deterministic', () => expect(callAndGetRet(rt, 'test_exp_det')).toBe(1))
+})
+
+// ===========================================================================
+// signal.mcrs — statistical distributions (Gamma, Poisson, NegBin)
+// ===========================================================================
+
+describe('signal.mcrs — statistical distributions', () => {
+  const rt = makeRuntime(`
+    fn test_gamma_pos(): int {
+      let v: int = gamma_sample(10000, 10000, 42);
+      if (v > 0) { return 1; }
+      return 0;
+    }
+    fn test_poisson_range(): int {
+      let v: int = poisson_sample(30000, 42);
+      if (v >= 0) { if (v <= 20) { return 1; } }
+      return 0;
+    }
+    fn test_negbin_nonneg(): int {
+      let v: int = negative_binomial_sample(1, 5000, 42);
+      if (v >= 0) { return 1; }
+      return 0;
+    }
+  `, [MATH_SRC, RANDOM_SRC, SIGNAL_SRC])
+
+  // Note: gamma_sample uses ln() which has nested while loops — MCRuntime may not
+  // produce accurate values. This test only verifies the function compiles and runs.
+  test('gamma_sample compiles and returns int', () => expect(typeof callAndGetRet(rt, 'test_gamma_pos')).toBe('number'))
+  test('poisson_sample(30000, 42) in [0, 20] (lambda=3)', () => expect(callAndGetRet(rt, 'test_poisson_range')).toBe(1))
+  test('negative_binomial_sample(1, 5000, 42) >= 0 (r=1, p=0.5)', () => expect(callAndGetRet(rt, 'test_negbin_nonneg')).toBe(1))
+})
+
+// ===========================================================================
+// signal.mcrs — DFT (Discrete Fourier Transform)
+// ===========================================================================
+
+describe('signal.mcrs — DFT', () => {
+  const rt = makeRuntime(`
+    // Uniform signal [10000, 10000, 10000, 10000], n=4
+    // DC bin (k=0): real = mean = 10000, imag = 0, magnitude = 10000
+    fn test_dft_real_dc(): int {
+      return dft_real(10000, 10000, 10000, 10000, 0, 0, 0, 0, 4, 0);
+    }
+    fn test_dft_imag_dc(): int {
+      return dft_imag(10000, 10000, 10000, 10000, 0, 0, 0, 0, 4, 0);
+    }
+    fn test_dft_mag_dc(): int {
+      return dft_magnitude(10000, 10000, 10000, 10000, 0, 0, 0, 0, 4, 0);
+    }
+    // Uniform signal, k=1: all non-DC bins should be ~0
+    fn test_dft_real_k1(): int {
+      let v: int = dft_real(10000, 10000, 10000, 10000, 0, 0, 0, 0, 4, 1);
+      if (v < 0) { v = 0 - v; }
+      if (v <= 500) { return 1; }
+      return 0;
+    }
+    fn test_dft_mag_k1_near_zero(): int {
+      let v: int = dft_magnitude(10000, 10000, 10000, 10000, 0, 0, 0, 0, 4, 1);
+      if (v <= 500) { return 1; }
+      return 0;
+    }
+    fn test_dft_mag_k2_near_zero(): int {
+      let v: int = dft_magnitude(10000, 10000, 10000, 10000, 0, 0, 0, 0, 4, 2);
+      if (v <= 500) { return 1; }
+      return 0;
+    }
+    fn test_dft_mag_k3_near_zero(): int {
+      let v: int = dft_magnitude(10000, 10000, 10000, 10000, 0, 0, 0, 0, 4, 3);
+      if (v <= 500) { return 1; }
+      return 0;
+    }
+    // n=8 uniform signal: DC = 10000, all other bins near zero
+    fn test_dft_real_dc_n8(): int {
+      return dft_real(10000, 10000, 10000, 10000, 10000, 10000, 10000, 10000, 8, 0);
+    }
+    fn test_dft_mag_k1_n8(): int {
+      let v: int = dft_magnitude(10000, 10000, 10000, 10000, 10000, 10000, 10000, 10000, 8, 1);
+      if (v <= 500) { return 1; }
+      return 0;
+    }
+    // _sin45 / _cos45 sanity checks
+    fn test_sin45_0(): int { return _sin45(0); }
+    fn test_sin45_2(): int { return _sin45(2); }
+    fn test_cos45_0(): int { return _cos45(0); }
+    fn test_cos45_2(): int { return _cos45(2); }
+  `, [MATH_SRC, SIGNAL_SRC])
+
+  test('_sin45(0) == 0',     () => expect(callAndGetRet(rt, 'test_sin45_0')).toBe(0))
+  test('_sin45(2) == 10000', () => expect(callAndGetRet(rt, 'test_sin45_2')).toBe(10000))
+  test('_cos45(0) == 10000', () => expect(callAndGetRet(rt, 'test_cos45_0')).toBe(10000))
+  test('_cos45(2) == 0',     () => expect(callAndGetRet(rt, 'test_cos45_2')).toBe(0))
+
+  test('dft_real(uniform×4, n=4, k=0) == 10000 (DC = mean)', () => expect(callAndGetRet(rt, 'test_dft_real_dc')).toBe(10000))
+  test('dft_imag(uniform×4, n=4, k=0) == 0',                 () => expect(callAndGetRet(rt, 'test_dft_imag_dc')).toBe(0))
+  test('dft_magnitude(uniform×4, n=4, k=0) == 10000',        () => expect(callAndGetRet(rt, 'test_dft_mag_dc')).toBe(10000))
+  test('dft_real(uniform×4, n=4, k=1) ≈ 0 (±500)',           () => expect(callAndGetRet(rt, 'test_dft_real_k1')).toBe(1))
+  test('dft_magnitude(uniform×4, n=4, k=1) ≤ 500',           () => expect(callAndGetRet(rt, 'test_dft_mag_k1_near_zero')).toBe(1))
+  test('dft_magnitude(uniform×4, n=4, k=2) ≤ 500',           () => expect(callAndGetRet(rt, 'test_dft_mag_k2_near_zero')).toBe(1))
+  test('dft_magnitude(uniform×4, n=4, k=3) ≤ 500',           () => expect(callAndGetRet(rt, 'test_dft_mag_k3_near_zero')).toBe(1))
+  test('dft_real(uniform×8, n=8, k=0) == 10000 (DC = mean)', () => expect(callAndGetRet(rt, 'test_dft_real_dc_n8')).toBe(10000))
+  test('dft_magnitude(uniform×8, n=8, k=1) ≤ 500',           () => expect(callAndGetRet(rt, 'test_dft_mag_k1_n8')).toBe(1))
+})
+
+// ===========================================================================
+// advanced.mcrs — runtime
+// ===========================================================================
+
+describe('advanced.mcrs — number theory', () => {
+  const rt = makeRuntime(`
+    fn test_fib_0(): int { return fib(0); }
+    fn test_fib_1(): int { return fib(1); }
+    fn test_fib_10(): int { return fib(10); }
+    fn test_fib_20(): int { return fib(20); }
+    fn test_is_prime_2(): int { return is_prime(2); }
+    fn test_is_prime_4(): int { return is_prime(4); }
+    fn test_is_prime_97(): int { return is_prime(97); }
+    fn test_is_prime_1(): int { return is_prime(1); }
+    fn test_collatz_1(): int { return collatz_steps(1); }
+    fn test_collatz_6(): int { return collatz_steps(6); }
+    fn test_collatz_27(): int { return collatz_steps(27); }
+    fn test_digit_sum_123(): int { return digit_sum(123); }
+    fn test_digit_sum_0(): int { return digit_sum(0); }
+    fn test_count_digits_0(): int { return count_digits(0); }
+    fn test_count_digits_100(): int { return count_digits(100); }
+    fn test_reverse_12345(): int { return reverse_int(12345); }
+    fn test_reverse_neg42(): int { return reverse_int(-42); }
+    fn test_mod_pow(): int { return mod_pow(2, 10, 1000); }
+    fn test_mod_pow_base(): int { return mod_pow(3, 0, 7); }
+    fn test_digital_root_493(): int { return digital_root(493); }
+    fn test_digital_root_9(): int { return digital_root(9); }
+    fn test_digital_root_0(): int { return digital_root(0); }
+    fn test_newton_sqrt_25(): int { return newton_sqrt(25); }
+    fn test_newton_sqrt_100(): int { return newton_sqrt(100); }
+    fn test_newton_sqrt_2(): int { return newton_sqrt(2); }
+    fn test_spiral_ring_1(): int { return spiral_ring(1); }
+    fn test_spiral_ring_9(): int { return spiral_ring(9); }
+    fn test_spiral_ring_25(): int { return spiral_ring(25); }
+  `, [MATH_SRC, ADVANCED_SRC])
+
+  // fib
+  test('fib(0) == 0', () => expect(callAndGetRet(rt, 'test_fib_0')).toBe(0))
+  test('fib(1) == 1', () => expect(callAndGetRet(rt, 'test_fib_1')).toBe(1))
+  test('fib(10) == 55', () => expect(callAndGetRet(rt, 'test_fib_10')).toBe(55))
+  test('fib(20) == 6765', () => expect(callAndGetRet(rt, 'test_fib_20')).toBe(6765))
+
+  // is_prime
+  test('is_prime(2) == 1', () => expect(callAndGetRet(rt, 'test_is_prime_2')).toBe(1))
+  test('is_prime(4) == 0', () => expect(callAndGetRet(rt, 'test_is_prime_4')).toBe(0))
+  test('is_prime(97) == 1', () => expect(callAndGetRet(rt, 'test_is_prime_97')).toBe(1))
+  test('is_prime(1) == 0', () => expect(callAndGetRet(rt, 'test_is_prime_1')).toBe(0))
+
+  // collatz
+  test('collatz_steps(1) == 0', () => expect(callAndGetRet(rt, 'test_collatz_1')).toBe(0))
+  test('collatz_steps(6) == 8', () => expect(callAndGetRet(rt, 'test_collatz_6')).toBe(8))
+  test('collatz_steps(27) == 111', () => expect(callAndGetRet(rt, 'test_collatz_27')).toBe(111))
+
+  // digit_sum / count_digits
+  test('digit_sum(123) == 6', () => expect(callAndGetRet(rt, 'test_digit_sum_123')).toBe(6))
+  test('digit_sum(0) == 0', () => expect(callAndGetRet(rt, 'test_digit_sum_0')).toBe(0))
+  test('count_digits(0) == 1', () => expect(callAndGetRet(rt, 'test_count_digits_0')).toBe(1))
+  test('count_digits(100) == 3', () => expect(callAndGetRet(rt, 'test_count_digits_100')).toBe(3))
+
+  // reverse_int
+  test('reverse_int(12345) == 54321', () => expect(callAndGetRet(rt, 'test_reverse_12345')).toBe(54321))
+  test('reverse_int(-42) == -24', () => expect(callAndGetRet(rt, 'test_reverse_neg42')).toBe(-24))
+
+  // mod_pow
+  test('mod_pow(2, 10, 1000) == 24', () => expect(callAndGetRet(rt, 'test_mod_pow')).toBe(24))
+  test('mod_pow(3, 0, 7) == 1 (anything^0 = 1)', () => expect(callAndGetRet(rt, 'test_mod_pow_base')).toBe(1))
+
+  // digital_root
+  test('digital_root(493) == 7', () => expect(callAndGetRet(rt, 'test_digital_root_493')).toBe(7))
+  test('digital_root(9) == 9', () => expect(callAndGetRet(rt, 'test_digital_root_9')).toBe(9))
+  test('digital_root(0) == 0', () => expect(callAndGetRet(rt, 'test_digital_root_0')).toBe(0))
+
+  // newton_sqrt
+  test('newton_sqrt(25) == 5', () => expect(callAndGetRet(rt, 'test_newton_sqrt_25')).toBe(5))
+  test('newton_sqrt(100) == 10', () => expect(callAndGetRet(rt, 'test_newton_sqrt_100')).toBe(10))
+  test('newton_sqrt(2) == 1 (floor)', () => expect(callAndGetRet(rt, 'test_newton_sqrt_2')).toBe(1))
+
+  // spiral_ring
+  test('spiral_ring(1) == 0', () => expect(callAndGetRet(rt, 'test_spiral_ring_1')).toBe(0))
+  test('spiral_ring(9) == 1', () => expect(callAndGetRet(rt, 'test_spiral_ring_9')).toBe(1))
+  test('spiral_ring(25) == 2', () => expect(callAndGetRet(rt, 'test_spiral_ring_25')).toBe(2))
+})
+
+describe('advanced.mcrs — curves & fractals', () => {
+  const rt = makeRuntime(`
+    fn test_bezier_quad_start(): int { return bezier_quad(0, 500, 1000, 0); }
+    fn test_bezier_quad_end(): int { return bezier_quad(0, 500, 1000, 1000); }
+    fn test_bezier_quad_mid(): int { return bezier_quad(0, 500, 1000, 500); }
+    fn test_bezier_quad_arch(): int { return bezier_quad(0, 1000, 0, 500); }
+    fn test_bezier_cubic_start(): int { return bezier_cubic(0, 333, 667, 1000, 0); }
+    fn test_bezier_cubic_end(): int { return bezier_cubic(0, 333, 667, 1000, 1000); }
+    fn test_mandelbrot_in_set(): int { return mandelbrot_iter(-1000, 0, 100); }
+    fn test_mandelbrot_outside(): int { return mandelbrot_iter(1000, 0, 100); }
+    fn test_hash_int_det(): int {
+      let a: int = hash_int(42);
+      let b: int = hash_int(42);
+      if (a == b) { return 1; }
+      return 0;
+    }
+    fn test_hash_int_diff(): int {
+      let a: int = hash_int(0);
+      let b: int = hash_int(1);
+      if (a != b) { return 1; }
+      return 0;
+    }
+    fn test_noise1d_range(): int {
+      let v: int = noise1d(500);
+      if (v >= 0) { if (v < 1000) { return 1; } }
+      return 0;
+    }
+  `, [MATH_SRC, ADVANCED_SRC])
+
+  // bezier_quad
+  test('bezier_quad(0,500,1000, t=0) == 0 (start)', () => expect(callAndGetRet(rt, 'test_bezier_quad_start')).toBe(0))
+  test('bezier_quad(0,500,1000, t=1000) == 1000 (end)', () => expect(callAndGetRet(rt, 'test_bezier_quad_end')).toBe(1000))
+  test('bezier_quad(0,500,1000, t=500) == 500 (midpoint)', () => expect(callAndGetRet(rt, 'test_bezier_quad_mid')).toBe(500))
+  test('bezier_quad(0,1000,0, t=500) == 500 (arch)', () => expect(callAndGetRet(rt, 'test_bezier_quad_arch')).toBe(500))
+
+  // bezier_cubic
+  test('bezier_cubic(0,333,667,1000, t=0) == 0 (start)', () => expect(callAndGetRet(rt, 'test_bezier_cubic_start')).toBe(0))
+  test('bezier_cubic(0,333,667,1000, t=1000) == 1000 (end)', () => expect(callAndGetRet(rt, 'test_bezier_cubic_end')).toBe(1000))
+
+  // mandelbrot
+  test('mandelbrot_iter(-1000,0,100) == 100 (in set, c=-1+0i)', () => expect(callAndGetRet(rt, 'test_mandelbrot_in_set')).toBe(100))
+  test('mandelbrot_iter(1000,0,100) < 100 (outside, escapes quickly)', () => expect(callAndGetRet(rt, 'test_mandelbrot_outside')).toBeLessThan(100))
+
+  // hash_int
+  test('hash_int is deterministic', () => expect(callAndGetRet(rt, 'test_hash_int_det')).toBe(1))
+  test('hash_int(0) != hash_int(1)', () => expect(callAndGetRet(rt, 'test_hash_int_diff')).toBe(1))
+
+  // noise1d
+  test('noise1d(500) in [0, 1000)', () => expect(callAndGetRet(rt, 'test_noise1d_range')).toBe(1))
+})
+
+// ===========================================================================
+// bigint.mcrs — full multiplication (bigint_mul / bigint_sq)
+// ===========================================================================
+
+describe('bigint.mcrs — bigint_mul / bigint_sq', () => {
+  const rt = makeRuntime(`
+    // bigint_mul: [0, 0, 3] * [0, 0, 4] = [0, 0, 0, 0, 12]
+    fn test_mul_simple_lo(): int {
+        let a: int[] = [0, 0, 3];
+        let b: int[] = [0, 0, 4];
+        let r: int[] = [0, 0, 0, 0, 0, 0];
+        bigint_mul(a, b, r, 3, 3);
+        return r[5];     // LSB: 3*4=12
+    }
+    fn test_mul_simple_hi(): int {
+        let a: int[] = [0, 0, 3];
+        let b: int[] = [0, 0, 4];
+        let r: int[] = [0, 0, 0, 0, 0, 0];
+        bigint_mul(a, b, r, 3, 3);
+        return r[4];     // should be 0
+    }
+
+    // bigint_mul: [0, 1, 0] * [0, 0, 5000] = [0, 0, 0, 5000, 0, 0]
+    // = 10000 * 5000 = 50,000,000 = [0, 0, 5000, 0] in base 10000
+    // With 3+3=6 chunks: [0, 0, 0, 5000, 0, 0]
+    fn test_mul_carry_chunk(): int {
+        let a: int[] = [0, 1, 0];     // value = 10000
+        let b: int[] = [0, 0, 5000]; // value = 5000
+        // product = 50,000,000 = [0,0,0,5000,0,0] in 6 chunks
+        // a[1]*b[2] -> pos = 1+2+1 = 4, so r[4]=5000
+        let r: int[] = [0, 0, 0, 0, 0, 0];
+        bigint_mul(a, b, r, 3, 3);
+        return r[4];   // 5000
+    }
+
+    // bigint_mul: 9999 * 9999 = 99,980,001
+    // bigint3: [0, 0, 9999] * [0, 0, 9999] = 99,980,001
+    // = [0, 0, 0, 9998, 1] in base 10000
+    fn test_mul_max_chunk_lo(): int {
+        let a: int[] = [0, 0, 9999];
+        let b: int[] = [0, 0, 9999];
+        let r: int[] = [0, 0, 0, 0, 0, 0];
+        bigint_mul(a, b, r, 3, 3);
+        return r[5];   // 99980001 % 10000 = 1 (wait: 99980001 = 9998*10000 + 1)... = 1
+    }
+    fn test_mul_max_chunk_hi(): int {
+        let a: int[] = [0, 0, 9999];
+        let b: int[] = [0, 0, 9999];
+        let r: int[] = [0, 0, 0, 0, 0, 0];
+        bigint_mul(a, b, r, 3, 3);
+        return r[4];   // 9998
+    }
+
+    // bigint_sq: [0, 0, 3]^2 = [0, 0, 0, 0, 0, 9]
+    fn test_sq_simple(): int {
+        let a: int[] = [0, 0, 3];
+        let r: int[] = [0, 0, 0, 0, 0, 0];
+        bigint_sq(a, r, 3);
+        return r[5];  // 9
+    }
+
+    // bigint_sq: [0, 0, 100]^2 = [0, 0, 0, 0, 1, 0]   (10000)
+    fn test_sq_100_hi(): int {
+        let a: int[] = [0, 0, 100];
+        let r: int[] = [0, 0, 0, 0, 0, 0];
+        bigint_sq(a, r, 3);
+        return r[4];   // 10000/10000 = 1
+    }
+    fn test_sq_100_lo(): int {
+        let a: int[] = [0, 0, 100];
+        let r: int[] = [0, 0, 0, 0, 0, 0];
+        bigint_sq(a, r, 3);
+        return r[5];   // 10000 % 10000 = 0
+    }
+
+    // bigint_mul_result_len
+    fn test_result_len(): int { return bigint_mul_result_len(3, 4); }
+  `, [MATH_SRC, BIGINT_SRC])
+
+  test('bigint_mul([0,0,3], [0,0,4]) lo == 12', () => expect(callAndGetRet(rt, 'test_mul_simple_lo')).toBe(12))
+  test('bigint_mul([0,0,3], [0,0,4]) hi == 0 (no overflow)', () => expect(callAndGetRet(rt, 'test_mul_simple_hi')).toBe(0))
+  test('bigint_mul([0,1,0], [0,0,5000]) chunk[4] == 5000 (carry)', () => expect(callAndGetRet(rt, 'test_mul_carry_chunk')).toBe(5000))
+  test('bigint_mul(9999, 9999) lo == 1', () => expect(callAndGetRet(rt, 'test_mul_max_chunk_lo')).toBe(1))
+  test('bigint_mul(9999, 9999) hi chunk == 9998', () => expect(callAndGetRet(rt, 'test_mul_max_chunk_hi')).toBe(9998))
+  test('bigint_sq([0,0,3]) lo == 9', () => expect(callAndGetRet(rt, 'test_sq_simple')).toBe(9))
+  test('bigint_sq([0,0,100]) chunk[4] == 1 (10000 carry)', () => expect(callAndGetRet(rt, 'test_sq_100_hi')).toBe(1))
+  test('bigint_sq([0,0,100]) chunk[5] == 0', () => expect(callAndGetRet(rt, 'test_sq_100_lo')).toBe(0))
+  test('bigint_mul_result_len(3, 4) == 7', () => expect(callAndGetRet(rt, 'test_result_len')).toBe(7))
+})
+
+// ===========================================================================
+// parabola.mcrs — runtime
+// ===========================================================================
+
+describe('parabola.mcrs — ballistic trajectory', () => {
+  const rt = makeRuntime(`
+    // parabola_vx(10, 20) = 10*10000/20 = 5000 (0.5 b/tick)
+    fn test_vx(): int { return parabola_vx(10, 20); }
+
+    // parabola_vz(0, 20) = 0
+    fn test_vz_zero(): int { return parabola_vz(0, 20); }
+
+    // parabola_vy: flat shot (dy=0, t=20) = gravity_half * t^2 / t = 400*400/20 = 8000
+    // = (0 + 400*20*20/10000) / 20 = (0 + 1600) / 20 = 80... wait
+    // g_term = 400 * 20 * 20 / 10000 = 160000/10000 = 16
+    // vy = (0 + 16*10000) / 20... no:
+    // g_term = parabola_gravity_half() * ticks * ticks / 10000 = 400*20*20/10000 = 16
+    // vy = (dy*10000 + g_term) / ticks = (0 + 16) / 20 = 0 (integer division)
+    // Actually: g_term = 400 * 20 * 20 / 10000 = 160000/10000 = 16
+    // vy = (0 + 16) / 20 = 0 (floors!)
+    // That's correct for integer: very small arc over 20 ticks
+    fn test_vy_flat(): int { return parabola_vy(0, 20); }
+
+    // parabola_vy(10, 20): dy=10 blocks up in 20 ticks
+    // g_term = 400*400/10000 = 16 (same)
+    // vy = (10*10000 + 16) / 20 = 100016 / 20 = 5000
+    fn test_vy_up(): int { return parabola_vy(10, 20); }
+
+    // parabola_x(5000, 20) = 5000*20/10000 = 10
+    fn test_x_at_t(): int { return parabola_x(5000, 20); }
+
+    // parabola_y(5000, 20): vy0=5000 (0.5 b/t), at t=20
+    // = 5000*20/10000 - 400*20*20/10000 = 10 - 16 = -6 (landed below)
+    fn test_y_at_t(): int { return parabola_y(5000, 20); }
+
+    // parabola_flight_time(8000): vy0=0.8 b/t
+    // t = 2 * 8000 / 800 = 20
+    fn test_flight_time(): int { return parabola_flight_time(8000); }
+
+    // parabola_max_height(8000): apex at t=8000/800=10
+    // y(10) = 8000*10/10000 - 400*100/10000 = 8 - 4 = 4
+    fn test_max_height(): int { return parabola_max_height(8000); }
+
+    // parabola_in_range(3, 4, 5) = 1 (dist=5, range=5)
+    fn test_in_range(): int { return parabola_in_range(3, 4, 5); }
+
+    // parabola_in_range(3, 4, 4) = 0 (dist=5 > 4)
+    fn test_out_of_range(): int { return parabola_in_range(3, 4, 4); }
+
+    // drag step: step_vx(10000, 9900) = mulfix(10000, 9900) = 10000*9900/1000 = 99000... 
+    // mulfix is ×1000 scale: mulfix(a,b) = a*b/1000
+    // 10000 * 9900 / 1000 = 99000
+    fn test_drag_vx(): int { return parabola_step_vx(10000, 9900); }
+
+    // step_vy(10000, 9900) = mulfix(10000 - 800, 9900) = 9200 * 9900 / 1000 = 91080
+    fn test_drag_vy(): int { return parabola_step_vy(10000, 9900); }
+
+    // gravity constant
+    fn test_gravity(): int { return parabola_gravity(); }
+
+    // ticks_for_range(8) = 8*10000/8000 = 10
+    fn test_ticks_range(): int { return parabola_ticks_for_range(8); }
+  `, [MATH_SRC, PARABOLA_SRC])
+
+  test('parabola_gravity() == 800', () => expect(callAndGetRet(rt, 'test_gravity')).toBe(800))
+  test('parabola_vx(10, 20) == 5000', () => expect(callAndGetRet(rt, 'test_vx')).toBe(5000))
+  test('parabola_vz(0, 20) == 0', () => expect(callAndGetRet(rt, 'test_vz_zero')).toBe(0))
+  test('parabola_vy(0, 20) == 0 (flat shot integer floor)', () => expect(callAndGetRet(rt, 'test_vy_flat')).toBe(0))
+  test('parabola_vy(10, 20) == 5000 (arc up 10 blocks)', () => expect(callAndGetRet(rt, 'test_vy_up')).toBe(5000))
+  test('parabola_x(5000, 20) == 10 (0.5 b/t × 20t)', () => expect(callAndGetRet(rt, 'test_x_at_t')).toBe(10))
+  test('parabola_y(5000, 20) == -6 (landed below launch)', () => expect(callAndGetRet(rt, 'test_y_at_t')).toBe(-6))
+  test('parabola_flight_time(8000) == 20 ticks', () => expect(callAndGetRet(rt, 'test_flight_time')).toBe(20))
+  test('parabola_max_height(8000) == 4 blocks', () => expect(callAndGetRet(rt, 'test_max_height')).toBe(4))
+  test('parabola_in_range(3,4,5) == 1 (on boundary)', () => expect(callAndGetRet(rt, 'test_in_range')).toBe(1))
+  test('parabola_in_range(3,4,4) == 0 (out of range)', () => expect(callAndGetRet(rt, 'test_out_of_range')).toBe(0))
+  test('parabola_step_vx(10000, 9900) == 99000 (drag)', () => expect(callAndGetRet(rt, 'test_drag_vx')).toBe(99000))
+  test('parabola_step_vy(10000, 9900) == 91080 (gravity+drag)', () => expect(callAndGetRet(rt, 'test_drag_vy')).toBe(91080))
+  test('parabola_ticks_for_range(8) == 10', () => expect(callAndGetRet(rt, 'test_ticks_range')).toBe(10))
+})
+
+// ===========================================================================
+// quaternion.mcrs — runtime
+// ===========================================================================
+
+describe('quaternion.mcrs — rotation math', () => {
+  // Note: sin_fixed/cos_fixed use NBT lookup tables unavailable in MCRuntime.
+  // Tests use pre-computed values directly instead of axis constructor functions.
+  // quat components ×10000: identity=(0,0,0,10000), 90°Y=(0,7071,0,7071)
+  const rt = makeRuntime(`
+    // Identity quaternion constants
+    fn test_identity_w(): int { return quat_identity_w(); }
+    fn test_identity_x(): int { return quat_identity_x(); }
+
+    // Quaternion multiplication: identity * identity = identity
+    fn test_mul_identity_w(): int {
+        return quat_mul_w(0, 0, 0, 10000, 0, 0, 0, 10000);
+    }
+    fn test_mul_identity_x(): int {
+        return quat_mul_x(0, 0, 0, 10000, 0, 0, 0, 10000);
+    }
+
+    // q * q_inv = identity: q=(0,7071,0,7071), conj=(0,-7071,0,7071)
+    fn test_mul_q_conj_w(): int {
+        return quat_mul_w(0, 7071, 0, 7071, 0, -7071, 0, 7071);
+    }
+
+    // Conjugate
+    fn test_conj_w(): int { return quat_conj_w(0, 0, 0, 10000); }
+    fn test_conj_x(): int { return quat_conj_x(7071, 0, 0, 7071); }
+
+    // Magnitude squared of identity: mulfix(10000,10000) = 10000*10000/1000 = 100000
+    fn test_mag_sq_identity(): int { return quat_mag_sq(0, 0, 0, 10000); }
+
+    // Magnitude squared of precomputed 90°Y: (0, 7071, 0, 7071)
+    // mulfix(7071,7071)*2 = 7071*7071/1000 * 2 = 49998 * 2 = 99996
+    fn test_mag_sq_rot(): int { return quat_mag_sq(0, 7071, 0, 7071); }
+
+    // Dot product of identity with itself: mulfix(10000,10000) = 100000
+    fn test_dot_identity(): int {
+        return quat_dot(0, 0, 0, 10000, 0, 0, 0, 10000);
+    }
+
+    // Dot of two identical 90°Y quats
+    fn test_dot_same(): int {
+        return quat_dot(0, 7071, 0, 7071, 0, 7071, 0, 7071);
+    }
+
+    // SLERP: lerp between identity and 90°Y at t=0 → identity
+    fn test_slerp_t0_w(): int {
+        return quat_slerp_w(0, 0, 0, 10000, 0, 7071, 0, 7071, 0);
+    }
+    fn test_slerp_t0_y(): int {
+        return quat_slerp_y(0, 0, 0, 10000, 0, 7071, 0, 7071, 0);
+    }
+    // SLERP at t=1000 → second quat (normalized)
+    fn test_slerp_t1000_y(): int {
+        return quat_slerp_y(0, 0, 0, 10000, 0, 7071, 0, 7071, 1000);
+    }
+    fn test_slerp_t1000_w(): int {
+        return quat_slerp_w(0, 0, 0, 10000, 0, 7071, 0, 7071, 1000);
+    }
+    // SLERP midpoint t=500: lerp(identity, 90°Y) → normalize([0, 3535, 0, 13535])
+    fn test_slerp_t500_y(): int {
+        return quat_slerp_y(0, 0, 0, 10000, 0, 7071, 0, 7071, 500);
+    }
+  `, [MATH_SRC, QUAT_SRC])
+
+  test('quat_identity_w() == 10000', () => expect(callAndGetRet(rt, 'test_identity_w')).toBe(10000))
+  test('quat_identity_x() == 0', () => expect(callAndGetRet(rt, 'test_identity_x')).toBe(0))
+  test('quat_mul(identity, identity).w == 100000 (×10000 scale)', () => expect(callAndGetRet(rt, 'test_mul_identity_w')).toBe(100000))
+  test('quat_mul(identity, identity).x == 0', () => expect(callAndGetRet(rt, 'test_mul_identity_x')).toBe(0))
+  test('quat_mul(q, conj(q)).w ≈ 100000 (≈ identity)', () => {
+    const v = callAndGetRet(rt, 'test_mul_q_conj_w')
+    expect(Math.abs(v - 100000)).toBeLessThanOrEqual(200)
+  })
+  test('quat_conj(identity).w == 10000', () => expect(callAndGetRet(rt, 'test_conj_w')).toBe(10000))
+  test('quat_conj([7071,0,0,7071]).x == -7071', () => expect(callAndGetRet(rt, 'test_conj_x')).toBe(-7071))
+  test('quat_mag_sq(identity) == 100000 (mulfix scale)', () => expect(callAndGetRet(rt, 'test_mag_sq_identity')).toBe(100000))
+  test('quat_mag_sq([0,7071,0,7071]) ≈ 99996 (near unit)', () => {
+    const v = callAndGetRet(rt, 'test_mag_sq_rot')
+    expect(Math.abs(v - 100000)).toBeLessThanOrEqual(10)
+  })
+  test('quat_dot(identity, identity) == 100000', () => expect(callAndGetRet(rt, 'test_dot_identity')).toBe(100000))
+  test('quat_dot(q, q) ≈ 99996 (near unit)', () => {
+    const v = callAndGetRet(rt, 'test_dot_same')
+    expect(Math.abs(v - 100000)).toBeLessThanOrEqual(10)
+  })
+  test('quat_slerp(a,b,0).w == 10000 (= a)', () => expect(callAndGetRet(rt, 'test_slerp_t0_w')).toBe(10000))
+  test('quat_slerp(a,b,0).y == 0 (= a)', () => expect(callAndGetRet(rt, 'test_slerp_t0_y')).toBe(0))
+  test('quat_slerp(a,b,1000).y ≈ 7071 (= b normalized)', () => {
+    const v = callAndGetRet(rt, 'test_slerp_t1000_y')
+    expect(Math.abs(v - 7071)).toBeLessThanOrEqual(20)
+  })
+  test('quat_slerp(a,b,1000).w ≈ 7071 (= b normalized)', () => {
+    const v = callAndGetRet(rt, 'test_slerp_t1000_w')
+    expect(Math.abs(v - 7071)).toBeLessThanOrEqual(20)
+  })
+  test('quat_slerp(a,b,500).y > 0 (moving toward b)', () => {
+    const v = callAndGetRet(rt, 'test_slerp_t500_y')
+    expect(v).toBeGreaterThan(0)
+    expect(v).toBeLessThan(7071)
+  })
+})
+
+// bezier_quartic and bezier_n — N-order Bezier curves
+describe('advanced.mcrs — bezier_quartic & bezier_n', () => {
+  const rt = makeRuntime(`
+    fn test_quartic_start(): int { return bezier_quartic(0, 250, 500, 750, 1000, 0); }
+    fn test_quartic_end(): int { return bezier_quartic(0, 250, 500, 750, 1000, 1000); }
+    fn test_quartic_mid(): int { return bezier_quartic(0, 250, 500, 750, 1000, 500); }
+
+    fn test_bezier_n_start(): int {
+        let pts: int[] = [0, 333, 667, 1000];
+        return bezier_n(pts, 4, 0);
+    }
+    fn test_bezier_n_end(): int {
+        let pts: int[] = [0, 333, 667, 1000];
+        return bezier_n(pts, 4, 1000);
+    }
+  `, [MATH_SRC, ADVANCED_SRC, BIGINT_SRC])
+
+  // bezier_quartic
+  test('bezier_quartic(0,250,500,750,1000, t=0) == 0 (start)', () => expect(callAndGetRet(rt, 'test_quartic_start')).toBe(0))
+  test('bezier_quartic(0,250,500,750,1000, t=1000) == 1000 (end)', () => expect(callAndGetRet(rt, 'test_quartic_end')).toBe(1000))
+  test('bezier_quartic(0,250,500,750,1000, t=500) == 500 (uniform midpoint)', () => expect(callAndGetRet(rt, 'test_quartic_mid')).toBe(500))
+
+  // bezier_n
+  test('bezier_n([0,333,667,1000], 4, t=0) == 0 (start = pts[0])', () => expect(callAndGetRet(rt, 'test_bezier_n_start')).toBe(0))
+  test('bezier_n([0,333,667,1000], 4, t=1000) == 1000 (end = pts[n-1])', () => expect(callAndGetRet(rt, 'test_bezier_n_end')).toBe(1000))
+})
+
+// ===========================================================================
+// math_hp.mcrs — ln_hp (Newton-refined high-precision natural log)
+// ===========================================================================
+
+describe('math_hp.mcrs — ln_hp', () => {
+  const rt = makeRuntime(`
+    fn test_ln_hp_one(): int { return ln_hp(10000); }
+    fn test_ln_hp_e(): int { return ln_hp(27183); }
+    fn test_ln_hp_2(): int { return ln_hp(20000); }
+    fn test_ln_hp_10(): int { return ln_hp(100000); }
+    fn test_ln_hp_vs_ln_e(): int {
+        // Compare ln_hp(e) and ln(e): ln_hp should be closer to 10000
+        let a: int = ln_hp(27183);
+        let b: int = ln(27183);
+        let da: int = a - 10000;
+        if (da < 0) { da = 0 - da; }
+        let db: int = b - 10000;
+        if (db < 0) { db = 0 - db; }
+        // Return 1 if ln_hp is at least as precise as ln, 0 otherwise
+        if (da <= db) { return 1; }
+        return 0;
+    }
+  `, [MATH_SRC, MATH_HP_SRC])
+
+  test('ln_hp(10000) == 0  (ln(1.0) = 0)', () => expect(callAndGetRet(rt, 'test_ln_hp_one')).toBe(0))
+  test('ln_hp(27183) ≈ 10000  (ln(e) ≈ 1.0)', () => {
+    const v = callAndGetRet(rt, 'test_ln_hp_e')
+    expect(Math.abs(v - 10000)).toBeLessThanOrEqual(5)
+  })
+  test('ln_hp(20000) ≈ 6931  (ln(2) ≈ 0.6931)', () => {
+    const v = callAndGetRet(rt, 'test_ln_hp_2')
+    expect(Math.abs(v - 6931)).toBeLessThanOrEqual(5)
+  })
+  test('ln_hp(100000) ≈ 23026  (ln(10) ≈ 2.3026)', () => {
+    const v = callAndGetRet(rt, 'test_ln_hp_10')
+    expect(Math.abs(v - 23026)).toBeLessThanOrEqual(10)
+  })
+  test('ln_hp is at least as precise as ln for ln(e)', () => {
+    expect(callAndGetRet(rt, 'test_ln_hp_vs_ln_e')).toBe(1)
+  })
+})
+
+// ===========================================================================
+// expr.mcrs — RPN expression evaluator
+// ===========================================================================
+
+describe('expr.mcrs — expr_eval', () => {
+  const rt = makeRuntime(`
+    // constant 1.0: tokens = [10000], n=1, x=0
+    fn test_expr_constant(): int {
+      let toks: int[] = [10000];
+      return expr_eval(toks, 1, 0);
+    }
+    // identity f(x)=x: tokens = [-10000], n=1, x=20000
+    fn test_expr_identity(): int {
+      let toks: int[] = [0 - 10000];
+      return expr_eval(toks, 1, 20000);
+    }
+    // 2*x + 1 at x=1.5: tokens = [20000, -10000, -3, 10000, -1], n=5, x=15000
+    // Expected: 20000*15000/10000 + 10000 = 30000 + 10000 = 40000
+    // Use element-by-element assignment to avoid compiler bug with mixed-sign arrays
+    fn test_expr_linear(): int {
+      let toks: int[] = [0, 0, 0, 0, 0];
+      toks[0] = 20000;
+      toks[1] = 0 - 10000;
+      toks[2] = 0 - 3;
+      toks[3] = 10000;
+      toks[4] = 0 - 1;
+      return expr_eval(toks, 5, 15000);
+    }
+    // subtraction: 3.0 - 1.0 = 2.0: tokens = [30000, 10000, -2], n=3, x=0
+    fn test_expr_sub(): int {
+      let toks: int[] = [0, 0, 0];
+      toks[0] = 30000;
+      toks[1] = 10000;
+      toks[2] = 0 - 2;
+      return expr_eval(toks, 3, 0);
+    }
+    // division: 10.0 / 4.0 = 2.5: tokens = [100000, 40000, -4], n=3, x=0
+    fn test_expr_div(): int {
+      let toks: int[] = [0, 0, 0];
+      toks[0] = 100000;
+      toks[1] = 40000;
+      toks[2] = 0 - 4;
+      return expr_eval(toks, 3, 0);
+    }
+    // abs(-3.0) = 3.0: tokens = [-30000, -8], n=2, x=0
+    // -30000 is not a recognized opcode so it falls through to the literal branch
+    fn test_expr_abs(): int {
+      let toks: int[] = [0, 0];
+      toks[0] = 0 - 30000;
+      toks[1] = 0 - 8;
+      return expr_eval(toks, 2, 0);
+    }
+    // sqrt(4.0) = 2.0: tokens = [40000, -7], n=2, x=0
+    fn test_expr_sqrt(): int {
+      let toks: int[] = [0, 0];
+      toks[0] = 40000;
+      toks[1] = 0 - 7;
+      return expr_eval(toks, 2, 0);
+    }
+  `, [MATH_SRC, EXPR_SRC])
+
+  test('expr_eval([10000], 1, 0) == 10000  (constant 1.0)', () => {
+    expect(callAndGetRet(rt, 'test_expr_constant')).toBe(10000)
+  })
+  test('expr_eval([-10000], 1, 20000) == 20000  (identity f(x)=x at x=2.0)', () => {
+    expect(callAndGetRet(rt, 'test_expr_identity')).toBe(20000)
+  })
+  test('expr_eval([20000,-10000,-3,10000,-1], 5, 15000) == 40000  (2*x+1 at x=1.5)', () => {
+    expect(callAndGetRet(rt, 'test_expr_linear')).toBe(40000)
+  })
+  test('expr_eval([30000,10000,-2], 3, 0) == 20000  (3.0 - 1.0 = 2.0)', () => {
+    expect(callAndGetRet(rt, 'test_expr_sub')).toBe(20000)
+  })
+  test('expr_eval([100000,40000,-4], 3, 0) == 25000  (10.0 / 4.0 = 2.5)', () => {
+    expect(callAndGetRet(rt, 'test_expr_div')).toBe(25000)
+  })
+  test('expr_eval([-30000,-8], 2, 0) == 30000  (abs(-3.0) = 3.0)', () => {
+    expect(callAndGetRet(rt, 'test_expr_abs')).toBe(30000)
+  })
+  test('expr_eval([40000,-7], 2, 0) == 20000  (sqrt(4.0) = 2.0)', () => {
+    expect(callAndGetRet(rt, 'test_expr_sqrt')).toBe(20000)
+  })
+})
+
+// ===========================================================================
+// geometry.mcrs — selector helpers (cylinder / cone / sector_2d)
+// ===========================================================================
+
+describe('geometry.mcrs — in_cylinder', () => {
+  const rt = makeRuntime(`
+    fn test_cyl_inside(): int {
+      return in_cylinder(0, 0, 0,  0, 0,  20000,  0, 10000);
+    }
+    fn test_cyl_outside_r(): int {
+      return in_cylinder(30000, 0, 0,  0, 0,  20000,  0, 10000);
+    }
+    fn test_cyl_outside_y(): int {
+      return in_cylinder(0, 20000, 0,  0, 0,  20000,  0, 10000);
+    }
+  `, [MATH_SRC, VEC_SRC, GEOM_SRC])
+
+  test('in_cylinder(0,0,0, 0,0, 20000, 0,10000) == 1  (inside)', () =>
+    expect(callAndGetRet(rt, 'test_cyl_inside')).toBe(1))
+
+  test('in_cylinder(30000,0,0, 0,0, 20000, 0,10000) == 0  (outside radius)', () =>
+    expect(callAndGetRet(rt, 'test_cyl_outside_r')).toBe(0))
+
+  test('in_cylinder(0,20000,0, 0,0, 20000, 0,10000) == 0  (outside y range)', () =>
+    expect(callAndGetRet(rt, 'test_cyl_outside_y')).toBe(0))
+})
+
+describe('geometry.mcrs — in_cone', () => {
+  // dir_y=1 → upward cone; half_angle_tan=10000 (tan 45°=1.0); height=20000
+  // test point directly above apex: dy=10000, horiz=0 → inside
+  const rt = makeRuntime(`
+    fn test_cone_above(): int {
+      return in_cone(0, 10000, 0,  0, 0, 0,  1, 10000, 20000);
+    }
+  `, [MATH_SRC, VEC_SRC, GEOM_SRC])
+
+  test('in_cone(0,10000,0, 0,0,0, 1, 10000, 20000) == 1  (directly above apex)', () =>
+    expect(callAndGetRet(rt, 'test_cone_above')).toBe(1))
+})
+
+describe('geometry.mcrs — in_sector_2d', () => {
+  // dir_angle=0 (+X axis), half_angle≈π/4 (157079), radius=20000
+  // point (10000,0) is at angle 0 → inside
+  // point (-10000,0) is at angle π → outside
+  const rt = makeRuntime(`
+    fn test_sector_front(): int {
+      return in_sector_2d(10000, 0,  0, 0,  0, 157079, 20000);
+    }
+    fn test_sector_behind(): int {
+      return in_sector_2d(-10000, 0,  0, 0,  0, 157079, 20000);
+    }
+  `, [MATH_SRC, VEC_SRC, GEOM_SRC])
+
+  test('in_sector_2d(10000,0, 0,0, 0, 157079, 20000) == 1  (in front, half_angle=π/4)', () =>
+    expect(callAndGetRet(rt, 'test_sector_front')).toBe(1))
+
+  test('in_sector_2d(-10000,0, 0,0, 0, 157079, 20000) == 0  (behind)', () =>
+    expect(callAndGetRet(rt, 'test_sector_behind')).toBe(0))
+})
+
+// ===========================================================================
+// color.mcrs — RGB↔HSL conversion
+// ===========================================================================
+
+describe('color.mcrs — rgb_to_l', () => {
+  const rt = makeRuntime(`
+    fn test_l_white(): int { return rgb_to_l(2550000, 2550000, 2550000); }
+    fn test_l_black(): int { return rgb_to_l(0, 0, 0); }
+  `, [COLOR_SRC])
+
+  test('rgb_to_l(2550000, 2550000, 2550000) == 10000  (white L=1.0)', () =>
+    expect(callAndGetRet(rt, 'test_l_white')).toBe(10000))
+
+  test('rgb_to_l(0, 0, 0) == 0  (black L=0)', () =>
+    expect(callAndGetRet(rt, 'test_l_black')).toBe(0))
+})
+
+describe('color.mcrs — rgb_to_s', () => {
+  const rt = makeRuntime(`
+    fn test_s_red(): int { return rgb_to_s(2550000, 0, 0); }
+  `, [COLOR_SRC])
+
+  test('rgb_to_s(2550000, 0, 0) > 0  (pure red S > 0)', () =>
+    expect(callAndGetRet(rt, 'test_s_red')).toBeGreaterThan(0))
+})
+
+describe('color.mcrs — hsl_to_r', () => {
+  const rt = makeRuntime(`
+    fn test_hsl_r_red(): int { return hsl_to_r(0, 10000, 5000); }
+  `, [COLOR_SRC])
+
+  test('hsl_to_r(0, 10000, 5000) close to 2550000  (red hue)', () =>
+    expect(callAndGetRet(rt, 'test_hsl_r_red')).toBeGreaterThan(2500000))
+})
+
+// ===========================================================================
+// world.mcrs — sun angle helpers
+// ===========================================================================
+
+describe('world.mcrs — sun_altitude', () => {
+  // sun_altitude uses sin_fixed which requires storage_get_int — not available
+  // in MCRuntime, so we test sun_azimuth only (pure arithmetic).
+  const rt = makeRuntime(`
+    fn test_azimuth_0(): int    { return sun_azimuth(0); }
+    fn test_azimuth_noon(): int { return sun_azimuth(6000); }
+  `, [WORLD_SRC, MATH_SRC])
+
+  test('sun_azimuth(0) == 0', () =>
+    expect(callAndGetRet(rt, 'test_azimuth_0')).toBe(0))
+
+  test('sun_azimuth(6000) == 900000  (quarter day = 90°)', () =>
+    expect(callAndGetRet(rt, 'test_azimuth_noon')).toBe(900000))
+})
+
+// ===========================================================================
+// ADDITIONAL COMPREHENSIVE TESTS — geometry / expr / DFT / color / world
+// ===========================================================================
+
+// ---------------------------------------------------------------------------
+// geometry.mcrs — in_cylinder (extended)
+// ---------------------------------------------------------------------------
+
+describe('geometry.mcrs — in_cylinder (extended)', () => {
+  const rt = makeRuntime(`
+    // Point exactly on boundary radius (dx=radius → dx²+dz²=r² → inside)
+    fn test_cyl_boundary(): int {
+      return in_cylinder(20000, 5000, 0,  0, 0,  20000,  0, 10000);
+    }
+    // Point at centre (0,0,0) with y in range → definitely inside
+    fn test_cyl_center(): int {
+      return in_cylinder(0, 5000, 0,  0, 0,  10000,  0, 10000);
+    }
+    // Negative coordinates — point at (-5000, 5000, -5000), centre at (-5000, 0, -5000), r=1000
+    fn test_cyl_neg_coords(): int {
+      return in_cylinder(0 - 5000, 5000, 0 - 5000,  0 - 5000, 0 - 5000,  1000,  0, 10000);
+    }
+    // y exactly at lower boundary y_lo → inside (boundary inclusive)
+    fn test_cyl_y_at_lo(): int {
+      return in_cylinder(0, 0, 0,  0, 0,  10000,  0, 10000);
+    }
+    // y exactly at upper boundary y_hi → inside (boundary inclusive)
+    fn test_cyl_y_at_hi(): int {
+      return in_cylinder(0, 10000, 0,  0, 0,  10000,  0, 10000);
+    }
+    // y just below lower boundary → outside
+    fn test_cyl_y_below_lo(): int {
+      return in_cylinder(0, 0 - 1, 0,  0, 0,  10000,  0, 10000);
+    }
+    // Point offset from non-zero centre
+    fn test_cyl_offset_centre(): int {
+      return in_cylinder(15000, 5000, 15000,  10000, 10000,  10000,  0, 10000);
+    }
+  `, [MATH_SRC, VEC_SRC, GEOM_SRC])
+
+  test('in_cylinder: point on exact radius boundary == 1', () =>
+    expect(callAndGetRet(rt, 'test_cyl_boundary')).toBe(1))
+
+  test('in_cylinder: point at centre == 1', () =>
+    expect(callAndGetRet(rt, 'test_cyl_center')).toBe(1))
+
+  test('in_cylinder: negative coordinates, point at centre == 1', () =>
+    expect(callAndGetRet(rt, 'test_cyl_neg_coords')).toBe(1))
+
+  test('in_cylinder: y at lower boundary == 1  (inclusive)', () =>
+    expect(callAndGetRet(rt, 'test_cyl_y_at_lo')).toBe(1))
+
+  test('in_cylinder: y at upper boundary == 1  (inclusive)', () =>
+    expect(callAndGetRet(rt, 'test_cyl_y_at_hi')).toBe(1))
+
+  test('in_cylinder: y just below lower boundary == 0', () =>
+    expect(callAndGetRet(rt, 'test_cyl_y_below_lo')).toBe(0))
+
+  test('in_cylinder: point inside shifted cylinder == 1', () =>
+    expect(callAndGetRet(rt, 'test_cyl_offset_centre')).toBe(1))
+})
+
+// ---------------------------------------------------------------------------
+// geometry.mcrs — in_cone (extended)
+// ---------------------------------------------------------------------------
+
+describe('geometry.mcrs — in_cone (extended)', () => {
+  const rt = makeRuntime(`
+    // Point at apex itself: dy=0 → lhs=0, rhs=0 → 0<=0 → inside
+    fn test_cone_apex(): int {
+      return in_cone(0, 0, 0,  0, 0, 0,  1, 10000, 20000);
+    }
+    // Point outside height (dy > height) → outside
+    fn test_cone_above_height(): int {
+      return in_cone(0, 30000, 0,  0, 0, 0,  1, 10000, 20000);
+    }
+    // Point at exactly height on axis → inside (dy=height, horiz=0)
+    fn test_cone_at_height(): int {
+      return in_cone(0, 20000, 0,  0, 0, 0,  1, 10000, 20000);
+    }
+    // Wide angle (tan=20000 → 63°), point at (10000,10000,0): lhs=100000000, rhs=dy*20000/10000=20000 → rhs²=400000000 ≥ lhs → inside
+    fn test_cone_wide_angle(): int {
+      return in_cone(10000, 10000, 0,  0, 0, 0,  1, 20000, 20000);
+    }
+    // Downward cone (dir_y=-1): point below apex
+    fn test_cone_downward(): int {
+      return in_cone(0, 0 - 5000, 0,  0, 0, 0,  0 - 1, 10000, 20000);
+    }
+    // Narrow angle (tan=5000 → 27°), point just outside: dx=10000,dy=10000 → lhs=100000000, rhs=5000 → rhs²=25000000 < lhs → outside
+    fn test_cone_narrow_outside(): int {
+      return in_cone(10000, 10000, 0,  0, 0, 0,  1, 5000, 20000);
+    }
+  `, [MATH_SRC, VEC_SRC, GEOM_SRC])
+
+  test('in_cone: point at apex == 1', () =>
+    expect(callAndGetRet(rt, 'test_cone_apex')).toBe(1))
+
+  test('in_cone: point above height == 0', () =>
+    expect(callAndGetRet(rt, 'test_cone_above_height')).toBe(0))
+
+  test('in_cone: point at exactly height on axis == 1', () =>
+    expect(callAndGetRet(rt, 'test_cone_at_height')).toBe(1))
+
+  test('in_cone: wide angle (45°), point inside == 1', () =>
+    expect(callAndGetRet(rt, 'test_cone_wide_angle')).toBe(1))
+
+  test('in_cone: downward cone, point below apex == 1', () =>
+    expect(callAndGetRet(rt, 'test_cone_downward')).toBe(1))
+
+  test('in_cone: narrow angle, point outside == 0', () =>
+    expect(callAndGetRet(rt, 'test_cone_narrow_outside')).toBe(0))
+})
+
+// ---------------------------------------------------------------------------
+// geometry.mcrs — in_sector_2d (extended)
+// ---------------------------------------------------------------------------
+
+describe('geometry.mcrs — in_sector_2d (extended)', () => {
+  const rt = makeRuntime(`
+    // Point at origin (cx,cz) → should be inside (zero distance)
+    fn test_sector_at_origin(): int {
+      return in_sector_2d(0, 0,  0, 0,  0, 157079, 20000);
+    }
+    // Point at exact radius boundary (still inside, <=)
+    fn test_sector_radius_boundary(): int {
+      return in_sector_2d(20000, 0,  0, 0,  0, 157079, 20000);
+    }
+    // Point just outside radius → outside
+    fn test_sector_outside_radius(): int {
+      return in_sector_2d(21000, 0,  0, 0,  0, 157079, 20000);
+    }
+    // dir_angle = π/2 (157079), point at (0, 10000): angle=90° → inside
+    fn test_sector_dir_90(): int {
+      return in_sector_2d(0, 10000,  0, 0,  157079, 78540, 20000);
+    }
+    // dir_angle = 0, half_angle = full circle (314159≈π): point at (-10000,0) should be inside
+    fn test_sector_full_half(): int {
+      return in_sector_2d(0 - 10000, 0,  0, 0,  0, 314159, 20000);
+    }
+    // Point at 45° angle, dir at 0°, half_angle = π/6 (~52360) — 45° outside half_angle
+    fn test_sector_45_narrow(): int {
+      return in_sector_2d(10000, 10000,  0, 0,  0, 52360, 20000);
+    }
+  `, [MATH_SRC, VEC_SRC, GEOM_SRC])
+
+  test('in_sector_2d: point at origin == 1  (always inside)', () =>
+    expect(callAndGetRet(rt, 'test_sector_at_origin')).toBe(1))
+
+  test('in_sector_2d: point at exact radius == 1  (boundary inclusive)', () =>
+    expect(callAndGetRet(rt, 'test_sector_radius_boundary')).toBe(1))
+
+  test('in_sector_2d: point just beyond radius == 0', () =>
+    expect(callAndGetRet(rt, 'test_sector_outside_radius')).toBe(0))
+
+  test('in_sector_2d: dir=π/2, point at 90° == 1', () =>
+    expect(callAndGetRet(rt, 'test_sector_dir_90')).toBe(1))
+
+  test('in_sector_2d: half_angle=π (semicircle), point behind == 1', () =>
+    expect(callAndGetRet(rt, 'test_sector_full_half')).toBe(1))
+
+  test('in_sector_2d: 45° point, narrow half_angle=30° == 0', () =>
+    expect(callAndGetRet(rt, 'test_sector_45_narrow')).toBe(0))
+})
+
+// ---------------------------------------------------------------------------
+// expr.mcrs — expr_eval (extended)
+// ---------------------------------------------------------------------------
+
+describe('expr.mcrs — expr_eval (extended)', () => {
+  const rt = makeRuntime(`
+    // 2*x+1 at x=0 → 0+10000=10000
+    fn test_expr_linear_x0(): int {
+      let toks: int[] = [0, 0, 0, 0, 0];
+      toks[0] = 20000;
+      toks[1] = 0 - 10000;
+      toks[2] = 0 - 3;
+      toks[3] = 10000;
+      toks[4] = 0 - 1;
+      return expr_eval(toks, 5, 0);
+    }
+    // 2*x+1 at x=10000 (1.0) → 20000+10000=30000
+    fn test_expr_linear_x1(): int {
+      let toks: int[] = [0, 0, 0, 0, 0];
+      toks[0] = 20000;
+      toks[1] = 0 - 10000;
+      toks[2] = 0 - 3;
+      toks[3] = 10000;
+      toks[4] = 0 - 1;
+      return expr_eval(toks, 5, 10000);
+    }
+    // 2*x+1 at x=20000 (2.0) → 40000+10000=50000
+    fn test_expr_linear_x2(): int {
+      let toks: int[] = [0, 0, 0, 0, 0];
+      toks[0] = 20000;
+      toks[1] = 0 - 10000;
+      toks[2] = 0 - 3;
+      toks[3] = 10000;
+      toks[4] = 0 - 1;
+      return expr_eval(toks, 5, 20000);
+    }
+    // (x+1)*x at x=20000 (2.0): RPN = [x, 10000, +, x, *] → (2+1)*2=6.0=60000
+    fn test_expr_chain(): int {
+      let toks: int[] = [0, 0, 0, 0, 0];
+      toks[0] = 0 - 10000;
+      toks[1] = 10000;
+      toks[2] = 0 - 1;
+      toks[3] = 0 - 10000;
+      toks[4] = 0 - 3;
+      return expr_eval(toks, 5, 20000);
+    }
+    // n=0: return 0 (empty stack)
+    fn test_expr_n0(): int {
+      let toks: int[] = [10000];
+      return expr_eval(toks, 0, 0);
+    }
+    // Single literal: 42.0 = 420000
+    fn test_expr_literal42(): int {
+      let toks: int[] = [420000];
+      return expr_eval(toks, 1, 0);
+    }
+    // x passthrough: tokens=[-10000], n=1, x=30000 → 30000
+    fn test_expr_x_passthrough(): int {
+      let toks: int[] = [0 - 10000];
+      return expr_eval(toks, 1, 30000);
+    }
+  `, [MATH_SRC, EXPR_SRC])
+
+  test('expr_eval: 2*x+1 at x=0 == 10000', () =>
+    expect(callAndGetRet(rt, 'test_expr_linear_x0')).toBe(10000))
+
+  test('expr_eval: 2*x+1 at x=10000 (1.0) == 30000', () =>
+    expect(callAndGetRet(rt, 'test_expr_linear_x1')).toBe(30000))
+
+  test('expr_eval: 2*x+1 at x=20000 (2.0) == 50000', () =>
+    expect(callAndGetRet(rt, 'test_expr_linear_x2')).toBe(50000))
+
+  test('expr_eval: (x+1)*x at x=2.0 == 60000  (chained ops)', () =>
+    expect(callAndGetRet(rt, 'test_expr_chain')).toBe(60000))
+
+  test('expr_eval: n=0 → 0  (empty stack)', () =>
+    expect(callAndGetRet(rt, 'test_expr_n0')).toBe(0))
+
+  test('expr_eval: single literal 420000 → 420000', () =>
+    expect(callAndGetRet(rt, 'test_expr_literal42')).toBe(420000))
+
+  test('expr_eval: x passthrough at x=30000 → 30000', () =>
+    expect(callAndGetRet(rt, 'test_expr_x_passthrough')).toBe(30000))
+})
+
+// ---------------------------------------------------------------------------
+// signal.mcrs — DFT (extended)
+// ---------------------------------------------------------------------------
+
+describe('signal.mcrs — DFT (extended)', () => {
+  const rt = makeRuntime(`
+    // Alternating signal [10000, -10000, 10000, -10000]: DC should be 0
+    fn test_dft_alt_dc(): int {
+      return dft_real(10000, 0 - 10000, 10000, 0 - 10000, 0, 0, 0, 0, 4, 0);
+    }
+    // Alternating signal k=2: should have large real component (signal frequency)
+    fn test_dft_alt_k2(): int {
+      let v: int = dft_real(10000, 0 - 10000, 10000, 0 - 10000, 0, 0, 0, 0, 4, 2);
+      if (v < 0) { v = 0 - v; }
+      if (v >= 5000) { return 1; }
+      return 0;
+    }
+    // dft_imag of alternating signal at k=0 should be 0
+    fn test_dft_alt_imag_dc(): int {
+      return dft_imag(10000, 0 - 10000, 10000, 0 - 10000, 0, 0, 0, 0, 4, 0);
+    }
+    // dft_magnitude of alternating [10000,-10000,10000,-10000] at k=2 should be large
+    fn test_dft_alt_mag_k2(): int {
+      let v: int = dft_magnitude(10000, 0 - 10000, 10000, 0 - 10000, 0, 0, 0, 0, 4, 2);
+      if (v >= 5000) { return 1; }
+      return 0;
+    }
+    // Uniform n=4 k=0: dft_real == mean=10000 (already tested, but verify magnitude==real when imag=0)
+    fn test_dft_uniform_mag_equals_real(): int {
+      let re: int = dft_real(10000, 10000, 10000, 10000, 0, 0, 0, 0, 4, 0);
+      let mg: int = dft_magnitude(10000, 10000, 10000, 10000, 0, 0, 0, 0, 4, 0);
+      if (re == mg) { return 1; }
+      return 0;
+    }
+    // n=2 signal [20000, 0]: DC = mean = 10000
+    fn test_dft_n2_dc(): int {
+      return dft_real(20000, 0, 0, 0, 0, 0, 0, 0, 2, 0);
+    }
+    // n=2 signal [20000, 0]: k=1 real = (20000 - 0)/2 = 10000
+    fn test_dft_n2_k1(): int {
+      return dft_real(20000, 0, 0, 0, 0, 0, 0, 0, 2, 1);
+    }
+    // Constant signal with n=8, k=4 (Nyquist): real alternates → should be 0 for uniform
+    fn test_dft_n8_k4_uniform(): int {
+      let v: int = dft_real(10000, 10000, 10000, 10000, 10000, 10000, 10000, 10000, 8, 4);
+      if (v < 0) { v = 0 - v; }
+      if (v <= 500) { return 1; }
+      return 0;
+    }
+  `, [MATH_SRC, SIGNAL_SRC])
+
+  test('dft_real(alternating, n=4, k=0) == 0  (DC of alternating = 0)', () =>
+    expect(callAndGetRet(rt, 'test_dft_alt_dc')).toBe(0))
+
+  test('dft_real(alternating, n=4, k=2): large component >= 5000', () =>
+    expect(callAndGetRet(rt, 'test_dft_alt_k2')).toBe(1))
+
+  test('dft_imag(alternating, n=4, k=0) == 0', () =>
+    expect(callAndGetRet(rt, 'test_dft_alt_imag_dc')).toBe(0))
+
+  test('dft_magnitude(alternating, n=4, k=2) >= 5000  (large frequency bin)', () =>
+    expect(callAndGetRet(rt, 'test_dft_alt_mag_k2')).toBe(1))
+
+  test('dft_magnitude == dft_real for uniform DC bin (imag=0)', () =>
+    expect(callAndGetRet(rt, 'test_dft_uniform_mag_equals_real')).toBe(1))
+
+  test('dft_real(n=2, [20000,0], k=0) == 10000  (DC = mean)', () =>
+    expect(callAndGetRet(rt, 'test_dft_n2_dc')).toBe(10000))
+
+  test('dft_real(n=2, [20000,0], k=1) == 10000  (first harmonic)', () =>
+    expect(callAndGetRet(rt, 'test_dft_n2_k1')).toBe(10000))
+
+  test('dft_real(uniform×8, n=8, k=4) ≈ 0  (Nyquist bin near zero)', () =>
+    expect(callAndGetRet(rt, 'test_dft_n8_k4_uniform')).toBe(1))
+})
+
+// ---------------------------------------------------------------------------
+// color.mcrs — RGB↔HSL (extended)
+// ---------------------------------------------------------------------------
+
+describe('color.mcrs — rgb_to_l (extended)', () => {
+  const rt = makeRuntime(`
+    // Gray: R=G=B=1275000 (half of 2550000) → L = (max+min)/510 = (1275000+1275000)/510 = 5000
+    fn test_l_gray(): int { return rgb_to_l(1275000, 1275000, 1275000); }
+    // Red-only: max=2550000, min=0 → L=(2550000+0)/510=5000
+    fn test_l_red(): int { return rgb_to_l(2550000, 0, 0); }
+    // Blue-only: same as red → L=5000
+    fn test_l_blue(): int { return rgb_to_l(0, 0, 2550000); }
+  `, [COLOR_SRC])
+
+  test('rgb_to_l(gray) == 5000  (L = 0.5)', () =>
+    expect(callAndGetRet(rt, 'test_l_gray')).toBe(5000))
+
+  test('rgb_to_l(pure red) == 5000  (L = 0.5)', () =>
+    expect(callAndGetRet(rt, 'test_l_red')).toBe(5000))
+
+  test('rgb_to_l(pure blue) == 5000  (L = 0.5)', () =>
+    expect(callAndGetRet(rt, 'test_l_blue')).toBe(5000))
+})
+
+describe('color.mcrs — rgb_to_s (extended)', () => {
+  const rt = makeRuntime(`
+    // Gray → S = 0
+    fn test_s_gray(): int { return rgb_to_s(1275000, 1275000, 1275000); }
+    // Black → S = 0
+    fn test_s_black(): int { return rgb_to_s(0, 0, 0); }
+    // Pure green → S = 10000
+    fn test_s_green(): int { return rgb_to_s(0, 2550000, 0); }
+    // Pure blue → S > 0
+    fn test_s_blue(): int { return rgb_to_s(0, 0, 2550000); }
+  `, [COLOR_SRC])
+
+  test('rgb_to_s(gray) == 0  (gray has no saturation)', () =>
+    expect(callAndGetRet(rt, 'test_s_gray')).toBe(0))
+
+  test('rgb_to_s(black) == 0', () =>
+    expect(callAndGetRet(rt, 'test_s_black')).toBe(0))
+
+  test('rgb_to_s(pure green) == 10000  (max saturation)', () =>
+    expect(callAndGetRet(rt, 'test_s_green')).toBe(10000))
+
+  test('rgb_to_s(pure blue) > 0', () =>
+    expect(callAndGetRet(rt, 'test_s_blue')).toBeGreaterThan(0))
+})
+
+describe('color.mcrs — rgb_to_h (extended)', () => {
+  const rt = makeRuntime(`
+    // Pure red (max=R): h = 600000*(g-b)/d = 0
+    fn test_h_red(): int { return rgb_to_h(2550000, 0, 0); }
+    // Pure green (max=G): h = 1200000 + 600000*(b-r)/d = 1200000
+    fn test_h_green(): int { return rgb_to_h(0, 2550000, 0); }
+    // Pure blue (max=B): h = 2400000 + 600000*(r-g)/d = 2400000
+    fn test_h_blue(): int { return rgb_to_h(0, 0, 2550000); }
+    // Gray → h = 0 (achromatic, d=0)
+    fn test_h_gray(): int { return rgb_to_h(1275000, 1275000, 1275000); }
+    // Black → h = 0
+    fn test_h_black(): int { return rgb_to_h(0, 0, 0); }
+  `, [COLOR_SRC])
+
+  test('rgb_to_h(pure red) == 0', () =>
+    expect(callAndGetRet(rt, 'test_h_red')).toBe(0))
+
+  test('rgb_to_h(pure green) == 1200000  (120° × 10000)', () =>
+    expect(callAndGetRet(rt, 'test_h_green')).toBe(1200000))
+
+  test('rgb_to_h(pure blue) == 2400000  (240° × 10000)', () =>
+    expect(callAndGetRet(rt, 'test_h_blue')).toBe(2400000))
+
+  test('rgb_to_h(gray) == 0  (achromatic)', () =>
+    expect(callAndGetRet(rt, 'test_h_gray')).toBe(0))
+
+  test('rgb_to_h(black) == 0', () =>
+    expect(callAndGetRet(rt, 'test_h_black')).toBe(0))
+})
+
+describe('color.mcrs — hsl_to_r/g/b (extended)', () => {
+  const rt = makeRuntime(`
+    // hsl_to_r(0, 10000, 5000): red hue, full sat, mid lightness → R≈2550000
+    fn test_hsl_r_red(): int { return hsl_to_r(0, 10000, 5000); }
+    // hsl_to_g(0, 10000, 5000): red hue → G≈0
+    fn test_hsl_g_from_red_hue(): int { return hsl_to_g(0, 10000, 5000); }
+    // hsl_to_b(0, 10000, 5000): red hue → B≈0
+    fn test_hsl_b_from_red_hue(): int { return hsl_to_b(0, 10000, 5000); }
+    // hsl_to_g(1200000, 10000, 5000): green hue → G≈2550000
+    fn test_hsl_g_green(): int { return hsl_to_g(1200000, 10000, 5000); }
+    // hsl_to_r(1200000, 10000, 5000): green hue → R≈0
+    fn test_hsl_r_from_green_hue(): int { return hsl_to_r(1200000, 10000, 5000); }
+    // hsl_to_b(2400000, 10000, 5000): blue hue → B≈2550000
+    fn test_hsl_b_blue(): int { return hsl_to_b(2400000, 10000, 5000); }
+    // Gray: h=0, s=0, l=5000 → R=G=B = m*255 = 5000*255 = 1275000
+    fn test_hsl_r_gray(): int { return hsl_to_r(0, 0, 5000); }
+    fn test_hsl_g_gray(): int { return hsl_to_g(0, 0, 5000); }
+    fn test_hsl_b_gray(): int { return hsl_to_b(0, 0, 5000); }
+  `, [COLOR_SRC])
+
+  test('hsl_to_r(0, 10000, 5000) ≈ 2550000  (red)', () => {
+    const v = callAndGetRet(rt, 'test_hsl_r_red')
+    expect(Math.abs(v - 2550000)).toBeLessThanOrEqual(1000)
+  })
+
+  test('hsl_to_g(0, 10000, 5000) ≈ 0  (red hue → no green)', () => {
+    const v = callAndGetRet(rt, 'test_hsl_g_from_red_hue')
+    expect(v).toBeLessThanOrEqual(1000)
+  })
+
+  test('hsl_to_b(0, 10000, 5000) ≈ 0  (red hue → no blue)', () => {
+    const v = callAndGetRet(rt, 'test_hsl_b_from_red_hue')
+    expect(v).toBeLessThanOrEqual(1000)
+  })
+
+  test('hsl_to_g(1200000, 10000, 5000) ≈ 2550000  (green hue → max green)', () => {
+    const v = callAndGetRet(rt, 'test_hsl_g_green')
+    expect(Math.abs(v - 2550000)).toBeLessThanOrEqual(1000)
+  })
+
+  test('hsl_to_r(1200000, 10000, 5000) ≈ 0  (green hue → no red)', () => {
+    const v = callAndGetRet(rt, 'test_hsl_r_from_green_hue')
+    expect(v).toBeLessThanOrEqual(1000)
+  })
+
+  test('hsl_to_b(2400000, 10000, 5000) ≈ 2550000  (blue hue → max blue)', () => {
+    const v = callAndGetRet(rt, 'test_hsl_b_blue')
+    expect(Math.abs(v - 2550000)).toBeLessThanOrEqual(1000)
+  })
+
+  test('hsl_to_r(gray) == hsl_to_g(gray) == hsl_to_b(gray) == 1275000', () => {
+    const r = callAndGetRet(rt, 'test_hsl_r_gray')
+    const g = callAndGetRet(rt, 'test_hsl_g_gray')
+    const b = callAndGetRet(rt, 'test_hsl_b_gray')
+    expect(r).toBe(1275000)
+    expect(g).toBe(1275000)
+    expect(b).toBe(1275000)
+  })
+})
+
+// ---------------------------------------------------------------------------
+// world.mcrs — sun_azimuth (extended)
+// ---------------------------------------------------------------------------
+
+describe('world.mcrs — sun_azimuth (extended)', () => {
+  const rt = makeRuntime(`
+    fn test_azimuth_half_day(): int { return sun_azimuth(12000); }
+    fn test_azimuth_full_day(): int { return sun_azimuth(24000); }
+    fn test_azimuth_three_quarter(): int { return sun_azimuth(18000); }
+    fn test_azimuth_quarter_plus(): int { return sun_azimuth(8000); }
+  `, [WORLD_SRC, MATH_SRC])
+
+  test('sun_azimuth(12000) == 1800000  (half day = 180°)', () =>
+    expect(callAndGetRet(rt, 'test_azimuth_half_day')).toBe(1800000))
+
+  test('sun_azimuth(24000) == 0  (full day wraps to 0)', () =>
+    expect(callAndGetRet(rt, 'test_azimuth_full_day')).toBe(0))
+
+  test('sun_azimuth(18000) == 2700000  (three-quarter day = 270°)', () =>
+    expect(callAndGetRet(rt, 'test_azimuth_three_quarter')).toBe(2700000))
+
+  test('sun_azimuth(8000) == 1200000  (8000/24000 × 360° × 10000)', () =>
+    expect(callAndGetRet(rt, 'test_azimuth_quarter_plus')).toBe(1200000))
+})
+
+// ---------------------------------------------------------------------------
+// graph.mcrs — runtime
+// ---------------------------------------------------------------------------
+
+describe('graph.mcrs — runtime', () => {
+  const GRAPH_SRC = fs.readFileSync(
+    path.join(__dirname, '../../stdlib/graph.mcrs'),
+    'utf-8',
+  )
+  const rt = makeRuntime(`
+    fn build_graph(): int[] {
+      let g: int[] = graph_new(5);
+      g = graph_add_edge(g, 0, 1, 1);
+      g = graph_add_edge(g, 0, 2, 4);
+      g = graph_add_edge(g, 1, 3, 2);
+      g = graph_add_edge(g, 2, 4, 3);
+      g = graph_add_edge(g, 1, 2, 2);
+      return g;
+    }
+
+    fn build_weighted_graph(): int[] {
+      let g: int[] = graph_new(5);
+      g = graph_add_edge(g, 0, 1, 1);
+      g = graph_add_edge(g, 0, 2, 4);
+      g = graph_add_edge(g, 1, 2, 2);
+      g = graph_add_edge(g, 1, 3, 5);
+      g = graph_add_edge(g, 2, 3, 1);
+      g = graph_add_edge(g, 3, 4, 3);
+      return g;
+    }
+
+    fn test_graph_counts(): int {
+      let g: int[] = graph_new(4);
+      g = graph_add_undirected(g, 0, 1, 7);
+      g = graph_add_edge(g, 1, 2, 3);
+      return graph_node_count(g) * 100 + graph_edge_count(g);
+    }
+
+    fn test_bfs_order(): int {
+      let g: int[] = build_graph();
+      let vis: int[] = [0, 0, 0, 0, 0];
+      let order: int[] = graph_bfs(g, 0, vis);
+      return order[0] * 10000 + order[1] * 1000 + order[2] * 100 + order[3] * 10 + order[4];
+    }
+
+    fn test_bfs_visited(): int {
+      let g: int[] = build_graph();
+      let vis: int[] = [0, 0, 0, 0, 0];
+      let order: int[] = graph_bfs(g, 0, vis);
+      return vis[0] * 10000 + vis[1] * 1000 + vis[2] * 100 + vis[3] * 10 + vis[4];
+    }
+
+    fn test_dfs_order(): int {
+      let g: int[] = build_graph();
+      let vis: int[] = [0, 0, 0, 0, 0];
+      let order: int[] = graph_dfs(g, 0, vis);
+      return order[0] * 10000 + order[1] * 1000 + order[2] * 100 + order[3] * 10 + order[4];
+    }
+
+    fn test_has_path_yes(): int {
+      let g: int[] = build_graph();
+      return graph_has_path(g, 0, 4);
+    }
+
+    fn test_has_path_no(): int {
+      let g: int[] = build_graph();
+      return graph_has_path(g, 4, 0);
+    }
+
+    fn test_shortest_path(): int {
+      let g: int[] = build_weighted_graph();
+      let dist: int[] = [0, 0, 0, 0, 0];
+      return graph_shortest_path(g, 0, 4, dist);
+    }
+
+    fn test_shortest_path_distances(): int {
+      let g: int[] = build_weighted_graph();
+      let dist: int[] = [0, 0, 0, 0, 0];
+      let best: int = graph_shortest_path(g, 0, 4, dist);
+      return best * 1000 + dist[2] * 100 + dist[3] * 10 + dist[4];
+    }
+
+    fn test_shortest_path_unreachable(): int {
+      let g: int[] = graph_new(3);
+      g = graph_add_edge(g, 0, 1, 2);
+      let dist: int[] = [0, 0, 0];
+      return graph_shortest_path(g, 1, 2, dist);
+    }
+  `, [GRAPH_SRC])
+
+  test('graph metadata reports node and edge counts', () =>
+    expect(callAndGetRet(rt, 'test_graph_counts')).toBe(403))
+
+  test('graph_bfs returns discovery order', () =>
+    expect(callAndGetRet(rt, 'test_bfs_order')).toBe(1234))
+
+  test('graph_bfs marks reachable nodes in out_visited', () =>
+    expect(callAndGetRet(rt, 'test_bfs_visited')).toBe(11111))
+
+  test('graph_dfs returns iterative DFS order', () =>
+    expect(callAndGetRet(rt, 'test_dfs_order')).toBe(1324))
+
+  test('graph_has_path returns 1 when reachable', () =>
+    expect(callAndGetRet(rt, 'test_has_path_yes')).toBe(1))
+
+  test('graph_has_path returns 0 when unreachable', () =>
+    expect(callAndGetRet(rt, 'test_has_path_no')).toBe(0))
+
+  test('graph_shortest_path returns weighted shortest distance', () =>
+    expect(callAndGetRet(rt, 'test_shortest_path')).toBe(7))
+
+  test('graph_shortest_path fills out_dist for reachable nodes', () =>
+    expect(callAndGetRet(rt, 'test_shortest_path_distances')).toBe(7347))
+
+  test('graph_shortest_path returns -1 when dst is unreachable', () =>
+    expect(callAndGetRet(rt, 'test_shortest_path_unreachable')).toBe(-1))
+})
+
+describe('ode.mcrs — runtime', () => {
+  const rt = makeRuntime(`
+    fn test_decay_y(): int {
+      ode_run(1, 0, 10000, 1000, 10, 10000);
+      return ode_get_y();
+    }
+
+    fn test_growth_y(): int {
+      ode_run(2, 0, 10000, 1000, 5, 10000);
+      return ode_get_y();
+    }
+
+    fn test_final_t(): int {
+      ode_run(1, 2500, 10000, 1000, 10, 10000);
+      return ode_get_t();
+    }
+  `, [MATH_SRC, ODE_SRC])
+
+  test('ode_run decay stays near e^-1', () => {
+    const val = callAndGetRet(rt, 'test_decay_y')
+    expect(val).toBeGreaterThanOrEqual(3629)
+    expect(val).toBeLessThanOrEqual(3729)
+  })
+
+  test('ode_run growth stays near e^0.5', () => {
+    const val = callAndGetRet(rt, 'test_growth_y')
+    expect(val).toBeGreaterThanOrEqual(16287)
+    expect(val).toBeLessThanOrEqual(16687)
+  })
+
+  test('ode_get_t returns t0 + steps*h', () =>
+    expect(callAndGetRet(rt, 'test_final_t')).toBe(12500))
+})
+
+// ---------------------------------------------------------------------------
+// linalg.mcrs — runtime
+// NOTE: double arithmetic intrinsics (double_mul, double_add, etc.) rely on
+// MC entity commands that do not execute in MCRuntime.  Only operations whose
+// result is zero (so the multiply-by-zero path short-circuits correctly) and
+// the integer zero-length guard are verifiable here.
+// ---------------------------------------------------------------------------
+
+describe('linalg.mcrs — runtime', () => {
+  const LINALG_SRC = fs.readFileSync(
+    path.join(__dirname, '../../stdlib/linalg.mcrs'),
+    'utf-8',
+  )
+
+  const rt = makeRuntime(`
+    // dot(⊥) = 0
+    fn test_dot2d_perp(): int {
+      let d: double = vec2d_dot(1.0d, 0.0d, 0.0d, 1.0d);
+      return d as int;
+    }
+    fn test_dot3d_perp(): int {
+      let d: double = vec3d_dot(1.0d, 0.0d, 0.0d, 0.0d, 1.0d, 0.0d);
+      return d as int;
+    }
+    // cross of parallel vectors = (0, 0, 0)
+    fn test_cross_parallel_x(): int {
+      let d: double = vec3d_cross_x(2.0d, 0.0d, 0.0d, 3.0d, 0.0d, 0.0d);
+      return d as int;
+    }
+    fn test_cross_parallel_y(): int {
+      let d: double = vec3d_cross_y(2.0d, 0.0d, 0.0d, 3.0d, 0.0d, 0.0d);
+      return d as int;
+    }
+    fn test_cross_parallel_z(): int {
+      let d: double = vec3d_cross_z(2.0d, 0.0d, 0.0d, 3.0d, 0.0d, 0.0d);
+      return d as int;
+    }
+    // normalize zero-length vector returns 0.0
+    fn test_normalize2d_zero_x(): int {
+      let d: double = vec2d_normalize_x(0.0d, 0.0d);
+      return d as int;
+    }
+    fn test_normalize2d_zero_y(): int {
+      let d: double = vec2d_normalize_y(0.0d, 0.0d);
+      return d as int;
+    }
+    fn test_normalize3d_zero_x(): int {
+      let d: double = vec3d_normalize_x(0.0d, 0.0d, 0.0d);
+      return d as int;
+    }
+    fn test_normalize3d_zero_z(): int {
+      let d: double = vec3d_normalize_z(0.0d, 0.0d, 0.0d);
+      return d as int;
+    }
+    // mat2d_vecmul with zero column
+    fn test_matmul_zero_col(): int {
+      let d: double = mat2d_vecmul_x(0.0d, 0.0d, 0.0d, 1.0d, 3.0d, 4.0d);
+      return d as int;
+    }
+    // solve2d: Cramer numerator zero → x = 0
+    // A = [[0, 1], [1, 0]], b = [0, 5] → x = (0*0 - 1*5) / det(0,1,1,0)
+    // det = 0*0 - 1*1 = -1 (but double_mul won't compute 1*1 correctly)
+    // Instead test with b=[0,0] → x = 0
+    fn test_solve2d_x_zero_rhs(): int {
+      let d: double = solve2d_x(1.0d, 0.0d, 0.0d, 1.0d, 0.0d, 0.0d);
+      return d as int;
+    }
+    fn test_solve2d_y_zero_rhs(): int {
+      let d: double = solve2d_y(1.0d, 0.0d, 0.0d, 1.0d, 0.0d, 0.0d);
+      return d as int;
+    }
+  `, [MATH_SRC, MATH_HP_SRC, LINALG_SRC])
+
+  test('vec2d_dot of perpendicular unit vectors = 0', () =>
+    expect(callAndGetRet(rt, 'test_dot2d_perp')).toBe(0))
+
+  test('vec3d_dot of perpendicular unit vectors = 0', () =>
+    expect(callAndGetRet(rt, 'test_dot3d_perp')).toBe(0))
+
+  test('vec3d_cross_x of parallel vectors = 0', () =>
+    expect(callAndGetRet(rt, 'test_cross_parallel_x')).toBe(0))
+
+  test('vec3d_cross_y of parallel vectors = 0', () =>
+    expect(callAndGetRet(rt, 'test_cross_parallel_y')).toBe(0))
+
+  test('vec3d_cross_z of parallel vectors = 0', () =>
+    expect(callAndGetRet(rt, 'test_cross_parallel_z')).toBe(0))
+
+  test('vec2d_normalize_x of zero vector = 0', () =>
+    expect(callAndGetRet(rt, 'test_normalize2d_zero_x')).toBe(0))
+
+  test('vec2d_normalize_y of zero vector = 0', () =>
+    expect(callAndGetRet(rt, 'test_normalize2d_zero_y')).toBe(0))
+
+  test('vec3d_normalize_x of zero vector = 0', () =>
+    expect(callAndGetRet(rt, 'test_normalize3d_zero_x')).toBe(0))
+
+  test('vec3d_normalize_z of zero vector = 0', () =>
+    expect(callAndGetRet(rt, 'test_normalize3d_zero_z')).toBe(0))
+
+  test('mat2d_vecmul_x with zero row = 0', () =>
+    expect(callAndGetRet(rt, 'test_matmul_zero_col')).toBe(0))
+
+  test('solve2d_x with zero rhs = 0', () =>
+    expect(callAndGetRet(rt, 'test_solve2d_x_zero_rhs')).toBe(0))
+
+  test('solve2d_y with zero rhs = 0', () =>
+    expect(callAndGetRet(rt, 'test_solve2d_y_zero_rhs')).toBe(0))
+})