@lokascript/language-server 2.3.1 → 2.4.0

package/dist/server.js

@@ -8,7 +8,7 @@ import {
   TextDocumentSyncKind,
   CompletionItemKind,
   MarkupKind,
-  DiagnosticSeverity,
+  DiagnosticSeverity as DiagnosticSeverity2,
   SymbolKind,
   CodeActionKind,
   DidChangeConfigurationNotification,
@@ -203,6 +203,42 @@ function extractHyperscriptRegions(content) {
       type: "script"
     });
   }
+  const templateRegex = /<template\s+[^>]*\bcomponent=["']([^"']+)["'][^>]*>([\s\S]*?)<\/template>/gi;
+  while ((match = templateRegex.exec(fullContent)) !== null) {
+    const tag = match[1];
+    const body = match[2];
+    const bodyStart = match.index + match[0].indexOf(">") + 1;
+    const bodyEnd = match.index + match[0].lastIndexOf("</template>");
+    const startPos = offsetToPosition(content, bodyStart);
+    const endPos = offsetToPosition(content, bodyEnd);
+    regions.push({
+      code: body,
+      startLine: startPos.line,
+      startChar: startPos.character,
+      endLine: endPos.line,
+      endChar: endPos.character,
+      type: "template",
+      componentTag: tag
+    });
+  }
+  const templateScriptRegex = /<script\s+[^>]*\btype=["']text\/hyperscript-template["'][^>]*\bcomponent=["']([^"']+)["'][^>]*>([\s\S]*?)<\/script>/gi;
+  while ((match = templateScriptRegex.exec(fullContent)) !== null) {
+    const tag = match[1];
+    const body = match[2];
+    const bodyStart = match.index + match[0].indexOf(">") + 1;
+    const bodyEnd = match.index + match[0].lastIndexOf("</script>");
+    const startPos = offsetToPosition(content, bodyStart);
+    const endPos = offsetToPosition(content, bodyEnd);
+    regions.push({
+      code: body,
+      startLine: startPos.line,
+      startChar: startPos.character,
+      endLine: endPos.line,
+      endChar: endPos.character,
+      type: "template",
+      componentTag: tag
+    });
+  }
   return regions;
 }
 function offsetToPosition(content, offset) {
@@ -243,20 +279,6 @@ function findRegionAtPosition(regions, line, character) {
   }
   return null;
 }
-function findLineInRegion(code, offset) {
-  let line = 0;
-  for (let i = 0; i < offset && i < code.length; i++) {
-    if (code[i] === "\n") line++;
-  }
-  return line;
-}
-function findCharInLine(code, offset) {
-  let lastNewline = -1;
-  for (let i = 0; i < offset && i < code.length; i++) {
-    if (code[i] === "\n") lastNewline = i;
-  }
-  return offset - lastNewline - 1;
-}
 
 // src/utils.ts
 function getWordAtPosition(line, character) {
@@ -275,9 +297,6 @@ function getWordAtPosition(line, character) {
   if (start === end) return null;
   return { text: line.slice(start, end), start, end };
 }
-function escapeRegExp(str) {
-  return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-}
 function findNextNonEmptyLine(lines, startIndex) {
   for (let i = startIndex; i < lines.length; i++) {
     const trimmed = lines[i].trim();
@@ -322,953 +341,466 @@ function formatHyperscript(code, indentStr = "  ") {
   return formattedLines.join("\n");
 }
 
-// src/chevrotain-parser.ts
-import { CstParser } from "chevrotain";
-
-// src/generated/chevrotain-vocabulary.ts
-import { createToken, Lexer } from "chevrotain";
-var Identifier = createToken({ name: "Identifier", pattern: /[a-zA-Z\u00C0-\u024F\u0400-\u04FF\u0600-\u06FF\u0900-\u09FF\u0E00-\u0E7F\u3040-\u9FFF\uAC00-\uD7AF][\w\u00C0-\u024F\u0400-\u04FF\u0600-\u06FF\u0900-\u09FF\u0E00-\u0E7F\u3040-\u9FFF\uAC00-\uD7AF'-]*/ });
-var WhiteSpace = createToken({ name: "WhiteSpace", pattern: /\s+/ });
-var StringLiteral = createToken({ name: "StringLiteral", pattern: /'[^']*'|"[^"]*"/ });
-var NumberLiteral = createToken({ name: "NumberLiteral", pattern: /\d+(\.\d+)?/ });
-var URLLiteral = createToken({ name: "URLLiteral", pattern: /\/[a-zA-Z0-9_\-.\/]+/ });
-var CSSSelector = createToken({ name: "CSSSelector", pattern: /[#.][a-zA-Z_][\w-]*/ });
-var AttributeSelector = createToken({ name: "AttributeSelector", pattern: /@[a-zA-Z_][\w-]*/ });
-var HTMLSelector = createToken({ name: "HTMLSelector", pattern: /<[a-zA-Z][\w.-]*\/>/ });
-var LocalVariable = createToken({ name: "LocalVariable", pattern: /:[a-zA-Z_][\w]*/ });
-var GlobalVariable = createToken({ name: "GlobalVariable", pattern: /\$[a-zA-Z_][\w]*/ });
-var LParen = createToken({ name: "LParen", pattern: /\(/ });
-var RParen = createToken({ name: "RParen", pattern: /\)/ });
-var Comma = createToken({ name: "Comma", pattern: /,/ });
-var Dot = createToken({ name: "Dot", pattern: /\./ });
-var Kw_previous = createToken({ name: "Kw_previous", pattern: /previous/, longer_alt: Identifier });
-var Kw_closest = createToken({ name: "Kw_closest", pattern: /closest/, longer_alt: Identifier });
-var Kw_while = createToken({ name: "Kw_while", pattern: /while/, longer_alt: Identifier });
-var Kw_until = createToken({ name: "Kw_until", pattern: /until/, longer_alt: Identifier });
-var Kw_times = createToken({ name: "Kw_times", pattern: /times/, longer_alt: Identifier });
-var Kw_first = createToken({ name: "Kw_first", pattern: /first/, longer_alt: Identifier });
-var Kw_false = createToken({ name: "Kw_false", pattern: /false/, longer_alt: Identifier });
-var Kw_then = createToken({ name: "Kw_then", pattern: /then/, longer_alt: Identifier });
-var Kw_else = createToken({ name: "Kw_else", pattern: /else/, longer_alt: Identifier });
-var Kw_from = createToken({ name: "Kw_from", pattern: /from/, longer_alt: Identifier });
-var Kw_into = createToken({ name: "Kw_into", pattern: /into/, longer_alt: Identifier });
-var Kw_with = createToken({ name: "Kw_with", pattern: /with/, longer_alt: Identifier });
-var Kw_have = createToken({ name: "Kw_have", pattern: /have/, longer_alt: Identifier });
-var Kw_last = createToken({ name: "Kw_last", pattern: /last/, longer_alt: Identifier });
-var Kw_next = createToken({ name: "Kw_next", pattern: /next/, longer_alt: Identifier });
-var Kw_true = createToken({ name: "Kw_true", pattern: /true/, longer_alt: Identifier });
-var Kw_null = createToken({ name: "Kw_null", pattern: /null/, longer_alt: Identifier });
-var Kw_end = createToken({ name: "Kw_end", pattern: /end/, longer_alt: Identifier });
-var Kw_for = createToken({ name: "Kw_for", pattern: /for/, longer_alt: Identifier });
-var Kw_and = createToken({ name: "Kw_and", pattern: /and/, longer_alt: Identifier });
-var Kw_not = createToken({ name: "Kw_not", pattern: /not/, longer_alt: Identifier });
-var Kw_has = createToken({ name: "Kw_has", pattern: /has/, longer_alt: Identifier });
-var Kw_you = createToken({ name: "Kw_you", pattern: /you/, longer_alt: Identifier });
-var Kw_its = createToken({ name: "Kw_its", pattern: /its/, longer_alt: Identifier });
-var Kw_the = createToken({ name: "Kw_the", pattern: /the/, longer_alt: Identifier });
-var Kw_on = createToken({ name: "Kw_on", pattern: /on/, longer_alt: Identifier });
-var Kw_if = createToken({ name: "Kw_if", pattern: /if/, longer_alt: Identifier });
-var Kw_to = createToken({ name: "Kw_to", pattern: /to/, longer_alt: Identifier });
-var Kw_in = createToken({ name: "Kw_in", pattern: /in/, longer_alt: Identifier });
-var Kw_of = createToken({ name: "Kw_of", pattern: /of/, longer_alt: Identifier });
-var Kw_as = createToken({ name: "Kw_as", pattern: /as/, longer_alt: Identifier });
-var Kw_at = createToken({ name: "Kw_at", pattern: /at/, longer_alt: Identifier });
-var Kw_by = createToken({ name: "Kw_by", pattern: /by/, longer_alt: Identifier });
-var Kw_or = createToken({ name: "Kw_or", pattern: /or/, longer_alt: Identifier });
-var Kw_is = createToken({ name: "Kw_is", pattern: /is/, longer_alt: Identifier });
-var Kw_me = createToken({ name: "Kw_me", pattern: /me/, longer_alt: Identifier });
-var Kw_it = createToken({ name: "Kw_it", pattern: /it/, longer_alt: Identifier });
-var Kw_my = createToken({ name: "Kw_my", pattern: /my/, longer_alt: Identifier });
-var Kw_no = createToken({ name: "Kw_no", pattern: /no/, longer_alt: Identifier });
-var Cmd_transition = createToken({ name: "Cmd_transition", pattern: /transition/, longer_alt: Identifier });
-var Cmd_show = createToken({ name: "Cmd_show", pattern: /show/, longer_alt: Identifier });
-var Cmd_hide = createToken({ name: "Cmd_hide", pattern: /hide/, longer_alt: Identifier });
-var Cmd_increment = createToken({ name: "Cmd_increment", pattern: /increment/, longer_alt: Identifier });
-var Cmd_decrement = createToken({ name: "Cmd_decrement", pattern: /decrement/, longer_alt: Identifier });
-var Cmd_default = createToken({ name: "Cmd_default", pattern: /default/, longer_alt: Identifier });
-var Cmd_beep = createToken({ name: "Cmd_beep", pattern: /beep/, longer_alt: Identifier });
-var Cmd_pick = createToken({ name: "Cmd_pick", pattern: /pick/, longer_alt: Identifier });
-var Cmd_set = createToken({ name: "Cmd_set", pattern: /set/, longer_alt: Identifier });
-var Cmd_log = createToken({ name: "Cmd_log", pattern: /log/, longer_alt: Identifier });
-var Cmd_get = createToken({ name: "Cmd_get", pattern: /get/, longer_alt: Identifier });
-var Cmd_continue = createToken({ name: "Cmd_continue", pattern: /continue/, longer_alt: Identifier });
-var Cmd_behavior = createToken({ name: "Cmd_behavior", pattern: /behavior/, longer_alt: Identifier });
-var Cmd_compound = createToken({ name: "Cmd_compound", pattern: /compound/, longer_alt: Identifier });
-var Cmd_install = createToken({ name: "Cmd_install", pattern: /install/, longer_alt: Identifier });
-var Cmd_unless = createToken({ name: "Cmd_unless", pattern: /unless/, longer_alt: Identifier });
-var Cmd_repeat = createToken({ name: "Cmd_repeat", pattern: /repeat/, longer_alt: Identifier });
-var Cmd_return = createToken({ name: "Cmd_return", pattern: /return/, longer_alt: Identifier });
-var Cmd_throw = createToken({ name: "Cmd_throw", pattern: /throw/, longer_alt: Identifier });
-var Cmd_break = createToken({ name: "Cmd_break", pattern: /break/, longer_alt: Identifier });
-var Cmd_halt = createToken({ name: "Cmd_halt", pattern: /halt/, longer_alt: Identifier });
-var Cmd_call = createToken({ name: "Cmd_call", pattern: /call/, longer_alt: Identifier });
-var Cmd_tell = createToken({ name: "Cmd_tell", pattern: /tell/, longer_alt: Identifier });
-var Cmd_init = createToken({ name: "Cmd_init", pattern: /init/, longer_alt: Identifier });
-var Cmd_exit = createToken({ name: "Cmd_exit", pattern: /exit/, longer_alt: Identifier });
-var Cmd_js = createToken({ name: "Cmd_js", pattern: /js/, longer_alt: Identifier });
-var Cmd_trigger = createToken({ name: "Cmd_trigger", pattern: /trigger/, longer_alt: Identifier });
-var Cmd_send = createToken({ name: "Cmd_send", pattern: /send/, longer_alt: Identifier });
-var Cmd_prepend = createToken({ name: "Cmd_prepend", pattern: /prepend/, longer_alt: Identifier });
-var Cmd_measure = createToken({ name: "Cmd_measure", pattern: /measure/, longer_alt: Identifier });
-var Cmd_append = createToken({ name: "Cmd_append", pattern: /append/, longer_alt: Identifier });
-var Cmd_render = createToken({ name: "Cmd_render", pattern: /render/, longer_alt: Identifier });
-var Cmd_clone = createToken({ name: "Cmd_clone", pattern: /clone/, longer_alt: Identifier });
-var Cmd_focus = createToken({ name: "Cmd_focus", pattern: /focus/, longer_alt: Identifier });
-var Cmd_morph = createToken({ name: "Cmd_morph", pattern: /morph/, longer_alt: Identifier });
-var Cmd_take = createToken({ name: "Cmd_take", pattern: /take/, longer_alt: Identifier });
-var Cmd_make = createToken({ name: "Cmd_make", pattern: /make/, longer_alt: Identifier });
-var Cmd_blur = createToken({ name: "Cmd_blur", pattern: /blur/, longer_alt: Identifier });
-var Cmd_swap = createToken({ name: "Cmd_swap", pattern: /swap/, longer_alt: Identifier });
-var Cmd_copy = createToken({ name: "Cmd_copy", pattern: /copy/, longer_alt: Identifier });
-var Cmd_put = createToken({ name: "Cmd_put", pattern: /put/, longer_alt: Identifier });
-var Cmd_toggle = createToken({ name: "Cmd_toggle", pattern: /toggle/, longer_alt: Identifier });
-var Cmd_remove = createToken({ name: "Cmd_remove", pattern: /remove/, longer_alt: Identifier });
-var Cmd_add = createToken({ name: "Cmd_add", pattern: /add/, longer_alt: Identifier });
-var Cmd_settle = createToken({ name: "Cmd_settle", pattern: /settle/, longer_alt: Identifier });
-var Cmd_fetch = createToken({ name: "Cmd_fetch", pattern: /fetch/, longer_alt: Identifier });
-var Cmd_async = createToken({ name: "Cmd_async", pattern: /async/, longer_alt: Identifier });
-var Cmd_wait = createToken({ name: "Cmd_wait", pattern: /wait/, longer_alt: Identifier });
-var Cmd_go = createToken({ name: "Cmd_go", pattern: /go/, longer_alt: Identifier });
-var Event_intersection = createToken({ name: "Event_intersection", pattern: /intersection/, longer_alt: Identifier });
-var Event_mouseenter = createToken({ name: "Event_mouseenter", pattern: /mouseenter/, longer_alt: Identifier });
-var Event_mouseleave = createToken({ name: "Event_mouseleave", pattern: /mouseleave/, longer_alt: Identifier });
-var Event_mousedown = createToken({ name: "Event_mousedown", pattern: /mousedown/, longer_alt: Identifier });
-var Event_mousemove = createToken({ name: "Event_mousemove", pattern: /mousemove/, longer_alt: Identifier });
-var Event_dblclick = createToken({ name: "Event_dblclick", pattern: /dblclick/, longer_alt: Identifier });
-var Event_keypress = createToken({ name: "Event_keypress", pattern: /keypress/, longer_alt: Identifier });
-var Event_mutation = createToken({ name: "Event_mutation", pattern: /mutation/, longer_alt: Identifier });
-var Event_mouseup = createToken({ name: "Event_mouseup", pattern: /mouseup/, longer_alt: Identifier });
-var Event_keydown = createToken({ name: "Event_keydown", pattern: /keydown/, longer_alt: Identifier });
-var Event_change = createToken({ name: "Event_change", pattern: /change/, longer_alt: Identifier });
-var Event_submit = createToken({ name: "Event_submit", pattern: /submit/, longer_alt: Identifier });
-var Event_scroll = createToken({ name: "Event_scroll", pattern: /scroll/, longer_alt: Identifier });
-var Event_resize = createToken({ name: "Event_resize", pattern: /resize/, longer_alt: Identifier });
-var Event_click = createToken({ name: "Event_click", pattern: /click/, longer_alt: Identifier });
-var Event_keyup = createToken({ name: "Event_keyup", pattern: /keyup/, longer_alt: Identifier });
-var Event_input = createToken({ name: "Event_input", pattern: /input/, longer_alt: Identifier });
-var Event_every = createToken({ name: "Event_every", pattern: /every/, longer_alt: Identifier });
-var Event_load = createToken({ name: "Event_load", pattern: /load/, longer_alt: Identifier });
-var allTokens = [
-  // Whitespace
-  WhiteSpace,
-  // Literals
-  StringLiteral,
-  NumberLiteral,
-  URLLiteral,
-  // Selectors
-  CSSSelector,
-  AttributeSelector,
-  HTMLSelector,
-  // Variables
-  LocalVariable,
-  GlobalVariable,
-  // Punctuation
-  LParen,
-  RParen,
-  Comma,
-  Dot,
-  // Event names
-  Event_intersection,
-  Event_mouseenter,
-  Event_mouseleave,
-  Event_mousedown,
-  Event_mousemove,
-  Event_dblclick,
-  Event_keypress,
-  Event_mutation,
-  Event_mouseup,
-  Event_keydown,
-  Event_change,
-  Event_submit,
-  Event_scroll,
-  Event_resize,
-  Event_click,
-  Event_keyup,
-  Event_input,
-  Event_every,
-  Event_load,
-  // Command keywords
-  Cmd_transition,
-  Cmd_increment,
-  Cmd_decrement,
-  Cmd_continue,
-  Cmd_behavior,
-  Cmd_compound,
-  Cmd_trigger,
-  Cmd_prepend,
-  Cmd_default,
-  Cmd_install,
-  Cmd_measure,
-  Cmd_toggle,
-  Cmd_remove,
-  Cmd_append,
-  Cmd_settle,
-  Cmd_unless,
-  Cmd_repeat,
-  Cmd_return,
-  Cmd_render,
-  Cmd_fetch,
-  Cmd_throw,
-  Cmd_clone,
-  Cmd_focus,
-  Cmd_async,
-  Cmd_morph,
-  Cmd_break,
-  Cmd_show,
-  Cmd_hide,
-  Cmd_wait,
-  Cmd_take,
-  Cmd_make,
-  Cmd_halt,
-  Cmd_send,
-  Cmd_blur,
-  Cmd_call,
-  Cmd_tell,
-  Cmd_init,
-  Cmd_swap,
-  Cmd_beep,
-  Cmd_copy,
-  Cmd_exit,
-  Cmd_pick,
-  Cmd_add,
-  Cmd_put,
-  Cmd_set,
-  Cmd_log,
-  Cmd_get,
-  Cmd_go,
-  Cmd_js,
-  // Structural keywords
-  Kw_previous,
-  Kw_closest,
-  Kw_while,
-  Kw_until,
-  Kw_times,
-  Kw_first,
-  Kw_false,
-  Kw_then,
-  Kw_else,
-  Kw_from,
-  Kw_into,
-  Kw_with,
-  Kw_have,
-  Kw_last,
-  Kw_next,
-  Kw_true,
-  Kw_null,
-  Kw_end,
-  Kw_for,
-  Kw_and,
-  Kw_not,
-  Kw_has,
-  Kw_you,
-  Kw_its,
-  Kw_the,
-  Kw_on,
-  Kw_if,
-  Kw_to,
-  Kw_in,
-  Kw_of,
-  Kw_as,
-  Kw_at,
-  Kw_by,
-  Kw_or,
-  Kw_is,
-  Kw_me,
-  Kw_it,
-  Kw_my,
-  Kw_no,
-  // Identifier (catch-all)
-  Identifier
-];
-var hyperscriptLexer = new Lexer(allTokens, {
-  positionTracking: "full",
-  ensureOptimizations: true
-});
-var COMMAND_SCHEMAS = [
-  { action: "toggle", category: "dom-class", roles: [{ role: "patient", required: true, expectedTypes: ["selector"] }, { role: "destination", required: false, expectedTypes: ["selector", "reference"] }], primaryRole: "patient" },
-  { action: "add", category: "dom-class", roles: [{ role: "patient", required: true, expectedTypes: ["selector"] }, { role: "destination", required: false, expectedTypes: ["selector", "reference"] }], primaryRole: "patient" },
-  { action: "remove", category: "dom-class", roles: [{ role: "patient", required: true, expectedTypes: ["selector"] }, { role: "source", required: false, expectedTypes: ["selector", "reference"] }], primaryRole: "patient" },
-  { action: "put", category: "dom-content", roles: [{ role: "patient", required: true, expectedTypes: ["literal", "selector", "reference", "expression"] }, { role: "destination", required: true, expectedTypes: ["selector", "reference"] }], primaryRole: "patient" },
-  { action: "set", category: "variable", roles: [{ role: "destination", required: true, expectedTypes: ["selector", "reference", "expression"] }, { role: "patient", required: true, expectedTypes: ["literal", "expression", "reference"] }], primaryRole: "destination" },
-  { action: "show", category: "dom-visibility", roles: [{ role: "patient", required: true, expectedTypes: ["selector", "reference"] }, { role: "style", required: false, expectedTypes: ["literal"] }], primaryRole: "patient" },
-  { action: "hide", category: "dom-visibility", roles: [{ role: "patient", required: true, expectedTypes: ["selector", "reference"] }, { role: "style", required: false, expectedTypes: ["literal"] }], primaryRole: "patient" },
-  { action: "on", category: "event", roles: [{ role: "event", required: true, expectedTypes: ["literal"] }, { role: "source", required: false, expectedTypes: ["selector", "reference"] }], primaryRole: "event" },
-  { action: "trigger", category: "event", roles: [{ role: "event", required: true, expectedTypes: ["literal", "expression"] }, { role: "destination", required: false, expectedTypes: ["selector", "reference"] }], primaryRole: "event" },
-  { action: "wait", category: "async", roles: [{ role: "patient", required: true, expectedTypes: ["literal", "expression"] }], primaryRole: "patient" },
-  { action: "fetch", category: "async", roles: [{ role: "source", required: true, expectedTypes: ["literal", "expression"] }, { role: "responseType", required: false, expectedTypes: ["literal", "expression"] }, { role: "method", required: false, expectedTypes: ["literal"] }, { role: "destination", required: false, expectedTypes: ["selector", "reference"] }], primaryRole: "source" },
-  { action: "increment", category: "variable", roles: [{ role: "patient", required: true, expectedTypes: ["selector", "reference", "expression"] }, { role: "quantity", required: false, expectedTypes: ["literal"] }], primaryRole: "patient" },
-  { action: "decrement", category: "variable", roles: [{ role: "patient", required: true, expectedTypes: ["selector", "reference", "expression"] }, { role: "quantity", required: false, expectedTypes: ["literal"] }], primaryRole: "patient" },
-  { action: "append", category: "dom-content", roles: [{ role: "patient", required: true, expectedTypes: ["literal", "selector", "expression"] }, { role: "destination", required: true, expectedTypes: ["selector", "reference"] }], primaryRole: "patient" },
-  { action: "prepend", category: "dom-content", roles: [{ role: "patient", required: true, expectedTypes: ["literal", "selector", "expression"] }, { role: "destination", required: true, expectedTypes: ["selector", "reference"] }], primaryRole: "patient" },
-  { action: "log", category: "variable", roles: [{ role: "patient", required: true, expectedTypes: ["literal", "selector", "reference", "expression"] }], primaryRole: "patient" },
-  { action: "get", category: "variable", roles: [{ role: "source", required: true, expectedTypes: ["selector", "reference", "expression"] }, { role: "destination", required: false, expectedTypes: ["reference"] }], primaryRole: "source" },
-  { action: "take", category: "dom-content", roles: [{ role: "patient", required: true, expectedTypes: ["selector"] }, { role: "source", required: false, expectedTypes: ["selector", "reference"] }], primaryRole: "patient" },
-  { action: "make", category: "dom-content", roles: [{ role: "patient", required: true, expectedTypes: ["literal", "selector"] }], primaryRole: "patient" },
-  { action: "halt", category: "control-flow", roles: [{ role: "patient", required: false, expectedTypes: ["literal", "reference", "expression"] }], primaryRole: "patient" },
-  { action: "settle", category: "async", roles: [{ role: "patient", required: false, expectedTypes: ["selector", "reference"] }], primaryRole: "patient" },
-  { action: "throw", category: "control-flow", roles: [{ role: "patient", required: true, expectedTypes: ["literal", "expression"] }], primaryRole: "patient" },
-  { action: "send", category: "event", roles: [{ role: "event", required: true, expectedTypes: ["literal", "expression"] }, { role: "destination", required: false, expectedTypes: ["selector", "reference"] }], primaryRole: "event" },
-  { action: "if", category: "control-flow", roles: [{ role: "condition", required: true, expectedTypes: ["expression"] }], primaryRole: "condition" },
-  { action: "unless", category: "control-flow", roles: [{ role: "condition", required: true, expectedTypes: ["expression"] }], primaryRole: "condition" },
-  { action: "else", category: "control-flow", roles: [], primaryRole: "patient" },
-  { action: "repeat", category: "control-flow", roles: [{ role: "loopType", required: true, expectedTypes: ["literal"] }, { role: "quantity", required: false, expectedTypes: ["literal", "expression"] }, { role: "event", required: false, expectedTypes: ["literal", "expression"] }, { role: "source", required: false, expectedTypes: ["selector", "reference"] }], primaryRole: "loopType" },
-  { action: "for", category: "control-flow", roles: [{ role: "patient", required: true, expectedTypes: ["reference"] }, { role: "source", required: true, expectedTypes: ["selector", "reference", "expression"] }], primaryRole: "patient" },
-  { action: "while", category: "control-flow", roles: [{ role: "condition", required: true, expectedTypes: ["expression"] }], primaryRole: "condition" },
-  { action: "continue", category: "control-flow", roles: [], primaryRole: "patient" },
-  { action: "go", category: "navigation", roles: [{ role: "destination", required: true, expectedTypes: ["literal", "expression"] }], primaryRole: "destination" },
-  { action: "transition", category: "dom-visibility", roles: [{ role: "patient", required: true, expectedTypes: ["literal"] }, { role: "goal", required: true, expectedTypes: ["literal", "expression"] }, { role: "destination", required: false, expectedTypes: ["selector", "reference"] }, { role: "duration", required: false, expectedTypes: ["literal"] }, { role: "style", required: false, expectedTypes: ["literal"] }], primaryRole: "patient" },
-  { action: "clone", category: "dom-content", roles: [{ role: "patient", required: true, expectedTypes: ["selector", "reference"] }, { role: "destination", required: false, expectedTypes: ["selector", "reference"] }], primaryRole: "patient" },
-  { action: "focus", category: "dom-content", roles: [{ role: "patient", required: false, expectedTypes: ["selector", "reference"] }], primaryRole: "patient" },
-  { action: "blur", category: "dom-content", roles: [{ role: "patient", required: false, expectedTypes: ["selector", "reference"] }], primaryRole: "patient" },
-  { action: "call", category: "control-flow", roles: [{ role: "patient", required: true, expectedTypes: ["expression", "reference"] }], primaryRole: "patient" },
-  { action: "return", category: "control-flow", roles: [{ role: "patient", required: false, expectedTypes: ["literal", "expression", "reference"] }], primaryRole: "patient" },
-  { action: "js", category: "control-flow", roles: [{ role: "patient", required: false, expectedTypes: ["expression"] }], primaryRole: "patient" },
-  { action: "async", category: "async", roles: [], primaryRole: "patient" },
-  { action: "tell", category: "control-flow", roles: [{ role: "destination", required: true, expectedTypes: ["selector", "reference"] }], primaryRole: "destination" },
-  { action: "default", category: "variable", roles: [{ role: "destination", required: true, expectedTypes: ["reference"] }, { role: "patient", required: true, expectedTypes: ["literal", "expression"] }], primaryRole: "destination" },
-  { action: "init", category: "control-flow", roles: [], primaryRole: "patient" },
-  { action: "behavior", category: "control-flow", roles: [{ role: "patient", required: true, expectedTypes: ["literal", "reference", "expression"] }], primaryRole: "patient" },
-  { action: "install", category: "control-flow", roles: [{ role: "patient", required: true, expectedTypes: ["literal", "reference", "expression"] }, { role: "destination", required: false, expectedTypes: ["selector", "reference"] }], primaryRole: "patient" },
-  { action: "measure", category: "dom-content", roles: [{ role: "patient", required: false, expectedTypes: ["literal", "expression"] }, { role: "source", required: false, expectedTypes: ["selector", "reference"] }], primaryRole: "patient" },
-  { action: "swap", category: "dom-content", roles: [{ role: "method", required: false, expectedTypes: ["literal"] }, { role: "destination", required: true, expectedTypes: ["selector", "reference"] }, { role: "patient", required: false, expectedTypes: ["literal", "expression", "selector"] }], primaryRole: "destination" },
-  { action: "morph", category: "dom-content", roles: [{ role: "destination", required: true, expectedTypes: ["selector", "reference"] }, { role: "patient", required: true, expectedTypes: ["literal", "expression", "selector"] }], primaryRole: "destination" },
-  { action: "beep", category: "variable", roles: [{ role: "patient", required: false, expectedTypes: ["literal", "selector", "reference", "expression"] }], primaryRole: "patient" },
-  { action: "break", category: "control-flow", roles: [], primaryRole: "patient" },
-  { action: "copy", category: "dom-content", roles: [{ role: "patient", required: true, expectedTypes: ["literal", "selector", "reference", "expression"] }], primaryRole: "patient" },
-  { action: "exit", category: "control-flow", roles: [], primaryRole: "patient" },
-  { action: "pick", category: "variable", roles: [{ role: "patient", required: true, expectedTypes: ["literal", "expression", "reference"] }, { role: "source", required: false, expectedTypes: ["reference", "expression"] }], primaryRole: "patient" },
-  { action: "render", category: "dom-content", roles: [{ role: "patient", required: true, expectedTypes: ["selector", "reference", "expression"] }, { role: "style", required: false, expectedTypes: ["expression", "reference"] }], primaryRole: "patient" },
-  { action: "compound", category: "control-flow", roles: [], primaryRole: "patient" }
-];
-
-// src/chevrotain-parser.ts
-var HyperscriptParser = class extends CstParser {
-  constructor() {
-    super(allTokens, {
-      recoveryEnabled: true,
-      maxLookahead: 3
-    });
-    this.performSelfAnalysis();
-  }
-  // -------------------------------------------------------------------------
-  // Top-level rules
-  // -------------------------------------------------------------------------
-  program = this.RULE("program", () => {
-    this.MANY(() => {
-      this.SUBRULE(this.statement);
-    });
-  });
-  statement = this.RULE("statement", () => {
-    this.OR([
-      { ALT: () => this.SUBRULE(this.eventHandler) },
-      { ALT: () => this.SUBRULE(this.commandChain) },
-      { ALT: () => this.SUBRULE(this.behaviorDef) }
-    ]);
-  });
-  // -------------------------------------------------------------------------
-  // Event handlers
-  // -------------------------------------------------------------------------
-  eventHandler = this.RULE("eventHandler", () => {
-    this.CONSUME(Kw_on);
-    this.SUBRULE(this.eventName);
-    this.OPTION(() => {
-      this.SUBRULE(this.eventModifiers);
-    });
-    this.OPTION2(() => {
-      this.SUBRULE(this.commandChain);
-    });
-    this.OPTION3(() => {
-      this.CONSUME(Kw_end);
-    });
-  });
-  eventName = this.RULE("eventName", () => {
-    this.OR([
-      { ALT: () => this.CONSUME(Event_click) },
-      { ALT: () => this.CONSUME(Event_dblclick) },
-      { ALT: () => this.CONSUME(Event_mousedown) },
-      { ALT: () => this.CONSUME(Event_mouseup) },
-      { ALT: () => this.CONSUME(Event_mousemove) },
-      { ALT: () => this.CONSUME(Event_mouseenter) },
-      { ALT: () => this.CONSUME(Event_mouseleave) },
-      { ALT: () => this.CONSUME(Event_keydown) },
-      { ALT: () => this.CONSUME(Event_keyup) },
-      { ALT: () => this.CONSUME(Event_input) },
-      { ALT: () => this.CONSUME(Event_change) },
-      { ALT: () => this.CONSUME(Event_submit) },
-      { ALT: () => this.CONSUME(Event_load) },
-      { ALT: () => this.CONSUME(Event_scroll) },
-      { ALT: () => this.CONSUME(Event_resize) },
-      { ALT: () => this.CONSUME(Event_mutation) },
-      { ALT: () => this.CONSUME(Event_intersection) },
-      { ALT: () => this.CONSUME(Event_every) },
-      { ALT: () => this.CONSUME(Identifier) }
-      // Custom event name
-    ]);
-  });
-  eventModifiers = this.RULE("eventModifiers", () => {
-    this.MANY(() => {
-      this.CONSUME(Dot);
-      this.CONSUME(Identifier);
-      this.OPTION(() => {
-        this.CONSUME(LParen);
-        this.SUBRULE(this.expression);
-        this.CONSUME(RParen);
-      });
-    });
-  });
-  // -------------------------------------------------------------------------
-  // Command chain (commands connected by 'then')
-  // -------------------------------------------------------------------------
-  commandChain = this.RULE("commandChain", () => {
-    this.SUBRULE(this.command);
-    this.MANY(() => {
-      this.CONSUME(Kw_then);
-      this.SUBRULE2(this.command);
-    });
-  });
-  // -------------------------------------------------------------------------
-  // Commands (grouped by category for error messages)
-  // -------------------------------------------------------------------------
-  command = this.RULE("command", () => {
-    this.OR([
-      // DOM class/attribute
-      { ALT: () => this.SUBRULE(this.toggleCommand) },
-      { ALT: () => this.SUBRULE(this.addCommand) },
-      { ALT: () => this.SUBRULE(this.removeCommand) },
-      // DOM content
-      { ALT: () => this.SUBRULE(this.putCommand) },
-      { ALT: () => this.SUBRULE(this.setCommand) },
-      { ALT: () => this.SUBRULE(this.appendCommand) },
-      { ALT: () => this.SUBRULE(this.prependCommand) },
-      // DOM visibility
-      { ALT: () => this.SUBRULE(this.showCommand) },
-      { ALT: () => this.SUBRULE(this.hideCommand) },
-      { ALT: () => this.SUBRULE(this.transitionCommand) },
-      // Variable
-      { ALT: () => this.SUBRULE(this.logCommand) },
-      { ALT: () => this.SUBRULE(this.incrementCommand) },
-      { ALT: () => this.SUBRULE(this.decrementCommand) },
-      // Async
-      { ALT: () => this.SUBRULE(this.fetchCommand) },
-      { ALT: () => this.SUBRULE(this.waitCommand) },
-      // Event
-      { ALT: () => this.SUBRULE(this.sendCommand) },
-      { ALT: () => this.SUBRULE(this.triggerCommand) },
-      // Navigation
-      { ALT: () => this.SUBRULE(this.goCommand) },
-      // Control flow
-      { ALT: () => this.SUBRULE(this.ifCommand) },
-      { ALT: () => this.SUBRULE(this.repeatCommand) },
-      // Execution
-      { ALT: () => this.SUBRULE(this.callCommand) },
-      { ALT: () => this.SUBRULE(this.jsCommand) },
-      { ALT: () => this.SUBRULE(this.returnCommand) },
-      { ALT: () => this.SUBRULE(this.throwCommand) },
-      { ALT: () => this.SUBRULE(this.haltCommand) }
-    ]);
-  });
-  // --- DOM class/attribute ---
-  toggleCommand = this.RULE("toggleCommand", () => {
-    this.CONSUME(Cmd_toggle);
-    this.SUBRULE(this.selectorOrExpression);
-    this.OPTION(() => {
-      this.CONSUME(Kw_on);
-      this.SUBRULE2(this.selectorOrExpression);
-    });
-  });
-  addCommand = this.RULE("addCommand", () => {
-    this.CONSUME(Cmd_add);
-    this.SUBRULE(this.selectorOrExpression);
-    this.OPTION(() => {
-      this.CONSUME(Kw_to);
-      this.SUBRULE2(this.selectorOrExpression);
-    });
-  });
-  removeCommand = this.RULE("removeCommand", () => {
-    this.CONSUME(Cmd_remove);
-    this.SUBRULE(this.selectorOrExpression);
-    this.OPTION(() => {
-      this.CONSUME(Kw_from);
-      this.SUBRULE2(this.selectorOrExpression);
-    });
-  });
-  // --- DOM content ---
-  putCommand = this.RULE("putCommand", () => {
-    this.CONSUME(Cmd_put);
-    this.SUBRULE(this.expression);
-    this.OPTION(() => {
-      this.OR([
-        { ALT: () => this.CONSUME(Kw_into) },
-        { ALT: () => this.CONSUME(Identifier, { LABEL: "putMarker" }) }
-        // before/after
-      ]);
-      this.SUBRULE2(this.selectorOrExpression);
-    });
-  });
-  setCommand = this.RULE("setCommand", () => {
-    this.CONSUME(Cmd_set);
-    this.SUBRULE(this.selectorOrExpression);
-    this.CONSUME(Kw_to);
-    this.SUBRULE2(this.expression);
-  });
-  appendCommand = this.RULE("appendCommand", () => {
-    this.CONSUME(Cmd_append);
-    this.SUBRULE(this.expression);
-    this.CONSUME(Kw_to);
-    this.SUBRULE2(this.selectorOrExpression);
-  });
-  prependCommand = this.RULE("prependCommand", () => {
-    this.CONSUME(Cmd_prepend);
-    this.SUBRULE(this.expression);
-    this.CONSUME(Kw_to);
-    this.SUBRULE2(this.selectorOrExpression);
-  });
-  // --- DOM visibility ---
-  showCommand = this.RULE("showCommand", () => {
-    this.CONSUME(Cmd_show);
-    this.OPTION(() => this.SUBRULE(this.selectorOrExpression));
-  });
-  hideCommand = this.RULE("hideCommand", () => {
-    this.CONSUME(Cmd_hide);
-    this.OPTION(() => this.SUBRULE(this.selectorOrExpression));
-  });
-  transitionCommand = this.RULE("transitionCommand", () => {
-    this.CONSUME(Cmd_transition);
-    this.SUBRULE(this.selectorOrExpression);
-  });
-  // --- Variable ---
-  logCommand = this.RULE("logCommand", () => {
-    this.CONSUME(Cmd_log);
-    this.SUBRULE(this.expression);
-  });
-  incrementCommand = this.RULE("incrementCommand", () => {
-    this.CONSUME(Cmd_increment);
-    this.SUBRULE(this.selectorOrExpression);
-    this.OPTION(() => {
-      this.CONSUME(Kw_by);
-      this.SUBRULE2(this.expression);
-    });
-  });
-  decrementCommand = this.RULE("decrementCommand", () => {
-    this.CONSUME(Cmd_decrement);
-    this.SUBRULE(this.selectorOrExpression);
-    this.OPTION(() => {
-      this.CONSUME(Kw_by);
-      this.SUBRULE2(this.expression);
-    });
-  });
-  // --- Async ---
-  fetchCommand = this.RULE("fetchCommand", () => {
-    this.CONSUME(Cmd_fetch);
-    this.SUBRULE(this.expression);
-    this.OPTION(() => {
-      this.CONSUME(Kw_as);
-      this.CONSUME(Identifier, { LABEL: "responseType" });
-    });
-  });
-  waitCommand = this.RULE("waitCommand", () => {
-    this.CONSUME(Cmd_wait);
-    this.OPTION(() => this.SUBRULE(this.expression));
-  });
-  // --- Event ---
-  sendCommand = this.RULE("sendCommand", () => {
-    this.CONSUME(Cmd_send);
-    this.CONSUME(Identifier, { LABEL: "eventName" });
-    this.OPTION(() => {
-      this.CONSUME(Kw_to);
-      this.SUBRULE(this.selectorOrExpression);
-    });
-  });
-  triggerCommand = this.RULE("triggerCommand", () => {
-    this.CONSUME(Cmd_trigger);
-    this.CONSUME(Identifier, { LABEL: "eventName" });
-    this.OPTION(() => {
-      this.CONSUME(Kw_on);
-      this.SUBRULE(this.selectorOrExpression);
-    });
-  });
-  // --- Navigation ---
-  goCommand = this.RULE("goCommand", () => {
-    this.CONSUME(Cmd_go);
-    this.OPTION(() => this.CONSUME(Kw_to));
-    this.SUBRULE(this.expression);
-  });
-  // --- Control flow ---
-  ifCommand = this.RULE("ifCommand", () => {
-    this.CONSUME(Kw_if);
-    this.SUBRULE(this.expression);
-    this.OPTION(() => this.SUBRULE(this.commandChain));
-    this.OPTION2(() => {
-      this.CONSUME(Kw_else);
-      this.OPTION3(() => this.SUBRULE2(this.commandChain));
-    });
-    this.OPTION4(() => this.CONSUME(Kw_end));
-  });
-  repeatCommand = this.RULE("repeatCommand", () => {
-    this.CONSUME(Cmd_repeat);
-    this.OR([
-      {
-        ALT: () => {
-          this.SUBRULE(this.expression);
-          this.CONSUME(Kw_times);
-        }
-      },
-      {
-        ALT: () => {
-          this.CONSUME(Kw_for);
-          this.CONSUME(Identifier, { LABEL: "loopVar" });
-          this.CONSUME(Kw_in);
-          this.SUBRULE2(this.expression);
-        }
-      },
-      {
-        ALT: () => {
-          this.CONSUME(Kw_while);
-          this.SUBRULE3(this.expression);
-        }
-      },
-      {
-        ALT: () => {
-          this.CONSUME(Kw_until);
-          this.SUBRULE4(this.expression);
+// src/simple-diagnostics.ts
+import { DiagnosticSeverity } from "vscode-languageserver/node.js";
+function isPossessive(code, i) {
+  if (i === 0) return false;
+  const prev = code[i - 1];
+  if (!/[\w\-#.]/.test(prev)) return false;
+  if (i + 1 >= code.length || code[i + 1] !== "s") return false;
+  if (i + 2 >= code.length) return true;
+  const after = code[i + 2];
+  return /[\s),.\]}|@*]/.test(after);
+}
+function runSimpleDiagnostics(code, _language = "en") {
+  const diagnostics = [];
+  let state = 0 /* NORMAL */;
+  let quoteStartLine = 0;
+  let quoteStartChar = 0;
+  let parenDepth = 0;
+  let bracketDepth = 0;
+  let line = 0;
+  let col = 0;
+  for (let i = 0; i < code.length; i++) {
+    const ch = code[i];
+    if (ch === "\n") {
+      line++;
+      col = 0;
+      continue;
+    }
+    if (state !== 0 /* NORMAL */) {
+      if (ch === "\\") {
+        i++;
+        col += 2;
+        continue;
+      }
+      if (state === 1 /* IN_SINGLE */ && ch === "'" || state === 2 /* IN_DOUBLE */ && ch === '"' || state === 3 /* IN_BACKTICK */ && ch === "`") {
+        state = 0 /* NORMAL */;
+      }
+      col++;
+      continue;
+    }
+    switch (ch) {
+      case "'":
+        if (isPossessive(code, i)) {
+          i++;
+          col += 2;
+          continue;
         }
+        state = 1 /* IN_SINGLE */;
+        quoteStartLine = line;
+        quoteStartChar = col;
+        break;
+      case '"':
+        state = 2 /* IN_DOUBLE */;
+        quoteStartLine = line;
+        quoteStartChar = col;
+        break;
+      case "`":
+        state = 3 /* IN_BACKTICK */;
+        quoteStartLine = line;
+        quoteStartChar = col;
+        break;
+      case "(":
+        parenDepth++;
+        break;
+      case ")":
+        parenDepth--;
+        break;
+      case "[":
+        bracketDepth++;
+        break;
+      case "]":
+        bracketDepth--;
+        break;
+    }
+    col++;
+  }
+  if (state !== 0 /* NORMAL */) {
+    const quoteType = state === 1 /* IN_SINGLE */ ? "single" : state === 2 /* IN_DOUBLE */ ? "double" : "backtick";
+    diagnostics.push({
+      range: {
+        start: { line: quoteStartLine, character: quoteStartChar },
+        end: { line: quoteStartLine, character: quoteStartChar + 1 }
       },
-      {
-        ALT: () => {
-        }
-      }
-    ]);
-    this.OPTION(() => this.SUBRULE(this.commandChain));
-    this.OPTION2(() => this.CONSUME(Kw_end));
-  });
-  // --- Execution ---
-  callCommand = this.RULE("callCommand", () => {
-    this.CONSUME(Cmd_call);
-    this.SUBRULE(this.expression);
-  });
-  jsCommand = this.RULE("jsCommand", () => {
-    this.CONSUME(Cmd_js);
-    this.MANY(() => {
-      this.OR([
-        { ALT: () => this.CONSUME(Identifier) },
-        { ALT: () => this.CONSUME(StringLiteral) },
-        { ALT: () => this.CONSUME(NumberLiteral) },
-        { ALT: () => this.CONSUME(CSSSelector) },
-        { ALT: () => this.CONSUME(LocalVariable) },
-        { ALT: () => this.CONSUME(LParen) },
-        { ALT: () => this.CONSUME(RParen) },
-        { ALT: () => this.CONSUME(Comma) },
-        { ALT: () => this.CONSUME(Dot) }
-      ]);
-    });
-    this.CONSUME(Kw_end);
-  });
-  returnCommand = this.RULE("returnCommand", () => {
-    this.CONSUME(Cmd_return);
-    this.OPTION(() => this.SUBRULE(this.expression));
-  });
-  throwCommand = this.RULE("throwCommand", () => {
-    this.CONSUME(Cmd_throw);
-    this.SUBRULE(this.expression);
-  });
-  haltCommand = this.RULE("haltCommand", () => {
-    this.CONSUME(Cmd_halt);
-  });
-  // -------------------------------------------------------------------------
-  // Behavior definitions
-  // -------------------------------------------------------------------------
-  behaviorDef = this.RULE("behaviorDef", () => {
-    this.CONSUME(Cmd_behavior);
-    this.CONSUME(Identifier, { LABEL: "behaviorName" });
-    this.OPTION(() => {
-      this.CONSUME(LParen);
-      this.AT_LEAST_ONE_SEP({
-        SEP: Comma,
-        DEF: () => this.CONSUME2(Identifier, { LABEL: "param" })
-      });
-      this.CONSUME(RParen);
+      severity: DiagnosticSeverity.Error,
+      code: "unmatched-quote",
+      source: "lokascript",
+      message: `Unmatched ${quoteType} quote`
     });
-    this.MANY(() => this.SUBRULE(this.statement));
-    this.CONSUME(Kw_end);
-  });
-  // -------------------------------------------------------------------------
-  // Expressions (simplified for LSP — full expression parsing is in core)
-  // -------------------------------------------------------------------------
-  expression = this.RULE("expression", () => {
-    this.SUBRULE(this.primaryExpression);
-    this.MANY(() => {
-      this.OR([
-        {
-          ALT: () => {
-            this.OR2([
-              { ALT: () => this.CONSUME(Kw_is) },
-              { ALT: () => this.CONSUME(Kw_and) },
-              { ALT: () => this.CONSUME(Kw_or) }
-            ]);
-            this.SUBRULE2(this.primaryExpression);
-          }
-        },
-        {
-          ALT: () => {
-            this.CONSUME(Dot);
-            this.CONSUME(Identifier);
-          }
-        }
-      ]);
+  }
+  if (parenDepth !== 0) {
+    diagnostics.push({
+      range: { start: { line: 0, character: 0 }, end: { line: 0, character: 1 } },
+      severity: DiagnosticSeverity.Error,
+      code: "unbalanced-parens",
+      source: "lokascript",
+      message: `Unbalanced parentheses`
     });
-  });
-  primaryExpression = this.RULE("primaryExpression", () => {
-    this.OPTION(() => {
-      this.OR([
-        { ALT: () => this.CONSUME(Kw_not) },
-        { ALT: () => this.CONSUME(Kw_the) },
-        { ALT: () => this.CONSUME(Kw_no) }
-      ]);
+  }
+  if (bracketDepth !== 0) {
+    diagnostics.push({
+      range: { start: { line: 0, character: 0 }, end: { line: 0, character: 1 } },
+      severity: DiagnosticSeverity.Error,
+      code: "unbalanced-brackets",
+      source: "lokascript",
+      message: `Unbalanced brackets`
     });
-    this.OR2([
-      { ALT: () => this.CONSUME(StringLiteral) },
-      { ALT: () => this.CONSUME(NumberLiteral) },
-      { ALT: () => this.CONSUME(CSSSelector) },
-      { ALT: () => this.CONSUME(AttributeSelector) },
-      { ALT: () => this.CONSUME(HTMLSelector) },
-      { ALT: () => this.CONSUME(LocalVariable) },
-      { ALT: () => this.CONSUME(GlobalVariable) },
-      { ALT: () => this.CONSUME(Kw_me) },
-      { ALT: () => this.CONSUME(Kw_it) },
-      { ALT: () => this.CONSUME(Kw_true) },
-      { ALT: () => this.CONSUME(Kw_false) },
-      { ALT: () => this.CONSUME(Identifier) },
-      {
-        ALT: () => {
-          this.CONSUME(LParen);
-          this.SUBRULE(this.expression);
-          this.CONSUME(RParen);
-        }
-      }
-    ]);
-  });
-  // -------------------------------------------------------------------------
-  // Selectors or expressions
-  // -------------------------------------------------------------------------
-  selectorOrExpression = this.RULE("selectorOrExpression", () => {
-    this.OR([
-      { ALT: () => this.CONSUME(CSSSelector) },
-      { ALT: () => this.CONSUME(AttributeSelector) },
-      { ALT: () => this.CONSUME(HTMLSelector) },
-      { ALT: () => this.CONSUME(Kw_me) },
-      { ALT: () => this.CONSUME(Kw_it) },
-      { ALT: () => this.CONSUME(LocalVariable) },
-      { ALT: () => this.CONSUME(GlobalVariable) },
-      { ALT: () => this.CONSUME(Identifier) }
-    ]);
-  });
-};
-var parserInstance = new HyperscriptParser();
-function parseWithRecovery(code) {
-  const lexResult = hyperscriptLexer.tokenize(code);
-  const diagnostics = lexResult.errors.map((err) => ({
-    message: err.message,
-    severity: "error",
-    startOffset: err.offset,
-    endOffset: err.offset + (err.length || 1),
-    startLine: err.line ?? 1,
-    startColumn: err.column ?? 1,
-    code: "lex-error"
-  }));
-  const nonWS = lexResult.tokens.filter((t) => t.tokenType !== WhiteSpace);
-  parserInstance.input = nonWS;
-  const cst = parserInstance.program();
-  for (const err of parserInstance.errors) {
-    diagnostics.push(recognitionExceptionToDiagnostic(err));
   }
-  return {
-    cst,
-    diagnostics,
-    tokens: lexResult.tokens
-  };
+  return diagnostics;
 }
-function getContentAssist(code, offset) {
-  const lexResult = hyperscriptLexer.tokenize(code);
-  const nonWS = lexResult.tokens.filter((t) => t.tokenType !== WhiteSpace);
-  const suggestions = [];
-  const tokenBefore = findTokenBefore(nonWS, offset);
-  const context = inferContextFromTokens(nonWS, tokenBefore);
-  switch (context) {
-    case "start":
-    case "after-then":
-      suggestions.push(...getCommandSuggestions());
-      suggestions.push({
-        label: "on",
-        kind: "keyword",
-        detail: "Event handler",
-        insertText: "on "
-      });
-      break;
-    case "after-on":
-      suggestions.push(...getEventSuggestions());
-      break;
-    case "after-command":
-      if (tokenBefore) {
-        suggestions.push(...getRoleMarkerSuggestions(tokenBefore));
+var DIRECTIVE_IF = /^#if\b/;
+var DIRECTIVE_FOR = /^#for\b/;
+var DIRECTIVE_ELSE = /^#else\s*$/;
+var DIRECTIVE_END = /^#end\s*$/;
+var DIRECTIVE_CONTINUE = /^#continue\s*$/;
+var DIRECTIVE_FOR_FORM = /^#for\s+([A-Za-z_$][\w$]*)\s+in\s+.+$/;
+function runDirectiveDiagnostics(code) {
+  const diagnostics = [];
+  const lines = code.split("\n");
+  const stack = [];
+  for (let i = 0; i < lines.length; i++) {
+    const raw = lines[i];
+    const trimmed = raw.trim();
+    if (!trimmed.startsWith("#")) continue;
+    const indent = raw.indexOf(trimmed.charAt(0));
+    const range = {
+      start: { line: i, character: Math.max(0, indent) },
+      end: { line: i, character: raw.length }
+    };
+    if (DIRECTIVE_IF.test(trimmed)) {
+      stack.push({ kind: "if", line: i, hasElse: false });
+    } else if (DIRECTIVE_FOR.test(trimmed)) {
+      if (!DIRECTIVE_FOR_FORM.test(trimmed)) {
+        diagnostics.push({
+          range,
+          severity: DiagnosticSeverity.Error,
+          code: "directive-malformed-for",
+          source: "lokascript",
+          message: "#for must be `#for <name> in <expr>`"
+        });
       }
-      break;
-    case "after-marker":
-      suggestions.push(...getSelectorSuggestions());
-      break;
-    default:
-      suggestions.push(...getCommandSuggestions());
-      suggestions.push(...getSelectorSuggestions());
-      break;
+      stack.push({ kind: "for", line: i, hasElse: false });
+    } else if (DIRECTIVE_ELSE.test(trimmed)) {
+      const top = stack[stack.length - 1];
+      if (!top) {
+        diagnostics.push({
+          range,
+          severity: DiagnosticSeverity.Error,
+          code: "directive-stray-else",
+          source: "lokascript",
+          message: "#else outside of #if or #for block"
+        });
+      } else if (top.hasElse) {
+        diagnostics.push({
+          range,
+          severity: DiagnosticSeverity.Error,
+          code: "directive-duplicate-else",
+          source: "lokascript",
+          message: "duplicate #else in this block"
+        });
+      } else {
+        top.hasElse = true;
+      }
+    } else if (DIRECTIVE_END.test(trimmed)) {
+      if (stack.length === 0) {
+        diagnostics.push({
+          range,
+          severity: DiagnosticSeverity.Error,
+          code: "directive-stray-end",
+          source: "lokascript",
+          message: "#end without matching #if or #for"
+        });
+      } else {
+        stack.pop();
+      }
+    } else if (DIRECTIVE_CONTINUE.test(trimmed)) {
+      const inFor = stack.some((b) => b.kind === "for");
+      if (!inFor) {
+        diagnostics.push({
+          range,
+          severity: DiagnosticSeverity.Error,
+          code: "directive-stray-continue",
+          source: "lokascript",
+          message: "#continue outside of #for block"
+        });
+      }
+    }
   }
-  return suggestions;
-}
-function recognitionExceptionToDiagnostic(err) {
-  const token = err.token;
-  const startOffset = token.startOffset ?? 0;
-  const endOffset = token.endOffset ?? startOffset + 1;
-  let message = err.message;
-  const match = message.match(/Expecting (.*?) but found/);
-  if (match) {
-    const expected = match[1].replace(/token of type --> /g, "").replace(/ <--/g, "").replace(/one of these possible Token Types:\s*/g, "").replace(/\[.*?\]/g, (m) => {
-      const names = m.slice(1, -1).split(",").map((n) => n.trim());
-      return names.slice(0, 5).join(", ") + (names.length > 5 ? "..." : "");
+  for (const open of stack) {
+    diagnostics.push({
+      range: {
+        start: { line: open.line, character: 0 },
+        end: { line: open.line, character: lines[open.line]?.length ?? 0 }
+      },
+      severity: DiagnosticSeverity.Error,
+      code: "directive-unclosed",
+      source: "lokascript",
+      message: `Unclosed #${open.kind} \u2014 missing #end`
     });
-    message = `Expected ${expected}`;
-    if (token.image) {
-      message += ` but found '${token.image}'`;
-    }
   }
-  return {
-    message,
-    severity: "error",
-    startOffset,
-    endOffset,
-    startLine: token.startLine ?? 1,
-    startColumn: token.startColumn ?? 1,
-    code: "parse-error"
-  };
+  return diagnostics;
 }
-function findTokenBefore(tokens, offset) {
-  let best = null;
-  for (const t of tokens) {
-    if (t.startOffset <= offset) {
-      best = t;
+
+// src/symbol-table.ts
+function buildSymbolTable(regions, getKeywordVariants2) {
+  const symbols = /* @__PURE__ */ new Map();
+  const locationIndex = [];
+  const variants = (eng) => getKeywordVariants2 ? getKeywordVariants2(eng) : [eng];
+  const behaviorKws = variants("behavior");
+  const defKws = variants("def");
+  const setKws = variants("set");
+  const defaultKws = variants("default");
+  const installKws = variants("install");
+  const callKws = variants("call");
+  const behaviorDefPat = new RegExp(`\\b(${behaviorKws.join("|")})\\s+(\\w+)`, "gi");
+  const funcDefPat = new RegExp(`\\b(${defKws.join("|")})\\s+(\\w+)`, "gi");
+  const varDefPat = new RegExp(`\\b(${[...setKws, ...defaultKws].join("|")})\\s+([:$]\\w+)`, "gi");
+  const installPat = new RegExp(`\\b(${installKws.join("|")})\\s+(\\w+)`, "gi");
+  const callPat = new RegExp(`\\b(${callKws.join("|")})\\s+(\\w+)`, "gi");
+  const varRefPat = /[:$]\w+/g;
+  const funcCallPat = /\b(\w+)\s*\(/g;
+  const caretWritePat = new RegExp(`\\b(${setKws.join("|")})\\s+\\^([A-Za-z_]\\w*)`, "gi");
+  const caretRefPat = /\^([A-Za-z_]\w*)/g;
+  const attrsRefPat = /\battrs\.([A-Za-z_]\w*)/g;
+  function getOrCreate(name, kind, scope) {
+    let entry = symbols.get(name);
+    if (!entry) {
+      entry = { name, kind, scope, definitions: [], usages: [] };
+      symbols.set(name, entry);
+    }
+    return entry;
+  }
+  function toDocLine(region, localLine) {
+    return region.startLine + localLine;
+  }
+  function toDocChar(region, localLine, localChar) {
+    return localLine === 0 ? region.startChar + localChar : localChar;
+  }
+  function addLocation(entry, kind, region, localLine, localChar, length) {
+    const loc = {
+      line: toDocLine(region, localLine),
+      character: toDocChar(region, localLine, localChar),
+      length
+    };
+    if (kind === "def") {
+      entry.definitions.push(loc);
     } else {
-      break;
+      entry.usages.push(loc);
     }
+    locationIndex.push({
+      line: loc.line,
+      start: loc.character,
+      end: loc.character + length,
+      name: entry.name
+    });
   }
-  return best;
-}
-function inferContextFromTokens(tokens, tokenBefore) {
-  if (!tokenBefore || tokens.length === 0) return "start";
-  const type = tokenBefore.tokenType;
-  if (type === Kw_on) return "after-on";
-  if (type === Kw_then) return "after-then";
-  if (type.name.startsWith("Cmd_")) return "after-command";
-  const markers = [Kw_to, Kw_from, Kw_into, Kw_in, Kw_of, Kw_on, Kw_as, Kw_with];
-  if (markers.includes(type)) return "after-marker";
-  return "general";
-}
-function getCommandSuggestions() {
-  return COMMAND_SCHEMAS.map((schema) => ({
-    label: schema.action,
-    kind: "command",
-    detail: getCategoryLabel(schema.category),
-    insertText: schema.action + " ",
-    category: schema.category
-  }));
-}
-function getEventSuggestions() {
-  const events = [
-    "click",
-    "dblclick",
-    "mousedown",
-    "mouseup",
-    "mousemove",
-    "mouseenter",
-    "mouseleave",
-    "keydown",
-    "keyup",
-    "keypress",
-    "input",
-    "change",
-    "submit",
-    "focus",
-    "blur",
-    "load",
-    "scroll",
-    "resize",
-    "mutation",
-    "intersection",
-    "every"
-  ];
-  return events.map((e) => ({
-    label: e,
-    kind: "event",
-    detail: `${e} event`,
-    insertText: e + " "
-  }));
-}
-function getRoleMarkerSuggestions(commandToken) {
-  const cmdName = commandToken.tokenType.name.replace("Cmd_", "");
-  const schema = COMMAND_SCHEMAS.find((s) => s.action === cmdName);
-  if (!schema) return [];
-  const suggestions = [];
-  for (const role of schema.roles) {
-    if (role.role === schema.primaryRole) continue;
-    const markers = getRoleMarkers(role.role);
-    for (const marker of markers) {
-      suggestions.push({
-        label: marker,
-        kind: "keyword",
-        detail: `${role.role} marker`,
-        insertText: marker + " "
-      });
+  function findLocalLine(code, offset) {
+    let line = 0;
+    for (let i = 0; i < offset && i < code.length; i++) {
+      if (code[i] === "\n") line++;
     }
+    return line;
   }
-  return suggestions;
-}
-function getSelectorSuggestions() {
-  return [
-    { label: "me", kind: "keyword", detail: "Current element" },
-    { label: "it", kind: "keyword", detail: "Last result" },
-    { label: ".", kind: "selector", detail: "CSS class selector", insertText: "." },
-    { label: "#", kind: "selector", detail: "CSS ID selector", insertText: "#" },
-    { label: "@", kind: "selector", detail: "Attribute selector", insertText: "@" },
-    { label: ":", kind: "variable", detail: "Local variable", insertText: ":" },
-    { label: "$", kind: "variable", detail: "Global variable", insertText: "$" }
-  ];
-}
-function getRoleMarkers(role) {
-  switch (role) {
-    case "destination":
-      return ["to", "into"];
-    case "source":
-      return ["from"];
-    case "target":
-      return ["on"];
-    case "container":
-      return ["in"];
-    case "instrument":
-      return ["with"];
-    case "beneficiary":
-      return ["for"];
-    default:
-      return [];
+  function findLocalChar(code, offset) {
+    let lastNewline = -1;
+    for (let i = 0; i < offset && i < code.length; i++) {
+      if (code[i] === "\n") lastNewline = i;
+    }
+    return offset - lastNewline - 1;
   }
-}
-function getCategoryLabel(category) {
-  const labels = {
-    "dom-class": "DOM Class/Attribute",
-    "dom-content": "DOM Content",
-    "dom-visibility": "DOM Visibility",
-    variable: "Variable",
-    event: "Event",
-    async: "Async",
-    navigation: "Navigation",
-    "control-flow": "Control Flow"
+  const defVarOffsets = /* @__PURE__ */ new Map();
+  const caretDefOffsets = /* @__PURE__ */ new Map();
+  for (const region of regions) {
+    const code = region.code;
+    const regionDefOffsets = /* @__PURE__ */ new Set();
+    defVarOffsets.set(region, regionDefOffsets);
+    const regionCaretDefOffsets = /* @__PURE__ */ new Set();
+    caretDefOffsets.set(region, regionCaretDefOffsets);
+    for (const m of code.matchAll(behaviorDefPat)) {
+      const name = m[2];
+      const nameOffset = (m.index ?? 0) + m[0].indexOf(name);
+      const localLine = findLocalLine(code, nameOffset);
+      const localChar = findLocalChar(code, nameOffset);
+      addLocation(
+        getOrCreate(name, "behavior", "global"),
+        "def",
+        region,
+        localLine,
+        localChar,
+        name.length
+      );
+    }
+    for (const m of code.matchAll(funcDefPat)) {
+      const name = m[2];
+      const nameOffset = (m.index ?? 0) + m[0].indexOf(name);
+      const localLine = findLocalLine(code, nameOffset);
+      const localChar = findLocalChar(code, nameOffset);
+      addLocation(
+        getOrCreate(name, "function", "global"),
+        "def",
+        region,
+        localLine,
+        localChar,
+        name.length
+      );
+    }
+    for (const m of code.matchAll(varDefPat)) {
+      const varName = m[2];
+      const varOffset = (m.index ?? 0) + m[0].indexOf(varName);
+      const localLine = findLocalLine(code, varOffset);
+      const localChar = findLocalChar(code, varOffset);
+      const scope = varName.startsWith("$") ? "global" : "local";
+      addLocation(
+        getOrCreate(varName, "variable", scope),
+        "def",
+        region,
+        localLine,
+        localChar,
+        varName.length
+      );
+      regionDefOffsets.add(varOffset);
+    }
+    for (const m of code.matchAll(installPat)) {
+      const name = m[2];
+      const nameOffset = (m.index ?? 0) + m[0].indexOf(name);
+      const localLine = findLocalLine(code, nameOffset);
+      const localChar = findLocalChar(code, nameOffset);
+      const entry = getOrCreate(name, "behavior", "global");
+      addLocation(entry, "use", region, localLine, localChar, name.length);
+    }
+    for (const m of code.matchAll(callPat)) {
+      const name = m[2];
+      const nameOffset = (m.index ?? 0) + m[0].indexOf(name);
+      const localLine = findLocalLine(code, nameOffset);
+      const localChar = findLocalChar(code, nameOffset);
+      const entry = getOrCreate(name, "function", "global");
+      addLocation(entry, "use", region, localLine, localChar, name.length);
+    }
+    for (const m of code.matchAll(varRefPat)) {
+      const varName = m[0];
+      const varOffset = m.index ?? 0;
+      if (regionDefOffsets.has(varOffset)) continue;
+      const localLine = findLocalLine(code, varOffset);
+      const localChar = findLocalChar(code, varOffset);
+      const scope = varName.startsWith("$") ? "global" : "local";
+      const entry = getOrCreate(varName, "variable", scope);
+      addLocation(entry, "use", region, localLine, localChar, varName.length);
+    }
+    for (const m of code.matchAll(caretWritePat)) {
+      const name = m[2];
+      const caretOffset = (m.index ?? 0) + m[0].lastIndexOf("^");
+      const localLine = findLocalLine(code, caretOffset);
+      const localChar = findLocalChar(code, caretOffset);
+      const symbolName = `^${name}`;
+      addLocation(
+        getOrCreate(symbolName, "caretVar", "caret"),
+        "def",
+        region,
+        localLine,
+        localChar,
+        symbolName.length
+      );
+      regionCaretDefOffsets.add(caretOffset);
+    }
+    for (const m of code.matchAll(caretRefPat)) {
+      const caretOffset = m.index ?? 0;
+      if (regionCaretDefOffsets.has(caretOffset)) continue;
+      const name = m[1];
+      const localLine = findLocalLine(code, caretOffset);
+      const localChar = findLocalChar(code, caretOffset);
+      const symbolName = `^${name}`;
+      addLocation(
+        getOrCreate(symbolName, "caretVar", "caret"),
+        "use",
+        region,
+        localLine,
+        localChar,
+        symbolName.length
+      );
+    }
+    for (const m of code.matchAll(attrsRefPat)) {
+      const name = m[1];
+      const attrsStart = m.index ?? 0;
+      const localLine = findLocalLine(code, attrsStart);
+      const localChar = findLocalChar(code, attrsStart);
+      const fullLength = m[0].length;
+      addLocation(
+        getOrCreate(`attrs.${name}`, "componentAttr", "attr"),
+        "use",
+        region,
+        localLine,
+        localChar,
+        fullLength
+      );
+    }
+    const keywords = /* @__PURE__ */ new Set([
+      "if",
+      "else",
+      "end",
+      "on",
+      "then",
+      "repeat",
+      "for",
+      "while",
+      "return",
+      "set",
+      "get",
+      "put",
+      "add",
+      "remove",
+      "toggle",
+      "show",
+      "hide",
+      "fetch",
+      "send",
+      "trigger",
+      "wait",
+      "log",
+      "call",
+      "default",
+      "behavior",
+      "def",
+      "install",
+      "init",
+      "async",
+      ...behaviorKws,
+      ...defKws,
+      ...setKws,
+      ...installKws,
+      ...callKws
+    ]);
+    for (const m of code.matchAll(funcCallPat)) {
+      const name = m[1];
+      if (keywords.has(name.toLowerCase())) continue;
+      const nameOffset = m.index ?? 0;
+      const localLine = findLocalLine(code, nameOffset);
+      const localChar = findLocalChar(code, nameOffset);
+      const entry = getOrCreate(name, "function", "global");
+      addLocation(entry, "use", region, localLine, localChar, name.length);
+    }
+  }
+  return {
+    symbols,
+    symbolAt(line, character) {
+      for (const loc of locationIndex) {
+        if (loc.line === line && character >= loc.start && character < loc.end) {
+          return symbols.get(loc.name);
+        }
+      }
+      return void 0;
+    }
   };
-  return labels[category] || category;
+}
+var cache = /* @__PURE__ */ new Map();
+function getSymbolTable(uri, version, regions, getKeywordVariants2) {
+  const cached = cache.get(uri);
+  if (cached && cached.version === version) {
+    return cached.table;
+  }
+  const table = buildSymbolTable(regions, getKeywordVariants2);
+  cache.set(uri, { version, table });
+  return table;
 }
 
 // src/localized-descriptions.ts
@@ -1326,7 +858,41 @@ var DESCRIPTIONS = {
       documentation: "Waits for CSS transitions/animations to complete."
     },
     go: { detail: "Navigate", documentation: "Navigates to a URL or page location." },
-    throw: { detail: "Throw error", documentation: "Throws an error with a specified message." }
+    throw: { detail: "Throw error", documentation: "Throws an error with a specified message." },
+    // v2 / v2.1 component + reactive (English only — localized translations
+    // can be added as language coverage rolls out).
+    "^": {
+      detail: "Reactive variable (^var)",
+      documentation: 'Reads or writes a DOM-scoped reactive variable. `^name` walks ancestors until it finds an owner, or stops at the nearest `dom-scope="isolated"` boundary.'
+    },
+    attrs: {
+      detail: "Component attributes",
+      documentation: 'Proxy over the component element\'s HTML attributes. `attrs.fooBar` reads `foo-bar="..."`, with number/boolean coercion. Available inside `<template _="...">` init scripts and `${...}` interpolation.'
+    },
+    "dom-scope": {
+      detail: "Reactive scope boundary",
+      documentation: '`dom-scope="isolated"` on a host element bounds `^var` lookup. Set automatically on `<template component>` instances; set manually for ad-hoc isolation.'
+    },
+    "#if": {
+      detail: "Conditional template block",
+      documentation: "Line-oriented template directive. Renders the contained block when the condition is truthy. Optional `#else` branch; closes with `#end`."
+    },
+    "#else": {
+      detail: "Alternative branch",
+      documentation: "Else branch of a `#if`, or empty-collection fallback for a `#for`."
+    },
+    "#end": {
+      detail: "Close directive block",
+      documentation: "Closes the most recent `#if` or `#for`. Must occupy its own line."
+    },
+    "#for": {
+      detail: "Iteration template block",
+      documentation: "`#for <name> in <expr>` iterates over `<expr>` with `<name>` bound to each element. Optional `#else` branch fires when the collection is empty."
+    },
+    "#continue": {
+      detail: "Skip iteration",
+      documentation: "Skip to the next iteration of the enclosing `#for`. Available v2.1+."
+    }
   },
   ja: {
     toggle: {
@@ -1571,7 +1137,7 @@ try {
 }
 var frameworkIR = null;
 try {
-  const fw = await import("./dist-V7SKUZF5.js");
+  const fw = await import("./dist-NRPF26M4.js");
   frameworkIR = { fromInterchangeNode: fw.fromInterchangeNode, renderExplicit: fw.renderExplicit };
   console.error(
     "[lokascript-ls] @lokascript/framework loaded \u2014 LSE bracket notation in hover enabled"
@@ -1724,6 +1290,91 @@ var FALLBACK_HOVER_DOCS = {
     title: "result",
     description: "Alias for it - the result of the last expression.",
     example: "call myFunction() then log result"
+  },
+  increment: {
+    title: "increment",
+    description: "Increases a numeric value by 1 (or a specified amount).",
+    example: "increment #count"
+  },
+  decrement: {
+    title: "decrement",
+    description: "Decreases a numeric value by 1 (or a specified amount).",
+    example: "decrement #count"
+  },
+  append: {
+    title: "append",
+    description: "Appends content to an element.",
+    example: 'append "<li>item</li>" to #list'
+  },
+  prepend: {
+    title: "prepend",
+    description: "Prepends content to an element.",
+    example: 'prepend "<li>first</li>" to #list'
+  },
+  take: {
+    title: "take",
+    description: "Takes a class from sibling elements (exclusive toggle).",
+    example: "take .active from .tabs"
+  },
+  transition: {
+    title: "transition",
+    description: "Applies a CSS transition to an element.",
+    example: "transition opacity to 0 over 500ms"
+  },
+  settle: {
+    title: "settle",
+    description: "Waits for CSS transitions to complete.",
+    example: "add .fade then settle"
+  },
+  halt: {
+    title: "halt",
+    description: "Stops the current event from propagating.",
+    example: "halt the event"
+  },
+  throw: {
+    title: "throw",
+    description: "Throws an error.",
+    example: 'throw "Something went wrong"'
+  },
+  return: {
+    title: "return",
+    description: "Returns a value from a function or behavior.",
+    example: "return 42"
+  },
+  install: {
+    title: "install",
+    description: "Installs a behavior on an element.",
+    example: "install Draggable(snap: true)"
+  },
+  default: {
+    title: "default",
+    description: "Sets a variable to a value only if it is not already set.",
+    example: "default :count to 0"
+  },
+  then: {
+    title: "then",
+    description: "Chains commands together sequentially.",
+    example: "add .active then wait 1s then remove .active"
+  },
+  end: {
+    title: "end",
+    description: "Closes a block (event handler, behavior, if, repeat).",
+    example: "on click\\n  toggle .active\\nend"
+  },
+  async: {
+    title: "async",
+    description: "Runs a command asynchronously without blocking.",
+    example: "async fetch /api/data"
+  },
+  tell: {
+    title: "tell",
+    description: "Sets the default target for subsequent commands.",
+    example: "tell #modal then add .visible"
+  },
+  copy: {
+    title: "copy",
+    description: "Copies text to the clipboard.",
+    example: 'copy "Hello" to the clipboard'
   }
 };
 var FALLBACK_EVENT_NAMES = [
@@ -1744,7 +1395,7 @@ function resolveMode(settings) {
   if (settings.mode === "hyperscript") return "hyperscript";
   if (settings.mode === "hyperscript-i18n") return "hyperscript-i18n";
   if (settings.mode === "lokascript") return "lokascript";
-  return semanticPackage ? "lokascript" : "hyperscript";
+  return semanticPackage?.getRegisteredLanguages ? "lokascript" : "hyperscript";
 }
 function getBranding(mode) {
   return mode === "lokascript" ? "lokascript" : "hyperscript";
@@ -1763,7 +1414,29 @@ var cachedAnalyzer = null;
 function getSemanticAnalyzer() {
   if (!semanticPackage) return null;
   if (!cachedAnalyzer) {
-    cachedAnalyzer = semanticPackage.createSemanticAnalyzer();
+    cachedAnalyzer = {
+      analyze(code, language) {
+        if (!semanticPackage.isLanguageRegistered(language)) {
+          return {
+            confidence: 0,
+            errors: [`Language '${language}' is not supported for semantic parsing`]
+          };
+        }
+        const result = semanticPackage.parseSemantic(code, language);
+        const out = { confidence: result.confidence };
+        if (result.node) {
+          out.command = { name: result.node.action, roles: result.node.roles };
+        }
+        if (result.error) out.errors = [result.error];
+        return out;
+      },
+      supportsLanguage(language) {
+        return semanticPackage.isLanguageRegistered(language);
+      },
+      supportedLanguages() {
+        return semanticPackage.getRegisteredLanguages();
+      }
+    };
   }
   return cachedAnalyzer;
 }
@@ -1786,6 +1459,7 @@ connection.onInitialize((params) => {
       },
       definitionProvider: true,
       referencesProvider: true,
+      renameProvider: { prepareProvider: true },
       documentFormattingProvider: true
     }
   };
@@ -1818,7 +1492,10 @@ async function validateDocument(document) {
   if (isHtmlDocument(uri, text)) {
     const regions = extractHyperscriptRegions(text);
     for (const region of regions) {
-      const diagnostics = await getDiagnostics(region.code, globalSettings.language);
+      const diagnostics = region.type === "template" ? runDirectiveDiagnostics(region.code).map((d) => ({
+        ...d,
+        source: getBranding(resolvedMode)
+      })) : await getDiagnostics(region.code, globalSettings.language);
       for (const diag of diagnostics) {
         allDiagnostics.push({
           ...diag,
@@ -1851,7 +1528,7 @@ async function getDiagnostics(code, language) {
           start: { line: 0, character: 0 },
           end: { line: 0, character: code.split("\n")[0]?.length || code.length }
         },
-        severity: DiagnosticSeverity.Error,
+        severity: DiagnosticSeverity2.Error,
         code: "lokascript-only",
         source: brand,
         message: `${feature.description} (not compatible with _hyperscript)`
@@ -1886,7 +1563,7 @@ async function getDiagnostics(code, language) {
               start: { line: 0, character: 0 },
               end: { line: 0, character: code.split("\n")[0]?.length || code.length }
             },
-            severity: DiagnosticSeverity.Error,
+            severity: DiagnosticSeverity2.Error,
             code: "semantic-error",
             source: brand,
             message: err
@@ -1899,7 +1576,7 @@ async function getDiagnostics(code, language) {
             start: { line: 0, character: 0 },
             end: { line: 0, character: code.length }
           },
-          severity: DiagnosticSeverity.Warning,
+          severity: DiagnosticSeverity2.Warning,
           code: "low-confidence",
           source: brand,
           message: `Code could not be fully parsed (${(result.confidence * 100).toFixed(0)}% confidence)`
@@ -1911,7 +1588,7 @@ async function getDiagnostics(code, language) {
         if (cmd === "toggle" && !roles.has("patient")) {
           diagnostics.push({
             range: { start: { line: 0, character: 0 }, end: { line: 0, character: code.length } },
-            severity: DiagnosticSeverity.Warning,
+            severity: DiagnosticSeverity2.Warning,
             code: "missing-role",
             source: brand,
             message: "toggle command missing target (add .class, @attr, or selector)"
@@ -1920,7 +1597,7 @@ async function getDiagnostics(code, language) {
         if (cmd === "put" && !roles.has("destination")) {
           diagnostics.push({
             range: { start: { line: 0, character: 0 }, end: { line: 0, character: code.length } },
-            severity: DiagnosticSeverity.Warning,
+            severity: DiagnosticSeverity2.Warning,
             code: "missing-role",
             source: brand,
             message: 'put command missing destination (add "into #element")'
@@ -1931,108 +1608,58 @@ async function getDiagnostics(code, language) {
       connection.console.log(`[${brand}-ls] Semantic parsing failed, trying fallback: ${e}`);
     }
   }
-  if (diagnostics.length === 0 && interchangeLSP && parseFunction && fromCoreASTFn) {
+  if (parseFunction && fromCoreASTFn) {
     try {
-      const ast = parseFunction(code);
-      if (ast) {
-        const interchange = fromCoreASTFn(ast);
-        const nodes = interchange.type === "event" ? [interchange] : [interchange];
-        const astDiagnostics = interchangeLSP.interchangeToLSPDiagnostics(nodes, { source: brand });
-        diagnostics.push(...astDiagnostics);
+      const parseResult = parseFunction(code);
+      if (parseResult.errors?.length) {
+        for (const err of parseResult.errors) {
+          diagnostics.push({
+            range: {
+              start: {
+                line: Math.max(0, (err.line ?? 1) - 1),
+                character: Math.max(0, err.column ?? 0)
+              },
+              end: {
+                line: Math.max(0, (err.line ?? 1) - 1),
+                character: Math.max(0, err.column ?? 0) + 10
+              }
+            },
+            severity: DiagnosticSeverity2.Error,
+            code: "parse-error",
+            source: brand,
+            message: err.message
+          });
+        }
+      }
+      if (parseResult.node && interchangeLSP) {
+        const interchange = fromCoreASTFn(parseResult.node);
+        if (interchange && interchange.type !== "literal") {
+          const nodes = Array.isArray(interchange) ? interchange : [interchange];
+          const astDiagnostics = interchangeLSP.interchangeToLSPDiagnostics(nodes, {
+            source: brand
+          });
+          diagnostics.push(...astDiagnostics);
+        }
       }
     } catch (parseError) {
       diagnostics.push({
         range: {
           start: { line: 0, character: 0 },
-          end: { line: 0, character: code.length }
+          end: { line: 0, character: Math.min(code.length, 80) }
         },
-        severity: DiagnosticSeverity.Error,
+        severity: DiagnosticSeverity2.Error,
         code: "parse-error",
         source: brand,
         message: parseError.message || "Failed to parse"
       });
     }
   }
-  if (diagnostics.length === 0) {
-    try {
-      const chevrotainResult = parseWithRecovery(code);
-      for (const diag of chevrotainResult.diagnostics) {
-        const lines = code.split("\n");
-        const { line: startLine, character: startChar } = offsetToLineChar(code, diag.startOffset);
-        const { line: endLine, character: endChar } = offsetToLineChar(code, diag.endOffset);
-        diagnostics.push({
-          range: {
-            start: { line: startLine, character: startChar },
-            end: { line: endLine, character: endChar }
-          },
-          severity: diag.severity === "error" ? DiagnosticSeverity.Error : diag.severity === "warning" ? DiagnosticSeverity.Warning : DiagnosticSeverity.Information,
-          code: diag.code,
-          source: brand,
-          message: diag.message
-        });
-      }
-    } catch (e) {
-      connection.console.log(`[${brand}-ls] Chevrotain parsing failed: ${e}`);
-    }
-  }
   if (diagnostics.length === 0) {
     const simpleDiagnostics = runSimpleDiagnostics(code, language);
     diagnostics.push(...simpleDiagnostics.map((d) => ({ ...d, source: brand })));
   }
   return diagnostics.slice(0, globalSettings.maxDiagnostics);
 }
-function offsetToLineChar(text, offset) {
-  let line = 0;
-  let col = 0;
-  for (let i = 0; i < offset && i < text.length; i++) {
-    if (text[i] === "\n") {
-      line++;
-      col = 0;
-    } else {
-      col++;
-    }
-  }
-  return { line, character: col };
-}
-function runSimpleDiagnostics(code, _language) {
-  const diagnostics = [];
-  const lines = code.split("\n");
-  for (let i = 0; i < lines.length; i++) {
-    const line = lines[i];
-    const singleQuotes = (line.match(/'/g) || []).length;
-    const doubleQuotes = (line.match(/"/g) || []).length;
-    if (singleQuotes % 2 !== 0) {
-      diagnostics.push({
-        range: { start: { line: i, character: 0 }, end: { line: i, character: line.length } },
-        severity: DiagnosticSeverity.Error,
-        code: "unmatched-quote",
-        source: "lokascript",
-        message: "Unmatched single quote"
-      });
-    }
-    if (doubleQuotes % 2 !== 0) {
-      diagnostics.push({
-        range: { start: { line: i, character: 0 }, end: { line: i, character: line.length } },
-        severity: DiagnosticSeverity.Error,
-        code: "unmatched-quote",
-        source: "lokascript",
-        message: "Unmatched double quote"
-      });
-    }
-  }
-  const openParens = (code.match(/\(/g) || []).length;
-  const closeParens = (code.match(/\)/g) || []).length;
-  if (openParens !== closeParens) {
-    diagnostics.push({
-      range: { start: { line: 0, character: 0 }, end: { line: 0, character: 1 } },
-      severity: DiagnosticSeverity.Error,
-      code: "unbalanced-parens",
-      source: "lokascript",
-      message: `Unbalanced parentheses: ${openParens} open, ${closeParens} close`
-    });
-  }
-  return diagnostics;
-}
 connection.onCompletion((params) => {
   const document = documents.get(params.textDocument.uri);
   if (!document) return [];
@@ -2055,31 +1682,110 @@ connection.onCompletion((params) => {
         beforeCursor += regionLines[i] + "\n";
       }
     }
+    if (found.region.type === "template") {
+      const currentLine = regionLines[found.localLine] ?? "";
+      const linePrefix = currentLine.slice(0, found.localChar);
+      if (/^\s*#\w*$/.test(linePrefix)) {
+        return getDirectiveCompletions();
+      }
+      const sigilContext = inferContext(beforeCursor);
+      if (sigilContext === "caret") {
+        return getCaretVarCompletions(document);
+      }
+      if (sigilContext === "attrs-property") {
+        return getAttrsCompletions();
+      }
+      return [];
+    }
     const context = inferContext(beforeCursor);
+    if (context === "caret") return getCaretVarCompletions(document);
+    if (context === "attrs-property") return getAttrsCompletions();
     return getContextualCompletions(context, language);
   } else {
     const offset = document.offsetAt(position);
     const beforeCursor = text.slice(0, offset);
     const context = inferContext(beforeCursor);
-    const completions = getContextualCompletions(context, language);
-    try {
-      const chevrotainSuggestions = getContentAssist(beforeCursor, offset);
-      const existingLabels = new Set(completions.map((c) => c.label));
-      for (const s of chevrotainSuggestions) {
-        if (existingLabels.has(s.label)) continue;
-        completions.push({
-          label: s.label,
-          kind: s.kind === "command" ? CompletionItemKind.Method : s.kind === "event" ? CompletionItemKind.Event : s.kind === "selector" ? CompletionItemKind.Field : s.kind === "variable" ? CompletionItemKind.Variable : CompletionItemKind.Keyword,
-          detail: s.detail,
-          insertText: s.insertText
-        });
-      }
-    } catch {
-    }
-    return completions;
+    if (context === "caret") return getCaretVarCompletions(document);
+    if (context === "attrs-property") return getAttrsCompletions();
+    return getContextualCompletions(context, language);
   }
 });
+function getDirectiveCompletions() {
+  return [
+    {
+      label: "#if",
+      kind: CompletionItemKind.Snippet,
+      detail: "Conditional template block",
+      insertText: "#if ${1:condition}\n  ${2}\n#end"
+    },
+    {
+      label: "#if/#else",
+      kind: CompletionItemKind.Snippet,
+      detail: "Conditional with else branch",
+      insertText: "#if ${1:condition}\n  ${2}\n#else\n  ${3}\n#end"
+    },
+    {
+      label: "#for",
+      kind: CompletionItemKind.Snippet,
+      detail: "Iteration template block",
+      insertText: "#for ${1:item} in ${2:collection}\n  ${3}\n#end"
+    },
+    {
+      label: "#else",
+      kind: CompletionItemKind.Keyword,
+      detail: "Else branch"
+    },
+    {
+      label: "#end",
+      kind: CompletionItemKind.Keyword,
+      detail: "Close #if or #for block"
+    },
+    {
+      label: "#continue",
+      kind: CompletionItemKind.Keyword,
+      detail: "Skip to next #for iteration (v2.1+)"
+    }
+  ];
+}
+function getCaretVarCompletions(document) {
+  const items = [];
+  try {
+    const { table } = getDocSymbolTable(document);
+    for (const [name, entry] of table.symbols) {
+      if (entry.kind !== "caretVar") continue;
+      const bare = name.startsWith("^") ? name.slice(1) : name;
+      items.push({
+        label: bare,
+        kind: CompletionItemKind.Variable,
+        detail: "Reactive variable (^var)",
+        insertText: bare
+      });
+    }
+  } catch {
+  }
+  if (items.length === 0) {
+    items.push({
+      label: "name",
+      kind: CompletionItemKind.Snippet,
+      detail: "New reactive variable",
+      insertText: "${1:name}"
+    });
+  }
+  return items;
+}
+function getAttrsCompletions() {
+  return [
+    {
+      label: "attribute",
+      kind: CompletionItemKind.Snippet,
+      detail: "Component attribute (attrs.X)",
+      insertText: "${1:propertyName}"
+    }
+  ];
+}
 function inferContext(beforeCursor) {
+  if (/\^\w*$/.test(beforeCursor)) return "caret";
+  if (/\battrs\.\w*$/.test(beforeCursor)) return "attrs-property";
   const trimmed = beforeCursor.trim();
   if (/\bon\s*$/.test(trimmed)) return "event";
   if (/\bthen\s*$/.test(trimmed)) return "command";
@@ -2097,7 +1803,7 @@ function getContextualCompletions(context, language) {
       return eng;
     }
     try {
-      const profile = semanticPackage.getProfile(effectiveLanguage);
+      const profile = semanticPackage.tryGetProfile(effectiveLanguage);
       if (profile?.keywords?.[eng]?.primary) {
         return profile.keywords[eng].primary;
       }
@@ -2236,6 +1942,24 @@ function getContextualCompletions(context, language) {
           }
         );
       }
+      completions.push(
+        { label: getKeyword("to"), kind: CompletionItemKind.Keyword, detail: "Target destination" },
+        { label: getKeyword("from"), kind: CompletionItemKind.Keyword, detail: "Source element" },
+        {
+          label: getKeyword("into"),
+          kind: CompletionItemKind.Keyword,
+          detail: "Insert destination"
+        },
+        { label: getKeyword("on"), kind: CompletionItemKind.Keyword, detail: "Target element" },
+        { label: getKeyword("with"), kind: CompletionItemKind.Keyword, detail: "Options/data" },
+        { label: getKeyword("by"), kind: CompletionItemKind.Keyword, detail: "Amount/method" },
+        { label: getKeyword("as"), kind: CompletionItemKind.Keyword, detail: "Type/format" },
+        {
+          label: getKeyword("then"),
+          kind: CompletionItemKind.Keyword,
+          detail: "Chain next command"
+        }
+      );
       break;
     case "expression":
       completions.push(
@@ -2305,15 +2029,25 @@ connection.onHover((params) => {
       if (!currentLine2) return null;
       const word2 = getWordAtPosition(currentLine2, found.localChar);
       if (!word2) return null;
-      let doc2 = getHoverDocumentation(word2.text, globalSettings.language);
+      const expanded2 = expandSigilPrefix(currentLine2, word2);
+      let lookupText2 = expanded2?.text ?? word2.text;
+      let lookupStart2 = expanded2?.start ?? word2.start;
+      let doc2 = getHoverDocumentation(lookupText2, globalSettings.language);
+      if (!doc2) {
+        lookupText2 = word2.text;
+        lookupStart2 = word2.start;
+        doc2 = getHoverDocumentation(lookupText2, globalSettings.language);
+      }
       if (!doc2) return null;
-      const lse2 = tryGetLSE(found.region.code);
-      if (lse2) {
-        doc2 += `
+      if (found.region.type !== "template") {
+        const lse2 = tryGetLSE(found.region.code);
+        if (lse2) {
+          doc2 += `
 
 **LSE:** \`${lse2}\``;
+        }
       }
-      const startChar = found.localLine === 0 ? found.region.startChar + word2.start : word2.start;
+      const startChar = found.localLine === 0 ? found.region.startChar + lookupStart2 : lookupStart2;
       const endChar = found.localLine === 0 ? found.region.startChar + word2.end : word2.end;
       return {
         contents: { kind: MarkupKind.Markdown, value: doc2 },
@@ -2328,7 +2062,15 @@ connection.onHover((params) => {
     if (!currentLine) return null;
     const word = getWordAtPosition(currentLine, position.character);
     if (!word) return null;
-    let doc = getHoverDocumentation(word.text, globalSettings.language);
+    const expanded = expandSigilPrefix(currentLine, word);
+    let lookupText = expanded?.text ?? word.text;
+    let lookupStart = expanded?.start ?? word.start;
+    let doc = getHoverDocumentation(lookupText, globalSettings.language);
+    if (!doc) {
+      lookupText = word.text;
+      lookupStart = word.start;
+      doc = getHoverDocumentation(lookupText, globalSettings.language);
+    }
     if (!doc) return null;
     const lse = tryGetLSE(text);
     if (lse) {
@@ -2339,7 +2081,7 @@ connection.onHover((params) => {
     return {
       contents: { kind: MarkupKind.Markdown, value: doc },
       range: {
-        start: { line: position.line, character: word.start },
+        start: { line: position.line, character: lookupStart },
         end: { line: position.line, character: word.end }
       }
     };
@@ -2351,9 +2093,9 @@ connection.onHover((params) => {
 function tryGetLSE(code) {
   if (!interchangeLSP || !parseFunction || !fromCoreASTFn || !frameworkIR) return null;
   try {
-    const ast = parseFunction(code);
-    if (!ast) return null;
-    const interchange = fromCoreASTFn(ast);
+    const parseResult = parseFunction(code);
+    if (!parseResult.node) return null;
+    const interchange = fromCoreASTFn(parseResult.node);
     if (!interchange) return null;
     const semanticNode = frameworkIR.fromInterchangeNode(interchange);
     return frameworkIR.renderExplicit(semanticNode);
@@ -2361,7 +2103,30 @@ function tryGetLSE(code) {
     return null;
   }
 }
+function expandSigilPrefix(line, word) {
+  if (word.start === 0) return null;
+  const prev = line[word.start - 1];
+  if (prev !== "^" && prev !== "#") return null;
+  return { text: prev + word.text, start: word.start - 1 };
+}
 function getHoverDocumentation(word, language) {
+  const docsPre = lspMetadata?.HOVER_DOCS ?? FALLBACK_HOVER_DOCS;
+  if (word.startsWith("^")) {
+    if (docsPre["^"]) {
+      return formatHoverEntry(docsPre["^"], word, language);
+    }
+  }
+  if (word.startsWith("#")) {
+    const direct = docsPre[word.toLowerCase()];
+    if (direct) {
+      return formatHoverEntry(direct, word, language);
+    }
+  }
+  if (word.startsWith("attrs.")) {
+    if (docsPre.attrs) {
+      return formatHoverEntry(docsPre.attrs, "attrs", language);
+    }
+  }
   const wordLower = word.toLowerCase();
   const canonicalKey = isMultilingualEnabled(resolvedMode) ? resolveCanonicalKeyword(wordLower, language) : wordLower;
   const docs = lspMetadata?.HOVER_DOCS ?? FALLBACK_HOVER_DOCS;
@@ -2391,10 +2156,25 @@ ${doc.example}
   }
   return content;
 }
+function formatHoverEntry(doc, displayName, _language) {
+  let content = `**${doc.title}**`;
+  if (displayName !== doc.title) {
+    content = `**${displayName}** (${doc.title})`;
+  }
+  content += `
+
+${doc.description}`;
+  content += `
+
+\`\`\`hyperscript
+${doc.example}
+\`\`\``;
+  return content;
+}
 var translationCache = null;
 function buildTranslationCache() {
-  const cache = /* @__PURE__ */ new Map();
-  if (!semanticPackage) return cache;
+  const cache2 = /* @__PURE__ */ new Map();
+  if (!semanticPackage) return cache2;
   const langMap = {
     es: "Spanish",
     ja: "Japanese",
@@ -2431,7 +2211,7 @@ function buildTranslationCache() {
     const translations = [];
     for (const [lang, langName] of Object.entries(langMap)) {
       try {
-        const profile = semanticPackage.getProfile(lang);
+        const profile = semanticPackage.tryGetProfile(lang);
         const kw = profile?.keywords?.[canonicalKey];
         if (kw) {
           const trans = kw;
@@ -2444,10 +2224,10 @@ function buildTranslationCache() {
       }
     }
     if (translations.length > 0) {
-      cache.set(canonicalKey, translations.join(" \xB7 "));
+      cache2.set(canonicalKey, translations.join(" \xB7 "));
     }
   }
-  return cache;
+  return cache2;
 }
 function getKeywordTranslations(canonicalKey) {
   if (!translationCache) {
@@ -2457,21 +2237,21 @@ function getKeywordTranslations(canonicalKey) {
 }
 var reverseKeywordCache = null;
 function buildReverseKeywordCache() {
-  const cache = /* @__PURE__ */ new Map();
-  if (!semanticPackage) return cache;
+  const cache2 = /* @__PURE__ */ new Map();
+  if (!semanticPackage) return cache2;
   const languagesToTry = getOtherLanguages();
   for (const lang of languagesToTry) {
     try {
-      const profile = semanticPackage.getProfile(lang);
+      const profile = semanticPackage.tryGetProfile(lang);
       if (profile?.keywords) {
         for (const [canonicalKey, translation] of Object.entries(profile.keywords)) {
           const trans = translation;
           if (trans.primary) {
-            cache.set(trans.primary.toLowerCase(), canonicalKey);
+            cache2.set(trans.primary.toLowerCase(), canonicalKey);
           }
           if (trans.alternatives) {
             for (const alt of trans.alternatives) {
-              cache.set(alt.toLowerCase(), canonicalKey);
+              cache2.set(alt.toLowerCase(), canonicalKey);
             }
           }
         }
@@ -2479,7 +2259,7 @@ function buildReverseKeywordCache() {
       if (profile?.references) {
         for (const [engRef, translatedRef] of Object.entries(profile.references)) {
           if (typeof translatedRef === "string") {
-            cache.set(translatedRef.toLowerCase(), engRef);
+            cache2.set(translatedRef.toLowerCase(), engRef);
           }
         }
       }
@@ -2487,7 +2267,7 @@ function buildReverseKeywordCache() {
       connection.console.log(`[lokascript-ls] Reverse keyword cache: profile '${lang}' not found`);
     }
   }
-  return cache;
+  return cache2;
 }
 function resolveCanonicalKeyword(word, _language) {
   const canonicalKeywords = lspMetadata?.ALL_KEYWORDS ?? FALLBACK_KEYWORDS;
@@ -2497,120 +2277,12 @@ function resolveCanonicalKeyword(word, _language) {
   }
   return reverseKeywordCache.get(word) || word;
 }
-connection.onDefinition((params) => {
-  try {
-    const document = documents.get(params.textDocument.uri);
-    if (!document) return null;
-    const text = document.getText();
-    const uri = document.uri;
-    const position = params.position;
-    let targetWord = null;
-    if (isHtmlDocument(uri, text)) {
-      const regions = extractHyperscriptRegions(text);
-      const found = findRegionAtPosition(regions, position.line, position.character);
-      if (!found) {
-        return null;
-      }
-      const regionLines = found.region.code.split("\n");
-      const currentLine = regionLines[found.localLine];
-      if (!currentLine) return null;
-      const word = getWordAtPosition(currentLine, found.localChar);
-      if (!word) return null;
-      targetWord = word.text;
-    } else {
-      const lines = text.split("\n");
-      const currentLine = lines[position.line];
-      if (!currentLine) return null;
-      const word = getWordAtPosition(currentLine, position.character);
-      if (!word) return null;
-      targetWord = word.text;
-    }
-    if (!targetWord) return null;
-    const locations = [];
-    const behaviorVariants = getKeywordVariants("behavior");
-    const defVariants = getKeywordVariants("def");
-    const behaviorPattern = new RegExp(
-      `\\b(${behaviorVariants.join("|")})\\s+(${escapeRegExp(targetWord)})\\b`,
-      "gi"
-    );
-    const defPattern = new RegExp(
-      `\\b(${defVariants.join("|")})\\s+(${escapeRegExp(targetWord)})\\b`,
-      "gi"
-    );
-    if (isHtmlDocument(uri, text)) {
-      const regions = extractHyperscriptRegions(text);
-      for (const region of regions) {
-        for (const match of region.code.matchAll(behaviorPattern)) {
-          const matchLine = findLineInRegion(region.code, match.index ?? 0);
-          const matchChar = findCharInLine(region.code, match.index ?? 0);
-          locations.push({
-            uri: params.textDocument.uri,
-            range: {
-              start: {
-                line: region.startLine + matchLine,
-                character: matchLine === 0 ? region.startChar + matchChar : matchChar
-              },
-              end: {
-                line: region.startLine + matchLine,
-                character: (matchLine === 0 ? region.startChar + matchChar : matchChar) + match[0].length
-              }
-            }
-          });
-        }
-        for (const match of region.code.matchAll(defPattern)) {
-          const matchLine = findLineInRegion(region.code, match.index ?? 0);
-          const matchChar = findCharInLine(region.code, match.index ?? 0);
-          locations.push({
-            uri: params.textDocument.uri,
-            range: {
-              start: {
-                line: region.startLine + matchLine,
-                character: matchLine === 0 ? region.startChar + matchChar : matchChar
-              },
-              end: {
-                line: region.startLine + matchLine,
-                character: (matchLine === 0 ? region.startChar + matchChar : matchChar) + match[0].length
-              }
-            }
-          });
-        }
-      }
-    } else {
-      for (const match of text.matchAll(behaviorPattern)) {
-        const pos = offsetToPosition(text, match.index ?? 0);
-        locations.push({
-          uri: params.textDocument.uri,
-          range: {
-            start: pos,
-            end: { line: pos.line, character: pos.character + match[0].length }
-          }
-        });
-      }
-      for (const match of text.matchAll(defPattern)) {
-        const pos = offsetToPosition(text, match.index ?? 0);
-        locations.push({
-          uri: params.textDocument.uri,
-          range: {
-            start: pos,
-            end: { line: pos.line, character: pos.character + match[0].length }
-          }
-        });
-      }
-    }
-    if (locations.length === 0) return null;
-    if (locations.length === 1) return locations[0];
-    return locations;
-  } catch (error) {
-    connection.console.error(`Go to Definition error: ${error}`);
-    return null;
-  }
-});
 function getKeywordVariants(eng) {
   const variants = [eng];
   if (!semanticPackage) return variants;
   for (const lang of getOtherLanguages()) {
     try {
-      const profile = semanticPackage.getProfile(lang);
+      const profile = semanticPackage.tryGetProfile(lang);
       if (profile?.keywords?.[eng]) {
         const trans = profile.keywords[eng];
         if (trans.primary && !variants.includes(trans.primary)) {
@@ -2629,71 +2301,94 @@ function getKeywordVariants(eng) {
   }
   return variants;
 }
+function getDocSymbolTable(document) {
+  const text = document.getText();
+  const uri = document.uri;
+  const regions = isHtmlDocument(uri, text) ? extractHyperscriptRegions(text) : [{ code: text, startLine: 0, startChar: 0, endLine: 0, endChar: 0, type: "script" }];
+  return { table: getSymbolTable(uri, document.version, regions, getKeywordVariants), uri };
+}
+function symbolLocToLocation(uri, loc) {
+  return {
+    uri,
+    range: {
+      start: { line: loc.line, character: loc.character },
+      end: { line: loc.line, character: loc.character + loc.length }
+    }
+  };
+}
+connection.onDefinition((params) => {
+  try {
+    const document = documents.get(params.textDocument.uri);
+    if (!document) return null;
+    const { table, uri } = getDocSymbolTable(document);
+    const entry = table.symbolAt(params.position.line, params.position.character);
+    if (!entry || entry.definitions.length === 0) return null;
+    const locations = entry.definitions.map((loc) => symbolLocToLocation(uri, loc));
+    return locations.length === 1 ? locations[0] : locations;
+  } catch (error) {
+    connection.console.error(`Go to Definition error: ${error}`);
+    return null;
+  }
+});
 connection.onReferences((params) => {
   try {
     const document = documents.get(params.textDocument.uri);
     if (!document) return null;
-    const text = document.getText();
-    const uri = document.uri;
-    const position = params.position;
-    let targetWord = null;
-    if (isHtmlDocument(uri, text)) {
-      const regions = extractHyperscriptRegions(text);
-      const found = findRegionAtPosition(regions, position.line, position.character);
-      if (!found) return null;
-      const regionLines = found.region.code.split("\n");
-      const currentLine = regionLines[found.localLine];
-      if (!currentLine) return null;
-      const word = getWordAtPosition(currentLine, found.localChar);
-      if (!word) return null;
-      targetWord = word.text;
-    } else {
-      const lines = text.split("\n");
-      const currentLine = lines[position.line];
-      if (!currentLine) return null;
-      const word = getWordAtPosition(currentLine, position.character);
-      if (!word) return null;
-      targetWord = word.text;
-    }
-    if (!targetWord) return null;
-    const locations = [];
-    const wordPattern = new RegExp(`\\b${escapeRegExp(targetWord)}\\b`, "gi");
-    if (isHtmlDocument(uri, text)) {
-      const regions = extractHyperscriptRegions(text);
-      for (const region of regions) {
-        for (const match of region.code.matchAll(wordPattern)) {
-          const matchLine = findLineInRegion(region.code, match.index ?? 0);
-          const matchChar = findCharInLine(region.code, match.index ?? 0);
-          locations.push({
-            uri: params.textDocument.uri,
-            range: {
-              start: {
-                line: region.startLine + matchLine,
-                character: matchLine === 0 ? region.startChar + matchChar : matchChar
-              },
-              end: {
-                line: region.startLine + matchLine,
-                character: (matchLine === 0 ? region.startChar + matchChar : matchChar) + match[0].length
-              }
-            }
-          });
-        }
-      }
-    } else {
-      for (const match of text.matchAll(wordPattern)) {
-        const pos = offsetToPosition(text, match.index ?? 0);
-        locations.push({
-          uri: params.textDocument.uri,
+    const { table, uri } = getDocSymbolTable(document);
+    const entry = table.symbolAt(params.position.line, params.position.character);
+    if (!entry) return null;
+    const allLocs = [...entry.definitions, ...entry.usages];
+    if (allLocs.length === 0) return null;
+    return allLocs.map((loc) => symbolLocToLocation(uri, loc));
+  } catch (error) {
+    connection.console.error(`Find References error: ${error}`);
+    return null;
+  }
+});
+connection.onPrepareRename((params) => {
+  try {
+    const document = documents.get(params.textDocument.uri);
+    if (!document) return null;
+    const { table } = getDocSymbolTable(document);
+    const entry = table.symbolAt(params.position.line, params.position.character);
+    if (!entry) return null;
+    const allLocs = [...entry.definitions, ...entry.usages];
+    for (const loc of allLocs) {
+      if (loc.line === params.position.line && params.position.character >= loc.character && params.position.character < loc.character + loc.length) {
+        return {
           range: {
-            start: pos,
-            end: { line: pos.line, character: pos.character + match[0].length }
-          }
-        });
+            start: { line: loc.line, character: loc.character },
+            end: { line: loc.line, character: loc.character + loc.length }
+          },
+          placeholder: entry.name
+        };
       }
     }
-    return locations.length > 0 ? locations : null;
+    return null;
   } catch (error) {
-    connection.console.error(`Find References error: ${error}`);
+    connection.console.error(`Prepare Rename error: ${error}`);
+    return null;
+  }
+});
+connection.onRenameRequest((params) => {
+  try {
+    const document = documents.get(params.textDocument.uri);
+    if (!document) return null;
+    const { table, uri } = getDocSymbolTable(document);
+    const entry = table.symbolAt(params.position.line, params.position.character);
+    if (!entry) return null;
+    const allLocs = [...entry.definitions, ...entry.usages];
+    if (allLocs.length === 0) return null;
+    const edits = allLocs.map((loc) => ({
+      range: {
+        start: { line: loc.line, character: loc.character },
+        end: { line: loc.line, character: loc.character + loc.length }
+      },
+      newText: params.newName
+    }));
+    return { changes: { [uri]: edits } };
+  } catch (error) {
+    connection.console.error(`Rename error: ${error}`);
     return null;
   }
 });
@@ -2776,7 +2471,7 @@ function extractSymbols(code, language) {
     const variants = [eng];
     if (!semanticPackage || language === "en") return variants;
     try {
-      const profile = semanticPackage.getProfile(language);
+      const profile = semanticPackage.tryGetProfile(language);
       if (profile?.keywords?.[eng]) {
         const trans = profile.keywords[eng];
         if (trans.primary) variants.push(trans.primary);