redscript-mc 2.6.0 → 2.6.2

package/dist/__tests__/codegen.test.js

@@ -0,0 +1,152 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const mcfunction_1 = require("../codegen/mcfunction");
+describe('generateDatapack', () => {
+    it('generates pack.mcmeta', () => {
+        const mod = { namespace: 'test', functions: [], globals: [] };
+        const files = (0, mcfunction_1.generateDatapack)(mod);
+        const meta = files.find(f => f.path === 'pack.mcmeta');
+        expect(meta).toBeDefined();
+        expect(JSON.parse(meta.content).pack.pack_format).toBe(26);
+    });
+    it('generates __load.mcfunction with objective setup', () => {
+        const mod = { namespace: 'mypack', functions: [], globals: [{ name: 'counter', init: 0 }] };
+        const files = (0, mcfunction_1.generateDatapack)(mod);
+        const load = files.find(f => f.path.includes('__load.mcfunction'));
+        expect(load?.content).toContain('scoreboard objectives add rs dummy');
+        expect(load?.content).toContain('scoreboard players set $counter rs 0');
+    });
+    it('generates function file for simple add(a, b)', () => {
+        // IR now uses { kind: 'param', index: i } for param-copy instructions,
+        // matching what the lowering emits.  Pass mangle:false so we can check
+        // readable names without worrying about sequential mangled names.
+        const mod = {
+            namespace: 'mypack',
+            globals: [],
+            functions: [{
+                    name: 'add',
+                    params: ['$a', '$b'],
+                    locals: ['$a', '$b', '$result'],
+                    blocks: [{
+                            label: 'entry',
+                            instrs: [
+                                // param-copy instructions (what the lowering now emits)
+                                { op: 'assign', dst: '$a', src: { kind: 'param', index: 0 } },
+                                { op: 'assign', dst: '$b', src: { kind: 'param', index: 1 } },
+                                { op: 'binop', dst: '$result', lhs: { kind: 'var', name: '$a' }, bop: '+', rhs: { kind: 'var', name: '$b' } },
+                            ],
+                            term: { op: 'return', value: { kind: 'var', name: '$result' } },
+                        }],
+                }],
+        };
+        const files = (0, mcfunction_1.generateDatapackWithStats)(mod, { mangle: false }).files;
+        const fn = files.find(f => f.path.includes('add.mcfunction'));
+        expect(fn).toBeDefined();
+        // param setup emitted from the IR
+        expect(fn.content).toContain('scoreboard players operation $a rs = $p0 rs');
+        expect(fn.content).toContain('scoreboard players operation $b rs = $p1 rs');
+        // Should have add operation
+        expect(fn.content).toContain('+=');
+    });
+    it('generates tick tag for tick loop function', () => {
+        const mod = {
+            namespace: 'mypack',
+            globals: [],
+            functions: [{
+                    name: 'game_loop',
+                    params: [],
+                    locals: [],
+                    blocks: [{ label: 'entry', instrs: [], term: { op: 'return' } }],
+                    isTickLoop: true,
+                }],
+        };
+        const files = (0, mcfunction_1.generateDatapack)(mod);
+        // tick.json should point to __tick
+        const tickTag = files.find(f => f.path.includes('tick.json'));
+        expect(tickTag).toBeDefined();
+        expect(JSON.parse(tickTag.content).values).toContain('mypack:__tick');
+        // __tick.mcfunction should call the game_loop function
+        const tickFn = files.find(f => f.path.includes('__tick.mcfunction'));
+        expect(tickFn).toBeDefined();
+        expect(tickFn.content).toContain('function mypack:game_loop');
+    });
+    it('generates conditional branches with execute if/unless', () => {
+        const mod = {
+            namespace: 'mypack',
+            globals: [],
+            functions: [{
+                    name: 'check',
+                    params: [],
+                    locals: ['cond'],
+                    blocks: [
+                        {
+                            label: 'entry',
+                            instrs: [
+                                { op: 'assign', dst: 'cond', src: { kind: 'const', value: 1 } },
+                            ],
+                            term: { op: 'jump_if', cond: 'cond', then: 'then_block', else_: 'else_block' },
+                        },
+                        {
+                            label: 'then_block',
+                            instrs: [{ op: 'raw', cmd: 'say hello' }],
+                            term: { op: 'return' },
+                        },
+                        {
+                            label: 'else_block',
+                            instrs: [{ op: 'raw', cmd: 'say goodbye' }],
+                            term: { op: 'return' },
+                        },
+                    ],
+                }],
+        };
+        const files = (0, mcfunction_1.generateDatapack)(mod);
+        const entry = files.find(f => f.path.endsWith('check.mcfunction'));
+        expect(entry?.content).toContain('execute if score $cond rs matches 1..');
+        expect(entry?.content).toContain('execute if score $cond rs matches ..0');
+    });
+    it('generates advancement json for event decorators', () => {
+        const mod = {
+            namespace: 'mypack',
+            globals: [],
+            functions: [{
+                    name: 'on_mine_diamond',
+                    params: [],
+                    locals: [],
+                    blocks: [{ label: 'entry', instrs: [], term: { op: 'return' } }],
+                    eventTrigger: { kind: 'advancement', value: 'story/mine_diamond' },
+                }],
+        };
+        const result = (0, mcfunction_1.generateDatapackWithStats)(mod);
+        const advancement = result.advancements.find(f => f.path === 'data/mypack/advancements/on_advancement_on_mine_diamond.json');
+        expect(advancement).toBeDefined();
+        const json = JSON.parse(advancement.content);
+        expect(json.criteria.trigger.trigger).toBe('minecraft:story/mine_diamond');
+        expect(json.rewards.function).toBe('mypack:on_mine_diamond');
+    });
+    it('generates static event dispatcher in __tick', () => {
+        const mod = {
+            namespace: 'mypack',
+            globals: [],
+            functions: [{
+                    name: 'handle_death',
+                    params: [],
+                    locals: [],
+                    blocks: [{ label: 'entry', instrs: [], term: { op: 'return' } }],
+                    eventHandler: { eventType: 'PlayerDeath', tag: 'rs.just_died' },
+                }, {
+                    name: 'handle_death_2',
+                    params: [],
+                    locals: [],
+                    blocks: [{ label: 'entry', instrs: [], term: { op: 'return' } }],
+                    eventHandler: { eventType: 'PlayerDeath', tag: 'rs.just_died' },
+                }],
+        };
+        const files = (0, mcfunction_1.generateDatapack)(mod);
+        const tickFn = files.find(f => f.path.includes('__tick.mcfunction'));
+        expect(tickFn).toBeDefined();
+        expect(tickFn.content).toContain('execute as @a[tag=rs.just_died] run function mypack:handle_death');
+        expect(tickFn.content).toContain('execute as @a[tag=rs.just_died] run function mypack:handle_death_2');
+        expect(tickFn.content).toContain('tag @a[tag=rs.just_died] remove rs.just_died');
+    });
+});
+//# sourceMappingURL=codegen.test.js.map

