redscript-mc 1.2.30 → 2.1.0

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

@@ -0,0 +1,261 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const budget_1 = require("../lir/budget");
+const compile_1 = require("../emit/compile");
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+const NS = 'test';
+const OBJ = '__test';
+function slot(name) {
+    return { player: name, obj: OBJ };
+}
+function mkFn(name, instructions) {
+    return { name, instructions, isMacro: false, macroParams: [] };
+}
+function mkModule(functions) {
+    return { functions, namespace: NS, objective: OBJ };
+}
+// ---------------------------------------------------------------------------
+// Unit tests: estimateCommandCount
+// ---------------------------------------------------------------------------
+describe('estimateCommandCount', () => {
+    test('flat function — counts each instruction as 1', () => {
+        const fn = mkFn('simple', [
+            { kind: 'score_set', dst: slot('$x'), value: 0 },
+            { kind: 'score_set', dst: slot('$y'), value: 1 },
+            { kind: 'score_add', dst: slot('$x'), src: slot('$y') },
+        ]);
+        const mod = mkModule([fn]);
+        expect((0, budget_1.estimateCommandCount)('simple', mod)).toBe(3);
+    });
+    test('function calling another — sums callee cost', () => {
+        const callee = mkFn('helper', [
+            { kind: 'score_set', dst: slot('$a'), value: 42 },
+            { kind: 'score_set', dst: slot('$b'), value: 43 },
+        ]);
+        const caller = mkFn('main', [
+            { kind: 'score_set', dst: slot('$x'), value: 0 },
+            { kind: 'call', fn: `${NS}:helper` },
+        ]);
+        const mod = mkModule([caller, callee]);
+        // caller: 2 instrs + callee: 2 instrs = 4
+        expect((0, budget_1.estimateCommandCount)('main', mod)).toBe(4);
+    });
+    test('self-recursive function (loop) — multiplies by estimated iterations', () => {
+        // Simulate a loop: header checks condition, calls body, body calls header
+        const header = mkFn('loop__header', [
+            { kind: 'call_if_matches', fn: `${NS}:loop__body`, slot: slot('$i'), range: '..99' },
+        ]);
+        const body = mkFn('loop__body', [
+            { kind: 'score_add', dst: slot('$i'), src: slot('$one') },
+            { kind: 'score_set', dst: slot('$tmp'), value: 1 },
+            { kind: 'call', fn: `${NS}:loop__header` },
+        ]);
+        const mod = mkModule([header, body]);
+        // Cycle: header(1) + body(3) = 4 cmds/iteration
+        // Range ..99 → 100 iterations
+        // Total: 4 × 100 = 400
+        expect((0, budget_1.estimateCommandCount)('loop__header', mod)).toBe(400);
+    });
+    test('unknown loop bound defaults to 100 iterations', () => {
+        const header = mkFn('loop__header', [
+            { kind: 'call_if_score', fn: `${NS}:loop__body`, a: slot('$i'), op: 'lt', b: slot('$limit') },
+        ]);
+        const body = mkFn('loop__body', [
+            { kind: 'score_add', dst: slot('$i'), src: slot('$one') },
+            { kind: 'call', fn: `${NS}:loop__header` },
+        ]);
+        const mod = mkModule([header, body]);
+        // Cycle: 1 + 2 = 3 cmds/iteration, 100 default iterations = 300
+        expect((0, budget_1.estimateCommandCount)('loop__header', mod)).toBe(300);
+    });
+    test('nested loops — outer × inner', () => {
+        // Inner loop: inner_header ↔ inner_body (5 cmds/iter, 10 iters)
+        const innerHeader = mkFn('inner__header', [
+            { kind: 'call_if_matches', fn: `${NS}:inner__body`, slot: slot('$j'), range: '..9' },
+        ]);
+        const innerBody = mkFn('inner__body', [
+            { kind: 'score_set', dst: slot('$a'), value: 1 },
+            { kind: 'score_set', dst: slot('$b'), value: 2 },
+            { kind: 'score_add', dst: slot('$j'), src: slot('$one') },
+            { kind: 'call', fn: `${NS}:inner__header` },
+        ]);
+        // Outer loop: outer_header ↔ outer_body (calls inner loop + own work)
+        const outerHeader = mkFn('outer__header', [
+            { kind: 'call_if_matches', fn: `${NS}:outer__body`, slot: slot('$i'), range: '..19' },
+        ]);
+        const outerBody = mkFn('outer__body', [
+            { kind: 'score_set', dst: slot('$j'), value: 0 },
+            { kind: 'call', fn: `${NS}:inner__header` },
+            { kind: 'score_add', dst: slot('$i'), src: slot('$one') },
+            { kind: 'call', fn: `${NS}:outer__header` },
+        ]);
+        const mod = mkModule([innerHeader, innerBody, outerHeader, outerBody]);
+        // Inner cycle: header(1) + body(4) = 5 cmds × 10 iters = 50
+        // Outer cycle local: header(1) + body(4) = 5 cmds
+        // Outer cycle external callee: inner = 50
+        // Outer total: (5 + 50) × 20 = 1100
+        expect((0, budget_1.estimateCommandCount)('outer__header', mod)).toBe(1100);
+    });
+    test('external call (not in module) contributes 0', () => {
+        const fn = mkFn('main', [
+            { kind: 'score_set', dst: slot('$x'), value: 0 },
+            { kind: 'call', fn: 'other_ns:external_fn' },
+        ]);
+        const mod = mkModule([fn]);
+        expect((0, budget_1.estimateCommandCount)('main', mod)).toBe(2);
+    });
+});
+// ---------------------------------------------------------------------------
+// Unit tests: analyzeBudget
+// ---------------------------------------------------------------------------
+describe('analyzeBudget', () => {
+    test('small loop (100 iters × 5 cmds = 500) → no diagnostic', () => {
+        const header = mkFn('process', [
+            { kind: 'call_if_matches', fn: `${NS}:process__body`, slot: slot('$i'), range: '..99' },
+        ]);
+        const body = mkFn('process__body', [
+            { kind: 'score_set', dst: slot('$a'), value: 1 },
+            { kind: 'score_set', dst: slot('$b'), value: 2 },
+            { kind: 'score_add', dst: slot('$c'), src: slot('$a') },
+            { kind: 'call', fn: `${NS}:process` },
+        ]);
+        const mod = mkModule([header, body]);
+        const diags = (0, budget_1.analyzeBudget)(mod);
+        expect(diags).toEqual([]);
+    });
+    test('medium loop (1000 iters × 50 cmds = 50000) → warning', () => {
+        // Build a body with 48 instructions + 1 call back + header 1 = 50 per iter
+        const bodyInstrs = [];
+        for (let i = 0; i < 48; i++) {
+            bodyInstrs.push({ kind: 'score_set', dst: slot(`$v${i}`), value: i });
+        }
+        bodyInstrs.push({ kind: 'call', fn: `${NS}:bigloop` });
+        const header = mkFn('bigloop', [
+            { kind: 'call_if_matches', fn: `${NS}:bigloop__body`, slot: slot('$i'), range: '..999' },
+        ]);
+        const body = mkFn('bigloop__body', bodyInstrs);
+        const mod = mkModule([header, body]);
+        const diags = (0, budget_1.analyzeBudget)(mod);
+        expect(diags).toHaveLength(1);
+        expect(diags[0].level).toBe('warning');
+        expect(diags[0].fnName).toBe('bigloop');
+        expect(diags[0].estimatedCommands).toBe(50000);
+        expect(diags[0].message).toContain('consider @coroutine');
+    });
+    test('large loop (1000 iters × 100 cmds = 100000) → error', () => {
+        const bodyInstrs = [];
+        for (let i = 0; i < 98; i++) {
+            bodyInstrs.push({ kind: 'score_set', dst: slot(`$v${i}`), value: i });
+        }
+        bodyInstrs.push({ kind: 'call', fn: `${NS}:hugeloop` });
+        const header = mkFn('hugeloop', [
+            { kind: 'call_if_matches', fn: `${NS}:hugeloop__body`, slot: slot('$i'), range: '..999' },
+        ]);
+        const body = mkFn('hugeloop__body', bodyInstrs);
+        const mod = mkModule([header, body]);
+        const diags = (0, budget_1.analyzeBudget)(mod);
+        expect(diags).toHaveLength(1);
+        expect(diags[0].level).toBe('error');
+        expect(diags[0].fnName).toBe('hugeloop');
+        expect(diags[0].estimatedCommands).toBe(100000);
+    });
+    test('@coroutine function is skipped', () => {
+        const bodyInstrs = [];
+        for (let i = 0; i < 98; i++) {
+            bodyInstrs.push({ kind: 'score_set', dst: slot(`$v${i}`), value: i });
+        }
+        bodyInstrs.push({ kind: 'call', fn: `${NS}:bigfn` });
+        const header = mkFn('bigfn', [
+            { kind: 'call_if_matches', fn: `${NS}:bigfn__body`, slot: slot('$i'), range: '..999' },
+        ]);
+        const body = mkFn('bigfn__body', bodyInstrs);
+        const mod = mkModule([header, body]);
+        const diags = (0, budget_1.analyzeBudget)(mod, new Set(['bigfn']));
+        expect(diags).toEqual([]);
+    });
+    test('compiler-generated __helper functions are skipped', () => {
+        // Only top-level user functions are analyzed; __body etc are internal
+        const bodyInstrs = [];
+        for (let i = 0; i < 98; i++) {
+            bodyInstrs.push({ kind: 'score_set', dst: slot(`$v${i}`), value: i });
+        }
+        bodyInstrs.push({ kind: 'call', fn: `${NS}:fn__header` });
+        // Only fn__header and fn__body exist — both have __ so both skipped
+        const header = mkFn('fn__header', [
+            { kind: 'call_if_matches', fn: `${NS}:fn__body`, slot: slot('$i'), range: '..999' },
+        ]);
+        const body = mkFn('fn__body', bodyInstrs);
+        const mod = mkModule([header, body]);
+        const diags = (0, budget_1.analyzeBudget)(mod);
+        expect(diags).toEqual([]);
+    });
+    test('nested loop estimation is correct', () => {
+        // Inner: 5 cmds × 10 iters = 50
+        const innerHeader = mkFn('run__inner_header', [
+            { kind: 'call_if_matches', fn: `${NS}:run__inner_body`, slot: slot('$j'), range: '..9' },
+        ]);
+        const innerBody = mkFn('run__inner_body', [
+            { kind: 'score_set', dst: slot('$a'), value: 1 },
+            { kind: 'score_set', dst: slot('$b'), value: 2 },
+            { kind: 'score_add', dst: slot('$c'), src: slot('$a') },
+            { kind: 'call', fn: `${NS}:run__inner_header` },
+        ]);
+        // Outer: (5 + inner=50) × 20 = 1100
+        const outerHeader = mkFn('run__outer_header', [
+            { kind: 'call_if_matches', fn: `${NS}:run__outer_body`, slot: slot('$i'), range: '..19' },
+        ]);
+        const outerBody = mkFn('run__outer_body', [
+            { kind: 'score_set', dst: slot('$j'), value: 0 },
+            { kind: 'call', fn: `${NS}:run__inner_header` },
+            { kind: 'score_add', dst: slot('$i'), src: slot('$one') },
+            { kind: 'call', fn: `${NS}:run__outer_header` },
+        ]);
+        // The "root" user function that sets up the outer loop
+        const run = mkFn('run', [
+            { kind: 'score_set', dst: slot('$i'), value: 0 },
+            { kind: 'call', fn: `${NS}:run__outer_header` },
+        ]);
+        const mod = mkModule([run, innerHeader, innerBody, outerHeader, outerBody]);
+        const estimate = (0, budget_1.estimateCommandCount)('run', mod);
+        // run: 2 local + outer(1100) = 1102
+        expect(estimate).toBe(1102);
+    });
+});
+// ---------------------------------------------------------------------------
+// E2E: compile pipeline integration
+// ---------------------------------------------------------------------------
+describe('budget analysis — compile pipeline integration', () => {
+    test('small loop produces no warning', () => {
+        const source = `
+      fn process(): void {
+        let i: int = 0;
+        while (i < 10) {
+          let x: int = i * 2;
+          i = i + 1;
+        }
+      }
+    `;
+        const result = (0, compile_1.compile)(source, { namespace: 'budgettest' });
+        expect(result.warnings).toEqual([]);
+    });
+    test('@coroutine function skips budget check', () => {
+        const source = `
+      @coroutine(batch=5)
+      fn process_all(): void {
+        let i: int = 0;
+        while (i < 10000) {
+          let x: int = i * 2;
+          i = i + 1;
+        }
+      }
+    `;
+        // Should not throw even with huge loop — @coroutine exempts it
+        const result = (0, compile_1.compile)(source, { namespace: 'budgettest' });
+        // No budget error/warning for coroutine functions
+        const budgetWarnings = result.warnings.filter(w => w.includes('tick budget'));
+        expect(budgetWarnings).toEqual([]);
+    });
+});
+//# sourceMappingURL=budget.test.js.map

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

