redscript-mc 2.6.2 → 3.0.0

package/dist/src/__tests__/emit/compile-extra-branches.test.js

@@ -0,0 +1,225 @@
+"use strict";
+/**
+ * Extra targeted tests to push compile.ts branch coverage above 85%.
+ *
+ * Targets remaining uncovered branches:
+ * - B9: default-arg (options = {} when called with no second arg)
+ * - B10: default-arg (namespace = 'redscript' when not provided)
+ * - B24/B25: mergeWholeModuleImport parse error (file import with bad syntax)
+ * - B32/B33: libraryImports parse error (library import with bad syntax)
+ * - B63: budget diagnostic level === 'error'
+ * - B69: stopAfterCheck + caught CheckFailedError → re-throw as-is
+ */
+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 compile_1 = require("../../emit/compile");
+const diagnostics_1 = require("../../diagnostics");
+// ---------------------------------------------------------------------------
+// B9 + B10: call compile() with no second arg / without namespace
+// ---------------------------------------------------------------------------
+describe('compile.ts default arg branches', () => {
+    test('B9: compile called with no options arg uses default {} → succeeds', () => {
+        // Branch 9: the default `options = {}` is used (i.e. no second arg)
+        const result = (0, compile_1.compile)('fn f(): int { return 1; }');
+        expect(result.success).toBe(true);
+        expect(result.files.length).toBeGreaterThan(0);
+        // default namespace is 'redscript'
+        expect(result.files.some(f => f.path.includes('redscript'))).toBe(true);
+    });
+    test('B10: compile called without namespace uses default "redscript"', () => {
+        // Branch 10: namespace defaults to 'redscript' when not provided
+        // We provide options but omit namespace
+        const result = (0, compile_1.compile)('fn f(): int { return 2; }', { stopAfterCheck: false });
+        expect(result.success).toBe(true);
+        expect(result.files.some(f => f.path.includes('redscript'))).toBe(true);
+    });
+});
+// ---------------------------------------------------------------------------
+// B24/B25: mergeWholeModuleImport parse error
+//   When a whole-module import file has invalid syntax, the parse error is thrown
+//   Branch 24: if (modParser.parseErrors.length > 0) → true
+//   Branch 25: throw stopAfterCheck ? DiagnosticBundleError : parseErrors[0]
+//     - B25 arm 0 (stopAfterCheck=true): throws DiagnosticBundleError → wrapped in CheckFailedError
+//     - B25 arm 1 (stopAfterCheck=false): throws parseErrors[0]
+// ---------------------------------------------------------------------------
+describe('compile.ts mergeWholeModuleImport parse error (B24/B25)', () => {
+    let tempDir;
+    let mainPath;
+    let badModPath;
+    beforeEach(() => {
+        tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'redscript-b24-'));
+        mainPath = path.join(tempDir, 'main.mcrs');
+        badModPath = path.join(tempDir, 'bad_mod.mcrs');
+        // Write a bad module (invalid syntax)
+        fs.writeFileSync(badModPath, 'fn broken_syntax( { return 1; }\n');
+        // Write main that imports the bad module with whole-module import
+        // `import bad_mod;` (no ::) → symbol=undefined → mergeWholeModuleImport
+        fs.writeFileSync(mainPath, 'import bad_mod;\nfn main(): int { return 0; }\n');
+    });
+    afterEach(() => {
+        fs.rmSync(tempDir, { recursive: true, force: true });
+    });
+    test('B24+B25 arm1: whole-module import parse error (no stopAfterCheck) → throws raw parse error', () => {
+        // Branch 24: true path (parse errors > 0)
+        // Branch 25: arm 1 (stopAfterCheck=false) → throws parseErrors[0]
+        expect(() => (0, compile_1.compile)(fs.readFileSync(mainPath, 'utf-8'), {
+            namespace: 'b24_nosac',
+            filePath: mainPath,
+        })).toThrow();
+    });
+    test('B24+B25 arm0: whole-module import parse error (stopAfterCheck=true) → throws CheckFailedError', () => {
+        // Branch 24: true path (parse errors > 0)
+        // Branch 25: arm 0 (stopAfterCheck=true) → throws DiagnosticBundleError → wrapped in CheckFailedError
+        expect(() => (0, compile_1.compile)(fs.readFileSync(mainPath, 'utf-8'), {
+            namespace: 'b24_sac',
+            filePath: mainPath,
+            stopAfterCheck: true,
+        })).toThrow(diagnostics_1.CheckFailedError);
+    });
+});
+// ---------------------------------------------------------------------------
+// B32/B33: libraryImports parse error
+//   When a file referenced via file-system `import "file.mcrs";` has:
+//     `module library;` declaration → goes to libraryImports array
+//   Then if that library file has parse errors → Branch 32/33 fires
+//   Branch 32: if (libParser.parseErrors.length > 0)
+//   Branch 33: throw stopAfterCheck ? DiagnosticBundleError : parseErrors[0]
+// ---------------------------------------------------------------------------
+describe('compile.ts libraryImports parse error (B32/B33)', () => {
+    let tempDir;
+    let mainPath;
+    let badLibPath;
+    beforeEach(() => {
+        tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'redscript-b32-'));
+        mainPath = path.join(tempDir, 'main.mcrs');
+        badLibPath = path.join(tempDir, 'mylib.mcrs');
+        // Write a library file with module library; but broken syntax
+        fs.writeFileSync(badLibPath, 'module library;\nfn broken( { return 1; }\n');
+        // Write main that imports the library file (file-path import triggers libraryImports path)
+        // The preprocessor finds `module library;` in the imported file → puts it in libraryImports
+        fs.writeFileSync(mainPath, 'import "mylib";\nfn main(): int { return 0; }\n');
+    });
+    afterEach(() => {
+        fs.rmSync(tempDir, { recursive: true, force: true });
+    });
+    test('B32+B33 arm1: library import parse error (no stopAfterCheck) → throws raw parse error', () => {
+        expect(() => (0, compile_1.compile)(fs.readFileSync(mainPath, 'utf-8'), {
+            namespace: 'b32_nosac',
+            filePath: mainPath,
+        })).toThrow();
+    });
+    test('B32+B33 arm0: library import parse error (stopAfterCheck=true) → throws CheckFailedError', () => {
+        expect(() => (0, compile_1.compile)(fs.readFileSync(mainPath, 'utf-8'), {
+            namespace: 'b32_sac',
+            filePath: mainPath,
+            stopAfterCheck: true,
+        })).toThrow(diagnostics_1.CheckFailedError);
+    });
+});
+// ---------------------------------------------------------------------------
+// B63: budget diagnostic with level 'error' → throws DiagnosticError
+// ---------------------------------------------------------------------------
+describe('compile.ts budget error level (B63) via mock', () => {
+    beforeEach(() => {
+        jest.resetModules();
+    });
+    afterEach(() => {
+        jest.resetModules();
+    });
+    test('B63: analyzeBudget returning error level throws DiagnosticError', () => {
+        jest.isolateModules(() => {
+            jest.doMock('../../lir/budget', () => ({
+                analyzeBudget: jest.fn(() => [
+                    { level: 'error', message: 'tick budget exceeded' },
+                ]),
+            }));
+            const { compile: compileFresh } = require('../../emit/compile');
+            let thrown;
+            try {
+                compileFresh('fn f(): int { return 0; }', { namespace: 'b63_budget' });
+            }
+            catch (e) {
+                thrown = e;
+            }
+            expect(thrown).toBeDefined();
+            expect(thrown.name).toBe('DiagnosticError');
+        });
+    });
+});
+// ---------------------------------------------------------------------------
+// B69: stopAfterCheck + CheckFailedError in catch → re-throw as-is
+//   This fires when err instanceof CheckFailedError in the catch block AND stopAfterCheck=true
+//   A CheckFailedError can only arrive here if something inside the try block throws it.
+//   lowerToHIR, lowerToMIR, etc. can throw one if mocked to do so.
+// ---------------------------------------------------------------------------
+describe('compile.ts catch block: B69 stopAfterCheck + CheckFailedError re-throw', () => {
+    beforeEach(() => {
+        jest.resetModules();
+    });
+    afterEach(() => {
+        jest.resetModules();
+    });
+    test('B69: stopAfterCheck + CheckFailedError thrown inside → re-throw unchanged', () => {
+        jest.isolateModules(() => {
+            jest.doMock('../../hir/lower', () => ({
+                lowerToHIR: jest.fn(() => {
+                    const { CheckFailedError: CFE, DiagnosticError: DE } = require('../../diagnostics');
+                    throw new CFE([new DE('LoweringError', 'injected check-failed error', { line: 1, col: 1 })], ['prior warning']);
+                }),
+            }));
+            const { compile: compileFresh } = require('../../emit/compile');
+            let thrown;
+            try {
+                compileFresh('fn f(): int { return 0; }', {
+                    namespace: 'b69_cfe',
+                    stopAfterCheck: true,
+                });
+            }
+            catch (e) {
+                thrown = e;
+            }
+            expect(thrown).toBeDefined();
+            expect(thrown.name).toBe('CheckFailedError');
+            // The original CheckFailedError is re-thrown unchanged (B69 path)
+            // vs. a new CheckFailedError being created (B70/B71 paths)
+            // We can verify it has the original warnings
+            expect(thrown.warnings).toEqual(['prior warning']);
+        });
+    });
+});
+//# sourceMappingURL=compile-extra-branches.test.js.map

