redscript-mc 2.5.0 → 2.6.2

package/src/__tests__/stdlib/matrix.test.ts

@@ -0,0 +1,140 @@
+/**
+ * Tests for stdlib/matrix.mcrs functions.
+ * Verifies compilation succeeds and key rotation/scale/quaternion functions are emitted.
+ */
+
+import { compile } from '../../emit/compile'
+import * as fs from 'fs'
+import * as path from 'path'
+
+const MATH_STDLIB   = path.join(__dirname, '../../stdlib/math.mcrs')
+const MATRIX_STDLIB = path.join(__dirname, '../../stdlib/matrix.mcrs')
+
+const mathSrc   = fs.readFileSync(MATH_STDLIB,   'utf-8')
+const matrixSrc = fs.readFileSync(MATRIX_STDLIB, 'utf-8')
+
+function compileWith(extra: string): { path: string; content: string }[] {
+  const result = compile(extra, { namespace: 'test', librarySources: [mathSrc, matrixSrc] })
+  return result.files
+}
+
+describe('stdlib/matrix.mcrs', () => {
+  test('compiles without errors', () => {
+    expect(() => {
+      compile('fn _noop(): int { return 0; }', { namespace: 'test', librarySources: [mathSrc, matrixSrc] })
+    }).not.toThrow()
+  })
+
+  // ─── 2D rotation ────────────────────────────────────────────────────────────
+
+  test('rotate2d_x is emitted', () => {
+    const files = compileWith(`@keep fn t(): int { return rotate2d_x(1000, 0, 0); }`)
+    expect(files.some(f => f.path.includes('rotate2d_x'))).toBe(true)
+  })
+
+  test('rotate2d_y is emitted', () => {
+    const files = compileWith(`@keep fn t(): int { return rotate2d_y(1000, 0, 0); }`)
+    expect(files.some(f => f.path.includes('rotate2d_y'))).toBe(true)
+  })
+
+  // rotate2d_x(1000, 0, 0°) = 1000 * cos(0)/1000 - 0 = 1000 * 1000 / 1000 = 1000
+  // cos_fixed(0) = 1000, sin_fixed(0) = 0 → x*c/1000 - y*s/1000 = 1000*1000/1000 = 1000
+  test('rotate2d_x(1000, 0, 0°) ≈ 1000 (no rotation)', () => {
+    const files = compileWith(`@keep fn t(): int { return rotate2d_x(1000, 0, 0); }`)
+    const fn = files.find(f => f.path.endsWith('/t.mcfunction'))
+    expect(fn).toBeDefined()
+    // Result should use scoreboard operations, not a static 0
+    expect(fn!.content).not.toBe('')
+  })
+
+  test('rotate2d_x(0, 1000, 900000) ≈ -1000 (90° rotation: -y)', () => {
+    const files = compileWith(`@keep fn t(): int { return rotate2d_x(0, 1000, 900000); }`)
+    expect(files.some(f => f.path.includes('rotate2d_x'))).toBe(true)
+  })
+
+  // ─── Scale ──────────────────────────────────────────────────────────────────
+
+  test('scale_x(500, 20000) = 1000 (2× scale)', () => {
+    // scale_x(500, 20000) = 500 * 20000 / 10000 = 1000
+    const files = compileWith(`@keep fn t(): int { return scale_x(500, 20000); }`)
+    // Constant folding should produce inline 1000 or the function
+    expect(files.some(f => f.path.includes('scale_x') || f.path.includes('/t.'))).toBe(true)
+  })
+
+  test('scale_y is emitted', () => {
+    const files = compileWith(`@keep fn t(): int { return scale_y(100, 5000); }`)
+    expect(files.some(f => f.path.includes('scale_y') || f.path.includes('/t.'))).toBe(true)
+  })
+
+  test('uniform_scale(1000, 15000) = 1500', () => {
+    // 1000 * 15000 / 10000 = 1500
+    const files = compileWith(`@keep fn t(): int { return uniform_scale(1000, 15000); }`)
+    expect(files.some(f => f.path.includes('uniform_scale') || f.path.includes('/t.'))).toBe(true)
+  })
+
+  // ─── 3D rotation ─────────────────────────────────────────────────────────────
+
+  test('rotate_y_x is emitted', () => {
+    const files = compileWith(`@keep fn t(): int { return rotate_y_x(1000, 0, 0); }`)
+    expect(files.some(f => f.path.includes('rotate_y_x'))).toBe(true)
+  })
+
+  test('rotate_y_z is emitted', () => {
+    const files = compileWith(`@keep fn t(): int { return rotate_y_z(1000, 0, 0); }`)
+    expect(files.some(f => f.path.includes('rotate_y_z'))).toBe(true)
+  })
+
+  test('rotate_x_y is emitted', () => {
+    const files = compileWith(`@keep fn t(): int { return rotate_x_y(0, 1000, 0); }`)
+    expect(files.some(f => f.path.includes('rotate_x_y'))).toBe(true)
+  })
+
+  // ─── Quaternion helpers ──────────────────────────────────────────────────────
+
+  test('quat_sin_half is emitted', () => {
+    const files = compileWith(`@keep fn t(): int { return quat_sin_half(1800000); }`)
+    expect(files.some(f => f.path.includes('quat_sin_half'))).toBe(true)
+  })
+
+  test('quat_cos_half is emitted', () => {
+    const files = compileWith(`@keep fn t(): int { return quat_cos_half(0); }`)
+    expect(files.some(f => f.path.includes('quat_cos_half'))).toBe(true)
+  })
+
+  // quat_cos_half(0) = cos_fixed(0 / 20000) = cos_fixed(0) = 1000
+  test('quat_cos_half(0) compiles and references cos_fixed', () => {
+    const files = compileWith(`@keep fn t(): int { return quat_cos_half(0); }`)
+    const allContent = files.map(f => f.content).join('\n')
+    expect(allContent).toContain('cos_fixed')
+  })
+
+  // ─── Billboard ───────────────────────────────────────────────────────────────
+
+  test('billboard_y(900000) = 2700000 (180° offset from 90°)', () => {
+    // (900000 + 1800000) % 3600000 = 2700000
+    const files = compileWith(`@keep fn t(): int { return billboard_y(900000); }`)
+    expect(files.some(f => f.path.includes('billboard_y') || f.path.includes('/t.'))).toBe(true)
+  })
+
+  test('billboard_y(3000000) = 1200000 (wrap around 360°)', () => {
+    // (3000000 + 1800000) % 3600000 = 1200000
+    const files = compileWith(`@keep fn t(): int { return billboard_y(3000000); }`)
+    expect(files.some(f => f.path.includes('billboard_y') || f.path.includes('/t.'))).toBe(true)
+  })
+
+  // ─── Lerp angle ──────────────────────────────────────────────────────────────
+
+  test('lerp_angle is emitted', () => {
+    const files = compileWith(`@keep fn t(): int { return lerp_angle(0, 900000, 5000); }`)
+    expect(files.some(f => f.path.includes('lerp_angle'))).toBe(true)
+  })
+
+  test('lerp_angle(0, 900000, 5000) = 450000 (midpoint of 0°→90°)', () => {
+    // diff = 900000, t=5000, result = 0 + 900000*5000/10000 = 450000
+    const files = compileWith(`@keep fn t(): int { return lerp_angle(0, 900000, 5000); }`)
+    const fn = files.find(f => f.path.endsWith('/t.mcfunction'))
+    expect(fn).toBeDefined()
+    // Should inline constant 450000 or call lerp_angle
+    expect(fn!.content).not.toBe('')
+  })
+})