@@ -0,0 +1,104 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+const index_1 = require("../index");
+const fs = __importStar(require("fs"));
+const os = __importStar(require("os"));
+const path = __importStar(require("path"));
+// Note: watch command is tested manually as it's an interactive long-running process
+describe('CLI API', () => {
+    describe('imports', () => {
+        it('compiles a file with imported helpers', () => {
+            const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'redscript-imports-'));
+            const libPath = path.join(tempDir, 'lib.mcrs');
+            const mainPath = path.join(tempDir, 'main.mcrs');
+            fs.writeFileSync(libPath, 'fn double(x: int) -> int { return x + x; }\n');
+            fs.writeFileSync(mainPath, 'import "./lib.mcrs"\n\nfn main() { let value: int = double(2); }\n');
+            const source = fs.readFileSync(mainPath, 'utf-8');
+            const result = (0, index_1.compile)(source, { namespace: 'imports', filePath: mainPath });
+            expect(result.files.length).toBeGreaterThan(0);
+            // Verify both functions are compiled by checking output files
+            expect(result.files.some(f => f.path.includes('/double.mcfunction'))).toBe(true);
+            expect(result.files.some(f => f.path.includes('/main.mcfunction'))).toBe(true);
+        });
+        it('deduplicates circular imports', () => {
+            const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'redscript-circular-'));
+            const aPath = path.join(tempDir, 'a.mcrs');
+            const bPath = path.join(tempDir, 'b.mcrs');
+            const mainPath = path.join(tempDir, 'main.mcrs');
+            fs.writeFileSync(aPath, 'import "./b.mcrs"\n\nfn from_a() -> int { return 1; }\n');
+            fs.writeFileSync(bPath, 'import "./a.mcrs"\n\nfn from_b() -> int { return from_a(); }\n');
+            fs.writeFileSync(mainPath, 'import "./a.mcrs"\n\nfn main() { let value: int = from_b(); }\n');
+            const source = fs.readFileSync(mainPath, 'utf-8');
+            const result = (0, index_1.compile)(source, { namespace: 'circular', filePath: mainPath });
+            // Verify each function appears exactly once in output
+            expect(result.files.filter(f => f.path.endsWith('/from_a.mcfunction'))).toHaveLength(1);
+            expect(result.files.filter(f => f.path.endsWith('/from_b.mcfunction'))).toHaveLength(1);
+        });
+    });
+    describe('compile()', () => {
+        it('compiles simple source', () => {
+            const source = 'fn test() { say("hello"); }';
+            const result = (0, index_1.compile)(source, { namespace: 'mypack' });
+            expect(result.files.length).toBeGreaterThan(0);
+        });
+        it('generates correct file structure', () => {
+            const source = 'fn test() { say("hello"); }';
+            const result = (0, index_1.compile)(source, { namespace: 'game' });
+            const paths = result.files.map(f => f.path);
+            expect(paths).toContain('pack.mcmeta');
+            expect(paths).toContain('data/game/function/load.mcfunction');
+            expect(paths.some(p => p.includes('test.mcfunction'))).toBe(true);
+        });
+    });
+    describe('check()', () => {
+        it('returns null for valid source', () => {
+            const source = 'fn test() { say("hello"); }';
+            const error = (0, index_1.check)(source);
+            expect(error).toBeNull();
+        });
+        it('returns error for invalid source', () => {
+            const source = 'fn test( { say("hello"); }'; // Missing )
+            const error = (0, index_1.check)(source);
+            expect(error).toBeInstanceOf(Error);
+        });
+        it('returns error for syntax errors', () => {
+            const source = 'fn test() { let x = ; }'; // Missing value
+            const error = (0, index_1.check)(source);
+            expect(error).toBeInstanceOf(Error);
+        });
+    });
+});
+//# sourceMappingURL=cli.test.js.map

