redscript-mc 1.0.0

package/editors/vscode/redscript-language-configuration.json

@@ -0,0 +1,28 @@
+{
+  "comments": {
+    "lineComment": "//",
+    "blockComment": ["/*", "*/"]
+  },
+  "brackets": [
+    ["{", "}"],
+    ["[", "]"],
+    ["(", ")"]
+  ],
+  "autoClosingPairs": [
+    { "open": "{", "close": "}" },
+    { "open": "[", "close": "]" },
+    { "open": "(", "close": ")" },
+    { "open": "\"", "close": "\"" }
+  ],
+  "surroundingPairs": [
+    ["{", "}"],
+    ["[", "]"],
+    ["(", ")"],
+    ["\"", "\""]
+  ],
+  "indentationRules": {
+    "increaseIndentPattern": "\\{\\s*$",
+    "decreaseIndentPattern": "^\\s*\\}"
+  },
+  "wordPattern": "[a-zA-Z_][a-zA-Z0-9_]*"
+}

package/editors/vscode/snippets/redscript.json

@@ -0,0 +1,114 @@
+{
+  "Function": {
+    "prefix": "fn",
+    "body": [
+      "fn ${1:name}(${2:params})${3: -> ${4:ReturnType}} {",
+      "    $0",
+      "}"
+    ],
+    "description": "Define a function"
+  },
+  "Tick Function": {
+    "prefix": "fntick",
+    "body": [
+      "@tick",
+      "fn ${1:name}(${2:params})${3: -> ${4:void}} {",
+      "    $0",
+      "}"
+    ],
+    "description": "Define an @tick function"
+  },
+  "Load Function": {
+    "prefix": "fnload",
+    "body": [
+      "@on_load",
+      "fn ${1:name}(${2:params})${3: -> ${4:void}} {",
+      "    $0",
+      "}"
+    ],
+    "description": "Define an @on_load function"
+  },
+  "If Statement": {
+    "prefix": "if",
+    "body": [
+      "if (${1:condition}) {",
+      "    $0",
+      "}"
+    ],
+    "description": "Insert an if statement"
+  },
+  "If Else Statement": {
+    "prefix": "ife",
+    "body": [
+      "if (${1:condition}) {",
+      "    ${2}",
+      "} else {",
+      "    $0",
+      "}"
+    ],
+    "description": "Insert an if-else statement"
+  },
+  "Match Expression": {
+    "prefix": "match",
+    "body": [
+      "match (${1:value}) {",
+      "    ${2:pattern} => {",
+      "        ${3}",
+      "    }",
+      "    _ => {",
+      "        $0",
+      "    }",
+      "}"
+    ],
+    "description": "Insert a match expression"
+  },
+  "Foreach Selector": {
+    "prefix": "foreach",
+    "body": [
+      "foreach (${1:entity} in ${2:@a}) {",
+      "    $0",
+      "}"
+    ],
+    "description": "Iterate over a selector or iterable"
+  },
+  "Foreach Selector Body": {
+    "prefix": "fors",
+    "body": [
+      "foreach (${1:entity} in ${2:@a}) {",
+      "    ${3}",
+      "    $0",
+      "}"
+    ],
+    "description": "Iterate over a selector with a prepared body"
+  },
+  "Let Declaration": {
+    "prefix": "let",
+    "body": [
+      "let ${1:name}: ${2:Type} = ${0:value};"
+    ],
+    "description": "Declare a typed local variable"
+  },
+  "Const Declaration": {
+    "prefix": "const",
+    "body": [
+      "const ${1:NAME}: ${2:Type} = ${0:value}"
+    ],
+    "description": "Declare a constant"
+  },
+  "Struct Definition": {
+    "prefix": "struct",
+    "body": [
+      "struct ${1:Name} {",
+      "    ${2:field}: ${3:Type}",
+      "}"
+    ],
+    "description": "Define a struct"
+  },
+  "Enum Definition": {
+    "prefix": "enum",
+    "body": [
+      "enum ${1:Name} { ${2:VariantA}, ${3:VariantB} }"
+    ],
+    "description": "Define an enum"
+  }
+}

