redscript-mc 2.0.0 → 2.1.1

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

@@ -0,0 +1,308 @@
+"use strict";
+/**
+ * Tests for incremental compilation: FileCache, DependencyGraph, and
+ * compileIncremental.
+ */
+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 os = __importStar(require("os"));
+const index_1 = require("../cache/index");
+const deps_1 = require("../cache/deps");
+const incremental_1 = require("../cache/incremental");
+/** Create a temp directory for test files. */
+function makeTmpDir() {
+    return fs.mkdtempSync(path.join(os.tmpdir(), 'redscript-test-'));
+}
+/** Write a .mcrs file and return its absolute path. */
+function writeFile(dir, name, content) {
+    const filePath = path.join(dir, name);
+    fs.mkdirSync(path.dirname(filePath), { recursive: true });
+    fs.writeFileSync(filePath, content);
+    return filePath;
+}
+// ---------------------------------------------------------------------------
+// FileCache
+// ---------------------------------------------------------------------------
+describe('FileCache', () => {
+    let tmpDir;
+    let cacheDir;
+    beforeEach(() => {
+        tmpDir = makeTmpDir();
+        cacheDir = path.join(tmpDir, '.redscript-cache');
+    });
+    afterEach(() => {
+        fs.rmSync(tmpDir, { recursive: true, force: true });
+    });
+    test('hashFile returns consistent SHA-256 hex', () => {
+        const f = writeFile(tmpDir, 'a.mcrs', 'fn main() {}');
+        const h1 = (0, index_1.hashFile)(f);
+        const h2 = (0, index_1.hashFile)(f);
+        expect(h1).toBe(h2);
+        expect(h1).toMatch(/^[0-9a-f]{64}$/);
+    });
+    test('hashFile changes when file content changes', () => {
+        const f = writeFile(tmpDir, 'a.mcrs', 'fn main() {}');
+        const h1 = (0, index_1.hashFile)(f);
+        fs.writeFileSync(f, 'fn main() { let x: int = 1; }');
+        const h2 = (0, index_1.hashFile)(f);
+        expect(h1).not.toBe(h2);
+    });
+    test('hasChanged returns true for unknown file', () => {
+        const cache = new index_1.FileCache(cacheDir);
+        const f = writeFile(tmpDir, 'a.mcrs', 'fn main() {}');
+        expect(cache.hasChanged(f)).toBe(true);
+    });
+    test('hasChanged returns false after update', () => {
+        const cache = new index_1.FileCache(cacheDir);
+        const f = writeFile(tmpDir, 'a.mcrs', 'fn main() {}');
+        cache.update(f);
+        expect(cache.hasChanged(f)).toBe(false);
+    });
+    test('hasChanged returns true after file modification', () => {
+        const cache = new index_1.FileCache(cacheDir);
+        const f = writeFile(tmpDir, 'a.mcrs', 'fn main() {}');
+        cache.update(f);
+        // Modify file (need to change mtime)
+        const now = Date.now();
+        fs.utimesSync(f, new Date(now + 2000), new Date(now + 2000));
+        fs.writeFileSync(f, 'fn main() { let x: int = 42; }');
+        expect(cache.hasChanged(f)).toBe(true);
+    });
+    test('save and load persists hashes', () => {
+        const cache = new index_1.FileCache(cacheDir);
+        const f = writeFile(tmpDir, 'a.mcrs', 'fn main() {}');
+        cache.update(f);
+        cache.save();
+        const cache2 = new index_1.FileCache(cacheDir);
+        cache2.load();
+        // File hasn't changed — should still be cached
+        expect(cache2.hasChanged(f)).toBe(false);
+    });
+    test('load handles missing cache gracefully', () => {
+        const cache = new index_1.FileCache(cacheDir);
+        cache.load(); // no file — should not throw
+        expect(cache.size).toBe(0);
+    });
+});
+// ---------------------------------------------------------------------------
+// DependencyGraph
+// ---------------------------------------------------------------------------
+describe('DependencyGraph', () => {
+    let tmpDir;
+    beforeEach(() => {
+        tmpDir = makeTmpDir();
+    });
+    afterEach(() => {
+        fs.rmSync(tmpDir, { recursive: true, force: true });
+    });
+    test('parseImports extracts import paths', () => {
+        const f = writeFile(tmpDir, 'main.mcrs', [
+            'import "lib.mcrs";',
+            'import "util.mcrs";',
+            '',
+            'fn main() {}',
+        ].join('\n'));
+        const imports = (0, deps_1.parseImports)(f);
+        expect(imports).toHaveLength(2);
+        expect(imports[0]).toBe(path.resolve(tmpDir, 'lib.mcrs'));
+        expect(imports[1]).toBe(path.resolve(tmpDir, 'util.mcrs'));
+    });
+    test('parseImports stops at non-import line', () => {
+        const f = writeFile(tmpDir, 'main.mcrs', [
+            'import "lib.mcrs";',
+            'fn main() {}',
+            'import "late.mcrs";', // should NOT be parsed
+        ].join('\n'));
+        const imports = (0, deps_1.parseImports)(f);
+        expect(imports).toHaveLength(1);
+    });
+    test('parseImports skips comments and blank lines in header', () => {
+        const f = writeFile(tmpDir, 'main.mcrs', [
+            '// Main file',
+            '',
+            'import "lib.mcrs";',
+            '',
+            'fn main() {}',
+        ].join('\n'));
+        const imports = (0, deps_1.parseImports)(f);
+        expect(imports).toHaveLength(1);
+    });
+    test('getDirectDeps returns direct imports', () => {
+        writeFile(tmpDir, 'lib.mcrs', 'fn helper() {}');
+        const main = writeFile(tmpDir, 'main.mcrs', 'import "lib.mcrs";\nfn main() {}');
+        const graph = new deps_1.DependencyGraph();
+        graph.addFile(main);
+        const deps = graph.getDirectDeps(main);
+        expect(deps.size).toBe(1);
+        expect(deps.has(path.resolve(tmpDir, 'lib.mcrs'))).toBe(true);
+    });
+    test('getTransitiveDeps follows transitive imports', () => {
+        const c = writeFile(tmpDir, 'c.mcrs', 'fn c() {}');
+        const b = writeFile(tmpDir, 'b.mcrs', 'import "c.mcrs";\nfn b() {}');
+        const a = writeFile(tmpDir, 'a.mcrs', 'import "b.mcrs";\nfn a() {}');
+        const graph = new deps_1.DependencyGraph();
+        graph.addFile(a);
+        graph.addFile(b);
+        graph.addFile(c);
+        const deps = graph.getTransitiveDeps(a);
+        expect(deps.has(path.resolve(tmpDir, 'b.mcrs'))).toBe(true);
+        expect(deps.has(path.resolve(tmpDir, 'c.mcrs'))).toBe(true);
+    });
+    test('getDependents returns reverse dependents', () => {
+        writeFile(tmpDir, 'lib.mcrs', 'fn helper() {}');
+        const main1 = writeFile(tmpDir, 'main1.mcrs', 'import "lib.mcrs";\nfn main1() {}');
+        const main2 = writeFile(tmpDir, 'main2.mcrs', 'import "lib.mcrs";\nfn main2() {}');
+        const graph = new deps_1.DependencyGraph();
+        graph.addFile(main1);
+        graph.addFile(main2);
+        const dependents = graph.getDependents(path.resolve(tmpDir, 'lib.mcrs'));
+        expect(dependents.has(path.resolve(tmpDir, 'main1.mcrs'))).toBe(true);
+        expect(dependents.has(path.resolve(tmpDir, 'main2.mcrs'))).toBe(true);
+    });
+    test('computeDirtySet includes changed files and their dependents', () => {
+        const lib = writeFile(tmpDir, 'lib.mcrs', 'fn helper() {}');
+        const main = writeFile(tmpDir, 'main.mcrs', 'import "lib.mcrs";\nfn main() {}');
+        const other = writeFile(tmpDir, 'other.mcrs', 'fn other() {}');
+        const graph = new deps_1.DependencyGraph();
+        graph.addFile(main);
+        graph.addFile(other);
+        const dirty = graph.computeDirtySet(new Set([lib]));
+        expect(dirty.has(path.resolve(tmpDir, 'lib.mcrs'))).toBe(true);
+        expect(dirty.has(path.resolve(tmpDir, 'main.mcrs'))).toBe(true);
+        expect(dirty.has(path.resolve(tmpDir, 'other.mcrs'))).toBe(false);
+    });
+});
+// ---------------------------------------------------------------------------
+// compileIncremental (end-to-end)
+// ---------------------------------------------------------------------------
+describe('compileIncremental', () => {
+    let tmpDir;
+    let cacheDir;
+    let outDir;
+    beforeEach(() => {
+        tmpDir = makeTmpDir();
+        cacheDir = path.join(tmpDir, '.redscript-cache');
+        outDir = path.join(tmpDir, 'out');
+        (0, incremental_1.resetCompileCache)();
+    });
+    afterEach(() => {
+        fs.rmSync(tmpDir, { recursive: true, force: true });
+    });
+    test('first compile: all files compiled (cache miss)', () => {
+        const a = writeFile(tmpDir, 'a.mcrs', 'fn a_func() { let x: int = 1; }');
+        const b = writeFile(tmpDir, 'b.mcrs', 'fn b_func() { let y: int = 2; }');
+        const cache = new index_1.FileCache(cacheDir);
+        const depGraph = new deps_1.DependencyGraph();
+        const result = (0, incremental_1.compileIncremental)([a, b], cache, depGraph, {
+            output: outDir,
+        });
+        expect(result.recompiled).toBe(2);
+        expect(result.cached).toBe(0);
+        expect(result.errors.size).toBe(0);
+    });
+    test('second compile (no changes): all files cached', () => {
+        const a = writeFile(tmpDir, 'a.mcrs', 'fn a_func() { let x: int = 1; }');
+        const b = writeFile(tmpDir, 'b.mcrs', 'fn b_func() { let y: int = 2; }');
+        const cache = new index_1.FileCache(cacheDir);
+        const depGraph = new deps_1.DependencyGraph();
+        // First compile
+        (0, incremental_1.compileIncremental)([a, b], cache, depGraph, { output: outDir });
+        // Second compile — no changes
+        const result = (0, incremental_1.compileIncremental)([a, b], cache, depGraph, { output: outDir });
+        expect(result.recompiled).toBe(0);
+        expect(result.cached).toBe(2);
+        expect(result.errors.size).toBe(0);
+    });
+    test('modify one file: only that file recompiled', () => {
+        const a = writeFile(tmpDir, 'a.mcrs', 'fn a_func() { let x: int = 1; }');
+        const b = writeFile(tmpDir, 'b.mcrs', 'fn b_func() { let y: int = 2; }');
+        const cache = new index_1.FileCache(cacheDir);
+        const depGraph = new deps_1.DependencyGraph();
+        // First compile
+        (0, incremental_1.compileIncremental)([a, b], cache, depGraph, { output: outDir });
+        // Modify file a
+        fs.writeFileSync(a, 'fn a_func() { let x: int = 42; }');
+        // Ensure mtime changes
+        const now = Date.now();
+        fs.utimesSync(a, new Date(now + 2000), new Date(now + 2000));
+        const result = (0, incremental_1.compileIncremental)([a, b], cache, depGraph, { output: outDir });
+        expect(result.recompiled).toBe(1);
+        expect(result.cached).toBe(1);
+        expect(result.errors.size).toBe(0);
+    });
+    test('modify dependency: all dependent files recompiled', () => {
+        const lib = writeFile(tmpDir, 'lib.mcrs', 'fn helper() { let h: int = 0; }');
+        const main1 = writeFile(tmpDir, 'main1.mcrs', 'import "lib.mcrs";\nfn main1() { helper(); }');
+        const main2 = writeFile(tmpDir, 'main2.mcrs', 'import "lib.mcrs";\nfn main2() { helper(); }');
+        const other = writeFile(tmpDir, 'other.mcrs', 'fn other() { let o: int = 0; }');
+        const cache = new index_1.FileCache(cacheDir);
+        const depGraph = new deps_1.DependencyGraph();
+        // First compile
+        (0, incremental_1.compileIncremental)([main1, main2, other], cache, depGraph, { output: outDir });
+        expect(cache.get(path.resolve(main1))).toBeDefined();
+        // Modify lib (a dependency, not an entry file itself)
+        fs.writeFileSync(lib, 'fn helper() { let h: int = 99; }');
+        const now = Date.now();
+        fs.utimesSync(lib, new Date(now + 2000), new Date(now + 2000));
+        const result = (0, incremental_1.compileIncremental)([main1, main2, other], cache, depGraph, { output: outDir });
+        // main1 and main2 depend on lib → recompiled; other is unrelated → cached
+        expect(result.recompiled).toBe(2);
+        expect(result.cached).toBe(1);
+        expect(result.errors.size).toBe(0);
+    });
+    test('output files are written to disk', () => {
+        writeFile(tmpDir, 'a.mcrs', 'fn a_func() { let x: int = 1; }');
+        const a = path.join(tmpDir, 'a.mcrs');
+        const cache = new index_1.FileCache(cacheDir);
+        const depGraph = new deps_1.DependencyGraph();
+        (0, incremental_1.compileIncremental)([a], cache, depGraph, { output: outDir });
+        // Output directory should exist with generated files
+        expect(fs.existsSync(outDir)).toBe(true);
+        const files = fs.readdirSync(outDir, { recursive: true });
+        expect(files.length).toBeGreaterThan(0);
+    });
+    test('compile errors are captured without crashing', () => {
+        // Invalid syntax
+        const bad = writeFile(tmpDir, 'bad.mcrs', 'fn { broken syntax !!!!');
+        const cache = new index_1.FileCache(cacheDir);
+        const depGraph = new deps_1.DependencyGraph();
+        const result = (0, incremental_1.compileIncremental)([bad], cache, depGraph, { output: outDir });
+        expect(result.errors.size).toBe(1);
+        expect(result.recompiled).toBe(0);
+    });
+});
+//# sourceMappingURL=incremental.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,321 @@
+"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");
+const metadata_1 = require("../builtins/metadata");
+// ---------------------------------------------------------------------------
+// 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');
+    });
+});
+// ---------------------------------------------------------------------------
+// Hover — builtin functions
+// ---------------------------------------------------------------------------
+const DECORATOR_DOCS = {
+    tick: 'Runs every MC game tick (~20 Hz). No arguments.',
+    load: 'Runs on `/reload`. Use for initialization logic.',
+    coroutine: 'Splits loops into tick-spread continuations. Arg: `batch=N` (steps per tick, default 1).',
+    schedule: 'Schedules the function to run after N ticks. Arg: `ticks=N`.',
+    on_trigger: 'Runs when a trigger scoreboard objective is set by a player. Arg: trigger name.',
+    keep: 'Prevents the compiler from dead-code-eliminating this function.',
+    on: 'Generic event handler decorator.',
+    on_advancement: 'Runs when a player earns an advancement. Arg: advancement id.',
+    on_craft: 'Runs when a player crafts an item. Arg: item id.',
+    on_death: 'Runs when a player dies.',
+    on_join_team: 'Runs when a player joins a team. Arg: team name.',
+    on_login: 'Runs when a player logs in.',
+};
+describe('LSP hover — builtin functions', () => {
+    it('has metadata for say', () => {
+        const b = metadata_1.BUILTIN_METADATA['say'];
+        expect(b).toBeDefined();
+        expect(b.params.length).toBeGreaterThan(0);
+        expect(b.returns).toBe('void');
+        expect(b.doc).toBeTruthy();
+    });
+    it('has metadata for kill', () => {
+        const b = metadata_1.BUILTIN_METADATA['kill'];
+        expect(b).toBeDefined();
+        expect(b.returns).toBe('void');
+    });
+    it('has metadata for tellraw', () => {
+        const b = metadata_1.BUILTIN_METADATA['tellraw'];
+        expect(b).toBeDefined();
+        const paramStr = b.params.map(p => `${p.name}: ${p.type}${p.required ? '' : '?'}`).join(', ');
+        const sig = `fn ${b.name}(${paramStr}): ${b.returns}`;
+        expect(sig).toMatch(/^fn tellraw/);
+        expect(sig).toContain('target');
+    });
+    it('formats builtin hover markdown', () => {
+        const b = metadata_1.BUILTIN_METADATA['particle'];
+        expect(b).toBeDefined();
+        const paramStr = b.params.map(p => `${p.name}: ${p.type}${p.required ? '' : '?'}`).join(', ');
+        const sig = `fn ${b.name}(${paramStr}): ${b.returns}`;
+        const markdown = `\`\`\`redscript\n${sig}\n\`\`\`\n${b.doc}`;
+        expect(markdown).toContain('```redscript');
+        expect(markdown).toContain('fn particle');
+        expect(markdown).toContain(b.doc);
+    });
+});
+// ---------------------------------------------------------------------------
+// Hover — decorators
+// ---------------------------------------------------------------------------
+describe('LSP hover — decorators', () => {
+    it('has docs for @tick', () => {
+        expect(DECORATOR_DOCS['tick']).toContain('tick');
+    });
+    it('has docs for @load', () => {
+        expect(DECORATOR_DOCS['load']).toContain('reload');
+    });
+    it('has docs for @coroutine', () => {
+        expect(DECORATOR_DOCS['coroutine']).toContain('batch');
+    });
+    it('has docs for @schedule', () => {
+        expect(DECORATOR_DOCS['schedule']).toContain('ticks');
+    });
+    it('has docs for @on_trigger', () => {
+        expect(DECORATOR_DOCS['on_trigger']).toContain('trigger');
+    });
+    it('formats decorator hover markdown', () => {
+        const name = 'tick';
+        const doc = DECORATOR_DOCS[name];
+        const markdown = `**@${name}** — ${doc}`;
+        expect(markdown).toBe(`**@tick** — ${DECORATOR_DOCS['tick']}`);
+    });
+});
+// ---------------------------------------------------------------------------
+// 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/src/__tests__/mc-syntax.test.js

