redscript-mc 1.2.24 → 1.2.26

package/.github/workflows/publish-extension-on-ci.yml

@@ -64,6 +64,7 @@ jobs:
           git config user.email "github-actions[bot]@users.noreply.github.com"
           git add editors/vscode/package.json editors/vscode/package-lock.json
           git commit -m "chore: auto-bump vscode extension to ${NEW_VER} [skip ci]" || echo "Nothing to commit"
+          git pull --rebase origin main || true
           git push
         id: bump
 

package/dist/__tests__/cli.test.js

@@ -176,7 +176,7 @@ describe('CLI API', () => {
             const mainFn = result.files.find(file => file.path.endsWith('/main.mcfunction'));
             expect(doneFn?.content).toContain('scoreboard players get timer_ticks rs');
             expect(doneFn?.content).toContain('return run scoreboard players get');
-            expect(mainFn?.content).toContain('execute if score $finished rs matches 1..');
+            expect(mainFn?.content).toContain('execute if score $main_finished rs matches 1..');
         });
         it('Timer.tick increments', () => {
             const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'redscript-timer-tick-'));

package/dist/__tests__/codegen.test.js

@@ -17,26 +17,32 @@ describe('generateDatapack', () => {
         expect(load?.content).toContain('scoreboard players set $counter rs 0');
     });
     it('generates function file for simple add(a, b)', () => {
+        // IR now uses { kind: 'param', index: i } for param-copy instructions,
+        // matching what the lowering emits.  Pass mangle:false so we can check
+        // readable names without worrying about sequential mangled names.
         const mod = {
             namespace: 'mypack',
             globals: [],
             functions: [{
                     name: 'add',
-                    params: ['a', 'b'],
-                    locals: ['a', 'b', 'result'],
+                    params: ['$a', '$b'],
+                    locals: ['$a', '$b', '$result'],
                     blocks: [{
                             label: 'entry',
                             instrs: [
-                                { op: 'binop', dst: 'result', lhs: { kind: 'var', name: 'a' }, bop: '+', rhs: { kind: 'var', name: 'b' } },
+                                // param-copy instructions (what the lowering now emits)
+                                { op: 'assign', dst: '$a', src: { kind: 'param', index: 0 } },
+                                { op: 'assign', dst: '$b', src: { kind: 'param', index: 1 } },
+                                { op: 'binop', dst: '$result', lhs: { kind: 'var', name: '$a' }, bop: '+', rhs: { kind: 'var', name: '$b' } },
                             ],
-                            term: { op: 'return', value: { kind: 'var', name: 'result' } },
+                            term: { op: 'return', value: { kind: 'var', name: '$result' } },
                         }],
                 }],
         };
-        const files = (0, mcfunction_1.generateDatapack)(mod);
+        const files = (0, mcfunction_1.generateDatapackWithStats)(mod, { mangle: false }).files;
         const fn = files.find(f => f.path.includes('add.mcfunction'));
         expect(fn).toBeDefined();
-        // Should have param setup
+        // param setup emitted from the IR
         expect(fn.content).toContain('scoreboard players operation $a rs = $p0 rs');
         expect(fn.content).toContain('scoreboard players operation $b rs = $p1 rs');
         // Should have add operation

package/dist/__tests__/e2e.test.js

@@ -104,7 +104,7 @@ fn main() {
 `);
             const mainFn = getFunction(files, 'main');
             expect(mainFn).toBeDefined();
-            expect(mainFn).toContain('scoreboard players set $hp rs 105');
+            expect(mainFn).toContain('scoreboard players set $main_hp rs 105');
             expect(mainFn).toContain('Arena Battle');
         });
     });
@@ -1683,7 +1683,7 @@ describe('for-range loop', () => {
         const src = `fn test() { for i in 0..5 { say("hi"); } }`;
         const files = compile(src, 'forloop');
         const fn = getFunction(files, 'test');
-        expect(fn).toContain('scoreboard players set $i rs 0');
+        expect(fn).toContain('scoreboard players set $test_i rs 0');
     });
     it('generates loop sub-function with increment and condition', () => {
         const src = `fn test() { for i in 0..5 { say("hi"); } }`;
@@ -1691,16 +1691,16 @@ describe('for-range loop', () => {
         const subFn = files.find(f => f.path.includes('__for_0'));
         expect(subFn).toBeDefined();
         expect(subFn?.content).toContain('say hi');
-        expect(subFn?.content).toContain('scoreboard players add $i rs 1');
-        expect(subFn?.content).toContain('execute if score $i rs matches ..4 run function forloop:test/__for_0');
+        expect(subFn?.content).toContain('scoreboard players add $test_i rs 1');
+        expect(subFn?.content).toContain('execute if score $test_i rs matches ..4 run function forloop:test/__for_0');
     });
     it('supports non-zero start', () => {
         const src = `fn test() { for x in 3..8 { say("loop"); } }`;
         const files = compile(src, 'forloop2');
         const fn = getFunction(files, 'test');
-        expect(fn).toContain('scoreboard players set $x rs 3');
+        expect(fn).toContain('scoreboard players set $test_x rs 3');
         const subFn = files.find(f => f.path.includes('__for_0'));
-        expect(subFn?.content).toContain('execute if score $x rs matches ..7 run function forloop2:test/__for_0');
+        expect(subFn?.content).toContain('execute if score $test_x rs matches ..7 run function forloop2:test/__for_0');
     });
 });
 // ---------------------------------------------------------------------------

package/dist/__tests__/lowering.test.js

@@ -42,7 +42,7 @@ describe('Lowering', () => {
             const ir = compile('fn foo(x: int) {}');
             const fn = getFunction(ir, 'foo');
             const instrs = getInstructions(fn);
-            expect(instrs.some(i => i.op === 'assign' && i.dst === '$x' && i.src.name === '$p0')).toBe(true);
+            expect(instrs.some(i => i.op === 'assign' && i.dst === '$foo_x' && i.src.kind === 'param' && i.src.index === 0)).toBe(true);
         });
         it('fills in missing default arguments at call sites', () => {
             const ir = compile(`
@@ -124,14 +124,14 @@ fn foo() {
 `);
             const fn = getFunction(ir, 'foo');
             const instrs = getInstructions(fn);
-            expect(instrs.some(i => i.op === 'assign' && i.dst === '$x' && i.src.kind === 'const' && i.src.value === 100)).toBe(true);
+            expect(instrs.some(i => i.op === 'assign' && i.dst === '$foo_x' && i.src.kind === 'const' && i.src.value === 100)).toBe(true);
             expect(ir.globals).not.toContain('$MAX_HP');
         });
         it('lowers let with literal', () => {
             const ir = compile('fn foo() { let x: int = 42; }');
             const fn = getFunction(ir, 'foo');
             const instrs = getInstructions(fn);
-            expect(instrs.some(i => i.op === 'assign' && i.dst === '$x' && i.src.value === 42)).toBe(true);
+            expect(instrs.some(i => i.op === 'assign' && i.dst === '$foo_x' && i.src.value === 42)).toBe(true);
         });
         it('lowers let with expression', () => {
             const ir = compile('fn foo(a: int) { let x: int = a + 1; }');
@@ -496,15 +496,15 @@ fn choose(dir: Direction) {
             const ir = compile('fn test() { let score: int = 7; say("You have ${score} points"); }');
             const fn = getFunction(ir, 'test');
             const rawCmds = getRawCommands(fn);
-            expect(rawCmds).toContain('tellraw @a ["",{"text":"You have "},{"score":{"name":"$score","objective":"rs"}},{"text":" points"}]');
+            expect(rawCmds).toContain('tellraw @a ["",{"text":"You have "},{"score":{"name":"$test_score","objective":"rs"}},{"text":" points"}]');
         });
         it('lowers f-string output builtins to tellraw/title JSON components', () => {
             const ir = compile('fn test() { let score: int = 7; say(f"Score: {score}"); tellraw(@a, f"Score: {score}"); actionbar(@s, f"Score: {score}"); title(@s, f"Score: {score}"); }');
             const fn = getFunction(ir, 'test');
             const rawCmds = getRawCommands(fn);
-            expect(rawCmds).toContain('tellraw @a ["",{"text":"Score: "},{"score":{"name":"$score","objective":"rs"}}]');
-            expect(rawCmds).toContain('title @s actionbar ["",{"text":"Score: "},{"score":{"name":"$score","objective":"rs"}}]');
-            expect(rawCmds).toContain('title @s title ["",{"text":"Score: "},{"score":{"name":"$score","objective":"rs"}}]');
+            expect(rawCmds).toContain('tellraw @a ["",{"text":"Score: "},{"score":{"name":"$test_score","objective":"rs"}}]');
+            expect(rawCmds).toContain('title @s actionbar ["",{"text":"Score: "},{"score":{"name":"$test_score","objective":"rs"}}]');
+            expect(rawCmds).toContain('title @s title ["",{"text":"Score: "},{"score":{"name":"$test_score","objective":"rs"}}]');
         });
         it('lowers summon()', () => {
             const ir = compile('fn test() { summon("zombie"); }');
@@ -987,7 +987,7 @@ fn count_down() {
             const ir = compile('let count: int = 0;\nfn test() { let y: int = count; }');
             const fn = getFunction(ir, 'test');
             const instrs = getInstructions(fn);
-            expect(instrs.some(i => i.op === 'assign' && i.dst === '$y' && i.src.kind === 'var' && i.src.name === '$count')).toBe(true);
+            expect(instrs.some(i => i.op === 'assign' && i.dst === '$test_y' && i.src.kind === 'var' && i.src.name === '$count')).toBe(true);
         });
         it('writes global variable in function body', () => {
             const ir = compile('let count: int = 0;\nfn inc() { count = 5; }');

package/dist/__tests__/optimizer.test.js

@@ -95,6 +95,37 @@ describe('deadCodeElimination', () => {
         expect(opt.blocks[0].instrs[0].dst).toBe('$used_by_raw');
     });
 });
+describe('copyPropagation – stale alias invalidation', () => {
+    it('does not propagate $tmp = $y after $y is overwritten (swap pattern)', () => {
+        // Simulates: let tmp = y; y = x % y; x = tmp
+        // The copy $tmp = $y must be invalidated when $y is reassigned.
+        // Before fix: x = tmp was propagated to x = y (new y, wrong value).
+        const fn = makeFn([
+            { op: 'assign', dst: '$tmp', src: { kind: 'var', name: '$y' } }, // tmp = y
+            { op: 'binop', dst: '$r', lhs: { kind: 'var', name: '$x' }, bop: '%', rhs: { kind: 'var', name: '$y' } }, // r = x%y
+            { op: 'assign', dst: '$y', src: { kind: 'var', name: '$r' } }, // y = r  ← stale: tmp still points to OLD y
+            { op: 'assign', dst: '$x', src: { kind: 'var', name: '$tmp' } }, // x = tmp (should NOT be x = y)
+        ]);
+        const opt = (0, passes_1.copyPropagation)(fn);
+        const instrs = opt.blocks[0].instrs;
+        const xAssign = instrs.find((i) => i.dst === '$x');
+        // x = tmp must NOT be optimised to x = $y (stale) or x = $r (new y).
+        // It should stay as x = $tmp (the original copy).
+        expect(xAssign.src).toEqual({ kind: 'var', name: '$tmp' });
+    });
+    it('still propagates simple non-conflicting copies', () => {
+        // a = 5; b = a; c = b → after propagation b and c should both be const 5
+        const fn = makeFn([
+            { op: 'assign', dst: '$a', src: { kind: 'const', value: 5 } },
+            { op: 'assign', dst: '$b', src: { kind: 'var', name: '$a' } },
+            { op: 'assign', dst: '$c', src: { kind: 'var', name: '$b' } },
+        ]);
+        const opt = (0, passes_1.copyPropagation)(fn);
+        const instrs = opt.blocks[0].instrs;
+        const cAssign = instrs.find((i) => i.dst === '$c');
+        expect(cAssign.src).toEqual({ kind: 'const', value: 5 });
+    });
+});
 describe('optimize pipeline', () => {
     it('combines all passes', () => {
         // t0 = 2 + 3  (→ constant fold → t0 = 5)

package/dist/__tests__/stdlib-advanced.test.d.ts

@@ -0,0 +1,4 @@
+/**
+ * stdlib/advanced.mcrs — runtime behavioural tests
+ */
+export {};

package/dist/__tests__/stdlib-advanced.test.js

@@ -0,0 +1,264 @@
+"use strict";
+/**
+ * stdlib/advanced.mcrs — runtime behavioural tests
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const compile_1 = require("../compile");
+const runtime_1 = require("../runtime");
+const MATH_SRC = fs.readFileSync(path.join(__dirname, '../../src/stdlib/math.mcrs'), 'utf-8');
+const ADV_SRC = fs.readFileSync(path.join(__dirname, '../../src/stdlib/advanced.mcrs'), 'utf-8');
+function run(driver) {
+    const result = (0, compile_1.compile)(driver, {
+        namespace: 'advtest',
+        librarySources: [MATH_SRC, ADV_SRC],
+    });
+    if (!result.success)
+        throw new Error(result.error?.message ?? 'compile failed');
+    const rt = new runtime_1.MCRuntime('advtest');
+    for (const file of result.files ?? []) {
+        if (!file.path.endsWith('.mcfunction'))
+            continue;
+        const match = file.path.match(/data\/([^/]+)\/function\/(.+)\.mcfunction$/);
+        if (!match)
+            continue;
+        rt.loadFunction(`${match[1]}:${match[2]}`, file.content.split('\n'));
+    }
+    rt.load();
+    return rt;
+}
+function scoreOf(rt, key) {
+    return rt.getScore('out', `advtest.${key}`);
+}
+// ─── fib ─────────────────────────────────────────────────────────────────────
+describe('fib', () => {
+    it.each([
+        [0, 0],
+        [1, 1],
+        [2, 1],
+        [5, 5],
+        [10, 55],
+        [20, 6765],
+    ])('fib(%d) == %d', (n, expected) => {
+        const rt = run(`fn test() { scoreboard_set("out", "r", fib(${n})); }`);
+        rt.execFunction('test');
+        expect(scoreOf(rt, 'r')).toBe(expected);
+    });
+});
+// ─── is_prime ─────────────────────────────────────────────────────────────────
+describe('is_prime', () => {
+    it.each([
+        [0, 0], [1, 0], [2, 1], [3, 1], [4, 0],
+        [7, 1], [9, 0], [11, 1], [97, 1], [100, 0],
+    ])('is_prime(%d) == %d', (n, expected) => {
+        const rt = run(`fn test() { scoreboard_set("out", "r", is_prime(${n})); }`);
+        rt.execFunction('test');
+        expect(scoreOf(rt, 'r')).toBe(expected);
+    });
+});
+// ─── collatz_steps ───────────────────────────────────────────────────────────
+describe('collatz_steps', () => {
+    it.each([
+        [1, 0],
+        [2, 1],
+        [4, 2],
+        [6, 8],
+        [27, 111],
+    ])('collatz_steps(%d) == %d', (n, expected) => {
+        const rt = run(`fn test() { scoreboard_set("out", "r", collatz_steps(${n})); }`);
+        rt.execFunction('test');
+        expect(scoreOf(rt, 'r')).toBe(expected);
+    });
+});
+// ─── digit helpers ───────────────────────────────────────────────────────────
+describe('digit_sum', () => {
+    it.each([
+        [0, 0], [1, 1], [9, 9], [123, 6], [999, 27], [-42, 6],
+    ])('digit_sum(%d) == %d', (n, expected) => {
+        const rt = run(`fn test() { scoreboard_set("out", "r", digit_sum(${n})); }`);
+        rt.execFunction('test');
+        expect(scoreOf(rt, 'r')).toBe(expected);
+    });
+});
+describe('count_digits', () => {
+    it.each([
+        [0, 1], [9, 1], [10, 2], [100, 3], [9999, 4],
+    ])('count_digits(%d) == %d', (n, expected) => {
+        const rt = run(`fn test() { scoreboard_set("out", "r", count_digits(${n})); }`);
+        rt.execFunction('test');
+        expect(scoreOf(rt, 'r')).toBe(expected);
+    });
+});
+describe('reverse_int', () => {
+    it.each([
+        [12345, 54321],
+        [100, 1],
+        [7, 7],
+    ])('reverse_int(%d) == %d', (n, expected) => {
+        const rt = run(`fn test() { scoreboard_set("out", "r", reverse_int(${n})); }`);
+        rt.execFunction('test');
+        expect(scoreOf(rt, 'r')).toBe(expected);
+    });
+});
+// ─── mod_pow ─────────────────────────────────────────────────────────────────
+describe('mod_pow', () => {
+    it.each([
+        [2, 10, 1000, 24], // 2^10 = 1024, 1024 mod 1000 = 24
+        [3, 4, 100, 81], // 3^4 = 81
+        [2, 0, 10, 1], // any^0 = 1
+        [5, 1, 100, 5],
+        [7, 3, 13, 343 % 13], // 343 mod 13 = 5
+    ])('mod_pow(%d,%d,%d) == %d', (b, e, m, expected) => {
+        const rt = run(`fn test() { scoreboard_set("out", "r", mod_pow(${b},${e},${m})); }`);
+        rt.execFunction('test');
+        expect(scoreOf(rt, 'r')).toBe(expected);
+    });
+});
+// ─── hash_int ────────────────────────────────────────────────────────────────
+describe('hash_int', () => {
+    it('is deterministic', () => {
+        const rt1 = run(`fn test() { scoreboard_set("out", "r", hash_int(42)); }`);
+        rt1.execFunction('test');
+        const rt2 = run(`fn test() { scoreboard_set("out", "r", hash_int(42)); }`);
+        rt2.execFunction('test');
+        expect(scoreOf(rt1, 'r')).toBe(scoreOf(rt2, 'r'));
+    });
+    it('different inputs → different outputs', () => {
+        const rt = run(`fn test() {
+      scoreboard_set("out", "a", hash_int(0));
+      scoreboard_set("out", "b", hash_int(1));
+      scoreboard_set("out", "c", hash_int(1000));
+    }`);
+        rt.execFunction('test');
+        const a = scoreOf(rt, 'a');
+        const b = scoreOf(rt, 'b');
+        const c = scoreOf(rt, 'c');
+        expect(a).not.toBe(b);
+        expect(b).not.toBe(c);
+    });
+    it('output is non-negative', () => {
+        for (const n of [-1000, -1, 0, 1, 999, 46340]) {
+            const rt = run(`fn test() { scoreboard_set("out", "r", hash_int(${n})); }`);
+            rt.execFunction('test');
+            expect(scoreOf(rt, 'r')).toBeGreaterThanOrEqual(0);
+        }
+    });
+});
+// ─── noise1d ─────────────────────────────────────────────────────────────────
+describe('noise1d', () => {
+    it('output in [0, 999]', () => {
+        for (const x of [0, 100, 500, 999, 1000, 2000]) {
+            const rt = run(`fn test() { scoreboard_set("out", "r", noise1d(${x})); }`);
+            rt.execFunction('test');
+            const v = scoreOf(rt, 'r');
+            expect(v).toBeGreaterThanOrEqual(0);
+            expect(v).toBeLessThan(1000);
+        }
+    });
+    it('is deterministic', () => {
+        const rt1 = run(`fn test() { scoreboard_set("out", "r", noise1d(1234)); }`);
+        rt1.execFunction('test');
+        const rt2 = run(`fn test() { scoreboard_set("out", "r", noise1d(1234)); }`);
+        rt2.execFunction('test');
+        expect(scoreOf(rt1, 'r')).toBe(scoreOf(rt2, 'r'));
+    });
+});
+// ─── bezier ──────────────────────────────────────────────────────────────────
+describe('bezier_quad', () => {
+    it.each([
+        [0, 500, 1000, 0, 0], // t=0: start
+        [0, 500, 1000, 1000, 1000], // t=1000: end
+        [0, 1000, 0, 500, 500], // arch midpoint
+    ])('bezier_quad(%d,%d,%d,t=%d) == %d', (p0, p1, p2, t, expected) => {
+        const rt = run(`fn test() { scoreboard_set("out", "r", bezier_quad(${p0},${p1},${p2},${t})); }`);
+        rt.execFunction('test');
+        expect(scoreOf(rt, 'r')).toBe(expected);
+    });
+});
+describe('bezier_cubic', () => {
+    it('t=0: start', () => {
+        const rt = run(`fn test() { scoreboard_set("out", "r", bezier_cubic(0,333,667,1000,0)); }`);
+        rt.execFunction('test');
+        expect(scoreOf(rt, 'r')).toBe(0);
+    });
+    it('t=1000: end', () => {
+        const rt = run(`fn test() { scoreboard_set("out", "r", bezier_cubic(0,333,667,1000,1000)); }`);
+        rt.execFunction('test');
+        expect(scoreOf(rt, 'r')).toBe(1000);
+    });
+});
+// ─── mandelbrot_iter ─────────────────────────────────────────────────────────
+describe('mandelbrot_iter', () => {
+    // c = 0 + 0i → always in set (z always 0)
+    it('origin (0,0) stays bounded for max_iter=20', () => {
+        const rt = run(`fn test() { scoreboard_set("out", "r", mandelbrot_iter(0,0,20)); }`);
+        rt.execFunction('test');
+        expect(scoreOf(rt, 'r')).toBe(20);
+    });
+    // c = 2 + 0i → escapes immediately (|z1| = 2, |z2| = 6 > 2)
+    it('c=(2000,0) escapes quickly', () => {
+        const rt = run(`fn test() { scoreboard_set("out", "r", mandelbrot_iter(2000,0,50)); }`);
+        rt.execFunction('test');
+        expect(scoreOf(rt, 'r')).toBeLessThan(5);
+    });
+    // c = -1 + 0i → stays bounded (period-2 cycle: 0 → -1 → 0 → ...)
+    it('c=(-1000,0) is in the set', () => {
+        const rt = run(`fn test() { scoreboard_set("out", "r", mandelbrot_iter(-1000,0,50)); }`);
+        rt.execFunction('test');
+        expect(scoreOf(rt, 'r')).toBe(50);
+    });
+    // c = 0.5 + 0.5i → escapes
+    it('c=(500,500) escapes before max_iter=100', () => {
+        const rt = run(`fn test() { scoreboard_set("out", "r", mandelbrot_iter(500,500,100)); }`);
+        rt.execFunction('test');
+        expect(scoreOf(rt, 'r')).toBeLessThan(100);
+    });
+});
+// ─── julia_iter ──────────────────────────────────────────────────────────────
+describe('julia_iter', () => {
+    it('z0=(0,0) with c=(0,0) stays bounded', () => {
+        const rt = run(`fn test() { scoreboard_set("out", "r", julia_iter(0,0,0,0,20)); }`);
+        rt.execFunction('test');
+        expect(scoreOf(rt, 'r')).toBe(20);
+    });
+    it('z0=(3000,0) escapes immediately', () => {
+        const rt = run(`fn test() { scoreboard_set("out", "r", julia_iter(3000,0,0,0,20)); }`);
+        rt.execFunction('test');
+        expect(scoreOf(rt, 'r')).toBe(0);
+    });
+});
+//# sourceMappingURL=stdlib-advanced.test.js.map

package/dist/__tests__/stdlib-math.test.d.ts

@@ -0,0 +1,7 @@
+/**
+ * stdlib/math.mcrs — Runtime behavioural tests
+ *
+ * Each test compiles the math stdlib together with a small driver function,
+ * runs it through MCRuntime, and checks scoreboard values.
+ */
+export {};