package/editors/vscode/src/codeactions.ts

@@ -0,0 +1,89 @@
+import * as vscode from 'vscode'
+
+/**
+ * Code action provider for RedScript.
+ * Currently provides:
+ *  - "Add minecraft: namespace" quick fix for unnamespaced entity types
+ *    e.g. type=zombie → type=minecraft:zombie
+ */
+export function registerCodeActions(context: vscode.ExtensionContext): void {
+  context.subscriptions.push(
+    vscode.languages.registerCodeActionsProvider(
+      { language: 'redscript', scheme: 'file' },
+      new RedScriptCodeActionProvider(),
+      { providedCodeActionKinds: [vscode.CodeActionKind.QuickFix] }
+    )
+  )
+}
+
+class RedScriptCodeActionProvider implements vscode.CodeActionProvider {
+  provideCodeActions(
+    document: vscode.TextDocument,
+    range: vscode.Range,
+    context: vscode.CodeActionContext
+  ): vscode.CodeAction[] {
+    const actions: vscode.CodeAction[] = []
+
+    for (const diag of context.diagnostics) {
+      if (diag.source !== 'redscript') continue
+
+      // W_UNNAMESPACED_TYPE: e.g. 'Unnamespaced entity type "zombie"'
+      if (diag.code === 'W_UNNAMESPACED_TYPE') {
+        const m = diag.message.match(/Unnamespaced entity type "([^"]+)"/)
+        if (!m) continue
+        const typeName = m[1]
+
+        // Find and replace in the diagnostic range area
+        const fix = new vscode.CodeAction(
+          `Add namespace: type=minecraft:${typeName}`,
+          vscode.CodeActionKind.QuickFix
+        )
+        fix.diagnostics = [diag]
+        fix.isPreferred = true
+
+        // Search the document for type=<typeName> (without namespace)
+        const text = document.getText()
+        const re = new RegExp(`\\btype=${escapeRe(typeName)}(?![a-zA-Z0-9_:.])`, 'g')
+        const edit = new vscode.WorkspaceEdit()
+        let match: RegExpExecArray | null
+        while ((match = re.exec(text)) !== null) {
+          const start = document.positionAt(match.index + 'type='.length)
+          const end = document.positionAt(match.index + 'type='.length + typeName.length)
+          edit.replace(document.uri, new vscode.Range(start, end), `minecraft:${typeName}`)
+        }
+        fix.edit = edit
+        actions.push(fix)
+      }
+    }
+
+    // Also scan the current line for unnamespaced type= patterns
+    // even without a diagnostic (as a proactive suggestion)
+    const lineText = document.lineAt(range.start.line).text
+    const lineTypeRe = /\btype=([a-z][a-z0-9_]*)(?!\s*[:a-z0-9_])/g
+    let lm: RegExpExecArray | null
+    while ((lm = lineTypeRe.exec(lineText)) !== null) {
+      const typeName = lm[1]
+      // Skip already-namespaced or already have a fix above
+      if (typeName.includes(':')) continue
+      if (actions.some(a => a.title.includes(typeName))) continue
+
+      const fix = new vscode.CodeAction(
+        `Add namespace: type=minecraft:${typeName}`,
+        vscode.CodeActionKind.QuickFix
+      )
+      const col = lm.index + 'type='.length
+      const start = new vscode.Position(range.start.line, col)
+      const end = new vscode.Position(range.start.line, col + typeName.length)
+      const edit = new vscode.WorkspaceEdit()
+      edit.replace(document.uri, new vscode.Range(start, end), `minecraft:${typeName}`)
+      fix.edit = edit
+      actions.push(fix)
+    }
+
+    return actions
+  }
+}
+
+function escapeRe(s: string): string {
+  return s.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')
+}

