redscript-mc 2.4.1 → 2.6.0

package/dist/src/__tests__/optimizer/constant_fold.test.js

@@ -128,4 +128,109 @@ describe('constant folding', () => {
         expect(result.blocks[0].instrs[0].kind).toBe('add');
     });
 });
+describe('constant folding — int32 wrap (MC scoreboard semantics)', () => {
+    const INT32_MAX = 2147483647;
+    const INT32_MIN = -2147483648;
+    // add overflow
+    test('add(INT32_MAX, 1) wraps to INT32_MIN', () => {
+        const fn = mkFn([
+            mkBlock('entry', [
+                { kind: 'add', dst: 't0', a: c(INT32_MAX), b: c(1) },
+            ], { kind: 'return', value: t('t0') }),
+        ]);
+        const result = (0, constant_fold_1.constantFold)(fn);
+        expect(result.blocks[0].instrs[0]).toEqual({ kind: 'const', dst: 't0', value: INT32_MIN });
+    });
+    test('add(INT32_MIN, -1) wraps to INT32_MAX', () => {
+        const fn = mkFn([
+            mkBlock('entry', [
+                { kind: 'add', dst: 't0', a: c(INT32_MIN), b: c(-1) },
+            ], { kind: 'return', value: t('t0') }),
+        ]);
+        const result = (0, constant_fold_1.constantFold)(fn);
+        expect(result.blocks[0].instrs[0]).toEqual({ kind: 'const', dst: 't0', value: INT32_MAX });
+    });
+    // sub overflow
+    test('sub(INT32_MIN, 1) wraps to INT32_MAX', () => {
+        const fn = mkFn([
+            mkBlock('entry', [
+                { kind: 'sub', dst: 't0', a: c(INT32_MIN), b: c(1) },
+            ], { kind: 'return', value: t('t0') }),
+        ]);
+        const result = (0, constant_fold_1.constantFold)(fn);
+        expect(result.blocks[0].instrs[0]).toEqual({ kind: 'const', dst: 't0', value: INT32_MAX });
+    });
+    // mul overflow — the original motivating bug
+    test('mul(12345, 1664525) wraps correctly (LCG first step)', () => {
+        // 12345 * 1664525 = 20548561125, int32 = -926275355 (via | 0 in JS)
+        const expected = (12345 * 1664525) | 0;
+        const fn = mkFn([
+            mkBlock('entry', [
+                { kind: 'mul', dst: 't0', a: c(12345), b: c(1664525) },
+            ], { kind: 'return', value: t('t0') }),
+        ]);
+        const result = (0, constant_fold_1.constantFold)(fn);
+        expect(result.blocks[0].instrs[0]).toEqual({ kind: 'const', dst: 't0', value: expected });
+        expect(expected).toBe(-926275355);
+    });
+    test('add after mul wrap matches MC LCG result (next_lcg(12345))', () => {
+        // next_lcg(12345) = 12345 * 1664525 + 1013904223, both steps int32 wrapped
+        const mulWrapped = (12345 * 1664525) | 0; // -926275355
+        const expected = (mulWrapped + 1013904223) | 0; // 87628868
+        const fn = mkFn([
+            mkBlock('entry', [
+                { kind: 'mul', dst: 't0', a: c(12345), b: c(1664525) },
+                { kind: 'add', dst: 't1', a: t('t0'), b: c(1013904223) },
+            ], { kind: 'return', value: t('t1') }),
+        ]);
+        const result = (0, constant_fold_1.constantFold)(fn);
+        // t0 gets folded first (mul), then if t1 uses folded t0 it gets folded too
+        // (constant folding runs on instructions in order, substituting as it goes)
+        const t0instr = result.blocks[0].instrs[0];
+        expect(t0instr).toEqual({ kind: 'const', dst: 't0', value: -926275355 });
+        // Note: t1 can't be folded in one pass because a.kind = 'temp' after substitution
+        // unless the folder propagates. Just verify t0 wrap is correct.
+        expect(expected).toBe(87628868);
+    });
+    // neg overflow
+    test('neg(INT32_MIN) wraps to INT32_MIN (unrepresentable positive)', () => {
+        // -INT32_MIN = 2147483648 which overflows int32 back to INT32_MIN
+        const fn = mkFn([
+            mkBlock('entry', [
+                { kind: 'neg', dst: 't0', src: c(INT32_MIN) },
+            ], { kind: 'return', value: t('t0') }),
+        ]);
+        const result = (0, constant_fold_1.constantFold)(fn);
+        expect(result.blocks[0].instrs[0]).toEqual({ kind: 'const', dst: 't0', value: INT32_MIN });
+    });
+    // div — no overflow possible in int32 except INT32_MIN / -1
+    test('div(INT32_MIN, -1) wraps to INT32_MIN', () => {
+        const fn = mkFn([
+            mkBlock('entry', [
+                { kind: 'div', dst: 't0', a: c(INT32_MIN), b: c(-1) },
+            ], { kind: 'return', value: t('t0') }),
+        ]);
+        const result = (0, constant_fold_1.constantFold)(fn);
+        expect(result.blocks[0].instrs[0]).toEqual({ kind: 'const', dst: 't0', value: INT32_MIN });
+    });
+    // No wrap needed for small values
+    test('add(3, 4) = 7 (no wrap)', () => {
+        const fn = mkFn([
+            mkBlock('entry', [
+                { kind: 'add', dst: 't0', a: c(3), b: c(4) },
+            ], { kind: 'return', value: t('t0') }),
+        ]);
+        const result = (0, constant_fold_1.constantFold)(fn);
+        expect(result.blocks[0].instrs[0]).toEqual({ kind: 'const', dst: 't0', value: 7 });
+    });
+    test('sub(10, 3) = 7 (no wrap)', () => {
+        const fn = mkFn([
+            mkBlock('entry', [
+                { kind: 'sub', dst: 't0', a: c(10), b: c(3) },
+            ], { kind: 'return', value: t('t0') }),
+        ]);
+        const result = (0, constant_fold_1.constantFold)(fn);
+        expect(result.blocks[0].instrs[0]).toEqual({ kind: 'const', dst: 't0', value: 7 });
+    });
+});
 //# sourceMappingURL=constant_fold.test.js.map

