redscript-mc 2.0.0 → 2.1.1

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

@@ -0,0 +1,206 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * Tests for the small constant loop unrolling pass.
+ *
+ * We test through the full compiler pipeline (source → MIR → optimize)
+ * to verify realistic unroll behavior, and also test the pass directly
+ * with synthetic MIR for edge cases.
+ */
+const lexer_1 = require("../../lexer");
+const parser_1 = require("../../parser");
+const lower_1 = require("../../hir/lower");
+const lower_2 = require("../../mir/lower");
+const pipeline_1 = require("../../optimizer/pipeline");
+const unroll_1 = require("../../optimizer/unroll");
+function compileToMIR(source) {
+    const tokens = new lexer_1.Lexer(source).tokenize();
+    const ast = new parser_1.Parser(tokens).parse('test');
+    const hir = (0, lower_1.lowerToHIR)(ast);
+    const mir = (0, lower_2.lowerToMIR)(hir);
+    return mir.functions;
+}
+function mkBlock(id, instrs, term, preds = []) {
+    return { id, instrs, term, preds };
+}
+function mkFn(blocks) {
+    return { name: 'test', params: [], blocks, entry: 'entry', isMacro: false };
+}
+const c = (v) => ({ kind: 'const', value: v });
+const t = (n) => ({ kind: 'temp', name: n });
+// ---------------------------------------------------------------------------
+// Synthetic MIR tests
+// ---------------------------------------------------------------------------
+describe('loopUnroll — synthetic MIR', () => {
+    /**
+     * Build a minimal for(i=0; i<N; i++) loop in MIR form:
+     *   entry: const i 0; jump → loop_header
+     *   loop_header: cmp t_cmp lt i N; branch t_cmp → loop_body / loop_exit
+     *   loop_body: [body instrs]; jump → loop_latch
+     *   loop_latch: add i i 1; jump → loop_header
+     *   loop_exit: return null
+     */
+    function buildLoop(N, bodyInstrs) {
+        return mkFn([
+            mkBlock('entry', [
+                { kind: 'const', dst: 'i', value: 0 },
+            ], { kind: 'jump', target: 'loop_header_0' }),
+            mkBlock('loop_header_0', [
+                { kind: 'cmp', dst: 't_cmp', op: 'lt', a: t('i'), b: c(N) },
+            ], { kind: 'branch', cond: t('t_cmp'), then: 'loop_body_0', else: 'loop_exit_0' }),
+            mkBlock('loop_body_0', bodyInstrs, { kind: 'jump', target: 'loop_latch_0' }),
+            mkBlock('loop_latch_0', [
+                { kind: 'add', dst: 'i', a: t('i'), b: c(1) },
+            ], { kind: 'jump', target: 'loop_header_0' }),
+            mkBlock('loop_exit_0', [], { kind: 'return', value: null }),
+        ]);
+    }
+    test('for(i=0; i<3; i++) unrolls to 3 copies of body', () => {
+        const bodyInstrs = [
+            { kind: 'call', dst: null, fn: 'test:body', args: [t('i')] },
+        ];
+        const fn = buildLoop(3, bodyInstrs);
+        const result = (0, unroll_1.loopUnroll)(fn);
+        // loop_header, loop_body, loop_latch should be gone
+        expect(result.blocks.some(b => b.id.startsWith('loop_header'))).toBe(false);
+        expect(result.blocks.some(b => b.id.startsWith('loop_latch'))).toBe(false);
+        expect(result.blocks.some(b => b.id.startsWith('loop_body'))).toBe(false);
+        // loop_exit should still be there
+        expect(result.blocks.some(b => b.id.startsWith('loop_exit'))).toBe(true);
+        // entry block should contain 3 call instructions with substituted i values
+        const entry = result.blocks.find(b => b.id === 'entry');
+        const calls = entry.instrs.filter(instr => instr.kind === 'call');
+        expect(calls).toHaveLength(3);
+        // Each call should have i substituted as 0, 1, 2
+        expect(calls[0].args[0]).toEqual(c(0));
+        expect(calls[1].args[0]).toEqual(c(1));
+        expect(calls[2].args[0]).toEqual(c(2));
+    });
+    test('for(i=0; i<1; i++) unrolls to 1 copy', () => {
+        const bodyInstrs = [
+            { kind: 'call', dst: null, fn: 'test:body', args: [t('i')] },
+        ];
+        const fn = buildLoop(1, bodyInstrs);
+        const result = (0, unroll_1.loopUnroll)(fn);
+        const entry = result.blocks.find(b => b.id === 'entry');
+        const calls = entry.instrs.filter(instr => instr.kind === 'call');
+        expect(calls).toHaveLength(1);
+        expect(calls[0].args[0]).toEqual(c(0));
+    });
+    test('for(i=0; i<8; i++) unrolls to 8 copies (at limit)', () => {
+        const bodyInstrs = [
+            { kind: 'call', dst: null, fn: 'test:body', args: [t('i')] },
+        ];
+        const fn = buildLoop(8, bodyInstrs);
+        const result = (0, unroll_1.loopUnroll)(fn);
+        const entry = result.blocks.find(b => b.id === 'entry');
+        const calls = entry.instrs.filter(instr => instr.kind === 'call');
+        expect(calls).toHaveLength(8);
+    });
+    test('for(i=0; i<9; i++) does NOT unroll (exceeds limit)', () => {
+        const bodyInstrs = [
+            { kind: 'call', dst: null, fn: 'test:body', args: [t('i')] },
+        ];
+        const fn = buildLoop(9, bodyInstrs);
+        const result = (0, unroll_1.loopUnroll)(fn);
+        // Should not have changed — loop blocks remain
+        expect(result.blocks.some(b => b.id.startsWith('loop_header'))).toBe(true);
+        expect(result).toBe(fn);
+    });
+    test('for(i=0; i<10; i++) does NOT unroll', () => {
+        const bodyInstrs = [
+            { kind: 'call', dst: null, fn: 'test:body', args: [t('i')] },
+        ];
+        const fn = buildLoop(10, bodyInstrs);
+        const result = (0, unroll_1.loopUnroll)(fn);
+        expect(result.blocks.some(b => b.id.startsWith('loop_header'))).toBe(true);
+    });
+    test('variable substitution replaces i in arithmetic', () => {
+        // Body: x = i * 2
+        const bodyInstrs = [
+            { kind: 'mul', dst: 'x', a: t('i'), b: c(2) },
+            { kind: 'call', dst: null, fn: 'test:use', args: [t('x')] },
+        ];
+        const fn = buildLoop(3, bodyInstrs);
+        const result = (0, unroll_1.loopUnroll)(fn);
+        const entry = result.blocks.find(b => b.id === 'entry');
+        const muls = entry.instrs.filter(instr => instr.kind === 'mul');
+        expect(muls).toHaveLength(3);
+        expect(muls[0].a).toEqual(c(0));
+        expect(muls[1].a).toEqual(c(1));
+        expect(muls[2].a).toEqual(c(2));
+    });
+    test('init must be 0 — does not unroll if initialized to non-zero', () => {
+        // entry: const i 1 (not 0)
+        const fn = mkFn([
+            mkBlock('entry', [
+                { kind: 'const', dst: 'i', value: 1 },
+            ], { kind: 'jump', target: 'loop_header_0' }),
+            mkBlock('loop_header_0', [
+                { kind: 'cmp', dst: 't_cmp', op: 'lt', a: t('i'), b: c(3) },
+            ], { kind: 'branch', cond: t('t_cmp'), then: 'loop_body_0', else: 'loop_exit_0' }),
+            mkBlock('loop_body_0', [
+                { kind: 'call', dst: null, fn: 'test:body', args: [t('i')] },
+            ], { kind: 'jump', target: 'loop_latch_0' }),
+            mkBlock('loop_latch_0', [
+                { kind: 'add', dst: 'i', a: t('i'), b: c(1) },
+            ], { kind: 'jump', target: 'loop_header_0' }),
+            mkBlock('loop_exit_0', [], { kind: 'return', value: null }),
+        ]);
+        const result = (0, unroll_1.loopUnroll)(fn);
+        expect(result).toBe(fn);
+    });
+    test('non-lt comparison does not unroll', () => {
+        // loop_header: cmp le (not lt)
+        const fn = mkFn([
+            mkBlock('entry', [
+                { kind: 'const', dst: 'i', value: 0 },
+            ], { kind: 'jump', target: 'loop_header_0' }),
+            mkBlock('loop_header_0', [
+                { kind: 'cmp', dst: 't_cmp', op: 'le', a: t('i'), b: c(3) },
+            ], { kind: 'branch', cond: t('t_cmp'), then: 'loop_body_0', else: 'loop_exit_0' }),
+            mkBlock('loop_body_0', [
+                { kind: 'call', dst: null, fn: 'test:body', args: [t('i')] },
+            ], { kind: 'jump', target: 'loop_latch_0' }),
+            mkBlock('loop_latch_0', [
+                { kind: 'add', dst: 'i', a: t('i'), b: c(1) },
+            ], { kind: 'jump', target: 'loop_header_0' }),
+            mkBlock('loop_exit_0', [], { kind: 'return', value: null }),
+        ]);
+        const result = (0, unroll_1.loopUnroll)(fn);
+        expect(result).toBe(fn);
+    });
+});
+// ---------------------------------------------------------------------------
+// End-to-end tests via full compiler pipeline
+// ---------------------------------------------------------------------------
+describe('loopUnroll — end-to-end via optimizeFunction', () => {
+    test('for(0..3) loop is unrolled after full optimization', () => {
+        const fns = compileToMIR(`
+      fn f(): void {
+        for (let i: int = 0; i < 3; i = i + 1) {
+          cmd("say " + i);
+        }
+      }
+    `);
+        const fn = fns[0];
+        const optimized = (0, pipeline_1.optimizeFunction)(fn);
+        // After optimization, loop blocks should be gone
+        expect(optimized.blocks.some(b => b.id.startsWith('loop_header'))).toBe(false);
+        expect(optimized.blocks.some(b => b.id.startsWith('loop_latch'))).toBe(false);
+    });
+    test('for(0..10) loop is NOT unrolled', () => {
+        const fns = compileToMIR(`
+      fn f(): void {
+        for (let i: int = 0; i < 10; i = i + 1) {
+          cmd("say " + i);
+        }
+      }
+    `);
+        const fn = fns[0];
+        const optimized = (0, pipeline_1.optimizeFunction)(fn);
+        // Loop blocks should remain (N=10 > limit)
+        expect(optimized.blocks.some(b => b.id.startsWith('loop_header'))).toBe(true);
+    });
+});
+//# sourceMappingURL=unroll.test.js.map