package/dist/src/__tests__/emit/compile-mocked-branches.test.js

@@ -0,0 +1,238 @@
+"use strict";
+describe('emit/compile mocked branch coverage', () => {
+    afterEach(() => {
+        jest.resetModules();
+        jest.clearAllMocks();
+        jest.unmock('../../compile');
+        jest.unmock('../../lexer');
+        jest.unmock('../../parser');
+        jest.unmock('../../typechecker');
+        jest.unmock('../../hir/lower');
+        jest.unmock('../../hir/monomorphize');
+        jest.unmock('../../hir/deprecated');
+        jest.unmock('../../mir/lower');
+        jest.unmock('../../optimizer/pipeline');
+        jest.unmock('../../optimizer/coroutine');
+        jest.unmock('../../lir/lower');
+        jest.unmock('../../optimizer/lir/pipeline');
+        jest.unmock('../../lir/budget');
+        jest.unmock('../../events/types');
+        jest.unmock('../../emit/index');
+        jest.unmock('fs');
+    });
+    test('whole-module import paths resolve, recurse, skip symbol imports, and warn on missing nested modules', () => {
+        jest.isolateModules(() => {
+            const parseQueue = [
+                {
+                    imports: [
+                        { moduleName: 'mod', symbol: undefined, span: { line: 1, col: 1 } },
+                        { moduleName: 'sym', symbol: 'named', span: { line: 2, col: 1 } },
+                    ],
+                    declarations: [],
+                    structs: [],
+                    implBlocks: [],
+                    enums: [],
+                    consts: [],
+                    globals: [],
+                },
+                {
+                    imports: [
+                        { moduleName: 'nested', symbol: undefined },
+                        { moduleName: 'skip_nested', symbol: 'named' },
+                        { moduleName: 'missing_nested', symbol: undefined },
+                    ],
+                    declarations: [{ name: 'helper', decorators: [] }],
+                    structs: [],
+                    implBlocks: [],
+                    enums: [],
+                    consts: [],
+                    globals: [],
+                },
+                {
+                    imports: [],
+                    declarations: [{ name: 'nested_helper', decorators: [] }],
+                    structs: [],
+                    implBlocks: [],
+                    enums: [],
+                    consts: [],
+                    globals: [],
+                },
+            ];
+            jest.doMock('../../compile', () => ({
+                preprocessSourceWithMetadata: jest.fn((source) => ({ source })),
+            }));
+            jest.doMock('fs', () => ({
+                existsSync: jest.fn((file) => (file === '/root/mod.mcrs' ||
+                    file === '/root/nested.mcrs')),
+                readFileSync: jest.fn((file) => {
+                    if (file === '/root/mod.mcrs')
+                        return 'mod-source';
+                    if (file === '/root/nested.mcrs')
+                        return 'nested-source';
+                    return '';
+                }),
+            }));
+            jest.doMock('../../lexer', () => ({
+                Lexer: jest.fn().mockImplementation(() => ({
+                    tokenize: () => [],
+                })),
+            }));
+            jest.doMock('../../parser', () => ({
+                Parser: jest.fn().mockImplementation(() => ({
+                    warnings: [],
+                    parseErrors: [],
+                    parse: () => parseQueue.shift(),
+                })),
+            }));
+            jest.doMock('../../typechecker', () => ({
+                TypeChecker: jest.fn().mockImplementation(() => ({
+                    check: () => [],
+                    getWarnings: () => [],
+                })),
+            }));
+            jest.doMock('../../hir/lower', () => ({ lowerToHIR: jest.fn(() => ({ functions: [], structs: [] })) }));
+            jest.doMock('../../hir/monomorphize', () => ({ monomorphize: jest.fn(x => x) }));
+            jest.doMock('../../hir/deprecated', () => ({ checkDeprecatedCalls: jest.fn(() => []) }));
+            jest.doMock('../../mir/lower', () => ({ lowerToMIR: jest.fn(() => ({ functions: [] })) }));
+            jest.doMock('../../optimizer/pipeline', () => ({ optimizeModule: jest.fn(x => x) }));
+            jest.doMock('../../optimizer/coroutine', () => ({
+                coroutineTransform: jest.fn(module => ({ module, generatedTickFunctions: [], warnings: [] })),
+            }));
+            jest.doMock('../../lir/lower', () => ({ lowerToLIR: jest.fn(() => ({ functions: [] })) }));
+            jest.doMock('../../optimizer/lir/pipeline', () => ({ lirOptimizeModule: jest.fn(x => x) }));
+            jest.doMock('../../lir/budget', () => ({ analyzeBudget: jest.fn(() => []) }));
+            jest.doMock('../../events/types', () => ({ isEventTypeName: jest.fn(() => false) }));
+            jest.doMock('../../emit/index', () => ({ emit: jest.fn(() => []) }));
+            const { compile } = require('../../emit/compile');
+            const result = compile('source', { namespace: 'mocked', filePath: '/root/main.mcrs' });
+            expect(result.warnings).toContain("[ImportWarning] Module 'missing_nested' not found (imported in /root/mod.mcrs)");
+        });
+    });
+    test('library imports, librarySources, lenient type errors, and decorator extraction flow into emit options', () => {
+        jest.isolateModules(() => {
+            const emit = jest.fn(() => []);
+            const parseQueue = [
+                {
+                    imports: [],
+                    declarations: [],
+                    structs: [],
+                    implBlocks: [],
+                    enums: [],
+                    consts: [],
+                    globals: [],
+                },
+                {
+                    imports: [],
+                    declarations: [{ name: 'lib_fn', decorators: [] }],
+                    structs: [],
+                    implBlocks: [],
+                    enums: [],
+                    consts: [],
+                    globals: [],
+                },
+                {
+                    declarations: [{ name: 'inline_fn', decorators: [] }],
+                    structs: [],
+                    implBlocks: [],
+                    enums: [],
+                    consts: [],
+                    globals: [],
+                },
+            ];
+            jest.doMock('../../compile', () => ({
+                preprocessSourceWithMetadata: jest.fn((source, options) => {
+                    if (options?.filePath === '/root/main.mcrs') {
+                        return {
+                            source,
+                            libraryImports: [{ source: 'module library;\nfn lib_fn(): int { return 1; }', filePath: '/root/lib.mcrs' }],
+                        };
+                    }
+                    return { source };
+                }),
+            }));
+            jest.doMock('fs', () => ({
+                existsSync: jest.fn(() => false),
+                readFileSync: jest.fn(() => ''),
+            }));
+            jest.doMock('../../lexer', () => ({
+                Lexer: jest.fn().mockImplementation(() => ({
+                    tokenize: () => [],
+                })),
+            }));
+            jest.doMock('../../parser', () => ({
+                Parser: jest.fn().mockImplementation(() => ({
+                    warnings: [],
+                    parseErrors: [],
+                    parse: () => parseQueue.shift(),
+                })),
+            }));
+            jest.doMock('../../typechecker', () => ({
+                TypeChecker: jest.fn().mockImplementation(() => ({
+                    check: () => [{ location: { line: 3, col: 5 }, message: 'bad types' }],
+                    getWarnings: () => ['lint warning'],
+                })),
+            }));
+            jest.doMock('../../hir/lower', () => ({
+                lowerToHIR: jest.fn(() => ({
+                    functions: [
+                        {
+                            name: 'tick_fn',
+                            decorators: [
+                                { name: 'tick' },
+                                { name: 'load' },
+                                { name: 'coroutine', args: { batch: 4, onDone: 'after' } },
+                                { name: 'schedule', args: { ticks: 5 } },
+                                { name: 'on', args: { eventType: 'PlayerJoin' } },
+                            ],
+                        },
+                        {
+                            name: 'ignored_event',
+                            decorators: [{ name: 'on', args: { eventType: 'NotReal' } }],
+                        },
+                    ],
+                    structs: [],
+                })),
+            }));
+            jest.doMock('../../hir/monomorphize', () => ({ monomorphize: jest.fn(x => x) }));
+            jest.doMock('../../hir/deprecated', () => ({ checkDeprecatedCalls: jest.fn(() => ['deprecated warning']) }));
+            jest.doMock('../../mir/lower', () => ({ lowerToMIR: jest.fn(() => ({ functions: [] })) }));
+            jest.doMock('../../optimizer/pipeline', () => ({ optimizeModule: jest.fn(x => x) }));
+            jest.doMock('../../optimizer/coroutine', () => ({
+                coroutineTransform: jest.fn(module => ({
+                    module,
+                    generatedTickFunctions: ['generated_tick'],
+                    warnings: ['coro warning'],
+                })),
+            }));
+            jest.doMock('../../lir/lower', () => ({ lowerToLIR: jest.fn(() => ({ functions: [] })) }));
+            jest.doMock('../../optimizer/lir/pipeline', () => ({ lirOptimizeModule: jest.fn(x => x) }));
+            jest.doMock('../../lir/budget', () => ({ analyzeBudget: jest.fn(() => [{ level: 'warning', message: 'budget warning' }]) }));
+            jest.doMock('../../events/types', () => ({
+                isEventTypeName: jest.fn((name) => name === 'PlayerJoin'),
+            }));
+            jest.doMock('../../emit/index', () => ({ emit }));
+            const { compile } = require('../../emit/compile');
+            const result = compile('source', {
+                namespace: 'mocked',
+                filePath: '/root/main.mcrs',
+                lenient: true,
+                librarySources: ['module library;\nfn inline_fn(): int { return 2; }'],
+            });
+            expect(result.warnings).toEqual(expect.arrayContaining([
+                'lint warning',
+                '[TypeError] line 3, col 5: bad types',
+                'deprecated warning',
+                'coro warning',
+                'budget warning',
+            ]));
+            expect(emit).toHaveBeenCalledWith({ functions: [] }, expect.objectContaining({
+                namespace: 'mocked',
+                tickFunctions: ['tick_fn', 'generated_tick'],
+                loadFunctions: ['tick_fn'],
+                scheduleFunctions: [{ name: 'tick_fn', ticks: 5 }],
+                eventHandlers: new Map([['PlayerJoin', ['mocked:tick_fn']]]),
+            }));
+        });
+    });
+});
+//# sourceMappingURL=compile-mocked-branches.test.js.map

