redscript-mc 2.0.0 → 2.1.1

package/src/__tests__/incremental.test.ts

@@ -0,0 +1,337 @@
+/**
+ * Tests for incremental compilation: FileCache, DependencyGraph, and
+ * compileIncremental.
+ */
+
+import * as fs from 'fs'
+import * as path from 'path'
+import * as os from 'os'
+import { FileCache, hashFile } from '../cache/index'
+import { DependencyGraph, parseImports } from '../cache/deps'
+import { compileIncremental, resetCompileCache } from '../cache/incremental'
+
+/** Create a temp directory for test files. */
+function makeTmpDir(): string {
+  return fs.mkdtempSync(path.join(os.tmpdir(), 'redscript-test-'))
+}
+
+/** Write a .mcrs file and return its absolute path. */
+function writeFile(dir: string, name: string, content: string): string {
+  const filePath = path.join(dir, name)
+  fs.mkdirSync(path.dirname(filePath), { recursive: true })
+  fs.writeFileSync(filePath, content)
+  return filePath
+}
+
+// ---------------------------------------------------------------------------
+// FileCache
+// ---------------------------------------------------------------------------
+
+describe('FileCache', () => {
+  let tmpDir: string
+  let cacheDir: string
+
+  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 = hashFile(f)
+    const h2 = 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 = hashFile(f)
+    fs.writeFileSync(f, 'fn main() { let x: int = 1; }')
+    const h2 = hashFile(f)
+    expect(h1).not.toBe(h2)
+  })
+
+  test('hasChanged returns true for unknown file', () => {
+    const cache = new 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 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 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 FileCache(cacheDir)
+    const f = writeFile(tmpDir, 'a.mcrs', 'fn main() {}')
+    cache.update(f)
+    cache.save()
+
+    const cache2 = new 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 FileCache(cacheDir)
+    cache.load() // no file — should not throw
+    expect(cache.size).toBe(0)
+  })
+})
+
+// ---------------------------------------------------------------------------
+// DependencyGraph
+// ---------------------------------------------------------------------------
+
+describe('DependencyGraph', () => {
+  let tmpDir: string
+
+  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 = 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 = 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 = 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 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 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 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 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: string
+  let cacheDir: string
+  let outDir: string
+
+  beforeEach(() => {
+    tmpDir = makeTmpDir()
+    cacheDir = path.join(tmpDir, '.redscript-cache')
+    outDir = path.join(tmpDir, 'out')
+    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 FileCache(cacheDir)
+    const depGraph = new DependencyGraph()
+
+    const result = 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 FileCache(cacheDir)
+    const depGraph = new DependencyGraph()
+
+    // First compile
+    compileIncremental([a, b], cache, depGraph, { output: outDir })
+
+    // Second compile — no changes
+    const result = 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 FileCache(cacheDir)
+    const depGraph = new DependencyGraph()
+
+    // First compile
+    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 = 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 FileCache(cacheDir)
+    const depGraph = new DependencyGraph()
+
+    // First compile
+    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 = 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 FileCache(cacheDir)
+    const depGraph = new DependencyGraph()
+
+    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 }) as string[]
+    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 FileCache(cacheDir)
+    const depGraph = new DependencyGraph()
+
+    const result = compileIncremental([bad], cache, depGraph, { output: outDir })
+
+    expect(result.errors.size).toBe(1)
+    expect(result.recompiled).toBe(0)
+  })
+})

package/src/__tests__/lsp.test.ts

@@ -0,0 +1,359 @@
+/**
+ * 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.
+ */
+
+import { Lexer } from '../lexer'
+import { Parser } from '../parser'
+import { TypeChecker } from '../typechecker'
+import { DiagnosticError } from '../diagnostics'
+import type { Program, FnDecl, TypeNode } from '../ast/types'
+import { BUILTIN_METADATA } from '../builtins/metadata'
+
+// ---------------------------------------------------------------------------
+// Helpers mirrored from lsp/server.ts (tested independently)
+// ---------------------------------------------------------------------------
+
+function typeToString(t: TypeNode): string {
+  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: FnDecl): string {
+  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: string): { program: Program | null; errors: DiagnosticError[] } {
+  const errors: DiagnosticError[] = []
+  let program: Program | null = null
+  try {
+    const tokens = new Lexer(source).tokenize()
+    program = new Parser(tokens, source).parse('test')
+  } catch (err) {
+    if (err instanceof DiagnosticError) errors.push(err)
+    else errors.push(new DiagnosticError('ParseError', (err as Error).message, { line: 1, col: 1 }))
+    return { program: null, errors }
+  }
+  try {
+    const checker = new 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(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: TypeNode = {
+      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: TypeNode = {
+      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: Record<string, string> = {
+  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 = 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 = BUILTIN_METADATA['kill']
+    expect(b).toBeDefined()
+    expect(b.returns).toBe('void')
+  })
+
+  it('has metadata for tellraw', () => {
+    const b = 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 = 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()
+  })
+})