package/src/__tests__/stdlib/pathfind.test.ts

@@ -0,0 +1,151 @@
+/**
+ * Tests for stdlib/pathfind.mcrs — BFS grid pathfinding.
+ */
+
+import { compile } from '../../emit/compile'
+import * as fs from 'fs'
+import * as path from 'path'
+
+const PF_STDLIB = path.join(__dirname, '../../stdlib/pathfind.mcrs')
+const pfSrc = fs.readFileSync(PF_STDLIB, 'utf-8')
+
+function compileWith(extra: string): { path: string; content: string }[] {
+  const result = compile(pfSrc + '\n' + extra, { namespace: 'test' })
+  return result.files
+}
+
+describe('stdlib/pathfind.mcrs', () => {
+  test('compiles without errors', () => {
+    expect(() => {
+      const result = compile(pfSrc, { namespace: 'test' })
+      expect(result.files.length).toBeGreaterThan(0)
+    }).not.toThrow()
+  })
+
+  test('pf_pack function is emitted', () => {
+    const files = compileWith(`@keep fn t(): int { return pf_pack(3, 7); }`)
+    expect(files.some(f => f.path.includes('pf_pack'))).toBe(true)
+  })
+
+  test('pf_unpack_x function is emitted', () => {
+    const files = compileWith(`@keep fn t(): int { return pf_unpack_x(55); }`)
+    expect(files.some(f => f.path.includes('pf_unpack_x'))).toBe(true)
+  })
+
+  test('pf_unpack_z function is emitted', () => {
+    const files = compileWith(`@keep fn t(): int { return pf_unpack_z(55); }`)
+    expect(files.some(f => f.path.includes('pf_unpack_z'))).toBe(true)
+  })
+
+  test('pf_new_map function is emitted', () => {
+    const files = compileWith(`@keep fn t(): int[] { return pf_new_map(); }`)
+    expect(files.some(f => f.path.includes('pf_new_map'))).toBe(true)
+  })
+
+  test('pf_set_blocked function is emitted', () => {
+    const files = compileWith(`@keep fn t() { let map: int[] = pf_new_map(); pf_set_blocked(map, 3, 5); }`)
+    expect(files.some(f => f.path.includes('pf_set_blocked'))).toBe(true)
+  })
+
+  test('pf_set_open function is emitted', () => {
+    const files = compileWith(`@keep fn t() { let map: int[] = pf_new_map(); pf_set_open(map, 3, 5); }`)
+    expect(files.some(f => f.path.includes('pf_set_open'))).toBe(true)
+  })
+
+  test('pf_is_blocked function is emitted', () => {
+    const files = compileWith(`
+      @keep fn t(): int {
+        let map: int[] = pf_new_map()
+        pf_set_blocked(map, 2, 2)
+        return pf_is_blocked(map, 2, 2)
+      }
+    `)
+    expect(files.some(f => f.path.includes('pf_is_blocked'))).toBe(true)
+  })
+
+  test('pf_heuristic function is emitted', () => {
+    const files = compileWith(`@keep fn t(): int { return pf_heuristic(0, 0, 3, 4); }`)
+    expect(files.some(f => f.path.includes('pf_heuristic'))).toBe(true)
+  })
+
+  test('pathfind_bfs function is emitted', () => {
+    const files = compileWith(`
+      @keep fn t(): int[] {
+        let map: int[] = pf_new_map()
+        return pathfind_bfs(map, 0, 0, 2, 2)
+      }
+    `)
+    expect(files.some(f => f.path.includes('pathfind_bfs'))).toBe(true)
+  })
+
+  test('pf_noop function is emitted', () => {
+    const files = compileWith(`@keep fn t() { pf_noop(); }`)
+    expect(files.some(f => f.path.includes('pf_noop'))).toBe(true)
+  })
+
+  test('pathfind_bfs_coro function is emitted', () => {
+    const files = compileWith(`
+      @keep fn t() {
+        let map: int[] = pf_new_map()
+        let out: int[] = []
+        pathfind_bfs_coro(map, 0, 0, 3, 3, out)
+      }
+    `)
+    expect(files.some(f => f.path.includes('pathfind_bfs_coro'))).toBe(true)
+  })
+
+  test('pf_pack and pf_unpack are inverse operations (compile check)', () => {
+    const files = compileWith(`
+      @keep fn t(): int {
+        let packed: int = pf_pack(5, 9)
+        let x: int = pf_unpack_x(packed)
+        let z: int = pf_unpack_z(packed)
+        return x + z
+      }
+    `)
+    expect(files.length).toBeGreaterThan(0)
+  })
+
+  test('full pathfinding pipeline compiles', () => {
+    const files = compileWith(`
+      @keep fn t(): int[] {
+        let map: int[] = pf_new_map()
+        pf_set_blocked(map, 1, 0)
+        pf_set_blocked(map, 1, 1)
+        pf_set_blocked(map, 1, 2)
+        let path: int[] = pathfind_bfs(map, 0, 0, 2, 0)
+        return path
+      }
+    `)
+    expect(files.length).toBeGreaterThan(0)
+  })
+
+  test('heuristic for same point is zero', () => {
+    const files = compileWith(`
+      @keep fn t(): int {
+        return pf_heuristic(5, 5, 5, 5)
+      }
+    `)
+    expect(files.length).toBeGreaterThan(0)
+  })
+
+  test('pf_is_blocked returns 1 for out-of-bounds (negative)', () => {
+    const files = compileWith(`
+      @keep fn t(): int {
+        let map: int[] = pf_new_map()
+        return pf_is_blocked(map, -1, 0)
+      }
+    `)
+    expect(files.length).toBeGreaterThan(0)
+  })
+
+  test('pf_is_blocked returns 1 for out-of-bounds (≥16)', () => {
+    const files = compileWith(`
+      @keep fn t(): int {
+        let map: int[] = pf_new_map()
+        return pf_is_blocked(map, 16, 0)
+      }
+    `)
+    expect(files.length).toBeGreaterThan(0)
+  })
+})

