redscript-mc 1.2.30 → 2.1.0

package/dist/src/__tests__/lir/types.test.js

@@ -0,0 +1,185 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+describe('LIR types — Slot', () => {
+    test('Slot has player and obj fields', () => {
+        const slot = { player: '$t0', obj: '__test' };
+        expect(slot.player).toBe('$t0');
+        expect(slot.obj).toBe('__test');
+    });
+});
+describe('LIR types — instructions', () => {
+    test('score_set instruction', () => {
+        const instr = { kind: 'score_set', dst: { player: '$x', obj: '__ns' }, value: 42 };
+        expect(instr.kind).toBe('score_set');
+    });
+    test('score_copy instruction', () => {
+        const dst = { player: '$x', obj: '__ns' };
+        const src = { player: '$y', obj: '__ns' };
+        const instr = { kind: 'score_copy', dst, src };
+        expect(instr.kind).toBe('score_copy');
+    });
+    test('score arithmetic instructions', () => {
+        const dst = { player: '$x', obj: '__ns' };
+        const src = { player: '$y', obj: '__ns' };
+        const ops = ['score_add', 'score_sub', 'score_mul', 'score_div', 'score_mod'];
+        for (const kind of ops) {
+            const instr = { kind, dst, src };
+            expect(instr.kind).toBe(kind);
+        }
+    });
+    test('score_min, score_max instructions', () => {
+        const dst = { player: '$x', obj: '__ns' };
+        const src = { player: '$y', obj: '__ns' };
+        const min = { kind: 'score_min', dst, src };
+        const max = { kind: 'score_max', dst, src };
+        expect(min.kind).toBe('score_min');
+        expect(max.kind).toBe('score_max');
+    });
+    test('score_swap instruction', () => {
+        const a = { player: '$x', obj: '__ns' };
+        const b = { player: '$y', obj: '__ns' };
+        const instr = { kind: 'score_swap', a, b };
+        expect(instr.kind).toBe('score_swap');
+    });
+    test('store_cmd_to_score instruction', () => {
+        const dst = { player: '$x', obj: '__ns' };
+        const cmd = { kind: 'call', fn: 'test:foo' };
+        const instr = { kind: 'store_cmd_to_score', dst, cmd };
+        expect(instr.kind).toBe('store_cmd_to_score');
+    });
+    test('store_score_to_nbt instruction', () => {
+        const instr = {
+            kind: 'store_score_to_nbt',
+            ns: 'rs:data', path: 'value', type: 'int', scale: 1,
+            src: { player: '$x', obj: '__ns' },
+        };
+        expect(instr.kind).toBe('store_score_to_nbt');
+    });
+    test('store_nbt_to_score instruction', () => {
+        const instr = {
+            kind: 'store_nbt_to_score',
+            dst: { player: '$x', obj: '__ns' },
+            ns: 'rs:data', path: 'value', scale: 1,
+        };
+        expect(instr.kind).toBe('store_nbt_to_score');
+    });
+    test('nbt_set_literal instruction', () => {
+        const instr = { kind: 'nbt_set_literal', ns: 'rs:data', path: 'x', value: '42' };
+        expect(instr.kind).toBe('nbt_set_literal');
+    });
+    test('nbt_copy instruction', () => {
+        const instr = {
+            kind: 'nbt_copy',
+            srcNs: 'rs:a', srcPath: 'x',
+            dstNs: 'rs:b', dstPath: 'y',
+        };
+        expect(instr.kind).toBe('nbt_copy');
+    });
+    test('call instruction', () => {
+        const instr = { kind: 'call', fn: 'test:foo' };
+        expect(instr.kind).toBe('call');
+    });
+    test('call_macro instruction', () => {
+        const instr = { kind: 'call_macro', fn: 'test:draw', storage: 'rs:macro_args' };
+        expect(instr.kind).toBe('call_macro');
+    });
+    test('call_if_matches instruction', () => {
+        const instr = {
+            kind: 'call_if_matches',
+            fn: 'test:branch',
+            slot: { player: '$cond', obj: '__ns' },
+            range: '1',
+        };
+        expect(instr.kind).toBe('call_if_matches');
+    });
+    test('call_unless_matches instruction', () => {
+        const instr = {
+            kind: 'call_unless_matches',
+            fn: 'test:branch',
+            slot: { player: '$cond', obj: '__ns' },
+            range: '1',
+        };
+        expect(instr.kind).toBe('call_unless_matches');
+    });
+    test('call_if_score instruction', () => {
+        const instr = {
+            kind: 'call_if_score',
+            fn: 'test:check',
+            a: { player: '$x', obj: '__ns' },
+            op: 'lt',
+            b: { player: '$y', obj: '__ns' },
+        };
+        expect(instr.kind).toBe('call_if_score');
+    });
+    test('call_unless_score instruction', () => {
+        const instr = {
+            kind: 'call_unless_score',
+            fn: 'test:check',
+            a: { player: '$x', obj: '__ns' },
+            op: 'ge',
+            b: { player: '$y', obj: '__ns' },
+        };
+        expect(instr.kind).toBe('call_unless_score');
+    });
+    test('call_context instruction', () => {
+        const instr = {
+            kind: 'call_context',
+            fn: 'test:helper',
+            subcommands: [{ kind: 'as', selector: '@e[tag=foo]' }, { kind: 'at_self' }],
+        };
+        expect(instr.kind).toBe('call_context');
+    });
+    test('return_value instruction', () => {
+        const instr = { kind: 'return_value', slot: { player: '$result', obj: '__ns' } };
+        expect(instr.kind).toBe('return_value');
+    });
+    test('macro_line instruction', () => {
+        const instr = { kind: 'macro_line', template: '$particle end_rod ^$(px) ^$(py) ^5' };
+        expect(instr.kind).toBe('macro_line');
+    });
+    test('raw instruction', () => {
+        const instr = { kind: 'raw', cmd: 'say hello' };
+        expect(instr.kind).toBe('raw');
+    });
+});
+describe('LIR types — LIRFunction', () => {
+    test('basic function structure', () => {
+        const fn = {
+            name: 'main',
+            instructions: [
+                { kind: 'score_set', dst: { player: '$x', obj: '__ns' }, value: 0 },
+            ],
+            isMacro: false,
+            macroParams: [],
+        };
+        expect(fn.name).toBe('main');
+        expect(fn.instructions).toHaveLength(1);
+        expect(fn.isMacro).toBe(false);
+        expect(fn.macroParams).toEqual([]);
+    });
+    test('macro function structure', () => {
+        const fn = {
+            name: 'draw_pt',
+            instructions: [
+                { kind: 'macro_line', template: '$particle end_rod ^$(px) ^$(py) ^5' },
+            ],
+            isMacro: true,
+            macroParams: ['px', 'py'],
+        };
+        expect(fn.isMacro).toBe(true);
+        expect(fn.macroParams).toEqual(['px', 'py']);
+    });
+});
+describe('LIR types — LIRModule', () => {
+    test('module structure', () => {
+        const mod = {
+            functions: [],
+            namespace: 'mypack',
+            objective: '__mypack',
+        };
+        expect(mod.namespace).toBe('mypack');
+        expect(mod.objective).toBe('__mypack');
+        expect(mod.functions).toEqual([]);
+    });
+});
+//# sourceMappingURL=types.test.js.map

