redscript-mc 2.6.2 → 3.0.1

package/editors/vscode/out/lsp-server.js

@@ -9207,6 +9207,8 @@ var KEYWORDS = {
   while: "while",
   for: "for",
   foreach: "foreach",
+  do: "do",
+  repeat: "repeat",
   match: "match",
   return: "return",
   break: "break",
@@ -9216,6 +9218,7 @@ var KEYWORDS = {
   in: "in",
   is: "is",
   struct: "struct",
+  extends: "extends",
   impl: "impl",
   enum: "enum",
   trigger: "trigger",
@@ -9226,6 +9229,8 @@ var KEYWORDS = {
   unless: "unless",
   declare: "declare",
   export: "export",
+  import: "import",
+  interface: "interface",
   int: "int",
   bool: "bool",
   float: "float",
@@ -9471,7 +9476,13 @@ var Lexer = class {
       return;
     }
     if (char === '"') {
-      this.scanString(startLine, startCol);
+      if (this.peek() === '"' && this.peek(1) === '"') {
+        this.advance();
+        this.advance();
+        this.scanMultiLineString(startLine, startCol);
+      } else {
+        this.scanString(startLine, startCol);
+      }
       return;
     }
     if (char === "#") {
@@ -9510,7 +9521,7 @@ var Lexer = class {
       return;
     }
     let value = "@";
-    while (/[a-zA-Z_0-9]/.test(this.peek())) {
+    while (/[a-zA-Z_0-9-]/.test(this.peek())) {
       value += this.advance();
     }
     if (this.peek() === "(") {
@@ -9539,6 +9550,26 @@ var Lexer = class {
     }
     return result;
   }
+  scanMultiLineString(startLine, startCol) {
+    let value = "";
+    while (!this.isAtEnd()) {
+      if (this.peek() === '"' && this.peek(1) === '"' && this.peek(2) === '"') {
+        this.advance();
+        this.advance();
+        this.advance();
+        break;
+      }
+      if (this.peek() === "\\" && this.peek(1) === '"') {
+        this.advance();
+        value += this.advance();
+        continue;
+      }
+      value += this.advance();
+    }
+    if (value.startsWith("\n")) value = value.slice(1);
+    if (value.endsWith("\n")) value = value.slice(0, -1);
+    this.addToken("string_lit", value, startLine, startCol);
+  }
   scanString(startLine, startCol) {
     let value = "";
     let interpolationDepth = 0;
@@ -9782,6 +9813,8 @@ var Parser = class _Parser {
     this.inLibraryMode = false;
     /** Warnings accumulated during parsing (e.g. deprecated keyword usage). */
     this.warnings = [];
+    /** Parse errors collected during error-recovery mode. */
+    this.parseErrors = [];
     this.tokens = tokens;
     this.sourceLines = source?.split("\n") ?? [];
     this.filePath = filePath;
@@ -9852,6 +9885,60 @@ var Parser = class _Parser {
     return { kind: "eof", value: "", line: span.line, col: span.col };
   }
   // -------------------------------------------------------------------------
+  // Error Recovery
+  // -------------------------------------------------------------------------
+  /**
+   * Synchronize to the next top-level declaration boundary after a parse error.
+   * Skips tokens until we find a keyword that starts a top-level declaration,
+   * or a `}` (end of a block), or EOF.
+   */
+  syncToNextDecl() {
+    const TOP_LEVEL_KEYWORDS = /* @__PURE__ */ new Set([
+      "fn",
+      "struct",
+      "impl",
+      "enum",
+      "const",
+      "let",
+      "export",
+      "declare",
+      "import",
+      "namespace",
+      "module"
+    ]);
+    while (!this.check("eof")) {
+      const kind = this.peek().kind;
+      if (kind === "}") {
+        this.advance();
+        return;
+      }
+      if (TOP_LEVEL_KEYWORDS.has(kind)) {
+        return;
+      }
+      if (kind === "ident" && this.peek().value === "import") {
+        return;
+      }
+      this.advance();
+    }
+  }
+  /**
+   * Synchronize to the next statement boundary inside a block after a parse error.
+   * Skips tokens until we reach `;`, `}`, or EOF.
+   */
+  syncToNextStmt() {
+    while (!this.check("eof")) {
+      const kind = this.peek().kind;
+      if (kind === ";") {
+        this.advance();
+        return;
+      }
+      if (kind === "}") {
+        return;
+      }
+      this.advance();
+    }
+  }
+  // -------------------------------------------------------------------------
   // Program
   // -------------------------------------------------------------------------
   parse(defaultNamespace = "redscript") {
@@ -9863,6 +9950,7 @@ var Parser = class _Parser {
     const enums = [];
     const consts = [];
     const imports = [];
+    const interfaces = [];
     let isLibrary = false;
     let moduleName;
     if (this.check("namespace")) {
@@ -9883,40 +9971,74 @@ var Parser = class _Parser {
       this.match(";");
     }
     while (!this.check("eof")) {
-      if (this.check("let")) {
-        globals.push(this.parseGlobalDecl(true));
-      } else if (this.check("struct")) {
-        structs.push(this.parseStructDecl());
-      } else if (this.check("impl")) {
-        implBlocks.push(this.parseImplBlock());
-      } else if (this.check("enum")) {
-        enums.push(this.parseEnumDecl());
-      } else if (this.check("const")) {
-        consts.push(this.parseConstDecl());
-      } else if (this.check("declare")) {
-        this.advance();
-        this.parseDeclareStub();
-      } else if (this.check("export")) {
-        declarations.push(this.parseExportedFnDecl());
-      } else if (this.check("ident") && this.peek().value === "import") {
-        this.advance();
-        const importToken = this.peek();
-        const modName = this.expect("ident").value;
-        this.expect("::");
-        let symbol;
-        if (this.check("*")) {
+      try {
+        if (this.check("decorator") && this.peek().value.startsWith("@config")) {
+          const decorToken = this.advance();
+          const decorator = this.parseDecoratorValue(decorToken.value);
+          if (!this.check("let")) {
+            this.error("@config decorator must be followed by a let declaration");
+          }
+          const g = this.parseGlobalDecl(true);
+          g.configKey = decorator.args?.configKey;
+          g.configDefault = decorator.args?.configDefault;
+          globals.push(g);
+        } else if (this.check("let")) {
+          globals.push(this.parseGlobalDecl(true));
+        } else if (this.check("decorator") && this.peek().value === "@singleton") {
           this.advance();
-          symbol = "*";
+          if (!this.check("struct")) {
+            this.error("@singleton decorator must be followed by a struct declaration");
+          }
+          const s = this.parseStructDecl();
+          s.isSingleton = true;
+          structs.push(s);
+        } else if (this.check("struct")) {
+          structs.push(this.parseStructDecl());
+        } else if (this.check("impl")) {
+          implBlocks.push(this.parseImplBlock());
+        } else if (this.check("interface")) {
+          interfaces.push(this.parseInterfaceDecl());
+        } else if (this.check("enum")) {
+          enums.push(this.parseEnumDecl());
+        } else if (this.check("const")) {
+          consts.push(this.parseConstDecl());
+        } else if (this.check("declare")) {
+          this.advance();
+          this.parseDeclareStub();
+        } else if (this.check("export")) {
+          declarations.push(this.parseExportedFnDecl());
+        } else if (this.check("import") || this.check("ident") && this.peek().value === "import") {
+          this.advance();
+          const importToken = this.peek();
+          const modName = this.expect("ident").value;
+          if (this.check("::")) {
+            this.advance();
+            let symbol;
+            if (this.check("*")) {
+              this.advance();
+              symbol = "*";
+            } else {
+              symbol = this.expect("ident").value;
+            }
+            this.match(";");
+            imports.push(this.withLoc({ moduleName: modName, symbol }, importToken));
+          } else {
+            this.match(";");
+            imports.push(this.withLoc({ moduleName: modName, symbol: void 0 }, importToken));
+          }
         } else {
-          symbol = this.expect("ident").value;
+          declarations.push(this.parseFnDecl());
+        }
+      } catch (err) {
+        if (err instanceof DiagnosticError) {
+          this.parseErrors.push(err);
+          this.syncToNextDecl();
+        } else {
+          throw err;
         }
-        this.match(";");
-        imports.push(this.withLoc({ moduleName: modName, symbol }, importToken));
-      } else {
-        declarations.push(this.parseFnDecl());
       }
     }
-    return { namespace, moduleName, globals, declarations, structs, implBlocks, enums, consts, imports, isLibrary };
+    return { namespace, moduleName, globals, declarations, structs, implBlocks, enums, consts, imports, interfaces, isLibrary };
   }
   // -------------------------------------------------------------------------
   // Struct Declaration
@@ -9924,6 +10046,7 @@ var Parser = class _Parser {
   parseStructDecl() {
     const structToken = this.expect("struct");
     const name = this.expect("ident").value;
+    const extendsName = this.match("extends") ? this.expect("ident").value : void 0;
     this.expect("{");
     const fields = [];
     while (!this.check("}") && !this.check("eof")) {
@@ -9934,7 +10057,7 @@ var Parser = class _Parser {
       this.match(",");
     }
     this.expect("}");
-    return this.withLoc({ name, fields }, structToken);
+    return this.withLoc({ name, extends: extendsName, fields }, structToken);
   }
   parseEnumDecl() {
     const enumToken = this.expect("enum");
@@ -9945,6 +10068,19 @@ var Parser = class _Parser {
     while (!this.check("}") && !this.check("eof")) {
       const variantToken = this.expect("ident");
       const variant = { name: variantToken.value };
+      if (this.check("(")) {
+        this.advance();
+        const fields = [];
+        while (!this.check(")") && !this.check("eof")) {
+          const fieldName = this.expect("ident").value;
+          this.expect(":");
+          const fieldType = this.parseType();
+          fields.push({ name: fieldName, type: fieldType });
+          if (!this.match(",")) break;
+        }
+        this.expect(")");
+        variant.fields = fields;
+      }
       if (this.match("=")) {
         const valueToken = this.expect("int_lit");
         variant.value = parseInt(valueToken.value, 10);
@@ -9962,14 +10098,72 @@ var Parser = class _Parser {
   }
   parseImplBlock() {
     const implToken = this.expect("impl");
-    const typeName = this.expect("ident").value;
+    let traitName;
+    let typeName;
+    const firstName = this.expect("ident").value;
+    if (this.match("for")) {
+      traitName = firstName;
+      typeName = this.expect("ident").value;
+    } else {
+      typeName = firstName;
+    }
     this.expect("{");
     const methods = [];
     while (!this.check("}") && !this.check("eof")) {
       methods.push(this.parseFnDecl(typeName));
     }
     this.expect("}");
-    return this.withLoc({ kind: "impl_block", typeName, methods }, implToken);
+    return this.withLoc({ kind: "impl_block", traitName, typeName, methods }, implToken);
+  }
+  /**
+   * Parse an interface declaration:
+   *   interface <Name> {
+   *     fn <method>(<params>): <retType>
+   *     ...
+   *   }
+   * Method signatures have no body — they are prototype-only.
+   */
+  parseInterfaceDecl() {
+    const ifaceToken = this.expect("interface");
+    const name = this.expect("ident").value;
+    this.expect("{");
+    const methods = [];
+    while (!this.check("}") && !this.check("eof")) {
+      const fnToken = this.expect("fn");
+      const methodName = this.expect("ident").value;
+      this.expect("(");
+      const params = this.parseInterfaceParams();
+      this.expect(")");
+      let returnType;
+      if (this.match(":")) {
+        returnType = this.parseType();
+      }
+      methods.push(this.withLoc({ name: methodName, params, returnType }, fnToken));
+    }
+    this.expect("}");
+    return this.withLoc({ name, methods }, ifaceToken);
+  }
+  /**
+   * Parse interface method params — like parseParams but allows bare `self`
+   * (no `:` required for the first param named 'self').
+   */
+  parseInterfaceParams() {
+    const params = [];
+    if (!this.check(")")) {
+      do {
+        const paramToken = this.expect("ident");
+        const paramName = paramToken.value;
+        let type;
+        if (params.length === 0 && paramName === "self" && !this.check(":")) {
+          type = { kind: "named", name: "void" };
+        } else {
+          this.expect(":");
+          type = this.parseType();
+        }
+        params.push(this.withLoc({ name: paramName, type }, paramToken));
+      } while (this.match(","));
+    }
+    return params;
   }
   parseConstDecl() {
     const constToken = this.expect("const");
@@ -9989,8 +10183,12 @@ var Parser = class _Parser {
     const name = this.expect("ident").value;
     this.expect(":");
     const type = this.parseType();
-    this.expect("=");
-    const init = this.parseExpr();
+    let init;
+    if (this.match("=")) {
+      init = this.parseExpr();
+    } else {
+      init = { kind: "int_lit", value: 0 };
+    }
     this.match(";");
     return this.withLoc({ kind: "global", name, type, init, mutable }, token);
   }
@@ -10006,6 +10204,7 @@ var Parser = class _Parser {
   }
   parseFnDecl(implTypeName) {
     const decorators = this.parseDecorators();
+    const watchObjective = decorators.find((decorator) => decorator.name === "watch")?.args?.objective;
     let isExported;
     const filteredDecorators = decorators.filter((d) => {
       if (d.name === "keep") {
@@ -10043,7 +10242,8 @@ var Parser = class _Parser {
         decorators: filteredDecorators,
         body,
         isLibraryFn: this.inLibraryMode || void 0,
-        isExported
+        isExported,
+        watchObjective
       },
       fnToken
     );
@@ -10076,7 +10276,7 @@ var Parser = class _Parser {
     return decorators;
   }
   parseDecoratorValue(value) {
-    const match = value.match(/^@(\w+)(?:\(([^)]*)\))?$/);
+    const match = value.match(/^@([A-Za-z_][A-Za-z0-9_-]*)(?:\((.*)\))?$/s);
     if (!match) {
       this.error(`Invalid decorator: ${value}`);
     }
@@ -10085,6 +10285,9 @@ var Parser = class _Parser {
     if (!argsStr) {
       return { name };
     }
+    if (name === "profile" || name === "benchmark" || name === "memoize") {
+      this.error(`@${name} decorator does not accept arguments`);
+    }
     const args = {};
     if (name === "on") {
       const eventTypeMatch = argsStr.match(/^([A-Za-z_][A-Za-z0-9_]*)$/);
@@ -10093,10 +10296,12 @@ var Parser = class _Parser {
         return { name, args };
       }
     }
-    if (name === "on_trigger" || name === "on_advancement" || name === "on_craft" || name === "on_join_team") {
+    if (name === "watch" || name === "on_trigger" || name === "on_advancement" || name === "on_craft" || name === "on_join_team") {
       const strMatch = argsStr.match(/^"([^"]*)"$/);
       if (strMatch) {
-        if (name === "on_trigger") {
+        if (name === "watch") {
+          args.objective = strMatch[1];
+        } else if (name === "on_trigger") {
           args.trigger = strMatch[1];
         } else if (name === "on_advancement") {
           args.advancement = strMatch[1];
@@ -10108,6 +10313,31 @@ var Parser = class _Parser {
         return { name, args };
       }
     }
+    if (name === "config") {
+      const configMatch = argsStr.match(/^"([^"]+)"\s*,\s*default\s*:\s*(-?\d+(?:\.\d+)?)$/);
+      if (configMatch) {
+        return { name, args: { configKey: configMatch[1], configDefault: parseFloat(configMatch[2]) } };
+      }
+      const keyOnlyMatch = argsStr.match(/^"([^"]+)"$/);
+      if (keyOnlyMatch) {
+        return { name, args: { configKey: keyOnlyMatch[1] } };
+      }
+      this.error(`Invalid @config syntax. Expected: @config("key", default: value) or @config("key")`);
+    }
+    if (name === "deprecated") {
+      const strMatch = argsStr.match(/^"([^"]*)"$/);
+      if (strMatch) {
+        return { name, args: { message: strMatch[1] } };
+      }
+      return { name, args: {} };
+    }
+    if (name === "test") {
+      const strMatch = argsStr.match(/^"([^"]*)"$/);
+      if (strMatch) {
+        return { name, args: { testLabel: strMatch[1] } };
+      }
+      return { name, args: { testLabel: "" } };
+    }
     if (name === "require_on_load") {
       const rawArgs = [];
       for (const part of argsStr.split(",")) {
@@ -10142,6 +10372,8 @@ var Parser = class _Parser {
         args.item = val;
       } else if (key === "team") {
         args.team = val;
+      } else if (key === "max") {
+        args.max = parseInt(val, 10);
       }
     }
     return { name, args };
@@ -10245,7 +10477,16 @@ var Parser = class _Parser {
     this.expect("{");
     const stmts = [];
     while (!this.check("}") && !this.check("eof")) {
-      stmts.push(this.parseStmt());
+      try {
+        stmts.push(this.parseStmt());
+      } catch (err) {
+        if (err instanceof DiagnosticError) {
+          this.parseErrors.push(err);
+          this.syncToNextStmt();
+        } else {
+          throw err;
+        }
+      }
     }
     this.expect("}");
     return stmts;
@@ -10254,25 +10495,65 @@ var Parser = class _Parser {
     if (this.check("let")) {
       return this.parseLetStmt();
     }
+    if (this.check("const")) {
+      return this.parseLocalConstDecl();
+    }
     if (this.check("return")) {
       return this.parseReturnStmt();
     }
     if (this.check("break")) {
       const token = this.advance();
+      if (this.check("ident")) {
+        const labelToken = this.advance();
+        this.match(";");
+        return this.withLoc({ kind: "break_label", label: labelToken.value }, token);
+      }
       this.match(";");
       return this.withLoc({ kind: "break" }, token);
     }
     if (this.check("continue")) {
       const token = this.advance();
+      if (this.check("ident")) {
+        const labelToken = this.advance();
+        this.match(";");
+        return this.withLoc({ kind: "continue_label", label: labelToken.value }, token);
+      }
       this.match(";");
       return this.withLoc({ kind: "continue" }, token);
     }
     if (this.check("if")) {
       return this.parseIfStmt();
     }
+    if (this.check("ident") && this.peek(1).kind === ":") {
+      const labelToken = this.advance();
+      const colonToken = this.advance();
+      let loopStmt;
+      if (this.check("while")) {
+        loopStmt = this.parseWhileStmt();
+      } else if (this.check("for")) {
+        loopStmt = this.parseForStmt();
+      } else if (this.check("foreach")) {
+        loopStmt = this.parseForeachStmt();
+      } else if (this.check("repeat")) {
+        loopStmt = this.parseRepeatStmt();
+      } else {
+        throw new DiagnosticError(
+          "ParseError",
+          `Expected loop statement after label '${labelToken.value}:', found '${this.peek().kind}'`,
+          { line: labelToken.line, col: labelToken.col }
+        );
+      }
+      return this.withLoc({ kind: "labeled_loop", label: labelToken.value, body: loopStmt }, labelToken);
+    }
     if (this.check("while")) {
       return this.parseWhileStmt();
     }
+    if (this.check("do")) {
+      return this.parseDoWhileStmt();
+    }
+    if (this.check("repeat")) {
+      return this.parseRepeatStmt();
+    }
     if (this.check("for")) {
       return this.parseForStmt();
     }
@@ -10327,6 +10608,16 @@ var Parser = class _Parser {
     this.match(";");
     return this.withLoc({ kind: "let", name, type, init }, letToken);
   }
+  parseLocalConstDecl() {
+    const constToken = this.expect("const");
+    const name = this.expect("ident").value;
+    this.expect(":");
+    const type = this.parseType();
+    this.expect("=");
+    const value = this.parseExpr();
+    this.match(";");
+    return this.withLoc({ kind: "const_decl", name, type, value }, constToken);
+  }
   parseReturnStmt() {
     const returnToken = this.expect("return");
     let value;
@@ -10357,9 +10648,7 @@ var Parser = class _Parser {
       }
       return this.withLoc({ kind: "if_let_some", binding, init, then: then2, else_: else_2 }, ifToken);
     }
-    this.expect("(");
-    const cond = this.parseExpr();
-    this.expect(")");
+    const cond = this.parseParenOptionalCond();
     const then = this.parseBlock();
     let else_;
     if (this.match("else")) {
@@ -10373,12 +10662,44 @@ var Parser = class _Parser {
   }
   parseWhileStmt() {
     const whileToken = this.expect("while");
-    this.expect("(");
-    const cond = this.parseExpr();
-    this.expect(")");
+    if (this.check("let") && this.peek(1).kind === "ident" && this.peek(1).value === "Some") {
+      this.advance();
+      this.advance();
+      this.expect("(");
+      const binding = this.expect("ident").value;
+      this.expect(")");
+      this.expect("=");
+      const init = this.parseExpr();
+      const body2 = this.parseBlock();
+      return this.withLoc({ kind: "while_let_some", binding, init, body: body2 }, whileToken);
+    }
+    const cond = this.parseParenOptionalCond();
     const body = this.parseBlock();
     return this.withLoc({ kind: "while", cond, body }, whileToken);
   }
+  parseDoWhileStmt() {
+    const doToken = this.expect("do");
+    const body = this.parseBlock();
+    this.expect("while");
+    const cond = this.parseParenOptionalCond();
+    this.match(";");
+    return this.withLoc({ kind: "do_while", cond, body }, doToken);
+  }
+  parseRepeatStmt() {
+    const repeatToken = this.expect("repeat");
+    const countToken = this.expect("int_lit");
+    const count = parseInt(countToken.value, 10);
+    const body = this.parseBlock();
+    return this.withLoc({ kind: "repeat", count, body }, repeatToken);
+  }
+  parseParenOptionalCond() {
+    if (this.match("(")) {
+      const cond = this.parseExpr();
+      this.expect(")");
+      return cond;
+    }
+    return this.parseExpr();
+  }
   parseForStmt() {
     const forToken = this.expect("for");
     if (this.check("ident") && this.peek(1).kind === "in") {
@@ -10495,6 +10816,21 @@ var Parser = class _Parser {
       this.expect(")");
       return { kind: "PatSome", binding };
     }
+    if (this.check("ident") && this.peek(1).kind === "::") {
+      const enumName = this.advance().value;
+      this.expect("::");
+      const variant = this.expect("ident").value;
+      const bindings = [];
+      if (this.check("(")) {
+        this.advance();
+        while (!this.check(")") && !this.check("eof")) {
+          bindings.push(this.expect("ident").value);
+          if (!this.match(",")) break;
+        }
+        this.expect(")");
+      }
+      return { kind: "PatEnum", enumName, variant, bindings };
+    }
     if (this.check("int_lit")) {
       const tok = this.advance();
       return { kind: "PatInt", value: parseInt(tok.value, 10) };
@@ -10838,6 +11174,15 @@ var Parser = class _Parser {
           continue;
         }
         if (expr.kind === "member") {
+          if (expr.field === "unwrap_or") {
+            const defaultExpr = this.parseExpr();
+            this.expect(")");
+            expr = this.withLoc(
+              { kind: "unwrap_or", opt: expr.obj, default_: defaultExpr },
+              this.getLocToken(expr) ?? openParenToken
+            );
+            continue;
+          }
           const methodMap = {
             "tag": "__entity_tag",
             "untag": "__entity_untag",
@@ -10930,6 +11275,20 @@ var Parser = class _Parser {
       this.expect("::");
       const memberToken = this.expect("ident");
       if (this.check("(")) {
+        const isNamedArgs = this.peek(1).kind === "ident" && this.peek(2).kind === ":";
+        if (isNamedArgs) {
+          this.advance();
+          const args2 = [];
+          while (!this.check(")") && !this.check("eof")) {
+            const fieldName = this.expect("ident").value;
+            this.expect(":");
+            const value = this.parseExpr();
+            args2.push({ name: fieldName, value });
+            if (!this.match(",")) break;
+          }
+          this.expect(")");
+          return this.withLoc({ kind: "enum_construct", enumName: typeToken.value, variant: memberToken.value, args: args2 }, typeToken);
+        }
         this.advance();
         const args = this.parseArgs();
         this.expect(")");
@@ -11611,6 +11970,49 @@ function toTypeNode(typeName) {
   return { kind: "struct", name: typeName };
 }
 
+// ../../src/structs/expand.ts
+function expandStructDeclarations(structs, onError) {
+  const expandedByName = /* @__PURE__ */ new Map();
+  const expanded = [];
+  for (const struct of structs) {
+    const inheritedFields = [];
+    const seenFieldNames = /* @__PURE__ */ new Set();
+    if (struct.extends) {
+      const parent = expandedByName.get(struct.extends);
+      if (!parent) {
+        onError?.({
+          message: `Struct '${struct.name}' extends unknown struct '${struct.extends}'`,
+          node: struct
+        });
+      } else {
+        for (const field of parent.fields) {
+          inheritedFields.push(field);
+          seenFieldNames.add(field.name);
+        }
+      }
+    }
+    const ownFields = [];
+    for (const field of struct.fields) {
+      if (seenFieldNames.has(field.name)) {
+        onError?.({
+          message: `Struct '${struct.name}' cannot override inherited field '${field.name}'`,
+          node: struct
+        });
+        continue;
+      }
+      seenFieldNames.add(field.name);
+      ownFields.push(field);
+    }
+    const resolved = {
+      ...struct,
+      fields: [...inheritedFields, ...ownFields]
+    };
+    expanded.push(resolved);
+    expandedByName.set(struct.name, resolved);
+  }
+  return expanded;
+}
+
 // ../../src/typechecker/index.ts
 var ENTITY_HIERARCHY = {
   "entity": null,
@@ -11693,8 +12095,11 @@ var MC_TYPE_TO_ENTITY = {
 var VOID_TYPE = { kind: "named", name: "void" };
 var INT_TYPE = { kind: "named", name: "int" };
 var STRING_TYPE = { kind: "named", name: "string" };
-var FORMAT_STRING_TYPE = { kind: "named", name: "format_string" };
 var BUILTIN_SIGNATURES = {
+  assert: {
+    params: [{ kind: "named", name: "bool" }],
+    return: VOID_TYPE
+  },
   setTimeout: {
     params: [INT_TYPE, { kind: "function_type", params: [], return: VOID_TYPE }],
     return: VOID_TYPE
@@ -11706,15 +12111,25 @@ var BUILTIN_SIGNATURES = {
   clearInterval: {
     params: [INT_TYPE],
     return: VOID_TYPE
+  },
+  int_to_str: {
+    params: [INT_TYPE],
+    return: STRING_TYPE
+  },
+  bool_to_str: {
+    params: [{ kind: "named", name: "bool" }],
+    return: STRING_TYPE
   }
 };
-var TypeChecker = class {
+var TypeChecker = class _TypeChecker {
   constructor(source, filePath) {
     this.lintWarnings = [];
     this.functions = /* @__PURE__ */ new Map();
     this.implMethods = /* @__PURE__ */ new Map();
     this.structs = /* @__PURE__ */ new Map();
     this.enums = /* @__PURE__ */ new Map();
+    // enumName → variantName → field list (for payload variants)
+    this.enumPayloads = /* @__PURE__ */ new Map();
     this.consts = /* @__PURE__ */ new Map();
     this.globals = /* @__PURE__ */ new Map();
     this.currentFn = null;
@@ -11725,6 +12140,8 @@ var TypeChecker = class {
     // Depth of loop/conditional nesting (for static-allocation enforcement)
     this.loopDepth = 0;
     this.condDepth = 0;
+    // interface name → InterfaceDecl
+    this.interfaces = /* @__PURE__ */ new Map();
     this.richTextBuiltins = /* @__PURE__ */ new Map([
       ["say", { messageIndex: 0 }],
       ["announce", { messageIndex: 0 }],
@@ -11766,6 +12183,9 @@ var TypeChecker = class {
     for (const fn of program.declarations) {
       this.functions.set(fn.name, fn);
     }
+    for (const iface of program.interfaces ?? []) {
+      this.interfaces.set(iface.name, iface);
+    }
     for (const global of program.globals ?? []) {
       this.globals.set(global.name, this.normalizeType(global.type));
     }
@@ -11789,19 +12209,56 @@ var TypeChecker = class {
         methods.set(method.name, method);
       }
     }
-    for (const struct of program.structs ?? []) {
+    const expandedStructs = expandStructDeclarations(program.structs ?? [], ({ message, node }) => {
+      this.report(message, node);
+    });
+    for (const struct of expandedStructs) {
       const fields = /* @__PURE__ */ new Map();
       for (const field of struct.fields) {
         fields.set(field.name, field.type);
       }
       this.structs.set(struct.name, fields);
+      if (struct.isSingleton) {
+        const structType = { kind: "struct", name: struct.name };
+        let singletonMethods = this.implMethods.get(struct.name);
+        if (!singletonMethods) {
+          singletonMethods = /* @__PURE__ */ new Map();
+          this.implMethods.set(struct.name, singletonMethods);
+        }
+        const voidType = { kind: "named", name: "void" };
+        singletonMethods.set("get", {
+          name: "get",
+          params: [],
+          returnType: structType,
+          decorators: [],
+          body: [],
+          typeParams: void 0,
+          isLibraryFn: true
+        });
+        singletonMethods.set("set", {
+          name: "set",
+          params: [{ name: "gs", type: structType }],
+          returnType: voidType,
+          decorators: [],
+          body: [],
+          typeParams: void 0,
+          isLibraryFn: true
+        });
+      }
     }
     for (const enumDecl of program.enums ?? []) {
       const variants = /* @__PURE__ */ new Map();
+      const payloads = /* @__PURE__ */ new Map();
       for (const variant of enumDecl.variants) {
         variants.set(variant.name, variant.value ?? 0);
+        if (variant.fields && variant.fields.length > 0) {
+          payloads.set(variant.name, variant.fields);
+        }
       }
       this.enums.set(enumDecl.name, variants);
+      if (payloads.size > 0) {
+        this.enumPayloads.set(enumDecl.name, payloads);
+      }
     }
     for (const constDecl of program.consts ?? []) {
       const constType = this.normalizeType(constDecl.type);
@@ -11814,6 +12271,21 @@ var TypeChecker = class {
       }
       this.consts.set(constDecl.name, constType);
     }
+    for (const implBlock of program.implBlocks ?? []) {
+      if (!implBlock.traitName) continue;
+      const iface = this.interfaces.get(implBlock.traitName);
+      if (!iface) continue;
+      const implementedMethods = new Set(implBlock.methods.map((m) => m.name));
+      for (const required of iface.methods) {
+        if (!implementedMethods.has(required.name)) {
+          const span = implBlock.span ?? required.span;
+          this.report(
+            `Struct '${implBlock.typeName}' does not implement required method '${required.name}' from interface '${implBlock.traitName}'`,
+            span ?? { line: 1, col: 1 }
+          );
+        }
+      }
+    }
     for (const fn of program.declarations) {
       this.checkFunction(fn);
     }
@@ -11859,6 +12331,77 @@ var TypeChecker = class {
     this.currentReturnType = null;
   }
   checkFunctionDecorators(fn) {
+    const watchDecorators = fn.decorators.filter((decorator) => decorator.name === "watch");
+    if (watchDecorators.length > 1) {
+      this.report(`Function '${fn.name}' cannot have multiple @watch decorators`, fn);
+      return;
+    }
+    if (watchDecorators.length === 1) {
+      const objective = watchDecorators[0].args?.objective;
+      if (!objective) {
+        this.report(`Function '${fn.name}' is missing a scoreboard objective in @watch("...")`, fn);
+        return;
+      }
+      if (fn.params.length > 0) {
+        this.report(`@watch handler '${fn.name}' cannot declare parameters`, fn);
+      }
+    }
+    const throttleDecorators = fn.decorators.filter((decorator) => decorator.name === "throttle");
+    if (throttleDecorators.length > 1) {
+      this.report(`Function '${fn.name}' cannot have multiple @throttle decorators`, fn);
+      return;
+    }
+    if (throttleDecorators.length === 1) {
+      const ticks = throttleDecorators[0].args?.ticks;
+      if (ticks === void 0 || ticks <= 0) {
+        this.report(`@throttle on '${fn.name}' requires ticks=N (positive integer)`, fn);
+      }
+    }
+    const retryDecorators = fn.decorators.filter((decorator) => decorator.name === "retry");
+    if (retryDecorators.length > 1) {
+      this.report(`Function '${fn.name}' cannot have multiple @retry decorators`, fn);
+      return;
+    }
+    if (retryDecorators.length === 1) {
+      const max = retryDecorators[0].args?.max;
+      if (max === void 0 || max <= 0) {
+        this.report(`@retry on '${fn.name}' requires max=N (positive integer)`, fn);
+      }
+    }
+    const profileDecorators = fn.decorators.filter((decorator) => decorator.name === "profile");
+    if (profileDecorators.length > 1) {
+      this.report(`Function '${fn.name}' cannot have multiple @profile decorators`, fn);
+      return;
+    }
+    if (profileDecorators.length === 1 && (profileDecorators[0].rawArgs?.length || profileDecorators[0].args && Object.keys(profileDecorators[0].args).length > 0)) {
+      this.report(`@profile decorator on '${fn.name}' does not accept arguments`, fn);
+      return;
+    }
+    const benchmarkDecorators = fn.decorators.filter((decorator) => decorator.name === "benchmark");
+    if (benchmarkDecorators.length > 1) {
+      this.report(`Function '${fn.name}' cannot have multiple @benchmark decorators`, fn);
+      return;
+    }
+    if (benchmarkDecorators.length === 1 && (benchmarkDecorators[0].rawArgs?.length || benchmarkDecorators[0].args && Object.keys(benchmarkDecorators[0].args).length > 0)) {
+      this.report(`@benchmark decorator on '${fn.name}' does not accept arguments`, fn);
+      return;
+    }
+    const memoizeDecorators = fn.decorators.filter((decorator) => decorator.name === "memoize");
+    if (memoizeDecorators.length > 1) {
+      this.report(`Function '${fn.name}' cannot have multiple @memoize decorators`, fn);
+      return;
+    }
+    if (memoizeDecorators.length === 1) {
+      if (fn.params.length !== 1) {
+        this.report(`@memoize on '${fn.name}' requires exactly one parameter`, fn);
+      } else {
+        const paramType = fn.params[0].type;
+        const isInt = paramType.kind === "named" && paramType.name === "int";
+        if (!isInt) {
+          this.report(`@memoize on '${fn.name}' only supports int parameters (got '${paramType.kind === "named" ? paramType.name : paramType.kind}')`, fn);
+        }
+      }
+    }
     const eventDecorators = fn.decorators.filter((decorator) => decorator.name === "on");
     if (eventDecorators.length === 0) {
       return;
@@ -11968,8 +12511,21 @@ var TypeChecker = class {
             if (!isUnknown(subjectType) && !isUnknown(patternType) && !this.typesMatch(subjectType, patternType)) {
               this.report("Match arm pattern type must match subject type", arm.pattern.expr);
             }
+            this.checkBlock(arm.body);
+          } else if (arm.pattern.kind === "PatEnum") {
+            const pat = arm.pattern;
+            const variantPayloads = this.enumPayloads.get(pat.enumName)?.get(pat.variant) ?? [];
+            const savedScope = new Map(this.scope);
+            for (let i = 0; i < pat.bindings.length; i++) {
+              const fieldDef = variantPayloads[i];
+              const bindingType = fieldDef ? fieldDef.type : { kind: "named", name: "int" };
+              this.scope.set(pat.bindings[i], { type: bindingType, mutable: false });
+            }
+            this.checkBlock(arm.body);
+            this.scope = savedScope;
+          } else {
+            this.checkBlock(arm.body);
           }
-          this.checkBlock(arm.body);
         }
         break;
       case "as_block": {
@@ -12008,6 +12564,19 @@ var TypeChecker = class {
         break;
       case "raw":
         break;
+      case "break":
+      case "continue":
+      case "break_label":
+      case "continue_label":
+        break;
+      case "labeled_loop":
+        this.loopDepth++;
+        this.checkStmt(stmt.body);
+        this.loopDepth--;
+        break;
+      case "const_decl":
+        this.scope.set(stmt.name, { type: stmt.type, mutable: false });
+        break;
     }
   }
   checkLetDestructStmt(stmt) {
@@ -12182,15 +12751,41 @@ var TypeChecker = class {
         break;
       case "struct_lit":
         for (const field of expr.fields) {
-          this.checkExpr(field.value);
-        }
-        break;
-      case "str_interp":
-        for (const part of expr.parts) {
-          if (typeof part !== "string") {
-            this.checkExpr(part);
-          }
-        }
+          let fieldType;
+          if (expectedType) {
+            const normalized = this.normalizeType(expectedType);
+            if (normalized.kind === "struct") {
+              const structFields = this.structs.get(normalized.name);
+              if (structFields && !structFields.has(field.name)) {
+                this.report(`Struct '${normalized.name}' has no field '${field.name}'`, expr);
+              } else {
+                fieldType = structFields?.get(field.name);
+              }
+            }
+          }
+          this.checkExpr(field.value, fieldType);
+          if (fieldType) {
+            const actualType = this.inferType(field.value, fieldType);
+            if (this.isNumericMismatch(fieldType, actualType)) {
+              this.report(
+                `Field '${field.name}' of struct expects ${this.typeToString(fieldType)}, got ${this.typeToString(actualType)}`,
+                field.value
+              );
+            } else if (!this.typesMatch(fieldType, actualType)) {
+              this.report(
+                `Field '${field.name}' of struct expects ${this.typeToString(fieldType)}, got ${this.typeToString(actualType)}`,
+                field.value
+              );
+            }
+          }
+        }
+        break;
+      case "str_interp":
+        for (const part of expr.parts) {
+          if (typeof part !== "string") {
+            this.checkExpr(part);
+          }
+        }
         break;
       case "f_string":
         for (const part of expr.parts) {
@@ -12234,6 +12829,31 @@ var TypeChecker = class {
           }
         }
         break;
+      case "enum_construct": {
+        if (!this.enums.has(expr.enumName)) {
+          this.report(`Unknown enum '${expr.enumName}'`, expr);
+          break;
+        }
+        const variants = this.enums.get(expr.enumName);
+        if (!variants.has(expr.variant)) {
+          this.report(`Enum '${expr.enumName}' has no variant '${expr.variant}'`, expr);
+          break;
+        }
+        const variantPayloads = this.enumPayloads.get(expr.enumName)?.get(expr.variant) ?? [];
+        if (variantPayloads.length === 0 && expr.args.length > 0) {
+          this.report(`Enum variant '${expr.enumName}::${expr.variant}' has no payload fields`, expr);
+          break;
+        }
+        for (const arg of expr.args) {
+          const fieldDef = variantPayloads.find((f) => f.name === arg.name);
+          if (!fieldDef) {
+            this.report(`Unknown field '${arg.name}' for enum variant '${expr.enumName}::${expr.variant}'`, expr);
+          } else {
+            this.checkExpr(arg.value, fieldDef.type);
+          }
+        }
+        break;
+      }
       case "blockpos":
         break;
       // Literals don't need checking
@@ -12345,7 +12965,7 @@ var TypeChecker = class {
       return;
     }
     const messageType = this.inferType(message);
-    if (messageType.kind !== "named" || messageType.name !== "string" && messageType.name !== "format_string") {
+    if (messageType.kind !== "named" || messageType.name !== "string") {
       this.report(
         `Argument ${messageIndex + 1} of '${expr.fn}' expects string or format_string, got ${this.typeToString(messageType)}`,
         message
@@ -12570,7 +13190,7 @@ var TypeChecker = class {
             this.checkExpr(part.expr);
           }
         }
-        return FORMAT_STRING_TYPE;
+        return STRING_TYPE;
       case "blockpos":
         return { kind: "named", name: "BlockPos" };
       case "ident":
@@ -12630,6 +13250,11 @@ var TypeChecker = class {
           return { kind: "enum", name: expr.enumName };
         }
         return { kind: "named", name: "void" };
+      case "enum_construct":
+        if (this.enums.has(expr.enumName)) {
+          return { kind: "enum", name: expr.enumName };
+        }
+        return { kind: "named", name: "void" };
       case "member":
         if (expr.obj.kind === "ident" && this.enums.has(expr.obj.name)) {
           return { kind: "enum", name: expr.obj.name };
@@ -12735,6 +13360,21 @@ var TypeChecker = class {
     }
     return "entity";
   }
+  static {
+    // Reverse map: parser sometimes remaps method names (e.g. add→set_add) for builtins.
+    // When the receiver is a struct with an impl method matching the original name, use that.
+    this.PARSER_METHOD_REMAP = {
+      "set_add": "add",
+      "set_contains": "contains",
+      "set_remove": "remove",
+      "set_clear": "clear",
+      "__array_push": "push",
+      "__array_pop": "pop",
+      "__entity_tag": "tag",
+      "__entity_untag": "untag",
+      "__entity_has_tag": "has_tag"
+    };
+  }
   resolveInstanceMethod(expr) {
     const receiver = expr.args[0];
     if (!receiver) {
@@ -12744,7 +13384,8 @@ var TypeChecker = class {
     if (receiverType.kind !== "struct") {
       return null;
     }
-    const method = this.implMethods.get(receiverType.name)?.get(expr.fn);
+    const methodName = _TypeChecker.PARSER_METHOD_REMAP[expr.fn] ?? expr.fn;
+    const method = this.implMethods.get(receiverType.name)?.get(expr.fn) ?? this.implMethods.get(receiverType.name)?.get(methodName);
     if (!method || method.params[0]?.name !== "self") {
       return null;
     }
@@ -12813,6 +13454,9 @@ var TypeChecker = class {
     if (expected.kind === "selector" && actual.kind === "selector") {
       return true;
     }
+    if (expected.kind === "selector" && actual.kind === "named" && actual.name === "string") {
+      return true;
+    }
     if (expected.kind !== actual.kind) return false;
     if (expected.kind === "named" && actual.kind === "named") {
       if (actual.name === "void") return true;
@@ -13822,132 +14466,1938 @@ var BUILTIN_METADATA = {
   }
 };
 
-// ../../src/lsp/server.ts
-var connection = (0, import_node.createConnection)(import_node.ProposedFeatures.all);
-var documents = new import_node.TextDocuments(TextDocument);
-function loadBuiltinsFromDeclFile() {
-  const extra = {};
-  const candidates = [
-    path.resolve(__dirname, "../../builtins.d.mcrs"),
-    path.resolve(__dirname, "../../../builtins.d.mcrs"),
-    path.resolve(__dirname, "../../../../builtins.d.mcrs")
-  ];
-  let src = "";
-  for (const p of candidates) {
-    if (fs.existsSync(p)) {
-      src = fs.readFileSync(p, "utf-8");
-      break;
+// ../../src/hir/lower.ts
+function lowerToHIR(program) {
+  const structs = expandStructDeclarations(program.structs).map((s) => ({
+    name: s.name,
+    extends: s.extends,
+    fields: s.fields.map((f) => ({ name: f.name, type: f.type })),
+    isSingleton: s.isSingleton,
+    span: s.span
+  }));
+  return {
+    namespace: program.namespace,
+    globals: program.globals.map(lowerGlobal),
+    functions: program.declarations.map(lowerFunction),
+    structs,
+    implBlocks: program.implBlocks.map((ib) => ({
+      typeName: ib.typeName,
+      traitName: ib.traitName,
+      methods: ib.methods.map(lowerFunction),
+      span: ib.span
+    })),
+    enums: program.enums.map((e) => ({
+      name: e.name,
+      variants: e.variants.map((v) => ({ name: v.name, value: v.value, fields: v.fields })),
+      span: e.span
+    })),
+    consts: program.consts.map((c) => ({
+      name: c.name,
+      type: c.type,
+      value: lowerExpr(c.value),
+      span: c.span
+    })),
+    isLibrary: program.isLibrary
+  };
+}
+function lowerMatchPattern(pat) {
+  switch (pat.kind) {
+    case "PatSome":
+      return pat;
+    case "PatNone":
+      return pat;
+    case "PatInt":
+      return pat;
+    case "PatWild":
+      return pat;
+    case "PatExpr":
+      return { kind: "PatExpr", expr: lowerExpr(pat.expr) };
+    case "PatEnum":
+      return { kind: "PatEnum", enumName: pat.enumName, variant: pat.variant, bindings: pat.bindings };
+  }
+}
+function lowerGlobal(g) {
+  return {
+    name: g.name,
+    type: g.type,
+    init: lowerExpr(g.init),
+    mutable: g.mutable,
+    span: g.span
+  };
+}
+function lowerFunction(fn) {
+  return {
+    name: fn.name,
+    typeParams: fn.typeParams,
+    params: fn.params.map(lowerParam),
+    returnType: fn.returnType,
+    decorators: fn.decorators,
+    body: lowerBlock(fn.body),
+    isLibraryFn: fn.isLibraryFn,
+    isExported: fn.isExported,
+    span: fn.span,
+    sourceFile: fn.sourceFile,
+    watchObjective: fn.watchObjective
+  };
+}
+function lowerParam(p) {
+  return {
+    name: p.name,
+    type: p.type,
+    default: p.default ? lowerExpr(p.default) : void 0
+  };
+}
+function lowerBlock(block) {
+  const result = [];
+  for (const stmt of block) {
+    const lowered = lowerStmt(stmt);
+    if (Array.isArray(lowered)) {
+      result.push(...lowered);
+    } else {
+      result.push(lowered);
     }
   }
-  if (!src) return extra;
-  const lines = src.split("\n");
-  let docLines = [];
-  let paramDocs = {};
-  for (const line of lines) {
-    const tripleDoc = line.match(/^\/\/\/\s?(.*)$/);
-    if (tripleDoc) {
-      const content = tripleDoc[1];
-      const paramMatch = content.match(/^@param\s+(\w+)\s+(.+)$/);
-      if (paramMatch) {
-        paramDocs[paramMatch[1]] = paramMatch[2];
-      } else if (!content.startsWith("@example")) {
-        docLines.push(content);
-      }
-      continue;
+  return result;
+}
+function lowerStmt(stmt) {
+  switch (stmt.kind) {
+    case "let":
+      return { kind: "let", name: stmt.name, type: stmt.type, init: lowerExpr(stmt.init), span: stmt.span };
+    case "let_destruct":
+      return { kind: "let_destruct", names: stmt.names, type: stmt.type, init: lowerExpr(stmt.init), span: stmt.span };
+    case "const_decl":
+      return { kind: "const_decl", name: stmt.name, type: stmt.type, value: lowerExpr(stmt.value), span: stmt.span };
+    case "expr":
+      return { kind: "expr", expr: lowerExpr(stmt.expr), span: stmt.span };
+    case "return":
+      return { kind: "return", value: stmt.value ? lowerExpr(stmt.value) : void 0, span: stmt.span };
+    case "break":
+      return { kind: "break", span: stmt.span };
+    case "continue":
+      return { kind: "continue", span: stmt.span };
+    case "break_label":
+      return { kind: "break_label", label: stmt.label, span: stmt.span };
+    case "continue_label":
+      return { kind: "continue_label", label: stmt.label, span: stmt.span };
+    case "labeled_loop": {
+      const lowered = lowerStmt(stmt.body);
+      if (Array.isArray(lowered)) {
+        const inits = lowered.slice(0, -1);
+        const loopStmt = lowered[lowered.length - 1];
+        const labeled = { kind: "labeled_loop", label: stmt.label, body: loopStmt, span: stmt.span };
+        return [...inits, labeled];
+      }
+      return { kind: "labeled_loop", label: stmt.label, body: lowered, span: stmt.span };
+    }
+    case "if":
+      return {
+        kind: "if",
+        cond: lowerExpr(stmt.cond),
+        then: lowerBlock(stmt.then),
+        else_: stmt.else_ ? lowerBlock(stmt.else_) : void 0,
+        span: stmt.span
+      };
+    case "while":
+      return { kind: "while", cond: lowerExpr(stmt.cond), body: lowerBlock(stmt.body), span: stmt.span };
+    // --- Desugaring: for → while ---
+    case "for": {
+      const stmts = [];
+      if (stmt.init) {
+        const init = lowerStmt(stmt.init);
+        if (Array.isArray(init)) stmts.push(...init);
+        else stmts.push(init);
+      }
+      const body = lowerBlock(stmt.body);
+      const step = [{ kind: "expr", expr: lowerExpr(stmt.step), span: stmt.span }];
+      stmts.push({ kind: "while", cond: lowerExpr(stmt.cond), body, step, span: stmt.span });
+      return stmts;
+    }
+    // --- Desugaring: for_range → let + while(cond) { body } step { v++ } ---
+    case "for_range": {
+      const varName = stmt.varName;
+      const initStmt = {
+        kind: "let",
+        name: varName,
+        type: { kind: "named", name: "int" },
+        init: lowerExpr(stmt.start),
+        span: stmt.span
+      };
+      const body = lowerBlock(stmt.body);
+      const step = [{
+        kind: "expr",
+        expr: {
+          kind: "assign",
+          target: varName,
+          value: {
+            kind: "binary",
+            op: "+",
+            left: { kind: "ident", name: varName },
+            right: { kind: "int_lit", value: 1 }
+          }
+        }
+      }];
+      const whileStmt = {
+        kind: "while",
+        cond: {
+          kind: "binary",
+          op: stmt.inclusive ? "<=" : "<",
+          left: { kind: "ident", name: varName },
+          right: lowerExpr(stmt.end)
+        },
+        body,
+        step,
+        span: stmt.span
+      };
+      return [initStmt, whileStmt];
+    }
+    // --- Desugaring: for_in_array → let idx = 0; while(idx < len) { let v = arr[idx]; body; idx = idx + 1 } ---
+    case "for_in_array": {
+      const idxName = `__forin_idx_${stmt.binding}`;
+      const initStmt = {
+        kind: "let",
+        name: idxName,
+        type: { kind: "named", name: "int" },
+        init: { kind: "int_lit", value: 0 },
+        span: stmt.span
+      };
+      const bindingInit = {
+        kind: "let",
+        name: stmt.binding,
+        type: void 0,
+        init: {
+          kind: "index",
+          obj: { kind: "ident", name: stmt.arrayName },
+          index: { kind: "ident", name: idxName }
+        },
+        span: stmt.span
+      };
+      const stepStmt = {
+        kind: "expr",
+        expr: {
+          kind: "assign",
+          target: idxName,
+          value: {
+            kind: "binary",
+            op: "+",
+            left: { kind: "ident", name: idxName },
+            right: { kind: "int_lit", value: 1 }
+          }
+        },
+        span: stmt.span
+      };
+      const body = [bindingInit, ...lowerBlock(stmt.body)];
+      const step = [stepStmt];
+      const whileStmt = {
+        kind: "while",
+        cond: {
+          kind: "binary",
+          op: "<",
+          left: { kind: "ident", name: idxName },
+          right: lowerExpr(stmt.lenExpr)
+        },
+        body,
+        step,
+        span: stmt.span
+      };
+      return [initStmt, whileStmt];
+    }
+    // --- Desugaring: for_each → let __for_len = arr.len(); let __for_i = 0; while(__for_i < __for_len) { let item = arr[__for_i]; body; __for_i = __for_i + 1 } ---
+    case "for_each": {
+      const id = forEachCounter++;
+      const idxName = `__foreach_i_${id}`;
+      const lenName = `__foreach_len_${id}`;
+      const arrExpr = lowerExpr(stmt.array);
+      const lenInitStmt = {
+        kind: "let",
+        name: lenName,
+        type: { kind: "named", name: "int" },
+        init: {
+          kind: "invoke",
+          callee: { kind: "member", obj: arrExpr, field: "len" },
+          args: []
+        },
+        span: stmt.span
+      };
+      const idxInitStmt = {
+        kind: "let",
+        name: idxName,
+        type: { kind: "named", name: "int" },
+        init: { kind: "int_lit", value: 0 },
+        span: stmt.span
+      };
+      const bindingInit = {
+        kind: "let",
+        name: stmt.binding,
+        type: void 0,
+        init: {
+          kind: "index",
+          obj: arrExpr,
+          index: { kind: "ident", name: idxName }
+        },
+        span: stmt.span
+      };
+      const stepStmt = {
+        kind: "expr",
+        expr: {
+          kind: "assign",
+          target: idxName,
+          value: {
+            kind: "binary",
+            op: "+",
+            left: { kind: "ident", name: idxName },
+            right: { kind: "int_lit", value: 1 }
+          }
+        },
+        span: stmt.span
+      };
+      const body = [bindingInit, ...lowerBlock(stmt.body)];
+      const step = [stepStmt];
+      const whileStmt = {
+        kind: "while",
+        cond: {
+          kind: "binary",
+          op: "<",
+          left: { kind: "ident", name: idxName },
+          right: { kind: "ident", name: lenName }
+        },
+        body,
+        step,
+        span: stmt.span
+      };
+      return [lenInitStmt, idxInitStmt, whileStmt];
     }
-    const declMatch = line.match(/^declare fn (\w+)\(([^)]*)\):\s*(\w+);?$/);
-    if (declMatch) {
-      const [, fnName, paramsStr, retType] = declMatch;
-      if (!ALL_BUILTINS[fnName]) {
-        const params = paramsStr.trim() ? paramsStr.split(",").map((p) => {
-          const [pname, ptype] = p.trim().split(":").map((s) => s.trim());
-          return {
-            name: pname ?? "",
-            type: ptype ?? "string",
-            required: true,
-            doc: paramDocs[pname ?? ""] ?? "",
-            docZh: ""
-          };
-        }) : [];
-        extra[fnName] = {
-          name: fnName,
-          params,
-          returns: retType === "void" || retType === "int" || retType === "bool" || retType === "string" ? retType : "void",
-          doc: docLines.join(" ").trim(),
-          docZh: "",
-          examples: [],
-          category: "builtin"
-        };
-      }
-      docLines = [];
-      paramDocs = {};
-      continue;
+    case "foreach":
+      return {
+        kind: "foreach",
+        binding: stmt.binding,
+        iterable: lowerExpr(stmt.iterable),
+        body: lowerBlock(stmt.body),
+        executeContext: stmt.executeContext,
+        span: stmt.span
+      };
+    case "match":
+      return {
+        kind: "match",
+        expr: lowerExpr(stmt.expr),
+        arms: stmt.arms.map((arm) => ({
+          pattern: lowerMatchPattern(arm.pattern),
+          body: lowerBlock(arm.body)
+        })),
+        span: stmt.span
+      };
+    // --- Desugaring: as_block → execute [as] ---
+    case "as_block":
+      return {
+        kind: "execute",
+        subcommands: [{ kind: "as", selector: stmt.selector }],
+        body: lowerBlock(stmt.body),
+        span: stmt.span
+      };
+    // --- Desugaring: at_block → execute [at] ---
+    case "at_block":
+      return {
+        kind: "execute",
+        subcommands: [{ kind: "at", selector: stmt.selector }],
+        body: lowerBlock(stmt.body),
+        span: stmt.span
+      };
+    // --- Desugaring: as_at → execute [as, at] ---
+    case "as_at":
+      return {
+        kind: "execute",
+        subcommands: [
+          { kind: "as", selector: stmt.as_sel },
+          { kind: "at", selector: stmt.at_sel }
+        ],
+        body: lowerBlock(stmt.body),
+        span: stmt.span
+      };
+    case "execute":
+      return {
+        kind: "execute",
+        subcommands: stmt.subcommands.map(lowerExecuteSubcommand),
+        body: lowerBlock(stmt.body),
+        span: stmt.span
+      };
+    case "raw":
+      return { kind: "raw", cmd: stmt.cmd, span: stmt.span };
+    case "if_let_some":
+      return {
+        kind: "if_let_some",
+        binding: stmt.binding,
+        init: lowerExpr(stmt.init),
+        then: lowerBlock(stmt.then),
+        else_: stmt.else_ ? lowerBlock(stmt.else_) : void 0,
+        span: stmt.span
+      };
+    // --- Desugaring: do_while → body + while(cond) { body } ---
+    // Emits the body once unconditionally, then a while loop:
+    //   <body>
+    //   while (cond) { <body> }
+    case "do_while": {
+      const firstBody = lowerBlock(stmt.body);
+      const loopBody = lowerBlock(stmt.body);
+      const whileStmt = {
+        kind: "while",
+        cond: lowerExpr(stmt.cond),
+        body: loopBody,
+        span: stmt.span
+      };
+      return [...firstBody, whileStmt];
+    }
+    // --- Desugaring: repeat N → let __repeat_i = 0; while(__repeat_i < N) { body; __repeat_i = __repeat_i + 1 } ---
+    case "repeat": {
+      const id = repeatCounter++;
+      const idxName = `__repeat_i_${id}`;
+      const initStmt = {
+        kind: "let",
+        name: idxName,
+        type: { kind: "named", name: "int" },
+        init: { kind: "int_lit", value: 0 },
+        span: stmt.span
+      };
+      const body = lowerBlock(stmt.body);
+      const step = [{
+        kind: "expr",
+        expr: {
+          kind: "assign",
+          target: idxName,
+          value: {
+            kind: "binary",
+            op: "+",
+            left: { kind: "ident", name: idxName },
+            right: { kind: "int_lit", value: 1 }
+          }
+        }
+      }];
+      const whileStmt = {
+        kind: "while",
+        cond: {
+          kind: "binary",
+          op: "<",
+          left: { kind: "ident", name: idxName },
+          right: { kind: "int_lit", value: stmt.count }
+        },
+        body,
+        step,
+        span: stmt.span
+      };
+      return [initStmt, whileStmt];
     }
-    if (line.trim() && !line.startsWith("//")) {
-      docLines = [];
-      paramDocs = {};
+    case "while_let_some":
+      return {
+        kind: "while_let_some",
+        binding: stmt.binding,
+        init: lowerExpr(stmt.init),
+        body: lowerBlock(stmt.body),
+        span: stmt.span
+      };
+    default: {
+      const _exhaustive = stmt;
+      throw new Error(`Unknown statement kind: ${_exhaustive.kind}`);
     }
   }
-  return extra;
 }
-var EXTRA_BUILTINS = loadBuiltinsFromDeclFile();
-var ALL_BUILTINS = { ...EXTRA_BUILTINS, ...BUILTIN_METADATA };
-var parsedDocs = /* @__PURE__ */ new Map();
-function typeToString(t) {
-  switch (t.kind) {
-    case "named":
-      return t.name;
-    case "array":
-      return `${typeToString(t.elem)}[]`;
-    case "struct":
-      return t.name;
-    case "enum":
-      return t.name;
-    case "entity":
-      return t.entityType;
-    case "selector":
-      return t.entityType ? `selector<${t.entityType}>` : "selector";
-    case "tuple":
-      return `(${t.elements.map(typeToString).join(", ")})`;
-    case "function_type":
-      return `(${t.params.map(typeToString).join(", ")}) => ${typeToString(t.return)}`;
-    default:
-      return "unknown";
-  }
+function lowerExecuteSubcommand(sub) {
+  return sub;
 }
-function parseDocument(uri, source) {
-  const errors = [];
-  let program = null;
-  try {
-    const strippedSource = source.replace(/^import\s+"[^"]*"\s*;?\s*$/gm, "// (import stripped for LSP)");
-    const lexer = new Lexer(strippedSource);
-    const tokens = lexer.tokenize();
-    const parser = new Parser(tokens, strippedSource, uri);
-    program = parser.parse("redscript");
-    try {
-      const checker = new TypeChecker(source, uri);
-      const typeErrors = checker.check(program);
-      errors.push(...typeErrors);
-    } catch {
+var forEachCounter = 0;
+var repeatCounter = 0;
+var COMPOUND_TO_BINOP = {
+  "+=": "+",
+  "-=": "-",
+  "*=": "*",
+  "/=": "/",
+  "%=": "%"
+};
+function lowerExpr(expr) {
+  switch (expr.kind) {
+    // --- Pass-through literals ---
+    case "int_lit":
+    case "float_lit":
+    case "byte_lit":
+    case "short_lit":
+    case "long_lit":
+    case "double_lit":
+    case "bool_lit":
+    case "str_lit":
+    case "range_lit":
+    case "rel_coord":
+    case "local_coord":
+    case "mc_name":
+    case "blockpos":
+      return expr;
+    case "ident":
+      return { kind: "ident", name: expr.name, span: expr.span };
+    case "selector":
+      return { kind: "selector", raw: expr.raw, isSingle: expr.isSingle, sel: expr.sel, span: expr.span };
+    case "array_lit":
+      return { kind: "array_lit", elements: expr.elements.map(lowerExpr), span: expr.span };
+    case "struct_lit":
+      return {
+        kind: "struct_lit",
+        fields: expr.fields.map((f) => ({ name: f.name, value: lowerExpr(f.value) })),
+        span: expr.span
+      };
+    case "str_interp":
+      return {
+        kind: "str_interp",
+        parts: expr.parts.map((p) => typeof p === "string" ? p : lowerExpr(p)),
+        span: expr.span
+      };
+    case "f_string": {
+      const hirParts = expr.parts.map(
+        (part) => part.kind === "text" ? { kind: "text", value: part.value } : { kind: "expr", expr: lowerExpr(part.expr) }
+      );
+      return { kind: "f_string", parts: hirParts, span: expr.span };
     }
-  } catch (err) {
-    if (err instanceof DiagnosticError) {
-      errors.push(err);
-    } else if (err instanceof Error) {
-      errors.push(new DiagnosticError(
-        "ParseError",
-        err.message,
-        { line: 1, col: 1, file: uri }
-      ));
+    // Binary ops — && and || preserved as-is (short-circuit → control flow in MIR)
+    case "binary":
+      return {
+        kind: "binary",
+        op: expr.op,
+        left: lowerExpr(expr.left),
+        right: lowerExpr(expr.right),
+        span: expr.span
+      };
+    case "unary":
+      return { kind: "unary", op: expr.op, operand: lowerExpr(expr.operand), span: expr.span };
+    case "is_check":
+      return { kind: "is_check", expr: lowerExpr(expr.expr), entityType: expr.entityType, span: expr.span };
+    // --- Desugaring: compound assignment → plain assign ---
+    case "assign":
+      if (expr.op !== "=") {
+        const binOp = COMPOUND_TO_BINOP[expr.op];
+        return {
+          kind: "assign",
+          target: expr.target,
+          value: {
+            kind: "binary",
+            op: binOp,
+            left: { kind: "ident", name: expr.target },
+            right: lowerExpr(expr.value),
+            span: expr.span
+          },
+          span: expr.span
+        };
+      }
+      return { kind: "assign", target: expr.target, value: lowerExpr(expr.value), span: expr.span };
+    // --- Desugaring: compound member_assign → plain member_assign ---
+    case "member_assign":
+      if (expr.op !== "=") {
+        const binOp = COMPOUND_TO_BINOP[expr.op];
+        const obj = lowerExpr(expr.obj);
+        return {
+          kind: "member_assign",
+          obj,
+          field: expr.field,
+          value: {
+            kind: "binary",
+            op: binOp,
+            left: { kind: "member", obj, field: expr.field },
+            right: lowerExpr(expr.value),
+            span: expr.span
+          },
+          span: expr.span
+        };
+      }
+      return {
+        kind: "member_assign",
+        obj: lowerExpr(expr.obj),
+        field: expr.field,
+        value: lowerExpr(expr.value),
+        span: expr.span
+      };
+    case "member":
+      return { kind: "member", obj: lowerExpr(expr.obj), field: expr.field, span: expr.span };
+    case "index":
+      return { kind: "index", obj: lowerExpr(expr.obj), index: lowerExpr(expr.index), span: expr.span };
+    // --- Desugaring: compound index_assign → plain index_assign ---
+    case "index_assign":
+      if (expr.op !== "=") {
+        const binOp = COMPOUND_TO_BINOP[expr.op];
+        const obj = lowerExpr(expr.obj);
+        const index = lowerExpr(expr.index);
+        return {
+          kind: "index_assign",
+          obj,
+          index,
+          op: "=",
+          value: {
+            kind: "binary",
+            op: binOp,
+            left: { kind: "index", obj, index },
+            right: lowerExpr(expr.value),
+            span: expr.span
+          },
+          span: expr.span
+        };
+      }
+      return {
+        kind: "index_assign",
+        obj: lowerExpr(expr.obj),
+        index: lowerExpr(expr.index),
+        op: expr.op,
+        value: lowerExpr(expr.value),
+        span: expr.span
+      };
+    case "call":
+      return { kind: "call", fn: expr.fn, args: expr.args.map(lowerExpr), typeArgs: expr.typeArgs, span: expr.span };
+    case "invoke":
+      return { kind: "invoke", callee: lowerExpr(expr.callee), args: expr.args.map(lowerExpr), span: expr.span };
+    case "static_call":
+      return {
+        kind: "static_call",
+        type: expr.type,
+        method: expr.method,
+        args: expr.args.map(lowerExpr),
+        span: expr.span
+      };
+    case "path_expr":
+      return { kind: "path_expr", enumName: expr.enumName, variant: expr.variant, span: expr.span };
+    case "enum_construct":
+      return {
+        kind: "enum_construct",
+        enumName: expr.enumName,
+        variant: expr.variant,
+        args: expr.args.map((a) => ({ name: a.name, value: lowerExpr(a.value) })),
+        span: expr.span
+      };
+    case "tuple_lit":
+      return { kind: "tuple_lit", elements: expr.elements.map(lowerExpr), span: expr.span };
+    case "some_lit":
+      return { kind: "some_lit", value: lowerExpr(expr.value), span: expr.span };
+    case "none_lit":
+      return { kind: "none_lit", span: expr.span };
+    case "unwrap_or":
+      return { kind: "unwrap_or", opt: lowerExpr(expr.opt), default_: lowerExpr(expr.default_), span: expr.span };
+    case "type_cast":
+      return { kind: "type_cast", expr: lowerExpr(expr.expr), targetType: expr.targetType, span: expr.span };
+    case "lambda": {
+      const body = Array.isArray(expr.body) ? lowerBlock(expr.body) : lowerExpr(expr.body);
+      return {
+        kind: "lambda",
+        params: expr.params,
+        returnType: expr.returnType,
+        body,
+        span: expr.span
+      };
+    }
+    default: {
+      const _exhaustive = expr;
+      throw new Error(`Unknown expression kind: ${_exhaustive.kind}`);
     }
   }
-  const doc = { program, errors, source };
-  parsedDocs.set(uri, doc);
-  return doc;
 }
-function toDiagnostic(err) {
-  const line = Math.max(0, (err.location?.line ?? 1) - 1);
-  const col = Math.max(0, (err.location?.col ?? 1) - 1);
+
+// ../../src/lint/index.ts
+function lintSource(source, imports, hir, options = {}) {
+  const warnings = [];
+  const file = options.filePath;
+  const maxLines = options.maxFunctionLines ?? 50;
+  warnings.push(...checkUnusedImports(imports, hir, file));
+  for (const fn of hir.functions) {
+    if (fn.isLibraryFn) continue;
+    warnings.push(...checkUnusedVariables(fn, file));
+    warnings.push(...checkMagicNumbers(fn, file));
+    warnings.push(...checkDeadBranches(fn, file));
+    const fnWarning = checkFunctionLength(fn, maxLines, file);
+    if (fnWarning) warnings.push(fnWarning);
+  }
+  return warnings;
+}
+function lintString(source, filePath, namespace = "redscript", options = {}) {
+  const lexer = new Lexer(source);
+  const tokens = lexer.tokenize();
+  const parser = new Parser(tokens, source, namespace);
+  const ast = parser.parse(namespace);
+  const hir = lowerToHIR(ast);
+  return lintSource(source, ast.imports, hir, { ...options, filePath });
+}
+function checkUnusedImports(imports, hir, file) {
+  const warnings = [];
+  const calledNames = /* @__PURE__ */ new Set();
+  for (const fn of hir.functions) {
+    collectCalledNames(fn.body, calledNames);
+  }
+  for (const imp of imports) {
+    if (!imp.symbol || imp.symbol === "*") continue;
+    if (!calledNames.has(imp.symbol)) {
+      const warn = {
+        rule: "unused-import",
+        message: `Import "${imp.symbol}" from "${imp.moduleName}" is never used`,
+        file
+      };
+      if (imp.span) {
+        warn.line = imp.span.line;
+        warn.col = imp.span.col;
+      }
+      warnings.push(warn);
+    }
+  }
+  return warnings;
+}
+function collectCalledNames(block, out) {
+  for (const stmt of block) {
+    collectCalledNamesStmt(stmt, out);
+  }
+}
+function collectCalledNamesStmt(stmt, out) {
+  switch (stmt.kind) {
+    case "let":
+      collectCalledNamesExpr(stmt.init, out);
+      break;
+    case "const_decl":
+      collectCalledNamesExpr(stmt.value, out);
+      break;
+    case "let_destruct":
+      collectCalledNamesExpr(stmt.init, out);
+      break;
+    case "expr":
+    case "return":
+      if (stmt.kind === "return" && stmt.value) collectCalledNamesExpr(stmt.value, out);
+      if (stmt.kind === "expr") collectCalledNamesExpr(stmt.expr, out);
+      break;
+    case "if":
+      collectCalledNamesExpr(stmt.cond, out);
+      collectCalledNames(stmt.then, out);
+      if (stmt.else_) collectCalledNames(stmt.else_, out);
+      break;
+    case "while":
+      collectCalledNamesExpr(stmt.cond, out);
+      collectCalledNames(stmt.body, out);
+      if (stmt.step) collectCalledNames(stmt.step, out);
+      break;
+    case "foreach":
+      collectCalledNamesExpr(stmt.iterable, out);
+      collectCalledNames(stmt.body, out);
+      break;
+    case "match":
+      collectCalledNamesExpr(stmt.expr, out);
+      for (const arm of stmt.arms) collectCalledNames(arm.body, out);
+      break;
+    case "execute":
+      collectCalledNames(stmt.body, out);
+      break;
+    case "if_let_some":
+      collectCalledNamesExpr(stmt.init, out);
+      collectCalledNames(stmt.then, out);
+      if (stmt.else_) collectCalledNames(stmt.else_, out);
+      break;
+    case "while_let_some":
+      collectCalledNamesExpr(stmt.init, out);
+      collectCalledNames(stmt.body, out);
+      break;
+    case "labeled_loop":
+      collectCalledNamesStmt(stmt.body, out);
+      break;
+  }
+}
+function collectCalledNamesExpr(expr, out) {
+  if (!expr) return;
+  switch (expr.kind) {
+    case "call":
+      out.add(expr.fn);
+      for (const arg of expr.args) collectCalledNamesExpr(arg, out);
+      break;
+    case "invoke":
+      collectCalledNamesExpr(expr.callee, out);
+      for (const arg of expr.args) collectCalledNamesExpr(arg, out);
+      break;
+    case "static_call":
+      out.add(expr.method);
+      for (const arg of expr.args) collectCalledNamesExpr(arg, out);
+      break;
+    case "binary":
+      collectCalledNamesExpr(expr.left, out);
+      collectCalledNamesExpr(expr.right, out);
+      break;
+    case "unary":
+      collectCalledNamesExpr(expr.operand, out);
+      break;
+    case "member":
+    case "member_assign":
+      collectCalledNamesExpr(expr.obj, out);
+      if (expr.kind === "member_assign") collectCalledNamesExpr(expr.value, out);
+      break;
+    case "index":
+    case "index_assign":
+      collectCalledNamesExpr(expr.obj, out);
+      collectCalledNamesExpr(expr.index, out);
+      if (expr.kind === "index_assign") collectCalledNamesExpr(expr.value, out);
+      break;
+    case "assign":
+      collectCalledNamesExpr(expr.value, out);
+      break;
+    case "some_lit":
+      collectCalledNamesExpr(expr.value, out);
+      break;
+    case "unwrap_or":
+      collectCalledNamesExpr(expr.opt, out);
+      collectCalledNamesExpr(expr.default_, out);
+      break;
+    case "type_cast":
+      collectCalledNamesExpr(expr.expr, out);
+      break;
+    case "array_lit":
+    case "tuple_lit":
+      for (const e of expr.elements) collectCalledNamesExpr(e, out);
+      break;
+    case "struct_lit":
+      for (const f of expr.fields) collectCalledNamesExpr(f.value, out);
+      break;
+    case "str_interp":
+      for (const p of expr.parts) {
+        if (typeof p !== "string") collectCalledNamesExpr(p, out);
+      }
+      break;
+    case "f_string":
+      for (const p of expr.parts) {
+        if (p.kind === "expr") collectCalledNamesExpr(p.expr, out);
+      }
+      break;
+    case "lambda":
+      if (Array.isArray(expr.body)) {
+        collectCalledNames(expr.body, out);
+      } else {
+        collectCalledNamesExpr(expr.body, out);
+      }
+      break;
+    case "enum_construct":
+      for (const f of expr.args) collectCalledNamesExpr(f.value, out);
+      break;
+    // Terminals: ident, int_lit, float_lit, bool_lit, str_lit, etc.
+    default:
+      break;
+  }
+}
+function checkUnusedVariables(fn, file) {
+  const warnings = [];
+  const declared = /* @__PURE__ */ new Map();
+  collectLetDecls(fn.body, declared);
+  const reads = /* @__PURE__ */ new Map();
+  countIdentReads(fn.body, reads, new Set(declared.keys()));
+  for (const [name, info] of declared) {
+    const readCount = reads.get(name) ?? 0;
+    if (readCount === 0) {
+      const warn = {
+        rule: "unused-variable",
+        message: `Variable "${name}" is declared but never used`,
+        file
+      };
+      if (info.span) {
+        warn.line = info.span.line;
+        warn.col = info.span.col;
+      }
+      warnings.push(warn);
+    }
+  }
+  return warnings;
+}
+function collectLetDecls(block, out) {
+  for (const stmt of block) {
+    if (stmt.kind === "let") {
+      out.set(stmt.name, { name: stmt.name, span: stmt.span, readCount: 0 });
+      collectLetDeclsExpr(stmt.init, out);
+    } else if (stmt.kind === "let_destruct") {
+      for (const name of stmt.names) {
+        out.set(name, { name, span: stmt.span, readCount: 0 });
+      }
+      collectLetDeclsExpr(stmt.init, out);
+    } else if (stmt.kind === "const_decl") {
+    } else {
+      collectLetDeclsStmt(stmt, out);
+    }
+  }
+}
+function collectLetDeclsExpr(_expr, _out) {
+}
+function collectLetDeclsStmt(stmt, out) {
+  switch (stmt.kind) {
+    case "if":
+      collectLetDecls(stmt.then, out);
+      if (stmt.else_) collectLetDecls(stmt.else_, out);
+      break;
+    case "while":
+      collectLetDecls(stmt.body, out);
+      if (stmt.step) collectLetDecls(stmt.step, out);
+      break;
+    case "foreach":
+      out.set(stmt.binding, { name: stmt.binding, span: stmt.span, readCount: 0 });
+      collectLetDecls(stmt.body, out);
+      break;
+    case "match":
+      for (const arm of stmt.arms) collectLetDecls(arm.body, out);
+      break;
+    case "execute":
+      collectLetDecls(stmt.body, out);
+      break;
+    case "if_let_some":
+      out.set(stmt.binding, { name: stmt.binding, span: stmt.span, readCount: 0 });
+      collectLetDecls(stmt.then, out);
+      if (stmt.else_) collectLetDecls(stmt.else_, out);
+      break;
+    case "while_let_some":
+      out.set(stmt.binding, { name: stmt.binding, span: stmt.span, readCount: 0 });
+      collectLetDecls(stmt.body, out);
+      break;
+    case "labeled_loop":
+      collectLetDeclsStmt(stmt.body, out);
+      break;
+  }
+}
+function countIdentReads(block, out, declared) {
+  for (const stmt of block) {
+    countIdentReadsStmt(stmt, out, declared);
+  }
+}
+function countIdentReadsStmt(stmt, out, declared) {
+  switch (stmt.kind) {
+    case "let":
+      countIdentReadsExpr(stmt.init, out, declared);
+      break;
+    case "let_destruct":
+      countIdentReadsExpr(stmt.init, out, declared);
+      break;
+    case "const_decl":
+      countIdentReadsExpr(stmt.value, out, declared);
+      break;
+    case "expr":
+      countIdentReadsExpr(stmt.expr, out, declared);
+      break;
+    case "return":
+      if (stmt.value) countIdentReadsExpr(stmt.value, out, declared);
+      break;
+    case "if":
+      countIdentReadsExpr(stmt.cond, out, declared);
+      countIdentReads(stmt.then, out, declared);
+      if (stmt.else_) countIdentReads(stmt.else_, out, declared);
+      break;
+    case "while":
+      countIdentReadsExpr(stmt.cond, out, declared);
+      countIdentReads(stmt.body, out, declared);
+      if (stmt.step) countIdentReads(stmt.step, out, declared);
+      break;
+    case "foreach":
+      countIdentReadsExpr(stmt.iterable, out, declared);
+      countIdentReads(stmt.body, out, declared);
+      break;
+    case "match":
+      countIdentReadsExpr(stmt.expr, out, declared);
+      for (const arm of stmt.arms) countIdentReads(arm.body, out, declared);
+      break;
+    case "execute":
+      countIdentReads(stmt.body, out, declared);
+      break;
+    case "if_let_some":
+      countIdentReadsExpr(stmt.init, out, declared);
+      countIdentReads(stmt.then, out, declared);
+      if (stmt.else_) countIdentReads(stmt.else_, out, declared);
+      break;
+    case "while_let_some":
+      countIdentReadsExpr(stmt.init, out, declared);
+      countIdentReads(stmt.body, out, declared);
+      break;
+    case "labeled_loop":
+      countIdentReadsStmt(stmt.body, out, declared);
+      break;
+  }
+}
+function countIdentReadsExpr(expr, out, declared) {
+  if (!expr) return;
+  switch (expr.kind) {
+    case "ident":
+      if (declared.has(expr.name)) {
+        out.set(expr.name, (out.get(expr.name) ?? 0) + 1);
+      }
+      break;
+    case "assign":
+      countIdentReadsExpr(expr.value, out, declared);
+      break;
+    case "binary":
+      countIdentReadsExpr(expr.left, out, declared);
+      countIdentReadsExpr(expr.right, out, declared);
+      break;
+    case "unary":
+      countIdentReadsExpr(expr.operand, out, declared);
+      break;
+    case "call":
+      for (const arg of expr.args) countIdentReadsExpr(arg, out, declared);
+      break;
+    case "invoke":
+      countIdentReadsExpr(expr.callee, out, declared);
+      for (const arg of expr.args) countIdentReadsExpr(arg, out, declared);
+      break;
+    case "static_call":
+      for (const arg of expr.args) countIdentReadsExpr(arg, out, declared);
+      break;
+    case "member":
+      countIdentReadsExpr(expr.obj, out, declared);
+      break;
+    case "member_assign":
+      countIdentReadsExpr(expr.obj, out, declared);
+      countIdentReadsExpr(expr.value, out, declared);
+      break;
+    case "index":
+      countIdentReadsExpr(expr.obj, out, declared);
+      countIdentReadsExpr(expr.index, out, declared);
+      break;
+    case "index_assign":
+      countIdentReadsExpr(expr.obj, out, declared);
+      countIdentReadsExpr(expr.index, out, declared);
+      countIdentReadsExpr(expr.value, out, declared);
+      break;
+    case "some_lit":
+      countIdentReadsExpr(expr.value, out, declared);
+      break;
+    case "unwrap_or":
+      countIdentReadsExpr(expr.opt, out, declared);
+      countIdentReadsExpr(expr.default_, out, declared);
+      break;
+    case "type_cast":
+      countIdentReadsExpr(expr.expr, out, declared);
+      break;
+    case "array_lit":
+    case "tuple_lit":
+      for (const e of expr.elements) countIdentReadsExpr(e, out, declared);
+      break;
+    case "struct_lit":
+      for (const f of expr.fields) countIdentReadsExpr(f.value, out, declared);
+      break;
+    case "str_interp":
+      for (const p of expr.parts) {
+        if (typeof p !== "string") countIdentReadsExpr(p, out, declared);
+      }
+      break;
+    case "f_string":
+      for (const p of expr.parts) {
+        if (p.kind === "expr") countIdentReadsExpr(p.expr, out, declared);
+      }
+      break;
+    case "lambda":
+      if (Array.isArray(expr.body)) {
+        countIdentReads(expr.body, out, declared);
+      } else {
+        countIdentReadsExpr(expr.body, out, declared);
+      }
+      break;
+    case "enum_construct":
+      for (const f of expr.args) countIdentReadsExpr(f.value, out, declared);
+      break;
+    default:
+      break;
+  }
+}
+function checkMagicNumbers(fn, file) {
+  const warnings = [];
+  checkMagicNumbersBlock(
+    fn.body,
+    warnings,
+    file,
+    /*inConst=*/
+    false
+  );
+  return warnings;
+}
+var MAGIC_NUMBER_THRESHOLD = 1;
+function isMagicNumber(value) {
+  return Math.abs(value) > MAGIC_NUMBER_THRESHOLD;
+}
+function checkMagicNumbersBlock(block, out, file, inConst) {
+  for (const stmt of block) {
+    checkMagicNumbersStmt(stmt, out, file, inConst);
+  }
+}
+function checkMagicNumbersStmt(stmt, out, file, inConst) {
+  switch (stmt.kind) {
+    case "const_decl":
+      break;
+    case "let":
+      checkMagicNumbersExpr(stmt.init, out, file);
+      break;
+    case "let_destruct":
+      checkMagicNumbersExpr(stmt.init, out, file);
+      break;
+    case "expr":
+      checkMagicNumbersExpr(stmt.expr, out, file);
+      break;
+    case "return":
+      if (stmt.value) checkMagicNumbersExpr(stmt.value, out, file);
+      break;
+    case "if":
+      checkMagicNumbersExpr(stmt.cond, out, file);
+      checkMagicNumbersBlock(stmt.then, out, file, false);
+      if (stmt.else_) checkMagicNumbersBlock(stmt.else_, out, file, false);
+      break;
+    case "while":
+      checkMagicNumbersExpr(stmt.cond, out, file);
+      checkMagicNumbersBlock(stmt.body, out, file, false);
+      if (stmt.step) checkMagicNumbersBlock(stmt.step, out, file, false);
+      break;
+    case "foreach":
+      checkMagicNumbersExpr(stmt.iterable, out, file);
+      checkMagicNumbersBlock(stmt.body, out, file, false);
+      break;
+    case "match":
+      checkMagicNumbersExpr(stmt.expr, out, file);
+      for (const arm of stmt.arms) checkMagicNumbersBlock(arm.body, out, file, false);
+      break;
+    case "execute":
+      checkMagicNumbersBlock(stmt.body, out, file, false);
+      break;
+    case "if_let_some":
+      checkMagicNumbersExpr(stmt.init, out, file);
+      checkMagicNumbersBlock(stmt.then, out, file, false);
+      if (stmt.else_) checkMagicNumbersBlock(stmt.else_, out, file, false);
+      break;
+    case "while_let_some":
+      checkMagicNumbersExpr(stmt.init, out, file);
+      checkMagicNumbersBlock(stmt.body, out, file, false);
+      break;
+    case "labeled_loop":
+      checkMagicNumbersStmt(stmt.body, out, file, inConst);
+      break;
+  }
+}
+function checkMagicNumbersExpr(expr, out, file) {
+  if (!expr) return;
+  switch (expr.kind) {
+    case "int_lit":
+    case "float_lit":
+    case "byte_lit":
+    case "short_lit":
+    case "long_lit":
+    case "double_lit":
+      if (isMagicNumber(expr.value)) {
+        const warn = {
+          rule: "magic-number",
+          message: `Avoid magic number ${expr.value}, consider using a const`,
+          file
+        };
+        if (expr.span) {
+          warn.line = expr.span.line;
+          warn.col = expr.span.col;
+        }
+        out.push(warn);
+      }
+      break;
+    case "binary":
+      checkMagicNumbersExpr(expr.left, out, file);
+      checkMagicNumbersExpr(expr.right, out, file);
+      break;
+    case "unary":
+      checkMagicNumbersExpr(expr.operand, out, file);
+      break;
+    case "call":
+      for (const arg of expr.args) checkMagicNumbersExpr(arg, out, file);
+      break;
+    case "invoke":
+      checkMagicNumbersExpr(expr.callee, out, file);
+      for (const arg of expr.args) checkMagicNumbersExpr(arg, out, file);
+      break;
+    case "static_call":
+      for (const arg of expr.args) checkMagicNumbersExpr(arg, out, file);
+      break;
+    case "member":
+      checkMagicNumbersExpr(expr.obj, out, file);
+      break;
+    case "member_assign":
+      checkMagicNumbersExpr(expr.obj, out, file);
+      checkMagicNumbersExpr(expr.value, out, file);
+      break;
+    case "index":
+      checkMagicNumbersExpr(expr.obj, out, file);
+      checkMagicNumbersExpr(expr.index, out, file);
+      break;
+    case "index_assign":
+      checkMagicNumbersExpr(expr.obj, out, file);
+      checkMagicNumbersExpr(expr.index, out, file);
+      checkMagicNumbersExpr(expr.value, out, file);
+      break;
+    case "assign":
+      checkMagicNumbersExpr(expr.value, out, file);
+      break;
+    case "some_lit":
+      checkMagicNumbersExpr(expr.value, out, file);
+      break;
+    case "unwrap_or":
+      checkMagicNumbersExpr(expr.opt, out, file);
+      checkMagicNumbersExpr(expr.default_, out, file);
+      break;
+    case "type_cast":
+      checkMagicNumbersExpr(expr.expr, out, file);
+      break;
+    case "array_lit":
+    case "tuple_lit":
+      for (const e of expr.elements) checkMagicNumbersExpr(e, out, file);
+      break;
+    case "struct_lit":
+      for (const f of expr.fields) checkMagicNumbersExpr(f.value, out, file);
+      break;
+    case "str_interp":
+      for (const p of expr.parts) {
+        if (typeof p !== "string") checkMagicNumbersExpr(p, out, file);
+      }
+      break;
+    case "f_string":
+      for (const p of expr.parts) {
+        if (p.kind === "expr") checkMagicNumbersExpr(p.expr, out, file);
+      }
+      break;
+    case "lambda":
+      if (Array.isArray(expr.body)) {
+        checkMagicNumbersBlock(expr.body, out, file, false);
+      } else {
+        checkMagicNumbersExpr(expr.body, out, file);
+      }
+      break;
+    case "enum_construct":
+      for (const f of expr.args) checkMagicNumbersExpr(f.value, out, file);
+      break;
+    default:
+      break;
+  }
+}
+function checkDeadBranches(fn, file) {
+  const warnings = [];
+  checkDeadBranchesBlock(fn.body, warnings, file);
+  return warnings;
+}
+function checkDeadBranchesBlock(block, out, file) {
+  for (const stmt of block) {
+    if (stmt.kind === "if") {
+      const result = evaluateConstBool(stmt.cond);
+      if (result !== null) {
+        const warn = {
+          rule: "dead-branch",
+          message: result ? `Condition is always true \u2014 else branch is dead code` : `Condition is always false \u2014 then branch is dead code`,
+          file
+        };
+        if (stmt.span) {
+          warn.line = stmt.span.line;
+          warn.col = stmt.span.col;
+        } else if (stmt.cond.span) {
+          warn.line = stmt.cond.span.line;
+          warn.col = stmt.cond.span.col;
+        }
+        out.push(warn);
+      }
+      checkDeadBranchesBlock(stmt.then, out, file);
+      if (stmt.else_) checkDeadBranchesBlock(stmt.else_, out, file);
+    } else {
+      checkDeadBranchesStmt(stmt, out, file);
+    }
+  }
+}
+function checkDeadBranchesStmt(stmt, out, file) {
+  switch (stmt.kind) {
+    case "while":
+      checkDeadBranchesBlock(stmt.body, out, file);
+      if (stmt.step) checkDeadBranchesBlock(stmt.step, out, file);
+      break;
+    case "foreach":
+      checkDeadBranchesBlock(stmt.body, out, file);
+      break;
+    case "match":
+      for (const arm of stmt.arms) checkDeadBranchesBlock(arm.body, out, file);
+      break;
+    case "execute":
+      checkDeadBranchesBlock(stmt.body, out, file);
+      break;
+    case "if_let_some":
+      checkDeadBranchesBlock(stmt.then, out, file);
+      if (stmt.else_) checkDeadBranchesBlock(stmt.else_, out, file);
+      break;
+    case "while_let_some":
+      checkDeadBranchesBlock(stmt.body, out, file);
+      break;
+    case "labeled_loop":
+      checkDeadBranchesStmt(stmt.body, out, file);
+      break;
+  }
+}
+function evaluateConstBool(expr) {
+  if (expr.kind === "bool_lit") return expr.value;
+  if (expr.kind === "binary") {
+    const lv = evaluateConstNumber(expr.left);
+    const rv = evaluateConstNumber(expr.right);
+    if (lv !== null && rv !== null) {
+      switch (expr.op) {
+        case "==":
+          return lv === rv;
+        case "!=":
+          return lv !== rv;
+        case "<":
+          return lv < rv;
+        case "<=":
+          return lv <= rv;
+        case ">":
+          return lv > rv;
+        case ">=":
+          return lv >= rv;
+      }
+    }
+    const lb = evaluateConstBool(expr.left);
+    const rb = evaluateConstBool(expr.right);
+    if (lb !== null && rb !== null) {
+      if (expr.op === "==") return lb === rb;
+      if (expr.op === "!=") return lb !== rb;
+    }
+  }
+  return null;
+}
+function evaluateConstNumber(expr) {
+  switch (expr.kind) {
+    case "int_lit":
+    case "float_lit":
+    case "byte_lit":
+    case "short_lit":
+    case "long_lit":
+    case "double_lit":
+      return expr.value;
+    default:
+      return null;
+  }
+}
+function checkFunctionLength(fn, maxLines, file) {
+  const lineCount = countFunctionLines(fn);
+  if (lineCount > maxLines) {
+    const warn = {
+      rule: "function-too-long",
+      message: `Function "${fn.name}" is ${lineCount} lines long (max ${maxLines}), consider splitting it`,
+      file
+    };
+    if (fn.span) {
+      warn.line = fn.span.line;
+      warn.col = fn.span.col;
+    }
+    return warn;
+  }
+  return null;
+}
+function countFunctionLines(fn) {
+  if (fn.span && fn.body.length > 0) {
+    const lastStmt = fn.body[fn.body.length - 1];
+    if (lastStmt.span && fn.span.line) {
+      const endLine = lastStmt.span.line;
+      const startLine = fn.span.line;
+      if (endLine > startLine) return endLine - startLine;
+    }
+  }
+  return countStmts(fn.body);
+}
+function countStmts(block) {
+  let count = 0;
+  for (const stmt of block) {
+    count++;
+    switch (stmt.kind) {
+      case "if":
+        count += countStmts(stmt.then);
+        if (stmt.else_) count += countStmts(stmt.else_);
+        break;
+      case "while":
+        count += countStmts(stmt.body);
+        if (stmt.step) count += countStmts(stmt.step);
+        break;
+      case "foreach":
+        count += countStmts(stmt.body);
+        break;
+      case "match":
+        for (const arm of stmt.arms) count += countStmts(arm.body);
+        break;
+      case "execute":
+        count += countStmts(stmt.body);
+        break;
+      case "if_let_some":
+        count += countStmts(stmt.then);
+        if (stmt.else_) count += countStmts(stmt.else_);
+        break;
+      case "while_let_some":
+        count += countStmts(stmt.body);
+        break;
+      case "labeled_loop":
+        count += countStmts([stmt.body]);
+        break;
+    }
+  }
+  return count;
+}
+
+// ../../src/lsp/rename.ts
+function keyFor(line, col) {
+  return `${line}:${col}`;
+}
+function buildTokenCursor(source) {
+  const tokens = new Lexer(source).tokenize().filter((token) => token.kind !== "eof");
+  const byLineCol = /* @__PURE__ */ new Map();
+  tokens.forEach((token, index) => byLineCol.set(keyFor(token.line, token.col), index));
+  return { tokens, byLineCol };
+}
+function tokenToRange(doc, token) {
+  const start = doc.positionAt(doc.offsetAt({ line: token.line - 1, character: token.col - 1 }));
+  const end = doc.positionAt(doc.offsetAt({ line: token.line - 1, character: token.col - 1 }) + token.value.length);
+  return { start, end };
+}
+function containsPosition(token, position) {
+  const line = token.line - 1;
+  const start = token.col - 1;
+  const end = start + token.value.length;
+  return position.line === line && position.character >= start && position.character <= end;
+}
+function makeScope(parent) {
+  return {
+    parent,
+    locals: /* @__PURE__ */ new Map(),
+    types: /* @__PURE__ */ new Map()
+  };
+}
+function resolveLocal(scope, name) {
+  let cur = scope;
+  while (cur) {
+    const found = cur.locals.get(name);
+    if (found) return found;
+    cur = cur.parent;
+  }
+  return null;
+}
+function resolveType(scope, name) {
+  let cur = scope;
+  while (cur) {
+    const found = cur.types.get(name);
+    if (found) return found;
+    cur = cur.parent;
+  }
+  return null;
+}
+function findTokenIndex(cursor, line, col) {
+  return cursor.byLineCol.get(keyFor(line, col)) ?? -1;
+}
+function findNextToken(cursor, startIndex, predicate) {
+  for (let i = Math.max(0, startIndex); i < cursor.tokens.length; i++) {
+    if (predicate(cursor.tokens[i], i)) return cursor.tokens[i];
+  }
+  return null;
+}
+function findFunctionNameToken(cursor, fn) {
+  if (!fn.span) return null;
+  const fnIndex = findTokenIndex(cursor, fn.span.line, fn.span.col);
+  if (fnIndex === -1) return null;
+  return findNextToken(cursor, fnIndex + 1, (token) => token.kind === "ident" && token.value === fn.name);
+}
+function findDeclarationNameToken(cursor, stmt) {
+  if (!stmt.span) return null;
+  const startIndex = findTokenIndex(cursor, stmt.span.line, stmt.span.col);
+  if (startIndex === -1) return null;
+  return findNextToken(
+    cursor,
+    startIndex + 1,
+    (token) => token.kind === "ident" && token.value === stmt.name && token.line === stmt.span.line
+  );
+}
+function findFieldDeclarationTokens(cursor, program) {
+  const result = /* @__PURE__ */ new Map();
+  for (const struct of program.structs ?? []) {
+    if (!struct.span) continue;
+    const structIndex = findTokenIndex(cursor, struct.span.line, struct.span.col);
+    if (structIndex === -1) continue;
+    let i = structIndex;
+    while (i < cursor.tokens.length && cursor.tokens[i].kind !== "{") i++;
+    if (i >= cursor.tokens.length) continue;
+    let fieldIndex = 0;
+    let depth = 1;
+    i++;
+    while (i < cursor.tokens.length && depth > 0 && fieldIndex < struct.fields.length) {
+      const token = cursor.tokens[i];
+      if (token.kind === "{") depth++;
+      else if (token.kind === "}") depth--;
+      else if (depth === 1 && token.kind === "ident" && token.value === struct.fields[fieldIndex].name && cursor.tokens[i + 1]?.kind === ":") {
+        result.set(`${struct.name}.${token.value}`, token);
+        fieldIndex++;
+      }
+      i++;
+    }
+  }
+  return result;
+}
+function findParamToken(cursor, fn, paramName, fromIndex) {
+  return findNextToken(
+    cursor,
+    fromIndex,
+    (token) => token.kind === "ident" && token.value === paramName && cursor.tokens[cursor.tokens.indexOf(token) + 1]?.kind === ":"
+  );
+}
+function findFieldAccessToken(cursor, expr) {
+  if (!expr.span) return null;
+  const startIndex = findTokenIndex(cursor, expr.span.line, expr.span.col);
+  if (startIndex === -1) return null;
+  return findNextToken(
+    cursor,
+    startIndex + 1,
+    (token, index) => token.kind === "ident" && token.value === expr.field && cursor.tokens[index - 1]?.kind === "." && token.line === expr.span.line
+  );
+}
+function findStructLiteralFieldToken(cursor, expr, fieldName, skipCount) {
+  if (!expr.span) return null;
+  const startIndex = findTokenIndex(cursor, expr.span.line, expr.span.col);
+  if (startIndex === -1) return null;
+  let depth = 0;
+  let skipped = 0;
+  for (let i = startIndex; i < cursor.tokens.length; i++) {
+    const token = cursor.tokens[i];
+    if (token.kind === "{") depth++;
+    else if (token.kind === "}") {
+      depth--;
+      if (depth === 0) break;
+    } else if (depth === 1 && token.kind === "ident" && token.value === fieldName && cursor.tokens[i + 1]?.kind === ":") {
+      if (skipped === skipCount) return token;
+      skipped++;
+    }
+  }
+  return null;
+}
+function typeNameOf(type, program) {
+  if (!type) return null;
+  if (type.kind === "struct") return type.name;
+  if (type.kind === "named" && program.structs?.some((struct) => struct.name === type.name)) return type.name;
+  return null;
+}
+function resolveExprStructName(expr, scope, program, currentFn) {
+  switch (expr.kind) {
+    case "ident":
+      return typeNameOf(resolveType(scope, expr.name), program);
+    case "member": {
+      const objType = resolveExprStructName(expr.obj, scope, program, currentFn);
+      if (!objType) return null;
+      const structDecl = program.structs?.find((struct) => struct.name === objType);
+      const fieldType = structDecl?.fields.find((field) => field.name === expr.field)?.type;
+      return typeNameOf(fieldType, program);
+    }
+    case "call": {
+      const fn = program.declarations.find((candidate) => candidate.name === expr.fn);
+      return typeNameOf(fn?.returnType, program);
+    }
+    case "type_cast":
+      return typeNameOf(expr.targetType, program);
+    case "struct_lit":
+      return typeNameOf(currentFn.returnType, program);
+    default:
+      return null;
+  }
+}
+function addOccurrence(symbol, token) {
+  if (!symbol || !token) return;
+  if (symbol.occurrences.some((existing) => existing.line === token.line && existing.col === token.col)) return;
+  symbol.occurrences.push(token);
+}
+function buildRenameIndex(source, program) {
+  const cursor = buildTokenCursor(source);
+  const symbols = [];
+  const functions = /* @__PURE__ */ new Map();
+  const fieldSymbols = /* @__PURE__ */ new Map();
+  const fieldDeclTokens = findFieldDeclarationTokens(cursor, program);
+  for (const fn of program.declarations) {
+    const symbol = { kind: "function", name: fn.name, occurrences: [] };
+    addOccurrence(symbol, findFunctionNameToken(cursor, fn));
+    functions.set(fn.name, symbol);
+    symbols.push(symbol);
+  }
+  for (const struct of program.structs ?? []) {
+    for (const field of struct.fields) {
+      const symbol = {
+        kind: "field",
+        name: field.name,
+        structName: struct.name,
+        occurrences: []
+      };
+      addOccurrence(symbol, fieldDeclTokens.get(`${struct.name}.${field.name}`) ?? null);
+      fieldSymbols.set(`${struct.name}.${field.name}`, symbol);
+      symbols.push(symbol);
+    }
+  }
+  function walkBlock(block, scope, currentFn) {
+    for (const stmt of block) walkStmt(stmt, scope, currentFn);
+  }
+  function bindLocal(name, type, token, scope) {
+    const symbol = { kind: "local", name, occurrences: [] };
+    addOccurrence(symbol, token);
+    scope.locals.set(name, symbol);
+    if (type) scope.types.set(name, type);
+    symbols.push(symbol);
+    return symbol;
+  }
+  function walkPattern(pattern, scope, currentFn) {
+    if (pattern.kind === "PatSome") {
+      bindLocal(pattern.binding, void 0, null, scope);
+    } else if (pattern.kind === "PatEnum") {
+      for (const binding of pattern.bindings) bindLocal(binding, void 0, null, scope);
+    } else if (pattern.kind === "PatExpr") {
+      walkExpr(pattern.expr, scope, null, currentFn);
+    }
+  }
+  function walkStmt(stmt, scope, currentFn) {
+    switch (stmt.kind) {
+      case "let": {
+        walkExpr(stmt.init, scope, stmt.type ? typeNameOf(stmt.type, program) : null, currentFn);
+        const inferredType = stmt.type ?? (() => {
+          const inferredStruct = resolveExprStructName(stmt.init, scope, program, currentFn);
+          return inferredStruct ? { kind: "struct", name: inferredStruct } : void 0;
+        })();
+        bindLocal(stmt.name, inferredType, findDeclarationNameToken(cursor, stmt), scope);
+        return;
+      }
+      case "const_decl":
+        walkExpr(stmt.value, scope, null, currentFn);
+        bindLocal(stmt.name, stmt.type, findDeclarationNameToken(cursor, stmt), scope);
+        return;
+      case "let_destruct":
+        walkExpr(stmt.init, scope, null, currentFn);
+        for (const name of stmt.names) bindLocal(name, stmt.type, null, scope);
+        return;
+      case "expr":
+        walkExpr(stmt.expr, scope, null, currentFn);
+        return;
+      case "return":
+        if (stmt.value) walkExpr(stmt.value, scope, typeNameOf(currentFn.returnType, program), currentFn);
+        return;
+      case "if":
+        walkExpr(stmt.cond, scope, null, currentFn);
+        walkBlock(stmt.then, makeScope(scope), currentFn);
+        if (stmt.else_) walkBlock(stmt.else_, makeScope(scope), currentFn);
+        return;
+      case "while":
+      case "do_while":
+        walkExpr(stmt.cond, scope, null, currentFn);
+        walkBlock(stmt.body, makeScope(scope), currentFn);
+        return;
+      case "repeat":
+      case "as_block":
+      case "at_block":
+      case "as_at":
+      case "execute":
+        walkBlock(stmt.body, makeScope(scope), currentFn);
+        return;
+      case "for": {
+        const forScope = makeScope(scope);
+        if (stmt.init) walkStmt(stmt.init, forScope, currentFn);
+        walkExpr(stmt.cond, forScope, null, currentFn);
+        walkExpr(stmt.step, forScope, null, currentFn);
+        walkBlock(stmt.body, forScope, currentFn);
+        return;
+      }
+      case "foreach": {
+        walkExpr(stmt.iterable, scope, null, currentFn);
+        const foreachScope = makeScope(scope);
+        bindLocal(stmt.binding, void 0, null, foreachScope);
+        walkBlock(stmt.body, foreachScope, currentFn);
+        return;
+      }
+      case "for_range": {
+        walkExpr(stmt.start, scope, null, currentFn);
+        walkExpr(stmt.end, scope, null, currentFn);
+        const forScope = makeScope(scope);
+        bindLocal(stmt.varName, { kind: "named", name: "int" }, null, forScope);
+        walkBlock(stmt.body, forScope, currentFn);
+        return;
+      }
+      case "for_each": {
+        walkExpr(stmt.array, scope, null, currentFn);
+        const forScope = makeScope(scope);
+        bindLocal(stmt.binding, void 0, null, forScope);
+        walkBlock(stmt.body, forScope, currentFn);
+        return;
+      }
+      case "for_in_array": {
+        const forScope = makeScope(scope);
+        bindLocal(stmt.binding, void 0, null, forScope);
+        walkExpr(stmt.lenExpr, forScope, null, currentFn);
+        walkBlock(stmt.body, forScope, currentFn);
+        return;
+      }
+      case "match":
+        walkExpr(stmt.expr, scope, null, currentFn);
+        for (const arm of stmt.arms) {
+          const armScope = makeScope(scope);
+          walkPattern(arm.pattern, armScope, currentFn);
+          walkBlock(arm.body, armScope, currentFn);
+        }
+        return;
+      case "if_let_some": {
+        walkExpr(stmt.init, scope, null, currentFn);
+        const thenScope = makeScope(scope);
+        bindLocal(stmt.binding, void 0, null, thenScope);
+        walkBlock(stmt.then, thenScope, currentFn);
+        if (stmt.else_) walkBlock(stmt.else_, makeScope(scope), currentFn);
+        return;
+      }
+      case "while_let_some": {
+        walkExpr(stmt.init, scope, null, currentFn);
+        const whileScope = makeScope(scope);
+        bindLocal(stmt.binding, void 0, null, whileScope);
+        walkBlock(stmt.body, whileScope, currentFn);
+        return;
+      }
+      case "labeled_loop":
+        walkStmt(stmt.body, makeScope(scope), currentFn);
+        return;
+      default:
+        return;
+    }
+  }
+  function walkExpr(expr, scope, expectedStructName, currentFn) {
+    switch (expr.kind) {
+      case "ident":
+        addOccurrence(resolveLocal(scope, expr.name), expr.span ? cursor.tokens[findTokenIndex(cursor, expr.span.line, expr.span.col)] ?? null : null);
+        return;
+      case "assign":
+        addOccurrence(resolveLocal(scope, expr.target), expr.span ? cursor.tokens[findTokenIndex(cursor, expr.span.line, expr.span.col)] ?? null : null);
+        walkExpr(expr.value, scope, null, currentFn);
+        return;
+      case "call":
+        addOccurrence(functions.get(expr.fn) ?? null, expr.span ? cursor.tokens[findTokenIndex(cursor, expr.span.line, expr.span.col)] ?? null : null);
+        for (const arg of expr.args) walkExpr(arg, scope, null, currentFn);
+        return;
+      case "member": {
+        walkExpr(expr.obj, scope, null, currentFn);
+        const structName = resolveExprStructName(expr.obj, scope, program, currentFn);
+        addOccurrence(structName ? fieldSymbols.get(`${structName}.${expr.field}`) ?? null : null, findFieldAccessToken(cursor, expr));
+        return;
+      }
+      case "member_assign": {
+        walkExpr(expr.obj, scope, null, currentFn);
+        const structName = resolveExprStructName(expr.obj, scope, program, currentFn);
+        addOccurrence(structName ? fieldSymbols.get(`${structName}.${expr.field}`) ?? null : null, findFieldAccessToken(cursor, expr));
+        walkExpr(expr.value, scope, structName ? typeNameOf(program.structs?.find((struct) => struct.name === structName)?.fields.find((field) => field.name === expr.field)?.type, program) : null, currentFn);
+        return;
+      }
+      case "struct_lit": {
+        const structName = expectedStructName;
+        if (structName) {
+          expr.fields.forEach((field, index) => {
+            addOccurrence(fieldSymbols.get(`${structName}.${field.name}`) ?? null, findStructLiteralFieldToken(cursor, expr, field.name, index));
+            const fieldType = program.structs?.find((struct) => struct.name === structName)?.fields.find((candidate) => candidate.name === field.name)?.type;
+            walkExpr(field.value, scope, typeNameOf(fieldType, program), currentFn);
+          });
+        } else {
+          for (const field of expr.fields) walkExpr(field.value, scope, null, currentFn);
+        }
+        return;
+      }
+      case "binary":
+        walkExpr(expr.left, scope, null, currentFn);
+        walkExpr(expr.right, scope, null, currentFn);
+        return;
+      case "unary":
+      case "type_cast":
+        walkExpr(expr.kind === "unary" ? expr.operand : expr.expr, scope, null, currentFn);
+        return;
+      case "invoke":
+        walkExpr(expr.callee, scope, null, currentFn);
+        for (const arg of expr.args) walkExpr(arg, scope, null, currentFn);
+        return;
+      case "index":
+        walkExpr(expr.obj, scope, null, currentFn);
+        walkExpr(expr.index, scope, null, currentFn);
+        return;
+      case "index_assign":
+        walkExpr(expr.obj, scope, null, currentFn);
+        walkExpr(expr.index, scope, null, currentFn);
+        walkExpr(expr.value, scope, null, currentFn);
+        return;
+      case "array_lit":
+      case "tuple_lit":
+        for (const item of expr.elements) walkExpr(item, scope, null, currentFn);
+        return;
+      case "enum_construct":
+        for (const arg of expr.args) walkExpr(arg.value, scope, null, currentFn);
+        return;
+      case "some_lit":
+        walkExpr(expr.value, scope, null, currentFn);
+        return;
+      case "unwrap_or":
+        walkExpr(expr.opt, scope, null, currentFn);
+        walkExpr(expr.default_, scope, null, currentFn);
+        return;
+      case "str_interp":
+        for (const part of expr.parts) {
+          if (typeof part !== "string") walkExpr(part, scope, null, currentFn);
+        }
+        return;
+      case "f_string":
+        for (const part of expr.parts) {
+          if (part.kind === "expr") walkExpr(part.expr, scope, null, currentFn);
+        }
+        return;
+      case "lambda": {
+        const lambdaScope = makeScope(scope);
+        let fromIndex = expr.span ? findTokenIndex(cursor, expr.span.line, expr.span.col) : -1;
+        for (const param of expr.params) {
+          const token = findParamToken(cursor, currentFn, param.name, fromIndex + 1);
+          if (token) fromIndex = cursor.tokens.indexOf(token);
+          bindLocal(param.name, param.type, token, lambdaScope);
+        }
+        if (Array.isArray(expr.body)) walkBlock(expr.body, lambdaScope, currentFn);
+        else walkExpr(expr.body, lambdaScope, null, currentFn);
+        return;
+      }
+      default:
+        return;
+    }
+  }
+  for (const fn of program.declarations) {
+    const rootScope = makeScope(null);
+    let fromIndex = findFunctionNameToken(cursor, fn) && cursor.tokens.indexOf(findFunctionNameToken(cursor, fn)) || -1;
+    for (const param of fn.params) {
+      const token = findParamToken(cursor, fn, param.name, fromIndex + 1);
+      if (token) fromIndex = cursor.tokens.indexOf(token);
+      bindLocal(param.name, param.type, token, rootScope);
+    }
+    walkBlock(fn.body, rootScope, fn);
+  }
+  return symbols;
+}
+function findRenameRanges(source, program, position) {
+  const doc = TextDocument.create("file:///rename.mcrs", "redscript", 1, source);
+  const symbols = buildRenameIndex(source, program);
+  const symbol = symbols.find((candidate) => candidate.occurrences.some((token) => containsPosition(token, position)));
+  if (!symbol) return [];
+  return symbol.occurrences.slice().sort((a, b) => a.line - b.line || a.col - b.col).map((token) => tokenToRange(doc, token));
+}
+function buildRenameWorkspaceEdit(doc, program, position, newName) {
+  const ranges = findRenameRanges(doc.getText(), program, position);
+  if (ranges.length === 0) return null;
+  return {
+    changes: {
+      [doc.uri]: ranges.map((range) => ({ range, newText: newName }))
+    }
+  };
+}
+
+// ../../src/lsp/server.ts
+var connection = (0, import_node.createConnection)(import_node.ProposedFeatures.all);
+var documents = new import_node.TextDocuments(TextDocument);
+function loadBuiltinsFromDeclFile() {
+  const extra = {};
+  const candidates = [
+    path.resolve(__dirname, "../../builtins.d.mcrs"),
+    path.resolve(__dirname, "../../../builtins.d.mcrs"),
+    path.resolve(__dirname, "../../../../builtins.d.mcrs")
+  ];
+  let src = "";
+  for (const p of candidates) {
+    if (fs.existsSync(p)) {
+      src = fs.readFileSync(p, "utf-8");
+      break;
+    }
+  }
+  if (!src) return extra;
+  const lines = src.split("\n");
+  let docLines = [];
+  let paramDocs = {};
+  for (const line of lines) {
+    const tripleDoc = line.match(/^\/\/\/\s?(.*)$/);
+    if (tripleDoc) {
+      const content = tripleDoc[1];
+      const paramMatch = content.match(/^@param\s+(\w+)\s+(.+)$/);
+      if (paramMatch) {
+        paramDocs[paramMatch[1]] = paramMatch[2];
+      } else if (!content.startsWith("@example")) {
+        docLines.push(content);
+      }
+      continue;
+    }
+    const declMatch = line.match(/^declare fn (\w+)\(([^)]*)\):\s*(\w+);?$/);
+    if (declMatch) {
+      const [, fnName, paramsStr, retType] = declMatch;
+      if (!ALL_BUILTINS[fnName]) {
+        const params = paramsStr.trim() ? paramsStr.split(",").map((p) => {
+          const [pname, ptype] = p.trim().split(":").map((s) => s.trim());
+          return {
+            name: pname ?? "",
+            type: ptype ?? "string",
+            required: true,
+            doc: paramDocs[pname ?? ""] ?? "",
+            docZh: ""
+          };
+        }) : [];
+        extra[fnName] = {
+          name: fnName,
+          params,
+          returns: retType === "void" || retType === "int" || retType === "bool" || retType === "string" ? retType : "void",
+          doc: docLines.join(" ").trim(),
+          docZh: "",
+          examples: [],
+          category: "builtin"
+        };
+      }
+      docLines = [];
+      paramDocs = {};
+      continue;
+    }
+    if (line.trim() && !line.startsWith("//")) {
+      docLines = [];
+      paramDocs = {};
+    }
+  }
+  return extra;
+}
+var EXTRA_BUILTINS = loadBuiltinsFromDeclFile();
+var ALL_BUILTINS = { ...EXTRA_BUILTINS, ...BUILTIN_METADATA };
+var parsedDocs = /* @__PURE__ */ new Map();
+function typeToString(t) {
+  switch (t.kind) {
+    case "named":
+      return t.name;
+    case "array":
+      return `${typeToString(t.elem)}[]`;
+    case "struct":
+      return t.name;
+    case "enum":
+      return t.name;
+    case "entity":
+      return t.entityType;
+    case "selector":
+      return t.entityType ? `selector<${t.entityType}>` : "selector";
+    case "tuple":
+      return `(${t.elements.map(typeToString).join(", ")})`;
+    case "function_type":
+      return `(${t.params.map(typeToString).join(", ")}) => ${typeToString(t.return)}`;
+    default:
+      return "unknown";
+  }
+}
+function parseDocument(uri, source) {
+  const errors = [];
+  let program = null;
+  try {
+    const strippedSource = source.replace(/^import\s+"[^"]*"\s*;?\s*$/gm, "// (import stripped for LSP)");
+    const lexer = new Lexer(strippedSource);
+    const tokens = lexer.tokenize();
+    const parser = new Parser(tokens, strippedSource, uri);
+    program = parser.parse("redscript");
+    try {
+      const checker = new TypeChecker(source, uri);
+      const typeErrors = checker.check(program);
+      errors.push(...typeErrors);
+    } catch {
+    }
+  } catch (err) {
+    if (err instanceof DiagnosticError) {
+      errors.push(err);
+    } else if (err instanceof Error) {
+      errors.push(new DiagnosticError(
+        "ParseError",
+        err.message,
+        { line: 1, col: 1, file: uri }
+      ));
+    }
+  }
+  const doc = { program, errors, source };
+  parsedDocs.set(uri, doc);
+  return doc;
+}
+function toDiagnostic(err) {
+  const line = Math.max(0, (err.location?.line ?? 1) - 1);
+  const col = Math.max(0, (err.location?.col ?? 1) - 1);
   return {
     severity: import_node.DiagnosticSeverity.Error,
     range: {
@@ -13958,9 +16408,32 @@ function toDiagnostic(err) {
     source: "redscript"
   };
 }
+var LINT_SEVERITY_MAP = {
+  "unused-variable": import_node.DiagnosticSeverity.Information,
+  "magic-number": import_node.DiagnosticSeverity.Hint,
+  "dead-branch": import_node.DiagnosticSeverity.Warning,
+  "unused-import": import_node.DiagnosticSeverity.Information,
+  "function-too-long": import_node.DiagnosticSeverity.Warning
+};
+function lintWarningToDiagnostic(w) {
+  const line = Math.max(0, (w.line ?? 1) - 1);
+  const col = Math.max(0, (w.col ?? 1) - 1);
+  const severity = LINT_SEVERITY_MAP[w.rule] ?? import_node.DiagnosticSeverity.Warning;
+  return {
+    severity,
+    range: {
+      start: { line, character: col },
+      end: { line, character: col + 80 }
+    },
+    message: w.message,
+    source: "redscript-lint",
+    code: w.rule
+  };
+}
 var DECORATOR_DOCS = {
   tick: "Runs every game tick.\n\n**Optional args:** `rate=N` (every N ticks, e.g. `@tick(rate=20)` = once per second)\n\nExample: `@tick fn every_tick() {}` or `@tick(rate=20) fn every_second() {}`",
   load: "Runs once on `/reload`. Use for initialization.\n\nExample: `@load fn init() { scoreboard_create(...) }`",
+  watch: 'Runs when a scoreboard objective changes for a player.\n\n**Required arg:** objective name.\n\nExample: `@watch("rs.kills") fn on_kill_change() {}`',
   coroutine: "Wraps a loop to spread execution across multiple ticks.\n\n**Required arg:** `batch=N` \u2014 iterations per tick.\n\nExample: `@coroutine(batch=10) fn scan_blocks() { for i in 0..1000 { ... } }`",
   schedule: "Schedules the function to run after a delay.\n\n**Required arg:** `ticks=N`\n\nExample: `@schedule(ticks=100) fn delayed() {}`",
   on_trigger: 'Runs when a player executes `/trigger <name>`.\n\n**Required arg:** trigger objective name.\n\nExample: `@on_trigger("shop") fn open_shop() {}`',
@@ -13997,6 +16470,41 @@ function formatFnSignature(fn) {
   const typeParams = fn.typeParams?.length ? `<${fn.typeParams.join(", ")}>` : "";
   return `fn ${fn.name}${typeParams}(${params}): ${ret}`;
 }
+function parseDocCommentText(raw) {
+  const result = { description: "", params: [], returns: null };
+  const descLines = [];
+  for (const line of raw.split("\n")) {
+    const paramMatch = line.match(/^@param\s+(\w+)\s+(.+)$/);
+    if (paramMatch) {
+      result.params.push({ name: paramMatch[1], doc: paramMatch[2].trim() });
+      continue;
+    }
+    const retMatch = line.match(/^@returns?\s+(.+)$/);
+    if (retMatch) {
+      result.returns = retMatch[1].trim();
+      continue;
+    }
+    if (/^@\w+/.test(line.trim())) continue;
+    descLines.push(line);
+  }
+  result.description = descLines.join("\n").trim();
+  return result;
+}
+function formatDocCommentMarkdown(doc) {
+  const parts = [];
+  if (doc.description) parts.push(doc.description);
+  if (doc.params.length > 0) {
+    parts.push("\n**Parameters:**");
+    for (const p of doc.params) {
+      parts.push(`- \`${p.name}\` \u2014 ${p.doc}`);
+    }
+  }
+  if (doc.returns) {
+    parts.push(`
+**Returns:** ${doc.returns}`);
+  }
+  return parts.join("\n");
+}
 function extractDocComment(source, fn) {
   if (!fn.span) return null;
   const lines = source.split("\n");
@@ -14107,6 +16615,7 @@ var TYPE_COMPLETIONS = [
 }));
 var DECORATOR_COMPLETIONS = [
   { label: "@tick", detail: "Run every game tick (~20 Hz)", insertText: "tick" },
+  { label: "@watch", detail: "Run when a scoreboard objective changes", insertText: "watch" },
   { label: "@load", detail: "Run on /reload (initialization)", insertText: "load" },
   { label: "@on_trigger", detail: "Run when a player uses /trigger", insertText: "on_trigger" },
   { label: "@schedule", detail: "Schedule function after N ticks", insertText: "schedule" },
@@ -14190,6 +16699,18 @@ function validateAndPublish(doc) {
   const source = doc.getText();
   const parsed = parseDocument(doc.uri, source);
   const diagnostics = parsed.errors.map(toDiagnostic);
+  try {
+    const filePath = (() => {
+      try {
+        return (0, import_url.fileURLToPath)(doc.uri);
+      } catch {
+        return doc.uri;
+      }
+    })();
+    const lintWarnings = lintString(source, filePath);
+    diagnostics.push(...lintWarnings.map(lintWarningToDiagnostic));
+  } catch {
+  }
   connection.sendDiagnostics({ uri: doc.uri, diagnostics });
 }
 documents.onDidOpen((e) => validateAndPublish(e.document));
@@ -14276,11 +16797,20 @@ ${builtin.doc}`
   const fn = findFunction(program, word);
   if (fn) {
     const sig = formatFnSignature(fn);
+    const rawDoc = extractDocComment(source, fn);
+    let docSection = "";
+    if (rawDoc) {
+      const parsed = parseDocCommentText(rawDoc);
+      const md = formatDocCommentMarkdown(parsed);
+      if (md) docSection = `
+
+${md}`;
+    }
     const content = {
       kind: import_node.MarkupKind.Markdown,
       value: `\`\`\`redscript
 ${sig}
-\`\`\``
+\`\`\`${docSection}`
     };
     return { contents: content };
   }
@@ -14835,20 +17365,9 @@ connection.onReferences((params) => {
 connection.onRenameRequest((params) => {
   const doc = documents.get(params.textDocument.uri);
   if (!doc) return null;
-  const wordRange = getWordRangeAtPosition(doc, params.position);
-  if (!wordRange) return null;
-  const word = doc.getText(wordRange);
-  if (!word) return null;
-  const text = doc.getText();
-  const edits = [];
-  const regex = new RegExp(`\\b${word}\\b`, "g");
-  let match;
-  while ((match = regex.exec(text)) !== null) {
-    const start = doc.positionAt(match.index);
-    const end = doc.positionAt(match.index + word.length);
-    edits.push({ range: { start, end }, newText: params.newName });
-  }
-  return { changes: { [params.textDocument.uri]: edits } };
+  const parsed = parsedDocs.get(params.textDocument.uri);
+  if (!parsed?.program) return null;
+  return buildRenameWorkspaceEdit(doc, parsed.program, params.position, params.newName);
 });
 documents.listen(connection);
 connection.listen();