package/dist/__tests__/compile-all.test.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Compile-all smoke test
+ *
+ * Finds every .mcrs file in the repo (excluding declaration files and node_modules)
+ * and verifies that each one compiles without errors via the CLI (which handles
+ * `import` statements, unlike the bare `compile()` function).
+ *
+ * This catches regressions where a language change breaks existing source files.
+ */
+export {};

package/dist/__tests__/compile-all.test.js

@@ -0,0 +1,108 @@
+"use strict";
+/**
+ * Compile-all smoke test
+ *
+ * Finds every .mcrs file in the repo (excluding declaration files and node_modules)
+ * and verifies that each one compiles without errors via the CLI (which handles
+ * `import` statements, unlike the bare `compile()` function).
+ *
+ * This catches regressions where a language change breaks existing source files.
+ */
+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 fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const child_process_1 = require("child_process");
+const os = __importStar(require("os"));
+const REPO_ROOT = path.resolve(__dirname, '../../');
+const CLI = path.join(REPO_ROOT, 'dist', 'cli.js');
+// Ensure dist/cli.js exists — build first if not (e.g. in CI)
+if (!fs.existsSync(CLI)) {
+    console.log('[compile-all] dist/cli.js not found, running npm run build...');
+    (0, child_process_1.execSync)('npm run build', { cwd: REPO_ROOT, stdio: 'inherit' });
+}
+/** Patterns to skip */
+const SKIP_GLOBS = [
+    'node_modules',
+    '.git',
+    'builtins.d.mcrs', // declaration-only file, not valid source
+    'editors/', // copy of builtins.d.mcrs
+];
+function shouldSkip(filePath) {
+    const rel = path.relative(REPO_ROOT, filePath);
+    return SKIP_GLOBS.some(pat => rel.includes(pat));
+}
+function findMcrsFiles(dir) {
+    const results = [];
+    for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
+        const fullPath = path.join(dir, entry.name);
+        if (shouldSkip(fullPath))
+            continue;
+        if (entry.isDirectory()) {
+            results.push(...findMcrsFiles(fullPath));
+        }
+        else if (entry.isFile() && entry.name.endsWith('.mcrs')) {
+            results.push(fullPath);
+        }
+    }
+    return results;
+}
+const mcrsFiles = findMcrsFiles(REPO_ROOT);
+const TMP_OUT = path.join(os.tmpdir(), 'redscript-compile-all');
+describe('compile-all: every .mcrs file should compile without errors (CLI)', () => {
+    test('found at least one .mcrs file', () => {
+        expect(mcrsFiles.length).toBeGreaterThan(0);
+    });
+    for (const filePath of mcrsFiles) {
+        const label = path.relative(REPO_ROOT, filePath);
+        test(label, () => {
+            const outDir = path.join(TMP_OUT, label.replace(/[^a-zA-Z0-9]/g, '_'));
+            let stdout = '';
+            let stderr = '';
+            try {
+                const result = (0, child_process_1.execSync)(`node "${CLI}" compile "${filePath}" -o "${outDir}"`, { encoding: 'utf8', stdio: 'pipe' });
+                stdout = result;
+            }
+            catch (err) {
+                stdout = err.stdout ?? '';
+                stderr = err.stderr ?? '';
+                const output = (stdout + stderr).trim();
+                // Fail with the compiler error message
+                throw new Error(`Compile failed for ${label}:\n${output}`);
+            }
+        });
+    }
+});
+//# sourceMappingURL=compile-all.test.js.map