package/dist/src/__tests__/lir/verify.test.js

@@ -0,0 +1,221 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const verify_1 = require("../../lir/verify");
+const OBJ = '__test';
+const NS = 'test';
+function mkModule(functions) {
+    return { functions, namespace: NS, objective: OBJ };
+}
+function mkFn(name, instructions, isMacro = false, macroParams = []) {
+    return { name, instructions, isMacro, macroParams };
+}
+function slot(name) {
+    return { player: `$${name}`, obj: OBJ };
+}
+// ---------------------------------------------------------------------------
+// Objective checks
+// ---------------------------------------------------------------------------
+describe('LIR verifier — objective checks', () => {
+    test('accepts slots with correct objective', () => {
+        const mod = mkModule([
+            mkFn('main', [
+                { kind: 'score_set', dst: slot('x'), value: 42 },
+                { kind: 'score_copy', dst: slot('y'), src: slot('x') },
+            ]),
+        ]);
+        expect((0, verify_1.verifyLIR)(mod)).toEqual([]);
+    });
+    test('rejects slot with wrong objective', () => {
+        const mod = mkModule([
+            mkFn('main', [
+                { kind: 'score_set', dst: { player: '$x', obj: '__wrong' }, value: 42 },
+            ]),
+        ]);
+        const errors = (0, verify_1.verifyLIR)(mod);
+        expect(errors.length).toBe(1);
+        expect(errors[0].message).toContain('objective');
+        expect(errors[0].message).toContain('__wrong');
+    });
+    test('rejects wrong objective in src slot', () => {
+        const mod = mkModule([
+            mkFn('main', [
+                { kind: 'score_copy', dst: slot('x'), src: { player: '$y', obj: '__bad' } },
+            ]),
+        ]);
+        const errors = (0, verify_1.verifyLIR)(mod);
+        expect(errors.length).toBe(1);
+        expect(errors[0].message).toContain('__bad');
+    });
+    test('checks slots in score_swap', () => {
+        const mod = mkModule([
+            mkFn('main', [
+                { kind: 'score_swap', a: { player: '$x', obj: '__bad' }, b: slot('y') },
+            ]),
+        ]);
+        const errors = (0, verify_1.verifyLIR)(mod);
+        expect(errors.length).toBe(1);
+        expect(errors[0].message).toContain('__bad');
+    });
+    test('checks slots in store_cmd_to_score (recursive)', () => {
+        const mod = mkModule([
+            mkFn('main', [
+                {
+                    kind: 'store_cmd_to_score',
+                    dst: slot('r'),
+                    cmd: {
+                        kind: 'call_if_score',
+                        fn: 'test:main',
+                        a: { player: '$a', obj: '__bad' },
+                        op: 'eq',
+                        b: slot('b'),
+                    },
+                },
+            ]),
+        ]);
+        const errors = (0, verify_1.verifyLIR)(mod);
+        expect(errors.length).toBe(1);
+        expect(errors[0].message).toContain('__bad');
+    });
+    test('checks slot in call_if_matches', () => {
+        const mod = mkModule([
+            mkFn('main', [
+                {
+                    kind: 'call_if_matches',
+                    fn: 'test:main',
+                    slot: { player: '$c', obj: '__bad' },
+                    range: '1',
+                },
+            ]),
+        ]);
+        const errors = (0, verify_1.verifyLIR)(mod);
+        expect(errors.length).toBe(1);
+    });
+    test('checks slot in return_value', () => {
+        const mod = mkModule([
+            mkFn('main', [
+                { kind: 'return_value', slot: { player: '$r', obj: '__bad' } },
+            ]),
+        ]);
+        const errors = (0, verify_1.verifyLIR)(mod);
+        expect(errors.length).toBe(1);
+    });
+});
+// ---------------------------------------------------------------------------
+// Function reference checks
+// ---------------------------------------------------------------------------
+describe('LIR verifier — function references', () => {
+    test('accepts call to existing function', () => {
+        const mod = mkModule([
+            mkFn('main', [{ kind: 'call', fn: 'test:helper' }]),
+            mkFn('helper', []),
+        ]);
+        expect((0, verify_1.verifyLIR)(mod)).toEqual([]);
+    });
+    test('rejects call to undefined function', () => {
+        const mod = mkModule([
+            mkFn('main', [{ kind: 'call', fn: 'test:nonexistent' }]),
+        ]);
+        const errors = (0, verify_1.verifyLIR)(mod);
+        expect(errors.length).toBe(1);
+        expect(errors[0].message).toContain('undefined function');
+        expect(errors[0].message).toContain('nonexistent');
+    });
+    test('rejects call_macro to undefined function', () => {
+        const mod = mkModule([
+            mkFn('main', [{ kind: 'call_macro', fn: 'test:missing', storage: 'rs:macro_args' }]),
+        ]);
+        const errors = (0, verify_1.verifyLIR)(mod);
+        expect(errors.length).toBe(1);
+        expect(errors[0].message).toContain('undefined function');
+    });
+    test('rejects call_if_matches to undefined function', () => {
+        const mod = mkModule([
+            mkFn('main', [
+                { kind: 'call_if_matches', fn: 'test:missing', slot: slot('c'), range: '1' },
+            ]),
+        ]);
+        const errors = (0, verify_1.verifyLIR)(mod);
+        expect(errors.length).toBe(1);
+        expect(errors[0].message).toContain('undefined function');
+    });
+    test('rejects call_context to undefined function', () => {
+        const mod = mkModule([
+            mkFn('main', [
+                { kind: 'call_context', fn: 'test:missing', subcommands: [{ kind: 'at_self' }] },
+            ]),
+        ]);
+        const errors = (0, verify_1.verifyLIR)(mod);
+        expect(errors.length).toBe(1);
+        expect(errors[0].message).toContain('undefined function');
+    });
+    test('checks function refs inside store_cmd_to_score', () => {
+        const mod = mkModule([
+            mkFn('main', [
+                {
+                    kind: 'store_cmd_to_score',
+                    dst: slot('r'),
+                    cmd: { kind: 'call', fn: 'test:missing' },
+                },
+            ]),
+        ]);
+        const errors = (0, verify_1.verifyLIR)(mod);
+        expect(errors.length).toBe(1);
+        expect(errors[0].message).toContain('undefined function');
+    });
+});
+// ---------------------------------------------------------------------------
+// Macro line checks
+// ---------------------------------------------------------------------------
+describe('LIR verifier — macro_line', () => {
+    test('accepts macro_line in macro function', () => {
+        const mod = mkModule([
+            mkFn('draw', [
+                { kind: 'macro_line', template: '$particle end_rod ^$(px)' },
+            ], true, ['px']),
+        ]);
+        expect((0, verify_1.verifyLIR)(mod)).toEqual([]);
+    });
+    test('rejects macro_line in non-macro function', () => {
+        const mod = mkModule([
+            mkFn('main', [
+                { kind: 'macro_line', template: '$particle end_rod ^$(px)' },
+            ], false),
+        ]);
+        const errors = (0, verify_1.verifyLIR)(mod);
+        expect(errors.length).toBe(1);
+        expect(errors[0].message).toContain('macro_line');
+        expect(errors[0].message).toContain('non-macro');
+    });
+});
+// ---------------------------------------------------------------------------
+// Clean module
+// ---------------------------------------------------------------------------
+describe('LIR verifier — clean module', () => {
+    test('accepts a well-formed module', () => {
+        const mod = mkModule([
+            mkFn('main', [
+                { kind: 'score_set', dst: slot('t0'), value: 1 },
+                { kind: 'score_set', dst: slot('t1'), value: 2 },
+                { kind: 'score_copy', dst: slot('r'), src: slot('t0') },
+                { kind: 'score_add', dst: slot('r'), src: slot('t1') },
+                { kind: 'call', fn: 'test:helper' },
+                { kind: 'return_value', slot: slot('r') },
+            ]),
+            mkFn('helper', [
+                { kind: 'raw', cmd: 'say hello' },
+            ]),
+        ]);
+        expect((0, verify_1.verifyLIR)(mod)).toEqual([]);
+    });
+    test('raw and nbt instructions do not trigger errors', () => {
+        const mod = mkModule([
+            mkFn('main', [
+                { kind: 'raw', cmd: 'say hi' },
+                { kind: 'nbt_set_literal', ns: 'rs:data', path: 'x', value: '42' },
+                { kind: 'nbt_copy', srcNs: 'rs:a', srcPath: 'x', dstNs: 'rs:b', dstPath: 'y' },
+            ]),
+        ]);
+        expect((0, verify_1.verifyLIR)(mod)).toEqual([]);
+    });
+});
+//# sourceMappingURL=verify.test.js.map

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