package/dist/src/__tests__/optimizer/coroutine.test.js

@@ -80,9 +80,10 @@ describe('coroutine transform', () => {
             const result = (0, coroutine_1.coroutineTransform)(mod, [info]);
             const initFn = result.module.functions.find(f => f.name === 'process_all');
             expect(initFn).toBeDefined();
-            // Init function should have a const instruction setting pc = 1
+            // Init function should have a score_write instruction setting pc = 1
+            // (score_write is used instead of const so DCE cannot eliminate it)
             const allInstrs = initFn.blocks.flatMap(b => b.instrs);
-            const pcSet = allInstrs.find(i => i.kind === 'const' && i.dst.includes('_pc') && i.value === 1);
+            const pcSet = allInstrs.find(i => i.kind === 'score_write' && i.player.includes('_pc') && i.src.kind === 'const' && i.src.value === 1);
             expect(pcSet).toBeDefined();
         });
         test('init function ends with return', () => {

package/dist/src/__tests__/optimizer/lir/peephole.test.js

@@ -123,4 +123,96 @@ describe('execute store peephole', () => {
         expect(result).toBe(fn);
     });
 });
+describe('execute store success peephole (cmp pattern)', () => {
+    test('merges score_set(0) + raw execute-set-1 into execute store success', () => {
+        const fn = mkFn([
+            { kind: 'score_set', dst: mkSlot('$flag'), value: 0 },
+            { kind: 'raw', cmd: `execute if score $a ${obj} > $b ${obj} run scoreboard players set $flag ${obj} 1` },
+        ]);
+        const result = (0, peephole_1.execStorePeephole)(fn);
+        expect(result.instructions).toHaveLength(1);
+        expect(result.instructions[0]).toEqual({
+            kind: 'raw',
+            cmd: `execute store success score $flag ${obj} if score $a ${obj} > $b ${obj}`,
+        });
+    });
+    test('merges with "unless" condition', () => {
+        const fn = mkFn([
+            { kind: 'score_set', dst: mkSlot('$ne_flag'), value: 0 },
+            { kind: 'raw', cmd: `execute unless score $x ${obj} = $y ${obj} run scoreboard players set $ne_flag ${obj} 1` },
+        ]);
+        const result = (0, peephole_1.execStorePeephole)(fn);
+        expect(result.instructions).toHaveLength(1);
+        expect(result.instructions[0]).toEqual({
+            kind: 'raw',
+            cmd: `execute store success score $ne_flag ${obj} unless score $x ${obj} = $y ${obj}`,
+        });
+    });
+    test('does not merge when players do not match', () => {
+        const fn = mkFn([
+            { kind: 'score_set', dst: mkSlot('$a'), value: 0 },
+            { kind: 'raw', cmd: `execute if score $x ${obj} > $y ${obj} run scoreboard players set $b ${obj} 1` },
+        ]);
+        const result = (0, peephole_1.execStorePeephole)(fn);
+        expect(result.instructions).toHaveLength(2);
+        expect(result).toBe(fn);
+    });
+    test('does not merge when objectives do not match', () => {
+        const fn = mkFn([
+            { kind: 'score_set', dst: mkSlot('$flag'), value: 0 },
+            { kind: 'raw', cmd: `execute if score $a other_obj > $b other_obj run scoreboard players set $flag other_obj 1` },
+        ]);
+        const result = (0, peephole_1.execStorePeephole)(fn);
+        // objectives differ between score_set (obj=__test) and raw (other_obj)
+        expect(result.instructions).toHaveLength(2);
+        expect(result).toBe(fn);
+    });
+    test('does not merge score_set(1) + raw execute-set-1 (value must be 0)', () => {
+        const fn = mkFn([
+            { kind: 'score_set', dst: mkSlot('$flag'), value: 1 },
+            { kind: 'raw', cmd: `execute if score $a ${obj} > $b ${obj} run scoreboard players set $flag ${obj} 1` },
+        ]);
+        const result = (0, peephole_1.execStorePeephole)(fn);
+        expect(result.instructions).toHaveLength(2);
+        expect(result).toBe(fn);
+    });
+    test('does not merge when there is an instruction between them', () => {
+        const fn = mkFn([
+            { kind: 'score_set', dst: mkSlot('$flag'), value: 0 },
+            { kind: 'call', fn: 'ns:other' },
+            { kind: 'raw', cmd: `execute if score $a ${obj} > $b ${obj} run scoreboard players set $flag ${obj} 1` },
+        ]);
+        const result = (0, peephole_1.execStorePeephole)(fn);
+        expect(result.instructions).toHaveLength(3);
+    });
+    test('merges multiple adjacent cmp patterns', () => {
+        const fn = mkFn([
+            { kind: 'score_set', dst: mkSlot('$r1'), value: 0 },
+            { kind: 'raw', cmd: `execute if score $a ${obj} > $b ${obj} run scoreboard players set $r1 ${obj} 1` },
+            { kind: 'score_set', dst: mkSlot('$r2'), value: 0 },
+            { kind: 'raw', cmd: `execute if score $c ${obj} < $d ${obj} run scoreboard players set $r2 ${obj} 1` },
+        ]);
+        const result = (0, peephole_1.execStorePeephole)(fn);
+        expect(result.instructions).toHaveLength(2);
+        expect(result.instructions[0]).toEqual({
+            kind: 'raw',
+            cmd: `execute store success score $r1 ${obj} if score $a ${obj} > $b ${obj}`,
+        });
+        expect(result.instructions[1]).toEqual({
+            kind: 'raw',
+            cmd: `execute store success score $r2 ${obj} if score $c ${obj} < $d ${obj}`,
+        });
+    });
+    test('5 cmp patterns: saves exactly 5 commands', () => {
+        const instrs = [];
+        for (let k = 1; k <= 5; k++) {
+            instrs.push({ kind: 'score_set', dst: mkSlot(`$r${k}`), value: 0 });
+            instrs.push({ kind: 'raw', cmd: `execute if score $a ${obj} > $b ${obj} run scoreboard players set $r${k} ${obj} 1` });
+        }
+        const fn = mkFn(instrs);
+        expect(fn.instructions).toHaveLength(10);
+        const result = (0, peephole_1.execStorePeephole)(fn);
+        expect(result.instructions).toHaveLength(5);
+    });
+});
 //# sourceMappingURL=peephole.test.js.map