package/dist/__tests__/dce.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/__tests__/dce.test.js

@@ -0,0 +1,138 @@
+"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 fs = __importStar(require("fs"));
+const os = __importStar(require("os"));
+const path = __importStar(require("path"));
+const child_process_1 = require("child_process");
+const index_1 = require("../index");
+function getFileContent(files, suffix) {
+    const file = files.find(candidate => candidate.path.endsWith(suffix));
+    if (!file) {
+        throw new Error(`Missing file: ${suffix}`);
+    }
+    return file.content;
+}
+describe('AST dead code elimination', () => {
+    it('removes private unused functions (prefixed with _)', () => {
+        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']);
+    });
+    it('eliminates dead branches with constant conditions', () => {
+        const source = `
+@tick fn main() {
+  if (false) {
+    say("dead code");
+  } else {
+    say("live code");
+  }
+}
+`;
+        const result = (0, index_1.compile)(source, { namespace: 'test' });
+        const output = getFileContent(result.files, 'data/test/function/main.mcfunction');
+        expect(output).not.toContain('dead code');
+        expect(output).toContain('live code');
+    });
+    it('keeps decorated entry points', () => {
+        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);
+    });
+});
+describe('CLI --no-dce', () => {
+    it('preserves unused functions when requested', () => {
+        const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'redscript-dce-cli-'));
+        const inputPath = path.join(tempDir, 'main.mcrs');
+        const outputDir = path.join(tempDir, 'out');
+        fs.writeFileSync(inputPath, [
+            'fn unused() { say("keep me"); }',
+            '@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);
+    });
+});
+//# sourceMappingURL=dce.test.js.map

