npm - kin-lang - Versions diffs - 1.0.0 - Mend

kin-lang 1.0.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (17) hide show

package/dist/lsp/server.js ADDED Viewed

@@ -0,0 +1,3425 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+// src/lexer/token.ts
+var TokenType;
+var init_token = __esm({
+  "src/lexer/token.ts"() {
+    "use strict";
+    TokenType = /* @__PURE__ */ ((TokenType2) => {
+      TokenType2[TokenType2["NUMBER"] = 0] = "NUMBER";
+      TokenType2[TokenType2["STRING"] = 1] = "STRING";
+      TokenType2[TokenType2["IDENTIFIER"] = 2] = "IDENTIFIER";
+      TokenType2[TokenType2["KEYWORD"] = 3] = "KEYWORD";
+      TokenType2[TokenType2["EQUALS"] = 4] = "EQUALS";
+      TokenType2[TokenType2["PLUS"] = 5] = "PLUS";
+      TokenType2[TokenType2["MINUS"] = 6] = "MINUS";
+      TokenType2[TokenType2["STAR"] = 7] = "STAR";
+      TokenType2[TokenType2["SLASH"] = 8] = "SLASH";
+      TokenType2[TokenType2["GREATER_THAN"] = 9] = "GREATER_THAN";
+      TokenType2[TokenType2["LESS_THAN"] = 10] = "LESS_THAN";
+      TokenType2[TokenType2["GREATER_EQ"] = 11] = "GREATER_EQ";
+      TokenType2[TokenType2["LESS_EQ"] = 12] = "LESS_EQ";
+      TokenType2[TokenType2["EQUAL_EQUAL"] = 13] = "EQUAL_EQUAL";
+      TokenType2[TokenType2["NOT_EQUAL"] = 14] = "NOT_EQUAL";
+      TokenType2[TokenType2["LPAREN"] = 15] = "LPAREN";
+      TokenType2[TokenType2["RPAREN"] = 16] = "RPAREN";
+      TokenType2[TokenType2["COMMA"] = 17] = "COMMA";
+      TokenType2[TokenType2["DOT"] = 18] = "DOT";
+      TokenType2[TokenType2["EOF"] = 19] = "EOF";
+      TokenType2[TokenType2["LBRACE"] = 20] = "LBRACE";
+      TokenType2[TokenType2["RBRACE"] = 21] = "RBRACE";
+      TokenType2[TokenType2["COLON"] = 22] = "COLON";
+      TokenType2[TokenType2["SEMICOLON"] = 23] = "SEMICOLON";
+      TokenType2[TokenType2["AT"] = 24] = "AT";
+      TokenType2[TokenType2["LBRACKET"] = 25] = "LBRACKET";
+      TokenType2[TokenType2["RBRACKET"] = 26] = "RBRACKET";
+      TokenType2[TokenType2["QUESTION_DOT"] = 27] = "QUESTION_DOT";
+      TokenType2[TokenType2["TEMPLATE_STRING"] = 28] = "TEMPLATE_STRING";
+      TokenType2[TokenType2["BANG"] = 29] = "BANG";
+      TokenType2[TokenType2["AMPERSAND"] = 30] = "AMPERSAND";
+      TokenType2[TokenType2["PIPE"] = 31] = "PIPE";
+      return TokenType2;
+    })(TokenType || {});
+  }
+});
+// src/plugins/plugin_engine.ts
+var PluginEngine;
+var init_plugin_engine = __esm({
+  "src/plugins/plugin_engine.ts"() {
+    "use strict";
+    PluginEngine = class _PluginEngine {
+      constructor() {
+        this.plugins = [];
+      }
+      static getInstance() {
+        if (!_PluginEngine.instance) {
+          _PluginEngine.instance = new _PluginEngine();
+        }
+        return _PluginEngine.instance;
+      }
+      register(plugin) {
+        if (this.plugins.some((p) => p.name === plugin.name)) {
+          return;
+        }
+        this.plugins.push(plugin);
+      }
+      getPlugins() {
+        return this.plugins;
+      }
+      clear() {
+        this.plugins = [];
+      }
+      /**
+       * Run the extendLexer hook across all plugins.
+       */
+      extendLexer(keywords) {
+        let currentKeywords = [...keywords];
+        for (const plugin of this.plugins) {
+          if (plugin.extendLexer) {
+            currentKeywords = plugin.extendLexer(currentKeywords);
+          }
+        }
+        return currentKeywords;
+      }
+      /**
+       * Run the extendParser hook until a plugin parses the keyword.
+       */
+      extendParser(parser, keyword) {
+        for (const plugin of this.plugins) {
+          if (plugin.extendParser) {
+            const node = plugin.extendParser(parser, keyword);
+            if (node) {
+              return node;
+            }
+          }
+        }
+        return null;
+      }
+      /**
+       * Run the extendGenerator hook until a plugin generates code.
+       */
+      extendGenerator(node, target) {
+        for (const plugin of this.plugins) {
+          if (plugin.extendGenerator) {
+            const code = plugin.extendGenerator(node, target);
+            if (code !== null) {
+              return code;
+            }
+          }
+        }
+        return null;
+      }
+    };
+  }
+});
+// src/lexer/lexer.ts
+var lexer_exports = {};
+__export(lexer_exports, {
+  Lexer: () => Lexer
+});
+var KEYWORDS, Lexer;
+var init_lexer = __esm({
+  "src/lexer/lexer.ts"() {
+    "use strict";
+    init_token();
+    init_plugin_engine();
+    KEYWORDS = [
+      "number",
+      "string",
+      "boolean",
+      "log",
+      "if",
+      "elseif",
+      "else",
+      "end",
+      "repeat",
+      "times",
+      "for",
+      "in",
+      "while",
+      "break",
+      "continue",
+      "function",
+      "return",
+      "import",
+      "export",
+      "from",
+      "style",
+      "class",
+      "extends",
+      "backend",
+      "route",
+      "method",
+      "auth",
+      "required",
+      "serverless",
+      "app",
+      "screen",
+      "on",
+      "go",
+      "to",
+      "click",
+      "change",
+      "state",
+      "navigate",
+      "placeholder",
+      "value",
+      "component",
+      "with",
+      "const",
+      "true",
+      "false",
+      "null",
+      "async",
+      "await",
+      "try",
+      "catch",
+      "enum",
+      "switch",
+      "case",
+      "default",
+      "typeof",
+      "computed",
+      "namespace",
+      "middleware",
+      "object",
+      "list",
+      // Stage 9.6 — UI Framework keywords
+      "textarea",
+      "icon",
+      "card",
+      "divider",
+      "avatar",
+      "badge",
+      "checkbox",
+      "toggle",
+      "radio",
+      "dropdown",
+      "select",
+      "form",
+      "modal",
+      "dialog",
+      "sheet",
+      "tabs",
+      "tab",
+      "grid",
+      "video",
+      "audio",
+      "webview",
+      "scroll",
+      "stack",
+      "center",
+      "theme",
+      "animate",
+      "bind",
+      "show",
+      "slot",
+      "token",
+      "errorBoundary",
+      "fallback",
+      "submit",
+      "mount",
+      "unmount",
+      "focus",
+      "mobile",
+      "tablet",
+      "desktop",
+      "ariaLabel",
+      "accessibilityRole",
+      "duration",
+      "scale",
+      "fade",
+      "min",
+      "max",
+      "pattern",
+      // Stage 10 — Testing framework keywords
+      "test",
+      "describe",
+      "assert",
+      "expect",
+      "should",
+      "equal",
+      "contain",
+      "throws",
+      "toBeTruthy",
+      "toBeFalsy",
+      "not",
+      "toBe",
+      "typeOf"
+    ];
+    Lexer = class {
+      constructor() {
+        this.pos = 0;
+        this.input = "";
+      }
+      tokenize(input) {
+        this.input = input;
+        this.pos = 0;
+        const tokens = [];
+        const lineStarts = [0];
+        for (let i = 0; i < input.length; i++) {
+          if (input[i] === "\n") {
+            lineStarts.push(i + 1);
+          }
+        }
+        const getLineNumber = (offset) => {
+          let low = 0;
+          let high = lineStarts.length - 1;
+          let result = 0;
+          while (low <= high) {
+            const mid = low + high >> 1;
+            if (lineStarts[mid] <= offset) {
+              result = mid;
+              low = mid + 1;
+            } else {
+              high = mid - 1;
+            }
+          }
+          return result + 1;
+        };
+        while (this.pos < this.input.length) {
+          this.skipWhitespace();
+          if (this.pos >= this.input.length) break;
+          if (this.input[this.pos] === "#") {
+            this.skipLineComment();
+            continue;
+          }
+          if (this.input[this.pos] === "/" && this.input[this.pos + 1] === "*") {
+            this.skipBlockComment();
+            continue;
+          }
+          const start = this.pos;
+          const ch = this.input[this.pos];
+          if (ch === '"') {
+            const str = this.readString();
+            if (this.hasInterpolation(str)) {
+              tokens.push({ type: 28 /* TEMPLATE_STRING */, value: str, start, length: this.pos - start });
+            } else {
+              tokens.push({ type: 1 /* STRING */, value: str, start, length: this.pos - start });
+            }
+            continue;
+          }
+          const two = this.input.slice(this.pos, this.pos + 2);
+          if (two === "?.") {
+            tokens.push({ type: 27 /* QUESTION_DOT */, value: "?.", start, length: 2 });
+            this.pos += 2;
+            continue;
+          }
+          if (two === ">=") {
+            tokens.push({ type: 11 /* GREATER_EQ */, value: ">=", start, length: 2 });
+            this.pos += 2;
+            continue;
+          }
+          if (two === "<=") {
+            tokens.push({ type: 12 /* LESS_EQ */, value: "<=", start, length: 2 });
+            this.pos += 2;
+            continue;
+          }
+          if (two === "==") {
+            tokens.push({ type: 13 /* EQUAL_EQUAL */, value: "==", start, length: 2 });
+            this.pos += 2;
+            continue;
+          }
+          if (two === "!=") {
+            tokens.push({ type: 14 /* NOT_EQUAL */, value: "!=", start, length: 2 });
+            this.pos += 2;
+            continue;
+          }
+          if (ch === "=") {
+            tokens.push({ type: 4 /* EQUALS */, value: "=", start, length: 1 });
+            this.pos++;
+            continue;
+          }
+          if (ch === "+") {
+            tokens.push({ type: 5 /* PLUS */, value: "+", start, length: 1 });
+            this.pos++;
+            continue;
+          }
+          if (ch === "-") {
+            tokens.push({ type: 6 /* MINUS */, value: "-", start, length: 1 });
+            this.pos++;
+            continue;
+          }
+          if (ch === "*") {
+            tokens.push({ type: 7 /* STAR */, value: "*", start, length: 1 });
+            this.pos++;
+            continue;
+          }
+          if (ch === "/") {
+            tokens.push({ type: 8 /* SLASH */, value: "/", start, length: 1 });
+            this.pos++;
+            continue;
+          }
+          if (ch === ">") {
+            tokens.push({ type: 9 /* GREATER_THAN */, value: ">", start, length: 1 });
+            this.pos++;
+            continue;
+          }
+          if (ch === "<") {
+            tokens.push({ type: 10 /* LESS_THAN */, value: "<", start, length: 1 });
+            this.pos++;
+            continue;
+          }
+          if (ch === "(") {
+            tokens.push({ type: 15 /* LPAREN */, value: "(", start, length: 1 });
+            this.pos++;
+            continue;
+          }
+          if (ch === ")") {
+            tokens.push({ type: 16 /* RPAREN */, value: ")", start, length: 1 });
+            this.pos++;
+            continue;
+          }
+          if (ch === ",") {
+            tokens.push({ type: 17 /* COMMA */, value: ",", start, length: 1 });
+            this.pos++;
+            continue;
+          }
+          if (ch === ".") {
+            tokens.push({ type: 18 /* DOT */, value: ".", start, length: 1 });
+            this.pos++;
+            continue;
+          }
+          if (ch === "{") {
+            tokens.push({ type: 20 /* LBRACE */, value: "{", start, length: 1 });
+            this.pos++;
+            continue;
+          }
+          if (ch === "}") {
+            tokens.push({ type: 21 /* RBRACE */, value: "}", start, length: 1 });
+            this.pos++;
+            continue;
+          }
+          if (ch === ":") {
+            tokens.push({ type: 22 /* COLON */, value: ":", start, length: 1 });
+            this.pos++;
+            continue;
+          }
+          if (ch === ";") {
+            tokens.push({ type: 23 /* SEMICOLON */, value: ";", start, length: 1 });
+            this.pos++;
+            continue;
+          }
+          if (ch === "@") {
+            tokens.push({ type: 24 /* AT */, value: "@", start, length: 1 });
+            this.pos++;
+            continue;
+          }
+          if (ch === "[") {
+            tokens.push({ type: 25 /* LBRACKET */, value: "[", start, length: 1 });
+            this.pos++;
+            continue;
+          }
+          if (ch === "]") {
+            tokens.push({ type: 26 /* RBRACKET */, value: "]", start, length: 1 });
+            this.pos++;
+            continue;
+          }
+          if (ch === "!") {
+            if (this.input[this.pos + 1] === "=") {
+              this.pos++;
+              continue;
+            }
+            tokens.push({ type: 29 /* BANG */, value: "!", start, length: 1 });
+            this.pos++;
+            continue;
+          }
+          if (ch === "&") {
+            tokens.push({ type: 30 /* AMPERSAND */, value: "&", start, length: 1 });
+            this.pos++;
+            continue;
+          }
+          if (ch === "|") {
+            tokens.push({ type: 31 /* PIPE */, value: "|", start, length: 1 });
+            this.pos++;
+            continue;
+          }
+          if (/\d/.test(ch)) {
+            const num = this.readWhile(/\d/);
+            tokens.push({ type: 0 /* NUMBER */, value: num, start, length: this.pos - start });
+            continue;
+          }
+          if (/[a-zA-Z_]/.test(ch)) {
+            const word = this.readWhile(/[a-zA-Z0-9_]/);
+            const keywords = PluginEngine.getInstance().extendLexer(KEYWORDS);
+            const type = keywords.includes(word) ? 3 /* KEYWORD */ : 2 /* IDENTIFIER */;
+            tokens.push({ type, value: word, start, length: this.pos - start });
+            continue;
+          }
+          this.pos++;
+        }
+        tokens.push({ type: 19 /* EOF */, value: "", start: this.pos, length: 0 });
+        for (const token of tokens) {
+          if (token.start !== void 0) {
+            token.line = getLineNumber(token.start);
+          }
+        }
+        return tokens;
+      }
+      skipWhitespace() {
+        while (this.pos < this.input.length && /\s/.test(this.input[this.pos])) {
+          this.pos++;
+        }
+      }
+      readWhile(pattern) {
+        let result = "";
+        while (this.pos < this.input.length && pattern.test(this.input[this.pos])) {
+          result += this.input[this.pos++];
+        }
+        return result;
+      }
+      readString() {
+        this.pos++;
+        let result = "";
+        while (this.pos < this.input.length && this.input[this.pos] !== '"') {
+          result += this.input[this.pos++];
+        }
+        this.pos++;
+        return result;
+      }
+      /** Skip from # to end of line */
+      skipLineComment() {
+        while (this.pos < this.input.length && this.input[this.pos] !== "\n") {
+          this.pos++;
+        }
+      }
+      /** Skip from /* to * / */
+      skipBlockComment() {
+        this.pos += 2;
+        while (this.pos < this.input.length) {
+          if (this.input[this.pos] === "*" && this.input[this.pos + 1] === "/") {
+            this.pos += 2;
+            return;
+          }
+          this.pos++;
+        }
+      }
+      /** Check if a string contains {expression} interpolation patterns */
+      hasInterpolation(str) {
+        for (let i = 0; i < str.length - 1; i++) {
+          if (str[i] === "{" && str[i + 1] !== "}") {
+            let depth = 1;
+            let j = i + 1;
+            while (j < str.length && depth > 0) {
+              if (str[j] === "{") depth++;
+              if (str[j] === "}") depth--;
+              j++;
+            }
+            if (depth === 0) return true;
+          }
+        }
+        return false;
+      }
+    };
+  }
+});
+// src/lsp/server.ts
+var server_exports = {};
+__export(server_exports, {
+  startLspServer: () => startLspServer
+});
+module.exports = __toCommonJS(server_exports);
+// src/ide/language_service.ts
+init_lexer();
+// src/parser/parser.ts
+init_token();
+init_plugin_engine();
+var UI_TAGS = /* @__PURE__ */ new Set([
+  "text",
+  "button",
+  "input",
+  "view",
+  "image",
+  "list",
+  "column",
+  "row",
+  "container",
+  // Stage 9.6 — new UI elements
+  "textarea",
+  "icon",
+  "card",
+  "divider",
+  "avatar",
+  "badge",
+  "checkbox",
+  "toggle",
+  "radio",
+  "dropdown",
+  "select",
+  "modal",
+  "dialog",
+  "sheet",
+  "tabs",
+  "tab",
+  "grid",
+  "video",
+  "audio",
+  "webview",
+  "scroll",
+  "stack",
+  "center"
+]);
+var PRECEDENCE = {
+  "==": 1,
+  "!=": 1,
+  "<": 2,
+  ">": 2,
+  "<=": 2,
+  ">=": 2,
+  "+": 3,
+  "-": 3,
+  "*": 4,
+  "/": 4
+};
+var OPERATOR_TYPES = /* @__PURE__ */ new Set([
+  5 /* PLUS */,
+  6 /* MINUS */,
+  7 /* STAR */,
+  8 /* SLASH */,
+  9 /* GREATER_THAN */,
+  10 /* LESS_THAN */,
+  11 /* GREATER_EQ */,
+  12 /* LESS_EQ */,
+  13 /* EQUAL_EQUAL */,
+  14 /* NOT_EQUAL */
+]);
+var Parser = class _Parser {
+  constructor(tokens) {
+    this.tokens = tokens;
+    this.current = 0;
+    this.errors = [];
+  }
+  // â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€
+  // Top-level parse
+  // â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€
+  parse() {
+    return this.parseStatements(() => this.isEOF());
+  }
+  // â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€
+  // Generic statement list parser
+  // â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€
+  parseStatements(until) {
+    const nodes = [];
+    while (!until()) {
+      const tok = this.tokens[this.current];
+      if (!tok) {
+        this.current++;
+        continue;
+      }
+      const startLine = tok.line;
+      let node = null;
+      if (tok.type === 3 /* KEYWORD */) {
+        if (tok.value === "number" || tok.value === "string" || tok.value === "boolean" || tok.value === "list" || tok.value === "object") {
+          node = this.parseVariable();
+        } else if (tok.value === "const") {
+          node = this.parseConstDeclaration();
+        } else if (tok.value === "log") {
+          node = this.parseLog();
+        } else if (tok.value === "if") {
+          node = this.parseIf();
+        } else if (tok.value === "repeat") {
+          node = this.parseRepeatOrForIn();
+        } else if (tok.value === "for") {
+          node = this.parseForInStatement();
+        } else if (tok.value === "while") {
+          node = this.parseWhileStatement();
+        } else if (tok.value === "break") {
+          node = this.parseBreakStatement();
+        } else if (tok.value === "continue") {
+          node = this.parseContinueStatement();
+        } else if (tok.value === "function") {
+          node = this.parseFunctionDeclaration(false);
+        } else if (tok.value === "async") {
+          node = this.parseAsyncFunctionOrAwait();
+        } else if (tok.value === "return") {
+          node = this.parseReturn();
+        } else if (tok.value === "import") {
+          node = this.parseImport();
+        } else if (tok.value === "export") {
+          node = this.parseExport();
+        } else if (tok.value === "style") {
+          node = this.parseStyleBlock();
+        } else if (tok.value === "class") {
+          node = this.parseClassReference();
+        } else if (tok.value === "backend") {
+          node = this.parseBackendDeclaration();
+        } else if (tok.value === "app") {
+          node = this.parseAppDeclaration();
+        } else if (tok.value === "component") {
+          node = this.parseComponentDeclaration();
+        } else if (tok.value === "screen") {
+          node = this.parseScreenDeclaration();
+        } else if (tok.value === "go") {
+          node = this.parseGoToStatement();
+        } else if (tok.value === "navigate") {
+          node = this.parseNavigateStatement();
+        } else if (tok.value === "state") {
+          node = this.parseStateDeclaration();
+        } else if (tok.value === "try") {
+          node = this.parseTryCatch();
+        } else if (tok.value === "enum") {
+          node = this.parseEnumDeclaration();
+        } else if (tok.value === "switch") {
+          node = this.parseSwitchStatement();
+        } else if (tok.value === "computed") {
+          node = this.parseComputedDeclaration();
+        } else if (tok.value === "namespace") {
+          node = this.parseNamespaceDeclaration();
+        } else if (tok.value === "middleware") {
+          node = this.parseMiddlewareDeclaration();
+        } else if (tok.value === "theme") {
+          node = this.parseThemeDeclaration();
+        } else if (tok.value === "form") {
+          node = this.parseFormDeclaration();
+        } else if (tok.value === "token") {
+          node = this.parseDesignToken();
+        } else if (tok.value === "show") {
+          node = this.parseShowIf();
+        } else if (tok.value === "errorBoundary") {
+          node = this.parseErrorBoundary();
+        } else if (tok.value === "slot") {
+          this.current++;
+          node = { type: "SlotDeclaration" };
+        } else if (tok.value === "on") {
+          const next = this.peek(1);
+          if (next && (next.value === "mount" || next.value === "unmount" || next.value === "focus")) {
+            node = this.parseLifecycleBlock();
+          } else {
+            node = PluginEngine.getInstance().extendParser(this, tok.value);
+            if (!node) {
+              this.current++;
+            }
+          }
+        } else if (tok.value === "mobile" || tok.value === "tablet" || tok.value === "desktop") {
+          node = this.parseResponsiveBlock();
+        } else if (tok.value === "animate") {
+          node = this.parseAnimateBlock();
+        } else if (tok.value === "describe") {
+          node = this.parseDescribeBlock();
+        } else if (tok.value === "test") {
+          node = this.parseTestBlock();
+        } else if (tok.value === "assert") {
+          node = this.parseAssertStatement();
+        } else if (tok.value === "switch") {
+          const next = this.peek(1);
+          if (next && (next.value === "bind" || next.value === "toggle")) {
+            node = this.parseUIElement("toggle");
+            if (node) {
+              node.elementType = "switch";
+            }
+          } else {
+            node = this.parseSwitchStatement();
+          }
+        } else {
+          node = PluginEngine.getInstance().extendParser(this, tok.value);
+          if (!node) {
+            this.current++;
+          }
+        }
+      } else if (tok.type === 24 /* AT */) {
+        node = this.parseDecoratorAndFunction();
+      } else if (tok.type === 2 /* IDENTIFIER */) {
+        const next1 = this.peek(1);
+        const next2 = this.peek(2);
+        if (UI_TAGS.has(tok.value)) {
+          node = this.parseUIElement(tok.value);
+        } else if (next1?.type === 4 /* EQUALS */) {
+          node = this.parseStateAssignment();
+        } else if (next1?.type === 18 /* DOT */ && next2?.type === 2 /* IDENTIFIER */) {
+          const next3 = this.peek(3);
+          if (next3?.type === 15 /* LPAREN */) {
+            node = this.parseDottedCallStatement();
+          } else {
+            this.current++;
+          }
+        } else if (next1?.type === 25 /* LBRACKET */) {
+          node = this.parseIndexOrAssignmentStatement();
+        } else if (next1?.type === 15 /* LPAREN */) {
+          if (/^[A-Z]/.test(tok.value)) {
+            node = this.parseComponentCallStatement();
+          } else {
+            node = this.parseFunctionCallStatement();
+          }
+        } else {
+          this.current++;
+        }
+      } else {
+        this.current++;
+      }
+      if (node) {
+        if (startLine !== void 0) {
+          node.line = startLine;
+        }
+        nodes.push(node);
+      }
+    }
+    return nodes;
+  }
+  // â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€
+  // Statement parsers
+  // â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€
+  parseVariable() {
+    const dataType = this.tokens[this.current++].value;
+    const name = this.tokens[this.current++].value;
+    if (this.tokens[this.current]?.type === 4 /* EQUALS */) {
+      this.current++;
+    }
+    const value = this.parseExpression();
+    return { type: "VariableDeclaration", dataType, name, value };
+  }
+  parseConstDeclaration() {
+    this.current++;
+    const name = this.tokens[this.current++].value;
+    if (this.tokens[this.current]?.type === 4 /* EQUALS */) {
+      this.current++;
+    }
+    const value = this.parseExpression();
+    return { type: "VariableDeclaration", dataType: "const", name, value, isConst: true };
+  }
+  parseLog() {
+    this.current++;
+    const value = this.parseExpression();
+    return { type: "LogStatement", value };
+  }
+  parseIf() {
+    this.current++;
+    const condition = this.parseExpression();
+    const body = this.parseBody();
+    const elseifs = [];
+    while (this.tokens[this.current]?.type === 3 /* KEYWORD */ && this.tokens[this.current]?.value === "elseif") {
+      this.current++;
+      const elseifCond = this.parseExpression();
+      const elseifBody = this.parseBody();
+      elseifs.push({ condition: elseifCond, body: elseifBody });
+    }
+    let elseBody;
+    if (this.tokens[this.current]?.type === 3 /* KEYWORD */ && this.tokens[this.current]?.value === "else") {
+      this.current++;
+      elseBody = this.parseBody();
+    }
+    return { type: "IfStatement", condition, body, elseifs: elseifs.length > 0 ? elseifs : void 0, elseBody };
+  }
+  parseRepeatOrForIn() {
+    this.current++;
+    const next1 = this.peek(1);
+    if (next1?.type === 3 /* KEYWORD */ && next1.value === "in") {
+      return this.parseForInBody();
+    }
+    const count = this.parseExpression();
+    if (this.tokens[this.current]?.type === 3 /* KEYWORD */ && this.tokens[this.current]?.value === "times") {
+      this.current++;
+    }
+    const body = this.parseBody();
+    return { type: "RepeatStatement", count, body };
+  }
+  parseForInStatement() {
+    this.current++;
+    return this.parseForInBody();
+  }
+  parseForInBody() {
+    const variable = this.tokens[this.current++].value;
+    if (this.tokens[this.current]?.type === 3 /* KEYWORD */ && this.tokens[this.current]?.value === "in") {
+      this.current++;
+    }
+    const iterable = this.parseExpression();
+    const body = this.parseBody();
+    return { type: "ForInStatement", variable, iterable, body };
+  }
+  parseWhileStatement() {
+    this.current++;
+    const condition = this.parseExpression();
+    const body = this.parseBody();
+    return { type: "WhileStatement", condition, body };
+  }
+  parseBreakStatement() {
+    this.current++;
+    return { type: "BreakStatement" };
+  }
+  parseContinueStatement() {
+    this.current++;
+    return { type: "ContinueStatement" };
+  }
+  parseFunctionDeclaration(exported, decorators) {
+    this.current++;
+    const name = this.tokens[this.current++].value;
+    let typeParams;
+    if (this.tokens[this.current]?.type === 10 /* LESS_THAN */) {
+      typeParams = this.parseTypeParams();
+    }
+    const params = [];
+    if (this.tokens[this.current]?.type === 15 /* LPAREN */) {
+      this.current++;
+      while (this.current < this.tokens.length && this.tokens[this.current].type !== 16 /* RPAREN */ && this.tokens[this.current].type !== 19 /* EOF */) {
+        if (this.tokens[this.current].type === 17 /* COMMA */) {
+          this.current++;
+          continue;
+        }
+        params.push(this.tokens[this.current++].value);
+      }
+      if (this.tokens[this.current]?.type === 16 /* RPAREN */) {
+        this.current++;
+      }
+    }
+    const body = this.parseBody();
+    return { type: "FunctionDeclaration", name, params, body, exported, typeParams, decorators };
+  }
+  parseAsyncFunctionOrAwait() {
+    if (this.peek(1)?.type === 3 /* KEYWORD */ && this.peek(1)?.value === "function") {
+      this.current++;
+      const fn = this.parseFunctionDeclaration(false);
+      fn.isAsync = true;
+      return fn;
+    }
+    this.current++;
+    return { type: "LogStatement", value: { type: "Identifier", name: "async" } };
+  }
+  parseDecoratorAndFunction() {
+    const decorators = [];
+    while (this.tokens[this.current]?.type === 24 /* AT */) {
+      this.current++;
+      const name = this.tokens[this.current++].value;
+      let args;
+      if (this.tokens[this.current]?.type === 15 /* LPAREN */) {
+        args = this.parseArgList();
+      }
+      decorators.push({ name, args });
+    }
+    if (this.tokens[this.current]?.type === 3 /* KEYWORD */ && this.tokens[this.current]?.value === "function") {
+      return this.parseFunctionDeclaration(false, decorators);
+    }
+    if (this.tokens[this.current]?.type === 3 /* KEYWORD */ && this.tokens[this.current]?.value === "async") {
+      this.current++;
+      const fn = this.parseFunctionDeclaration(false, decorators);
+      fn.isAsync = true;
+      return fn;
+    }
+    this.errors.push("Expected 'function' after decorator(s)");
+    return { type: "FunctionDeclaration", name: "_unknown", params: [], body: [], exported: false, decorators };
+  }
+  parseReturn() {
+    this.current++;
+    const value = this.parseExpression();
+    return { type: "ReturnStatement", value };
+  }
+  parseTryCatch() {
+    this.current++;
+    const body = this.parseBody();
+    let catchParam = "error";
+    if (this.tokens[this.current]?.type === 3 /* KEYWORD */ && this.tokens[this.current]?.value === "catch") {
+      this.current++;
+      if (this.tokens[this.current]?.type === 2 /* IDENTIFIER */) {
+        catchParam = this.tokens[this.current++].value;
+      }
+    }
+    const catchBody = this.parseBody();
+    return { type: "TryCatchStatement", body, catchParam, catchBody };
+  }
+  parseEnumDeclaration() {
+    this.current++;
+    const name = this.tokens[this.current++].value;
+    const members = [];
+    while (!this.isEOF() && !(this.tokens[this.current]?.type === 3 /* KEYWORD */ && this.tokens[this.current]?.value === "end")) {
+      if (this.tokens[this.current]?.type === 2 /* IDENTIFIER */ || this.tokens[this.current]?.type === 3 /* KEYWORD */) {
+        members.push(this.tokens[this.current++].value);
+      } else {
+        this.current++;
+      }
+    }
+    if (this.tokens[this.current]?.type === 3 /* KEYWORD */ && this.tokens[this.current]?.value === "end") {
+      this.current++;
+    }
+    return { type: "EnumDeclaration", name, members };
+  }
+  parseSwitchStatement() {
+    this.current++;
+    const discriminant = this.parseExpression();
+    const cases = [];
+    let defaultBody;
+    while (!this.isEOF() && !(this.tokens[this.current]?.type === 3 /* KEYWORD */ && this.tokens[this.current]?.value === "end")) {
+      if (this.tokens[this.current]?.type === 3 /* KEYWORD */ && this.tokens[this.current]?.value === "case") {
+        this.current++;
+        const condition = this.parseExpression();
+        const body = this.parseStatements(() => {
+          if (this.isEOF()) return true;
+          const t = this.tokens[this.current];
+          return t.type === 3 /* KEYWORD */ && t.value === "end" || t.type === 3 /* KEYWORD */ && t.value === "case" || t.type === 3 /* KEYWORD */ && t.value === "default";
+        });
+        cases.push({ condition, body });
+      } else if (this.tokens[this.current]?.type === 3 /* KEYWORD */ && this.tokens[this.current]?.value === "default") {
+        this.current++;
+        defaultBody = this.parseStatements(() => {
+          if (this.isEOF()) return true;
+          const t = this.tokens[this.current];
+          return t.type === 3 /* KEYWORD */ && t.value === "end";
+        });
+      } else {
+        this.current++;
+      }
+    }
+    if (this.tokens[this.current]?.type === 3 /* KEYWORD */ && this.tokens[this.current]?.value === "end") {
+      this.current++;
+    }
+    return { type: "SwitchStatement", discriminant, cases, defaultBody };
+  }
+  parseComputedDeclaration() {
+    this.current++;
+    const name = this.tokens[this.current++].value;
+    if (this.tokens[this.current]?.type === 4 /* EQUALS */) {
+      this.current++;
+    }
+    const value = this.parseExpression();
+    return { type: "ComputedDeclaration", name, value };
+  }
+  parseNamespaceDeclaration() {
+    this.current++;
+    const name = this.tokens[this.current++].value;
+    const body = this.parseBody();
+    return { type: "NamespaceDeclaration", name, body };
+  }
+  parseMiddlewareDeclaration() {
+    this.current++;
+    const name = this.tokens[this.current++].value;
+    const body = this.parseBody();
+    return { type: "MiddlewareDeclaration", name, body };
+  }
+  // ────────────────────────────────────────────────────────
+  // Stage 9.6 — UI Framework parsers
+  // ────────────────────────────────────────────────────────
+  /** theme Light primary: "#3498db" end */
+  parseThemeDeclaration() {
+    this.current++;
+    const name = this.tokens[this.current++].value;
+    const properties = [];
+    while (!this.isEOF() && !(this.tokens[this.current].type === 3 /* KEYWORD */ && this.tokens[this.current].value === "end")) {
+      const key = this.tokens[this.current++].value;
+      if (this.tokens[this.current]?.type === 22 /* COLON */) this.current++;
+      const value = this.parseExpression();
+      properties.push({ key, value });
+    }
+    if (this.tokens[this.current]?.type === 3 /* KEYWORD */ && this.tokens[this.current].value === "end") this.current++;
+    return { type: "ThemeDeclaration", name, properties };
+  }
+  /** form LoginForm ... end */
+  parseFormDeclaration() {
+    this.current++;
+    const name = this.tokens[this.current++].value;
+    const body = this.parseBody();
+    return { type: "FormDeclaration", name, body };
+  }
+  /** token primaryColor = "#3498db" */
+  parseDesignToken() {
+    this.current++;
+    const name = this.tokens[this.current++].value;
+    if (this.tokens[this.current]?.type === 4 /* EQUALS */) this.current++;
+    const value = this.parseExpression();
+    return { type: "DesignToken", name, value };
+  }
+  /** show if condition body end */
+  parseShowIf() {
+    this.current++;
+    if (this.tokens[this.current]?.type === 3 /* KEYWORD */ && this.tokens[this.current].value === "if") {
+      this.current++;
+    }
+    const condition = this.parseExpression();
+    const body = this.parseStatements(
+      () => this.isEOF() || this.tokens[this.current].type === 3 /* KEYWORD */ && this.tokens[this.current].value === "end"
+    );
+    if (this.tokens[this.current]?.type === 3 /* KEYWORD */ && this.tokens[this.current].value === "end") this.current++;
+    return { type: "ShowIfStatement", condition, body };
+  }
+  /** errorBoundary fallback ... end */
+  parseErrorBoundary() {
+    this.current++;
+    const fallback = [];
+    if (this.tokens[this.current]?.type === 3 /* KEYWORD */ && this.tokens[this.current].value === "fallback") {
+      this.current++;
+    }
+    const body = this.parseStatements(
+      () => this.isEOF() || this.tokens[this.current].type === 3 /* KEYWORD */ && this.tokens[this.current].value === "end"
+    );
+    if (this.tokens[this.current]?.type === 3 /* KEYWORD */ && this.tokens[this.current].value === "end") this.current++;
+    return { type: "ErrorBoundary", fallback: body };
+  }
+  /** on mount / on unmount / on focus — lifecycle blocks */
+  parseLifecycleBlock() {
+    this.current++;
+    const event = this.tokens[this.current++].value;
+    const body = this.parseBody();
+    return { type: "LifecycleBlock", event, body };
+  }
+  /** if mobile / if tablet / if desktop — responsive blocks */
+  parseResponsiveBlock() {
+    const platform = this.tokens[this.current++].value;
+    const body = this.parseBody();
+    return { type: "ResponsiveBlock", platform, body };
+  }
+  /** animate duration: 300 scale: 1.2 fade: "in" end */
+  parseAnimateBlock() {
+    this.current++;
+    const properties = {};
+    while (!this.isEOF() && !(this.tokens[this.current].type === 3 /* KEYWORD */ && this.tokens[this.current].value === "end")) {
+      const key = this.tokens[this.current++].value;
+      if (this.tokens[this.current]?.type === 22 /* COLON */) this.current++;
+      properties[key] = this.parseExpression();
+    }
+    if (this.tokens[this.current]?.type === 3 /* KEYWORD */ && this.tokens[this.current].value === "end") this.current++;
+    return { type: "AnimateBlock", properties };
+  }
+  // ────────────────────────────────────────────────────────
+  // Stage 10 — Testing Framework parsers
+  // ────────────────────────────────────────────────────────
+  /** describe "name" body end */
+  parseDescribeBlock() {
+    this.current++;
+    const name = this.parseExpression();
+    const body = this.parseBody();
+    return { type: "DescribeBlock", name, body };
+  }
+  /** test "description" body end */
+  parseTestBlock() {
+    this.current++;
+    const description = this.parseExpression();
+    const body = this.parseBody();
+    return { type: "TestBlock", description, body };
+  }
+  /**
+   * assert expr == expr     -> equal
+   * assert expr != expr     -> notEqual
+   * assert expr             -> truthy
+   * assert not expr         -> falsy
+   * assert throws expr      -> throws
+   * assert contain expr expr -> contains
+   * assert typeOf expr "type" -> typeOf
+   */
+  parseAssertStatement() {
+    this.current++;
+    const tok = this.tokens[this.current];
+    if (tok?.type === 3 /* KEYWORD */ && tok.value === "not") {
+      this.current++;
+      const left2 = this.parseExpression();
+      return { type: "AssertStatement", variant: "falsy", left: left2 };
+    }
+    if (tok?.type === 3 /* KEYWORD */ && tok.value === "throws") {
+      this.current++;
+      const left2 = this.parseExpression();
+      return { type: "AssertStatement", variant: "throws", left: left2 };
+    }
+    if (tok?.type === 3 /* KEYWORD */ && tok.value === "contain") {
+      this.current++;
+      const left2 = this.parseExpression();
+      const right = this.parseExpression();
+      return { type: "AssertStatement", variant: "contains", left: left2, right };
+    }
+    if (tok?.type === 3 /* KEYWORD */ && tok.value === "typeOf") {
+      this.current++;
+      const left2 = this.parseExpression();
+      let expectedType = "any";
+      if (this.tokens[this.current]?.type === 1 /* STRING */) {
+        expectedType = this.tokens[this.current++].value;
+      }
+      return { type: "AssertStatement", variant: "typeOf", left: left2, expectedType };
+    }
+    const left = this.parseExpression();
+    if (left.type === "BinaryExpression") {
+      if (left.operator === "==") {
+        return { type: "AssertStatement", variant: "equal", left: left.left, right: left.right };
+      }
+      if (left.operator === "!=") {
+        return { type: "AssertStatement", variant: "notEqual", left: left.left, right: left.right };
+      }
+    }
+    const nextTok = this.tokens[this.current];
+    if (nextTok?.type === 13 /* EQUAL_EQUAL */) {
+      this.current++;
+      const right = this.parseExpression();
+      return { type: "AssertStatement", variant: "equal", left, right };
+    }
+    if (nextTok?.type === 14 /* NOT_EQUAL */) {
+      this.current++;
+      const right = this.parseExpression();
+      return { type: "AssertStatement", variant: "notEqual", left, right };
+    }
+    return { type: "AssertStatement", variant: "truthy", left };
+  }
+  // â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€
+  // UI Element parsers
+  // â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€
+  parseUIElement(tag) {
+    this.current++;
+    const element = { type: "UIElement", elementType: tag };
+    if (this.tokens[this.current]?.type === 3 /* KEYWORD */ && this.tokens[this.current].value === "bind") {
+      this.current++;
+      element.bindTarget = this.tokens[this.current++].value;
+      return element;
+    }
+    const nextTok = this.tokens[this.current];
+    if (nextTok && nextTok.type !== 19 /* EOF */ && nextTok.type !== 3 /* KEYWORD */ && !(nextTok.type === 2 /* IDENTIFIER */ && UI_TAGS.has(nextTok.value))) {
+      if (nextTok.type === 1 /* STRING */ || nextTok.type === 28 /* TEMPLATE_STRING */ || nextTok.type === 0 /* NUMBER */ || nextTok.type === 2 /* IDENTIFIER */ || nextTok.type === 15 /* LPAREN */) {
+        element.content = this.parseExpression();
+      }
+    }
+    if (tag === "card" && element.content) {
+      const next2 = this.tokens[this.current];
+      if (next2 && next2.type !== 19 /* EOF */ && next2.type !== 3 /* KEYWORD */) {
+        element.secondaryContent = this.parseExpression();
+      }
+    }
+    if ((tag === "input" || tag === "textarea") && this.tokens[this.current]?.type === 3 /* KEYWORD */ && this.tokens[this.current].value === "placeholder") {
+      this.current++;
+      if (this.tokens[this.current]?.type === 1 /* STRING */) {
+        element.placeholder = this.tokens[this.current++].value;
+      }
+    }
+    if (this.tokens[this.current]?.type === 3 /* KEYWORD */ && this.tokens[this.current].value === "bind") {
+      this.current++;
+      element.bindTarget = this.tokens[this.current++].value;
+    }
+    const validatable = ["input", "textarea", "select", "dropdown"];
+    if (validatable.includes(tag)) {
+      const rules = [];
+      while (!this.isEOF()) {
+        const tok = this.tokens[this.current];
+        if (tok?.type === 3 /* KEYWORD */ && tok.value === "required") {
+          this.current++;
+          rules.push({ rule: "required" });
+        } else if (tok?.type === 3 /* KEYWORD */ && tok.value === "min") {
+          this.current++;
+          rules.push({ rule: "min", value: this.parseExpression() });
+        } else if (tok?.type === 3 /* KEYWORD */ && tok.value === "max") {
+          this.current++;
+          rules.push({ rule: "max", value: this.parseExpression() });
+        } else if (tok?.type === 3 /* KEYWORD */ && tok.value === "pattern") {
+          this.current++;
+          rules.push({ rule: "pattern", value: this.parseExpression() });
+        } else {
+          break;
+        }
+      }
+      if (rules.length > 0) element.validation = rules;
+    }
+    const afterContent = this.tokens[this.current];
+    if (afterContent?.type === 3 /* KEYWORD */ && afterContent.value === "style") {
+      element.inlineStyle = this.parseStyleBlock();
+    } else if (afterContent?.type === 3 /* KEYWORD */ && afterContent.value === "class") {
+      this.current++;
+      if (this.tokens[this.current]?.type === 1 /* STRING */) {
+        element.className = this.tokens[this.current++].value;
+      }
+    }
+    if (this.tokens[this.current]?.type === 3 /* KEYWORD */ && (this.tokens[this.current].value === "ariaLabel" || this.tokens[this.current].value === "accessibilityRole")) {
+      element.accessibility = {};
+      while (this.tokens[this.current]?.type === 3 /* KEYWORD */ && (this.tokens[this.current].value === "ariaLabel" || this.tokens[this.current].value === "accessibilityRole")) {
+        const propName = this.tokens[this.current].value;
+        this.current++;
+        if (this.tokens[this.current]?.type === 22 /* COLON */) this.current++;
+        if (propName === "ariaLabel") {
+          element.accessibility.ariaLabel = this.parseExpression();
+        } else {
+          const roleExpr = this.parseExpression();
+          element.accessibility.role = roleExpr.type === "StringLiteral" ? roleExpr.value : "generic";
+        }
+      }
+    }
+    if (this.tokens[this.current]?.type === 3 /* KEYWORD */ && this.tokens[this.current].value === "animate") {
+      const animBlock = this.parseAnimateBlock();
+      element.animateProps = animBlock.properties;
+    }
+    const containers = /* @__PURE__ */ new Set([
+      "column",
+      "row",
+      "container",
+      "list",
+      "scroll",
+      "stack",
+      "center",
+      "grid",
+      "modal",
+      "dialog",
+      "sheet",
+      "tabs",
+      "tab"
+    ]);
+    if (containers.has(tag)) {
+      element.children = this.parseStatements(() => {
+        if (this.isEOF()) return true;
+        const t = this.tokens[this.current];
+        return t.type === 3 /* KEYWORD */ && t.value === "end";
+      });
+      if (this.tokens[this.current]?.type === 3 /* KEYWORD */ && this.tokens[this.current]?.value === "end") {
+        this.current++;
+      }
+    }
+    element.events = [];
+    while (!this.isEOF() && this.tokens[this.current]?.type === 3 /* KEYWORD */ && this.tokens[this.current]?.value === "on") {
+      element.events.push(this.parseEventHandler());
+    }
+    return element;
+  }
+  parseEventHandler() {
+    this.current++;
+    const eventName = this.tokens[this.current++].value;
+    let valueBinding;
+    if (eventName === "change" && this.tokens[this.current]?.type === 3 /* KEYWORD */ && this.tokens[this.current]?.value === "value") {
+      this.current++;
+      if (this.tokens[this.current]?.type === 2 /* IDENTIFIER */) {
+        valueBinding = this.tokens[this.current++].value;
+      } else {
+        valueBinding = "value";
+      }
+    }
+    const body = this.parseBody();
+    return { type: "EventHandler", eventName, valueBinding, body };
+  }
+  // â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€
+  // Component parsers
+  // â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€
+  parseComponentDeclaration() {
+    this.current++;
+    const nameTok = this.tokens[this.current];
+    const name = nameTok && nameTok.type !== 19 /* EOF */ ? nameTok.value : "";
+    if (nameTok && nameTok.type !== 19 /* EOF */) {
+      this.current++;
+    }
+    const params = [];
+    if (this.tokens[this.current]?.type === 15 /* LPAREN */) {
+      this.current++;
+      while (this.current < this.tokens.length && this.tokens[this.current].type !== 16 /* RPAREN */ && this.tokens[this.current].type !== 19 /* EOF */) {
+        if (this.tokens[this.current].type === 17 /* COMMA */) {
+          this.current++;
+          continue;
+        }
+        params.push(this.tokens[this.current++].value);
+      }
+      if (this.tokens[this.current]?.type === 16 /* RPAREN */) {
+        this.current++;
+      }
+    }
+    const body = this.parseBody();
+    return { type: "ComponentDeclaration", name, params, body };
+  }
+  parseComponentCallStatement() {
+    const name = this.tokens[this.current++].value;
+    const args = this.parseArgList();
+    return { type: "ComponentCall", name, args };
+  }
+  parseFunctionCallStatement() {
+    const callee = this.tokens[this.current++].value;
+    const args = this.parseArgList();
+    return { type: "FunctionCall", callee, args };
+  }
+  parseDottedCallStatement() {
+    const obj = this.tokens[this.current++].value;
+    this.current++;
+    const method = this.tokens[this.current++].value;
+    const callee = `${obj}.${method}`;
+    const args = this.parseArgList();
+    return { type: "FunctionCall", callee, args };
+  }
+  parseIndexOrAssignmentStatement() {
+    const obj = this.tokens[this.current++].value;
+    this.current++;
+    const index = this.parseExpression();
+    if (this.tokens[this.current]?.type === 26 /* RBRACKET */) {
+      this.current++;
+    }
+    const indexExpr = {
+      type: "IndexExpression",
+      object: { type: "Identifier", name: obj },
+      index
+    };
+    if (this.tokens[this.current]?.type === 4 /* EQUALS */) {
+      this.current++;
+      const value = this.parseExpression();
+      return { type: "StateAssignment", name: obj, value };
+    }
+    return { type: "FunctionCall", callee: "_index_access", args: [indexExpr] };
+  }
+  // â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€
+  // Import / Export
+  // â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€
+  parseImport() {
+    this.current++;
+    if (this.tokens[this.current]?.type === 20 /* LBRACE */) {
+      this.current++;
+      const namedImports = [];
+      while (this.current < this.tokens.length && this.tokens[this.current].type !== 21 /* RBRACE */ && this.tokens[this.current].type !== 19 /* EOF */) {
+        if (this.tokens[this.current].type === 17 /* COMMA */) {
+          this.current++;
+          continue;
+        }
+        namedImports.push(this.tokens[this.current++].value);
+      }
+      if (this.tokens[this.current]?.type === 21 /* RBRACE */) this.current++;
+      if (this.tokens[this.current]?.type === 3 /* KEYWORD */ && this.tokens[this.current].value === "from") this.current++;
+      const path3 = this.tokens[this.current++].value;
+      return { type: "ImportDeclaration", alias: namedImports[0] || "", path: path3, namedImports };
+    }
+    const alias = this.tokens[this.current++].value;
+    if (this.tokens[this.current]?.type === 3 /* KEYWORD */ && this.tokens[this.current]?.value === "from") {
+      this.current++;
+    }
+    const path2 = this.tokens[this.current++].value;
+    return { type: "ImportDeclaration", alias, path: path2 };
+  }
+  parseExport() {
+    this.current++;
+    let isDefault = false;
+    if (this.tokens[this.current]?.type === 3 /* KEYWORD */ && this.tokens[this.current].value === "default") {
+      this.current++;
+      isDefault = true;
+    }
+    if (this.tokens[this.current]?.type === 3 /* KEYWORD */ && this.tokens[this.current]?.value === "function") {
+      const decl = this.parseFunctionDeclaration(true);
+      return { type: "ExportDeclaration", declaration: decl, isDefault };
+    }
+    if (this.tokens[this.current]?.type === 3 /* KEYWORD */ && this.tokens[this.current]?.value === "async") {
+      this.current++;
+      const decl = this.parseFunctionDeclaration(true);
+      decl.isAsync = true;
+      return { type: "ExportDeclaration", declaration: decl, isDefault };
+    }
+    if (this.tokens[this.current]?.type === 3 /* KEYWORD */ && this.tokens[this.current]?.value === "component") {
+      const decl = this.parseComponentDeclaration();
+      return { type: "ExportDeclaration", declaration: decl, isDefault };
+    }
+    if (this.tokens[this.current]?.type === 3 /* KEYWORD */ && this.tokens[this.current]?.value === "const") {
+      const decl = this.parseConstDeclaration();
+      return { type: "ExportDeclaration", declaration: decl, isDefault };
+    }
+    throw new Error("'export' must be followed by 'function', 'component', 'const', or 'async function'");
+  }
+  // â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€
+  // Style parsers
+  // â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€
+  parseStyleBlock(name) {
+    this.current++;
+    let extendsName;
+    if (this.tokens[this.current]?.type === 3 /* KEYWORD */ && this.tokens[this.current]?.value === "extends") {
+      this.current++;
+      if (this.tokens[this.current]?.type === 1 /* STRING */) {
+        extendsName = this.tokens[this.current++].value;
+      }
+    }
+    if (this.tokens[this.current]?.type === 20 /* LBRACE */) {
+      this.current++;
+    }
+    const properties = [];
+    while (!this.isEOF() && this.tokens[this.current].type !== 21 /* RBRACE */) {
+      const tok = this.tokens[this.current];
+      if (tok.type !== 2 /* IDENTIFIER */) {
+        this.current++;
+        continue;
+      }
+      let key = this.tokens[this.current++].value;
+      while (this.tokens[this.current]?.type === 6 /* MINUS */ && this.tokens[this.current + 1]?.type === 2 /* IDENTIFIER */) {
+        this.current++;
+        key += "-" + this.tokens[this.current++].value;
+      }
+      if (this.tokens[this.current]?.type === 22 /* COLON */) {
+        this.current++;
+      }
+      const value = this.parseExpression();
+      if (this.tokens[this.current]?.type === 23 /* SEMICOLON */) {
+        this.current++;
+      }
+      properties.push({ key, value });
+    }
+    if (this.tokens[this.current]?.type === 21 /* RBRACE */) {
+      this.current++;
+    }
+    const block = { type: "StyleBlock", properties };
+    if (name !== void 0) block.name = name;
+    if (extendsName !== void 0) block.extends = extendsName;
+    return block;
+  }
+  parseClassReference() {
+    this.current++;
+    let name = "";
+    if (this.tokens[this.current]?.type === 1 /* STRING */) {
+      name = this.tokens[this.current++].value;
+    }
+    return { type: "ClassReference", name };
+  }
+  parseKinstyleFile() {
+    const blocks = [];
+    while (!this.isEOF()) {
+      const tok = this.tokens[this.current];
+      if (tok.type !== 2 /* IDENTIFIER */) {
+        this.current++;
+        continue;
+      }
+      const blockName = this.tokens[this.current++].value;
+      let extendsName;
+      if (this.tokens[this.current]?.type === 3 /* KEYWORD */ && this.tokens[this.current]?.value === "extends") {
+        this.current++;
+        if (this.tokens[this.current]?.type === 1 /* STRING */) {
+          extendsName = this.tokens[this.current++].value;
+        }
+      }
+      if (this.tokens[this.current]?.type === 20 /* LBRACE */) {
+        this.current++;
+      }
+      const properties = [];
+      while (!this.isEOF() && this.tokens[this.current].type !== 21 /* RBRACE */) {
+        const propTok = this.tokens[this.current];
+        if (propTok.type !== 2 /* IDENTIFIER */) {
+          this.current++;
+          continue;
+        }
+        let key = this.tokens[this.current++].value;
+        while (this.tokens[this.current]?.type === 6 /* MINUS */ && this.tokens[this.current + 1]?.type === 2 /* IDENTIFIER */) {
+          this.current++;
+          key += "-" + this.tokens[this.current++].value;
+        }
+        if (this.tokens[this.current]?.type === 22 /* COLON */) {
+          this.current++;
+        }
+        const value = this.parseExpression();
+        if (this.tokens[this.current]?.type === 23 /* SEMICOLON */) {
+          this.current++;
+        }
+        properties.push({ key, value });
+      }
+      if (this.tokens[this.current]?.type === 21 /* RBRACE */) {
+        this.current++;
+      }
+      const block = { type: "StyleBlock", name: blockName, properties };
+      if (extendsName !== void 0) block.extends = extendsName;
+      blocks.push(block);
+    }
+    return { type: "StyleSheet", blocks };
+  }
+  // â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€
+  // Backend DSL parsers
+  // â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€
+  parseMethodStatement() {
+    this.current++;
+    const tok = this.tokens[this.current];
+    if (!tok || tok.type === 19 /* EOF */) {
+      this.errors.push("Expected HTTP method after 'method' keyword");
+      return null;
+    }
+    const value = tok.value.toUpperCase();
+    const valid = /* @__PURE__ */ new Set(["GET", "POST", "PUT", "DELETE", "PATCH"]);
+    if (!valid.has(value)) {
+      this.errors.push(`Unknown HTTP method: '${tok.value}'`);
+      this.current++;
+      return null;
+    }
+    this.current++;
+    return { type: "MethodStatement", httpMethod: value };
+  }
+  parseRouteDeclaration() {
+    this.current++;
+    const pathTok = this.tokens[this.current];
+    const path2 = pathTok && pathTok.type !== 19 /* EOF */ ? pathTok.value : "";
+    if (pathTok && pathTok.type !== 19 /* EOF */) {
+      this.current++;
+    }
+    let method = null;
+    let auth = false;
+    const bodyNodes = [];
+    while (!this.isEOF()) {
+      const tok = this.tokens[this.current];
+      if (tok.type === 3 /* KEYWORD */ && tok.value === "end") break;
+      if (tok.type === 3 /* KEYWORD */ && tok.value === "method") {
+        method = this.parseMethodStatement();
+        continue;
+      }
+      if (tok.type === 3 /* KEYWORD */ && tok.value === "auth") {
+        this.current++;
+        if (this.tokens[this.current]?.type === 3 /* KEYWORD */ && this.tokens[this.current]?.value === "required") {
+          this.current++;
+        }
+        auth = true;
+        continue;
+      }
+      const stmtsBefore = bodyNodes.length;
+      const parsed = this.parseStatements(() => {
+        if (this.isEOF()) return true;
+        const t = this.tokens[this.current];
+        return t.type === 3 /* KEYWORD */ && t.value === "end" || t.type === 3 /* KEYWORD */ && t.value === "method" || t.type === 3 /* KEYWORD */ && t.value === "auth";
+      });
+      bodyNodes.push(...parsed);
+      if (bodyNodes.length === stmtsBefore) {
+        this.current++;
+      }
+    }
+    if (this.tokens[this.current]?.type === 3 /* KEYWORD */ && this.tokens[this.current]?.value === "end") {
+      this.current++;
+    }
+    if (!method) {
+      this.errors.push(`Route '${path2}' is missing a method declaration`);
+      method = { type: "MethodStatement", httpMethod: "GET" };
+    }
+    return { type: "RouteDeclaration", path: path2, method, body: bodyNodes, auth };
+  }
+  parseBackendDeclaration() {
+    this.current++;
+    const nameTok = this.tokens[this.current];
+    const name = nameTok && nameTok.type !== 19 /* EOF */ ? nameTok.value : "";
+    if (nameTok && nameTok.type !== 19 /* EOF */) {
+      this.current++;
+    }
+    const routes = [];
+    while (!this.isEOF()) {
+      const tok = this.tokens[this.current];
+      if (tok.type === 3 /* KEYWORD */ && tok.value === "end") break;
+      if (tok.type === 3 /* KEYWORD */ && tok.value === "route") {
+        routes.push(this.parseRouteDeclaration());
+        continue;
+      }
+      this.current++;
+    }
+    if (this.tokens[this.current]?.type === 3 /* KEYWORD */ && this.tokens[this.current]?.value === "end") {
+      this.current++;
+    }
+    const seen = /* @__PURE__ */ new Set();
+    for (const route of routes) {
+      const key = `${route.method.httpMethod} ${route.path}`;
+      if (seen.has(key)) {
+        this.errors.push(`Duplicate route ${route.method.httpMethod} ${route.path} in backend '${name}'`);
+      } else {
+        seen.add(key);
+      }
+    }
+    return { type: "BackendDeclaration", name, routes };
+  }
+  // â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€
+  // App DSL parsers
+  // â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€
+  parseAppDeclaration() {
+    this.current++;
+    const name = this.tokens[this.current++].value;
+    return { type: "AppDeclaration", name };
+  }
+  parseScreenDeclaration() {
+    this.current++;
+    const name = this.tokens[this.current++].value;
+    const params = [];
+    if (this.tokens[this.current]?.type === 15 /* LPAREN */) {
+      this.current++;
+      while (this.current < this.tokens.length && this.tokens[this.current].type !== 16 /* RPAREN */ && this.tokens[this.current].type !== 19 /* EOF */) {
+        if (this.tokens[this.current].type === 17 /* COMMA */) {
+          this.current++;
+          continue;
+        }
+        params.push(this.tokens[this.current++].value);
+      }
+      if (this.tokens[this.current]?.type === 16 /* RPAREN */) {
+        this.current++;
+      }
+    }
+    const body = this.parseBody();
+    return { type: "ScreenDeclaration", name, params, body };
+  }
+  parseGoToStatement() {
+    this.current++;
+    if (this.tokens[this.current]?.type === 3 /* KEYWORD */ && this.tokens[this.current]?.value === "to") {
+      this.current++;
+    } else {
+      this.errors.push("Expected 'to' after 'go'");
+    }
+    const target = this.tokens[this.current++].value;
+    const args = [];
+    if (this.tokens[this.current]?.type === 3 /* KEYWORD */ && this.tokens[this.current]?.value === "with") {
+      this.current++;
+      while (!this.isEOF()) {
+        const tok = this.tokens[this.current];
+        if (tok?.type !== 2 /* IDENTIFIER */) break;
+        const key = this.tokens[this.current++].value;
+        if (this.tokens[this.current]?.type === 4 /* EQUALS */) {
+          this.current++;
+        } else {
+          this.errors.push(`Expected '=' after navigation argument key '${key}'`);
+        }
+        const value = this.parseExpression();
+        args.push({ key, value });
+        if (this.tokens[this.current]?.type === 17 /* COMMA */) {
+          this.current++;
+        } else {
+          if (this.tokens[this.current]?.type !== 2 /* IDENTIFIER */) break;
+        }
+      }
+    }
+    return { type: "GoToStatement", target, args };
+  }
+  parseNavigateStatement() {
+    this.current++;
+    const tok = this.tokens[this.current];
+    let target = "";
+    if (tok?.type === 1 /* STRING */ || tok?.type === 2 /* IDENTIFIER */) {
+      target = this.tokens[this.current++].value;
+    }
+    return { type: "NavigateStatement", target };
+  }
+  parseStateDeclaration() {
+    this.current++;
+    const name = this.tokens[this.current++].value;
+    if (this.tokens[this.current]?.type === 4 /* EQUALS */) this.current++;
+    const value = this.parseExpression();
+    return { type: "StateDeclaration", name, value };
+  }
+  parseStateAssignment() {
+    const name = this.tokens[this.current++].value;
+    this.current++;
+    const value = this.parseExpression();
+    return { type: "StateAssignment", name, value };
+  }
+  // â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€
+  // Body parser
+  // â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€
+  parseBody() {
+    const nodes = this.parseStatements(
+      () => this.isEOF() || this.tokens[this.current].type === 3 /* KEYWORD */ && this.tokens[this.current].value === "end" || this.tokens[this.current].type === 3 /* KEYWORD */ && this.tokens[this.current].value === "elseif" || this.tokens[this.current].type === 3 /* KEYWORD */ && this.tokens[this.current].value === "else" || this.tokens[this.current].type === 3 /* KEYWORD */ && this.tokens[this.current].value === "catch" || this.tokens[this.current].type === 3 /* KEYWORD */ && this.tokens[this.current].value === "case" || this.tokens[this.current].type === 3 /* KEYWORD */ && this.tokens[this.current].value === "default"
+    );
+    if (this.tokens[this.current]?.type === 3 /* KEYWORD */ && this.tokens[this.current]?.value === "end") {
+      this.current++;
+    }
+    return nodes;
+  }
+  // â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€
+  // Expression parser â€” precedence climbing
+  // â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€
+  parseExpression(minPrec = 0) {
+    let left = this.parsePrimary();
+    while (this.tokens[this.current]?.type === 25 /* LBRACKET */) {
+      this.current++;
+      const index = this.parseExpression(0);
+      if (this.tokens[this.current]?.type === 26 /* RBRACKET */) {
+        this.current++;
+      }
+      left = { type: "IndexExpression", object: left, index };
+    }
+    while (true) {
+      const tok = this.tokens[this.current];
+      if (!tok || !OPERATOR_TYPES.has(tok.type)) break;
+      const prec = PRECEDENCE[tok.value] ?? 0;
+      if (prec <= minPrec) break;
+      const operator = tok.value;
+      this.current++;
+      const right = this.parseExpression(prec);
+      left = {
+        type: "BinaryExpression",
+        left,
+        operator,
+        right
+      };
+      while (this.tokens[this.current]?.type === 25 /* LBRACKET */) {
+        this.current++;
+        const index = this.parseExpression(0);
+        if (this.tokens[this.current]?.type === 26 /* RBRACKET */) {
+          this.current++;
+        }
+        left = { type: "IndexExpression", object: left, index };
+      }
+    }
+    return left;
+  }
+  parsePrimary() {
+    const tok = this.tokens[this.current];
+    if (!tok || tok.type === 19 /* EOF */) {
+      throw new Error("Unexpected end of input while parsing expression");
+    }
+    if (tok.type === 0 /* NUMBER */) {
+      this.current++;
+      return { type: "NumberLiteral", value: Number(tok.value) };
+    }
+    if (tok.type === 3 /* KEYWORD */ && (tok.value === "true" || tok.value === "false")) {
+      this.current++;
+      return { type: "BooleanLiteral", value: tok.value === "true" };
+    }
+    if (tok.type === 3 /* KEYWORD */ && tok.value === "null") {
+      this.current++;
+      return { type: "NullLiteral" };
+    }
+    if (tok.type === 3 /* KEYWORD */ && tok.value === "typeof") {
+      this.current++;
+      const operand = this.parsePrimary();
+      return { type: "TypeofExpression", operand };
+    }
+    if (tok.type === 3 /* KEYWORD */ && tok.value === "await") {
+      this.current++;
+      const operand = this.parsePrimary();
+      return { type: "AwaitExpression", operand };
+    }
+    if (tok.type === 25 /* LBRACKET */) {
+      return this.parseArrayLiteral();
+    }
+    if (tok.type === 20 /* LBRACE */) {
+      return this.parseObjectLiteral();
+    }
+    if (tok.type === 28 /* TEMPLATE_STRING */) {
+      this.current++;
+      return this.parseStringInterpolation(tok.value);
+    }
+    if (tok.type === 1 /* STRING */) {
+      this.current++;
+      return { type: "StringLiteral", value: tok.value };
+    }
+    if (tok.type === 2 /* IDENTIFIER */) {
+      this.current++;
+      if (this.tokens[this.current]?.type === 27 /* QUESTION_DOT */) {
+        return this.parseOptionalChain(tok.value);
+      }
+      if (this.tokens[this.current]?.type === 18 /* DOT */) {
+        this.current++;
+        const property = this.tokens[this.current++].value;
+        const dotted = `${tok.value}.${property}`;
+        if (this.tokens[this.current]?.type === 15 /* LPAREN */) {
+          const args = this.parseArgList();
+          return { type: "CallExpression", callee: dotted, args };
+        }
+        return { type: "MemberExpression", object: tok.value, property };
+      }
+      if (this.tokens[this.current]?.type === 15 /* LPAREN */) {
+        const args = this.parseArgList();
+        return { type: "CallExpression", callee: tok.value, args };
+      }
+      if (this.tokens[this.current]?.type === 25 /* LBRACKET */) {
+        this.current++;
+        const index = this.parseExpression(0);
+        if (this.tokens[this.current]?.type === 26 /* RBRACKET */) {
+          this.current++;
+        }
+        return {
+          type: "IndexExpression",
+          object: { type: "Identifier", name: tok.value },
+          index
+        };
+      }
+      return { type: "Identifier", name: tok.value };
+    }
+    if (tok.type === 15 /* LPAREN */) {
+      this.current++;
+      const expr = this.parseExpression(0);
+      if (this.tokens[this.current]?.type === 16 /* RPAREN */) {
+        this.current++;
+      }
+      return expr;
+    }
+    throw new Error(
+      `Unexpected token in expression: "${tok.value}" (type ${TokenType[tok.type]})`
+    );
+  }
+  // â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€
+  // Data structure parsers
+  // â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€
+  parseArrayLiteral() {
+    this.current++;
+    const elements = [];
+    while (this.current < this.tokens.length && this.tokens[this.current].type !== 26 /* RBRACKET */ && this.tokens[this.current].type !== 19 /* EOF */) {
+      if (this.tokens[this.current].type === 17 /* COMMA */) {
+        this.current++;
+        continue;
+      }
+      elements.push(this.parseExpression(0));
+    }
+    if (this.tokens[this.current]?.type === 26 /* RBRACKET */) {
+      this.current++;
+    }
+    return { type: "ArrayLiteral", elements };
+  }
+  parseObjectLiteral() {
+    this.current++;
+    const properties = [];
+    while (!this.isEOF() && this.tokens[this.current].type !== 21 /* RBRACE */) {
+      let key;
+      if (this.tokens[this.current].type === 2 /* IDENTIFIER */) {
+        key = this.tokens[this.current++].value;
+      } else if (this.tokens[this.current].type === 1 /* STRING */) {
+        key = this.tokens[this.current++].value;
+      } else {
+        this.current++;
+        continue;
+      }
+      if (this.tokens[this.current]?.type === 22 /* COLON */) {
+        this.current++;
+      }
+      const value = this.parseExpression(0);
+      properties.push({ key, value });
+      if (this.tokens[this.current]?.type === 17 /* COMMA */) {
+        this.current++;
+      }
+    }
+    if (this.tokens[this.current]?.type === 21 /* RBRACE */) {
+      this.current++;
+    }
+    return { type: "ObjectLiteral", properties };
+  }
+  parseOptionalChain(baseName) {
+    this.current++;
+    const property = this.tokens[this.current++].value;
+    if (this.tokens[this.current]?.type === 15 /* LPAREN */) {
+      const args = this.parseArgList();
+      return {
+        type: "CallExpression",
+        callee: `${baseName}?.${property}`,
+        args
+      };
+    }
+    if (this.tokens[this.current]?.type === 27 /* QUESTION_DOT */) {
+      const rest = this.parseOptionalChain(`${baseName}?.${property}`);
+      return rest;
+    }
+    if (this.tokens[this.current]?.type === 18 /* DOT */) {
+      this.current++;
+      const nextProp = this.tokens[this.current++].value;
+      if (this.tokens[this.current]?.type === 15 /* LPAREN */) {
+        const args = this.parseArgList();
+        return {
+          type: "CallExpression",
+          callee: `${baseName}?.${property}.${nextProp}`,
+          args
+        };
+      }
+      return {
+        type: "MemberExpression",
+        object: `${baseName}?.${property}`,
+        property: nextProp,
+        optional: true
+      };
+    }
+    return {
+      type: "MemberExpression",
+      object: baseName,
+      property,
+      optional: true
+    };
+  }
+  parseStringInterpolation(raw) {
+    const parts = [];
+    let current = "";
+    let i = 0;
+    while (i < raw.length) {
+      if (raw[i] === "{") {
+        let depth = 1;
+        let j = i + 1;
+        while (j < raw.length && depth > 0) {
+          if (raw[j] === "{") depth++;
+          if (raw[j] === "}") depth--;
+          j++;
+        }
+        if (depth === 0) {
+          if (current.length > 0) {
+            parts.push(current);
+            current = "";
+          }
+          const exprStr = raw.slice(i + 1, j - 1);
+          const subLexer = new (init_lexer(), __toCommonJS(lexer_exports)).Lexer();
+          const subTokens = subLexer.tokenize(exprStr);
+          const subParser = new _Parser(subTokens);
+          try {
+            const expr = subParser.parseExpression(0);
+            parts.push(expr);
+          } catch {
+            parts.push(exprStr);
+          }
+          i = j;
+        } else {
+          current += raw[i];
+          i++;
+        }
+      } else {
+        current += raw[i];
+        i++;
+      }
+    }
+    if (current.length > 0) {
+      parts.push(current);
+    }
+    return { type: "StringInterpolation", parts };
+  }
+  // â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€
+  // Generics type params
+  // â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€
+  parseTypeParams() {
+    this.current++;
+    const params = [];
+    while (this.current < this.tokens.length && this.tokens[this.current].type !== 9 /* GREATER_THAN */ && this.tokens[this.current].type !== 19 /* EOF */) {
+      if (this.tokens[this.current].type === 17 /* COMMA */) {
+        this.current++;
+        continue;
+      }
+      params.push(this.tokens[this.current++].value);
+    }
+    if (this.tokens[this.current]?.type === 9 /* GREATER_THAN */) {
+      this.current++;
+    }
+    return params;
+  }
+  // â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€
+  // Argument list
+  // â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€
+  parseArgList() {
+    const args = [];
+    if (this.tokens[this.current]?.type !== 15 /* LPAREN */) {
+      return args;
+    }
+    this.current++;
+    while (this.current < this.tokens.length && this.tokens[this.current].type !== 16 /* RPAREN */ && this.tokens[this.current].type !== 19 /* EOF */) {
+      if (this.tokens[this.current].type === 17 /* COMMA */) {
+        this.current++;
+        continue;
+      }
+      args.push(this.parseExpression(0));
+    }
+    if (this.tokens[this.current]?.type === 16 /* RPAREN */) {
+      this.current++;
+    }
+    return args;
+  }
+  // â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€
+  // Utilities
+  // â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€
+  isEOF() {
+    return this.current >= this.tokens.length || this.tokens[this.current].type === 19 /* EOF */;
+  }
+  peek(offset) {
+    return this.tokens[this.current + offset];
+  }
+  getCurrentToken() {
+    return this.tokens[this.current];
+  }
+};
+// src/ide/language_service.ts
+init_token();
+// src/checker/type_checker.ts
+var TypeChecker = class {
+  constructor() {
+    this.errors = [];
+    // Maps: name -> type/info
+    this.variables = /* @__PURE__ */ new Map();
+    // name -> "number" | "string" | "boolean" | "list" | "object" | "null"
+    this.constVars = /* @__PURE__ */ new Set();
+    // names declared with const
+    this.functions = /* @__PURE__ */ new Map();
+    this.components = /* @__PURE__ */ new Map();
+    this.screens = /* @__PURE__ */ new Map();
+    this.enums = /* @__PURE__ */ new Map();
+  }
+  // enum name -> member names
+  check(nodes, filename) {
+    this.errors = [];
+    this.variables.clear();
+    this.constVars.clear();
+    this.functions.clear();
+    this.components.clear();
+    this.screens.clear();
+    this.enums.clear();
+    for (const node of nodes) {
+      this.collectDeclarations(node);
+    }
+    for (const node of nodes) {
+      this.checkNode(node, filename);
+    }
+    return this.errors;
+  }
+  collectDeclarations(node) {
+    switch (node.type) {
+      case "VariableDeclaration":
+        this.variables.set(node.name, node.dataType);
+        if (node.isConst) {
+          this.constVars.add(node.name);
+        }
+        break;
+      case "FunctionDeclaration":
+        this.functions.set(node.name, { arity: node.params.length });
+        break;
+      case "ComponentDeclaration":
+        this.components.set(node.name, { arity: node.params.length });
+        break;
+      case "ScreenDeclaration":
+        this.screens.set(node.name, { params: node.params || [] });
+        break;
+      case "ExportDeclaration":
+        if (node.declaration) {
+          const decl = node.declaration;
+          if (decl.type === "FunctionDeclaration") {
+            this.functions.set(decl.name, { arity: decl.params.length });
+          } else if (decl.type === "ComponentDeclaration") {
+            this.components.set(decl.name, { arity: decl.params.length });
+          } else if (decl.type === "VariableDeclaration") {
+            this.variables.set(decl.name, decl.dataType);
+          }
+        }
+        break;
+      case "EnumDeclaration":
+        this.enums.set(node.name, node.members);
+        break;
+      case "NamespaceDeclaration":
+        for (const child of node.body) {
+          this.collectDeclarations(child);
+        }
+        break;
+      case "ComputedDeclaration":
+        this.variables.set(node.name, this.inferExprType(node.value));
+        break;
+      case "StateDeclaration":
+        this.variables.set(node.name, this.inferExprType(node.value));
+        break;
+      // Stage 9.6
+      case "ThemeDeclaration":
+        break;
+      // themes are always valid
+      case "DesignToken":
+        this.variables.set(node.name, this.inferExprType(node.value));
+        break;
+      case "FormDeclaration":
+        for (const child of node.body) {
+          this.collectDeclarations(child);
+        }
+        break;
+      // Stage 10 — Testing constructs
+      case "DescribeBlock":
+        for (const child of node.body) {
+          this.collectDeclarations(child);
+        }
+        break;
+      case "TestBlock":
+        for (const child of node.body) {
+          this.collectDeclarations(child);
+        }
+        break;
+    }
+  }
+  checkNode(node, filename) {
+    switch (node.type) {
+      case "VariableDeclaration": {
+        const valueType = this.inferExprType(node.value);
+        if (valueType !== "any" && node.dataType !== "any" && node.dataType !== "const" && valueType !== node.dataType) {
+          this.errors.push({
+            message: `Type mismatch: Cannot assign type '${valueType}' to variable '${node.name}' of type '${node.dataType}'`,
+            file: filename,
+            line: node.line
+          });
+        }
+        break;
+      }
+      case "StateDeclaration": {
+        const valType = this.inferExprType(node.value);
+        this.variables.set(node.name, valType);
+        break;
+      }
+      case "StateAssignment": {
+        if (this.constVars.has(node.name)) {
+          this.errors.push({
+            message: `Cannot reassign constant '${node.name}'`,
+            file: filename,
+            line: node.line
+          });
+        }
+        const varType = this.variables.get(node.name);
+        if (varType) {
+          const valType = this.inferExprType(node.value);
+          if (varType !== "any" && valType !== "any" && varType !== valType) {
+            this.errors.push({
+              message: `Type mismatch: Cannot assign type '${valType}' to state variable '${node.name}' of type '${varType}'`,
+              file: filename,
+              line: node.line
+            });
+          }
+        }
+        break;
+      }
+      case "FunctionCall": {
+        const func = this.functions.get(node.callee);
+        if (func) {
+          if (node.args.length !== func.arity) {
+            this.errors.push({
+              message: `Arity mismatch: Function '${node.callee}' expects ${func.arity} arguments, but got ${node.args.length}`,
+              file: filename,
+              line: node.line
+            });
+          }
+        }
+        break;
+      }
+      case "ComponentCall": {
+        const comp = this.components.get(node.name);
+        if (comp) {
+          if (node.args.length !== comp.arity) {
+            this.errors.push({
+              message: `Arity mismatch: Component '${node.name}' expects ${comp.arity} arguments, but got ${node.args.length}`,
+              file: filename,
+              line: node.line
+            });
+          }
+        }
+        break;
+      }
+      case "GoToStatement": {
+        const screen = this.screens.get(node.target);
+        if (screen) {
+          const screenParams = screen.params;
+          const passedArgs = node.args || [];
+          for (const param of screenParams) {
+            const passed = passedArgs.some((a) => a.key === param);
+            if (!passed) {
+              this.errors.push({
+                message: `Navigation error: Missing required parameter '${param}' for screen '${node.target}'`,
+                file: filename,
+                line: node.line
+              });
+            }
+          }
+          for (const arg of passedArgs) {
+            if (!screenParams.includes(arg.key)) {
+              this.errors.push({
+                message: `Navigation error: Screen '${node.target}' does not accept parameter '${arg.key}'`,
+                file: filename,
+                line: node.line
+              });
+            }
+          }
+        }
+        break;
+      }
+      case "FunctionDeclaration":
+        for (const child of node.body) {
+          this.checkNode(child, filename);
+        }
+        break;
+      case "ComponentDeclaration":
+        for (const child of node.body) {
+          this.checkNode(child, filename);
+        }
+        break;
+      case "ScreenDeclaration":
+        if (node.params) {
+          for (const p of node.params) {
+            this.variables.set(p, "any");
+          }
+        }
+        for (const child of node.body) {
+          this.checkNode(child, filename);
+        }
+        break;
+      case "IfStatement":
+        for (const child of node.body) {
+          this.checkNode(child, filename);
+        }
+        if (node.elseifs) {
+          for (const elseif of node.elseifs) {
+            for (const child of elseif.body) {
+              this.checkNode(child, filename);
+            }
+          }
+        }
+        if (node.elseBody) {
+          for (const child of node.elseBody) {
+            this.checkNode(child, filename);
+          }
+        }
+        break;
+      case "RepeatStatement":
+        for (const child of node.body) {
+          this.checkNode(child, filename);
+        }
+        break;
+      case "WhileStatement":
+        for (const child of node.body) {
+          this.checkNode(child, filename);
+        }
+        break;
+      case "ForInStatement":
+        this.variables.set(node.variable, "any");
+        for (const child of node.body) {
+          this.checkNode(child, filename);
+        }
+        break;
+      case "TryCatchStatement":
+        for (const child of node.body) {
+          this.checkNode(child, filename);
+        }
+        this.variables.set(node.catchParam, "any");
+        for (const child of node.catchBody) {
+          this.checkNode(child, filename);
+        }
+        break;
+      case "SwitchStatement":
+        for (const clause of node.cases) {
+          for (const child of clause.body) {
+            this.checkNode(child, filename);
+          }
+        }
+        if (node.defaultBody) {
+          for (const child of node.defaultBody) {
+            this.checkNode(child, filename);
+          }
+        }
+        break;
+      case "NamespaceDeclaration":
+        for (const child of node.body) {
+          this.checkNode(child, filename);
+        }
+        break;
+      case "MiddlewareDeclaration":
+        for (const child of node.body) {
+          this.checkNode(child, filename);
+        }
+        break;
+      case "UIElement":
+        if (node.children) {
+          for (const child of node.children) {
+            this.checkNode(child, filename);
+          }
+        }
+        if (node.events) {
+          for (const ev of node.events) {
+            for (const child of ev.body) {
+              this.checkNode(child, filename);
+            }
+          }
+        }
+        if (node.bindTarget && !this.variables.has(node.bindTarget)) {
+          this.errors.push({
+            message: `Bind target '${node.bindTarget}' is not a declared variable`,
+            file: filename,
+            line: node.line
+          });
+        }
+        break;
+      // Stage 9.6 — UI Framework checking
+      case "FormDeclaration":
+        for (const child of node.body) {
+          this.checkNode(child, filename);
+        }
+        break;
+      case "ThemeDeclaration":
+        break;
+      case "LifecycleBlock":
+        for (const child of node.body) {
+          this.checkNode(child, filename);
+        }
+        break;
+      case "ShowIfStatement":
+        for (const child of node.body) {
+          this.checkNode(child, filename);
+        }
+        break;
+      case "ErrorBoundary":
+        for (const child of node.fallback) {
+          this.checkNode(child, filename);
+        }
+        break;
+      case "ResponsiveBlock":
+        for (const child of node.body) {
+          this.checkNode(child, filename);
+        }
+        break;
+      case "AnimateBlock":
+        break;
+      case "SlotDeclaration":
+        break;
+      case "DesignToken":
+        break;
+      // Stage 10 — Testing framework
+      case "DescribeBlock":
+        for (const child of node.body) {
+          this.checkNode(child, filename);
+        }
+        break;
+      case "TestBlock":
+        for (const child of node.body) {
+          this.checkNode(child, filename);
+        }
+        break;
+      case "AssertStatement":
+        break;
+    }
+  }
+  inferExprType(expr) {
+    switch (expr.type) {
+      case "NumberLiteral":
+        return "number";
+      case "StringLiteral":
+        return "string";
+      case "BooleanLiteral":
+        return "boolean";
+      case "NullLiteral":
+        return "null";
+      case "ArrayLiteral":
+        return "list";
+      case "ObjectLiteral":
+        return "object";
+      case "StringInterpolation":
+        return "string";
+      case "Identifier":
+        return this.variables.get(expr.name) || "any";
+      case "TypeofExpression":
+        return "string";
+      case "MemberExpression":
+        return "any";
+      case "IndexExpression":
+        return "any";
+      case "AwaitExpression":
+        return "any";
+      case "CallExpression":
+        return "any";
+      case "BinaryExpression": {
+        const leftType = this.inferExprType(expr.left);
+        const rightType = this.inferExprType(expr.right);
+        if (leftType === "number" && rightType === "number") {
+          return "number";
+        }
+        if (expr.operator === "+") {
+          if (leftType === "string" || rightType === "string") {
+            return "string";
+          }
+        }
+        if (["==", "!=", "<", ">", "<=", ">="].includes(expr.operator)) {
+          return "boolean";
+        }
+        return "any";
+      }
+      case "TernaryExpression":
+        return this.inferExprType(expr.consequent);
+      default:
+        return "any";
+    }
+  }
+};
+// src/ide/language_service.ts
+var STYLE_PROPERTIES = [
+  "color",
+  "background-color",
+  "font-size",
+  "font-weight",
+  "padding",
+  "margin",
+  "border-radius",
+  "width",
+  "height",
+  "display",
+  "flex-direction",
+  "align-items",
+  "justify-content",
+  "border",
+  "opacity"
+];
+var BACKEND_KEYWORDS = [
+  "route",
+  "method",
+  "auth",
+  "required",
+  "end",
+  "middleware",
+  "GET",
+  "POST",
+  "PUT",
+  "DELETE",
+  "PATCH"
+];
+var GLOBAL_KEYWORDS = [
+  "number",
+  "string",
+  "boolean",
+  "log",
+  "if",
+  "elseif",
+  "else",
+  "end",
+  "repeat",
+  "times",
+  "for",
+  "in",
+  "while",
+  "break",
+  "continue",
+  "function",
+  "return",
+  "import",
+  "export",
+  "from",
+  "style",
+  "class",
+  "extends",
+  "backend",
+  "const",
+  "true",
+  "false",
+  "null",
+  "async",
+  "await",
+  "try",
+  "catch",
+  "enum",
+  "switch",
+  "case",
+  "default",
+  "typeof",
+  "computed",
+  "namespace",
+  "middleware",
+  "object",
+  "list",
+  "state",
+  "component",
+  "screen",
+  "text",
+  "button",
+  "input",
+  "view",
+  // Stage 9.6 — UI Framework keywords
+  "textarea",
+  "icon",
+  "card",
+  "divider",
+  "avatar",
+  "badge",
+  "checkbox",
+  "toggle",
+  "radio",
+  "dropdown",
+  "select",
+  "form",
+  "modal",
+  "dialog",
+  "sheet",
+  "tabs",
+  "tab",
+  "grid",
+  "video",
+  "audio",
+  "webview",
+  "scroll",
+  "stack",
+  "center",
+  "theme",
+  "animate",
+  "bind",
+  "show",
+  "slot",
+  "token",
+  "errorBoundary",
+  "fallback",
+  "submit",
+  "mount",
+  "unmount",
+  "focus",
+  "mobile",
+  "tablet",
+  "desktop",
+  "ariaLabel",
+  "accessibilityRole",
+  "on",
+  "navigate",
+  "go",
+  "app",
+  "placeholder",
+  // Stage 10 — Testing framework keywords
+  "describe",
+  "test",
+  "assert",
+  "expect",
+  "should",
+  "equal",
+  "contain",
+  "throws",
+  "toBeTruthy",
+  "toBeFalsy",
+  "not",
+  "toBe",
+  "typeOf"
+];
+var MODULE_MEMBERS = {
+  math: ["add", "subtract", "multiply", "divide", "square", "PI"],
+  request: ["body", "query", "params", "headers"]
+};
+var HOVER_DOCS = {
+  math: "Standard math module containing trigonometric and arithmetic operations.",
+  "math.add": "math.add(a, b): Returns the sum of two numbers.",
+  "math.subtract": "math.subtract(a, b): Returns the difference of two numbers.",
+  "math.multiply": "math.multiply(a, b): Returns the product of two numbers.",
+  "math.divide": "math.divide(a, b): Returns the quotient of two numbers.",
+  "math.square": "math.square(n): Returns the square of a number.",
+  "math.PI": "math.PI: The mathematical constant PI (approx. 3.14159).",
+  request: "API route Request object containing body, query, params, and headers.",
+  "request.body": "JSON body payload sent with the request.",
+  "request.query": "Query parameters in the request URL.",
+  "request.params": "Route path parameters (e.g. /users/:id).",
+  "request.headers": "HTTP headers sent with the request.",
+  number: "Declares a double-precision float variable.",
+  string: "Declares a UTF-8 character string variable.",
+  boolean: "Declares a boolean variable (true or false).",
+  const: "Declares an immutable constant that cannot be reassigned.",
+  null: "Represents the absence of a value.",
+  true: "Boolean literal representing a truthy value.",
+  false: "Boolean literal representing a falsy value.",
+  log: "Logs an expression value to the standard output / console.",
+  if: "Conditional statement: `if condition ... elseif ... else ... end`.",
+  elseif: "Additional condition branch inside an if block.",
+  else: "Fallback branch executed when no if/elseif conditions are true.",
+  for: "Loop construct: `for item in list body ... end`.",
+  in: "Used with for loops: `for item in collection`.",
+  while: "Loop that continues while a condition is true: `while cond body ... end`.",
+  break: "Immediately exits the innermost loop.",
+  continue: "Skips to the next iteration of the innermost loop.",
+  repeat: "Loop shorthand: `repeat 5 times body ... end` or `repeat item in list`.",
+  function: "Declares a reusable function: `function name(params) body ... end`.",
+  return: "Returns a value from a function or route handler.",
+  async: "Declares an asynchronous function: `async function name() body ... end`.",
+  await: "Pauses execution until a Promise resolves inside an async function.",
+  try: "Begins a try/catch error-handling block: `try ... catch err ... end`.",
+  catch: "Catches errors thrown inside a try block.",
+  enum: "Declares an enumeration: `enum Name members ... end`.",
+  switch: "Multi-branch selection: `switch expr case val ... default ... end`.",
+  case: "Matches a value inside a switch statement.",
+  default: "Fallback branch inside a switch statement.",
+  typeof: "Returns the type of an expression as a string.",
+  computed: "Declares a derived/computed value: `computed name = expr`.",
+  namespace: "Groups related declarations: `namespace Name body ... end`.",
+  middleware: "Declares Express middleware: `middleware name body ... end`.",
+  state: "Declares reactive UI state: `state name = value`.",
+  component: "Declares a reusable UI component.",
+  screen: "Declares a top-level UI screen / page.",
+  backend: "Declares a backend microservice configuration block.",
+  route: "Defines an HTTP route endpoint inside a backend microservice.",
+  style: "Defines inline styles or stylesheet classes.",
+  class: "Applies a styling class reference to a UI element.",
+  text: "UI Element: Renders a span text label.",
+  button: "UI Element: Renders a clickable button component.",
+  input: "UI Element: Renders an interactive text input form field.",
+  view: "UI Element: Renders a container block layout (div).",
+  import: 'Imports a module: `import module from path` or `import { A, B } from "path"`.',
+  export: "Exports a declaration for use by other modules.",
+  // Stage 9.6 — UI Framework docs
+  textarea: "UI Element: Renders a multi-line text input area.",
+  icon: 'UI Element: Renders a named icon (e.g. `icon "home"`).',
+  card: "UI Element: Renders a card with title and body.",
+  divider: "UI Element: Renders a horizontal divider/separator.",
+  avatar: "UI Element: Renders a user avatar image.",
+  badge: "UI Element: Renders a small badge/label.",
+  checkbox: "UI Element: Renders a checkbox input. Use with `bind` for two-way binding.",
+  toggle: "UI Element: Renders a toggle/switch control.",
+  radio: "UI Element: Renders a radio button input.",
+  dropdown: "UI Element: Renders a dropdown select menu.",
+  select: "UI Element: Renders a selection list.",
+  form: "Declares a form container: `form Name ... end`.",
+  modal: "UI Element: Renders a modal dialog overlay.",
+  dialog: "UI Element: Renders a dialog/popup.",
+  sheet: "UI Element: Renders a bottom sheet overlay.",
+  tabs: "UI Element: Renders a tabbed container.",
+  tab: "UI Element: Renders a single tab inside `tabs`.",
+  grid: "UI Element: Renders a CSS grid layout container.",
+  video: "UI Element: Renders a video player.",
+  audio: "UI Element: Renders an audio player.",
+  webview: "UI Element: Renders an embedded web view / iframe.",
+  scroll: "UI Element: Renders a scrollable container.",
+  stack: "UI Element: Renders a vertical stack layout.",
+  center: "UI Element: Renders a centered flex container.",
+  theme: "Declares a theme: `theme Name key: value ... end`.",
+  animate: "Declares animation properties: `animate duration: 300 ... end`.",
+  bind: "Creates two-way data binding: `input bind varName`.",
+  show: "Conditional UI rendering: `show if condition body ... end`.",
+  slot: "Marks where children are rendered inside a component.",
+  token: "Declares a design token: `token name = value`.",
+  errorBoundary: "Declares an error boundary with fallback UI.",
+  fallback: "The fallback UI inside an errorBoundary.",
+  mount: "Lifecycle event: `on mount body ... end` (runs when screen mounts).",
+  unmount: "Lifecycle event: `on unmount body ... end` (runs when screen unmounts).",
+  focus: "Lifecycle event: `on focus body ... end` (runs when screen gains focus).",
+  mobile: "Responsive condition: renders body only on mobile screens.",
+  tablet: "Responsive condition: renders body only on tablet screens.",
+  desktop: "Responsive condition: renders body only on desktop screens.",
+  ariaLabel: "Accessibility property for screen readers.",
+  accessibilityRole: "Accessibility role property (button, link, etc.).",
+  // Stage 10 — Testing framework docs
+  describe: 'Groups related test cases: `describe "name" body ... end`.',
+  test: 'Defines a test case: `test "description" body ... end`.',
+  assert: "Asserts a condition: `assert expr == value`, `assert expr`, `assert throws fn`, etc.",
+  expect: "Alternative assertion syntax.",
+  should: "BDD-style assertion keyword.",
+  equal: "Assert equality: `assert a equal b`.",
+  contain: "Assert containment: `assert list contain item`.",
+  throws: "Assert that a function throws: `assert throws fn`.",
+  toBeTruthy: "Assert that a value is truthy.",
+  toBeFalsy: "Assert that a value is falsy.",
+  typeOf: 'Assert the type of a value: `assert x typeOf "string"`.'
+};
+var KinLanguageService = class {
+  constructor() {
+    this.lexer = new Lexer();
+  }
+  /**
+   * Run compilation diagnostics on a file's source code.
+   */
+  getDiagnostics(source) {
+    const diagnostics = [];
+    try {
+      const tokens = this.lexer.tokenize(source);
+      const parser = new Parser(tokens);
+      const ast = parser.parse();
+      const typeChecker = new TypeChecker();
+      const typeErrors = typeChecker.check(ast);
+      for (const err of parser.errors) {
+        diagnostics.push({
+          message: err,
+          line: 1,
+          character: 1,
+          severity: "error"
+        });
+      }
+      for (const err of typeErrors) {
+        diagnostics.push({
+          message: err.message,
+          line: err.line ?? 1,
+          character: 1,
+          severity: "error"
+        });
+      }
+    } catch (e) {
+      const tokens = this.lexer.tokenize(source);
+      const parser = new Parser(tokens);
+      try {
+        parser.parse();
+      } catch (_) {
+      }
+      const currentTok = parser.getCurrentToken() || tokens[tokens.length - 1];
+      const startOffset = currentTok?.start ?? source.length;
+      const { line, character } = this.getLineCol(source, startOffset);
+      diagnostics.push({
+        message: e.message || String(e),
+        line,
+        character,
+        severity: "error"
+      });
+    }
+    return diagnostics;
+  }
+  /**
+   * Suggest autocompletions based on cursor coordinates.
+   */
+  getAutocomplete(source, line, character) {
+    const tokens = this.lexer.tokenize(source);
+    const offset = this.getOffset(source, line, character);
+    let activeIndex = -1;
+    for (let i = 0; i < tokens.length; i++) {
+      const t = tokens[i];
+      if (t.start !== void 0 && t.length !== void 0) {
+        if (t.start <= offset && offset <= t.start + t.length) {
+          activeIndex = i;
+          break;
+        }
+      }
+    }
+    if (activeIndex === -1) {
+      for (let i = tokens.length - 1; i >= 0; i--) {
+        const t = tokens[i];
+        if (t.start !== void 0 && t.start < offset) {
+          activeIndex = i;
+          break;
+        }
+      }
+    }
+    if (activeIndex === -1) {
+      return this.toCompletions(GLOBAL_KEYWORDS, "keyword");
+    }
+    let dotIndex = -1;
+    if (tokens[activeIndex]?.type === 18 /* DOT */) {
+      dotIndex = activeIndex;
+    } else if (tokens[activeIndex - 1]?.type === 18 /* DOT */) {
+      dotIndex = activeIndex - 1;
+    }
+    if (dotIndex > 0) {
+      const prev = tokens[dotIndex - 1];
+      if (prev && prev.type === 2 /* IDENTIFIER */) {
+        const objName = prev.value;
+        let fullPath = objName;
+        if (dotIndex > 2 && tokens[dotIndex - 2]?.type === 18 /* DOT */) {
+          const baseObj = tokens[dotIndex - 3];
+          if (baseObj && baseObj.type === 2 /* IDENTIFIER */) {
+            fullPath = `${baseObj.value}.${objName}`;
+          }
+        }
+        const members = MODULE_MEMBERS[fullPath];
+        if (members) {
+          return this.toCompletions(members, "property");
+        }
+      }
+      return [];
+    }
+    let isInsideStyle = false;
+    let braceCount = 0;
+    for (let i = activeIndex; i >= 0; i--) {
+      const tok = tokens[i];
+      if (tok.type === 21 /* RBRACE */) {
+        braceCount++;
+      } else if (tok.type === 20 /* LBRACE */) {
+        if (braceCount > 0) {
+          braceCount--;
+        } else {
+          const prev = tokens[i - 1];
+          if (prev && prev.type === 3 /* KEYWORD */ && prev.value === "style") {
+            isInsideStyle = true;
+          }
+          break;
+        }
+      }
+    }
+    if (isInsideStyle) {
+      return this.toCompletions(STYLE_PROPERTIES, "property");
+    }
+    let isInsideBackend = false;
+    let backendEndCount = 0;
+    for (let i = activeIndex; i >= 0; i--) {
+      const tok = tokens[i];
+      if (tok.type === 3 /* KEYWORD */ && tok.value === "end") {
+        backendEndCount++;
+      } else if (tok.type === 3 /* KEYWORD */ && tok.value === "backend") {
+        if (backendEndCount > 0) {
+          backendEndCount--;
+        } else {
+          isInsideBackend = true;
+          break;
+        }
+      }
+    }
+    if (isInsideBackend) {
+      return this.toCompletions(BACKEND_KEYWORDS, "keyword");
+    }
+    const completions = this.toCompletions(GLOBAL_KEYWORDS, "keyword");
+    try {
+      const parser = new Parser(tokens);
+      const ast = parser.parse();
+      for (const node of ast) {
+        if (node.type === "VariableDeclaration") {
+          const prefix = node.isConst ? "const" : node.dataType;
+          completions.push({ label: node.name, kind: "variable", detail: `${prefix} variable` });
+        } else if (node.type === "FunctionDeclaration") {
+          const asyncTag = node.isAsync ? "async " : "";
+          completions.push({ label: node.name, kind: "function", detail: `${asyncTag}function (${node.params.join(", ")})` });
+        } else if (node.type === "EnumDeclaration") {
+          completions.push({ label: node.name, kind: "variable", detail: "enum" });
+        } else if (node.type === "NamespaceDeclaration") {
+          completions.push({ label: node.name, kind: "module", detail: "namespace" });
+        } else if (node.type === "ComputedDeclaration") {
+          completions.push({ label: node.name, kind: "variable", detail: "computed value" });
+        } else if (node.type === "StateDeclaration") {
+          completions.push({ label: node.name, kind: "variable", detail: "state" });
+        } else if (node.type === "ComponentDeclaration") {
+          completions.push({ label: node.name, kind: "function", detail: "component" });
+        } else if (node.type === "MiddlewareDeclaration") {
+          completions.push({ label: node.name, kind: "function", detail: "middleware" });
+        } else if (node.type === "ThemeDeclaration") {
+          completions.push({ label: node.name, kind: "variable", detail: "theme" });
+        } else if (node.type === "FormDeclaration") {
+          completions.push({ label: node.name, kind: "variable", detail: "form" });
+        } else if (node.type === "DesignToken") {
+          completions.push({ label: node.name, kind: "variable", detail: "design token" });
+        } else if (node.type === "DescribeBlock") {
+          completions.push({ label: "describe", kind: "function", detail: "test suite" });
+        } else if (node.type === "TestBlock") {
+          completions.push({ label: "test", kind: "function", detail: "test case" });
+        }
+      }
+    } catch (_) {
+      for (let i = 0; i < tokens.length; i++) {
+        const tok = tokens[i];
+        if (tok.type === 3 /* KEYWORD */ && (tok.value === "number" || tok.value === "string")) {
+          const next = tokens[i + 1];
+          if (next && next.type === 2 /* IDENTIFIER */) {
+            completions.push({ label: next.value, kind: "variable" });
+          }
+        } else if (tok.type === 3 /* KEYWORD */ && tok.value === "function") {
+          const next = tokens[i + 1];
+          if (next && next.type === 2 /* IDENTIFIER */) {
+            completions.push({ label: next.value, kind: "function" });
+          }
+        }
+      }
+    }
+    const seen = /* @__PURE__ */ new Set();
+    return completions.filter((item) => {
+      if (seen.has(item.label)) return false;
+      seen.add(item.label);
+      return true;
+    });
+  }
+  /**
+   * Return hover details for symbol under cursor.
+   */
+  getHover(source, line, character) {
+    const tokens = this.lexer.tokenize(source);
+    const offset = this.getOffset(source, line, character);
+    let activeTok = null;
+    let activeIdx = -1;
+    for (let i = 0; i < tokens.length; i++) {
+      const t = tokens[i];
+      if (t.start !== void 0 && t.length !== void 0) {
+        if (t.start <= offset && offset <= t.start + t.length) {
+          activeTok = t;
+          activeIdx = i;
+          break;
+        }
+      }
+    }
+    if (!activeTok) return null;
+    let symbol = activeTok.value;
+    if (activeTok.type === 2 /* IDENTIFIER */) {
+      if (activeIdx > 1 && tokens[activeIdx - 1]?.type === 18 /* DOT */) {
+        const base = tokens[activeIdx - 2];
+        if (base && base.type === 2 /* IDENTIFIER */) {
+          symbol = `${base.value}.${symbol}`;
+          if (activeIdx > 3 && tokens[activeIdx - 3]?.type === 18 /* DOT */) {
+            const baseBase = tokens[activeIdx - 4];
+            if (baseBase && baseBase.type === 2 /* IDENTIFIER */) {
+              symbol = `${baseBase.value}.${symbol}`;
+            }
+          }
+        }
+      } else if (activeIdx < tokens.length - 2 && tokens[activeIdx + 1]?.type === 18 /* DOT */) {
+        const prop = tokens[activeIdx + 2];
+        if (prop && prop.type === 2 /* IDENTIFIER */) {
+          symbol = `${symbol}.${prop.value}`;
+        }
+      }
+    }
+    const documentation = HOVER_DOCS[symbol];
+    if (documentation) {
+      return { contents: documentation };
+    }
+    return null;
+  }
+  // ─────────────────────────────────────────
+  // Position Helpers
+  // ─────────────────────────────────────────
+  getLineCol(input, offset) {
+    let line = 1;
+    let character = 1;
+    for (let i = 0; i < Math.min(offset, input.length); i++) {
+      if (input[i] === "\n") {
+        line++;
+        character = 1;
+      } else {
+        character++;
+      }
+    }
+    return { line, character };
+  }
+  getOffset(input, line, character) {
+    let currentLine = 1;
+    let currentCol = 1;
+    for (let i = 0; i < input.length; i++) {
+      if (currentLine === line && currentCol === character) {
+        return i;
+      }
+      if (input[i] === "\n") {
+        currentLine++;
+        currentCol = 1;
+      } else {
+        currentCol++;
+      }
+    }
+    return input.length;
+  }
+  toCompletions(list, kind) {
+    return list.map((item) => ({
+      label: item,
+      kind,
+      detail: HOVER_DOCS[item] ?? `${kind} element`
+    }));
+  }
+};
+// src/cli/formatter.ts
+var import_fs = __toESM(require("fs"));
+var import_path = __toESM(require("path"));
+init_lexer();
+init_token();
+var INDENT_SIZE = 2;
+var BLOCK_OPENERS = /* @__PURE__ */ new Set([
+  "if",
+  "function",
+  "async",
+  "repeat",
+  "while",
+  "for",
+  "try",
+  "switch",
+  "describe",
+  "test",
+  "backend",
+  "route",
+  "middleware",
+  "namespace",
+  "enum",
+  "component",
+  "screen",
+  "form",
+  "theme",
+  "animate",
+  "on",
+  "show",
+  "responsive",
+  "errorBoundary"
+]);
+var INDENT_DEDENT_KEYWORDS = /* @__PURE__ */ new Set([
+  "end",
+  "elseif",
+  "else",
+  "case",
+  "default",
+  "catch",
+  "fallback"
+]);
+var KinFormatter = class {
+  constructor() {
+    this.lexer = new Lexer();
+  }
+  /**
+   * Format a single Kin source file and return the formatted string.
+   */
+  format(source) {
+    const lines = source.split("\n");
+    return this.formatLines(lines);
+  }
+  /**
+   * Format one or more files/directories in-place.
+   * Returns the list of files that were changed.
+   */
+  formatFiles(targets, check = false) {
+    const changed = [];
+    const unchanged = [];
+    for (const target of targets) {
+      const files = this.collectFiles(target);
+      for (const file of files) {
+        const original = import_fs.default.readFileSync(file, "utf8");
+        const formatted = this.format(original);
+        if (original !== formatted) {
+          changed.push(file);
+          if (!check) {
+            import_fs.default.writeFileSync(file, formatted, "utf8");
+          }
+        } else {
+          unchanged.push(file);
+        }
+      }
+    }
+    return { changed, unchanged };
+  }
+  // ───────────────────────────────────────────────────────────────────────
+  // Core formatting logic
+  // ───────────────────────────────────────────────────────────────────────
+  formatLines(rawLines) {
+    const output = [];
+    let indentLevel = 0;
+    let prevBlank = false;
+    for (const rawLine of rawLines) {
+      const trimmed = rawLine.trim();
+      if (trimmed === "") {
+        if (!prevBlank && output.length > 0) {
+          output.push("");
+          prevBlank = true;
+        }
+        continue;
+      }
+      prevBlank = false;
+      const tokens = this.lexer.tokenize(trimmed);
+      const keywords = tokens.filter((t) => t.type === 3 /* KEYWORD */).map((t) => t.value);
+      const firstKeyword = keywords[0];
+      if (firstKeyword && INDENT_DEDENT_KEYWORDS.has(firstKeyword)) {
+        indentLevel = Math.max(0, indentLevel - 1);
+      }
+      const indent = " ".repeat(indentLevel * INDENT_SIZE);
+      output.push(indent + trimmed);
+      const hasOpener = keywords.some((k) => BLOCK_OPENERS.has(k));
+      if (hasOpener) {
+        if (!INDENT_DEDENT_KEYWORDS.has(firstKeyword || "")) {
+          indentLevel++;
+        }
+      }
+    }
+    while (output.length > 0 && output[output.length - 1] === "") {
+      output.pop();
+    }
+    return output.join("\n") + "\n";
+  }
+  // ───────────────────────────────────────────────────────────────────────
+  // File collection
+  // ───────────────────────────────────────────────────────────────────────
+  collectFiles(target) {
+    const abs = import_path.default.resolve(target);
+    const stat = import_fs.default.statSync(abs, { throwIfNoEntry: false });
+    if (!stat) return [];
+    if (stat.isFile() && abs.endsWith(".kin")) return [abs];
+    if (stat.isDirectory()) return this.walkDir(abs);
+    return [];
+  }
+  walkDir(dir) {
+    const results = [];
+    for (const entry of import_fs.default.readdirSync(dir, { withFileTypes: true })) {
+      const full = import_path.default.join(dir, entry.name);
+      if (entry.isDirectory()) {
+        if (entry.name === "node_modules" || entry.name === "dist" || entry.name === ".git") continue;
+        results.push(...this.walkDir(full));
+      } else if (entry.isFile() && entry.name.endsWith(".kin")) {
+        results.push(full);
+      }
+    }
+    return results;
+  }
+};
+// src/lsp/server.ts
+var langService = new KinLanguageService();
+var kinFormatter = new KinFormatter();
+var documents = /* @__PURE__ */ new Map();
+function sendMessage(obj) {
+  const body = JSON.stringify(obj);
+  const header = `Content-Length: ${Buffer.byteLength(body, "utf8")}\r
+\r
+`;
+  process.stdout.write(header + body);
+}
+function response(id, result) {
+  sendMessage({ jsonrpc: "2.0", id, result });
+}
+function notification(method, params) {
+  sendMessage({ jsonrpc: "2.0", method, params });
+}
+var MessageReader = class {
+  constructor() {
+    this.buffer = "";
+  }
+  feed(chunk) {
+    this.buffer += chunk;
+    this.processBuffer();
+  }
+  processBuffer() {
+    while (true) {
+      const headerEnd = this.buffer.indexOf("\r\n\r\n");
+      if (headerEnd === -1) break;
+      const header = this.buffer.slice(0, headerEnd);
+      const match = header.match(/Content-Length:\s*(\d+)/i);
+      if (!match) {
+        this.buffer = this.buffer.slice(headerEnd + 4);
+        continue;
+      }
+      const length = parseInt(match[1], 10);
+      const bodyStart = headerEnd + 4;
+      if (this.buffer.length < bodyStart + length) break;
+      const body = this.buffer.slice(bodyStart, bodyStart + length);
+      this.buffer = this.buffer.slice(bodyStart + length);
+      try {
+        const msg = JSON.parse(body);
+        handleMessage(msg);
+      } catch {
+      }
+    }
+  }
+};
+function handleMessage(msg) {
+  const { id, method, params } = msg;
+  switch (method) {
+    case "initialize":
+      response(id, {
+        capabilities: {
+          textDocumentSync: {
+            openClose: true,
+            change: 1
+            /* full */
+          },
+          completionProvider: { triggerCharacters: [".", " "] },
+          hoverProvider: true,
+          definitionProvider: true,
+          referencesProvider: true,
+          renameProvider: true,
+          documentFormattingProvider: true,
+          codeActionProvider: true
+        },
+        serverInfo: { name: "kin-language-server", version: "1.0.0" }
+      });
+      break;
+    case "initialized":
+      break;
+    case "shutdown":
+      response(id, null);
+      break;
+    case "exit":
+      process.exit(0);
+    case "textDocument/didOpen": {
+      const uri = params.textDocument.uri;
+      const content = params.textDocument.text;
+      documents.set(uri, content);
+      publishDiagnostics(uri, content);
+      break;
+    }
+    case "textDocument/didChange": {
+      const uri = params.textDocument.uri;
+      const content = params.contentChanges[0].text;
+      documents.set(uri, content);
+      publishDiagnostics(uri, content);
+      break;
+    }
+    case "textDocument/didClose": {
+      const uri = params.textDocument.uri;
+      documents.delete(uri);
+      notification("textDocument/publishDiagnostics", { uri, diagnostics: [] });
+      break;
+    }
+    case "textDocument/completion": {
+      const uri = params.textDocument.uri;
+      const pos = params.position;
+      const text = documents.get(uri) ?? "";
+      const items = langService.getAutocomplete(text, pos.line + 1, pos.character + 1);
+      response(id, {
+        isIncomplete: false,
+        items: items.map((i) => ({
+          label: i.label,
+          kind: completionKindMap(i.kind),
+          detail: i.detail ?? "",
+          documentation: i.documentation ?? i.detail ?? ""
+        }))
+      });
+      break;
+    }
+    case "textDocument/hover": {
+      const uri = params.textDocument.uri;
+      const pos = params.position;
+      const text = documents.get(uri) ?? "";
+      const info = langService.getHover(text, pos.line + 1, pos.character + 1);
+      response(
+        id,
+        info ? { contents: { kind: "markdown", value: info.contents } } : null
+      );
+      break;
+    }
+    case "textDocument/definition": {
+      const uri = params.textDocument.uri;
+      const pos = params.position;
+      const text = documents.get(uri) ?? "";
+      const loc = findDefinition(text, uri, pos.line, pos.character);
+      response(id, loc);
+      break;
+    }
+    case "textDocument/references": {
+      const uri = params.textDocument.uri;
+      const pos = params.position;
+      const text = documents.get(uri) ?? "";
+      const refs = findReferences(text, uri, pos.line, pos.character);
+      response(id, refs);
+      break;
+    }
+    case "textDocument/rename": {
+      const uri = params.textDocument.uri;
+      const pos = params.position;
+      const newName = params.newName;
+      const text = documents.get(uri) ?? "";
+      const edit = renameSymbol(text, uri, pos.line, pos.character, newName);
+      response(id, edit);
+      break;
+    }
+    case "textDocument/formatting": {
+      const uri = params.textDocument.uri;
+      const text = documents.get(uri) ?? "";
+      const formatted = kinFormatter.format(text);
+      if (formatted === text) {
+        response(id, []);
+      } else {
+        const lineCount = text.split("\n").length;
+        response(id, [{
+          range: {
+            start: { line: 0, character: 0 },
+            end: { line: lineCount, character: 0 }
+          },
+          newText: formatted
+        }]);
+      }
+      break;
+    }
+    case "textDocument/codeAction": {
+      const uri = params.textDocument.uri;
+      const text = documents.get(uri) ?? "";
+      const diags = params.context?.diagnostics ?? [];
+      response(id, buildCodeActions(uri, text, diags));
+      break;
+    }
+    default:
+      if (id !== void 0) {
+        response(id, null);
+      }
+  }
+}
+function publishDiagnostics(uri, text) {
+  const diagnostics = langService.getDiagnostics(text);
+  notification("textDocument/publishDiagnostics", {
+    uri,
+    diagnostics: diagnostics.map((d) => ({
+      severity: d.severity === "error" ? 1 : 2,
+      range: {
+        start: { line: Math.max(0, d.line - 1), character: Math.max(0, d.character - 1) },
+        end: { line: Math.max(0, d.line - 1), character: Math.max(0, d.character + 20) }
+      },
+      message: d.message,
+      source: "kin"
+    }))
+  });
+}
+function findDefinition(text, uri, line, character) {
+  const lines = text.split("\n");
+  const targetLine = lines[line] ?? "";
+  const word = wordAt(targetLine, character);
+  if (!word) return null;
+  const declPattern = new RegExp(
+    `^\\s*(?:function|component|screen|state|number|string|boolean|list|object|const|enum|namespace)\\s+${escapeRegex(word)}\\b`
+  );
+  for (let i = 0; i < lines.length; i++) {
+    if (declPattern.test(lines[i])) {
+      const col = lines[i].indexOf(word);
+      return {
+        uri,
+        range: {
+          start: { line: i, character: col },
+          end: { line: i, character: col + word.length }
+        }
+      };
+    }
+  }
+  return null;
+}
+function findReferences(text, uri, line, character) {
+  const lines = text.split("\n");
+  const word = wordAt(lines[line] ?? "", character);
+  if (!word) return [];
+  const refs = [];
+  const pattern = new RegExp(`\\b${escapeRegex(word)}\\b`, "g");
+  for (let i = 0; i < lines.length; i++) {
+    let match;
+    pattern.lastIndex = 0;
+    while ((match = pattern.exec(lines[i])) !== null) {
+      refs.push({
+        uri,
+        range: {
+          start: { line: i, character: match.index },
+          end: { line: i, character: match.index + word.length }
+        }
+      });
+    }
+  }
+  return refs;
+}
+function renameSymbol(text, uri, line, character, newName) {
+  const lines = text.split("\n");
+  const word = wordAt(lines[line] ?? "", character);
+  if (!word) return null;
+  const edits = [];
+  const pattern = new RegExp(`\\b${escapeRegex(word)}\\b`, "g");
+  for (let i = 0; i < lines.length; i++) {
+    let match;
+    pattern.lastIndex = 0;
+    while ((match = pattern.exec(lines[i])) !== null) {
+      edits.push({
+        range: {
+          start: { line: i, character: match.index },
+          end: { line: i, character: match.index + word.length }
+        },
+        newText: newName
+      });
+    }
+  }
+  return {
+    changes: { [uri]: edits }
+  };
+}
+function buildCodeActions(uri, text, diagnostics) {
+  const actions = [];
+  for (const diag of diagnostics) {
+    const msg = diag.message ?? "";
+    if (msg.includes("Cannot resolve module")) {
+      const match = msg.match(/"([^"]+)"/);
+      if (match) {
+        const pkgName = match[1];
+        actions.push({
+          title: `Install missing package: ${pkgName}`,
+          kind: "quickfix",
+          diagnostics: [diag],
+          command: {
+            title: `kin install ${pkgName}`,
+            command: "kin.install",
+            arguments: [pkgName]
+          }
+        });
+      }
+    }
+    if (msg.includes("Type mismatch")) {
+      actions.push({
+        title: "Suppress type error (use 'any')",
+        kind: "quickfix",
+        diagnostics: [diag]
+      });
+    }
+  }
+  return actions;
+}
+function wordAt(line, character) {
+  const start = line.slice(0, character).search(/\w+$/) ?? -1;
+  if (start === -1) return "";
+  const end = line.slice(character).search(/\W/);
+  return end === -1 ? line.slice(start) : line.slice(start, character + end);
+}
+function escapeRegex(str) {
+  return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function completionKindMap(kind) {
+  const map = {
+    keyword: 14,
+    variable: 6,
+    function: 3,
+    property: 10,
+    module: 9
+  };
+  return map[kind] ?? 1;
+}
+function startLspServer() {
+  process.stdin.setEncoding("utf8");
+  const reader = new MessageReader();
+  process.stdin.on("data", (chunk) => reader.feed(chunk));
+  process.stdin.on("end", () => process.exit(0));
+}
+if (require.main === module) {
+  startLspServer();
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  startLspServer
+});