package/editors/vscode/src/completion.ts

@@ -0,0 +1,130 @@
+import * as vscode from 'vscode'
+
+interface BuiltinFunction {
+  name: string
+  detail: string
+  doc: string
+  insertText?: string
+  kind?: vscode.CompletionItemKind
+}
+
+const BUILTIN_FUNCTIONS: BuiltinFunction[] = [
+  { name: 'say', detail: 'say(msg: string)', doc: 'Broadcast a message to all players as the server.' },
+  { name: 'tell', detail: 'tell(target: selector, msg: string)', doc: 'Send a private message to a player or selector.' },
+  { name: 'announce', detail: 'announce(msg: string)', doc: 'Send a message to all players in chat.' },
+  { name: 'title', detail: 'title(target: selector, msg: string)', doc: 'Show a large title on screen for target players.' },
+  { name: 'subtitle', detail: 'subtitle(target: selector, msg: string)', doc: 'Show subtitle text below the title.' },
+  { name: 'actionbar', detail: 'actionbar(target: selector, msg: string)', doc: 'Show text in the action bar (above hotbar).' },
+  { name: 'title_times', detail: 'title_times(target: selector, fadeIn: int, stay: int, fadeOut: int)', doc: 'Set title display timing (in ticks).' },
+  { name: 'give', detail: 'give(target: selector, item: string, count?: int)', doc: 'Give item(s) to a player.' },
+  { name: 'kill', detail: 'kill(target?: selector)', doc: 'Kill entity/entities. Defaults to @s.' },
+  { name: 'effect', detail: 'effect(target: selector, effect: string, duration?: int, amplifier?: int)', doc: 'Apply a status effect.' },
+  { name: 'clear', detail: 'clear(target: selector, item?: string)', doc: 'Remove items from inventory.' },
+  { name: 'kick', detail: 'kick(player: selector, reason?: string)', doc: 'Kick a player from the server.' },
+  { name: 'xp_add', detail: 'xp_add(target: selector, amount: int, type?: string)', doc: 'Add experience to a player.' },
+  { name: 'xp_set', detail: 'xp_set(target: selector, amount: int, type?: string)', doc: "Set a player's experience." },
+  { name: 'tp', detail: 'tp(target: selector, destination: selector | BlockPos)', doc: 'Teleport entity to a player or coordinates.' },
+  { name: 'setblock', detail: 'setblock(pos: BlockPos, block: string)', doc: 'Place a block at coordinates.' },
+  { name: 'fill', detail: 'fill(from: BlockPos, to: BlockPos, block: string)', doc: 'Fill a region with blocks.' },
+  { name: 'clone', detail: 'clone(from: BlockPos, to: BlockPos, dest: BlockPos)', doc: 'Clone a region of blocks to a new location.' },
+  { name: 'summon', detail: 'summon(type: string, pos: BlockPos)', doc: 'Spawn an entity at a location.' },
+  { name: 'weather', detail: 'weather(type: string)', doc: 'Set the weather.' },
+  { name: 'time_set', detail: 'time_set(value: int | string)', doc: 'Set the world time.' },
+  { name: 'time_add', detail: 'time_add(ticks: int)', doc: 'Advance world time by ticks.' },
+  { name: 'gamerule', detail: 'gamerule(rule: string, value: bool | int)', doc: 'Set a gamerule value.' },
+  { name: 'difficulty', detail: 'difficulty(level: string)', doc: 'Set the game difficulty.' },
+  { name: 'particle', detail: 'particle(name: string, pos: BlockPos)', doc: 'Spawn a particle effect.' },
+  { name: 'playsound', detail: 'playsound(sound: string, source: string, target: selector, pos?: BlockPos, volume?: float, pitch?: float)', doc: 'Play a sound for a player.' },
+  { name: 'tag_add', detail: 'tag_add(target: selector, tag: string)', doc: 'Add an entity tag.' },
+  { name: 'tag_remove', detail: 'tag_remove(target: selector, tag: string)', doc: 'Remove an entity tag.' },
+  { name: 'scoreboard_get', detail: 'scoreboard_get(target: selector | string, objective: string) -> int', doc: 'Read a scoreboard value.' },
+  { name: 'score', detail: 'score(target: selector | string, objective: string) -> int', doc: 'Alias for scoreboard_get. Read a scoreboard value.' },
+  { name: 'scoreboard_set', detail: 'scoreboard_set(target: selector | string, objective: string, value: int)', doc: 'Set a scoreboard value.' },
+  { name: 'scoreboard_add', detail: 'scoreboard_add(target: selector | string, objective: string, amount: int)', doc: 'Add to a scoreboard value.' },
+  { name: 'scoreboard_display', detail: 'scoreboard_display(slot: string, objective: string)', doc: 'Display a scoreboard objective in a slot.' },
+  { name: 'scoreboard_add_objective', detail: 'scoreboard_add_objective(name: string, criteria: string)', doc: 'Create a new scoreboard objective.' },
+  { name: 'scoreboard_remove_objective', detail: 'scoreboard_remove_objective(name: string)', doc: 'Remove a scoreboard objective.' },
+  { name: 'scoreboard_hide', detail: 'scoreboard_hide(slot: string)', doc: 'Clear the display in a scoreboard slot.' },
+  { name: 'random', detail: 'random(min: int, max: int) -> int', doc: 'Generate a random integer in range [min, max] using scoreboard arithmetic.' },
+  { name: 'random_native', detail: 'random_native(min: int, max: int) -> int', doc: 'Generate a random integer using /random command (MC 1.20.3+). Faster than random().' },
+  { name: 'str_len', detail: 'str_len(s: string) -> int', doc: 'Get the length of a string (stored in NBT storage).' },
+  { name: 'push', detail: 'push(arr: T[], value: T)', doc: 'Append a value to the end of an array.' },
+  { name: 'pop', detail: 'pop(arr: T[]) -> T', doc: 'Remove and return the last element of an array.' },
+  { name: 'len', detail: 'arr.len', doc: 'Get the number of elements in an array (property access, not a function call).', kind: vscode.CompletionItemKind.Property },
+  { name: 'data_get', detail: 'data_get(target: string, path: string) -> int', doc: 'Read NBT data from entity/block/storage.' },
+  { name: 'bossbar_add', detail: 'bossbar_add(id: string, name: string)', doc: 'Create a new boss bar.' },
+  { name: 'bossbar_set_value', detail: 'bossbar_set_value(id: string, value: int)', doc: 'Set boss bar current value.' },
+  { name: 'bossbar_set_max', detail: 'bossbar_set_max(id: string, max: int)', doc: 'Set boss bar maximum value.' },
+  { name: 'bossbar_remove', detail: 'bossbar_remove(id: string)', doc: 'Remove a boss bar.' },
+  { name: 'bossbar_set_players', detail: 'bossbar_set_players(id: string, target: selector)', doc: 'Set which players see the boss bar.' },
+  { name: 'bossbar_set_color', detail: 'bossbar_set_color(id: string, color: string)', doc: 'Set boss bar color.' },
+  { name: 'bossbar_set_style', detail: 'bossbar_set_style(id: string, style: string)', doc: 'Set boss bar segmentation style.' },
+  { name: 'bossbar_set_visible', detail: 'bossbar_set_visible(id: string, visible: bool)', doc: 'Show or hide a boss bar.' },
+  { name: 'bossbar_get_value', detail: 'bossbar_get_value(id: string) -> int', doc: 'Get the current value of a boss bar.' },
+  { name: 'team_add', detail: 'team_add(name: string)', doc: 'Create a new team.' },
+  { name: 'team_remove', detail: 'team_remove(name: string)', doc: 'Remove a team.' },
+  { name: 'team_join', detail: 'team_join(name: string, target: selector)', doc: 'Add entities to a team.' },
+  { name: 'team_leave', detail: 'team_leave(target: selector)', doc: 'Remove entities from their team.' },
+  { name: 'team_option', detail: 'team_option(name: string, option: string, value: string)', doc: 'Set a team option.' },
+  { name: 'tick', detail: '@tick  |  @tick(rate: int)', doc: 'Run this function every tick (rate=1) or every N ticks.', insertText: '@tick', kind: vscode.CompletionItemKind.Event },
+  { name: 'on_advancement', detail: '@on_advancement(id: string)', doc: 'Trigger when a player earns an advancement.', insertText: '@on_advancement', kind: vscode.CompletionItemKind.Event },
+  { name: 'on_death', detail: '@on_death', doc: 'Trigger when the executing entity dies.', insertText: '@on_death', kind: vscode.CompletionItemKind.Event },
+  { name: 'on_craft', detail: '@on_craft(item: string)', doc: 'Trigger when a player crafts an item.', insertText: '@on_craft', kind: vscode.CompletionItemKind.Event },
+]
+
+const KEYWORDS = [
+  'fn',
+  'let',
+  'const',
+  'if',
+  'else',
+  'match',
+  'foreach',
+  'in',
+  'return',
+  'struct',
+  'enum',
+  'execute',
+  'as',
+  'at',
+  'true',
+  'false',
+]
+
+const TYPES = ['int', 'float', 'string', 'bool', 'void', 'BlockPos', 'selector']
+const TRIGGER_CHARACTERS = 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ_@'.split('')
+
+export function registerCompletionProvider(context: vscode.ExtensionContext): void {
+  const provider = vscode.languages.registerCompletionItemProvider(
+    { language: 'redscript', scheme: 'file' },
+    {
+      provideCompletionItems() {
+        const items: vscode.CompletionItem[] = []
+
+        for (const builtin of BUILTIN_FUNCTIONS) {
+          const item = new vscode.CompletionItem(
+            builtin.name,
+            builtin.kind ?? vscode.CompletionItemKind.Function,
+          )
+          item.detail = builtin.detail
+          item.documentation = builtin.doc
+          item.insertText = builtin.insertText ?? builtin.name
+          items.push(item)
+        }
+
+        for (const keyword of KEYWORDS) {
+          items.push(new vscode.CompletionItem(keyword, vscode.CompletionItemKind.Keyword))
+        }
+
+        for (const type of TYPES) {
+          items.push(new vscode.CompletionItem(type, vscode.CompletionItemKind.TypeParameter))
+        }
+
+        return items
+      },
+    },
+    ...TRIGGER_CHARACTERS,
+  )
+
+  context.subscriptions.push(provider)
+}