package/dist/__tests__/diagnostics.test.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Diagnostics Tests
+ */
+export {};

package/dist/__tests__/diagnostics.test.js

@@ -0,0 +1,149 @@
+"use strict";
+/**
+ * Diagnostics Tests
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+const diagnostics_1 = require("../diagnostics");
+const compile_1 = require("../compile");
+describe('DiagnosticError', () => {
+    describe('formatError', () => {
+        it('formats source context with a caret pointer', () => {
+            const source = [
+                'fn main() {',
+                '  let x = foo(',
+                '}',
+            ].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:',
+                '    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:');
+        });
+    });
+    describe('format', () => {
+        it('formats error with source line and pointer', () => {
+            const sourceLines = [
+                'fn main() {',
+                '  let x = 42',
+                '}',
+            ];
+            const error = new diagnostics_1.DiagnosticError('ParseError', "Expected ';' after statement", { line: 2, col: 14 }, sourceLines);
+            const formatted = error.format();
+            expect(formatted).toContain('[ParseError]');
+            expect(formatted).toContain('line 2');
+            expect(formatted).toContain('col 14');
+            expect(formatted).toContain('let x = 42');
+            expect(formatted).toContain('^');
+        });
+        it('formats error with file path', () => {
+            const error = new diagnostics_1.DiagnosticError('LexError', 'Unexpected character', { file: 'test.mcrs', line: 1, col: 1 }, ['@@@']);
+            const formatted = error.format();
+            expect(formatted).toContain('test.mcrs:');
+            expect(formatted).toContain('[LexError]');
+        });
+        it('handles missing source lines gracefully', () => {
+            const error = new diagnostics_1.DiagnosticError('ParseError', 'Syntax error', { line: 10, col: 5 });
+            const formatted = error.format();
+            expect(formatted).toContain('[ParseError]');
+            expect(formatted).toContain('line 10');
+        });
+    });
+});
+describe('DiagnosticCollector', () => {
+    it('collects multiple errors', () => {
+        const collector = new diagnostics_1.DiagnosticCollector('line1\nline2\nline3');
+        collector.error('ParseError', 'First error', 1, 1);
+        collector.error('ParseError', 'Second error', 2, 1);
+        expect(collector.hasErrors()).toBe(true);
+        expect(collector.getErrors()).toHaveLength(2);
+    });
+    it('formats all errors', () => {
+        const collector = new diagnostics_1.DiagnosticCollector('let x');
+        collector.error('ParseError', 'Missing semicolon', 1, 6);
+        const formatted = collector.formatAll();
+        expect(formatted).toContain('Missing semicolon');
+        expect(formatted).toContain('let x');
+    });
+});
+describe('parseErrorMessage', () => {
+    it('extracts line and col from error message', () => {
+        const err = (0, diagnostics_1.parseErrorMessage)('ParseError', "Expected ';' at line 5, col 12", ['', '', '', '', 'let x = 42']);
+        expect(err.location.line).toBe(5);
+        expect(err.location.col).toBe(12);
+        expect(err.message).toBe("Expected ';'");
+    });
+    it('defaults to line 1, col 1 if no position in message', () => {
+        const err = (0, diagnostics_1.parseErrorMessage)('LexError', 'Unknown error');
+        expect(err.location.line).toBe(1);
+        expect(err.location.col).toBe(1);
+    });
+});
+describe('compile function', () => {
+    it('returns success for valid code', () => {
+        const result = (0, compile_1.compile)('fn main() { let x = 1; }');
+        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('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('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('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
+        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('}');
+    });
+});
+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');
+    });
+    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');
+    });
+});
+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);
+    });
+});
+//# sourceMappingURL=diagnostics.test.js.map

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

@@ -0,0 +1,6 @@
+/**
+ * End-to-End Tests
+ *
+ * Tests the complete pipeline: Source → Lexer → Parser → Lowering → Optimizer → CodeGen
+ */
+export {};