redscript-mc 1.1.0 → 1.2.1

package/dist/__tests__/mc-integration.test.js

@@ -52,6 +52,7 @@ const MC_HOST = process.env.MC_HOST ?? 'localhost';
 const MC_PORT = parseInt(process.env.MC_PORT ?? '25561');
 const MC_SERVER_DIR = process.env.MC_SERVER_DIR ?? path.join(process.env.HOME, 'mc-test-server');
 const DATAPACK_DIR = path.join(MC_SERVER_DIR, 'world', 'datapacks', 'redscript-test');
+const FIXTURE_DIR = path.join(__dirname, 'fixtures');
 let serverOnline = false;
 let mc;
 /** Write compiled RedScript source into the shared test datapack directory.
@@ -84,9 +85,22 @@ function writeFixture(source, namespace) {
         }
     }
 }
+function writeFixtureFile(fileName, namespace) {
+    writeFixture(fs.readFileSync(path.join(FIXTURE_DIR, fileName), 'utf-8'), namespace);
+}
+async function waitForServer(client, timeoutMs = 30000) {
+    const deadline = Date.now() + timeoutMs;
+    while (Date.now() < deadline) {
+        if (await client.isOnline()) {
+            return true;
+        }
+        await new Promise(resolve => setTimeout(resolve, 1000));
+    }
+    return false;
+}
 beforeAll(async () => {
     mc = new client_1.MCTestClient(MC_HOST, MC_PORT);
-    serverOnline = await mc.isOnline();
+    serverOnline = await waitForServer(mc);
     if (!serverOnline) {
         console.warn(`⚠ MC server not running at ${MC_HOST}:${MC_PORT} — skipping integration tests`);
         console.warn(`  Run: MC_SERVER_DIR=~/mc-test-server npx ts-node src/mc-test/setup.ts`);
@@ -104,16 +118,16 @@ beforeAll(async () => {
     writeFixture(`
     @tick
     fn on_tick() {
-      scoreboard_set("#tick_counter", "ticks", scoreboard_get("#tick_counter", "ticks") + 1);
+      scoreboard_set("#tick_counter", #ticks, scoreboard_get("#tick_counter", #ticks) + 1);
     }
   `, 'tick_test');
     writeFixture(`
     fn check_score() {
-      let x: int = scoreboard_get("#check_x", "test_score");
+      let x: int = scoreboard_get("#check_x", #test_score);
       if (x > 5) {
-        scoreboard_set("#check_x", "result", 1);
+        scoreboard_set("#check_x", #result, 1);
       } else {
-        scoreboard_set("#check_x", "result", 0);
+        scoreboard_set("#check_x", #result, 0);
       }
     }
   `, 'inline_test');
@@ -122,30 +136,30 @@ beforeAll(async () => {
     writeFixture(`
     @tick
     fn game_tick() {
-      let time: int = scoreboard_get("#game", "timer");
+      let time: int = scoreboard_get("#game", #timer);
       if (time > 0) {
-        scoreboard_set("#game", "timer", time - 1);
+        scoreboard_set("#game", #timer, time - 1);
       }
       if (time == 1) {
-        scoreboard_set("#game", "ended", 1);
+        scoreboard_set("#game", #ended, 1);
       }
     }
     fn start_game() {
-      scoreboard_set("#game", "timer", 5);
-      scoreboard_set("#game", "ended", 0);
+      scoreboard_set("#game", #timer, 5);
+      scoreboard_set("#game", #ended, 0);
     }
   `, 'game_loop');
     // Scenario B: two functions, same temp var namespace — verify no collision
     writeFixture(`
     fn calc_sum() {
-      let a: int = scoreboard_get("#math", "val_a");
-      let b: int = scoreboard_get("#math", "val_b");
-      scoreboard_set("#math", "sum", a + b);
+      let a: int = scoreboard_get("#math", #val_a);
+      let b: int = scoreboard_get("#math", #val_b);
+      scoreboard_set("#math", #sum, a + b);
     }
     fn calc_product() {
-      let x: int = scoreboard_get("#math", "val_x");
-      let y: int = scoreboard_get("#math", "val_y");
-      scoreboard_set("#math", "product", x * y);
+      let x: int = scoreboard_get("#math", #val_x);
+      let y: int = scoreboard_get("#math", #val_y);
+      scoreboard_set("#math", #product, x * y);
     }
     fn run_both() {
       calc_sum();
@@ -155,16 +169,16 @@ beforeAll(async () => {
     // Scenario C: 3-deep call chain, each step modifies shared state
     writeFixture(`
     fn step3() {
-      let v: int = scoreboard_get("#chain", "val");
-      scoreboard_set("#chain", "val", v * 2);
+      let v: int = scoreboard_get("#chain", #val);
+      scoreboard_set("#chain", #val, v * 2);
     }
     fn step2() {
-      let v: int = scoreboard_get("#chain", "val");
-      scoreboard_set("#chain", "val", v + 5);
+      let v: int = scoreboard_get("#chain", #val);
+      scoreboard_set("#chain", #val, v + 5);
       step3();
     }
     fn step1() {
-      scoreboard_set("#chain", "val", 10);
+      scoreboard_set("#chain", #val, 10);
       step2();
     }
   `, 'call_chain');
@@ -180,10 +194,10 @@ beforeAll(async () => {
     // Scenario E: for-range loop — loop counter increments exactly N times
     writeFixture(`
     fn count_to_five() {
-      scoreboard_set("#range", "counter", 0);
+      scoreboard_set("#range", #counter, 0);
       for i in 0..5 {
-        let c: int = scoreboard_get("#range", "counter");
-        scoreboard_set("#range", "counter", c + 1);
+        let c: int = scoreboard_get("#range", #counter);
+        scoreboard_set("#range", #counter, c + 1);
       }
     }
   `, 'range_test');
@@ -194,48 +208,48 @@ beforeAll(async () => {
     }
     fn run_nested() {
       let a: int = triple(4);
-      scoreboard_set("#nested", "result", a);
+      scoreboard_set("#nested", #result, a);
     }
   `, 'nested_test');
     // Scenario G: match statement dispatches to correct branch
     writeFixture(`
     fn classify(x: int) {
       match (x) {
-        1 => { scoreboard_set("#match", "out", 10); }
-        2 => { scoreboard_set("#match", "out", 20); }
-        3 => { scoreboard_set("#match", "out", 30); }
-        _ => { scoreboard_set("#match", "out", -1); }
+        1 => { scoreboard_set("#match", #out, 10); }
+        2 => { scoreboard_set("#match", #out, 20); }
+        3 => { scoreboard_set("#match", #out, 30); }
+        _ => { scoreboard_set("#match", #out, -1); }
       }
     }
   `, 'match_test');
     // Scenario H: while loop counts down
     writeFixture(`
     fn countdown() {
-      scoreboard_set("#wloop", "i", 10);
-      scoreboard_set("#wloop", "steps", 0);
-      let i: int = scoreboard_get("#wloop", "i");
+      scoreboard_set("#wloop", #i, 10);
+      scoreboard_set("#wloop", #steps, 0);
+      let i: int = scoreboard_get("#wloop", #i);
       while (i > 0) {
-        let s: int = scoreboard_get("#wloop", "steps");
-        scoreboard_set("#wloop", "steps", s + 1);
+        let s: int = scoreboard_get("#wloop", #steps);
+        scoreboard_set("#wloop", #steps, s + 1);
         i = i - 1;
-        scoreboard_set("#wloop", "i", i);
+        scoreboard_set("#wloop", #i, i);
       }
     }
   `, 'while_test');
     // Scenario I: multiple if/else branches (boundary test)
     writeFixture(`
     fn classify_score() {
-      let x: int = scoreboard_get("#boundary", "input");
+      let x: int = scoreboard_get("#boundary", #input);
       if (x > 100) {
-        scoreboard_set("#boundary", "tier", 3);
+        scoreboard_set("#boundary", #tier, 3);
       } else {
         if (x > 50) {
-          scoreboard_set("#boundary", "tier", 2);
+          scoreboard_set("#boundary", #tier, 2);
         } else {
           if (x > 0) {
-            scoreboard_set("#boundary", "tier", 1);
+            scoreboard_set("#boundary", #tier, 1);
           } else {
-            scoreboard_set("#boundary", "tier", 0);
+            scoreboard_set("#boundary", #tier, 0);
           }
         }
       }
@@ -255,31 +269,37 @@ beforeAll(async () => {
       let a: int = 2;
       let b: int = 3;
       let c: int = 4;
-      scoreboard_set("#order", "r1", a + b * c);
-      scoreboard_set("#order", "r2", (a + b) * c);
+      scoreboard_set("#order", #r1, a + b * c);
+      scoreboard_set("#order", #r2, (a + b) * c);
       let d: int = 100;
       let e: int = d / 3;
-      scoreboard_set("#order", "r3", e);
+      scoreboard_set("#order", #r3, e);
     }
   `, 'order_test');
     // Scenario L: scoreboard read-modify-write chain
     writeFixture(`
     fn chain_rmw() {
-      scoreboard_set("#rmw", "v", 1);
-      let v: int = scoreboard_get("#rmw", "v");
-      scoreboard_set("#rmw", "v", v * 2);
-      v = scoreboard_get("#rmw", "v");
-      scoreboard_set("#rmw", "v", v * 2);
-      v = scoreboard_get("#rmw", "v");
-      scoreboard_set("#rmw", "v", v * 2);
+      scoreboard_set("#rmw", #v, 1);
+      let v: int = scoreboard_get("#rmw", #v);
+      scoreboard_set("#rmw", #v, v * 2);
+      v = scoreboard_get("#rmw", #v);
+      scoreboard_set("#rmw", #v, v * 2);
+      v = scoreboard_get("#rmw", #v);
+      scoreboard_set("#rmw", #v, v * 2);
     }
   `, 'rmw_test');
+    writeFixtureFile('impl-test.mcrs', 'impl_test');
+    writeFixtureFile('timeout-test.mcrs', 'timeout_test');
+    writeFixtureFile('interval-test.mcrs', 'interval_test');
+    writeFixtureFile('is-check-test.mcrs', 'is_check_test');
+    writeFixtureFile('event-test.mcrs', 'event_test');
     // ── Full reset + safe data reload ────────────────────────────────────
     await mc.fullReset();
     // Pre-create scoreboards
     for (const obj of ['ticks', 'seconds', 'test_score', 'result', 'calc', 'rs',
         'timer', 'ended', 'val_a', 'val_b', 'sum', 'val_x', 'val_y', 'product', 'val',
-        'counter', 'out', 'i', 'steps', 'input', 'tier', 'r1', 'r2', 'r3', 'v']) {
+        'counter', 'out', 'i', 'steps', 'input', 'tier', 'r1', 'r2', 'r3', 'v',
+        'done', 'fired', 'players', 'zombies']) {
         await mc.command(`/scoreboard objectives add ${obj} dummy`).catch(() => { });
     }
     await mc.command('/scoreboard players set counter ticks 0');
@@ -637,4 +657,78 @@ describe('E2E Scenario Tests', () => {
         console.log(`  RMW chain: 1→2→4→8, got ${v} (expect 8) ✓`);
     });
 });
+describe('MC Integration - New Features', () => {
+    test('impl-test.mcrs: Timer::new/start/tick/done works in-game', async () => {
+        if (!serverOnline)
+            return;
+        await mc.command('/scoreboard players set #impl done 0');
+        await mc.command('/scoreboard players set timer_ticks rs 0');
+        await mc.command('/scoreboard players set timer_active rs 0');
+        await mc.command('/function impl_test:__load').catch(() => { });
+        await mc.command('/function impl_test:test');
+        await mc.ticks(5);
+        const done = await mc.scoreboard('#impl', 'done');
+        const ticks = await mc.scoreboard('timer_ticks', 'rs');
+        expect(done).toBe(1);
+        expect(ticks).toBe(3);
+    });
+    test('timeout-test.mcrs: setTimeout executes after delay', async () => {
+        if (!serverOnline)
+            return;
+        await mc.command('/scoreboard players set #timeout fired 0');
+        await mc.command('/function timeout_test:__load').catch(() => { });
+        await mc.command('/function timeout_test:start');
+        await mc.ticks(10);
+        expect(await mc.scoreboard('#timeout', 'fired')).toBe(0);
+        await mc.ticks(15);
+        expect(await mc.scoreboard('#timeout', 'fired')).toBe(1);
+    });
+    test('interval-test.mcrs: setInterval repeats on schedule', async () => {
+        if (!serverOnline)
+            return;
+        await mc.command('/scoreboard players set #interval ticks 0');
+        await mc.command('/function interval_test:__load').catch(() => { });
+        await mc.command('/function interval_test:start');
+        await mc.ticks(70);
+        const count = await mc.scoreboard('#interval', 'ticks');
+        expect(count).toBeGreaterThanOrEqual(3);
+        expect(count).toBeLessThanOrEqual(3);
+    });
+    test('is-check-test.mcrs: foreach is-narrowing only matches zombie entities', async () => {
+        if (!serverOnline)
+            return;
+        await mc.fullReset({ clearArea: false, killEntities: true, resetScoreboards: false });
+        await mc.command('/scoreboard players set #is_check players 0');
+        await mc.command('/scoreboard players set #is_check zombies 0');
+        await mc.command('/function is_check_test:__load').catch(() => { });
+        await mc.command('/summon minecraft:zombie 0 65 0');
+        await mc.command('/tag @e[type=minecraft:zombie,sort=nearest,limit=1] add is_check_target');
+        await mc.command('/summon minecraft:armor_stand 2 65 0');
+        await mc.command('/tag @e[type=minecraft:armor_stand,sort=nearest,limit=1] add is_check_target');
+        await mc.command('/function is_check_test:check_types');
+        await mc.ticks(5);
+        const zombies = await mc.scoreboard('#is_check', 'zombies');
+        const players = await mc.scoreboard('#is_check', 'players');
+        const zombieEntities = await mc.entities('@e[type=minecraft:zombie,tag=is_check_target]');
+        const standEntities = await mc.entities('@e[type=minecraft:armor_stand,tag=is_check_target]');
+        expect(zombies).toBe(1);
+        expect(players).toBe(0);
+        expect(zombieEntities).toHaveLength(0);
+        expect(standEntities).toHaveLength(1);
+        await mc.command('/kill @e[tag=is_check_target]').catch(() => { });
+    });
+    test('event-test.mcrs: @on(PlayerDeath) compiles and loads', async () => {
+        if (!serverOnline)
+            return;
+        // Verify the event system compiles correctly
+        await mc.command('/function event_test:__load').catch(() => { });
+        await mc.ticks(5);
+        // Verify the trigger function exists
+        const result = await mc.command('/function event_test:trigger_fake_death');
+        expect(result.ok).toBe(true);
+        // Verify __tick exists (event dispatcher)
+        const tickResult = await mc.command('/function event_test:__tick').catch(() => ({ ok: false }));
+        expect(tickResult.ok).toBe(true);
+    });
+});
 //# sourceMappingURL=mc-integration.test.js.map

package/dist/__tests__/mc-syntax.test.js

@@ -80,6 +80,18 @@ fn chat() {
 `, 'interpolation');
         expect(errors).toHaveLength(0);
     });
+    test('f-strings generate valid tellraw/title commands', () => {
+        const errors = validateSource(validator, `
+fn chat() {
+    let score: int = 7;
+    say(f"You have {score} points");
+    tellraw(@a, f"Score: {score}");
+    actionbar(@s, f"Score: {score}");
+    title(@s, f"Score: {score}");
+}
+`, 'f-string');
+        expect(errors).toHaveLength(0);
+    });
     test('array operations generate valid data commands', () => {
         const errors = validateSource(validator, `
 fn arrays() {

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

@@ -26,11 +26,11 @@ fn turret_tick() {
         const result = (0, index_1.compile)(source, { namespace: 'test' });
         const parent = getFileContent(result.files, 'data/test/function/turret_tick.mcfunction');
         const loopBody = getFileContent(result.files, 'data/test/function/turret_tick/foreach_0.mcfunction');
-        const hoistedRead = 'execute store result score $_0 rs run scoreboard players get config turret_range';
+        const hoistedRead = 'execute store result score $_0 rs run scoreboard players get config test.turret_range';
         const executeCall = 'execute as @e[tag=turret] run function test:turret_tick/foreach_0';
         expect(parent).toContain(hoistedRead);
         expect(parent.indexOf(hoistedRead)).toBeLessThan(parent.indexOf(executeCall));
-        expect(loopBody).not.toContain('scoreboard players get config turret_range');
+        expect(loopBody).not.toContain('scoreboard players get config test.turret_range');
     });
 });
 describe('CSE', () => {
@@ -46,7 +46,7 @@ fn read_twice() {
 `;
         const result = (0, index_1.compile)(source, { namespace: 'test' });
         const fn = getFileContent(result.files, 'data/test/function/read_twice.mcfunction');
-        const readMatches = fn.match(/scoreboard players get @s coins/g) ?? [];
+        const readMatches = fn.match(/scoreboard players get @s test\.coins/g) ?? [];
         expect(readMatches).toHaveLength(1);
         expect(fn).toContain('scoreboard players operation $_1 rs = $_0 rs');
     });

package/dist/__tests__/parser.test.js

@@ -23,6 +23,7 @@ describe('Parser', () => {
             const program = parse('');
             expect(program.namespace).toBe('test');
             expect(program.declarations).toEqual([]);
+            expect(program.implBlocks).toEqual([]);
             expect(program.enums).toEqual([]);
             expect(program.consts).toEqual([]);
         });
@@ -90,6 +91,12 @@ describe('Parser', () => {
                 { name: 'on_death' },
             ]);
         });
+        it('parses @on event decorators', () => {
+            const program = parse('@on(PlayerDeath)\nfn handle_death(player: Player) {}');
+            expect(program.declarations[0].decorators).toEqual([
+                { name: 'on', args: { eventType: 'PlayerDeath' } },
+            ]);
+        });
     });
     describe('types', () => {
         it('parses primitive types', () => {
@@ -134,6 +141,50 @@ describe('Parser', () => {
                 },
             ]);
         });
+        it('parses impl blocks', () => {
+            const program = parse(`
+struct Timer { duration: int }
+
+impl Timer {
+  fn new(duration: int): Timer {
+    return { duration: duration };
+  }
+
+  fn start(self) {}
+}
+`);
+            expect(program.implBlocks).toHaveLength(1);
+            expect(program.implBlocks[0].typeName).toBe('Timer');
+            expect(program.implBlocks[0].methods.map(method => method.name)).toEqual(['new', 'start']);
+            expect(program.implBlocks[0].methods[1].params[0]).toEqual({
+                name: 'self',
+                type: { kind: 'struct', name: 'Timer' },
+                default: undefined,
+            });
+        });
+        it('parses impl blocks with static and instance methods', () => {
+            const program = parse(`
+struct Point { x: int, y: int }
+
+impl Point {
+  fn new(x: int, y: int) -> Point {
+    return { x: x, y: y };
+  }
+
+  fn distance(self) -> int {
+    return self.x + self.y;
+  }
+}
+`);
+            expect(program.implBlocks).toHaveLength(1);
+            expect(program.implBlocks[0].typeName).toBe('Point');
+            expect(program.implBlocks[0].methods[0].params.map(param => param.name)).toEqual(['x', 'y']);
+            expect(program.implBlocks[0].methods[1].params[0]).toEqual({
+                name: 'self',
+                type: { kind: 'struct', name: 'Point' },
+                default: undefined,
+            });
+        });
     });
     describe('statements', () => {
         it('parses let statement', () => {
@@ -173,6 +224,26 @@ describe('Parser', () => {
             expect(stmt.kind).toBe('if');
             expect(stmt.else_).toHaveLength(1);
         });
+        it('parses entity is-checks in if conditions', () => {
+            const stmt = parseStmt('if (e is Player) { kill(@s); }');
+            expect(stmt.kind).toBe('if');
+            expect(stmt.cond).toEqual({
+                kind: 'is_check',
+                expr: { kind: 'ident', name: 'e' },
+                entityType: 'Player',
+            });
+        });
+        it('parses entity is-checks inside foreach bodies', () => {
+            const stmt = parseStmt('foreach (e in @e) { if (e is Zombie) { kill(e); } }');
+            expect(stmt.kind).toBe('foreach');
+            const innerIf = stmt.body[0];
+            expect(innerIf.kind).toBe('if');
+            expect(innerIf.cond).toEqual({
+                kind: 'is_check',
+                expr: { kind: 'ident', name: 'e' },
+                entityType: 'Zombie',
+            });
+        });
         it('parses while statement', () => {
             const stmt = parseStmt('while (i > 0) { i = i - 1; }');
             expect(stmt.kind).toBe('while');
@@ -358,6 +429,16 @@ describe('Parser', () => {
                     ],
                 });
             });
+            it('parses f-string literal', () => {
+                const expr = parseExpr('f"Score: {x}"');
+                expect(expr).toEqual({
+                    kind: 'f_string',
+                    parts: [
+                        { kind: 'text', value: 'Score: ' },
+                        { kind: 'expr', expr: { kind: 'ident', name: 'x' } },
+                    ],
+                });
+            });
             it('parses boolean literals', () => {
                 expect(parseExpr('true')).toEqual({ kind: 'bool_lit', value: true });
                 expect(parseExpr('false')).toEqual({ kind: 'bool_lit', value: false });
@@ -429,6 +510,15 @@ describe('Parser', () => {
                 });
             });
         });
+        it('parses static method calls', () => {
+            const expr = parseExpr('Timer::new(100)');
+            expect(expr).toEqual({
+                kind: 'static_call',
+                type: 'Timer',
+                method: 'new',
+                args: [{ kind: 'int_lit', value: 100 }],
+            });
+        });
         describe('binary operators', () => {
             it('parses arithmetic', () => {
                 const expr = parseExpr('1 + 2');

package/dist/__tests__/runtime.test.js

@@ -81,7 +81,7 @@ fn compute() {
 `);
         runtime.load();
         runtime.execFunction('compute');
-        expect(runtime.getScore('math', 'result')).toBe(11);
+        expect(runtime.getScore('math', 'runtime.result')).toBe(11);
     });
     it('captures say, announce, actionbar, and title output in the chat log', () => {
         const runtime = loadCompiledProgram(`
@@ -107,6 +107,19 @@ fn chat() {
     let score: int = 7;
     say("You have \${score} points");
 }
+`);
+        runtime.load();
+        runtime.execFunction('chat');
+        expect(runtime.getChatLog()).toEqual([
+            'You have 7 points',
+        ]);
+    });
+    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');
@@ -146,8 +159,8 @@ fn arrays() {
 `);
         runtime.load();
         runtime.execFunction('arrays');
-        expect(runtime.getScore('arrays', 'len')).toBe(1);
-        expect(runtime.getScore('arrays', 'last')).toBe(9);
+        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', () => {
@@ -182,7 +195,7 @@ fn pulse() {
 `);
         runtime.load();
         runtime.ticks(10);
-        expect(runtime.getScore('pulse', 'count')).toBe(2);
+        expect(runtime.getScore('pulse', 'runtime.count')).toBe(2);
     });
     it('executes only the matching match arm', () => {
         const runtime = loadCompiledProgram(`
@@ -229,7 +242,7 @@ fn test() {
 `);
         runtime.load();
         runtime.execFunction('test');
-        expect(runtime.getScore('lambda', 'direct')).toBe(10);
+        expect(runtime.getScore('lambda', 'runtime.direct')).toBe(10);
     });
     it('executes lambdas passed as callback arguments', () => {
         const runtime = loadCompiledProgram(`
@@ -244,7 +257,7 @@ fn test() {
 `);
         runtime.load();
         runtime.execFunction('test');
-        expect(runtime.getScore('lambda', 'callback')).toBe(15);
+        expect(runtime.getScore('lambda', 'runtime.callback')).toBe(15);
     });
     it('executes block-body lambdas', () => {
         const runtime = loadCompiledProgram(`
@@ -259,7 +272,7 @@ fn test() {
 `);
         runtime.load();
         runtime.execFunction('test');
-        expect(runtime.getScore('lambda', 'block')).toBe(11);
+        expect(runtime.getScore('lambda', 'runtime.block')).toBe(11);
     });
     it('executes immediately-invoked expression-body lambdas', () => {
         const runtime = loadCompiledProgram(`
@@ -270,7 +283,7 @@ fn test() {
 `);
         runtime.load();
         runtime.execFunction('test');
-        expect(runtime.getScore('lambda', 'iife')).toBe(10);
+        expect(runtime.getScore('lambda', 'runtime.iife')).toBe(10);
     });
 });
 //# sourceMappingURL=runtime.test.js.map