package/editors/vscode/src/extension.ts

@@ -0,0 +1,239 @@
+import * as vscode from 'vscode'
+import { registerHoverProvider } from './hover'
+import { registerCodeActions } from './codeactions'
+import { registerCompletionProvider } from './completion'
+import { registerSymbolProviders } from './symbols'
+// The compiler is bundled directly into this extension by esbuild.
+// eslint-disable-next-line @typescript-eslint/no-var-requires
+const { compile: _compile } = require('redscript') as {
+  compile: (source: string, opts?: { filePath?: string }) => {
+    files: { path: string; content: string }[]
+    warnings: { message: string; code: string; line?: number; col?: number }[]
+  }
+}
+
+function getCompile() {
+  return _compile ?? null
+}
+
+const DEBOUNCE_MS = 600
+
+export function activate(context: vscode.ExtensionContext): void {
+  const diagnostics = vscode.languages.createDiagnosticCollection('redscript')
+  context.subscriptions.push(diagnostics)
+
+  // Debounce timer per document URI
+  const timers = new Map<string, NodeJS.Timeout>()
+
+  function scheduleValidation(doc: vscode.TextDocument) {
+    if (doc.languageId !== 'redscript') return
+    const key = doc.uri.toString()
+    const existing = timers.get(key)
+    if (existing) clearTimeout(existing)
+    timers.set(key, setTimeout(() => {
+      validateDocument(doc, diagnostics)
+      timers.delete(key)
+    }, DEBOUNCE_MS))
+  }
+
+  // Validate on open
+  context.subscriptions.push(
+    vscode.workspace.onDidOpenTextDocument(doc => scheduleValidation(doc))
+  )
+
+  // Validate on change
+  context.subscriptions.push(
+    vscode.workspace.onDidChangeTextDocument(e => scheduleValidation(e.document))
+  )
+
+  // Clear diagnostics on close
+  context.subscriptions.push(
+    vscode.workspace.onDidCloseTextDocument(doc => {
+      diagnostics.delete(doc.uri)
+      const key = doc.uri.toString()
+      const t = timers.get(key)
+      if (t) { clearTimeout(t); timers.delete(key) }
+    })
+  )
+
+  // Validate all already-open .rs files
+  vscode.workspace.textDocuments
+    .filter(d => d.languageId === 'redscript')
+    .forEach(d => scheduleValidation(d))
+
+  // Register hover documentation
+  registerHoverProvider(context)
+
+  // Register completions
+  registerCompletionProvider(context)
+
+  // Register code actions (quick fixes)
+  registerCodeActions(context)
+
+  // Register Go-to-Definition and Find-References
+  registerSymbolProviders(context)
+
+  // Status bar item to show compilation state
+  const statusBar = vscode.window.createStatusBarItem(vscode.StatusBarAlignment.Left, 10)
+  statusBar.text = '$(pass) RedScript'
+  statusBar.tooltip = 'RedScript compiler'
+  statusBar.show()
+  context.subscriptions.push(statusBar)
+
+  // Track the active editor's compile state
+  context.subscriptions.push(
+    vscode.window.onDidChangeActiveTextEditor(editor => {
+      if (editor?.document.languageId === 'redscript') {
+        statusBar.show()
+      } else {
+        statusBar.hide()
+      }
+    })
+  )
+}
+
+function validateDocument(
+  doc: vscode.TextDocument,
+  collection: vscode.DiagnosticCollection
+): void {
+  const compile = getCompile()
+  if (!compile) {
+    // Compiler not available — show a one-time info message
+    collection.set(doc.uri, [{
+      message: 'RedScript compiler not found. Run `npm install -g redscript` to enable diagnostics.',
+      range: new vscode.Range(0, 0, 0, 0),
+      severity: vscode.DiagnosticSeverity.Information,
+      source: 'redscript'
+    }])
+    return
+  }
+
+  const source = doc.getText()
+  const docDiagnostics: vscode.Diagnostic[] = []
+
+  try {
+    const result = compile(source, { filePath: doc.uri.fsPath })
+
+    // Convert warnings to VS Code diagnostics
+    for (const w of result.warnings ?? []) {
+      // Use real line/col from AST span when available, fall back to text search
+      const range = (w.line && w.col)
+        ? new vscode.Range(w.line - 1, w.col - 1, w.line - 1, w.col - 1 + 20)
+        : findWarningRange(w.message, w.code, source, doc)
+      docDiagnostics.push({
+        message: w.message,
+        range,
+        severity: vscode.DiagnosticSeverity.Warning,
+        source: 'redscript',
+        code: w.code
+      })
+    }
+  } catch (err: unknown) {
+    const msg = err instanceof Error ? err.message : String(err)
+
+    // Try to get location from DiagnosticError.location first
+    let range: vscode.Range
+    const loc = (err as { location?: { line?: number; col?: number } }).location
+    if (loc?.line && loc?.col) {
+      const l = Math.max(0, loc.line - 1)
+      const c = Math.max(0, loc.col - 1)
+      range = new vscode.Range(l, c, l, c + 20)
+    } else {
+      // Fallback: parse the error message for line/column info
+      range = extractRange(msg, doc)
+    }
+
+    docDiagnostics.push({
+      message: msg,
+      range,
+      severity: vscode.DiagnosticSeverity.Error,
+      source: 'redscript'
+    })
+  }
+
+  collection.set(doc.uri, docDiagnostics)
+}
+
+/**
+ * For warnings without position info, search the source for the relevant token
+ * mentioned in the warning message.
+ */
+function findWarningRange(
+  message: string,
+  code: string | undefined,
+  source: string,
+  doc: vscode.TextDocument
+): vscode.Range {
+  // W_UNNAMESPACED_TYPE: message contains the unqualified type name in quotes
+  // e.g. 'Unnamespaced entity type "zombie"'
+  if (code === 'W_UNNAMESPACED_TYPE') {
+    const m = message.match(/"([^"]+)"/)
+    if (m) return searchToken(source, doc, `type=${m[1]}`) ?? searchToken(source, doc, m[1]) ?? topLine(doc)
+  }
+
+  // W_QUOTED_SELECTOR: message contains the quoted selector
+  // e.g. 'Quoted selector "@a" is deprecated'
+  if (code === 'W_QUOTED_SELECTOR') {
+    const m = message.match(/"(@[^"]+)"/)
+    if (m) return searchToken(source, doc, `"${m[1]}"`) ?? topLine(doc)
+  }
+
+  // W_DEPRECATED: usually about tp_to
+  if (code === 'W_DEPRECATED') {
+    const m = message.match(/^(\w+) is deprecated/)
+    if (m) return searchToken(source, doc, m[1]) ?? topLine(doc)
+  }
+
+  return topLine(doc)
+}
+
+/** Search source for a literal string, return range of first match. */
+function searchToken(
+  source: string,
+  doc: vscode.TextDocument,
+  token: string
+): vscode.Range | null {
+  const idx = source.indexOf(token)
+  if (idx < 0) return null
+  const pos = doc.positionAt(idx)
+  return new vscode.Range(pos, doc.positionAt(idx + token.length))
+}
+
+function topLine(doc: vscode.TextDocument): vscode.Range {
+  return new vscode.Range(0, 0, 0, doc.lineAt(0).text.length)
+}
+
+/**
+ * Try to extract line/column from common error formats:
+ *   "Error at line 5, column 12: ..."
+ *   "5:12: ..."
+ *   "[line 5] ..."
+ */
+function extractRange(msg: string, doc: vscode.TextDocument): vscode.Range {
+  // "line N, column M"
+  let m = msg.match(/line[: ]+(\d+)[,\s]+col(?:umn)?[: ]+(\d+)/i)
+  if (m) {
+    const l = Math.max(0, parseInt(m[1]) - 1)
+    const c = Math.max(0, parseInt(m[2]) - 1)
+    return new vscode.Range(l, c, l, c + 80)
+  }
+  // "N:M"
+  m = msg.match(/^(\d+):(\d+)/)
+  if (m) {
+    const l = Math.max(0, parseInt(m[1]) - 1)
+    const c = Math.max(0, parseInt(m[2]) - 1)
+    return new vscode.Range(l, c, l, c + 80)
+  }
+  // "[line N]"
+  m = msg.match(/\[line (\d+)\]/i)
+  if (m) {
+    const l = Math.max(0, parseInt(m[1]) - 1)
+    return new vscode.Range(l, 0, l, 200)
+  }
+  // Fallback: highlight first line
+  return new vscode.Range(0, 0, 0, doc.lineAt(0).text.length)
+}
+
+export function deactivate(): void {
+  // nothing
+}