package/src/__tests__/stdlib/scheduler.test.ts

@@ -0,0 +1,171 @@
+/**
+ * Tests for stdlib/scheduler.mcrs — scoreboard-based task scheduler.
+ * Verifies compilation succeeds and generated mcfunction contains
+ * the correct scoreboard commands.
+ */
+
+import { compile } from '../../emit/compile'
+import * as fs from 'fs'
+import * as path from 'path'
+
+const SCHED_STDLIB = path.join(__dirname, '../../stdlib/scheduler.mcrs')
+const schedSrc = fs.readFileSync(SCHED_STDLIB, 'utf-8')
+
+function compileWith(extra: string): { path: string; content: string }[] {
+  const result = compile(schedSrc + '\n' + extra, { namespace: 'test' })
+  return result.files
+}
+
+function getFn(files: { path: string; content: string }[], fnName: string): string {
+  const f = files.find(f => f.path.endsWith(`/${fnName}.mcfunction`))
+  if (!f) {
+    const paths = files.map(f => f.path).join('\n')
+    throw new Error(`Function '${fnName}' not found. Files:\n${paths}`)
+  }
+  return f.content
+}
+
+describe('stdlib/scheduler.mcrs', () => {
+  // ── Compilation ────────────────────────────────────────────────────────────
+
+  test('compiles without errors', () => {
+    expect(() => {
+      const result = compile(schedSrc, { namespace: 'test' })
+      expect(result.files.length).toBeGreaterThan(0)
+    }).not.toThrow()
+  })
+
+  // ── task_schedule ──────────────────────────────────────────────────────────
+
+  test('task_schedule is emitted', () => {
+    const files = compileWith(`@keep fn t() { task_schedule(@s, 0, 40); }`)
+    expect(files.some(f => f.path.includes('task_schedule'))).toBe(true)
+  })
+
+  test('task_schedule generates scoreboard set command', () => {
+    const files = compileWith(`@keep fn t() { task_schedule(@s, 0, 40); }`)
+    const body = getFn(files, 'task_schedule')
+    expect(body).toContain('scoreboard')
+  })
+
+  test('task_schedule with slot 0 uses rs.t0 objective', () => {
+    const files = compileWith(`@keep fn t() { task_schedule(@s, 0, 40); }`)
+    // The dispatcher branches into leaf functions — check any emitted file references rs.t0
+    const allContent = files.map(f => f.content).join('\n')
+    expect(allContent).toContain('rs.t0')
+  })
+
+  // ── task_cancel ────────────────────────────────────────────────────────────
+
+  test('task_cancel is emitted', () => {
+    const files = compileWith(`@keep fn t() { task_cancel(@s, 0); }`)
+    expect(files.some(f => f.path.includes('task_cancel'))).toBe(true)
+  })
+
+  test('task_cancel generates scoreboard set to 0', () => {
+    const files = compileWith(`@keep fn t() { task_cancel(@s, 0); }`)
+    const body = getFn(files, 'task_cancel')
+    expect(body).toContain('scoreboard')
+  })
+
+  // ── task_ready ─────────────────────────────────────────────────────────────
+
+  test('task_ready is emitted', () => {
+    const files = compileWith(`@keep fn t() -> int { return task_ready(@s, 0); }`)
+    expect(files.some(f => f.path.includes('task_ready'))).toBe(true)
+  })
+
+  test('task_ready reads scoreboard objective', () => {
+    const files = compileWith(`@keep fn t() -> int { return task_ready(@s, 0); }`)
+    const body = getFn(files, 'task_ready')
+    expect(body).toContain('scoreboard')
+  })
+
+  // ── gtask_schedule ─────────────────────────────────────────────────────────
+
+  test('gtask_schedule is emitted', () => {
+    const files = compileWith(`@keep fn t() { gtask_schedule(0, 100); }`)
+    expect(files.some(f => f.path.includes('gtask_schedule'))).toBe(true)
+  })
+
+  test('gtask_schedule uses #rs fake-player and rs.g0 objective', () => {
+    const files = compileWith(`@keep fn t() { gtask_schedule(0, 100); }`)
+    // The dispatcher branches into leaf functions — check across all emitted files
+    const allContent = files.map(f => f.content).join('\n')
+    expect(allContent).toContain('#rs')
+    expect(allContent).toContain('rs.g0')
+  })
+
+  // ── gtask_cancel ───────────────────────────────────────────────────────────
+
+  test('gtask_cancel is emitted', () => {
+    const files = compileWith(`@keep fn t() { gtask_cancel(0); }`)
+    expect(files.some(f => f.path.includes('gtask_cancel'))).toBe(true)
+  })
+
+  // ── gtask_ready ────────────────────────────────────────────────────────────
+
+  test('gtask_ready is emitted', () => {
+    const files = compileWith(`@keep fn t() -> int { return gtask_ready(0); }`)
+    expect(files.some(f => f.path.includes('gtask_ready'))).toBe(true)
+  })
+
+  // ── scheduler_tick ─────────────────────────────────────────────────────────
+
+  test('scheduler_tick is emitted', () => {
+    const files = compileWith(`@keep fn t() { scheduler_tick(); }`)
+    expect(files.some(f => f.path.includes('scheduler_tick'))).toBe(true)
+  })
+
+  test('scheduler_tick decrements per-player slots', () => {
+    const files = compileWith(`@keep fn t() { scheduler_tick(); }`)
+    const body = getFn(files, 'scheduler_tick')
+    expect(body).toContain('rs.t0')
+    expect(body).toContain('scoreboard')
+  })
+
+  test('scheduler_tick decrements global slots', () => {
+    const files = compileWith(`@keep fn t() { scheduler_tick(); }`)
+    const body = getFn(files, 'scheduler_tick')
+    expect(body).toContain('rs.g0')
+    expect(body).toContain('#rs')
+  })
+
+  // ── Combined usage ─────────────────────────────────────────────────────────
+
+  test('schedule and check readiness compiles together', () => {
+    const files = compileWith(`
+      @keep fn setup() {
+        task_schedule(@s, 0, 40);
+        task_schedule(@s, 1, 100);
+        gtask_schedule(0, 200);
+      }
+      @keep fn tick() {
+        scheduler_tick();
+        let r0: int = task_ready(@s, 0);
+        let r1: int = task_ready(@s, 1);
+        let gr0: int = gtask_ready(0);
+        if (r0 == 1) {
+          task_cancel(@s, 1);
+        }
+      }
+    `)
+    expect(files.length).toBeGreaterThan(0)
+  })
+
+  test('all 8 per-player slots compile', () => {
+    const files = compileWith(`
+      @keep fn t() {
+        task_schedule(@s, 0, 10);
+        task_schedule(@s, 1, 20);
+        task_schedule(@s, 2, 30);
+        task_schedule(@s, 3, 40);
+        task_schedule(@s, 4, 50);
+        task_schedule(@s, 5, 60);
+        task_schedule(@s, 6, 70);
+        task_schedule(@s, 7, 80);
+      }
+    `)
+    expect(files.length).toBeGreaterThan(0)
+  })
+})

