redscript-mc 2.5.0 → 2.6.2

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__/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' },
             ]);
         });
@@ -278,9 +278,9 @@ impl Point {
             expect(stmt.kind).toBe('match');
             expect(stmt.expr).toEqual({ kind: 'ident', name: 'choice' });
             expect(stmt.arms).toEqual([
-                { pattern: { kind: 'int_lit', value: 1 }, body: [{ kind: 'expr', expr: { kind: 'call', fn: 'say', args: [{ kind: 'str_lit', value: 'one' }] } }] },
-                { pattern: { kind: 'int_lit', value: 2 }, body: [{ kind: 'expr', expr: { kind: 'call', fn: 'say', args: [{ kind: 'str_lit', value: 'two' }] } }] },
-                { pattern: null, body: [{ kind: 'expr', expr: { kind: 'call', fn: 'say', args: [{ kind: 'str_lit', value: 'other' }] } }] },
+                { pattern: { kind: 'PatInt', value: 1 }, body: [{ kind: 'expr', expr: { kind: 'call', fn: 'say', args: [{ kind: 'str_lit', value: 'one' }] } }] },
+                { pattern: { kind: 'PatInt', value: 2 }, body: [{ kind: 'expr', expr: { kind: 'call', fn: 'say', args: [{ kind: 'str_lit', value: 'two' }] } }] },
+                { pattern: { kind: 'PatWild' }, body: [{ kind: 'expr', expr: { kind: 'call', fn: 'say', args: [{ kind: 'str_lit', value: 'other' }] } }] },
             ]);
         });
         it('parses as block', () => {

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

@@ -34,256 +34,161 @@ var __importStar = (this && this.__importStar) || (function () {
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
 const fs = __importStar(require("fs"));
+const os = __importStar(require("os"));
 const path = __importStar(require("path"));
-const compile_1 = require("../compile");
 const runtime_1 = require("../runtime");
-function loadCompiledProgram(source, namespace = 'runtime') {
-    const result = (0, compile_1.compile)(source, { namespace });
-    expect(result.success).toBe(true);
-    expect(result.files).toBeDefined();
-    const runtime = new runtime_1.MCRuntime(namespace);
-    for (const file of result.files ?? []) {
-        if (!file.path.endsWith('.mcfunction'))
-            continue;
-        const match = file.path.match(/data\/([^/]+)\/function\/(.+)\.mcfunction$/);
-        if (!match)
-            continue;
-        const [, ns, fnPath] = match;
-        runtime.loadFunction(`${ns}:${fnPath}`, file.content.split('\n'));
-    }
-    return runtime;
-}
-function loadExample(name) {
-    return fs.readFileSync(path.join(__dirname, '..', 'examples', name), 'utf-8');
-}
-describe('MCRuntime behavioral integration', () => {
-    it('runs the counter example and increments the scoreboard across ticks', () => {
-        const runtime = loadCompiledProgram(loadExample('counter.mcrs'));
-        runtime.load();
-        runtime.ticks(5);
-        expect(runtime.getScore('counter', 'ticks')).toBe(5);
-        expect(runtime.tickCount).toBe(5);
+describe('runtime helpers', () => {
+    it('parses ranges and matches inclusive bounds', () => {
+        expect((0, runtime_1.parseRange)('5')).toEqual({ min: 5, max: 5 });
+        expect((0, runtime_1.parseRange)('..3')).toEqual({ min: -Infinity, max: 3 });
+        expect((0, runtime_1.parseRange)('7..')).toEqual({ min: 7, max: Infinity });
+        expect((0, runtime_1.parseRange)('2..4')).toEqual({ min: 2, max: 4 });
+        expect((0, runtime_1.matchesRange)(3, (0, runtime_1.parseRange)('2..4'))).toBe(true);
+        expect((0, runtime_1.matchesRange)(5, (0, runtime_1.parseRange)('2..4'))).toBe(false);
     });
-    it('executes compiled math control flow and stores the expected result', () => {
-        const runtime = loadCompiledProgram(`
-fn compute() {
-    let x: int = 3;
-    let result: int = 0;
-
-    if (x > 2) {
-        result = 11;
-    } else {
-        result = 29;
-    }
-
-    scoreboard_set("math", "result", result);
-}
-`);
-        runtime.load();
-        runtime.execFunction('compute');
-        expect(runtime.getScore('math', 'runtime.result')).toBe(11);
+    it('parses selectors with tags, types, scores, limits, and executor context', () => {
+        const executor = {
+            id: 'player',
+            tags: new Set(['runner']),
+            scores: new Map([['rs', 9], ['coins', 3]]),
+            selector: '@s',
+            type: 'minecraft:player',
+            position: { x: 0, y: 64, z: 0 },
+        };
+        const entities = [
+            executor,
+            {
+                id: 'zombie_a',
+                tags: new Set(['enemy', 'boss']),
+                scores: new Map([['rs', 5], ['coins', 10]]),
+                selector: '@e[tag=enemy,limit=1]',
+                type: 'zombie',
+                position: { x: 1, y: 64, z: 0 },
+            },
+            {
+                id: 'armor',
+                tags: new Set(['marker']),
+                scores: new Map([['rs', 1]]),
+                selector: '@e[tag=marker,limit=1]',
+                type: 'minecraft:armor_stand',
+                position: { x: 2, y: 64, z: 0 },
+            },
+        ];
+        expect((0, runtime_1.parseSelector)('@s', entities, executor)).toEqual([executor]);
+        expect((0, runtime_1.parseSelector)('@e[type=zombie,tag=enemy,scores={coins=8..},limit=1]', entities, executor))
+            .toEqual([entities[1]]);
+        expect((0, runtime_1.parseSelector)('@e[type=!armor_stand,tag=!marker]', entities, executor))
+            .toEqual([executor, entities[1]]);
+        expect((0, runtime_1.parseSelector)('@s[tag=runner,scores={rs=9}]', entities, executor)).toEqual([executor]);
     });
-    it('captures say, announce, actionbar, and title output in the chat log', () => {
-        const runtime = loadCompiledProgram(`
-fn chat() {
-    say("hello");
-    announce("broadcast");
-    actionbar(@a, "warning");
-    title(@a, "Boss Wave");
-}
-`);
-        runtime.load();
-        runtime.execFunction('chat');
-        expect(runtime.getChatLog()).toEqual([
-            '[Server] hello',
-            'broadcast',
-            '[ACTIONBAR] warning',
-            '[TITLE] Boss Wave',
+});
+describe('MCRuntime', () => {
+    it('loads functions, runs lifecycle hooks, and stops execution after return', () => {
+        const rt = new runtime_1.MCRuntime('test');
+        rt.loadFunction('test:__load', [
+            'scoreboard players add init rs 1',
+            '# comment should be dropped',
+            '',
         ]);
-    });
-    it('renders interpolated strings through tellraw score components', () => {
-        const runtime = loadCompiledProgram(`
-fn chat() {
-    let score: int = 7;
-    say("You have \${score} points");
-}
-`);
-        runtime.load();
-        runtime.execFunction('chat');
-        expect(runtime.getChatLog()).toEqual([
-            'You have 7 points',
+        rt.loadFunction('test:__tick', ['scoreboard players add tick rs 1']);
+        rt.loadFunction('test:early_return', [
+            'scoreboard players set before rs 1',
+            'return 42',
+            'scoreboard players set after rs 1',
         ]);
+        rt.load();
+        rt.ticks(3);
+        rt.execFunction('early_return');
+        expect(rt.getScore('init', 'rs')).toBe(1);
+        expect(rt.getScore('tick', 'rs')).toBe(3);
+        expect(rt.getScore('before', 'rs')).toBe(1);
+        expect(rt.getScore('after', 'rs')).toBe(0);
+        expect(rt.execCommand('execute store result score result rs run scoreboard players get before rs')).toBe(true);
+        expect(rt.getScore('result', 'rs')).toBe(1);
     });
-    it('renders f-strings through tellraw score components', () => {
-        const runtime = loadCompiledProgram(`
-fn chat() {
-    let score: int = 7;
-    say(f"You have {score} points");
-}
-`);
-        runtime.load();
-        runtime.execFunction('chat');
-        expect(runtime.getChatLog()).toEqual([
-            'You have 7 points',
+    it('supports execute conditions, storage writes, and macro function calls', () => {
+        const rt = new runtime_1.MCRuntime('test');
+        const runner = rt.spawnEntity(['runner'], 'minecraft:player', { x: 0, y: 64, z: 0 });
+        rt.setScore('lhs', 'rs', 7);
+        rt.setScore('rhs', 'rs', 4);
+        rt.setStorage('test:macro', { msg: 'macro hello', amount: 12 });
+        rt.loadFunction('test:macro_echo', [
+            '$say $(msg)',
+            '$scoreboard players set macro_score rs $(amount)',
         ]);
+        expect(rt.execCommand('execute if score lhs rs > rhs rs run scoreboard players set compare rs 1')).toBe(true);
+        expect(rt.getScore('compare', 'rs')).toBe(1);
+        expect(rt.execCommand('execute unless score lhs rs matches 1..5 run scoreboard players set outside rs 1')).toBe(true);
+        expect(rt.getScore('outside', 'rs')).toBe(1);
+        expect(rt.execCommand('execute as @e[tag=runner] if entity @s[tag=runner] run tag @s add active')).toBe(true);
+        expect(runner.tags.has('active')).toBe(true);
+        expect(rt.execCommand('execute store success score success rs if entity @e[tag=runner]')).toBe(true);
+        expect(rt.getScore('success', 'rs')).toBe(1);
+        expect(rt.execCommand('execute store result storage test:store answer int 1 run scoreboard players get lhs rs')).toBe(true);
+        expect(rt.getStorage('test:store.answer')).toBe(7);
+        expect(rt.execCommand('function test:macro_echo with storage test:macro')).toBe(true);
+        expect(rt.getLastSaid()).toBe('[Server] macro hello');
+        expect(rt.getScore('macro_score', 'rs')).toBe(12);
     });
-    it('kills only entities matched by a foreach selector', () => {
-        const runtime = loadCompiledProgram(`
-fn purge_zombies() {
-    foreach (z in @e[type=zombie]) {
-        kill(z);
-    }
-}
-`);
-        const zombieA = runtime.spawnEntity(['hostile'], 'minecraft:zombie');
-        const zombieB = runtime.spawnEntity(['hostile'], 'zombie');
-        const skeleton = runtime.spawnEntity(['hostile'], 'minecraft:skeleton');
-        runtime.load();
-        runtime.execFunction('purge_zombies');
-        expect(runtime.entities.map(entity => entity.id)).toEqual([skeleton.id]);
-        expect(runtime.entities.find(entity => entity.id === zombieA.id)).toBeUndefined();
-        expect(runtime.entities.find(entity => entity.id === zombieB.id)).toBeUndefined();
-    });
-    it('executes array push, pop, and len through storage operations', () => {
-        const runtime = loadCompiledProgram(`
-fn arrays() {
-    let arr: int[] = [];
-    arr.push(4);
-    arr.push(9);
-    let popped: int = arr.pop();
-    let len: int = arr.len;
-
-    scoreboard_set("arrays", "len", len);
-    scoreboard_set("arrays", "last", popped);
-}
-`);
-        runtime.load();
-        runtime.execFunction('arrays');
-        expect(runtime.getScore('arrays', 'runtime.len')).toBe(1);
-        expect(runtime.getScore('arrays', 'runtime.last')).toBe(9);
-        expect(runtime.getStorage('rs:heap.arr')).toEqual([4]);
-    });
-    it('tracks world state, weather, and time from compiled world commands', () => {
-        const runtime = loadCompiledProgram(`
-fn reset_world() {
-    let floor_start: BlockPos = (0, 64, 0);
-    let floor_end: BlockPos = (1, 64, 1);
-    let centerpiece: BlockPos = (1, 64, 1);
-    fill(floor_start, floor_end, "minecraft:stone");
-    setblock(centerpiece, "minecraft:gold_block");
-    weather("rain");
-    time_set("noon");
-}
-`);
-        runtime.load();
-        runtime.execFunction('reset_world');
-        expect(runtime.world.get('0,64,0')).toBe('minecraft:stone');
-        expect(runtime.world.get('0,64,1')).toBe('minecraft:stone');
-        expect(runtime.world.get('1,64,0')).toBe('minecraft:stone');
-        expect(runtime.world.get('1,64,1')).toBe('minecraft:gold_block');
-        expect(runtime.weather).toBe('rain');
-        expect(runtime.worldTime).toBe(6000);
-    });
-    it('respects @tick(rate=5) scheduling when ticking the runtime', () => {
-        const runtime = loadCompiledProgram(`
-@tick(rate=5)
-fn pulse() {
-    let count: int = scoreboard_get("pulse", "count");
-    count = count + 1;
-    scoreboard_set("pulse", "count", count);
-}
-`);
-        runtime.load();
-        runtime.ticks(10);
-        expect(runtime.getScore('pulse', 'runtime.count')).toBe(2);
-    });
-    it('executes only the matching match arm', () => {
-        const runtime = loadCompiledProgram(`
-fn choose() {
-    let choice: int = 2;
-    match (choice) {
-        1 => { say("one"); }
-        2 => { say("two"); }
-        _ => { say("other"); }
-    }
-}
-`);
-        runtime.load();
-        runtime.execFunction('choose');
-        expect(runtime.getChatLog()).toEqual([
-            '[Server] two',
+    it('handles storage, chat output, world state, and entity-affecting commands', () => {
+        const rt = new runtime_1.MCRuntime('test');
+        const player = rt.spawnEntity(['player'], 'minecraft:player', { x: 10, y: 64, z: 10 });
+        expect(rt.execCommand('data modify storage test:data numbers set value [1,2]')).toBe(true);
+        expect(rt.execCommand('data modify storage test:data numbers append value 3')).toBe(true);
+        expect(rt.execCommand('data modify storage test:data numbers[1] set value 9')).toBe(true);
+        expect(rt.execCommand('data modify storage test:data nested.value set value {"ok":true}')).toBe(true);
+        expect(rt.execCommand('data modify storage test:copy clone set from storage test:data nested.value')).toBe(true);
+        expect(rt.execCommand('data get storage test:data numbers[1]')).toBe(true);
+        expect(rt.execCommand('execute store result score fetched rs run data get storage test:data numbers')).toBe(true);
+        expect(rt.execCommand('data remove storage test:data nested.value')).toBe(true);
+        expect(rt.getStorage('test:data.numbers')).toEqual([1, 9, 3]);
+        expect(rt.getStorage('test:copy.clone')).toEqual({ ok: true });
+        expect(rt.getScore('fetched', 'rs')).toBe(3);
+        expect(rt.getStorage('test:data.nested.value')).toBeUndefined();
+        expect(rt.execCommand('say hello')).toBe(true);
+        expect(rt.execCommand('tellraw @a {"text":"score:","extra":[{"score":{"name":"fetched","objective":"rs"}}]}')).toBe(true);
+        expect(rt.execCommand('title @a actionbar {"text":"Alert"}')).toBe(true);
+        expect(rt.getChatLog()).toEqual([
+            '[Server] hello',
+            'score:',
+            '[ACTIONBAR] Alert',
         ]);
-    });
-    it('updates position, effects, and xp for executor-targeted builtins', () => {
-        const runtime = loadCompiledProgram(`
-fn buff_player() {
-    tp(@s, (5, 70, -2));
-    effect(@s, "speed", 15, 2);
-    xp_add(@s, 5);
-    xp_set(@s, 12, "levels");
-}
-`);
-        const player = runtime.spawnEntity(['player'], 'minecraft:player');
-        runtime.load();
-        runtime.execFunction('buff_player', player);
-        expect(player.position).toEqual({ x: 5, y: 70, z: -2 });
-        expect(runtime.effects.get(player.id)).toEqual([
-            { effect: 'speed', duration: 15, amplifier: 2 },
+        expect(rt.execCommand('setblock 1 2 3 minecraft:stone')).toBe(true);
+        expect(rt.execCommand('fill 0 0 0 1 0 1 minecraft:dirt')).toBe(true);
+        expect(rt.execCommand('weather rain')).toBe(true);
+        expect(rt.execCommand('time set noon')).toBe(true);
+        expect(rt.execCommand('time add 20')).toBe(true);
+        expect(rt.execCommand('tp @e[tag=player] ~1 ~2 ~3')).toBe(true);
+        expect(rt.execCommand('summon minecraft:zombie 5 65 5 {Tags:["enemy","boss"]}')).toBe(true);
+        expect(rt.execCommand('effect give @e[tag=player] minecraft:speed 15 2')).toBe(true);
+        expect(rt.execCommand('xp add @e[tag=player] 5 points')).toBe(true);
+        expect(rt.execCommand('xp set @s 8 points', player)).toBe(true);
+        expect(rt.execCommand('kill @e[tag=enemy]')).toBe(true);
+        expect(rt.world.get('1,2,3')).toBe('minecraft:stone');
+        expect(rt.world.get('0,0,0')).toBe('minecraft:dirt');
+        expect(rt.world.get('1,0,1')).toBe('minecraft:dirt');
+        expect(rt.weather).toBe('rain');
+        expect(rt.worldTime).toBe(6020);
+        expect(player.position).toEqual({ x: 11, y: 66, z: 13 });
+        expect(rt.effects.get(player.id)).toEqual([
+            { effect: 'minecraft:speed', duration: 15, amplifier: 2 },
         ]);
-        expect(runtime.xp.get(player.id)).toBe(12);
-    });
-    it('executes lambda variables through generated sub-functions', () => {
-        const runtime = loadCompiledProgram(`
-fn test() {
-    let double: (int) -> int = (x: int) => x * 2;
-    let result: int = double(5);
-    scoreboard_set("lambda", "direct", result);
-}
-`);
-        runtime.load();
-        runtime.execFunction('test');
-        expect(runtime.getScore('lambda', 'runtime.direct')).toBe(10);
-    });
-    it('executes lambdas passed as callback arguments', () => {
-        const runtime = loadCompiledProgram(`
-fn apply(val: int, cb: (int) -> int) -> int {
-    return cb(val);
-}
-
-fn test() {
-    let result: int = apply(5, (x: int) => x * 3);
-    scoreboard_set("lambda", "callback", result);
-}
-`);
-        runtime.load();
-        runtime.execFunction('test');
-        expect(runtime.getScore('lambda', 'runtime.callback')).toBe(15);
-    });
-    it('executes block-body lambdas', () => {
-        const runtime = loadCompiledProgram(`
-fn test() {
-    let process: (int) -> int = (x: int) => {
-        let doubled: int = x * 2;
-        return doubled + 1;
-    };
-    let result: int = process(5);
-    scoreboard_set("lambda", "block", result);
-}
-`);
-        runtime.load();
-        runtime.execFunction('test');
-        expect(runtime.getScore('lambda', 'runtime.block')).toBe(11);
+        expect(rt.xp.get(player.id)).toBe(8);
+        expect(rt.getEntities('@e[tag=enemy]')).toEqual([]);
     });
-    it('executes immediately-invoked expression-body lambdas', () => {
-        const runtime = loadCompiledProgram(`
-fn test() {
-    let result: int = ((x: int) => x * 2)(5);
-    scoreboard_set("lambda", "iife", result);
-}
-`);
-        runtime.load();
-        runtime.execFunction('test');
-        expect(runtime.getScore('lambda', 'runtime.iife')).toBe(10);
+    it('loads datapacks from disk and exposes loaded functions', () => {
+        const base = fs.mkdtempSync(path.join(os.tmpdir(), 'redscript-runtime-'));
+        const fnDir = path.join(base, 'data', 'pack', 'function', 'nested');
+        fs.mkdirSync(fnDir, { recursive: true });
+        fs.writeFileSync(path.join(base, 'data', 'pack', 'function', '__load.mcfunction'), 'scoreboard players set loaded rs 1\n', 'utf8');
+        fs.writeFileSync(path.join(fnDir, 'ping.mcfunction'), 'say datapack\n', 'utf8');
+        const rt = new runtime_1.MCRuntime('pack');
+        rt.loadDatapack(base);
+        rt.load();
+        rt.execFunction('nested/ping');
+        expect(rt.getScore('loaded', 'rs')).toBe(1);
+        expect(rt.getLastSaid()).toBe('[Server] datapack');
+        expect(rt.functions.has('pack:nested/ping')).toBe(true);
     });
 });
 //# sourceMappingURL=runtime.test.js.map

package/dist/src/__tests__/stdlib/arr-len.test.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Tests for arr.len() — literal constant and dynamic runtime variants.
+ *
+ * Covers:
+ * - Literal array: nums.len() where nums = [1,2,3] → compile-time constant 3
+ * - Function-parameter array: items.len() → scoreboard param (passed by caller)
+ * - for item in arr with dynamic array parameter (iterates using loop counter)
+ * - Nested for-each over two distinct dynamic arrays (both compile without error)
+ *
+ * Validation is purely through compiled .mcfunction content inspection;
+ * no Minecraft server is required.
+ */
+export {};