package/dist/src/__tests__/parser.test.js

@@ -100,12 +100,12 @@ describe('Parser', () => {
     });
     describe('types', () => {
         it('parses primitive types', () => {
-            const program = parse('fn f(a: int, b: bool, c: float, d: string) {}');
+            const program = parse('fn f(a: int, b: bool, c: fixed, d: string) {}');
             const params = program.declarations[0].params;
             expect(params.map(p => p.type)).toEqual([
                 { kind: 'named', name: 'int' },
                 { kind: 'named', name: 'bool' },
-                { kind: 'named', name: 'float' },
+                { kind: 'named', name: 'fixed' },
                 { kind: 'named', name: 'string' },
             ]);
         });

package/dist/src/__tests__/stdlib/calculus.test.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Tests for stdlib/calculus.mcrs functions.
+ * Verifies compilation succeeds and key functions are present/emitted.
+ */
+export {};

package/dist/src/__tests__/stdlib/calculus.test.js

@@ -0,0 +1,123 @@
+"use strict";
+/**
+ * Tests for stdlib/calculus.mcrs functions.
+ * Verifies compilation succeeds and key functions are present/emitted.
+ */
+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 compile_1 = require("../../emit/compile");
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const CALCULUS_STDLIB = path.join(__dirname, '../../stdlib/calculus.mcrs');
+const calculusSrc = fs.readFileSync(CALCULUS_STDLIB, 'utf-8');
+function compileWith(extra) {
+    const result = (0, compile_1.compile)(calculusSrc + '\n' + extra, { namespace: 'test' });
+    return result.files;
+}
+describe('stdlib/calculus.mcrs', () => {
+    test('compiles without errors', () => {
+        expect(() => {
+            const result = (0, compile_1.compile)(calculusSrc, { namespace: 'test' });
+            expect(result.files.length).toBeGreaterThan(0);
+        }).not.toThrow();
+    });
+    test('integrate_trapezoid function is emitted', () => {
+        const files = compileWith(`
+      @keep fn t(): int {
+        let vals: int[] = [0, 5000, 10000];
+        return integrate_trapezoid(vals, 3, 10000);
+      }
+    `);
+        expect(files.some(f => f.path.includes('integrate_trapezoid'))).toBe(true);
+    });
+    test('integrate_simpson function is emitted', () => {
+        const files = compileWith(`
+      @keep fn t(): int {
+        let vals: int[] = [0, 5000, 10000];
+        return integrate_simpson(vals, 3, 10000);
+      }
+    `);
+        expect(files.some(f => f.path.includes('integrate_simpson'))).toBe(true);
+    });
+    test('curve_length_2d function is emitted', () => {
+        const files = compileWith(`
+      @keep fn t(): int {
+        let xs: int[] = [0, 3000, 6000];
+        let ys: int[] = [0, 4000, 0];
+        return curve_length_2d(xs, ys, 3);
+      }
+    `);
+        expect(files.some(f => f.path.includes('curve_length_2d'))).toBe(true);
+    });
+    test('running_mean function is emitted', () => {
+        const files = compileWith(`
+      @keep fn t(): int {
+        return running_mean(5000, 7000, 2);
+      }
+    `);
+        expect(files.some(f => f.path.includes('running_mean'))).toBe(true);
+    });
+    test('deriv_forward function is emitted', () => {
+        const files = compileWith(`
+      @keep fn t(): int {
+        return deriv_forward(20000, 10000, 10000);
+      }
+    `);
+        expect(files.some(f => f.path.includes('deriv_forward'))).toBe(true);
+    });
+    test('deriv_central function is emitted', () => {
+        const files = compileWith(`
+      @keep fn t(): int {
+        return deriv_central(20000, 0, 10000);
+      }
+    `);
+        expect(files.some(f => f.path.includes('deriv_central'))).toBe(true);
+    });
+    test('second_deriv function is emitted', () => {
+        const files = compileWith(`
+      @keep fn t(): int {
+        return second_deriv(10000, 5000, 0, 10000);
+      }
+    `);
+        expect(files.some(f => f.path.includes('second_deriv'))).toBe(true);
+    });
+    test('running_mean formula: (5000*(2-1) + 7000) / 2 = 6000', () => {
+        // running_mean(prev, new_val, n) = prev + (new_val - prev) / n
+        // running_mean(5000, 7000, 2) = 5000 + (7000-5000)/2 = 6000
+        const files = compileWith(`@keep fn t(): int { return running_mean(5000, 7000, 2); }`);
+        expect(files.length).toBeGreaterThan(0);
+    });
+});
+//# sourceMappingURL=calculus.test.js.map

package/dist/src/__tests__/stdlib/easing.test.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Tests for stdlib/easing.mcrs functions.
+ * Verifies easing function boundary values via MCRuntime.
+ */
+export {};

package/dist/src/__tests__/stdlib/easing.test.js

@@ -0,0 +1,117 @@
+"use strict";
+/**
+ * Tests for stdlib/easing.mcrs functions.
+ * Verifies easing function boundary values via MCRuntime.
+ */
+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("../../emit/compile");
+const runtime_1 = require("../../runtime");
+const NS = 'test';
+const OBJ = `__${NS}`;
+const MATH_SRC = fs.readFileSync(path.join(__dirname, '../../stdlib/math.mcrs'), 'utf-8');
+const EASING_SRC = fs.readFileSync(path.join(__dirname, '../../stdlib/easing.mcrs'), 'utf-8');
+function makeEasingRuntime(source) {
+    const result = (0, compile_1.compile)(source, {
+        namespace: NS,
+        librarySources: [MATH_SRC, EASING_SRC],
+    });
+    const rt = new runtime_1.MCRuntime(NS);
+    for (const file of result.files) {
+        if (!file.path.endsWith('.mcfunction'))
+            continue;
+        const m = file.path.match(/data\/([^/]+)\/function\/(.+)\.mcfunction$/);
+        if (!m)
+            continue;
+        rt.loadFunction(`${m[1]}:${m[2]}`, file.content.split('\n'));
+    }
+    rt.execFunction(`${NS}:load`);
+    return rt;
+}
+function callAndGetRet(rt, fnName) {
+    rt.execFunction(`${NS}:${fnName}`);
+    return rt.getScore('$ret', OBJ);
+}
+describe('stdlib/easing.mcrs — boundary values', () => {
+    const rt = makeEasingRuntime(`
+    fn test_ease_linear_0(): int { return ease_linear(0); }
+    fn test_ease_linear_10000(): int { return ease_linear(10000); }
+    fn test_ease_in_quad_5000(): int { return ease_in_quad(5000); }
+    fn test_ease_out_quad_5000(): int { return ease_out_quad(5000); }
+    fn test_ease_out_bounce_0(): int { return ease_out_bounce(0); }
+    fn test_ease_out_bounce_10000(): int { return ease_out_bounce(10000); }
+    fn test_ease_in_quad_0(): int { return ease_in_quad(0); }
+    fn test_ease_in_quad_10000(): int { return ease_in_quad(10000); }
+    fn test_ease_out_quad_0(): int { return ease_out_quad(0); }
+    fn test_ease_out_quad_10000(): int { return ease_out_quad(10000); }
+    fn test_ease_in_cubic_0(): int { return ease_in_cubic(0); }
+    fn test_ease_in_cubic_10000(): int { return ease_in_cubic(10000); }
+    fn test_ease_out_cubic_0(): int { return ease_out_cubic(0); }
+    fn test_ease_out_cubic_10000(): int { return ease_out_cubic(10000); }
+    fn test_ease_in_out_quad_0(): int { return ease_in_out_quad(0); }
+    fn test_ease_in_out_quad_10000(): int { return ease_in_out_quad(10000); }
+    fn test_ease_in_bounce_0(): int { return ease_in_bounce(0); }
+    fn test_ease_in_bounce_10000(): int { return ease_in_bounce(10000); }
+  `);
+    // Linear
+    test('ease_linear(0) == 0', () => expect(callAndGetRet(rt, 'test_ease_linear_0')).toBe(0));
+    test('ease_linear(10000) == 10000', () => expect(callAndGetRet(rt, 'test_ease_linear_10000')).toBe(10000));
+    // Quadratic in
+    test('ease_in_quad(0) == 0', () => expect(callAndGetRet(rt, 'test_ease_in_quad_0')).toBe(0));
+    test('ease_in_quad(10000) == 10000', () => expect(callAndGetRet(rt, 'test_ease_in_quad_10000')).toBe(10000));
+    // ease_in_quad(5000) = 5000²/10000 = 25000000/10000 = 2500
+    test('ease_in_quad(5000) == 2500', () => expect(callAndGetRet(rt, 'test_ease_in_quad_5000')).toBe(2500));
+    // Quadratic out
+    test('ease_out_quad(0) == 0', () => expect(callAndGetRet(rt, 'test_ease_out_quad_0')).toBe(0));
+    test('ease_out_quad(10000) == 10000', () => expect(callAndGetRet(rt, 'test_ease_out_quad_10000')).toBe(10000));
+    // ease_out_quad(5000) = 10000 - 5000²/10000 = 10000 - 2500 = 7500
+    test('ease_out_quad(5000) == 7500', () => expect(callAndGetRet(rt, 'test_ease_out_quad_5000')).toBe(7500));
+    // Cubic
+    test('ease_in_cubic(0) == 0', () => expect(callAndGetRet(rt, 'test_ease_in_cubic_0')).toBe(0));
+    test('ease_in_cubic(10000) == 10000', () => expect(callAndGetRet(rt, 'test_ease_in_cubic_10000')).toBe(10000));
+    test('ease_out_cubic(0) == 0', () => expect(callAndGetRet(rt, 'test_ease_out_cubic_0')).toBe(0));
+    test('ease_out_cubic(10000) == 10000', () => expect(callAndGetRet(rt, 'test_ease_out_cubic_10000')).toBe(10000));
+    // In-out quad
+    test('ease_in_out_quad(0) == 0', () => expect(callAndGetRet(rt, 'test_ease_in_out_quad_0')).toBe(0));
+    test('ease_in_out_quad(10000) == 10000', () => expect(callAndGetRet(rt, 'test_ease_in_out_quad_10000')).toBe(10000));
+    // Bounce boundary values
+    test('ease_out_bounce(0) == 0', () => expect(callAndGetRet(rt, 'test_ease_out_bounce_0')).toBe(0));
+    test('ease_out_bounce(10000) == 10000', () => expect(callAndGetRet(rt, 'test_ease_out_bounce_10000')).toBe(10000));
+    test('ease_in_bounce(0) == 0', () => expect(callAndGetRet(rt, 'test_ease_in_bounce_0')).toBe(0));
+    test('ease_in_bounce(10000) == 10000', () => expect(callAndGetRet(rt, 'test_ease_in_bounce_10000')).toBe(10000));
+});
+//# sourceMappingURL=easing.test.js.map

package/dist/src/__tests__/stdlib/geometry.test.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Tests for stdlib/geometry.mcrs selector helpers.
+ * in_cylinder, in_cone, in_sector_2d
+ */
+export {};

package/dist/src/__tests__/stdlib/geometry.test.js

@@ -0,0 +1,163 @@
+"use strict";
+/**
+ * Tests for stdlib/geometry.mcrs selector helpers.
+ * in_cylinder, in_cone, in_sector_2d
+ */
+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("../../emit/compile");
+const runtime_1 = require("../../runtime");
+const NS = 'test';
+const OBJ = `__${NS}`;
+const MATH_SRC = fs.readFileSync(path.join(__dirname, '../../stdlib/math.mcrs'), 'utf-8');
+const VEC_SRC = fs.readFileSync(path.join(__dirname, '../../stdlib/vec.mcrs'), 'utf-8');
+const GEOM_SRC = fs.readFileSync(path.join(__dirname, '../../stdlib/geometry.mcrs'), 'utf-8');
+function makeRuntime(source) {
+    const result = (0, compile_1.compile)(source, {
+        namespace: NS,
+        librarySources: [MATH_SRC, VEC_SRC, GEOM_SRC],
+    });
+    const rt = new runtime_1.MCRuntime(NS);
+    for (const file of result.files) {
+        if (!file.path.endsWith('.mcfunction'))
+            continue;
+        const m = file.path.match(/data\/([^/]+)\/function\/(.+)\.mcfunction$/);
+        if (!m)
+            continue;
+        rt.loadFunction(`${m[1]}:${m[2]}`, file.content.split('\n'));
+    }
+    if (result.files.some(f => f.path.includes('/load.mcfunction'))) {
+        rt.execFunction(`${NS}:load`);
+    }
+    return rt;
+}
+function callAndGetRet(rt, fnName) {
+    rt.execFunction(`${NS}:${fnName}`);
+    return rt.getScore('$ret', OBJ);
+}
+// ─── in_cylinder ─────────────────────────────────────────────────────────────
+describe('in_cylinder', () => {
+    const rt = makeRuntime(`
+    // point at origin, cylinder centre (0,0), r=20000, y=[0,10000]
+    fn test_cyl_inside(): int {
+      return in_cylinder(0, 0, 0, 0, 0, 20000, 0, 10000);
+    }
+    // point at (30000,0,0) — outside radius
+    fn test_cyl_outside_r(): int {
+      return in_cylinder(30000, 0, 0, 0, 0, 20000, 0, 10000);
+    }
+    // point inside radius but below y_lo
+    fn test_cyl_outside_y_lo(): int {
+      return in_cylinder(0, -1, 0, 0, 0, 20000, 0, 10000);
+    }
+    // point inside radius but above y_hi
+    fn test_cyl_outside_y_hi(): int {
+      return in_cylinder(0, 20000, 0, 0, 0, 20000, 0, 10000);
+    }
+    // point on the rim (r == radius)
+    fn test_cyl_on_rim(): int {
+      return in_cylinder(20000, 5000, 0, 0, 0, 20000, 0, 10000);
+    }
+  `);
+    test('point at origin inside cylinder → 1', () => expect(callAndGetRet(rt, 'test_cyl_inside')).toBe(1));
+    test('point at (30000,0,0) outside radius → 0', () => expect(callAndGetRet(rt, 'test_cyl_outside_r')).toBe(0));
+    test('point below y_lo → 0', () => expect(callAndGetRet(rt, 'test_cyl_outside_y_lo')).toBe(0));
+    test('point above y_hi → 0', () => expect(callAndGetRet(rt, 'test_cyl_outside_y_hi')).toBe(0));
+    test('point on rim (dist == radius) → 1', () => expect(callAndGetRet(rt, 'test_cyl_on_rim')).toBe(1));
+});
+// ─── in_cone ─────────────────────────────────────────────────────────────────
+describe('in_cone', () => {
+    // 45° half-angle: half_angle_tan = 10000 (tan 45° = 1.0 × 10000)
+    // Point directly above apex at dy=5000 → horizontal dist = 0, threshold = 5000 → inside
+    // Point to the side at (apex_x+3000, apex_y+4000, apex_z): dy=4000, threshold=4000, horiz=3000 → inside
+    // Point outside angle: (apex_x+6000, apex_y+4000, apex_z): dy=4000, threshold=4000, horiz=6000 → outside
+    const rt = makeRuntime(`
+    // directly above apex, half_angle_tan=10000 (45°), height=10000
+    fn test_cone_above(): int {
+      return in_cone(0, 5000, 0,  0, 0, 0,  1, 10000, 10000);
+    }
+    // inside cone: dx=3000, dy=4000, dz=0 → horiz=3000, threshold=4000
+    fn test_cone_inside(): int {
+      return in_cone(3000, 4000, 0,  0, 0, 0,  1, 10000, 10000);
+    }
+    // outside cone: dx=6000, dy=4000, dz=0 → horiz=6000, threshold=4000
+    fn test_cone_outside(): int {
+      return in_cone(6000, 4000, 0,  0, 0, 0,  1, 10000, 10000);
+    }
+    // below apex (dir_y=1 means upward cone, dy<0 is outside)
+    fn test_cone_below(): int {
+      return in_cone(0, -1, 0,  0, 0, 0,  1, 10000, 10000);
+    }
+    // above height limit
+    fn test_cone_over_height(): int {
+      return in_cone(0, 20000, 0,  0, 0, 0,  1, 10000, 10000);
+    }
+  `);
+    test('point directly above apex → 1', () => expect(callAndGetRet(rt, 'test_cone_above')).toBe(1));
+    test('point inside cone angle → 1', () => expect(callAndGetRet(rt, 'test_cone_inside')).toBe(1));
+    test('point outside cone angle → 0', () => expect(callAndGetRet(rt, 'test_cone_outside')).toBe(0));
+    test('point below apex (upward cone) → 0', () => expect(callAndGetRet(rt, 'test_cone_below')).toBe(0));
+    test('point above height limit → 0', () => expect(callAndGetRet(rt, 'test_cone_over_height')).toBe(0));
+});
+// ─── in_sector_2d ─────────────────────────────────────────────────────────────
+describe('in_sector_2d', () => {
+    // dir_angle = 0 (pointing along +X), half_angle = 157079 (≈ π/4 × 10000 ≈ 45°)
+    // radius = 20000
+    // Point in front (+X direction): (10000, 0) → inside
+    // Point behind (-X direction): (-10000, 0) → outside
+    // Point at 90° from dir (along +Z): should be outside 45° half-angle
+    const HALF_45 = 157080; // π/4 × 10000
+    const rt = makeRuntime(`
+    fn test_sector_front(): int {
+      return in_sector_2d(10000, 0,  0, 0,  0, ${HALF_45}, 20000);
+    }
+    fn test_sector_behind(): int {
+      return in_sector_2d(-10000, 0,  0, 0,  0, ${HALF_45}, 20000);
+    }
+    fn test_sector_outside_r(): int {
+      return in_sector_2d(30000, 0,  0, 0,  0, ${HALF_45}, 20000);
+    }
+    fn test_sector_on_edge(): int {
+      // 45° from dir_angle=0 is exactly at boundary → should be inside (diff == half_angle)
+      return in_sector_2d(10000, 10000,  0, 0,  0, ${HALF_45}, 20000);
+    }
+  `);
+    test('point in front sector (0°) → 1', () => expect(callAndGetRet(rt, 'test_sector_front')).toBe(1));
+    test('point behind (180°) → 0', () => expect(callAndGetRet(rt, 'test_sector_behind')).toBe(0));
+    test('point outside radius → 0', () => expect(callAndGetRet(rt, 'test_sector_outside_r')).toBe(0));
+});
+//# sourceMappingURL=geometry.test.js.map

package/dist/src/__tests__/stdlib/heap.test.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Tests for stdlib/heap.mcrs — MinHeap and MaxHeap priority queues.
+ */
+export {};