package/dist/src/__tests__/option.test.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Tests for Phase 6a: Option<T> — null safety
+ *
+ * Covers:
+ * - Parsing Option<T> type annotation
+ * - Parsing Some(expr) and None expressions
+ * - Parsing if let Some(x) = opt { ... }
+ * - HIR lowering of Option nodes
+ * - MIR lowering: Option compiles to two slots (has + val)
+ * - if let Some(x) = opt → checks has slot, binds val slot
+ * - Function returning Option<int>
+ * - Correct scoreboard commands generated
+ */
+export {};

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

@@ -0,0 +1,275 @@
+"use strict";
+/**
+ * Tests for Phase 6a: Option<T> — null safety
+ *
+ * Covers:
+ * - Parsing Option<T> type annotation
+ * - Parsing Some(expr) and None expressions
+ * - Parsing if let Some(x) = opt { ... }
+ * - HIR lowering of Option nodes
+ * - MIR lowering: Option compiles to two slots (has + val)
+ * - if let Some(x) = opt → checks has slot, binds val slot
+ * - Function returning Option<int>
+ * - Correct scoreboard commands generated
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+const lexer_1 = require("../lexer");
+const parser_1 = require("../parser");
+const compile_1 = require("../emit/compile");
+const lower_1 = require("../hir/lower");
+function parse(source, namespace = 'test') {
+    const tokens = new lexer_1.Lexer(source).tokenize();
+    return new parser_1.Parser(tokens).parse(namespace);
+}
+function getFile(files, pathSubstr) {
+    // Prefer exact function file match: look for function/<name>.mcfunction
+    const exact = files.find(f => f.path.endsWith(`function/${pathSubstr}.mcfunction`));
+    if (exact)
+        return exact.content;
+    const f = files.find(f => f.path.includes(pathSubstr));
+    return f?.content;
+}
+// ---------------------------------------------------------------------------
+// Parser tests
+// ---------------------------------------------------------------------------
+describe('Option: Parser', () => {
+    it('parses Option<int> type annotation', () => {
+        const prog = parse('fn f(): Option<int> {}');
+        expect(prog.declarations[0].returnType).toEqual({ kind: 'option', inner: { kind: 'named', name: 'int' } });
+    });
+    it('parses Option<bool> parameter type', () => {
+        const prog = parse('fn f(x: Option<bool>): void {}');
+        expect(prog.declarations[0].params[0].type).toEqual({ kind: 'option', inner: { kind: 'named', name: 'bool' } });
+    });
+    it('parses Some(42) expression', () => {
+        const prog = parse('fn f(): void { let x: Option<int> = Some(42); }');
+        const letStmt = prog.declarations[0].body[0];
+        expect(letStmt.kind).toBe('let');
+        if (letStmt.kind === 'let') {
+            expect(letStmt.init.kind).toBe('some_lit');
+            if (letStmt.init.kind === 'some_lit') {
+                expect(letStmt.init.value).toEqual({ kind: 'int_lit', value: 42 });
+            }
+        }
+    });
+    it('parses None expression', () => {
+        const prog = parse('fn f(): void { let x: Option<int> = None; }');
+        const letStmt = prog.declarations[0].body[0];
+        expect(letStmt.kind).toBe('let');
+        if (letStmt.kind === 'let') {
+            expect(letStmt.init.kind).toBe('none_lit');
+        }
+    });
+    it('parses if let Some(x) = opt { ... }', () => {
+        const prog = parse('fn f(p: Option<int>): void { if let Some(x) = p { let y: int = x; } }');
+        const stmt = prog.declarations[0].body[0];
+        expect(stmt.kind).toBe('if_let_some');
+        if (stmt.kind === 'if_let_some') {
+            expect(stmt.binding).toBe('x');
+            expect(stmt.init).toEqual({ kind: 'ident', name: 'p' });
+            expect(stmt.then.length).toBe(1);
+        }
+    });
+    it('parses if let Some(x) = opt { } else { }', () => {
+        const prog = parse(`
+      fn f(p: Option<int>): void {
+        if let Some(x) = p {
+          let a: int = x;
+        } else {
+          let b: int = 0;
+        }
+      }
+    `);
+        const stmt = prog.declarations[0].body[0];
+        expect(stmt.kind).toBe('if_let_some');
+        if (stmt.kind === 'if_let_some') {
+            expect(stmt.else_).toBeDefined();
+            expect(stmt.else_.length).toBe(1);
+        }
+    });
+    it('does not treat Some as identifier', () => {
+        const prog = parse('fn f(): void { let x: Option<int> = Some(1); }');
+        if (prog.declarations[0].body[0].kind === 'let') {
+            const init = prog.declarations[0].body[0].init;
+            expect(init.kind).toBe('some_lit');
+        }
+    });
+    it('does not treat None as identifier', () => {
+        const prog = parse('fn f(): void { let x: Option<int> = None; }');
+        if (prog.declarations[0].body[0].kind === 'let') {
+            const init = prog.declarations[0].body[0].init;
+            expect(init.kind).toBe('none_lit');
+        }
+    });
+});
+// ---------------------------------------------------------------------------
+// HIR lowering tests
+// ---------------------------------------------------------------------------
+describe('Option: HIR lowering', () => {
+    function hirOf(source) {
+        const tokens = new lexer_1.Lexer(source).tokenize();
+        const ast = new parser_1.Parser(tokens).parse('test');
+        return (0, lower_1.lowerToHIR)(ast);
+    }
+    it('lowers some_lit through HIR unchanged', () => {
+        const hir = hirOf('fn f(): void { let x: Option<int> = Some(42); }');
+        const fn0 = hir.functions[0];
+        const letStmt = fn0.body[0];
+        expect(letStmt.kind).toBe('let');
+        if (letStmt.kind === 'let') {
+            expect(letStmt.init.kind).toBe('some_lit');
+        }
+    });
+    it('lowers none_lit through HIR unchanged', () => {
+        const hir = hirOf('fn f(): void { let x: Option<int> = None; }');
+        const fn0 = hir.functions[0];
+        const letStmt = fn0.body[0];
+        expect(letStmt.kind).toBe('let');
+        if (letStmt.kind === 'let') {
+            expect(letStmt.init.kind).toBe('none_lit');
+        }
+    });
+    it('lowers if_let_some through HIR unchanged', () => {
+        const hir = hirOf('fn f(p: Option<int>): void { if let Some(x) = p {} }');
+        const fn0 = hir.functions[0];
+        const stmt = fn0.body[0];
+        expect(stmt.kind).toBe('if_let_some');
+        if (stmt.kind === 'if_let_some') {
+            expect(stmt.binding).toBe('x');
+        }
+    });
+});
+// ---------------------------------------------------------------------------
+// Compilation (E2E) tests
+// ---------------------------------------------------------------------------
+describe('Option: E2E compilation', () => {
+    it('compiles Some(42) assignment — sets has=1, val=42', () => {
+        const source = `
+      fn test(): void {
+        let p: Option<int> = Some(42);
+      }
+    `;
+        const result = (0, compile_1.compile)(source, { namespace: 'test' });
+        const fn = getFile(result.files, 'test');
+        expect(fn).toBeDefined();
+        expect(fn).toContain('scoreboard players set');
+        // has slot should be set to 1, val slot should be set to 42
+        expect(fn).toContain('1');
+        expect(fn).toContain('42');
+    });
+    it('compiles None assignment — sets has=0', () => {
+        const source = `
+      fn test(): void {
+        let p: Option<int> = None;
+      }
+    `;
+        const result = (0, compile_1.compile)(source, { namespace: 'test' });
+        const fn = getFile(result.files, 'test');
+        expect(fn).toBeDefined();
+        expect(fn).toContain('scoreboard players set');
+        expect(fn).toContain('0');
+    });
+    it('compiles if let Some(x) = p — conditional on has slot', () => {
+        const source = `
+      fn test(p: Option<int>): void {
+        if let Some(x) = p {
+          let y: int = x;
+        }
+      }
+    `;
+        const result = (0, compile_1.compile)(source, { namespace: 'test' });
+        // Should generate a conditional call checking has slot
+        expect(result.files.length).toBeGreaterThan(0);
+    });
+    it('compiles function returning Option<int> Some value', () => {
+        const source = `
+      fn make_some(): Option<int> {
+        return Some(99);
+      }
+      fn test(): void {
+        let p: Option<int> = make_some();
+      }
+    `;
+        const result = (0, compile_1.compile)(source, { namespace: 'test' });
+        const fn = getFile(result.files, 'make_some');
+        expect(fn).toBeDefined();
+        // Should set ret_has=1 and ret_val=99
+        expect(fn).toContain('$ret_has');
+        expect(fn).toContain('99');
+    });
+    it('compiles function returning Option<int> None value', () => {
+        const source = `
+      fn make_none(): Option<int> {
+        return None;
+      }
+    `;
+        const result = (0, compile_1.compile)(source, { namespace: 'test' });
+        const fn = getFile(result.files, 'make_none');
+        expect(fn).toBeDefined();
+        expect(fn).toContain('$ret_has');
+        // has=0
+        expect(fn).toContain('0');
+    });
+    it('compiles full if-let Some pattern with body using bound variable', () => {
+        // Use a function that returns Option<int> so the condition is not constant-folded
+        const source = `
+      fn maybe_val(): Option<int> {
+        return Some(10);
+      }
+      @tick
+      fn tick(): void {
+        let p: Option<int> = maybe_val();
+        if let Some(n) = p {
+          let doubled: int = n + n;
+        }
+      }
+    `;
+        const result = (0, compile_1.compile)(source, { namespace: 'test' });
+        expect(result.files.length).toBeGreaterThan(0);
+        // Verify a conditional function split was created
+        const hasConditional = result.files.some(f => f.content.includes('execute if score'));
+        expect(hasConditional).toBe(true);
+    });
+    it('compiles if-let with else branch', () => {
+        const source = `
+      @tick
+      fn tick(): void {
+        let q: Option<int> = None;
+        if let Some(v) = q {
+          let a: int = v;
+        } else {
+          let b: int = 0;
+        }
+      }
+    `;
+        const result = (0, compile_1.compile)(source, { namespace: 'test' });
+        expect(result.files.length).toBeGreaterThan(0);
+    });
+    it('compiles nested if-let inside if-let', () => {
+        const source = `
+      fn test(): void {
+        let a: Option<int> = Some(1);
+        let b: Option<int> = Some(2);
+        if let Some(x) = a {
+          if let Some(y) = b {
+            let sum: int = x + y;
+          }
+        }
+      }
+    `;
+        const result = (0, compile_1.compile)(source, { namespace: 'test' });
+        expect(result.files.length).toBeGreaterThan(0);
+    });
+    it('generated scoreboard slots are unique per function and variable', () => {
+        const source = `
+      fn test(): void {
+        let p: Option<int> = Some(5);
+        let q: Option<int> = None;
+      }
+    `;
+        const result = (0, compile_1.compile)(source, { namespace: 'test' });
+        const fn = getFile(result.files, 'test');
+        expect(fn).toBeDefined();
+    });
+});
+//# sourceMappingURL=option.test.js.map

package/dist/src/__tests__/schedule.test.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Tests for @schedule decorator (Phase 5c)
+ *
+ * @schedule(ticks=N) generates a _schedule_xxx.mcfunction wrapper that
+ * emits `schedule function ns:xxx Nt`.
+ */
+export {};

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