package/src/__tests__/stdlib/sort-v2.test.ts

@@ -0,0 +1,111 @@
+/**
+ * Tests for stdlib/sort.mcrs — merge_sort_coro (v2 coroutine bottom-up merge sort).
+ */
+
+import { compile } from '../../emit/compile'
+import * as fs from 'fs'
+import * as path from 'path'
+
+const SORT_STDLIB = path.join(__dirname, '../../stdlib/sort.mcrs')
+const sortSrc = fs.readFileSync(SORT_STDLIB, 'utf-8')
+
+function compileWith(extra: string): { path: string; content: string }[] {
+  const result = compile(sortSrc + '\n' + extra, { namespace: 'test' })
+  return result.files
+}
+
+describe('stdlib/sort.mcrs — merge_sort_coro (v2)', () => {
+  test('full stdlib (with merge_sort_coro) compiles without errors', () => {
+    expect(() => {
+      const result = compile(sortSrc, { namespace: 'test' })
+      expect(result.files.length).toBeGreaterThan(0)
+    }).not.toThrow()
+  })
+
+  test('merge_sort_coro function is emitted', () => {
+    const files = compileWith(`@keep fn t() { let arr: int[] = [3, 1, 2]; merge_sort_coro(arr, 3); }`)
+    expect(files.some(f => f.path.includes('merge_sort_coro'))).toBe(true)
+  })
+
+  test('merge_sort_noop function is emitted', () => {
+    const files = compileWith(`@keep fn t() { merge_sort_noop(); }`)
+    expect(files.some(f => f.path.includes('merge_sort_noop'))).toBe(true)
+  })
+
+  test('merge_sort_coro on single-element array compiles', () => {
+    const files = compileWith(`@keep fn t() { let arr: int[] = [42]; merge_sort_coro(arr, 1); }`)
+    expect(files.length).toBeGreaterThan(0)
+  })
+
+  test('merge_sort_coro on two-element array compiles', () => {
+    const files = compileWith(`@keep fn t() { let arr: int[] = [5, 3]; merge_sort_coro(arr, 2); }`)
+    expect(files.length).toBeGreaterThan(0)
+  })
+
+  test('merge_sort_coro on already-sorted array compiles', () => {
+    const files = compileWith(`@keep fn t() { let arr: int[] = [1, 2, 3, 4, 5]; merge_sort_coro(arr, 5); }`)
+    expect(files.length).toBeGreaterThan(0)
+  })
+
+  test('merge_sort_coro on reverse-sorted array compiles', () => {
+    const files = compileWith(`@keep fn t() { let arr: int[] = [5, 4, 3, 2, 1]; merge_sort_coro(arr, 5); }`)
+    expect(files.length).toBeGreaterThan(0)
+  })
+
+  test('merge_sort_coro on power-of-two size compiles', () => {
+    const files = compileWith(`@keep fn t() { let arr: int[] = [8, 3, 6, 1, 7, 2, 5, 4]; merge_sort_coro(arr, 8); }`)
+    expect(files.length).toBeGreaterThan(0)
+  })
+
+  test('merge_sort_coro on odd-length array compiles', () => {
+    const files = compileWith(`@keep fn t() { let arr: int[] = [9, 2, 7, 4, 6]; merge_sort_coro(arr, 5); }`)
+    expect(files.length).toBeGreaterThan(0)
+  })
+
+  test('merge_sort_coro emits @coroutine decorated function output', () => {
+    const files = compileWith(`@keep fn t() { let arr: int[] = [30, 10, 20]; merge_sort_coro(arr, 3); }`)
+    const coroFiles = files.filter(f => f.path.includes('merge_sort_coro'))
+    expect(coroFiles.length).toBeGreaterThan(0)
+    // coroutine functions emit multiple tick-slice files or a scheduler entry
+    const allContent = coroFiles.map(f => f.content).join('\n')
+    expect(allContent.length).toBeGreaterThan(0)
+  })
+
+  test('merge_sort_coro can coexist with insertion_sort in same program', () => {
+    const files = compileWith(`
+      @keep fn t() {
+        let a: int[] = [30, 10, 20]
+        insertion_sort(a, 3)
+        let b: int[] = [9, 1, 5]
+        merge_sort_coro(b, 3)
+      }
+    `)
+    expect(files.some(f => f.path.includes('insertion_sort'))).toBe(true)
+    expect(files.some(f => f.path.includes('merge_sort_coro'))).toBe(true)
+  })
+
+  test('merge_sort_coro can coexist with sort_merge in same program', () => {
+    const files = compileWith(`
+      @keep fn t() {
+        let a: int[] = [3, 1, 2]
+        merge_sort_coro(a, 3)
+        let x: int[] = [10, 30]
+        let y: int[] = [20, 40]
+        let merged: int[] = sort_merge(x, 2, y, 2)
+      }
+    `)
+    expect(files.some(f => f.path.includes('merge_sort_coro'))).toBe(true)
+    expect(files.some(f => f.path.includes('sort_merge'))).toBe(true)
+  })
+
+  test('merge_sort_coro uses n parameter (not hardcoded length)', () => {
+    // Compile with a helper that calls with n < arr.len to ensure n is threaded through
+    const files = compileWith(`
+      @keep fn t() {
+        let arr: int[] = [5, 2, 8, 1, 9, 3]
+        merge_sort_coro(arr, 4)
+      }
+    `)
+    expect(files.length).toBeGreaterThan(0)
+  })
+})