@@ -38,7 +38,7 @@ const path = __importStar(require("path"));
 const compile_1 = require("../compile");
 const mc_validator_1 = require("../mc-validator");
 const FIXTURE_PATH = path.join(__dirname, 'fixtures', 'mc-commands-1.21.4.json');
-const EXAMPLES = ['counter', 'arena', 'shop', 'quiz', 'turret'];
+const EXAMPLES = ['shop', 'quiz', 'turret'];
 function getCommands(source, namespace = 'test') {
     const result = (0, compile_1.compile)(source, { namespace });
     expect(result.success).toBe(true);
@@ -56,11 +56,6 @@ function validateSource(validator, source, namespace) {
 }
 describe('MC Command Syntax Validation', () => {
     const validator = new mc_validator_1.MCCommandValidator(FIXTURE_PATH);
-    test('counter example generates valid MC commands', () => {
-        const src = fs.readFileSync(path.join(__dirname, '..', 'examples', 'counter.mcrs'), 'utf-8');
-        const errors = validateSource(validator, src, 'counter');
-        expect(errors).toHaveLength(0);
-    });
     EXAMPLES.forEach(name => {
         test(`${name}.mcrs generates valid MC commands`, () => {
             const src = fs.readFileSync(path.join(__dirname, '..', 'examples', `${name}.mcrs`), 'utf-8');

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 {};