redscript-mc 2.1.1 → 2.3.0

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

@@ -95,4 +95,109 @@ describe('@schedule decorator', () => {
         expect(startFn).toContain('function test:_schedule_after_one_second');
     });
 });
+describe('setTimeout / setInterval codegen', () => {
+    test('setTimeout lifts lambda to __timeout_callback_0 and schedules it', () => {
+        const source = `
+      fn start() {
+        setTimeout(20, () => {
+          say("later");
+        });
+      }
+    `;
+        const result = (0, compile_1.compile)(source, { namespace: 'ns' });
+        const startFn = getFile(result.files, 'start.mcfunction');
+        const cbFn = getFile(result.files, '__timeout_callback_0.mcfunction');
+        expect(startFn).toContain('schedule function ns:__timeout_callback_0 20t');
+        expect(cbFn).toBeDefined();
+        expect(cbFn).toContain('say later');
+    });
+    test('setInterval lambda reschedules itself at the end', () => {
+        const source = `
+      fn start() {
+        setInterval(10, () => {
+          say("tick");
+        });
+      }
+    `;
+        const result = (0, compile_1.compile)(source, { namespace: 'ns' });
+        const cbFn = getFile(result.files, '__timeout_callback_0.mcfunction');
+        expect(cbFn).toBeDefined();
+        expect(cbFn).toContain('schedule function ns:__timeout_callback_0 10t');
+    });
+    test('multiple setTimeout calls get unique callback names', () => {
+        const source = `
+      fn start() {
+        setTimeout(10, () => { say("a"); });
+        setTimeout(20, () => { say("b"); });
+      }
+    `;
+        const result = (0, compile_1.compile)(source, { namespace: 'ns' });
+        const cb0 = getFile(result.files, '__timeout_callback_0.mcfunction');
+        const cb1 = getFile(result.files, '__timeout_callback_1.mcfunction');
+        expect(cb0).toBeDefined();
+        expect(cb1).toBeDefined();
+        expect(cb0).toContain('say a');
+        expect(cb1).toContain('say b');
+    });
+});
+const TIMER_STRUCT = `
+struct Timer {
+    _id: int,
+    _duration: int
+}
+impl Timer {
+    fn new(duration: int) -> Timer {
+        return { _id: 0, _duration: duration };
+    }
+    fn start(self) {}
+    fn pause(self) {}
+    fn reset(self) {}
+    fn tick(self) {}
+    fn done(self) -> bool { return false; }
+    fn elapsed(self) -> int { return 0; }
+}
+`;
+describe('Timer static allocation codegen', () => {
+    test('Timer::new() initializes unique scoreboard slots', () => {
+        const source = TIMER_STRUCT + `
+fn init() {
+    let t: Timer = Timer::new(20);
+}
+`;
+        const result = (0, compile_1.compile)(source, { namespace: 'ns' });
+        const initFn = getFile(result.files, 'init.mcfunction');
+        expect(initFn).toContain('scoreboard players set __timer_0_ticks ns 0');
+        expect(initFn).toContain('scoreboard players set __timer_0_active ns 0');
+    });
+    test('Timer.start() inlines to scoreboard set active=1', () => {
+        const source = TIMER_STRUCT + `
+fn init() {
+    let t: Timer = Timer::new(20);
+    t.start();
+}
+`;
+        const result = (0, compile_1.compile)(source, { namespace: 'ns' });
+        const initFn = getFile(result.files, 'init.mcfunction');
+        expect(initFn).toContain('scoreboard players set __timer_0_active ns 1');
+        expect(initFn).not.toContain('function ns:timer/start');
+    });
+    test('two Timer::new() calls get distinct IDs', () => {
+        const source = TIMER_STRUCT + `
+fn init() {
+    let t0: Timer = Timer::new(10);
+    let t1: Timer = Timer::new(20);
+    t0.start();
+    t1.start();
+}
+`;
+        const result = (0, compile_1.compile)(source, { namespace: 'ns' });
+        const initFn = getFile(result.files, 'init.mcfunction');
+        // Both timers initialized
+        expect(initFn).toContain('__timer_0_ticks');
+        expect(initFn).toContain('__timer_1_ticks');
+        // Both started with unique slot names
+        expect(initFn).toContain('scoreboard players set __timer_0_active ns 1');
+        expect(initFn).toContain('scoreboard players set __timer_1_active ns 1');
+    });
+});
 //# sourceMappingURL=schedule.test.js.map