@@ -0,0 +1,98 @@
+"use strict";
+/**
+ * Tests for @schedule decorator (Phase 5c)
+ *
+ * @schedule(ticks=N) generates a _schedule_xxx.mcfunction wrapper that
+ * emits `schedule function ns:xxx Nt`.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+const compile_1 = require("../emit/compile");
+function getFile(files, pathSubstr) {
+    const f = files.find(f => f.path.includes(pathSubstr));
+    return f?.content;
+}
+describe('@schedule decorator', () => {
+    test('@schedule(ticks=20) generates _schedule wrapper with 20t', () => {
+        const source = `
+      @schedule(ticks=20)
+      fn after_one_second(): void {
+        say("One second passed!");
+      }
+    `;
+        const result = (0, compile_1.compile)(source, { namespace: 'test' });
+        const wrapper = getFile(result.files, '_schedule_after_one_second.mcfunction');
+        expect(wrapper).toBeDefined();
+        expect(wrapper).toBe('schedule function test:after_one_second 20t\n');
+    });
+    test('@schedule(ticks=1) generates _schedule wrapper with 1t', () => {
+        const source = `
+      @schedule(ticks=1)
+      fn next_tick(): void {
+        say("next tick!");
+      }
+    `;
+        const result = (0, compile_1.compile)(source, { namespace: 'ns' });
+        const wrapper = getFile(result.files, '_schedule_next_tick.mcfunction');
+        expect(wrapper).toBeDefined();
+        expect(wrapper).toBe('schedule function ns:next_tick 1t\n');
+    });
+    test('@schedule does not affect tick.json', () => {
+        const source = `
+      @schedule(ticks=20)
+      fn deferred(): void {
+        say("deferred");
+      }
+    `;
+        const result = (0, compile_1.compile)(source, { namespace: 'test' });
+        const tickJson = getFile(result.files, 'tick.json');
+        expect(tickJson).toBeUndefined();
+    });
+    test('@schedule coexists with @tick and @load', () => {
+        const source = `
+      @tick
+      fn game_tick(): void {
+        let x: int = 1;
+      }
+
+      @load
+      fn init(): void {
+        let y: int = 0;
+      }
+
+      @schedule(ticks=40)
+      fn two_seconds(): void {
+        say("two seconds!");
+      }
+    `;
+        const result = (0, compile_1.compile)(source, { namespace: 'combo' });
+        // @tick still works
+        const tickJson = getFile(result.files, 'tick.json');
+        expect(tickJson).toBeDefined();
+        expect(JSON.parse(tickJson).values).toContain('combo:game_tick');
+        // @load still works
+        const loadJson = getFile(result.files, 'load.json');
+        expect(loadJson).toBeDefined();
+        expect(JSON.parse(loadJson).values).toContain('combo:init');
+        // @schedule generates wrapper
+        const wrapper = getFile(result.files, '_schedule_two_seconds.mcfunction');
+        expect(wrapper).toBeDefined();
+        expect(wrapper).toBe('schedule function combo:two_seconds 40t\n');
+    });
+    test('calling _schedule_xxx() invokes the schedule wrapper', () => {
+        const source = `
+      @schedule(ticks=20)
+      fn after_one_second(): void {
+        say("delayed");
+      }
+
+      fn start(): void {
+        _schedule_after_one_second();
+      }
+    `;
+        const result = (0, compile_1.compile)(source, { namespace: 'test' });
+        const startFn = getFile(result.files, 'start.mcfunction');
+        expect(startFn).toBeDefined();
+        expect(startFn).toContain('function test:_schedule_after_one_second');
+    });
+});
+//# sourceMappingURL=schedule.test.js.map

package/dist/src/__tests__/sourcemap.test.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Source Map Tests — Phase 4a
+ *
+ * Verifies that generated .sourcemap.json files correctly map output lines
+ * back to source .mcrs locations.
+ */
+export {};