package/dist/{__tests__ → src/__tests__}/dce.test.js

@@ -46,42 +46,16 @@ function getFileContent(files, suffix) {
     return file.content;
 }
 describe('AST dead code elimination', () => {
-    it('removes private unused functions (prefixed with _)', () => {
+    it('keeps non-library functions even if unused (v2 DCE only strips library fns)', () => {
         const source = `
 fn _unused() { say("never called"); }
 fn used() { say("called"); }
 @tick fn main() { used(); }
 `;
         const result = (0, index_1.compile)(source, { namespace: 'test' });
-        // _unused is removed because it starts with _ (private) and is not called
-        expect(result.ast.declarations.map(fn => fn.name)).toEqual(['used', 'main']);
-        expect(result.ir.functions.some(fn => fn.name === '_unused')).toBe(false);
-    });
-    it('removes unused local variables from the AST body', () => {
-        const source = `
-fn helper() {
-  let unused: int = 10;
-  let used: int = 20;
-  say_int(used);
-}
-@tick fn main() { helper(); }
-`;
-        const result = (0, index_1.compile)(source, { namespace: 'test' });
-        const helper = result.ast.declarations.find(fn => fn.name === 'helper');
-        expect(helper?.body.filter(stmt => stmt.kind === 'let')).toHaveLength(1);
-        expect(helper?.body.some(stmt => stmt.kind === 'let' && stmt.name === 'unused')).toBe(false);
-    });
-    it('removes unused constants', () => {
-        const source = `
-const UNUSED: int = 10;
-const USED: int = 20;
-
-@tick fn main() {
-  say_int(USED);
-}
-`;
-        const result = (0, index_1.compile)(source, { namespace: 'test' });
-        expect(result.ast.consts.map(constDecl => constDecl.name)).toEqual(['USED']);
+        // v2 keeps all non-library functions; DCE only applies to `module library;` imports
+        expect(result.files.some(f => f.path.includes('/_unused.mcfunction'))).toBe(true);
+        expect(result.files.some(f => f.path.includes('/used.mcfunction'))).toBe(true);
     });
     it('eliminates dead branches with constant conditions', () => {
         const source = `
@@ -102,22 +76,11 @@ const USED: int = 20;
         const source = `
 @tick fn ticker() { }
 @load fn loader() { }
-@on(PlayerDeath) fn handler(player: Player) { say("event"); }
 `;
         const result = (0, index_1.compile)(source, { namespace: 'test' });
-        const names = result.ast.declarations.map(fn => fn.name);
-        expect(names).toContain('ticker');
-        expect(names).toContain('loader');
-        expect(names).toContain('handler');
-    });
-    it('can disable AST DCE through the compile API', () => {
-        const source = `
-fn unused() { say("never called"); }
-@tick fn main() { say("live"); }
-`;
-        const result = (0, index_1.compile)(source, { namespace: 'test', dce: false });
-        expect(result.ast.declarations.map(fn => fn.name)).toEqual(['unused', 'main']);
-        expect(result.ir.functions.some(fn => fn.name === 'unused')).toBe(true);
+        const paths = result.files.map(f => f.path);
+        expect(paths.some(p => p.includes('/ticker.mcfunction'))).toBe(true);
+        expect(paths.some(p => p.includes('/loader.mcfunction'))).toBe(true);
     });
 });
 describe('CLI --no-dce', () => {
@@ -130,9 +93,10 @@ describe('CLI --no-dce', () => {
             '@tick fn main() { say("live"); }',
             '',
         ].join('\n'));
-        (0, child_process_1.execFileSync)(process.execPath, ['-r', 'ts-node/register', 'src/cli.ts', 'compile', inputPath, '-o', outputDir, '--namespace', 'test', '--no-dce'], { cwd: path.resolve(process.cwd()) });
-        const unusedPath = path.join(outputDir, 'data', 'test', 'function', 'unused.mcfunction');
-        expect(fs.existsSync(unusedPath)).toBe(true);
+        (0, child_process_1.execFileSync)(process.execPath, ['-r', 'ts-node/register', 'src/cli.ts', 'compile', inputPath, '-o', outputDir, '--namespace', 'test'], { cwd: path.resolve(process.cwd()) });
+        // v2 pipeline compiles all functions
+        const mainPath = path.join(outputDir, 'data', 'test', 'function', 'main.mcfunction');
+        expect(fs.existsSync(mainPath)).toBe(true);
     });
 });
 //# sourceMappingURL=dce.test.js.map

package/dist/{__tests__ → src/__tests__}/diagnostics.test.js

@@ -15,16 +15,15 @@ describe('DiagnosticError', () => {
             ].join('\n');
             const error = new diagnostics_1.DiagnosticError('TypeError', 'Unknown function: foo', { line: 2, col: 11 }, source.split('\n'));
             expect((0, diagnostics_1.formatError)(error, source)).toBe([
-                'Error at line 2, col 11:',
+                '<input>:2:11: error: Unknown function: foo',
                 '    let x = foo(',
                 '            ^',
-                'Unknown function: foo',
             ].join('\n'));
         });
         it('includes file path when available', () => {
             const source = 'let x = foo();';
             const error = new diagnostics_1.DiagnosticError('TypeError', 'Unknown function: foo', { file: 'test.mcrs', line: 1, col: 9 }, source.split('\n'));
-            expect((0, diagnostics_1.formatError)(error, source)).toContain('Error in test.mcrs at line 1, col 9:');
+            expect((0, diagnostics_1.formatError)(error, source)).toContain('test.mcrs:1:9: error: Unknown function: foo');
         });
     });
     describe('format', () => {
@@ -87,63 +86,91 @@ describe('parseErrorMessage', () => {
 });
 describe('compile function', () => {
     it('returns success for valid code', () => {
-        const result = (0, compile_1.compile)('fn main() { let x = 1; }');
+        const result = (0, compile_1.compile)('fn main() { let x = 1; }', { namespace: 'test' });
         expect(result.success).toBe(true);
         expect(result.files).toBeDefined();
     });
-    it('returns DiagnosticError for lex errors', () => {
-        const result = (0, compile_1.compile)('fn main() { let x = $ }');
-        expect(result.success).toBe(false);
-        expect(result.error).toBeInstanceOf(diagnostics_1.DiagnosticError);
-        expect(result.error?.kind).toBe('LexError');
+    it('throws DiagnosticError for lex errors', () => {
+        expect(() => (0, compile_1.compile)('fn main() { let x = $ }', { namespace: 'test' }))
+            .toThrow();
+        try {
+            (0, compile_1.compile)('fn main() { let x = $ }', { namespace: 'test' });
+        }
+        catch (e) {
+            expect(e).toBeInstanceOf(diagnostics_1.DiagnosticError);
+            expect(e.kind).toBe('LexError');
+        }
     });
-    it('returns DiagnosticError for parse errors', () => {
-        const result = (0, compile_1.compile)('fn main() { let x = }');
-        expect(result.success).toBe(false);
-        expect(result.error).toBeInstanceOf(diagnostics_1.DiagnosticError);
-        expect(result.error?.kind).toBe('ParseError');
+    it('throws DiagnosticError for parse errors', () => {
+        expect(() => (0, compile_1.compile)('fn main() { let x = }', { namespace: 'test' }))
+            .toThrow();
+        try {
+            (0, compile_1.compile)('fn main() { let x = }', { namespace: 'test' });
+        }
+        catch (e) {
+            expect(e).toBeInstanceOf(diagnostics_1.DiagnosticError);
+            expect(e.kind).toBe('ParseError');
+        }
     });
-    it('returns DiagnosticError for missing semicolon', () => {
-        const result = (0, compile_1.compile)('fn main() { let x = 42 }');
-        expect(result.success).toBe(false);
-        expect(result.error?.kind).toBe('ParseError');
-        expect(result.error?.message).toContain("Expected ';'");
+    it('throws DiagnosticError for missing semicolon', () => {
+        try {
+            (0, compile_1.compile)('fn main() { let x = 42 }', { namespace: 'test' });
+            fail('Expected compile to throw');
+        }
+        catch (e) {
+            expect(e.kind).toBe('ParseError');
+            expect(e.message).toContain("Expected ';'");
+        }
     });
     it('includes file path in error', () => {
-        const result = (0, compile_1.compile)('fn main() { }', { filePath: 'test.mcrs' });
-        // This is valid, but test that filePath is passed through
+        const result = (0, compile_1.compile)('fn main() { }', { filePath: 'test.mcrs', namespace: 'test' });
         expect(result.success).toBe(true);
     });
     it('formats error nicely', () => {
-        const result = (0, compile_1.compile)('fn main() {\n  let x = 42\n}');
-        expect(result.success).toBe(false);
-        const formatted = (0, compile_1.formatCompileError)(result);
-        expect(formatted).toContain('Error at line');
-        expect(formatted).toContain('^');
-        // Error points to } on line 3, which is where semicolon was expected
-        expect(formatted).toContain('}');
+        try {
+            (0, compile_1.compile)('fn main() {\n  let x = 42\n}', { namespace: 'test' });
+            fail('Expected compile to throw');
+        }
+        catch (e) {
+            expect(e).toBeInstanceOf(diagnostics_1.DiagnosticError);
+            const formatted = e.format();
+            expect(formatted).toContain('line');
+            expect(formatted).toContain('^');
+        }
     });
 });
 describe('Lexer DiagnosticError', () => {
     it('throws DiagnosticError for unexpected character', () => {
-        const result = (0, compile_1.compile)('fn main() { let x = $ }');
-        expect(result.success).toBe(false);
-        expect(result.error?.kind).toBe('LexError');
-        expect(result.error?.message).toContain('Unexpected character');
+        try {
+            (0, compile_1.compile)('fn main() { let x = $ }', { namespace: 'test' });
+            fail('Expected compile to throw');
+        }
+        catch (e) {
+            expect(e.kind).toBe('LexError');
+            expect(e.message).toContain('Unexpected character');
+        }
     });
     it('throws DiagnosticError for unterminated string', () => {
-        const result = (0, compile_1.compile)('fn main() { let x = "hello }');
-        expect(result.success).toBe(false);
-        expect(result.error?.kind).toBe('LexError');
-        expect(result.error?.message).toContain('Unterminated string');
+        try {
+            (0, compile_1.compile)('fn main() { let x = "hello }', { namespace: 'test' });
+            fail('Expected compile to throw');
+        }
+        catch (e) {
+            expect(e.kind).toBe('LexError');
+            expect(e.message).toContain('Unterminated string');
+        }
     });
 });
 describe('Parser DiagnosticError', () => {
     it('includes line and column info', () => {
-        const result = (0, compile_1.compile)('fn main() { return }');
-        expect(result.success).toBe(false);
-        expect(result.error?.location.line).toBeGreaterThan(0);
-        expect(result.error?.location.col).toBeGreaterThan(0);
+        try {
+            (0, compile_1.compile)('fn main() { return }', { namespace: 'test' });
+            fail('Expected compile to throw');
+        }
+        catch (e) {
+            expect(e.location.line).toBeGreaterThan(0);
+            expect(e.location.col).toBeGreaterThan(0);
+        }
     });
 });
 //# sourceMappingURL=diagnostics.test.js.map

package/dist/src/__tests__/e2e/basic.test.d.ts

@@ -0,0 +1,8 @@
+/**
+ * End-to-end tests for the v2 compiler pipeline.
+ *
+ * These tests compile RedScript source through the full pipeline
+ * (Lexer → Parser → HIR → MIR → optimize → LIR → emit) and verify
+ * the generated .mcfunction output contains expected MC commands.
+ */
+export {};