package/dist/src/__tests__/tuner/engine.test.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Tests for the redscript tuner engine, simulator, and ln-polynomial adapter.
+ */
+export {};

package/dist/src/__tests__/tuner/engine.test.js

@@ -0,0 +1,232 @@
+"use strict";
+/**
+ * Tests for the redscript tuner engine, simulator, and ln-polynomial adapter.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+const engine_1 = require("../../tuner/engine");
+const simulator_1 = require("../../tuner/simulator");
+const metrics_1 = require("../../tuner/metrics");
+const ln_polynomial_1 = require("../../tuner/adapters/ln-polynomial");
+const sqrt_newton_1 = require("../../tuner/adapters/sqrt-newton");
+// ─── simulator tests ──────────────────────────────────────────────────────────
+describe('simulator', () => {
+    test('i32 truncates to int32', () => {
+        expect((0, simulator_1.i32)(3.7)).toBe(3);
+        expect((0, simulator_1.i32)(-3.7)).toBe(-3);
+        expect((0, simulator_1.i32)(2147483648)).toBe(-2147483648); // overflow wraps
+        expect((0, simulator_1.i32)(0)).toBe(0);
+    });
+    test('fixedMul basic', () => {
+        // 10000 * 10000 / 10000 = 10000
+        expect((0, simulator_1.fixedMul)(10000, 10000, 10000)).toBe(10000);
+        // 5000 * 2 / 10000 = 1
+        expect((0, simulator_1.fixedMul)(5000, 2, 10000)).toBe(1);
+    });
+    test('fixedMul returns Infinity on overflow', () => {
+        expect((0, simulator_1.fixedMul)(2147483647, 2147483647, 1)).toBe(Infinity);
+    });
+    test('isOverflow detects out-of-range', () => {
+        expect((0, simulator_1.isOverflow)(2147483648)).toBe(true);
+        expect((0, simulator_1.isOverflow)(-2147483649)).toBe(true);
+        expect((0, simulator_1.isOverflow)(Infinity)).toBe(true);
+        expect((0, simulator_1.isOverflow)(NaN)).toBe(true);
+        expect((0, simulator_1.isOverflow)(0)).toBe(false);
+        expect((0, simulator_1.isOverflow)(2147483647)).toBe(false);
+    });
+});
+// ─── Nelder-Mead convergence test ────────────────────────────────────────────
+describe('Nelder-Mead engine', () => {
+    test('converges to minimum of (x-3)^2', () => {
+        // Simple 1D minimization: minimize (x-3)^2
+        const mockAdapter = {
+            name: 'test-quadratic',
+            description: 'Minimize (x-3)^2',
+            params: [
+                { name: 'x', range: [-10, 10], integer: false },
+            ],
+            simulate(input, params) {
+                // Return the residual as a scaled integer
+                const x = params['x'];
+                return Math.round(x * 10000);
+            },
+            reference(_input) {
+                // Target: x = 3 → value 30000
+                return 30000;
+            },
+            sampleInputs() {
+                return [1]; // single input, target value is 3.0 (×10000 = 30000)
+            },
+            generateCode(params) {
+                return `// x = ${params['x']}`;
+            },
+        };
+        const result = (0, engine_1.search)(mockAdapter, 5000);
+        // Should converge close to x=3
+        expect(result.params['x']).toBeCloseTo(3.0, 1);
+        expect(result.maxError).toBeLessThan(0.1);
+    });
+    test('handles integer constraints', () => {
+        const mockAdapter = {
+            name: 'test-integer',
+            description: 'Integer parameter test',
+            params: [
+                { name: 'n', range: [0, 10], integer: true },
+            ],
+            simulate(input, params) {
+                // Should snap to integer 7
+                return Math.round(params['n'] * 10000);
+            },
+            reference(_input) {
+                return 70000; // 7.0 × 10000
+            },
+            sampleInputs() {
+                return [1];
+            },
+            generateCode() {
+                return '';
+            },
+        };
+        const result = (0, engine_1.search)(mockAdapter, 2000);
+        // Should find n close to 7
+        expect(Math.round(result.params['n'])).toBe(7);
+    });
+    test('i32 overflow penalization', () => {
+        const mockAdapter = {
+            name: 'test-overflow',
+            description: 'Test overflow penalization',
+            params: [
+                { name: 'scale', range: [1, 1000], integer: true },
+            ],
+            simulate(_input, params) {
+                // Always overflow for any scale >= 500
+                if (params['scale'] >= 500)
+                    return Infinity;
+                return params['scale'] * 10000;
+            },
+            reference(_input) {
+                return 2000000; // target: scale=200 → 2000000
+            },
+            sampleInputs() {
+                return [1];
+            },
+            generateCode() {
+                return '';
+            },
+        };
+        const { maxError, mae, rmse } = (0, metrics_1.evaluate)(mockAdapter, { scale: 2147483647 });
+        expect(maxError).toBe(Infinity);
+        expect(mae).toBe(Infinity);
+        expect(rmse).toBe(Infinity);
+    });
+});
+// ─── ln-polynomial adapter tests ─────────────────────────────────────────────
+describe('ln-polynomial adapter', () => {
+    const defaultParams = ln_polynomial_1.defaultParams; // { A1: 20000, A3: 6667, A5: 4000 }
+    test('sample inputs cover the valid range', () => {
+        const inputs = ln_polynomial_1.lnPolynomialAdapter.sampleInputs();
+        expect(inputs.length).toBeGreaterThan(50);
+        // All inputs should be positive
+        expect(inputs.every(x => x > 0)).toBe(true);
+    });
+    test('reference matches Math.log', () => {
+        const SCALE = 10000;
+        // ln(1.0) = 0
+        expect(ln_polynomial_1.lnPolynomialAdapter.reference(SCALE)).toBeCloseTo(0, 5);
+        // ln(2.0) ≈ 0.6931 → 6931
+        expect(ln_polynomial_1.lnPolynomialAdapter.reference(2 * SCALE)).toBeCloseTo(6931.47, 0);
+        // ln(0.5) ≈ -0.6931 → -6931
+        expect(ln_polynomial_1.lnPolynomialAdapter.reference(5000)).toBeCloseTo(-6931.47, 0);
+    });
+    test('simulate produces reasonable output for x=1 (no error)', () => {
+        const result = ln_polynomial_1.lnPolynomialAdapter.simulate(10000, defaultParams);
+        // ln(1.0) = 0; allow some approximation error
+        expect(Math.abs(result)).toBeLessThan(500); // within 0.05
+    });
+    test('simulate returns Infinity for invalid input', () => {
+        const result = ln_polynomial_1.lnPolynomialAdapter.simulate(0, defaultParams);
+        expect(result).toBeLessThan(0); // negative sentinel or -MAX_INT
+    });
+    test('max_error < 0.001 with default atanh coefficients', () => {
+        const metrics = (0, metrics_1.evaluate)(ln_polynomial_1.lnPolynomialAdapter, defaultParams);
+        expect(metrics.maxError).toBeLessThan(0.001);
+    }, 10000);
+    test('search improves over default params', () => {
+        // Run a short search and confirm it doesn't get worse
+        const baseMetrics = (0, metrics_1.evaluate)(ln_polynomial_1.lnPolynomialAdapter, defaultParams);
+        const result = (0, engine_1.search)(ln_polynomial_1.lnPolynomialAdapter, 500); // short budget for test speed
+        // Either same or better
+        expect(result.maxError).toBeLessThanOrEqual(baseMetrics.maxError * 2);
+        expect(result.maxError).toBeLessThan(0.01);
+    }, 30000);
+    test('generateCode produces valid output', () => {
+        const meta = {
+            maxError: 0.00003,
+            mae: 0.000012,
+            rmse: 0.000015,
+            estimatedCmds: 38,
+            tuneDate: '2026-03-17',
+            budgetUsed: 5000,
+        };
+        const code = ln_polynomial_1.lnPolynomialAdapter.generateCode(defaultParams, meta);
+        expect(code).toContain('AUTO-GENERATED');
+        expect(code).toContain('ln-polynomial');
+        expect(code).toContain('fn ln');
+        expect(code).toContain('A1');
+        expect(code).toContain('A3');
+        expect(code).toContain('A5');
+        expect(code).toContain('2026-03-17');
+    });
+    test('searchSA achieves max_error < 0.001 on ln-polynomial', () => {
+        const result = (0, engine_1.searchSA)(ln_polynomial_1.lnPolynomialAdapter, 3000);
+        expect(result.maxError).toBeLessThan(0.001);
+    }, 30000);
+});
+// ─── sqrt-newton adapter tests ────────────────────────────────────────────────
+describe('sqrt-newton adapter', () => {
+    test('simulate(10000, defaultParams) ≈ 10000 (sqrt(1.0)=1.0)', () => {
+        const result = sqrt_newton_1.sqrtNewtonAdapter.simulate(10000, sqrt_newton_1.defaultParams);
+        // sqrt(1.0) * 10000 = 10000
+        expect(Math.abs(result - 10000)).toBeLessThan(10);
+    });
+    test('simulate(40000, defaultParams) ≈ 20000 (sqrt(4.0)=2.0)', () => {
+        const result = sqrt_newton_1.sqrtNewtonAdapter.simulate(40000, sqrt_newton_1.defaultParams);
+        // sqrt(4.0) * 10000 = 20000
+        expect(Math.abs(result - 20000)).toBeLessThan(10);
+    });
+    test('simulate(0) returns 0', () => {
+        expect(sqrt_newton_1.sqrtNewtonAdapter.simulate(0, sqrt_newton_1.defaultParams)).toBe(0);
+        expect(sqrt_newton_1.sqrtNewtonAdapter.simulate(-1, sqrt_newton_1.defaultParams)).toBe(0);
+    });
+    test('simulate(250000, defaultParams) ≈ 50000 (sqrt(25.0)=5.0)', () => {
+        const result = sqrt_newton_1.sqrtNewtonAdapter.simulate(250000, sqrt_newton_1.defaultParams);
+        expect(Math.abs(result - 50000)).toBeLessThan(10);
+    });
+    test('sample inputs are all positive', () => {
+        const inputs = sqrt_newton_1.sqrtNewtonAdapter.sampleInputs();
+        expect(inputs.length).toBeGreaterThan(50);
+        expect(inputs.every(x => x > 0)).toBe(true);
+    });
+    test('reference matches Math.sqrt', () => {
+        const SCALE = 10000;
+        expect(sqrt_newton_1.sqrtNewtonAdapter.reference(SCALE)).toBe(SCALE); // sqrt(1.0)
+        expect(sqrt_newton_1.sqrtNewtonAdapter.reference(4 * SCALE)).toBe(2 * SCALE); // sqrt(4.0)
+        expect(sqrt_newton_1.sqrtNewtonAdapter.reference(9 * SCALE)).toBe(3 * SCALE); // sqrt(9.0)
+        expect(sqrt_newton_1.sqrtNewtonAdapter.reference(0)).toBe(0);
+    });
+    test('generateCode contains fn sqrt_fx', () => {
+        const meta = {
+            maxError: 1.5,
+            mae: 0.5,
+            rmse: 0.8,
+            estimatedCmds: 30,
+            tuneDate: '2026-03-17',
+            budgetUsed: 3000,
+        };
+        const code = sqrt_newton_1.sqrtNewtonAdapter.generateCode(sqrt_newton_1.defaultParams, meta);
+        expect(code).toContain('AUTO-GENERATED');
+        expect(code).toContain('sqrt-newton');
+        expect(code).toContain('fn sqrt_fx');
+        expect(code).toContain('2026-03-17');
+    });
+});
+//# sourceMappingURL=engine.test.js.map

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

@@ -246,6 +246,69 @@ fn test() {
             expect(errors.length).toBeGreaterThan(0);
             expect(errors[0].message).toContain('Return type mismatch: expected void, got int');
         });
+        it('rejects setTimeout inside a loop', () => {
+            const errors = typeCheck(`
+fn test() {
+    while (true) {
+        setTimeout(20, () => { say("x"); });
+    }
+}
+`);
+            expect(errors.length).toBeGreaterThan(0);
+            expect(errors[0].message).toContain('cannot be called inside a loop');
+        });
+        it('rejects setTimeout inside an if body', () => {
+            const errors = typeCheck(`
+fn test() {
+    if (true) {
+        setTimeout(20, () => { say("x"); });
+    }
+}
+`);
+            expect(errors.length).toBeGreaterThan(0);
+            expect(errors[0].message).toContain('cannot be called inside an if/else body');
+        });
+        it('rejects setInterval inside a loop', () => {
+            const errors = typeCheck(`
+fn test() {
+    while (true) {
+        setInterval(20, () => { say("x"); });
+    }
+}
+`);
+            expect(errors.length).toBeGreaterThan(0);
+            expect(errors[0].message).toContain('cannot be called inside a loop');
+        });
+        it('rejects Timer::new() inside a loop', () => {
+            const errors = typeCheck(`
+struct Timer { _id: int, _duration: int }
+impl Timer {
+    fn new(duration: int) -> Timer { return { _id: 0, _duration: duration }; }
+}
+fn test() {
+    while (true) {
+        let t: Timer = Timer::new(10);
+    }
+}
+`);
+            expect(errors.length).toBeGreaterThan(0);
+            expect(errors[0].message).toContain('Timer::new() cannot be called inside a loop');
+        });
+        it('rejects Timer::new() inside an if body', () => {
+            const errors = typeCheck(`
+struct Timer { _id: int, _duration: int }
+impl Timer {
+    fn new(duration: int) -> Timer { return { _id: 0, _duration: duration }; }
+}
+fn test() {
+    if (true) {
+        let t: Timer = Timer::new(10);
+    }
+}
+`);
+            expect(errors.length).toBeGreaterThan(0);
+            expect(errors[0].message).toContain('Timer::new() cannot be called inside an if/else body');
+        });
         it('allows impl instance methods with inferred self type', () => {
             const errors = typeCheck(`
 struct Timer { duration: int }

package/dist/src/emit/compile.js

@@ -116,6 +116,7 @@ function compile(source, options = {}) {
         const coroResult = (0, coroutine_1.coroutineTransform)(mirOpt, coroutineInfos);
         const mirFinal = coroResult.module;
         tickFunctions.push(...coroResult.generatedTickFunctions);
+        warnings.push(...coroResult.warnings);
         // Stage 5: MIR → LIR
         const lir = (0, lower_3.lowerToLIR)(mirFinal);
         // Stage 6: LIR optimization

package/dist/src/emit/index.js

@@ -152,7 +152,9 @@ function emitInstr(instr, ns, obj, mcVersion) {
             return `execute unless score ${slot(instr.a)} ${cmpToMC(instr.op)} ${slot(instr.b)} run function ${instr.fn}`;
         case 'call_context': {
             const subcmds = instr.subcommands.map(emitSubcmd).join(' ');
-            return `execute ${subcmds} run function ${instr.fn}`;
+            return subcmds
+                ? `execute ${subcmds} run function ${instr.fn}`
+                : `function ${instr.fn}`;
         }
         case 'return_value':
             return `scoreboard players operation $ret ${instr.slot.obj} = ${slot(instr.slot)}`;

package/dist/src/lir/lower.js

@@ -275,6 +275,32 @@ function lowerInstrInner(instr, fn, ctx, instrs) {
             });
             break;
         }
+        case 'score_read': {
+            // execute store result score $dst __obj run scoreboard players get <player> <obj>
+            const dst = ctx.slot(instr.dst);
+            instrs.push({
+                kind: 'store_cmd_to_score',
+                dst,
+                cmd: { kind: 'raw', cmd: `scoreboard players get ${instr.player} ${instr.obj}` },
+            });
+            break;
+        }
+        case 'score_write': {
+            // Write a value to a vanilla MC scoreboard objective
+            if (instr.src.kind === 'const') {
+                instrs.push({ kind: 'raw', cmd: `scoreboard players set ${instr.player} ${instr.obj} ${instr.src.value}` });
+            }
+            else {
+                // execute store result score <player> <obj> run scoreboard players get $src __ns
+                const srcSlot = operandToSlot(instr.src, ctx, instrs);
+                instrs.push({
+                    kind: 'store_cmd_to_score',
+                    dst: { player: instr.player, obj: instr.obj },
+                    cmd: { kind: 'raw', cmd: `scoreboard players get ${srcSlot.player} ${srcSlot.obj}` },
+                });
+            }
+            break;
+        }
         case 'call': {
             // Set parameter slots $p0, $p1, ...
             for (let i = 0; i < instr.args.length; i++) {