@@ -0,0 +1,7 @@
+/**
+ * LSP Server Tests
+ *
+ * Tests the internal logic of the LSP server without starting an actual
+ * stdio process. We test the helper functions and document parsing logic.
+ */
+export {};

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

@@ -0,0 +1,245 @@
+"use strict";
+/**
+ * LSP Server Tests
+ *
+ * Tests the internal logic of the LSP server without starting an actual
+ * stdio process. We test the helper functions and document parsing logic.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+const lexer_1 = require("../lexer");
+const parser_1 = require("../parser");
+const typechecker_1 = require("../typechecker");
+const diagnostics_1 = require("../diagnostics");
+// ---------------------------------------------------------------------------
+// Helpers mirrored from lsp/server.ts (tested independently)
+// ---------------------------------------------------------------------------
+function typeToString(t) {
+    switch (t.kind) {
+        case 'named': return t.name;
+        case 'array': return `${typeToString(t.elem)}[]`;
+        case 'struct': return t.name;
+        case 'enum': return t.name;
+        case 'entity': return t.entityType;
+        case 'selector': return t.entityType ? `selector<${t.entityType}>` : 'selector';
+        case 'tuple': return `(${t.elements.map(typeToString).join(', ')})`;
+        case 'function_type':
+            return `(${t.params.map(typeToString).join(', ')}) => ${typeToString(t.return)}`;
+        default:
+            return 'unknown';
+    }
+}
+function formatFnSignature(fn) {
+    const params = fn.params.map(p => `${p.name}: ${typeToString(p.type)}`).join(', ');
+    const ret = typeToString(fn.returnType);
+    const typeParams = fn.typeParams?.length ? `<${fn.typeParams.join(', ')}>` : '';
+    return `fn ${fn.name}${typeParams}(${params}): ${ret}`;
+}
+function parseSource(source) {
+    const errors = [];
+    let program = null;
+    try {
+        const tokens = new lexer_1.Lexer(source).tokenize();
+        program = new parser_1.Parser(tokens, source).parse('test');
+    }
+    catch (err) {
+        if (err instanceof diagnostics_1.DiagnosticError)
+            errors.push(err);
+        else
+            errors.push(new diagnostics_1.DiagnosticError('ParseError', err.message, { line: 1, col: 1 }));
+        return { program: null, errors };
+    }
+    try {
+        const checker = new typechecker_1.TypeChecker(source);
+        errors.push(...checker.check(program));
+    }
+    catch {
+        // TypeChecker errors are collected, not thrown
+    }
+    return { program, errors };
+}
+// ---------------------------------------------------------------------------
+// Diagnostics
+// ---------------------------------------------------------------------------
+describe('LSP diagnostics', () => {
+    it('parses valid source without errors', () => {
+        const source = `fn greet(): void {}`;
+        const { errors } = parseSource(source);
+        expect(errors).toHaveLength(0);
+    });
+    it('reports a parse error for invalid syntax', () => {
+        const source = `fn broken( {`;
+        const { errors } = parseSource(source);
+        expect(errors.length).toBeGreaterThan(0);
+        expect(errors[0]).toBeInstanceOf(diagnostics_1.DiagnosticError);
+    });
+    it('collects type errors for wrong argument count', () => {
+        const source = `
+fn add(a: int, b: int): int {
+  return a + b;
+}
+
+fn main(): void {
+  add(1);
+}
+`;
+        const { errors } = parseSource(source);
+        // Type checker may or may not catch arity; at minimum we get a parsed program
+        // The important thing is no crash
+        expect(errors).toBeDefined();
+    });
+});
+// ---------------------------------------------------------------------------
+// Hover / type display
+// ---------------------------------------------------------------------------
+describe('LSP hover — typeToString', () => {
+    it('formats named types', () => {
+        expect(typeToString({ kind: 'named', name: 'int' })).toBe('int');
+        expect(typeToString({ kind: 'named', name: 'bool' })).toBe('bool');
+        expect(typeToString({ kind: 'named', name: 'void' })).toBe('void');
+    });
+    it('formats array types', () => {
+        expect(typeToString({ kind: 'array', elem: { kind: 'named', name: 'int' } })).toBe('int[]');
+    });
+    it('formats function types', () => {
+        const t = {
+            kind: 'function_type',
+            params: [{ kind: 'named', name: 'int' }, { kind: 'named', name: 'int' }],
+            return: { kind: 'named', name: 'bool' },
+        };
+        expect(typeToString(t)).toBe('(int, int) => bool');
+    });
+    it('formats tuple types', () => {
+        const t = {
+            kind: 'tuple',
+            elements: [{ kind: 'named', name: 'int' }, { kind: 'named', name: 'bool' }],
+        };
+        expect(typeToString(t)).toBe('(int, bool)');
+    });
+    it('formats entity types', () => {
+        expect(typeToString({ kind: 'entity', entityType: 'Player' })).toBe('Player');
+        expect(typeToString({ kind: 'entity', entityType: 'Zombie' })).toBe('Zombie');
+    });
+    it('formats selector types', () => {
+        expect(typeToString({ kind: 'selector' })).toBe('selector');
+        expect(typeToString({ kind: 'selector', entityType: 'Player' })).toBe('selector<Player>');
+    });
+});
+describe('LSP hover — formatFnSignature', () => {
+    it('formats a simple function', () => {
+        const source = `fn add(a: int, b: int): int { return a + b; }`;
+        const { program } = parseSource(source);
+        expect(program).toBeTruthy();
+        const fn = program.declarations.find(f => f.name === 'add');
+        expect(fn).toBeTruthy();
+        expect(formatFnSignature(fn)).toBe('fn add(a: int, b: int): int');
+    });
+    it('formats a void function with no params', () => {
+        const source = `fn start(): void {}`;
+        const { program } = parseSource(source);
+        expect(program).toBeTruthy();
+        const fn = program.declarations[0];
+        expect(formatFnSignature(fn)).toBe('fn start(): void');
+    });
+    it('formats a generic function', () => {
+        const source = `fn identity<T>(x: T): T { return x; }`;
+        const { program } = parseSource(source);
+        expect(program).toBeTruthy();
+        const fn = program.declarations[0];
+        expect(formatFnSignature(fn)).toBe('fn identity<T>(x: T): T');
+    });
+});
+// ---------------------------------------------------------------------------
+// Go-to-definition map
+// ---------------------------------------------------------------------------
+describe('LSP go-to-definition', () => {
+    it('finds function spans in parsed program', () => {
+        const source = `
+fn helper(): void {}
+
+fn main(): void {
+  helper();
+}
+`;
+        const { program } = parseSource(source);
+        expect(program).toBeTruthy();
+        const helperFn = program.declarations.find(f => f.name === 'helper');
+        expect(helperFn).toBeTruthy();
+        // Span should have line info
+        expect(helperFn.span).toBeDefined();
+        expect(helperFn.span.line).toBeGreaterThan(0);
+    });
+    it('finds struct spans', () => {
+        const source = `
+struct Point {
+  x: int,
+  y: int,
+}
+`;
+        const { program } = parseSource(source);
+        expect(program).toBeTruthy();
+        const s = program.structs.find(s => s.name === 'Point');
+        expect(s).toBeTruthy();
+        expect(s.span).toBeDefined();
+    });
+    it('finds enum spans', () => {
+        const source = `
+enum Color {
+  Red,
+  Green,
+  Blue,
+}
+`;
+        const { program } = parseSource(source);
+        expect(program).toBeTruthy();
+        const e = program.enums.find(e => e.name === 'Color');
+        expect(e).toBeTruthy();
+        expect(e.span).toBeDefined();
+    });
+});
+// ---------------------------------------------------------------------------
+// Completion items (static list sanity check)
+// ---------------------------------------------------------------------------
+describe('LSP completion', () => {
+    const KEYWORDS = ['fn', 'let', 'if', 'else', 'while', 'return', 'struct', 'enum'];
+    const TYPES = ['int', 'bool', 'float', 'string', 'void', 'Player'];
+    const BUILTINS = ['say', 'tell', 'give', 'kill', 'summon', 'setTimeout'];
+    it('contains expected keywords', () => {
+        for (const kw of KEYWORDS) {
+            expect(kw).toBeTruthy();
+        }
+    });
+    it('contains expected builtin types', () => {
+        for (const t of TYPES) {
+            expect(t).toBeTruthy();
+        }
+    });
+    it('contains expected builtin functions', () => {
+        for (const fn of BUILTINS) {
+            expect(fn).toBeTruthy();
+        }
+    });
+    it('parses user functions and they can be listed', () => {
+        const source = `
+fn myCustomFn(): void {}
+fn anotherFn(x: int): int { return x; }
+`;
+        const { program } = parseSource(source);
+        expect(program).toBeTruthy();
+        const names = program.declarations.map(f => f.name);
+        expect(names).toContain('myCustomFn');
+        expect(names).toContain('anotherFn');
+    });
+});
+// ---------------------------------------------------------------------------
+// Server module import (smoke test — does not start stdio)
+// ---------------------------------------------------------------------------
+describe('LSP server module', () => {
+    it('can be required without crashing', () => {
+        // The server module calls createConnection() which requires stdio;
+        // we test only that the module-level imports and helper functions work.
+        expect(() => {
+            typeToString({ kind: 'named', name: 'int' });
+        }).not.toThrow();
+    });
+});
+//# sourceMappingURL=lsp.test.js.map

package/dist/{__tests__ → src/__tests__}/mc-integration.test.js

@@ -66,9 +66,7 @@ function writeFixture(source, namespace) {
         }));
     }
     const result = (0, compile_1.compile)(source, { namespace });
-    if (result.error)
-        throw new Error(`Compile error in ${namespace}: ${result.error}`);
-    for (const file of result.files ?? []) {
+    for (const file of result.files) {
         if (file.path === 'pack.mcmeta')
             continue;
         const filePath = path.join(DATAPACK_DIR, file.path);

package/dist/src/__tests__/mc-version.test.d.ts

@@ -0,0 +1,10 @@
+/**
+ * MC Version Tests — Phase 5a
+ *
+ * Verifies:
+ *  - parseMcVersion() parses version strings correctly
+ *  - compareMcVersion() returns the right ordering
+ *  - Codegen emits macro syntax ($ prefix, `with storage`) for >= 1.20.2
+ *  - Codegen emits compat syntax for < 1.20.2
+ */
+export {};