package/src/__tests__/stdlib/sort.test.ts

@@ -0,0 +1,106 @@
+/**
+ * Tests for stdlib/sort.mcrs — insertion sort and merge utilities.
+ */
+
+import { compile } from '../../emit/compile'
+import * as fs from 'fs'
+import * as path from 'path'
+
+const SORT_STDLIB = path.join(__dirname, '../../stdlib/sort.mcrs')
+const sortSrc = fs.readFileSync(SORT_STDLIB, 'utf-8')
+
+function compileWith(extra: string): { path: string; content: string }[] {
+  const result = compile(sortSrc + '\n' + extra, { namespace: 'test' })
+  return result.files
+}
+
+describe('stdlib/sort.mcrs', () => {
+  test('compiles without errors', () => {
+    expect(() => {
+      const result = compile(sortSrc, { namespace: 'test' })
+      expect(result.files.length).toBeGreaterThan(0)
+    }).not.toThrow()
+  })
+
+  test('insertion_sort function is emitted', () => {
+    const files = compileWith(`@keep fn t() { let arr: int[] = [30, 10, 20]; insertion_sort(arr, 3); }`)
+    expect(files.some(f => f.path.includes('insertion_sort'))).toBe(true)
+  })
+
+  test('insertion_sort_desc function is emitted', () => {
+    const files = compileWith(`@keep fn t() { let arr: int[] = [10, 30, 20]; insertion_sort_desc(arr, 3); }`)
+    expect(files.some(f => f.path.includes('insertion_sort_desc'))).toBe(true)
+  })
+
+  test('sort_merge function is emitted', () => {
+    const files = compileWith(`
+      @keep fn t(): int[] {
+        let a: int[] = [10, 30, 50]
+        let b: int[] = [20, 40, 60]
+        return sort_merge(a, 3, b, 3)
+      }
+    `)
+    expect(files.some(f => f.path.includes('sort_merge'))).toBe(true)
+  })
+
+  test('insertion_sort on single element compiles', () => {
+    const files = compileWith(`@keep fn t() { let arr: int[] = [42]; insertion_sort(arr, 1); }`)
+    expect(files.length).toBeGreaterThan(0)
+  })
+
+  test('insertion_sort on two elements compiles', () => {
+    const files = compileWith(`@keep fn t() { let arr: int[] = [5, 3]; insertion_sort(arr, 2); }`)
+    expect(files.length).toBeGreaterThan(0)
+  })
+
+  test('insertion_sort_desc on two elements compiles', () => {
+    const files = compileWith(`@keep fn t() { let arr: int[] = [3, 5]; insertion_sort_desc(arr, 2); }`)
+    expect(files.length).toBeGreaterThan(0)
+  })
+
+  test('sort_merge with empty second array compiles', () => {
+    const files = compileWith(`
+      @keep fn t(): int[] {
+        let a: int[] = [1, 2, 3]
+        let b: int[] = []
+        return sort_merge(a, 3, b, 0)
+      }
+    `)
+    expect(files.length).toBeGreaterThan(0)
+  })
+
+  test('sort_merge result array contains storage operations', () => {
+    const files = compileWith(`
+      @keep fn t(): int[] {
+        let a: int[] = [1, 3]
+        let b: int[] = [2, 4]
+        return sort_merge(a, 2, b, 2)
+      }
+    `)
+    const mergeFile = files.find(f => f.path.includes('sort_merge'))
+    if (mergeFile) {
+      expect(mergeFile.content.length).toBeGreaterThan(0)
+    }
+  })
+
+  test('insertion_sort emit contains index write operations', () => {
+    const files = compileWith(`@keep fn t() { let arr: int[] = [30, 10, 20]; insertion_sort(arr, 3); }`)
+    const sortFile = files.find(f => f.path.includes('insertion_sort') && !f.path.includes('desc'))
+    if (sortFile) {
+      expect(sortFile.content.length).toBeGreaterThan(0)
+    }
+  })
+
+  test('insertion_sort after sort_merge compiles (chaining)', () => {
+    const files = compileWith(`
+      @keep fn t() {
+        let a: int[] = [30, 10]
+        let b: int[] = [25, 5]
+        insertion_sort(a, 2)
+        insertion_sort(b, 2)
+        let merged: int[] = sort_merge(a, 2, b, 2)
+      }
+    `)
+    expect(files.length).toBeGreaterThan(0)
+  })
+})