package/dist/src/__tests__/emit/execute-chain.test.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Tests for Execute Chain Optimization
+ *
+ * MC allows chaining execute conditions:
+ *   execute if A run execute if B run X
+ * →  execute if A if B run X
+ *
+ * This reduces command parsing overhead and improves TPS.
+ */
+export {};

package/dist/src/__tests__/emit/execute-chain.test.js

@@ -0,0 +1,94 @@
+"use strict";
+/**
+ * Tests for Execute Chain Optimization
+ *
+ * MC allows chaining execute conditions:
+ *   execute if A run execute if B run X
+ * →  execute if A if B run X
+ *
+ * This reduces command parsing overhead and improves TPS.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+const emit_1 = require("../../emit");
+const emit_2 = require("../../emit");
+// ---------------------------------------------------------------------------
+// Unit tests: flattenExecute()
+// ---------------------------------------------------------------------------
+describe('flattenExecute()', () => {
+    test('double-level if: merges nested execute if into single execute', () => {
+        const input = 'execute if score A rs.vars matches 1 run execute if score B rs.vars matches 1 run function rs:foo';
+        const expected = 'execute if score A rs.vars matches 1 if score B rs.vars matches 1 run function rs:foo';
+        expect((0, emit_1.flattenExecute)(input)).toBe(expected);
+    });
+    test('triple-level if: recursively merges three levels into one execute', () => {
+        const input = 'execute if score A rs.vars matches 1 run execute if score B rs.vars matches 1 run execute if score C rs.vars matches 1 run function rs:bar';
+        const expected = 'execute if score A rs.vars matches 1 if score B rs.vars matches 1 if score C rs.vars matches 1 run function rs:bar';
+        expect((0, emit_1.flattenExecute)(input)).toBe(expected);
+    });
+    test('if + unless mix: does NOT merge (semantics differ)', () => {
+        const input = 'execute if score A rs.vars matches 1 run execute unless score B rs.vars matches 1 run function rs:baz';
+        // Should remain unchanged — "unless" is not the same as another "if"
+        expect((0, emit_1.flattenExecute)(input)).toBe(input);
+    });
+    test('non-execute command is returned unchanged', () => {
+        const input = 'scoreboard players set $x rs.vars 42';
+        expect((0, emit_1.flattenExecute)(input)).toBe(input);
+    });
+    test('plain execute without nested run execute is returned unchanged', () => {
+        const input = 'execute if score A rs.vars matches 1 run function rs:simple';
+        expect((0, emit_1.flattenExecute)(input)).toBe(input);
+    });
+    test('execute run execute with "as" subcmd is NOT merged (not an if clause)', () => {
+        const input = 'execute if score A rs.vars matches 1 run execute as @a run function rs:ctx';
+        // Inner starts with "as", not "if" — should not be merged
+        expect((0, emit_1.flattenExecute)(input)).toBe(input);
+    });
+    test('execute if score using score comparison: merges correctly', () => {
+        const input = 'execute if score $a rs.vars = $b rs.vars run execute if score $c rs.vars = $d rs.vars run function rs:check';
+        const expected = 'execute if score $a rs.vars = $b rs.vars if score $c rs.vars = $d rs.vars run function rs:check';
+        expect((0, emit_1.flattenExecute)(input)).toBe(expected);
+    });
+    test('four-level nesting: recursively flattens all levels', () => {
+        const input = 'execute if score A o matches 1 run execute if score B o matches 2 run execute if score C o matches 3 run execute if score D o matches 4 run function ns:deep';
+        const expected = 'execute if score A o matches 1 if score B o matches 2 if score C o matches 3 if score D o matches 4 run function ns:deep';
+        expect((0, emit_1.flattenExecute)(input)).toBe(expected);
+    });
+});
+// ---------------------------------------------------------------------------
+// Integration tests: actual compilation output
+// ---------------------------------------------------------------------------
+describe('execute chain optimization: compilation output', () => {
+    function buildModule(instructions) {
+        const fn = {
+            name: 'test_fn',
+            instructions,
+            params: [],
+            returnType: 'void',
+        };
+        return {
+            functions: [fn],
+            objective: 'rs.vars',
+            namespace: 'rs',
+        };
+    }
+    function getFile(files, pathSubstr) {
+        const f = files.find(f => f.path.includes(pathSubstr));
+        if (!f)
+            throw new Error(`Missing file matching: ${pathSubstr}\nFiles: ${files.map(f => f.path).join(', ')}`);
+        return f.content;
+    }
+    test('call_if_matches + nested raw execute if: flattened in emitted output', () => {
+        // Emit a raw execute that already contains a nested execute if to verify post-processing
+        const instructions = [
+            {
+                kind: 'raw',
+                cmd: 'execute if score $cond rs.vars matches 1 run execute if score $cond2 rs.vars matches 2 run function rs:target',
+            },
+        ];
+        const files = (0, emit_2.emit)(buildModule(instructions), { namespace: 'rs' });
+        const content = getFile(files, 'test_fn.mcfunction');
+        expect(content).toContain('execute if score $cond rs.vars matches 1 if score $cond2 rs.vars matches 2 run function rs:target');
+        expect(content).not.toContain('run execute if');
+    });
+});
+//# sourceMappingURL=execute-chain.test.js.map

package/dist/src/__tests__/emit/index.test.js

@@ -109,6 +109,7 @@ describe('emit: direct LIR emission', () => {
         expect(JSON.parse(getFile(files, 'pack.mcmeta')).pack.description).toContain('emitns');
         expect(getFile(files, 'data/emitns/function/load.mcfunction')).toBe('scoreboard objectives add __emit dummy\n');
         const main = getFile(files, 'data/emitns/function/main/run.mcfunction');
+        expect(main).toContain('# src: src/test.mcrs:3');
         expect(main).toContain('scoreboard players set $a __emit 7');
         expect(main).toContain('scoreboard players operation $b __emit = $a __emit');
         expect(main).toContain('scoreboard players operation $a __emit += $b __emit');
@@ -143,7 +144,7 @@ describe('emit: direct LIR emission', () => {
         const map = JSON.parse(getFile(files, 'data/emitns/function/main/run.sourcemap.json'));
         expect(map.generatedFile).toBe('data/emitns/function/main/run.mcfunction');
         expect(map.sources).toEqual(['src/test.mcrs']);
-        expect(map.mappings[0]).toMatchObject({ line: 1, sourceLine: 3, sourceCol: 5 });
+        expect(map.mappings[0]).toMatchObject({ line: 2, sourceLine: 3, sourceCol: 5 });
         expect(files.find(f => f.path === 'data/emitns/function/empty.sourcemap.json')).toBeUndefined();
     });
     test('falls back to legacy macro emission for pre-1.20.2 and handles empty execute context', () => {

package/dist/src/__tests__/emit/modules-branches.test.d.ts

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