@jbearak/sight 0.8.4 → 0.9.0

package/dist/sight-server.js

@@ -52,15 +52,15 @@ var package_default;
 var init_package = __esm(() => {
   package_default = {
     name: "@jbearak/sight",
-    version: "0.8.4",
+    version: "0.9.0",
     type: "module",
     workspaces: [
       "client"
     ],
-    description: "Language Server Protocol implementation for Stata",
+    description: "A static analyzer and language server for the Stata statistical programming language",
     repository: {
       type: "git",
-      url: "https://github.com/jbearak/sight.git"
+      url: "git+https://github.com/jbearak/sight.git"
     },
     bugs: {
       url: "https://github.com/jbearak/sight/issues"
@@ -79,8 +79,8 @@ var init_package = __esm(() => {
       "build:npm": "bun run build:bundle && npm run validate:npm",
       "validate:npm": "node dist/sight-server.js --version && echo 'NPM build validation passed'",
       prepublishOnly: "npm run build:npm",
-      "publish:npm": "npm publish --ignore-scripts --access public",
-      "publish:dry-run": "npm publish --dry-run --access public",
+      "publish:npm": "npm run build:npm && npm publish --ignore-scripts --access public",
+      "publish:dry-run": "npm run build:npm && npm publish --dry-run --ignore-scripts --access public",
       "install:binary": "bun scripts/install.ts",
       "uninstall:binary": "bun scripts/uninstall.ts",
       watch: "tsc --watch",
@@ -913,6 +913,7 @@ var init_schema = __esm(() => {
     "undefinedVariable",
     "styleWarnings",
     "malformedOperator",
+    "spacedCompoundOperator",
     "invalidOperatorSequence",
     "cStyleLogicalInControlFlow",
     "mixedLogicalOperators"
@@ -2145,7 +2146,8 @@ function isFileCommand(command) {
   return FILE_COMMANDS.has(command);
 }
 function isPathDirective(directive) {
-  return PATH_DIRECTIVES.has(directive.toLowerCase());
+  const normalized = directive.trim().replace(/^sight:\s*/, "@lsp-");
+  return PATH_DIRECTIVES.has(normalized);
 }
 function hasStataExtension(filename) {
   const lower = filename.toLowerCase();
@@ -2431,6 +2433,7 @@ var init_file_path_utils = __esm(() => {
   ]);
   PATH_DIRECTIVES = new Set([
     "@lsp-done-by",
+    "@lsp-run-by",
     "@lsp-included-by",
     "@lsp-do",
     "@lsp-run",
@@ -11109,7 +11112,7 @@ var require_server = __commonJS((exports) => {
 
 // node_modules/vscode-languageserver/lib/node/files.js
 var require_files = __commonJS((exports) => {
-  var __filename = "/Users/jmb/.codex/worktrees/3573/sight/node_modules/vscode-languageserver/lib/node/files.js";
+  var __filename = "/home/runner/work/sight/sight/node_modules/vscode-languageserver/lib/node/files.js";
   Object.defineProperty(exports, "__esModule", { value: true });
   exports.resolveModulePath = exports.FileSystem = exports.resolveGlobalYarnPath = exports.resolveGlobalNodePath = exports.resolve = exports.uriToFilePath = undefined;
   var url = __require("url");
@@ -11676,8 +11679,99 @@ function undefined_symbol_data_fields(diagnostic) {
   };
 }
 
+// src/utils/diagnostic-code-description.ts
+function diagnostic_code_anchor(code) {
+  if (code === undefined || code === null) {
+    return null;
+  }
+  const value = String(code).trim();
+  if (value.length === 0) {
+    return null;
+  }
+  const cached = anchor_cache.get(value);
+  if (cached !== undefined) {
+    return cached;
+  }
+  const anchor = value.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "");
+  anchor_cache.set(value, anchor);
+  return anchor;
+}
+function diagnostic_code_description(code) {
+  const anchor = diagnostic_code_anchor(code);
+  if (!anchor) {
+    return;
+  }
+  return {
+    href: `${DIAGNOSTICS_DOCUMENTATION_URL}#${anchor}`
+  };
+}
+function diagnostic_code_description_fields(code) {
+  const codeDescription = diagnostic_code_description(code);
+  return codeDescription ? { codeDescription } : {};
+}
+var DIAGNOSTICS_DOCUMENTATION_URL = "https://github.com/jbearak/sight/blob/main/docs/diagnostics.md", anchor_cache;
+var init_diagnostic_code_description = __esm(() => {
+  anchor_cache = new Map;
+});
+
 // src/types/index.ts
-var init_types = () => {};
+var LexerErrorCode, ParseErrorCode, StataDiagnosticCode;
+var init_types = __esm(() => {
+  ((LexerErrorCode2) => {
+    LexerErrorCode2["UNBALANCED_QUOTES"] = "UNBALANCED_QUOTES";
+    LexerErrorCode2["UNBALANCED_BLOCK_COMMENT"] = "UNBALANCED_BLOCK_COMMENT";
+    LexerErrorCode2["UNTERMINATED_STATEMENT"] = "UNTERMINATED_STATEMENT";
+    LexerErrorCode2["CONTINUATION_NO_SPACE"] = "CONTINUATION_NO_SPACE";
+    LexerErrorCode2["BLOCK_COMMENT_IN_STAR_COMMENT"] = "BLOCK_COMMENT_IN_STAR_COMMENT";
+  })(LexerErrorCode ||= {});
+  ((ParseErrorCode2) => {
+    ParseErrorCode2["SYNTAX_ERROR"] = "SYNTAX_ERROR";
+    ParseErrorCode2["BRACE_ELSE_SAME_LINE"] = "BRACE_ELSE_SAME_LINE";
+    ParseErrorCode2["BRACE_NOT_ALONE"] = "BRACE_NOT_ALONE";
+    ParseErrorCode2["MISSING_PROGRAM_END"] = "MISSING_PROGRAM_END";
+    ParseErrorCode2["OPEN_BRACE_ALONE"] = "OPEN_BRACE_ALONE";
+    ParseErrorCode2["UNCLOSED_BLOCK"] = "UNCLOSED_BLOCK";
+    ParseErrorCode2["CODE_AFTER_OPEN_BRACE"] = "CODE_AFTER_OPEN_BRACE";
+    ParseErrorCode2["FORVALUES_SYNTAX"] = "FORVALUES_SYNTAX";
+    ParseErrorCode2["REDUNDANT_MACRO_SUFFIX"] = "REDUNDANT_MACRO_SUFFIX";
+    ParseErrorCode2["MISSING_EXPRESSION_AFTER_EQUALS"] = "MISSING_EXPRESSION_AFTER_EQUALS";
+    ParseErrorCode2["UNBALANCED_PARENTHESES"] = "UNBALANCED_PARENTHESES";
+    ParseErrorCode2["ORPHAN_CLOSE_BRACE"] = "ORPHAN_CLOSE_BRACE";
+    ParseErrorCode2["STRAY_TOKEN_IN_CONDITION"] = "STRAY_TOKEN_IN_CONDITION";
+    ParseErrorCode2["SPLIT_LITERAL_IN_CONDITION"] = "SPLIT_LITERAL_IN_CONDITION";
+  })(ParseErrorCode ||= {});
+  ((StataDiagnosticCode2) => {
+    StataDiagnosticCode2["UNBALANCED_QUOTES"] = "UNBALANCED_QUOTES";
+    StataDiagnosticCode2["UNBALANCED_BLOCK_COMMENT"] = "UNBALANCED_BLOCK_COMMENT";
+    StataDiagnosticCode2["UNTERMINATED_STATEMENT"] = "UNTERMINATED_STATEMENT";
+    StataDiagnosticCode2["CONTINUATION_NO_SPACE"] = "CONTINUATION_NO_SPACE";
+    StataDiagnosticCode2["BLOCK_COMMENT_IN_STAR_COMMENT"] = "BLOCK_COMMENT_IN_STAR_COMMENT";
+    StataDiagnosticCode2["UNDEFINED_MACRO"] = "UNDEFINED_MACRO";
+    StataDiagnosticCode2["UNDEFINED_VARIABLE"] = "UNDEFINED_VARIABLE";
+    StataDiagnosticCode2["OUT_OF_SCOPE_SYMBOL"] = "OUT_OF_SCOPE_SYMBOL";
+    StataDiagnosticCode2["MISSING_VARIABLE_NAME"] = "MISSING_VARIABLE_NAME";
+    StataDiagnosticCode2["SYNTAX_ERROR"] = "SYNTAX_ERROR";
+    StataDiagnosticCode2["BRACE_ELSE_SAME_LINE"] = "BRACE_ELSE_SAME_LINE";
+    StataDiagnosticCode2["BRACE_NOT_ALONE"] = "BRACE_NOT_ALONE";
+    StataDiagnosticCode2["MISSING_PROGRAM_END"] = "MISSING_PROGRAM_END";
+    StataDiagnosticCode2["OPEN_BRACE_ALONE"] = "OPEN_BRACE_ALONE";
+    StataDiagnosticCode2["UNCLOSED_BLOCK"] = "UNCLOSED_BLOCK";
+    StataDiagnosticCode2["CODE_AFTER_OPEN_BRACE"] = "CODE_AFTER_OPEN_BRACE";
+    StataDiagnosticCode2["FORVALUES_SYNTAX"] = "FORVALUES_SYNTAX";
+    StataDiagnosticCode2["REDUNDANT_MACRO_SUFFIX"] = "REDUNDANT_MACRO_SUFFIX";
+    StataDiagnosticCode2["INVALID_MACRO_CHAR"] = "INVALID_MACRO_CHAR";
+    StataDiagnosticCode2["UNNECESSARY_INDENTATION"] = "UNNECESSARY_INDENTATION";
+    StataDiagnosticCode2["MISSING_INDENTATION"] = "MISSING_INDENTATION";
+    StataDiagnosticCode2["MALFORMED_OPERATOR"] = "MALFORMED_OPERATOR";
+    StataDiagnosticCode2["INVALID_OPERATOR_SEQUENCE"] = "INVALID_OPERATOR_SEQUENCE";
+    StataDiagnosticCode2["CSTYLE_LOGICAL_IN_CONTROL_FLOW"] = "CSTYLE_LOGICAL_IN_CONTROL_FLOW";
+    StataDiagnosticCode2["MIXED_LOGICAL_OPERATORS"] = "MIXED_LOGICAL_OPERATORS";
+    StataDiagnosticCode2["SPACED_COMPOUND_OPERATOR"] = "SPACED_COMPOUND_OPERATOR";
+    StataDiagnosticCode2["PATH_CASE_MISMATCH"] = "PATH_CASE_MISMATCH";
+    StataDiagnosticCode2["CROSS_FILE_MISSING_FILE"] = "CROSS_FILE_MISSING_FILE";
+    StataDiagnosticCode2["CROSS_FILE_TRUNCATED"] = "CROSS_FILE_TRUNCATED";
+  })(StataDiagnosticCode ||= {});
+});
 
 // src/lexer/index.ts
 class StataLexer {
@@ -11739,7 +11833,7 @@ class StataLexer {
         const lexerError = {
           message: `Unexpected lexer error: ${error}`,
           range: this.makeRange(startLine, startColumn, this.line, this.column),
-          code: 1001 /* UNBALANCED_QUOTES */
+          code: "UNBALANCED_QUOTES" /* UNBALANCED_QUOTES */
         };
         this.errors.push(lexerError);
         this.advance();
@@ -11820,10 +11914,17 @@ class StataLexer {
       }
       if (my_char === "/" && my_pos + 1 < this.source.length && this.source[my_pos + 1] === "*") {
         my_pos += 2;
-        while (my_pos + 1 < this.source.length) {
+        let my_depth = 1;
+        while (my_pos + 1 < this.source.length && my_depth > 0) {
+          if (this.source[my_pos] === "/" && this.source[my_pos + 1] === "*") {
+            my_depth++;
+            my_pos += 2;
+            continue;
+          }
           if (this.source[my_pos] === "*" && this.source[my_pos + 1] === "/") {
+            my_depth--;
             my_pos += 2;
-            break;
+            continue;
           }
           if (this.source[my_pos] === `
 `) {
@@ -11831,7 +11932,7 @@ class StataLexer {
           }
           my_pos++;
         }
-        if (my_pos + 1 >= this.source.length) {
+        if (my_depth > 0) {
           return true;
         }
         continue;
@@ -12192,19 +12293,12 @@ class StataLexer {
         const my_block_start_column = this.column;
         this.advance();
         this.advance();
-        while (!this.isAtEnd()) {
-          if (this.peek() === "*" && this.peekNext() === "/") {
-            this.advance();
-            this.advance();
-            break;
-          }
-          this.advance();
-        }
+        this.consumeBlockCommentBody();
         if (this.line !== my_block_start_line) {
           const my_error = {
             message: "Block comment `/* */` inside star comment causes" + " multi-line comment behavior — subsequent lines until" + " `*/` will be treated as comment by Stata",
             range: this.makeRange(my_block_start_line, my_block_start_column, this.line, this.column),
-            code: 1005 /* BLOCK_COMMENT_IN_STAR_COMMENT */
+            code: "BLOCK_COMMENT_IN_STAR_COMMENT" /* BLOCK_COMMENT_IN_STAR_COMMENT */
           };
           this.errors.push(my_error);
         }
@@ -12235,14 +12329,7 @@ class StataLexer {
     };
   }
   scanBlockComment(startLine, startColumn) {
-    while (!this.isAtEnd()) {
-      if (this.peek() === "*" && this.peekNext() === "/") {
-        this.advance();
-        this.advance();
-        break;
-      }
-      this.advance();
-    }
+    this.consumeBlockCommentBody();
     const value = this.source.substring(this.position_to_offset(startLine, startColumn), this.position);
     return {
       type: "COMMENT_BLOCK",
@@ -12250,6 +12337,24 @@ class StataLexer {
       range: this.makeRange(startLine, startColumn, this.line, this.column)
     };
   }
+  consumeBlockCommentBody() {
+    let depth = 1;
+    while (!this.isAtEnd() && depth > 0) {
+      if (this.peek() === "/" && this.peekNext() === "*") {
+        this.advance();
+        this.advance();
+        depth++;
+        continue;
+      }
+      if (this.peek() === "*" && this.peekNext() === "/") {
+        this.advance();
+        this.advance();
+        depth--;
+        continue;
+      }
+      this.advance();
+    }
+  }
   scanDelimitDirective(startLine, startColumn) {
     while (this.peek() === " " || this.peek() === "\t") {
       this.advance();
@@ -12291,7 +12396,7 @@ class StataLexer {
         const error = {
           message: "Unclosed string literal",
           range: this.makeRange(startLine, startColumn, this.line, this.column + 1),
-          code: 1001 /* UNBALANCED_QUOTES */
+          code: "UNBALANCED_QUOTES" /* UNBALANCED_QUOTES */
         };
         this.errors.push(error);
         break;
@@ -12407,7 +12512,7 @@ class StataLexer {
       const error = {
         message: "Unclosed string literal",
         range: this.makeRange(startLine, startColumn, this.line, this.column),
-        code: 1001 /* UNBALANCED_QUOTES */
+        code: "UNBALANCED_QUOTES" /* UNBALANCED_QUOTES */
       };
       this.errors.push(error);
     }
@@ -12437,7 +12542,7 @@ class StataLexer {
         const error = {
           message: "Unclosed string literal",
           range: this.makeRange(startLine, startColumn, this.line, this.column + 1),
-          code: 1001 /* UNBALANCED_QUOTES */
+          code: "UNBALANCED_QUOTES" /* UNBALANCED_QUOTES */
         };
         this.errors.push(error);
         break;
@@ -12554,7 +12659,7 @@ class StataLexer {
       const error = {
         message: "Unclosed string literal",
         range: this.makeRange(startLine, startColumn, this.line, this.column),
-        code: 1001 /* UNBALANCED_QUOTES */
+        code: "UNBALANCED_QUOTES" /* UNBALANCED_QUOTES */
       };
       this.errors.push(error);
     }
@@ -12581,7 +12686,7 @@ class StataLexer {
         const my_error = {
           message: "Incomplete macro expression: expected closing quote",
           range: this.makeRange(startLine, startColumn, this.line, this.column),
-          code: 1001 /* UNBALANCED_QUOTES */
+          code: "UNBALANCED_QUOTES" /* UNBALANCED_QUOTES */
         };
         this.errors.push(my_error);
         break;
@@ -12602,7 +12707,7 @@ class StataLexer {
       const my_error = {
         message: "Incomplete macro expression: expected closing quote",
         range: this.makeRange(startLine, startColumn, this.line, this.column),
-        code: 1001 /* UNBALANCED_QUOTES */
+        code: "UNBALANCED_QUOTES" /* UNBALANCED_QUOTES */
       };
       this.errors.push(my_error);
     }
@@ -12625,7 +12730,7 @@ class StataLexer {
           const my_error = {
             message: "Incomplete macro expression: expected '}' or closing quote",
             range: this.makeRange(startLine, startColumn, this.line, this.column),
-            code: 1001 /* UNBALANCED_QUOTES */
+            code: "UNBALANCED_QUOTES" /* UNBALANCED_QUOTES */
           };
           this.errors.push(my_error);
           break;
@@ -12660,7 +12765,7 @@ class StataLexer {
         const my_error = {
           message: "Incomplete macro expression: expected '}' or closing quote",
           range: this.makeRange(startLine, startColumn, this.line, this.column),
-          code: 1001 /* UNBALANCED_QUOTES */
+          code: "UNBALANCED_QUOTES" /* UNBALANCED_QUOTES */
         };
         this.errors.push(my_error);
       }
@@ -13017,7 +13122,7 @@ var init_parser = __esm(() => {
         this.errors.push({
           message: "open brace must be on the same line as the condition",
           range: brace_token.range,
-          code: 3004 /* OPEN_BRACE_ALONE */
+          code: "OPEN_BRACE_ALONE" /* OPEN_BRACE_ALONE */
         });
         let brace_depth = 1;
         while (!this.isAtEnd() && brace_depth > 0) {
@@ -13035,7 +13140,7 @@ var init_parser = __esm(() => {
         this.errors.push({
           message: "unexpected closing brace - no matching opening brace",
           range: brace_token.range,
-          code: 3012 /* ORPHAN_CLOSE_BRACE */
+          code: "ORPHAN_CLOSE_BRACE" /* ORPHAN_CLOSE_BRACE */
         });
         this.pending_trivia = leading_trivia;
         return null;
@@ -13214,11 +13319,11 @@ var init_parser = __esm(() => {
     parseMacroDefinition() {
       const scopeToken = this.advance();
       const scope = scopeToken.value;
-      this.skipTrivia();
+      this.skipMacroDefinitionTrivia();
       let prefixOp;
       if (this.check("OPERATOR") && (this.peek().value === "++" || this.peek().value === "--")) {
         prefixOp = this.advance().value;
-        this.skipTrivia();
+        this.skipMacroDefinitionTrivia();
       }
       if (!this.check("WORD")) {
         this.addError("Expected macro name", this.peek().range);
@@ -13226,13 +13331,13 @@ var init_parser = __esm(() => {
       }
       const nameToken = this.advance();
       const macroName = nameToken.value;
-      this.skipTrivia();
+      this.skipMacroDefinitionTrivia();
       if (!prefixOp && this.check("OPERATOR") && (this.peek().value === "++" || this.peek().value === "--")) {
         const suffixOp = this.peek().value;
         this.errors.push({
           message: `Macro ${suffixOp} suffix is likely a mistake. Did you mean ${suffixOp}${macroName}?`,
           range: this.makeRange(nameToken.range.start, this.peek().range.end),
-          code: 3009 /* REDUNDANT_MACRO_SUFFIX */
+          code: "REDUNDANT_MACRO_SUFFIX" /* REDUNDANT_MACRO_SUFFIX */
         });
       }
       if (this.check("COLON")) {
@@ -13243,7 +13348,7 @@ var init_parser = __esm(() => {
         has_equals = true;
         this.advance();
       }
-      this.skipTrivia();
+      this.skipMacroDefinitionTrivia();
       let value = prefixOp || "";
       const value_start_pos = this.current;
       let paren_depth = 0;
@@ -13261,7 +13366,7 @@ var init_parser = __esm(() => {
         } else if (token.type === "RPAREN") {
           paren_depth--;
           if (paren_depth < 0) {
-            this.addError("Unbalanced parentheses: unexpected closing parenthesis", token.range, 3011 /* UNBALANCED_PARENTHESES */);
+            this.addError("Unbalanced parentheses: unexpected closing parenthesis", token.range, "UNBALANCED_PARENTHESES" /* UNBALANCED_PARENTHESES */);
             paren_depth = 0;
           }
         }
@@ -13269,11 +13374,11 @@ var init_parser = __esm(() => {
       }
       if (paren_depth > 0) {
         const end_pos = this.current > 0 ? this.previous().range : this.peek().range;
-        this.addError("Unbalanced parentheses: missing closing parenthesis", end_pos, 3011 /* UNBALANCED_PARENTHESES */);
+        this.addError("Unbalanced parentheses: missing closing parenthesis", end_pos, "UNBALANCED_PARENTHESES" /* UNBALANCED_PARENTHESES */);
       }
       if (has_equals && value.trim() === "" && !prefixOp) {
         const equals_pos = value_start_pos > 0 ? this.tokens[value_start_pos - 1].range : this.peek().range;
-        this.addError("Missing expression after equals sign", equals_pos, 3010 /* MISSING_EXPRESSION_AFTER_EQUALS */);
+        this.addError("Missing expression after equals sign", equals_pos, "MISSING_EXPRESSION_AFTER_EQUALS" /* MISSING_EXPRESSION_AFTER_EQUALS */);
       }
       return {
         type: "macro_def",
@@ -13286,15 +13391,21 @@ var init_parser = __esm(() => {
     }
     parse_extended_macro_def(scopeToken, scope, macroName) {
       this.advance();
-      this.skipTrivia();
+      this.skipMacroDefinitionTrivia();
       if (!this.check("WORD")) {
         this.addError("Expected function name after colon", this.peek().range);
         throw new Error("Missing function name");
       }
       const function_name = this.advance().value;
-      this.skipTrivia();
+      this.skipMacroDefinitionTrivia();
       const arg_tokens = [];
-      while (!this.check("STATEMENT_TERMINATOR") && !this.isAtEnd() && !this.isTrivia()) {
+      while (!this.check("STATEMENT_TERMINATOR") && !this.isAtEnd()) {
+        if (this.skipContinuation()) {
+          continue;
+        }
+        if (this.check("COMMENT_LINE") || this.check("COMMENT_BLOCK")) {
+          break;
+        }
         const token = this.advance();
         arg_tokens.push(token);
       }
@@ -13399,7 +13510,7 @@ var init_parser = __esm(() => {
           range: prefix_token.range
         };
         if (prefix_token.value === "by") {
-          if (this.check("COLON")) {}
+          if (this.check("COLON")) {} else {}
         }
         if (this.check("COLON")) {
           this.advance();
@@ -14158,7 +14269,7 @@ var init_parser = __esm(() => {
         } else if (token.type === "RPAREN") {
           paren_depth--;
           if (paren_depth < 0) {
-            this.addError("Unbalanced parentheses in if condition", token.range, 3011 /* UNBALANCED_PARENTHESES */);
+            this.addError("Unbalanced parentheses in if condition", token.range, "UNBALANCED_PARENTHESES" /* UNBALANCED_PARENTHESES */);
             paren_depth = 0;
           }
         }
@@ -14168,10 +14279,10 @@ var init_parser = __esm(() => {
       }
       const condition = this.reconstructTokensWithSpacing(condition_tokens).trim();
       if (paren_depth > 0) {
-        this.addError("Unbalanced parentheses in if condition: missing closing parenthesis", ifToken.range, 3011 /* UNBALANCED_PARENTHESES */);
+        this.addError("Unbalanced parentheses in if condition: missing closing parenthesis", ifToken.range, "UNBALANCED_PARENTHESES" /* UNBALANCED_PARENTHESES */);
       }
       if (condition.trim() === "") {
-        this.addError("Empty if condition", ifToken.range, 3010 /* MISSING_EXPRESSION_AFTER_EQUALS */);
+        this.addError("Empty if condition", ifToken.range, "MISSING_EXPRESSION_AFTER_EQUALS" /* MISSING_EXPRESSION_AFTER_EQUALS */);
       }
       const body = [];
       if (this.check("LBRACE")) {
@@ -14323,7 +14434,7 @@ var init_parser = __esm(() => {
         } else if (token.type === "RPAREN") {
           paren_depth--;
           if (paren_depth < 0) {
-            this.addError("Unbalanced parentheses in while condition", token.range, 3011 /* UNBALANCED_PARENTHESES */);
+            this.addError("Unbalanced parentheses in while condition", token.range, "UNBALANCED_PARENTHESES" /* UNBALANCED_PARENTHESES */);
             paren_depth = 0;
           }
         }
@@ -14333,10 +14444,10 @@ var init_parser = __esm(() => {
       }
       const condition = this.reconstructTokensWithSpacing(condition_tokens).trim();
       if (paren_depth > 0) {
-        this.addError("Unbalanced parentheses in while condition: missing closing parenthesis", whileToken.range, 3011 /* UNBALANCED_PARENTHESES */);
+        this.addError("Unbalanced parentheses in while condition: missing closing parenthesis", whileToken.range, "UNBALANCED_PARENTHESES" /* UNBALANCED_PARENTHESES */);
       }
       if (condition.trim() === "") {
-        this.addError("Empty while condition", whileToken.range, 3010 /* MISSING_EXPRESSION_AFTER_EQUALS */);
+        this.addError("Empty while condition", whileToken.range, "MISSING_EXPRESSION_AFTER_EQUALS" /* MISSING_EXPRESSION_AFTER_EQUALS */);
       }
       const body = [];
       if (this.check("LBRACE")) {
@@ -14553,30 +14664,52 @@ var init_parser = __esm(() => {
         this.advance();
       }
     }
-    looksLikeMacroDefinition() {
-      let offset = 1;
+    skipMacroDefinitionTrivia() {
+      while (!this.isAtEnd()) {
+        if (this.skipContinuation()) {
+          continue;
+        }
+        if (this.check("WHITESPACE") || this.check("COMMENT_LINE") || this.check("COMMENT_BLOCK")) {
+          this.advance();
+          continue;
+        }
+        break;
+      }
+    }
+    nextSignificantOffsetForMacroDef(offset) {
       while (this.current + offset < this.tokens.length) {
         const token = this.tokens[this.current + offset];
-        if (token.type === "COMMENT_LINE" || token.type === "COMMENT_BLOCK" || token.type === "CONTINUATION" || token.type === "WHITESPACE") {
+        if (token.type === "CONTINUATION") {
           offset++;
+          if (this.current + offset < this.tokens.length && this.tokens[this.current + offset].type === "STATEMENT_TERMINATOR") {
+            offset++;
+          }
           continue;
         }
-        if (token.type === "WORD") {
-          return true;
-        }
-        if (token.type === "OPERATOR" && (token.value === "++" || token.value === "--")) {
+        if (token.type === "COMMENT_LINE" || token.type === "COMMENT_BLOCK" || token.type === "WHITESPACE") {
           offset++;
-          while (this.current + offset < this.tokens.length) {
-            const next_token = this.tokens[this.current + offset];
-            if (next_token.type === "COMMENT_LINE" || next_token.type === "COMMENT_BLOCK" || next_token.type === "CONTINUATION" || next_token.type === "WHITESPACE") {
-              offset++;
-              continue;
-            }
-            return next_token.type === "WORD";
-          }
+          continue;
         }
+        break;
+      }
+      return offset;
+    }
+    looksLikeMacroDefinition() {
+      let offset = this.nextSignificantOffsetForMacroDef(1);
+      if (this.current + offset >= this.tokens.length) {
         return false;
       }
+      const token = this.tokens[this.current + offset];
+      if (token.type === "WORD") {
+        return true;
+      }
+      if (token.type === "OPERATOR" && (token.value === "++" || token.value === "--")) {
+        offset = this.nextSignificantOffsetForMacroDef(offset + 1);
+        if (this.current + offset >= this.tokens.length) {
+          return false;
+        }
+        return this.tokens[this.current + offset].type === "WORD";
+      }
       return false;
     }
     skipToStatementEnd() {
@@ -14643,7 +14776,7 @@ var init_parser = __esm(() => {
     previous() {
       return this.tokens[this.current - 1];
     }
-    addError(message, range, code = 3000 /* SYNTAX_ERROR */) {
+    addError(message, range, code = "SYNTAX_ERROR" /* SYNTAX_ERROR */) {
       this.errors.push({
         message,
         range,
@@ -14670,7 +14803,7 @@ var init_parser = __esm(() => {
         } else if (token.type === "RPAREN") {
           paren_depth--;
           if (paren_depth < 0) {
-            this.addError("Unbalanced parentheses: unexpected closing parenthesis", token.range, 3011 /* UNBALANCED_PARENTHESES */);
+            this.addError("Unbalanced parentheses: unexpected closing parenthesis", token.range, "UNBALANCED_PARENTHESES" /* UNBALANCED_PARENTHESES */);
             paren_depth = 0;
           }
         }
@@ -14694,12 +14827,12 @@ var init_parser = __esm(() => {
       }
       if (paren_depth > 0) {
         const end_pos = this.current > 0 ? this.previous().range : this.peek().range;
-        this.addError("Unbalanced parentheses: missing closing parenthesis", end_pos, 3011 /* UNBALANCED_PARENTHESES */);
+        this.addError("Unbalanced parentheses: missing closing parenthesis", end_pos, "UNBALANCED_PARENTHESES" /* UNBALANCED_PARENTHESES */);
       }
       const trimmed_expression = expression.trim();
       if (trimmed_expression === "") {
         const equals_pos = start_pos > 0 ? this.tokens[start_pos - 1].range : this.peek().range;
-        this.addError("Missing expression after equals sign", equals_pos, 3010 /* MISSING_EXPRESSION_AFTER_EQUALS */);
+        this.addError("Missing expression after equals sign", equals_pos, "MISSING_EXPRESSION_AFTER_EQUALS" /* MISSING_EXPRESSION_AFTER_EQUALS */);
       }
       return trimmed_expression;
     }
@@ -14738,7 +14871,7 @@ var init_parser = __esm(() => {
         } else if (token.type === "RPAREN") {
           paren_depth--;
           if (paren_depth < 0) {
-            this.addError(`Unbalanced parentheses in ${qualifier_type} qualifier`, token.range, 3011 /* UNBALANCED_PARENTHESES */);
+            this.addError(`Unbalanced parentheses in ${qualifier_type} qualifier`, token.range, "UNBALANCED_PARENTHESES" /* UNBALANCED_PARENTHESES */);
             paren_depth = 0;
           }
           if (state_stack.length > 1) {
@@ -14785,7 +14918,7 @@ var init_parser = __esm(() => {
         const current_state = state_stack[state_stack.length - 1];
         if (current_state === "AFTER_RHS" && token.type !== "LPAREN" && token.type !== "RPAREN" && token.type !== "LBRACKET" && token.type !== "RBRACKET" && bracket_depth === 0 && !in_string_context && !is_delimiter_only) {
           if (prev_token && this.detectSplitLiteral(prev_token, token)) {} else if (!this.isValidAfterComparison(token)) {
-            this.addError(`Unexpected token '${token.value}' after comparison expression. Did you mean to use '&' or '|'?`, token.range, 3013 /* STRAY_TOKEN_IN_CONDITION */);
+            this.addError(`Unexpected token '${token.value}' after comparison expression. Did you mean to use '&' or '|'?`, token.range, "STRAY_TOKEN_IN_CONDITION" /* STRAY_TOKEN_IN_CONDITION */);
           }
         }
         if (token.type !== "WHITESPACE" && token.type !== "LPAREN" && token.type !== "RPAREN" && bracket_depth === 0) {
@@ -14824,11 +14957,11 @@ var init_parser = __esm(() => {
         }
       }
       if (paren_depth > 0) {
-        this.addError(`Unbalanced parentheses in ${qualifier_type} qualifier: missing closing parenthesis`, start_token.range, 3011 /* UNBALANCED_PARENTHESES */);
+        this.addError(`Unbalanced parentheses in ${qualifier_type} qualifier: missing closing parenthesis`, start_token.range, "UNBALANCED_PARENTHESES" /* UNBALANCED_PARENTHESES */);
       }
       const trimmed_expression = expression.trim();
       if (check_empty && trimmed_expression === "") {
-        this.addError(`Empty ${qualifier_type} qualifier expression`, start_token.range, 3010 /* MISSING_EXPRESSION_AFTER_EQUALS */);
+        this.addError(`Empty ${qualifier_type} qualifier expression`, start_token.range, "MISSING_EXPRESSION_AFTER_EQUALS" /* MISSING_EXPRESSION_AFTER_EQUALS */);
       }
       return trimmed_expression;
     }
@@ -14839,21 +14972,21 @@ var init_parser = __esm(() => {
       const is_prev_dot = prev_token.value === "." && (prev_token.type === "OPERATOR" || prev_token.type === "WORD");
       if (is_prev_dot) {
         if (current_token.type === "NUMBER") {
-          this.addError(`Split literal detected: '${prev_token.value} ${current_token.value}' may have been intended as '.${current_token.value}'`, { start: prev_token.range.start, end: current_token.range.end }, 3014 /* SPLIT_LITERAL_IN_CONDITION */);
+          this.addError(`Split literal detected: '${prev_token.value} ${current_token.value}' may have been intended as '.${current_token.value}'`, { start: prev_token.range.start, end: current_token.range.end }, "SPLIT_LITERAL_IN_CONDITION" /* SPLIT_LITERAL_IN_CONDITION */);
           return true;
         }
         if (current_token.type === "WORD" && /^[a-z]$/i.test(current_token.value)) {
-          this.addError(`Split literal detected: '${prev_token.value} ${current_token.value}' may have been intended as '.${current_token.value}' (extended missing value)`, { start: prev_token.range.start, end: current_token.range.end }, 3014 /* SPLIT_LITERAL_IN_CONDITION */);
+          this.addError(`Split literal detected: '${prev_token.value} ${current_token.value}' may have been intended as '.${current_token.value}' (extended missing value)`, { start: prev_token.range.start, end: current_token.range.end }, "SPLIT_LITERAL_IN_CONDITION" /* SPLIT_LITERAL_IN_CONDITION */);
           return true;
         }
       }
       const is_current_dot = current_token.value === "." && (current_token.type === "OPERATOR" || current_token.type === "WORD");
       if (prev_token.type === "NUMBER" && is_current_dot) {
-        this.addError(`Split literal detected: '${prev_token.value} ${current_token.value}' may have been intended as '${prev_token.value}.' or the '.' may be stray`, { start: prev_token.range.start, end: current_token.range.end }, 3014 /* SPLIT_LITERAL_IN_CONDITION */);
+        this.addError(`Split literal detected: '${prev_token.value} ${current_token.value}' may have been intended as '${prev_token.value}.' or the '.' may be stray`, { start: prev_token.range.start, end: current_token.range.end }, "SPLIT_LITERAL_IN_CONDITION" /* SPLIT_LITERAL_IN_CONDITION */);
         return true;
       }
       if (prev_token.type === "WORD" && prev_token.value !== "." && is_current_dot) {
-        this.addError(`Split literal detected: '${prev_token.value} ${current_token.value}' - the '.' may be stray or part of a split literal`, { start: prev_token.range.start, end: current_token.range.end }, 3014 /* SPLIT_LITERAL_IN_CONDITION */);
+        this.addError(`Split literal detected: '${prev_token.value} ${current_token.value}' - the '.' may be stray or part of a split literal`, { start: prev_token.range.start, end: current_token.range.end }, "SPLIT_LITERAL_IN_CONDITION" /* SPLIT_LITERAL_IN_CONDITION */);
         return true;
       }
       return false;
@@ -14930,7 +15063,7 @@ var init_parser = __esm(() => {
         this.errors.push({
           message: "close brace must be alone on its line",
           range: this.makeRange(code_before.range.start, brace_token.range.end),
-          code: 3002 /* BRACE_NOT_ALONE */
+          code: "BRACE_NOT_ALONE" /* BRACE_NOT_ALONE */
         });
       }
       const code_after = this.find_code_after_on_same_line(brace_index + 1, brace_line);
@@ -14939,13 +15072,13 @@ var init_parser = __esm(() => {
           this.errors.push({
             message: "else must appear on a separate line from close brace",
             range: this.makeRange(brace_token.range.start, code_after.range.end),
-            code: 3001 /* BRACE_ELSE_SAME_LINE */
+            code: "BRACE_ELSE_SAME_LINE" /* BRACE_ELSE_SAME_LINE */
           });
         } else {
           this.errors.push({
             message: "code follows on the same line as close brace",
             range: this.makeRange(brace_token.range.start, code_after.range.end),
-            code: 3002 /* BRACE_NOT_ALONE */
+            code: "BRACE_NOT_ALONE" /* BRACE_NOT_ALONE */
           });
         }
       }
@@ -14958,7 +15091,7 @@ var init_parser = __esm(() => {
           this.errors.push({
             message: "open brace must be on the same line as the condition",
             range: brace_token.range,
-            code: 3004 /* OPEN_BRACE_ALONE */
+            code: "OPEN_BRACE_ALONE" /* OPEN_BRACE_ALONE */
           });
         }
       }
@@ -14986,7 +15119,7 @@ var init_parser = __esm(() => {
         this.errors.push({
           message: "code after open brace may be silently ignored",
           range: this.makeRange(brace_token.range.start, last_token.range.end),
-          code: 3006 /* CODE_AFTER_OPEN_BRACE */
+          code: "CODE_AFTER_OPEN_BRACE" /* CODE_AFTER_OPEN_BRACE */
         });
       }
     }
@@ -15094,6 +15227,71 @@ var init_stata_call_patterns = __esm(() => {
   CALL_PREFIX_ALTERNATIVES = /qui(?:etly)?|cap(?:ture)?|noi(?:sily)?|version\s+\d+(?:\.\d+)?/.source;
 });
 
+// src/utils/block-comment-utils.ts
+function block_comment_ranges(content, tokens) {
+  const the_tokens = tokens ?? new StataLexer().tokenize(content).tokens;
+  return the_tokens.filter((my_token) => my_token.type === "COMMENT_BLOCK" || my_token.type === "COMMENT_LINE" && my_token.range.end.line > my_token.range.start.line).map((my_token) => my_token.range);
+}
+function position_in_block_comment(line, character, ranges) {
+  for (const my_range of ranges) {
+    const after_start = line > my_range.start.line || line === my_range.start.line && character >= my_range.start.character;
+    const before_end = line < my_range.end.line || line === my_range.end.line && character < my_range.end.character;
+    if (after_start && before_end) {
+      return true;
+    }
+  }
+  return false;
+}
+function block_comment_lines(content, tokens) {
+  const the_comment_ranges = block_comment_ranges(content, tokens);
+  const the_lines = new Set;
+  if (the_comment_ranges.length === 0) {
+    return the_lines;
+  }
+  const doc = { content, line_offsets: compute_line_offsets(content) };
+  const line_count = get_line_count(doc);
+  for (let my_line = 0;my_line < line_count; my_line++) {
+    const my_text = get_line_text(doc, my_line);
+    const my_col = my_text.search(/\S/);
+    if (my_col < 0) {
+      continue;
+    }
+    if (position_in_block_comment(my_line, my_col, the_comment_ranges)) {
+      the_lines.add(my_line);
+    }
+  }
+  return the_lines;
+}
+var init_block_comment_utils = __esm(() => {
+  init_lexer();
+});
+
+// src/utils/directives.ts
+function make_directive_pattern(keywords, suffix, flags) {
+  return new RegExp(`${DIRECTIVE_PREFIX_PATTERN}(${keywords})${suffix}`, flags);
+}
+function has_ignore_directive(text) {
+  return IGNORE_DIRECTIVE_REGEX.test(text);
+}
+function has_trailing_ignore_directive(text) {
+  return TRAILING_IGNORE_DIRECTIVE_REGEX.test(text);
+}
+function has_ignore_next_directive(text) {
+  return IGNORE_NEXT_DIRECTIVE_REGEX.test(text);
+}
+var DIRECTIVE_BODY_PREFIX_PATTERN, DIRECTIVE_PREFIX_PATTERN, FORWARD_DIRECTIVE_KEYWORDS = "do|run|include", BACKWARD_DIRECTIVE_KEYWORDS = "done-by|run-by|included-by", CALL_SITE_PARAMS_FRAGMENT, WORKING_DIR_DIRECTIVE_KEYWORDS = "working-directory|working-dir|current-directory|current-dir|cd|wd", DECLARATION_DIRECTIVE_KEYWORDS = "local|global|scalar|matrix|program", DIRECTIVE_PREFIX_REGEX, IGNORE_DIRECTIVE_REGEX, IGNORE_NEXT_DIRECTIVE_REGEX, VARIABLES_DIRECTIVE_PATTERN, DECLARATION_DIRECTIVE_PATTERN, TRAILING_IGNORE_DIRECTIVE_REGEX;
+var init_directives = __esm(() => {
+  DIRECTIVE_BODY_PREFIX_PATTERN = String.raw`(?:@lsp-|sight:\s*)`;
+  DIRECTIVE_PREFIX_PATTERN = String.raw`^\s*(?://|\*)\s*${DIRECTIVE_BODY_PREFIX_PATTERN}`;
+  CALL_SITE_PARAMS_FRAGMENT = String.raw`(?:\s+(?:line=\d+|match="(?:\\"|[^"])+"))*`;
+  DIRECTIVE_PREFIX_REGEX = new RegExp(DIRECTIVE_PREFIX_PATTERN);
+  IGNORE_DIRECTIVE_REGEX = new RegExp(`${DIRECTIVE_PREFIX_PATTERN}ignore:?\\s*$`);
+  IGNORE_NEXT_DIRECTIVE_REGEX = new RegExp(`${DIRECTIVE_PREFIX_PATTERN}ignore-next:?\\s*$`);
+  VARIABLES_DIRECTIVE_PATTERN = new RegExp(`${DIRECTIVE_PREFIX_PATTERN}variables:?\\s+(.+)\\s*$`);
+  DECLARATION_DIRECTIVE_PATTERN = new RegExp(`${DIRECTIVE_PREFIX_PATTERN}(${DECLARATION_DIRECTIVE_KEYWORDS}):?\\s+(.+)\\s*$`);
+  TRAILING_IGNORE_DIRECTIVE_REGEX = new RegExp(`//\\s*${DIRECTIVE_BODY_PREFIX_PATTERN}ignore:?\\s*$`);
+});
+
 // src/directive-parser/index.ts
 import * as path2 from "path";
 import * as fs3 from "fs";
@@ -15106,7 +15304,7 @@ function looks_like_unquoted_path_token(token) {
 }
 
 class DirectiveParser {
-  parse(content, file_uri) {
+  parse(content, file_uri, tokens) {
     const doc = { content, line_offsets: compute_line_offsets(content) };
     const line_count = get_line_count(doc);
     const the_directives = [];
@@ -15114,7 +15312,11 @@ class DirectiveParser {
     const containing_dir = path2.dirname(URI.parse(file_uri).fsPath);
     let working_directory;
     let working_dir_count = 0;
+    const block_lines = block_comment_lines(content, tokens);
     for (let i = 0;i < line_count; i++) {
+      if (block_lines.has(i)) {
+        continue;
+      }
       const my_line = get_line_text(doc, i);
       const my_trimmed = my_line.trim();
       if (my_trimmed !== "" && !my_trimmed.startsWith("*") && !my_trimmed.startsWith("//")) {
@@ -15157,10 +15359,10 @@ class DirectiveParser {
         const my_quoted_path = my_match[2];
         const my_unquoted_path = my_match[3];
         const my_raw_path = my_quoted_path || my_unquoted_path;
-        const my_params = my_trimmed.slice((my_match.index ?? 0) + my_match[0].length).trim();
+        const my_params = my_match[4]?.trim() ?? "";
         if (!my_quoted_path && my_unquoted_path && !looks_like_unquoted_path_token(my_unquoted_path)) {
           the_diagnostics.push({
-            message: "Malformed directive. Expected: " + '// @lsp-done-by: "path.do" or // @lsp-run-by: "path.do" or // @lsp-included-by: "path.do"',
+            message: "Malformed directive. Expected: " + '// sight: done-by: "path.do" or // sight: run-by: "path.do" or // sight: included-by: "path.do"',
             range: {
               start: { line: i, character: 0 },
               end: { line: i, character: my_line.length }
@@ -15182,9 +15384,9 @@ class DirectiveParser {
           call_site: my_call_site,
           range: my_range
         });
-      } else if (my_trimmed.includes("@lsp-done-by") || my_trimmed.includes("@lsp-run-by") || my_trimmed.includes("@lsp-included-by")) {
+      } else if (BACKWARD_DIRECTIVE_HEAD_PATTERN.test(my_trimmed)) {
         the_diagnostics.push({
-          message: "Malformed directive. Expected: " + '// @lsp-done-by "path" or // @lsp-run-by "path" or // @lsp-included-by "path"',
+          message: "Malformed directive. Expected: " + '// sight: done-by "path" or // sight: run-by "path" or // sight: included-by "path"',
           range: {
             start: { line: i, character: 0 },
             end: { line: i, character: my_line.length }
@@ -15193,9 +15395,9 @@ class DirectiveParser {
         });
       }
     }
-    const declaration_result = this.parse_declaration_directives(content, file_uri);
+    const declaration_result = this.parse_declaration_directives(content, file_uri, tokens);
     the_diagnostics.push(...declaration_result.diagnostics);
-    const forward_call_result = this.parse_forward_call_directives(content, file_uri);
+    const forward_call_result = this.parse_forward_call_directives(content, file_uri, tokens);
     the_diagnostics.push(...forward_call_result.diagnostics);
     if (working_dir_count > 1 && working_directory) {
       the_diagnostics.push({
@@ -15212,17 +15414,25 @@ class DirectiveParser {
       diagnostics: the_diagnostics
     };
   }
-  parse_forward_call_directives(content, _file_uri) {
+  parse_forward_call_directives(content, _file_uri, tokens) {
     const doc = { content, line_offsets: compute_line_offsets(content) };
     const line_count = get_line_count(doc);
     const the_forward_calls = [];
     const the_diagnostics = [];
+    const block_lines = block_comment_lines(content, tokens);
+    let the_block_ranges;
     const ignored_next_lines = new Set;
     for (let i = 0;i < line_count; i++) {
+      if (block_lines.has(i)) {
+        continue;
+      }
       const my_line = get_line_text(doc, i);
       const my_trimmed = my_line.trim();
-      if ((my_trimmed.startsWith("*") || my_trimmed.startsWith("//")) && my_trimmed.includes("@lsp-ignore-next")) {
+      if ((my_trimmed.startsWith("*") || my_trimmed.startsWith("//")) && (has_ignore_directive(my_trimmed) || has_ignore_next_directive(my_trimmed))) {
         for (let j = i + 1;j < line_count; j++) {
+          if (block_lines.has(j)) {
+            continue;
+          }
           const next_trimmed = get_line_text(doc, j).trim();
           if (next_trimmed !== "" && !next_trimmed.startsWith("*") && !next_trimmed.startsWith("//")) {
             ignored_next_lines.add(j);
@@ -15236,6 +15446,9 @@ class DirectiveParser {
       }
     }
     for (let i = 0;i < line_count; i++) {
+      if (block_lines.has(i)) {
+        continue;
+      }
       const my_line = get_line_text(doc, i);
       const my_trimmed = my_line.trim();
       if (!my_trimmed.startsWith("*") && !my_trimmed.startsWith("//")) {
@@ -15243,9 +15456,6 @@ class DirectiveParser {
       }
       const my_match = my_trimmed.match(FORWARD_CALL_DIRECTIVE_PATTERN);
       if (my_match) {
-        if (my_trimmed.includes("@lsp-ignore") && !my_trimmed.includes("@lsp-ignore-next")) {
-          continue;
-        }
         if (ignored_next_lines.has(i)) {
           continue;
         }
@@ -15253,7 +15463,7 @@ class DirectiveParser {
         const my_quoted_path = my_match[2];
         const my_unquoted_path = my_match[3];
         const my_raw_path = my_quoted_path || my_unquoted_path;
-        const my_params = my_trimmed.slice((my_match.index ?? 0) + my_match[0].length).trim();
+        const my_params = my_match[4]?.trim() ?? "";
         if (!my_raw_path) {
           the_diagnostics.push({
             message: "Forward call directive requires a path",
@@ -15264,7 +15474,7 @@ class DirectiveParser {
         }
         if (!my_quoted_path && my_unquoted_path && !looks_like_unquoted_path_token(my_unquoted_path)) {
           the_diagnostics.push({
-            message: "Malformed directive. Expected: " + '// @lsp-do: "path.do" or // @lsp-run: "path.do" or // @lsp-include: "path.do"',
+            message: "Malformed directive. Expected: " + '// sight: do: "path.do" or // sight: run: "path.do" or // sight: include: "path.do"',
             range: { start: { line: i, character: 0 }, end: { line: i, character: my_line.length } },
             severity: "warning"
           });
@@ -15279,7 +15489,10 @@ class DirectiveParser {
         if (my_call_site?.type === "line" && typeof my_call_site.value === "number") {
           my_call_site_line = Math.max(0, my_call_site.value - 1);
         } else if (my_call_site?.type === "match" && typeof my_call_site.value === "string") {
-          const match_line = this.find_match_line(content, my_call_site.value);
+          if (the_block_ranges === undefined) {
+            the_block_ranges = block_comment_ranges(content, tokens);
+          }
+          const match_line = this.find_match_line(content, my_call_site.value, the_block_ranges);
           if (match_line !== undefined) {
             my_call_site_line = match_line;
           } else {
@@ -15303,22 +15516,32 @@ class DirectiveParser {
           call_site: my_call_site,
           range: my_range
         });
+      } else if (!ignored_next_lines.has(i) && FORWARD_CALL_DIRECTIVE_HEAD_PATTERN.test(my_trimmed)) {
+        the_diagnostics.push({
+          message: "Malformed directive. Expected: " + '// sight: do: "path.do" or // sight: run: "path.do" or // sight: include: "path.do"',
+          range: { start: { line: i, character: 0 }, end: { line: i, character: my_line.length } },
+          severity: "warning"
+        });
       }
     }
     return { forward_calls: the_forward_calls, diagnostics: the_diagnostics };
   }
-  parse_declaration_directives(content, _file_uri) {
+  parse_declaration_directives(content, _file_uri, tokens) {
     const doc = { content, line_offsets: compute_line_offsets(content) };
     const line_count = get_line_count(doc);
     const the_declarations = [];
     const the_diagnostics = [];
+    const block_lines = block_comment_lines(content, tokens);
     for (let i = 0;i < line_count; i++) {
+      if (block_lines.has(i)) {
+        continue;
+      }
       const my_line = get_line_text(doc, i);
       const my_trimmed = my_line.trim();
       if (!my_trimmed.startsWith("*") && !my_trimmed.startsWith("//")) {
         continue;
       }
-      const my_match = my_trimmed.match(DECLARATION_DIRECTIVE_PATTERN);
+      const my_match = my_trimmed.match(DECLARATION_DIRECTIVE_HEAD_PATTERN);
       if (my_match) {
         const my_type = my_match[1];
         const my_rest = my_trimmed.slice((my_match.index ?? 0) + my_match[0].length).trim();
@@ -15349,7 +15572,8 @@ class DirectiveParser {
   parse_call_site(params) {
     const my_match_result = params.match(PARAM_MATCH);
     if (my_match_result) {
-      return { type: "match", value: my_match_result[1] };
+      const my_value = my_match_result[1].replace(/\\"/g, '"');
+      return { type: "match", value: my_value };
     }
     const my_line_result = params.match(PARAM_LINE);
     if (my_line_result) {
@@ -15380,12 +15604,44 @@ class DirectiveParser {
     }
     return my_resolved;
   }
-  find_match_line(parent_content, match_string) {
+  find_match_line(parent_content, match_string, block_ranges) {
     const doc = { content: parent_content, line_offsets: compute_line_offsets(parent_content) };
     const line_count = get_line_count(doc);
+    const the_block_ranges = block_ranges ?? block_comment_ranges(parent_content);
     for (let i = 0;i < line_count; i++) {
-      if (get_line_text(doc, i).includes(match_string)) {
-        return i;
+      const my_text = get_line_text(doc, i);
+      let my_from = 0;
+      while (my_from <= my_text.length) {
+        const my_col = my_text.indexOf(match_string, my_from);
+        if (my_col < 0) {
+          break;
+        }
+        if (!position_in_block_comment(i, my_col, the_block_ranges)) {
+          return i;
+        }
+        my_from = my_col + 1;
+      }
+    }
+    return;
+  }
+  classify_call_line(line_content) {
+    const my_trimmed = line_content.trim();
+    const command_match = my_trimmed.match(DO_INCLUDE_PATTERN);
+    if (command_match) {
+      const my_path = command_match[2] || command_match[3];
+      if (my_path) {
+        return command_match[1];
+      }
+    }
+    if (my_trimmed.startsWith("*") || my_trimmed.startsWith("//")) {
+      const directive_match = my_trimmed.match(FORWARD_CALL_DIRECTIVE_PATTERN);
+      if (directive_match) {
+        const my_quoted_path = directive_match[2];
+        const my_unquoted_path = directive_match[3];
+        const my_path = my_quoted_path || my_unquoted_path;
+        if (my_path && (my_quoted_path || looks_like_unquoted_path_token(my_unquoted_path))) {
+          return directive_match[1];
+        }
       }
     }
     return;
@@ -15395,7 +15651,11 @@ class DirectiveParser {
     const line_count = get_line_count(doc);
     const child_basename = path2.basename(child_filename);
     const child_without_ext = child_basename.toLowerCase().endsWith(".do") ? child_basename.slice(0, -3).toLowerCase() : child_basename.toLowerCase();
+    const block_lines = block_comment_lines(parent_content);
     for (let i = 0;i < line_count; i++) {
+      if (block_lines.has(i)) {
+        continue;
+      }
       const my_line = get_line_text(doc, i);
       const my_trimmed = my_line.trim();
       const my_match = my_line.match(DO_INCLUDE_PATTERN);
@@ -15412,12 +15672,12 @@ class DirectiveParser {
         }
       }
       if (my_trimmed.startsWith("*") || my_trimmed.startsWith("//")) {
-        const directive_match = my_trimmed.match(CALL_DIRECTIVE_PATTERN);
+        const directive_match = my_trimmed.match(FORWARD_CALL_DIRECTIVE_PATTERN);
         if (directive_match) {
           const my_quoted_path = directive_match[2];
           const my_unquoted_path = directive_match[3];
           const my_target_path = my_quoted_path || my_unquoted_path;
-          if (my_target_path) {
+          if (my_target_path && (my_quoted_path || looks_like_unquoted_path_token(my_unquoted_path))) {
             const my_target_basename = path2.basename(my_target_path);
             const my_target_without_ext = my_target_basename.toLowerCase().endsWith(".do") ? my_target_basename.slice(0, -3).toLowerCase() : my_target_basename.toLowerCase();
             if (my_target_without_ext === child_without_ext) {
@@ -15434,7 +15694,11 @@ class DirectiveParser {
     const line_count = get_line_count(doc);
     const child_basename = path2.basename(child_filename);
     const child_without_ext = child_basename.toLowerCase().endsWith(".do") ? child_basename.slice(0, -3).toLowerCase() : child_basename.toLowerCase();
+    const block_lines = block_comment_lines(parent_content);
     for (let i = 0;i < line_count; i++) {
+      if (block_lines.has(i)) {
+        continue;
+      }
       const my_line = get_line_text(doc, i);
       const my_trimmed = my_line.trim();
       const my_match = my_line.match(DO_INCLUDE_PATTERN);
@@ -15452,13 +15716,13 @@ class DirectiveParser {
         }
       }
       if (my_trimmed.startsWith("*") || my_trimmed.startsWith("//")) {
-        const directive_match = my_trimmed.match(CALL_DIRECTIVE_PATTERN);
+        const directive_match = my_trimmed.match(FORWARD_CALL_DIRECTIVE_PATTERN);
         if (directive_match) {
           const my_call_type = directive_match[1];
           const my_quoted_path = directive_match[2];
           const my_unquoted_path = directive_match[3];
           const my_target_path = my_quoted_path || my_unquoted_path;
-          if (my_target_path) {
+          if (my_target_path && (my_quoted_path || looks_like_unquoted_path_token(my_unquoted_path))) {
             const my_target_basename = path2.basename(my_target_path);
             const my_target_without_ext = my_target_basename.toLowerCase().endsWith(".do") ? my_target_basename.slice(0, -3).toLowerCase() : my_target_basename.toLowerCase();
             if (my_target_without_ext === child_without_ext) {
@@ -15476,7 +15740,11 @@ class DirectiveParser {
     const the_call_sites = [];
     const child_basename = path2.basename(child_filename);
     const child_without_ext = child_basename.toLowerCase().endsWith(".do") ? child_basename.slice(0, -3).toLowerCase() : child_basename.toLowerCase();
+    const block_lines = block_comment_lines(parent_content);
     for (let i = 0;i < line_count; i++) {
+      if (block_lines.has(i)) {
+        continue;
+      }
       const my_line = get_line_text(doc, i);
       const my_trimmed = my_line.trim();
       const my_match = my_line.match(DO_INCLUDE_PATTERN);
@@ -15494,13 +15762,13 @@ class DirectiveParser {
         }
       }
       if (my_trimmed.startsWith("*") || my_trimmed.startsWith("//")) {
-        const directive_match = my_trimmed.match(CALL_DIRECTIVE_PATTERN);
+        const directive_match = my_trimmed.match(FORWARD_CALL_DIRECTIVE_PATTERN);
         if (directive_match) {
           const my_call_type = directive_match[1];
           const my_quoted_path = directive_match[2];
           const my_unquoted_path = directive_match[3];
           const my_target_path = my_quoted_path || my_unquoted_path;
-          if (my_target_path) {
+          if (my_target_path && (my_quoted_path || looks_like_unquoted_path_token(my_unquoted_path))) {
             const my_target_basename = path2.basename(my_target_path);
             const my_target_without_ext = my_target_basename.toLowerCase().endsWith(".do") ? my_target_basename.slice(0, -3).toLowerCase() : my_target_basename.toLowerCase();
             if (my_target_without_ext === child_without_ext) {
@@ -15513,18 +15781,22 @@ class DirectiveParser {
     return the_call_sites;
   }
 }
-var DIRECTIVE_PATTERN, FORWARD_CALL_DIRECTIVE_PATTERN, WORKING_DIR_DIRECTIVE_PATTERN, PARAM_LINE, PARAM_MATCH, DECLARATION_DIRECTIVE_PATTERN, DO_INCLUDE_PATTERN, CALL_DIRECTIVE_PATTERN;
+var CALL_SITE_PARAMS_PATTERN, DIRECTIVE_PATTERN, BACKWARD_DIRECTIVE_HEAD_PATTERN, FORWARD_CALL_DIRECTIVE_PATTERN, FORWARD_CALL_DIRECTIVE_HEAD_PATTERN, WORKING_DIR_DIRECTIVE_PATTERN, PARAM_LINE, PARAM_MATCH, DECLARATION_DIRECTIVE_HEAD_PATTERN, DO_INCLUDE_PATTERN;
 var init_directive_parser = __esm(() => {
   init_esm();
   init_stata_call_patterns();
-  DIRECTIVE_PATTERN = /@lsp-(done-by|run-by|included-by):?\s+(?:"([^"]+)"|([^\s]+))/;
-  FORWARD_CALL_DIRECTIVE_PATTERN = /@lsp-(do|run|include):?\s+(?:"([^"]+)"|([^\s]+))/;
-  WORKING_DIR_DIRECTIVE_PATTERN = /@lsp-(working-directory|working-dir|current-directory|current-dir|cd|wd):?\s+(?:"([^"]+)"|([^\s]+))$/;
+  init_block_comment_utils();
+  init_directives();
+  CALL_SITE_PARAMS_PATTERN = String.raw`(${CALL_SITE_PARAMS_FRAGMENT})\s*$`;
+  DIRECTIVE_PATTERN = make_directive_pattern(BACKWARD_DIRECTIVE_KEYWORDS, String.raw`:?\s+(?:"([^"]+)"|([^\s]+))${CALL_SITE_PARAMS_PATTERN}`);
+  BACKWARD_DIRECTIVE_HEAD_PATTERN = make_directive_pattern(BACKWARD_DIRECTIVE_KEYWORDS, String.raw`(?=:|\s|$)`);
+  FORWARD_CALL_DIRECTIVE_PATTERN = make_directive_pattern(FORWARD_DIRECTIVE_KEYWORDS, String.raw`:?\s+(?:"([^"]+)"|([^\s]+))${CALL_SITE_PARAMS_PATTERN}`);
+  FORWARD_CALL_DIRECTIVE_HEAD_PATTERN = make_directive_pattern(FORWARD_DIRECTIVE_KEYWORDS, String.raw`(?=:|\s|$)`);
+  WORKING_DIR_DIRECTIVE_PATTERN = make_directive_pattern(WORKING_DIR_DIRECTIVE_KEYWORDS, String.raw`:?\s+(?:"([^"]+)"|([^\s]+))\s*$`);
   PARAM_LINE = /line=(\d+)/;
-  PARAM_MATCH = /match="([^"]+)"/;
-  DECLARATION_DIRECTIVE_PATTERN = /@lsp-(local|global|scalar|matrix|program)(?=\s|$)/;
+  PARAM_MATCH = /match="((?:\\"|[^"])+)"/;
+  DECLARATION_DIRECTIVE_HEAD_PATTERN = make_directive_pattern(DECLARATION_DIRECTIVE_KEYWORDS, String.raw`:?(?=\s|$)`);
   DO_INCLUDE_PATTERN = build_do_include_pattern("capture");
-  CALL_DIRECTIVE_PATTERN = /@lsp-(do|run|include):?\s+(?:"([^"]+)"|([^\s]+))/;
 });
 
 // src/analyzer/macro-creating-commands.ts
@@ -15675,20 +15947,23 @@ class SemanticAnalyzer {
     this.parse_declaration_directives_from_tokens(tokens, symbols);
     for (let i = 0;i < tokens.length; i++) {
       const token = tokens[i];
-      if (token.type === "COMMENT_LINE" || token.type === "COMMENT_BLOCK") {
+      if (token.type === "COMMENT_LINE") {
         const token_content = token.value.trim();
-        if (token_content.includes("@lsp-ignore-next")) {
-          for (let j = i + 1;j < tokens.length; j++) {
-            const next_token = tokens[j];
-            if (next_token.type !== "WHITESPACE" && next_token.type !== "COMMENT_LINE" && next_token.type !== "COMMENT_BLOCK" && next_token.type !== "CONTINUATION" && next_token.type !== "STATEMENT_TERMINATOR") {
-              this.config.ignored_lines.add(next_token.range.start.line);
-              break;
-            }
+        const is_standalone_comment = this.is_standalone_comment_token(tokens, i);
+        if (has_ignore_directive(token_content)) {
+          if (is_standalone_comment) {
+            this.ignore_next_non_trivia_line(tokens, i);
+          } else {
+            this.config.ignored_lines.add(token.range.start.line);
           }
-        } else if (token_content.includes("@lsp-ignore")) {
-          this.config.ignored_lines.add(token.range.start.line);
         }
-        const variables_match = token_content.match(/@lsp-variables\s+(.+)/);
+        if (has_ignore_next_directive(token_content)) {
+          this.ignore_next_non_trivia_line(tokens, i);
+        }
+        if (!is_standalone_comment) {
+          continue;
+        }
+        const variables_match = token_content.match(VARIABLES_DIRECTIVE_PATTERN);
         if (variables_match) {
           const var_names = variables_match[1].split(/\s+/).filter((v) => v.length > 0);
           for (const var_name of var_names) {
@@ -15698,37 +15973,31 @@ class SemanticAnalyzer {
       }
     }
   }
+  ignore_next_non_trivia_line(tokens, directive_index) {
+    for (let j = directive_index + 1;j < tokens.length; j++) {
+      const next_token = tokens[j];
+      if (next_token.type !== "WHITESPACE" && next_token.type !== "COMMENT_LINE" && next_token.type !== "COMMENT_BLOCK" && next_token.type !== "CONTINUATION" && next_token.type !== "STATEMENT_TERMINATOR") {
+        this.config.ignored_lines.add(next_token.range.start.line);
+        break;
+      }
+    }
+  }
   parse_declaration_directives_from_tokens(tokens, symbols) {
-    const DECLARATION_PATTERN = /@lsp-(local|global|scalar|matrix|program)\s+(.+)/;
-    for (const token of tokens) {
-      if (token.type !== "COMMENT_LINE" && token.type !== "COMMENT_BLOCK") {
+    for (let i = 0;i < tokens.length; i++) {
+      const token = tokens[i];
+      if (token.type !== "COMMENT_LINE") {
         continue;
       }
-      const token_content = token.value;
-      if (token.type === "COMMENT_BLOCK") {
-        const my_doc = { content: token_content, line_offsets: compute_line_offsets(token_content) };
-        const my_line_count = get_line_count(my_doc);
-        for (let line_offset = 0;line_offset < my_line_count; line_offset++) {
-          const my_line = get_line_text(my_doc, line_offset);
-          const my_match = my_line.match(DECLARATION_PATTERN);
-          if (my_match) {
-            const my_type = my_match[1];
-            const the_names = my_match[2].split(/\s+/).filter((n) => n.length > 0);
-            const my_actual_line = token.range.start.line + line_offset;
-            for (const my_name of the_names) {
-              this.register_declaration_directive(my_type, my_name, my_actual_line, symbols);
-            }
-          }
-        }
-      } else {
-        const my_match = token_content.match(DECLARATION_PATTERN);
-        if (my_match) {
-          const my_type = my_match[1];
-          const the_names = my_match[2].split(/\s+/).filter((n) => n.length > 0);
-          const my_actual_line = token.range.start.line;
-          for (const my_name of the_names) {
-            this.register_declaration_directive(my_type, my_name, my_actual_line, symbols);
-          }
+      if (!this.is_standalone_comment_token(tokens, i)) {
+        continue;
+      }
+      const my_match = token.value.match(DECLARATION_DIRECTIVE_PATTERN);
+      if (my_match) {
+        const my_type = my_match[1];
+        const the_names = my_match[2].split(/\s+/).filter((n) => n.length > 0);
+        const my_actual_line = token.range.start.line;
+        for (const my_name of the_names) {
+          this.register_declaration_directive(my_type, my_name, my_actual_line, symbols);
         }
       }
     }
@@ -15807,11 +16076,6 @@ class SemanticAnalyzer {
         this.parse_directive(trivia, node);
       }
     }
-    if (this.has_trivia(node) && node.trailingTrivia) {
-      for (const trivia of node.trailingTrivia) {
-        this.parse_directive(trivia, node);
-      }
-    }
     if (node.type === "program") {
       for (const child of node.body) {
         this.extract_directives_from_node(child);
@@ -15824,11 +16088,11 @@ class SemanticAnalyzer {
   }
   parse_directive(trivia, following_node) {
     const content = trivia.content.trim();
-    if (content.includes("@lsp-ignore-next")) {
+    if (has_ignore_directive(content) || has_ignore_next_directive(content)) {
       const line_to_ignore = following_node.range.start.line;
       this.config.ignored_lines.add(line_to_ignore);
     }
-    const variables_match = content.match(/@lsp-variables\s+(.+)/);
+    const variables_match = content.match(VARIABLES_DIRECTIVE_PATTERN);
     if (variables_match) {
       const var_names = variables_match[1].split(/\s+/).filter((v) => v.length > 0);
       for (const var_name of var_names) {
@@ -15836,6 +16100,20 @@ class SemanticAnalyzer {
       }
     }
   }
+  is_standalone_comment_token(tokens, comment_index) {
+    const comment = tokens[comment_index];
+    const line = comment.range.start.line;
+    for (let i = comment_index - 1;i >= 0; i--) {
+      const token = tokens[i];
+      if (token.range.start.line !== line) {
+        break;
+      }
+      if (token.type !== "WHITESPACE") {
+        return false;
+      }
+    }
+    return true;
+  }
   build_symbols(nodes, symbols, current_scope, all_scopes) {
     this.traverse_ast_preorder(nodes, (node, node_index) => {
       this.process_node(node, symbols, current_scope, all_scopes, node_index);
@@ -16322,7 +16600,7 @@ class SemanticAnalyzer {
       this.current_diagnostics.push({
         message: `Missing variable name after storage type \`${node.varlist[0].name}'`,
         range: node.varlist[0].range,
-        code: 2004 /* MISSING_VARIABLE_NAME */,
+        code: "MISSING_VARIABLE_NAME" /* MISSING_VARIABLE_NAME */,
         severity: "error"
       });
       return;
@@ -16833,7 +17111,7 @@ class SemanticAnalyzer {
       diagnostics.push({
         message: format_undefined_macro_message(node.scope, node.name),
         range: node.range,
-        code: 2001 /* UNDEFINED_MACRO */,
+        code: "UNDEFINED_MACRO" /* UNDEFINED_MACRO */,
         severity: "warning",
         symbol_name: node.name,
         reference_kind: node.scope
@@ -16851,7 +17129,7 @@ class SemanticAnalyzer {
       diagnostics.push({
         message: format_undefined_macro_message(macro_ref.scope, macro_ref.name),
         range: macro_ref.range,
-        code: 2001 /* UNDEFINED_MACRO */,
+        code: "UNDEFINED_MACRO" /* UNDEFINED_MACRO */,
         severity: "warning",
         symbol_name: macro_ref.name,
         reference_kind: macro_ref.scope
@@ -16873,7 +17151,7 @@ class SemanticAnalyzer {
           diagnostics.push({
             message: format_undefined_variable_message(var_node.name),
             range: var_node.range,
-            code: 2002 /* UNDEFINED_VARIABLE */,
+            code: "UNDEFINED_VARIABLE" /* UNDEFINED_VARIABLE */,
             severity: "information",
             symbol_name: var_node.name,
             reference_kind: "variable"
@@ -17001,7 +17279,7 @@ class SemanticAnalyzer {
           diagnostics.push({
             message: "Invalid character in macro name",
             range: token.range,
-            code: 3010 /* INVALID_MACRO_CHAR */,
+            code: "INVALID_MACRO_CHAR" /* INVALID_MACRO_CHAR */,
             severity: "error"
           });
           continue;
@@ -17011,7 +17289,7 @@ class SemanticAnalyzer {
           diagnostics.push({
             message: format_undefined_macro_message("local", macro_name),
             range: token.range,
-            code: 2001 /* UNDEFINED_MACRO */,
+            code: "UNDEFINED_MACRO" /* UNDEFINED_MACRO */,
             severity: "warning",
             symbol_name: macro_name,
             reference_kind: "local"
@@ -17030,7 +17308,7 @@ class SemanticAnalyzer {
           diagnostics.push({
             message: "Invalid character in macro name",
             range: token.range,
-            code: 3010 /* INVALID_MACRO_CHAR */,
+            code: "INVALID_MACRO_CHAR" /* INVALID_MACRO_CHAR */,
             severity: "error"
           });
           continue;
@@ -17040,7 +17318,7 @@ class SemanticAnalyzer {
           diagnostics.push({
             message: format_undefined_macro_message("global", macro_name),
             range: token.range,
-            code: 2001 /* UNDEFINED_MACRO */,
+            code: "UNDEFINED_MACRO" /* UNDEFINED_MACRO */,
             severity: "warning",
             symbol_name: macro_name,
             reference_kind: "global"
@@ -17193,6 +17471,7 @@ var init_analyzer = __esm(() => {
   init_types();
   init_directive_parser();
   init_macro_creating_commands();
+  init_directives();
   STATA_SYSTEM_GLOBALS = new Set([
     "S_DATE",
     "S_TIME",
@@ -17227,7 +17506,9 @@ var init_analyzer = __esm(() => {
 });
 
 // src/context-tracker/types.ts
-var init_types2 = () => {};
+var init_types2 = __esm(() => {
+  init_types();
+});
 
 // src/context-tracker/index.ts
 class ContextTracker {
@@ -17236,10 +17517,18 @@ class ContextTracker {
   context_stack = ["stata" /* STATA */];
   document_content = "";
   diagnostics = [];
+  block_comment_continuation_lines = new Set;
   initialize_from_tokens(tokens, document_content) {
     if (document_content !== undefined) {
       this.document_content = document_content;
     }
+    const my_comment_lines = block_comment_lines(this.document_content, tokens);
+    for (const my_token of tokens) {
+      if (!CONTEXT_TRIVIA_TOKEN_TYPES.has(my_token.type)) {
+        my_comment_lines.delete(my_token.range.start.line);
+      }
+    }
+    this.block_comment_continuation_lines = my_comment_lines;
     this.context_ranges = [];
     this.sorted_ranges_cache = null;
     this.context_stack = ["stata" /* STATA */];
@@ -17404,7 +17693,7 @@ class ContextTracker {
     this.diagnostics = [];
     for (const my_range of this.context_ranges) {
       if (!my_range.end_delimiter && !my_range.is_single_line) {
-        const my_error_code = my_range.context === "mata" /* MATA */ ? 4001 /* UNCLOSED_MATA_BLOCK */ : 4002 /* UNCLOSED_PYTHON_BLOCK */;
+        const my_error_code = my_range.context === "mata" /* MATA */ ? "UNCLOSED_MATA_BLOCK" /* UNCLOSED_MATA_BLOCK */ : "UNCLOSED_PYTHON_BLOCK" /* UNCLOSED_PYTHON_BLOCK */;
         this.diagnostics.push({
           message: my_range.context === "mata" /* MATA */ ? 'Unclosed mata block - missing "end" command' : 'Unclosed python block - missing "end" command',
           range: my_range.start_delimiter.range,
@@ -17421,6 +17710,9 @@ class ContextTracker {
     const my_line_count = get_line_count(my_doc);
     const my_valid_end_lines = this.find_valid_end_lines(my_doc);
     for (let my_line_number = 0;my_line_number < my_line_count; my_line_number++) {
+      if (this.block_comment_continuation_lines.has(my_line_number)) {
+        continue;
+      }
       const my_line = get_line_text(my_doc, my_line_number);
       const my_code_part = this.extract_code_before_comment(my_line);
       const my_code_trimmed = my_code_part.trim();
@@ -17454,7 +17746,7 @@ class ContextTracker {
               }
             },
             severity: "error",
-            code: 4003 /* UNEXPECTED_END */
+            code: "UNEXPECTED_END" /* UNEXPECTED_END */
           });
         }
       }
@@ -17469,7 +17761,7 @@ class ContextTracker {
             }
           },
           severity: "error",
-          code: 4005 /* MISMATCHED_END_PYTHON */
+          code: "MISMATCHED_END_PYTHON" /* MISMATCHED_END_PYTHON */
         });
       }
       if (my_code_trimmed === "end mata") {
@@ -17483,7 +17775,7 @@ class ContextTracker {
             }
           },
           severity: "warning",
-          code: 4007 /* INVALID_DELIMITER_POSITION */
+          code: "INVALID_DELIMITER_POSITION" /* INVALID_DELIMITER_POSITION */
         });
       }
       if (my_code_trimmed.startsWith("end ") && my_code_trimmed !== "end python") {
@@ -17502,7 +17794,7 @@ class ContextTracker {
               }
             },
             severity: "error",
-            code: 4007 /* INVALID_DELIMITER_POSITION */
+            code: "INVALID_DELIMITER_POSITION" /* INVALID_DELIMITER_POSITION */
           });
         }
       }
@@ -17532,6 +17824,9 @@ class ContextTracker {
     const my_embedded_stack = [];
     const my_line_count = get_line_count(doc);
     for (let my_line_number = 0;my_line_number < my_line_count; my_line_number++) {
+      if (this.block_comment_continuation_lines.has(my_line_number)) {
+        continue;
+      }
       const my_line = get_line_text(doc, my_line_number);
       const my_code_part = this.extract_code_before_comment(my_line);
       const my_code_trimmed = my_code_part.trim();
@@ -17686,27 +17981,27 @@ class ContextTracker {
   get_error_recovery_suggestions(error) {
     const my_suggestions = [];
     switch (error.code) {
-      case 4001 /* UNCLOSED_MATA_BLOCK */:
+      case "UNCLOSED_MATA_BLOCK" /* UNCLOSED_MATA_BLOCK */:
         my_suggestions.push('Add "end" command to close the mata block');
         my_suggestions.push('Ensure "end" is on its own line at the start of a statement');
         break;
-      case 4002 /* UNCLOSED_PYTHON_BLOCK */:
+      case "UNCLOSED_PYTHON_BLOCK" /* UNCLOSED_PYTHON_BLOCK */:
         my_suggestions.push('Add "end" command to close the python block');
         my_suggestions.push('Ensure "end" is on its own line at the start of a statement');
         break;
-      case 4003 /* UNEXPECTED_END */:
+      case "UNEXPECTED_END" /* UNEXPECTED_END */:
         my_suggestions.push('Remove "end" command or add a corresponding program, mata, python, or input block');
         my_suggestions.push('"end" can only be used to close a program, mata, python, or input block');
         break;
-      case 4005 /* MISMATCHED_END_PYTHON */:
+      case "MISMATCHED_END_PYTHON" /* MISMATCHED_END_PYTHON */:
         my_suggestions.push('Remove "end python" command or add a corresponding "python" block');
         my_suggestions.push('"end python" can only be used to close a python block');
         break;
-      case 4007 /* INVALID_DELIMITER_POSITION */:
+      case "INVALID_DELIMITER_POSITION" /* INVALID_DELIMITER_POSITION */:
         my_suggestions.push('Use "end" to close mata blocks, not "end mata"');
         my_suggestions.push("Ensure block delimiters are at statement boundaries");
         break;
-      case 4006 /* NESTED_BLOCK_ERROR */:
+      case "NESTED_BLOCK_ERROR" /* NESTED_BLOCK_ERROR */:
         my_suggestions.push("Check that nested blocks are properly closed in the correct order");
         my_suggestions.push("Inner blocks must be closed before outer blocks");
         break;
@@ -17720,6 +18015,9 @@ class ContextTracker {
     const my_doc = { content: this.document_content, line_offsets: compute_line_offsets(this.document_content) };
     const my_line_count = get_line_count(my_doc);
     for (let my_i = start_line + 1;my_i < my_line_count; my_i++) {
+      if (this.block_comment_continuation_lines.has(my_i)) {
+        continue;
+      }
       const my_line = get_line_text(my_doc, my_i);
       const my_code_part = this.extract_code_before_comment(my_line);
       const my_code_trimmed = my_code_part.trim();
@@ -17778,9 +18076,19 @@ end  // Correct order`
     ];
   }
 }
+var CONTEXT_TRIVIA_TOKEN_TYPES;
 var init_context_tracker = __esm(() => {
   init_types2();
   init_types();
+  init_block_comment_utils();
+  CONTEXT_TRIVIA_TOKEN_TYPES = new Set([
+    "COMMENT_LINE",
+    "COMMENT_BLOCK",
+    "CONTINUATION",
+    "WHITESPACE",
+    "STATEMENT_TERMINATOR",
+    "EOF"
+  ]);
 });
 
 // src/utils/parse-timeout.ts
@@ -18189,7 +18497,7 @@ class DocumentStore {
     const directive_parser = new DirectiveParser;
     let resolved_working_directory;
     try {
-      const directive_result = directive_parser.parse(content, uri);
+      const directive_result = directive_parser.parse(content, uri, lex_result.result.tokens);
       if (this.scope_resolver) {
         this.scope_resolver.sync_backward_directive_dependencies(uri, directive_result.directives);
       }
@@ -18251,7 +18559,7 @@ class DocumentStore {
     let all_forward_calls = analyze_result.result.forward_calls;
     try {
       const directive_parser2 = new DirectiveParser;
-      const directive_result = directive_parser2.parse_forward_call_directives(content, uri);
+      const directive_result = directive_parser2.parse_forward_call_directives(content, uri, lex_result.result.tokens);
       const directive_forward_calls = directive_result.forward_calls.map((d) => ({
         type: d.type,
         raw_path: d.raw_path,
@@ -18382,14 +18690,16 @@ class DocumentStore {
         message: error.message,
         severity: import_vscode_languageserver.DiagnosticSeverity.Error,
         code: error.code,
-        source: "sight"
+        source: "sight",
+        ...diagnostic_code_description_fields(error.code)
       })),
       ...parser_errors.map((error) => ({
         range: error.range,
         message: error.message,
         severity: import_vscode_languageserver.DiagnosticSeverity.Error,
         code: error.code,
-        source: "sight"
+        source: "sight",
+        ...diagnostic_code_description_fields(error.code)
       })),
       ...analyzer_diagnostics.map((diag) => ({
         range: diag.range,
@@ -18397,6 +18707,7 @@ class DocumentStore {
         severity: diag.severity === "error" ? import_vscode_languageserver.DiagnosticSeverity.Error : diag.severity === "warning" ? import_vscode_languageserver.DiagnosticSeverity.Warning : diag.severity === "information" ? import_vscode_languageserver.DiagnosticSeverity.Information : import_vscode_languageserver.DiagnosticSeverity.Hint,
         code: diag.code,
         source: "sight",
+        ...diagnostic_code_description_fields(diag.code),
         ...undefined_symbol_data_fields(diag)
       }))
     ];
@@ -18417,6 +18728,7 @@ class DocumentStore {
 }
 var import_vscode_languageserver;
 var init_document_store = __esm(() => {
+  init_diagnostic_code_description();
   init_lexer();
   init_parser();
   init_analyzer();
@@ -18537,7 +18849,7 @@ class ForwardScopeResolver {
             message: `${source_prefix}Maximum forward resolution ` + `depth (${resolved_config.max_forward_depth}) ` + `exceeded`,
             severity: max_depth_setting,
             kind: "truncation",
-            code: 7002 /* CROSS_FILE_TRUNCATED */,
+            code: "CROSS_FILE_TRUNCATED" /* CROSS_FILE_TRUNCATED */,
             range: anchor_range,
             source: {
               source_file: path4.basename(URI.parse(anchor_uri).fsPath),
@@ -18562,7 +18874,7 @@ class ForwardScopeResolver {
           range: my_call.range,
           severity: "warning",
           kind: "path_case_mismatch",
-          code: 7001 /* PATH_CASE_MISMATCH */,
+          code: "PATH_CASE_MISMATCH" /* PATH_CASE_MISMATCH */,
           case_mismatch_seed_dir: my_path_result.seed_dir,
           source: {
             source_file: path4.basename(URI.parse(file_uri).fsPath),
@@ -18578,6 +18890,7 @@ class ForwardScopeResolver {
           range: my_call.range,
           severity: "warning",
           kind: "missing_file",
+          code: "CROSS_FILE_MISSING_FILE" /* CROSS_FILE_MISSING_FILE */,
           source: {
             source_file: my_source_filename,
             source_line: my_call.call_site_line,
@@ -18627,6 +18940,8 @@ class ForwardScopeResolver {
           message: `${source_prefix}Cannot read file: ${my_call.raw_path}${error_suffix}`,
           range: my_call.range,
           severity: "warning",
+          kind: "missing_file",
+          code: "CROSS_FILE_MISSING_FILE" /* CROSS_FILE_MISSING_FILE */,
           source: {
             source_file: source_filename,
             source_line: my_call.call_site_line,
@@ -19297,19 +19612,17 @@ class ScopeResolver {
     const total_lines = get_line_count(doc);
     return line_number >= 0 && line_number < total_lines;
   }
-  validate_call_statement(line_content) {
-    const my_trimmed = line_content.trim();
-    const command_match = my_trimmed.match(DO_INCLUDE_PATTERN2);
-    if (command_match) {
-      return command_match[1];
-    }
-    if (my_trimmed.startsWith("*") || my_trimmed.startsWith("//")) {
-      const directive_match = my_trimmed.match(DIRECTIVE_PATTERN2);
-      if (directive_match) {
-        return directive_match[1];
-      }
+  validate_call_statement(parent_content, line_number, block_ranges) {
+    const doc = {
+      content: parent_content,
+      line_offsets: compute_line_offsets(parent_content)
+    };
+    const line_content = get_line_text(doc, line_number);
+    const leading_col = line_content.search(/\S/);
+    if (leading_col >= 0 && position_in_block_comment(line_number, leading_col, block_ranges)) {
+      return;
     }
-    return;
+    return this.directive_parser.classify_call_line(line_content);
   }
   detect_mixed_call_types(parent_content, child_filename) {
     const all_call_sites = this.directive_parser.find_all_call_sites_for_file(parent_content, child_filename);
@@ -19326,7 +19639,7 @@ class ScopeResolver {
   maybe_emit_included_by_mismatch(directive_type, detected_call_type, range, parent_filename, source_line, diagnostics) {
     if (directive_type === "included-by" && detected_call_type !== "include") {
       diagnostics.push({
-        message: `Directive @lsp-included-by used but caller uses ${detected_call_type} (not include). Local macros will not be inherited.`,
+        message: `Directive sight: included-by used but caller uses ${detected_call_type} (not include). Local macros will not be inherited.`,
         range,
         severity: "warning",
         source: {
@@ -19342,7 +19655,7 @@ class ScopeResolver {
       const call_site_severity = config.diagnostics?.call_site_identification ?? "information";
       if (call_site_severity !== "off") {
         diagnostics.push({
-          message: `Directive @lsp-done-by used but caller uses include. Full inheritance (including local macros) will occur.`,
+          message: `Directive sight: done-by used but caller uses include. Full inheritance (including local macros) will occur.`,
           range,
           severity: call_site_severity,
           source: {
@@ -19384,7 +19697,7 @@ class ScopeResolver {
       if (has_done_by && has_included_by) {
         const my_range = the_group.find((d) => d.type === "included-by")?.range ?? the_group[0].range;
         diagnostics.push({
-          message: "Both @lsp-done-by and @lsp-included-by reference the same parent; " + "treating as included-by (full inheritance).",
+          message: "Both sight: done-by and sight: included-by reference the same parent; " + "treating as included-by (full inheritance).",
           range: my_range,
           severity: "warning"
         });
@@ -19441,7 +19754,7 @@ class ScopeResolver {
       range: directive.range,
       severity: "warning",
       kind: "path_case_mismatch",
-      code: 7001 /* PATH_CASE_MISMATCH */,
+      code: "PATH_CASE_MISMATCH" /* PATH_CASE_MISMATCH */,
       case_mismatch_seed_dir: seed_dir,
       source: {
         source_file: path5.basename(URI.parse(child_uri).fsPath),
@@ -19710,7 +20023,7 @@ class ScopeResolver {
           range: chain_range,
           severity: max_depth_setting,
           kind: "truncation",
-          code: 7002 /* CROSS_FILE_TRUNCATED */,
+          code: "CROSS_FILE_TRUNCATED" /* CROSS_FILE_TRUNCATED */,
           source: {
             source_file: parent_basename,
             ...has_known_call_site ? { source_line: call_site_line } : {},
@@ -19827,7 +20140,7 @@ class ScopeResolver {
           range: default_range,
           severity: max_depth_severity,
           kind: "truncation",
-          code: 7002 /* CROSS_FILE_TRUNCATED */,
+          code: "CROSS_FILE_TRUNCATED" /* CROSS_FILE_TRUNCATED */,
           source: {
             source_file: source_filename,
             source_line: 0,
@@ -19873,6 +20186,7 @@ class ScopeResolver {
           range: my_directive.range,
           severity: "warning",
           kind: "missing_file",
+          code: "CROSS_FILE_MISSING_FILE" /* CROSS_FILE_MISSING_FILE */,
           source: {
             source_file: source_filename,
             original_range: my_directive.range
@@ -19889,6 +20203,7 @@ class ScopeResolver {
       let my_call_site_line;
       let effective_call_type = my_directive.type === "included-by" ? "include" : "do";
       if (my_directive.call_site) {
+        const my_block_ranges = block_comment_ranges(my_parent_content);
         if (my_directive.call_site.type === "line") {
           my_call_site_line = my_directive.call_site.value - 1;
           if (!this.is_line_in_bounds(my_call_site_line, my_parent_content)) {
@@ -19905,12 +20220,10 @@ class ScopeResolver {
             });
             my_call_site_line = config.assume_call_site === "end" ? Number.MAX_SAFE_INTEGER : 0;
           } else {
-            const doc = { content: my_parent_content, line_offsets: compute_line_offsets(my_parent_content) };
-            const line_content = get_line_text(doc, my_call_site_line);
-            const call_validation = this.validate_call_statement(line_content);
+            const call_validation = this.validate_call_statement(my_parent_content, my_call_site_line, my_block_ranges);
             if (!call_validation) {
               diagnostics.push({
-                message: `Specified line=${my_directive.call_site.value} does not contain a do/run/include command or @lsp-do/run/include directive.`,
+                message: `Specified line=${my_directive.call_site.value} does not contain a do/run/include command or forward directive.`,
                 range: my_directive.range,
                 severity: "warning",
                 source: {
@@ -19926,7 +20239,7 @@ class ScopeResolver {
             }
           }
         } else {
-          const my_match_line = this.directive_parser.find_match_line(my_parent_content, my_directive.call_site.value);
+          const my_match_line = this.directive_parser.find_match_line(my_parent_content, my_directive.call_site.value, my_block_ranges);
           if (my_match_line === undefined) {
             diagnostics.push({
               message: `Match string "${my_directive.call_site.value}" not found in parent file "${parent_filename}". Using default call site assumption.`,
@@ -19940,9 +20253,7 @@ class ScopeResolver {
             my_call_site_line = config.assume_call_site === "end" ? Number.MAX_SAFE_INTEGER : 0;
           } else {
             my_call_site_line = my_match_line;
-            const doc = { content: my_parent_content, line_offsets: compute_line_offsets(my_parent_content) };
-            const line_content = get_line_text(doc, my_call_site_line);
-            const matched_call_type = this.validate_call_statement(line_content);
+            const matched_call_type = this.validate_call_statement(my_parent_content, my_call_site_line, my_block_ranges);
             if (matched_call_type) {
               effective_call_type = matched_call_type;
               this.maybe_emit_included_by_mismatch(my_directive.type, matched_call_type, my_directive.range, parent_filename, my_call_site_line, diagnostics);
@@ -20089,7 +20400,7 @@ class ScopeResolver {
     const effective_working_directory = own_working_directory ?? inherited_working_directory;
     const my_analysis = this.analyzer.analyze(my_parse_result.ast, uri, undefined, {
       working_directory: effective_working_directory
-    });
+    }, my_lex_result.tokens);
     const directive_forward_calls = (my_directive_result.forward_calls ?? []).map((d) => ({
       type: d.type,
       raw_path: d.raw_path,
@@ -20857,7 +21168,7 @@ class ScopeResolver {
     this.reset_reverse_deps();
   }
 }
-var DEFAULT_CONFIG2, DO_INCLUDE_PATTERN2, DIRECTIVE_PATTERN2;
+var DEFAULT_CONFIG2;
 var init_scope_resolver = __esm(() => {
   init_esm();
   init_types();
@@ -20867,8 +21178,8 @@ var init_scope_resolver = __esm(() => {
   init_analyzer();
   init_logger();
   init_workspace_roots();
-  init_stata_call_patterns();
   init_file_path_utils();
+  init_block_comment_utils();
   init_visible_symbols();
   DEFAULT_CONFIG2 = {
     assume_call_site: "end",
@@ -20876,8 +21187,6 @@ var init_scope_resolver = __esm(() => {
     max_forward_depth: 10,
     max_chain_depth: 20
   };
-  DO_INCLUDE_PATTERN2 = build_do_include_pattern("prefix");
-  DIRECTIVE_PATTERN2 = /@lsp-(do|run|include):?\s+/;
 });
 
 // src/utils/include-expander.ts
@@ -21582,7 +21891,7 @@ var init_indexer = __esm(() => {
         const lexResult = this.lexer.tokenize(content);
         const parseResult = this.parser.parse(lexResult.tokens);
         const workspace_root = get_workspace_root_for_path(this.workspace_roots, file_path);
-        const analyzeResult = this.analyzer.analyze(parseResult.ast, file_uri, undefined);
+        const analyzeResult = this.analyzer.analyze(parseResult.ast, file_uri, undefined, undefined, lexResult.tokens);
         const own_working_directory = directive_result.working_directory ? resolve_working_directory_directive(directive_result.working_directory, workspace_root) : undefined;
         let effective_working_directory = own_working_directory;
         if (own_working_directory === undefined && this.scope_resolver) {
@@ -22189,13 +22498,13 @@ class IndentationDiagnosticAnalyzer {
     }
     const indent_size = config.formatting?.indentSize ?? 4;
     const stataRanges = this.getStataRanges(document);
-    const block_comment_lines = this.compute_block_comment_lines(lines);
+    const block_comment_lines2 = this.compute_block_comment_lines(lines, document.tokens);
     const continuation_lines = document.tokens ? this.compute_continuation_lines(document.tokens) : new Set;
     for (const range of stataRanges) {
-      diagnostics.push(...this.find_comment_indentation_issues(lines, range, block_comment_lines, indent_size));
-      diagnostics.push(...this.find_block_indentation_issues(document, lines, range, block_comment_lines, indent_size, continuation_lines));
+      diagnostics.push(...this.find_comment_indentation_issues(lines, range, block_comment_lines2, indent_size));
+      diagnostics.push(...this.find_block_indentation_issues(document, lines, range, block_comment_lines2, indent_size, continuation_lines));
       const expected_depths = this.compute_expected_depths(document, range);
-      diagnostics.push(...this.find_unnecessary_indentation_issues(document, lines, range, block_comment_lines, indent_size, expected_depths, continuation_lines));
+      diagnostics.push(...this.find_unnecessary_indentation_issues(document, lines, range, block_comment_lines2, indent_size, expected_depths, continuation_lines));
     }
     return diagnostics;
   }
@@ -22246,10 +22555,10 @@ class IndentationDiagnosticAnalyzer {
   is_continuation_line(lineIndex, continuation_lines) {
     return continuation_lines.has(lineIndex);
   }
-  find_comment_indentation_issues(lines, range, block_comment_lines, indent_size) {
+  find_comment_indentation_issues(lines, range, block_comment_lines2, indent_size) {
     const diagnostics = [];
     for (let i = range.start;i < range.end && i < lines.length - 1; i++) {
-      if (block_comment_lines.has(i) || block_comment_lines.has(i + 1)) {
+      if (block_comment_lines2.has(i) || block_comment_lines2.has(i + 1)) {
         continue;
       }
       const line = lines[i];
@@ -22265,17 +22574,18 @@ class IndentationDiagnosticAnalyzer {
             range: import_node.Range.create(import_node.Position.create(i + 1, 0), import_node.Position.create(i + 1, nextIndent)),
             message: "Line appears unnecessarily indented after comment. Use Format Document to fix.",
             source: "sight",
-            code: 5001 /* UNNECESSARY_INDENTATION */
+            code: "UNNECESSARY_INDENTATION" /* UNNECESSARY_INDENTATION */,
+            ...diagnostic_code_description_fields("UNNECESSARY_INDENTATION" /* UNNECESSARY_INDENTATION */)
           });
         }
       }
     }
     return diagnostics;
   }
-  find_block_indentation_issues(document, lines, range, block_comment_lines, indent_size, continuation_lines) {
+  find_block_indentation_issues(document, lines, range, block_comment_lines2, indent_size, continuation_lines) {
     const diagnostics = [];
     for (let i = range.start;i <= range.end && i < lines.length; i++) {
-      if (block_comment_lines.has(i)) {
+      if (block_comment_lines2.has(i)) {
         continue;
       }
       const line = lines[i];
@@ -22285,7 +22595,7 @@ class IndentationDiagnosticAnalyzer {
         const braceIndent = this.get_statement_indentation(lines, i, range.start, indent_size, continuation_lines);
         let braceDepth = 1;
         for (let j = i + 1;j <= range.end && j < lines.length && braceDepth > 0; j++) {
-          if (block_comment_lines.has(j)) {
+          if (block_comment_lines2.has(j)) {
             continue;
           }
           const innerLine = lines[j];
@@ -22315,7 +22625,8 @@ class IndentationDiagnosticAnalyzer {
               range: import_node.Range.create(import_node.Position.create(j, 0), import_node.Position.create(j, innerIndent)),
               message: "Line should be indented inside brace block. Use Format Document to fix.",
               source: "sight",
-              code: 5002 /* MISSING_INDENTATION */
+              code: "MISSING_INDENTATION" /* MISSING_INDENTATION */,
+              ...diagnostic_code_description_fields("MISSING_INDENTATION" /* MISSING_INDENTATION */)
             });
           }
         }
@@ -22336,35 +22647,51 @@ class IndentationDiagnosticAnalyzer {
     }
     return false;
   }
-  compute_block_comment_lines(lines) {
-    const block_comment_lines = new Set;
-    let in_block_comment = false;
+  compute_block_comment_lines(lines, tokens) {
+    if (tokens && tokens.length > 0) {
+      return this.block_comment_lines_from_tokens(tokens);
+    }
+    const block_comment_lines2 = new Set;
+    let block_comment_depth = 0;
     for (let i = 0;i < lines.length; i++) {
       const line = lines[i];
       let j = 0;
       while (j < line.length) {
-        if (!in_block_comment) {
-          if (j + 1 < line.length && line[j] === "/" && line[j + 1] === "*") {
-            in_block_comment = true;
-            block_comment_lines.add(i);
-            j += 2;
-            continue;
-          }
-        } else {
-          block_comment_lines.add(i);
+        if (j + 1 < line.length && line[j] === "/" && line[j + 1] === "*") {
+          block_comment_depth++;
+          block_comment_lines2.add(i);
+          j += 2;
+          continue;
+        }
+        if (block_comment_depth > 0) {
+          block_comment_lines2.add(i);
           if (j + 1 < line.length && line[j] === "*" && line[j + 1] === "/") {
-            in_block_comment = false;
+            block_comment_depth--;
             j += 2;
             continue;
           }
         }
         j++;
       }
-      if (in_block_comment) {
-        block_comment_lines.add(i);
+      if (block_comment_depth > 0) {
+        block_comment_lines2.add(i);
       }
     }
-    return block_comment_lines;
+    return block_comment_lines2;
+  }
+  block_comment_lines_from_tokens(tokens) {
+    const the_block_comment_lines = new Set;
+    for (const my_token of tokens) {
+      const my_spans_lines = my_token.range.end.line > my_token.range.start.line;
+      const my_is_multiline_comment = my_token.type === "COMMENT_BLOCK" || my_token.type === "COMMENT_LINE" && my_spans_lines;
+      if (!my_is_multiline_comment) {
+        continue;
+      }
+      for (let my_line = my_token.range.start.line;my_line <= my_token.range.end.line; my_line++) {
+        the_block_comment_lines.add(my_line);
+      }
+    }
+    return the_block_comment_lines;
   }
   get_statement_indentation(lines, lineIndex, rangeStart, indent_size, continuation_lines) {
     let current_index = lineIndex;
@@ -22473,8 +22800,8 @@ class IndentationDiagnosticAnalyzer {
   is_block_node_type(node) {
     return node.type === "program" || node.type === "if" || node.type === "else" || node.type === "foreach" || node.type === "forvalues" || node.type === "while" || node.type === "frame";
   }
-  should_skip_unnecessary_check(line, lineIndex, block_comment_lines, continuation_lines) {
-    if (block_comment_lines.has(lineIndex)) {
+  should_skip_unnecessary_check(line, lineIndex, block_comment_lines2, continuation_lines) {
+    if (block_comment_lines2.has(lineIndex)) {
       return true;
     }
     const trimmed = line.trim();
@@ -22489,11 +22816,11 @@ class IndentationDiagnosticAnalyzer {
     }
     return false;
   }
-  find_unnecessary_indentation_issues(document, lines, range, block_comment_lines, indent_size, expected_depths, continuation_lines) {
+  find_unnecessary_indentation_issues(document, lines, range, block_comment_lines2, indent_size, expected_depths, continuation_lines) {
     const diagnostics = [];
     for (let i = range.start;i <= range.end && i < lines.length; i++) {
       const line = lines[i];
-      if (this.should_skip_unnecessary_check(line, i, block_comment_lines, continuation_lines)) {
+      if (this.should_skip_unnecessary_check(line, i, block_comment_lines2, continuation_lines)) {
         continue;
       }
       const actual_indent = this.get_line_indentation(line, indent_size);
@@ -22505,7 +22832,8 @@ class IndentationDiagnosticAnalyzer {
           range: import_node.Range.create(import_node.Position.create(i, 0), import_node.Position.create(i, actual_indent)),
           message: "Line appears unnecessarily indented. Use Format Document to fix.",
           source: "sight",
-          code: 5001 /* UNNECESSARY_INDENTATION */
+          code: "UNNECESSARY_INDENTATION" /* UNNECESSARY_INDENTATION */,
+          ...diagnostic_code_description_fields("UNNECESSARY_INDENTATION" /* UNNECESSARY_INDENTATION */)
         });
       }
     }
@@ -22516,6 +22844,7 @@ var import_node, CONTROL_FLOW_RE, FIRST_WORD_RE;
 var init_indentation_diagnostics = __esm(() => {
   init_types2();
   init_types();
+  init_diagnostic_code_description();
   import_node = __toESM(require_main4(), 1);
   CONTROL_FLOW_RE = /^(if|foreach|while|program|mata|python)\b/;
   FIRST_WORD_RE = /^(\w+)\b/;
@@ -22525,9 +22854,10 @@ var init_indentation_diagnostics = __esm(() => {
 class OperatorSequenceAnalyzer {
   analyze(document, config) {
     const malformed_severity = config.diagnostics?.severity?.malformedOperator ?? "warning";
+    const spaced_compound_severity = config.diagnostics?.severity?.spacedCompoundOperator ?? "information";
     const invalid_severity = config.diagnostics?.severity?.invalidOperatorSequence ?? "error";
     const cstyle_severity = config.diagnostics?.severity?.cStyleLogicalInControlFlow ?? "information";
-    if (malformed_severity === "off" && invalid_severity === "off" && cstyle_severity === "off") {
+    if (malformed_severity === "off" && spaced_compound_severity === "off" && invalid_severity === "off" && cstyle_severity === "off") {
       return [];
     }
     const the_tokens = document.tokens;
@@ -22562,7 +22892,10 @@ class OperatorSequenceAnalyzer {
       }
       let config_severity;
       switch (pair_result.kind) {
-        case "suggestible":
+        case "spaced_compound":
+          config_severity = spaced_compound_severity;
+          break;
+        case "malformed":
           config_severity = malformed_severity;
           break;
         case "invalid":
@@ -22582,7 +22915,8 @@ class OperatorSequenceAnalyzer {
         message: pair_result.message,
         severity,
         source: "sight",
-        code: pair_result.code
+        code: pair_result.code,
+        ...diagnostic_code_description_fields(pair_result.code)
       };
       the_diagnostics.push(diagnostic);
       i = next_index;
@@ -22620,16 +22954,28 @@ class OperatorSequenceAnalyzer {
     const first_value = first_token.value;
     const second_value = second_token.value;
     const pair_key = `${first_value} ${second_value}`;
-    const suggested_compound = SUGGESTIBLE_PAIRS.get(pair_key);
-    if (suggested_compound) {
+    const spaced_compound = SPACED_COMPOUND_PAIRS.get(pair_key);
+    if (spaced_compound) {
+      return {
+        kind: "spaced_compound",
+        first_token,
+        second_token,
+        pair_key,
+        message: `Spaced compound operator '${pair_key}'. Stata treats this as ` + `'${spaced_compound}'; consider writing '${spaced_compound}'.`,
+        default_severity: import_node2.DiagnosticSeverity.Information,
+        code: "SPACED_COMPOUND_OPERATOR" /* SPACED_COMPOUND_OPERATOR */
+      };
+    }
+    const malformed_suggestion = MALFORMED_OPERATOR_PAIRS.get(pair_key);
+    if (malformed_suggestion) {
       return {
-        kind: "suggestible",
+        kind: "malformed",
         first_token,
         second_token,
         pair_key,
-        message: `Malformed operator '${pair_key}'. Did you mean '${suggested_compound}'?`,
+        message: `Malformed operator '${pair_key}'. Did you mean '${malformed_suggestion}'?`,
         default_severity: import_node2.DiagnosticSeverity.Warning,
-        code: 6001 /* MALFORMED_OPERATOR */
+        code: "MALFORMED_OPERATOR" /* MALFORMED_OPERATOR */
       };
     }
     if (CSTYLE_LOGICAL_PAIRS.has(pair_key)) {
@@ -22643,7 +22989,7 @@ class OperatorSequenceAnalyzer {
           pair_key,
           message,
           default_severity: import_node2.DiagnosticSeverity.Information,
-          code: 6003 /* CSTYLE_LOGICAL_IN_CONTROL_FLOW */
+          code: "CSTYLE_LOGICAL_IN_CONTROL_FLOW" /* CSTYLE_LOGICAL_IN_CONTROL_FLOW */
         };
       } else {
         const special_message = CSTYLE_QUALIFIER_MESSAGES.get(pair_key);
@@ -22655,7 +23001,7 @@ class OperatorSequenceAnalyzer {
           pair_key,
           message,
           default_severity: import_node2.DiagnosticSeverity.Error,
-          code: 6002 /* INVALID_OPERATOR_SEQUENCE */
+          code: "INVALID_OPERATOR_SEQUENCE" /* INVALID_OPERATOR_SEQUENCE */
         };
       }
     }
@@ -22669,7 +23015,7 @@ class OperatorSequenceAnalyzer {
         pair_key,
         message,
         default_severity: import_node2.DiagnosticSeverity.Error,
-        code: 6002 /* INVALID_OPERATOR_SEQUENCE */
+        code: "INVALID_OPERATOR_SEQUENCE" /* INVALID_OPERATOR_SEQUENCE */
       };
     }
     if (this.is_allowed_adjacency(first_value, second_value)) {
@@ -22789,15 +23135,18 @@ class OperatorSequenceAnalyzer {
     }
   }
 }
-var import_node2, SUGGESTIBLE_PAIRS, INVALID_PAIRS, CSTYLE_LOGICAL_PAIRS, SPECIAL_MESSAGES, CSTYLE_QUALIFIER_MESSAGES, CSTYLE_CONTROL_FLOW_MESSAGES, ARITHMETIC_OPS, COMPARISON_OPS, NEGATION_OPS, TRIVIA_TYPES, ADJACENCY_BREAKERS;
+var import_node2, SPACED_COMPOUND_PAIRS, MALFORMED_OPERATOR_PAIRS, INVALID_PAIRS, CSTYLE_LOGICAL_PAIRS, SPECIAL_MESSAGES, CSTYLE_QUALIFIER_MESSAGES, CSTYLE_CONTROL_FLOW_MESSAGES, ARITHMETIC_OPS, COMPARISON_OPS, NEGATION_OPS, TRIVIA_TYPES, ADJACENCY_BREAKERS;
 var init_operator_sequence_diagnostics = __esm(() => {
   init_types();
+  init_diagnostic_code_description();
   import_node2 = __toESM(require_main4(), 1);
-  SUGGESTIBLE_PAIRS = new Map([
+  SPACED_COMPOUND_PAIRS = new Map([
     ["< =", "<="],
     ["> =", ">="],
     ["! =", "!="],
-    ["~ =", "~="],
+    ["~ =", "~="]
+  ]);
+  MALFORMED_OPERATOR_PAIRS = new Map([
     ["= =", "=="]
   ]);
   INVALID_PAIRS = new Set([
@@ -23002,7 +23351,8 @@ class MixedLogicalOperatorAnalyzer {
         message: "Mixed '&' and '|' without parentheses. " + "Use parentheses to clarify precedence " + "(e.g., '(x & y) | z' or 'x & (y | z)')",
         severity: my_severity,
         source: "sight",
-        code: 6004 /* MIXED_LOGICAL_OPERATORS */
+        code: "MIXED_LOGICAL_OPERATORS" /* MIXED_LOGICAL_OPERATORS */,
+        ...diagnostic_code_description_fields("MIXED_LOGICAL_OPERATORS" /* MIXED_LOGICAL_OPERATORS */)
       });
     }
   }
@@ -23022,6 +23372,7 @@ class MixedLogicalOperatorAnalyzer {
 var import_node3, LOGICAL_OPS, QUALIFIER_BREAKERS, EXPRESSION_BREAKERS;
 var init_mixed_logical_diagnostics = __esm(() => {
   init_types();
+  init_diagnostic_code_description();
   import_node3 = __toESM(require_main4(), 1);
   LOGICAL_OPS = new Set(["&", "|"]);
   QUALIFIER_BREAKERS = new Set(["if", "in"]);
@@ -23035,6 +23386,15 @@ var init_mixed_logical_diagnostics = __esm(() => {
 
 // src/providers/diagnostics.ts
 import { createHash } from "crypto";
+function is_lexer_error_code(code) {
+  return typeof code === "string" && LEXER_ERROR_CODES.has(code);
+}
+function is_parser_error_code(code) {
+  return typeof code === "string" && PARSER_ERROR_CODES.has(code);
+}
+function is_stata_diagnostic_code(code) {
+  return typeof code === "string" && STATA_DIAGNOSTIC_CODES.has(code);
+}
 
 class DiagnosticsProvider {
   connection;
@@ -23121,17 +23481,17 @@ class DiagnosticsProvider {
       if (this.is_in_embedded_context(my_diagnostic.range.start, the_context_ranges)) {
         continue;
       }
-      if (defer_undefined_diagnostics && (my_diagnostic.code === 2001 /* UNDEFINED_MACRO */ || my_diagnostic.code === 2002 /* UNDEFINED_VARIABLE */)) {
+      if (defer_undefined_diagnostics && (my_diagnostic.code === "UNDEFINED_MACRO" /* UNDEFINED_MACRO */ || my_diagnostic.code === "UNDEFINED_VARIABLE" /* UNDEFINED_VARIABLE */)) {
         continue;
       }
-      const is_undefined_symbol = my_diagnostic.code === 2001 /* UNDEFINED_MACRO */ || my_diagnostic.code === 2002 /* UNDEFINED_VARIABLE */;
+      const is_undefined_symbol = my_diagnostic.code === "UNDEFINED_MACRO" /* UNDEFINED_MACRO */ || my_diagnostic.code === "UNDEFINED_VARIABLE" /* UNDEFINED_VARIABLE */;
       const symbol_name = is_undefined_symbol ? this.extract_symbol_name_from_diagnostic(my_diagnostic) : null;
       const reference_kind = is_undefined_symbol ? this.classify_reference_kind(my_diagnostic) : null;
       if (resolved_scope && symbol_name) {
         if (this.is_symbol_defined_in_scope(symbol_name, resolved_scope.symbols, my_diagnostic.code, document.uri, reference_kind)) {
           continue;
         }
-        if (my_diagnostic.code === 2001 /* UNDEFINED_MACRO */ && this.is_c_local_from_resolved_program(symbol_name, resolved_scope.symbols, document, my_diagnostic.range.start.line)) {
+        if (my_diagnostic.code === "UNDEFINED_MACRO" /* UNDEFINED_MACRO */ && this.is_c_local_from_resolved_program(symbol_name, resolved_scope.symbols, document, my_diagnostic.range.start.line)) {
           continue;
         }
       }
@@ -23250,15 +23610,12 @@ class DiagnosticsProvider {
   extract_lexer_errors(document) {
     const lexer_errors = [];
     for (const diag of document.diagnostics) {
-      if (diag.code && typeof diag.code === "number") {
-        const code = diag.code;
-        if (code >= 1001 && code <= 1004) {
-          lexer_errors.push({
-            message: diag.message,
-            range: diag.range,
-            code
-          });
-        }
+      if (is_lexer_error_code(diag.code)) {
+        lexer_errors.push({
+          message: diag.message,
+          range: diag.range,
+          code: diag.code
+        });
       }
     }
     return lexer_errors;
@@ -23266,15 +23623,12 @@ class DiagnosticsProvider {
   extract_parser_errors(document) {
     const parser_errors = [];
     for (const diag of document.diagnostics) {
-      if (diag.code && typeof diag.code === "number") {
-        const code = diag.code;
-        if (code >= 3000 && code <= 3014) {
-          parser_errors.push({
-            message: diag.message,
-            range: diag.range,
-            code
-          });
-        }
+      if (is_parser_error_code(diag.code)) {
+        parser_errors.push({
+          message: diag.message,
+          range: diag.range,
+          code: diag.code
+        });
       }
     }
     return parser_errors;
@@ -23282,25 +23636,26 @@ class DiagnosticsProvider {
   extract_semantic_diagnostics(document) {
     const semantic_diags = [];
     for (const diag of document.diagnostics) {
-      if (diag.code && typeof diag.code === "number") {
-        const code = diag.code;
-        if (code === 2001 /* UNDEFINED_MACRO */ || code === 2002 /* UNDEFINED_VARIABLE */ || code === 2004 /* MISSING_VARIABLE_NAME */) {
-          const severity_map = {
-            [import_vscode_languageserver2.DiagnosticSeverity.Error]: "error",
-            [import_vscode_languageserver2.DiagnosticSeverity.Warning]: "warning",
-            [import_vscode_languageserver2.DiagnosticSeverity.Information]: "information",
-            [import_vscode_languageserver2.DiagnosticSeverity.Hint]: "hint"
-          };
-          const data = diag.data;
-          semantic_diags.push({
-            message: diag.message,
-            range: diag.range,
-            code,
-            severity: severity_map[diag.severity ?? import_vscode_languageserver2.DiagnosticSeverity.Error],
-            symbol_name: data?.symbol_name,
-            reference_kind: data?.reference_kind
-          });
-        }
+      if (!is_stata_diagnostic_code(diag.code)) {
+        continue;
+      }
+      const code = diag.code;
+      if (code === "UNDEFINED_MACRO" /* UNDEFINED_MACRO */ || code === "UNDEFINED_VARIABLE" /* UNDEFINED_VARIABLE */ || code === "INVALID_MACRO_CHAR" /* INVALID_MACRO_CHAR */ || code === "MISSING_VARIABLE_NAME" /* MISSING_VARIABLE_NAME */) {
+        const severity_map = {
+          [import_vscode_languageserver2.DiagnosticSeverity.Error]: "error",
+          [import_vscode_languageserver2.DiagnosticSeverity.Warning]: "warning",
+          [import_vscode_languageserver2.DiagnosticSeverity.Information]: "information",
+          [import_vscode_languageserver2.DiagnosticSeverity.Hint]: "hint"
+        };
+        const data = diag.data;
+        semantic_diags.push({
+          message: diag.message,
+          range: diag.range,
+          code,
+          severity: severity_map[diag.severity ?? import_vscode_languageserver2.DiagnosticSeverity.Error],
+          symbol_name: data?.symbol_name,
+          reference_kind: data?.reference_kind
+        });
       }
     }
     return semantic_diags;
@@ -23322,15 +23677,15 @@ class DiagnosticsProvider {
   convert_lexer_error(error, config) {
     let severity;
     switch (error.code) {
-      case 1001 /* UNBALANCED_QUOTES */:
-      case 1002 /* UNBALANCED_BLOCK_COMMENT */:
-      case 1003 /* UNTERMINATED_STATEMENT */:
+      case "UNBALANCED_QUOTES" /* UNBALANCED_QUOTES */:
+      case "UNBALANCED_BLOCK_COMMENT" /* UNBALANCED_BLOCK_COMMENT */:
+      case "UNTERMINATED_STATEMENT" /* UNTERMINATED_STATEMENT */:
         severity = import_vscode_languageserver2.DiagnosticSeverity.Error;
         break;
-      case 1004 /* CONTINUATION_NO_SPACE */:
+      case "CONTINUATION_NO_SPACE" /* CONTINUATION_NO_SPACE */:
         severity = this.get_severity_from_config(config.diagnostics.severity.styleWarnings);
         break;
-      case 1005 /* BLOCK_COMMENT_IN_STAR_COMMENT */:
+      case "BLOCK_COMMENT_IN_STAR_COMMENT" /* BLOCK_COMMENT_IN_STAR_COMMENT */:
         severity = import_vscode_languageserver2.DiagnosticSeverity.Warning;
         break;
       default:
@@ -23344,21 +23699,22 @@ class DiagnosticsProvider {
       message: error.message,
       severity,
       code: error.code,
-      source: "sight"
+      source: "sight",
+      ...diagnostic_code_description_fields(error.code)
     };
   }
   get_undefined_symbol_severity_setting(diagnostic_code, config) {
-    if (diagnostic_code === 2001 /* UNDEFINED_MACRO */) {
+    if (diagnostic_code === "UNDEFINED_MACRO" /* UNDEFINED_MACRO */) {
       return config.diagnostics.severity.undefinedMacro;
     }
-    if (diagnostic_code === 2002 /* UNDEFINED_VARIABLE */) {
+    if (diagnostic_code === "UNDEFINED_VARIABLE" /* UNDEFINED_VARIABLE */) {
       return config.diagnostics.severity.undefinedVariable;
     }
     return null;
   }
   convert_parser_error(error, _config) {
     let severity = import_vscode_languageserver2.DiagnosticSeverity.Error;
-    if (error.code === 3006 /* CODE_AFTER_OPEN_BRACE */ || error.code === 3009 /* REDUNDANT_MACRO_SUFFIX */) {
+    if (error.code === "CODE_AFTER_OPEN_BRACE" /* CODE_AFTER_OPEN_BRACE */ || error.code === "REDUNDANT_MACRO_SUFFIX" /* REDUNDANT_MACRO_SUFFIX */) {
       severity = import_vscode_languageserver2.DiagnosticSeverity.Warning;
     }
     return {
@@ -23366,38 +23722,42 @@ class DiagnosticsProvider {
       message: error.message,
       severity,
       code: error.code,
-      source: "sight"
+      source: "sight",
+      ...diagnostic_code_description_fields(error.code)
     };
   }
   should_suppress_undefined_symbol(document, diagnostic_range) {
     const diagnostic_line = diagnostic_range.start.line;
-    const line_count = get_line_count(document);
-    if (diagnostic_line < line_count) {
-      const current_line = get_line_text(document, diagnostic_line);
-      if (current_line.includes("// @lsp-ignore")) {
-        return true;
-      }
+    if (document.ignored_lines?.has(diagnostic_line)) {
+      return true;
+    }
+    if (document.tokens && document.tokens.length > 0) {
+      return false;
+    }
+    const current_line = get_line_text(document, diagnostic_line);
+    if (has_trailing_ignore_directive(current_line)) {
+      return true;
     }
     if (diagnostic_line > 0) {
       const previous_line = get_line_text(document, diagnostic_line - 1);
-      if (previous_line.includes("// @lsp-ignore-next")) {
+      if (has_ignore_directive(previous_line) || has_ignore_next_directive(previous_line)) {
         return true;
       }
     }
     return false;
   }
   convert_semantic_diagnostic(diagnostic, config, document) {
-    if (document && (diagnostic.code === 2001 /* UNDEFINED_MACRO */ || diagnostic.code === 2002 /* UNDEFINED_VARIABLE */ || diagnostic.code === 2003 /* OUT_OF_SCOPE_SYMBOL */)) {
+    if (document && (diagnostic.code === "UNDEFINED_MACRO" /* UNDEFINED_MACRO */ || diagnostic.code === "UNDEFINED_VARIABLE" /* UNDEFINED_VARIABLE */ || diagnostic.code === "OUT_OF_SCOPE_SYMBOL" /* OUT_OF_SCOPE_SYMBOL */)) {
       if (this.should_suppress_undefined_symbol(document, diagnostic.range)) {
         return null;
       }
     }
     let severity;
     switch (diagnostic.code) {
-      case 2001 /* UNDEFINED_MACRO */:
-      case 2002 /* UNDEFINED_VARIABLE */:
-      case 2003 /* OUT_OF_SCOPE_SYMBOL */: {
-        const severity_setting = this.get_undefined_symbol_severity_setting(diagnostic.code === 2003 /* OUT_OF_SCOPE_SYMBOL */ ? diagnostic.base_code : diagnostic.code, config);
+      case "UNDEFINED_MACRO" /* UNDEFINED_MACRO */:
+      case "UNDEFINED_VARIABLE" /* UNDEFINED_VARIABLE */:
+      case "OUT_OF_SCOPE_SYMBOL" /* OUT_OF_SCOPE_SYMBOL */: {
+        const severity_setting = this.get_undefined_symbol_severity_setting(diagnostic.code === "OUT_OF_SCOPE_SYMBOL" /* OUT_OF_SCOPE_SYMBOL */ ? diagnostic.base_code : diagnostic.code, config);
         if (!severity_setting) {
           severity = this.semantic_severity_to_lsp(diagnostic.severity);
           break;
@@ -23417,6 +23777,7 @@ class DiagnosticsProvider {
       severity,
       code: diagnostic.code,
       source: "sight",
+      ...diagnostic_code_description_fields(diagnostic.code),
       ...undefined_symbol_data_fields(diagnostic)
     };
   }
@@ -23424,7 +23785,7 @@ class DiagnosticsProvider {
     return this.convert_semantic_diagnostic({
       message: format_out_of_scope_message(symbol_name, match.symbol_kind, match.reason),
       range: base_diagnostic.range,
-      code: 2003 /* OUT_OF_SCOPE_SYMBOL */,
+      code: "OUT_OF_SCOPE_SYMBOL" /* OUT_OF_SCOPE_SYMBOL */,
       severity: base_diagnostic.severity,
       base_code: base_diagnostic.code
     }, config, document);
@@ -23523,15 +23884,7 @@ class DiagnosticsProvider {
     return false;
   }
   is_stata_specific_error(error_code) {
-    const structural_errors = [
-      1001 /* UNBALANCED_QUOTES */,
-      1002 /* UNBALANCED_BLOCK_COMMENT */
-    ];
-    if (typeof error_code === "number") {
-      return !structural_errors.includes(error_code);
-    }
-    const error_code_str = String(error_code).toLowerCase();
-    return !(error_code_str.includes("quote") || error_code_str.includes("comment") || error_code_str.includes("brace"));
+    return !STRUCTURAL_EMBEDDED_ERROR_CODES.has(error_code);
   }
   convert_context_diagnostic(diagnostic) {
     const severity_map = {
@@ -23544,7 +23897,8 @@ class DiagnosticsProvider {
       message: diagnostic.message,
       severity: severity_map[diagnostic.severity],
       code: diagnostic.code,
-      source: "sight"
+      source: "sight",
+      ...diagnostic_code_description_fields(diagnostic.code)
     };
   }
   convert_directive_diagnostic(diagnostic, config) {
@@ -23566,7 +23920,8 @@ class DiagnosticsProvider {
         message: diagnostic.message,
         severity: severity2,
         code: diagnostic.code,
-        source: "sight"
+        source: "sight",
+        ...diagnostic_code_description_fields(diagnostic.code)
       };
     }
     if (diagnostic.kind === "truncation") {
@@ -23575,7 +23930,8 @@ class DiagnosticsProvider {
         message: diagnostic.message,
         severity: this.semantic_severity_to_lsp(diagnostic.severity),
         code: diagnostic.code,
-        source: "sight"
+        source: "sight",
+        ...diagnostic_code_description_fields(diagnostic.code)
       };
     }
     const is_missing_file = diagnostic.kind === "missing_file" || diagnostic.message.includes("Cannot read file");
@@ -23588,7 +23944,9 @@ class DiagnosticsProvider {
       range: diagnostic.range,
       message: diagnostic.message,
       severity,
-      source: "sight"
+      code: diagnostic.code,
+      source: "sight",
+      ...diagnostic_code_description_fields(diagnostic.code)
     };
   }
   extract_symbol_name_from_diagnostic(diagnostic) {
@@ -23598,7 +23956,7 @@ class DiagnosticsProvider {
     const is_external_symbol = (symbol) => {
       return !!symbol?.sourceUri && symbol.sourceUri !== current_document_uri;
     };
-    if (diagnostic_code === 2001 /* UNDEFINED_MACRO */) {
+    if (diagnostic_code === "UNDEFINED_MACRO" /* UNDEFINED_MACRO */) {
       if (reference_kind === "local") {
         return is_external_symbol(symbols.localMacros.get(symbol_name));
       }
@@ -23607,7 +23965,7 @@ class DiagnosticsProvider {
       }
       return false;
     }
-    if (diagnostic_code === 2002 /* UNDEFINED_VARIABLE */) {
+    if (diagnostic_code === "UNDEFINED_VARIABLE" /* UNDEFINED_VARIABLE */) {
       if (reference_kind !== "variable") {
         return false;
       }
@@ -23622,7 +23980,7 @@ class DiagnosticsProvider {
       }
       return symbol.sourceUri === current_document_uri || symbol.location?.uri === current_document_uri;
     };
-    if (diagnostic_code === 2001 /* UNDEFINED_MACRO */) {
+    if (diagnostic_code === "UNDEFINED_MACRO" /* UNDEFINED_MACRO */) {
       if (reference_kind === "local") {
         return is_from_current_document(symbols.localMacros.get(symbol_name));
       }
@@ -23631,13 +23989,13 @@ class DiagnosticsProvider {
       }
       return is_from_current_document(symbols.localMacros.get(symbol_name)) || is_from_current_document(symbols.globalMacros.get(symbol_name));
     }
-    if (diagnostic_code === 2002 /* UNDEFINED_VARIABLE */) {
+    if (diagnostic_code === "UNDEFINED_VARIABLE" /* UNDEFINED_VARIABLE */) {
       return is_from_current_document(symbols.variables.get(symbol_name)) || is_from_current_document(symbols.scalars?.get(symbol_name)) || is_from_current_document(symbols.matrices?.get(symbol_name));
     }
     return false;
   }
   is_symbol_excluded_by_forward_call(symbol_name, call_site, diagnostic_code, reference_kind, current_document_uri) {
-    if (diagnostic_code !== 2001 /* UNDEFINED_MACRO */) {
+    if (diagnostic_code !== "UNDEFINED_MACRO" /* UNDEFINED_MACRO */) {
       return false;
     }
     if (reference_kind !== "local") {
@@ -23653,7 +24011,7 @@ class DiagnosticsProvider {
     const is_external_symbol = (symbol) => {
       return !!symbol?.sourceUri && symbol.sourceUri !== current_document_uri;
     };
-    if (diagnostic_code === 2001 /* UNDEFINED_MACRO */) {
+    if (diagnostic_code === "UNDEFINED_MACRO" /* UNDEFINED_MACRO */) {
       if (reference_kind === "local") {
         return effective_type === "include" && is_external_symbol(symbols.localMacros.get(symbol_name));
       }
@@ -23662,7 +24020,7 @@ class DiagnosticsProvider {
       }
       return false;
     }
-    if (diagnostic_code === 2002 /* UNDEFINED_VARIABLE */) {
+    if (diagnostic_code === "UNDEFINED_VARIABLE" /* UNDEFINED_VARIABLE */) {
       if (reference_kind !== "variable") {
         return false;
       }
@@ -23731,16 +24089,25 @@ class DiagnosticsProvider {
     return reference_kind === out_of_scope_type;
   }
 }
-var import_vscode_languageserver2, host_probe;
+var import_vscode_languageserver2, LEXER_ERROR_CODES, PARSER_ERROR_CODES, STATA_DIAGNOSTIC_CODES, STRUCTURAL_EMBEDDED_ERROR_CODES, host_probe;
 var init_diagnostics = __esm(() => {
   init_types2();
   init_types();
   init_scope_resolver();
+  init_diagnostic_code_description();
   init_file_path_utils();
+  init_directives();
   init_indentation_diagnostics();
   init_operator_sequence_diagnostics();
   init_mixed_logical_diagnostics();
   import_vscode_languageserver2 = __toESM(require_main4(), 1);
+  LEXER_ERROR_CODES = new Set(Object.values(LexerErrorCode));
+  PARSER_ERROR_CODES = new Set(Object.values(ParseErrorCode));
+  STATA_DIAGNOSTIC_CODES = new Set(Object.values(StataDiagnosticCode));
+  STRUCTURAL_EMBEDDED_ERROR_CODES = new Set([
+    "UNBALANCED_QUOTES" /* UNBALANCED_QUOTES */,
+    "UNBALANCED_BLOCK_COMMENT" /* UNBALANCED_BLOCK_COMMENT */
+  ]);
   host_probe = host_is_case_sensitive;
 });
 
@@ -24656,6 +25023,28 @@ function is_cursor_in_comment_from_tokens(tokens, position) {
   }
   return false;
 }
+function is_cursor_in_block_comment(document, position, options) {
+  if (document.tokens && document.tokens.length > 0) {
+    const the_candidates = document.token_line_index?.size ? document.token_line_index.get(position.line) ?? [] : document.tokens;
+    for (const my_token of the_candidates) {
+      const is_block = my_token.type === "COMMENT_BLOCK";
+      const is_spanned_line = my_token.type === "COMMENT_LINE" && my_token.range.end.line > my_token.range.start.line;
+      if (is_block || is_spanned_line) {
+        if (is_position_in_range(position, my_token.range)) {
+          return true;
+        }
+        if (!my_token.value.endsWith("*/") && position.line === my_token.range.end.line && position.character === my_token.range.end.character) {
+          return true;
+        }
+      }
+    }
+    return false;
+  }
+  if (options?.require_tokens) {
+    return false;
+  }
+  return is_in_block_comment(document.content, position);
+}
 function is_cursor_in_comment_heuristic(content, position) {
   const doc = { content, line_offsets: compute_line_offsets(content) };
   const current_line = get_line_text(doc, position.line);
@@ -24936,7 +25325,7 @@ function detect_completion_context(document, position, tokens, command_db) {
     return extended_macro_context;
   }
   const directive_context = detect_directive_context(text_before_cursor);
-  if (directive_context) {
+  if (directive_context && !is_cursor_in_block_comment(document, position)) {
     return directive_context;
   }
   const command_path_context = detect_command_path_context(text_before_cursor);
@@ -25084,8 +25473,7 @@ function detect_directive_context(text_before_cursor) {
     return null;
   }
   const comment_content = comment_match[2];
-  const directive_pattern = /(@lsp-[a-zA-Z-]+)\s*:\s*(.*)$/;
-  const directive_match = comment_content.match(directive_pattern);
+  const directive_match = comment_content.match(DIRECTIVE_PATH_CONTEXT_PATTERN);
   if (directive_match) {
     const directive = directive_match[1];
     const path_part = directive_match[2];
@@ -25360,6 +25748,9 @@ class CompletionProvider {
         this.context_tracker = document.context_tracker;
       }
       const my_current_context = this.context_tracker ? this.context_tracker.get_context_at_position(position) : "stata" /* STATA */;
+      if (my_current_context === "stata" /* STATA */ && is_cursor_in_block_comment(document, position, { require_tokens: true })) {
+        return [];
+      }
       const context = detect_completion_context(document, position, undefined, this.command_db);
       if (my_current_context !== "stata" /* STATA */ && context.type !== "macro") {
         const my_boundary_completions = this.get_block_boundary_completions(document, position);
@@ -26682,7 +27073,7 @@ class CompletionProvider {
     return true;
   }
 }
-var import_vscode_languageserver4;
+var import_vscode_languageserver4, DIRECTIVE_PATH_CONTEXT_PATTERN;
 var init_completion = __esm(() => {
   init_command_database();
   init_types2();
@@ -26690,9 +27081,12 @@ var init_completion = __esm(() => {
   init_scope_resolver();
   init_analyzer();
   init_file_path_utils();
+  init_directives();
+  init_comment_utils();
   init_logger();
   init_macro_completion();
   import_vscode_languageserver4 = __toESM(require_main4(), 1);
+  DIRECTIVE_PATH_CONTEXT_PATTERN = new RegExp(`^\\s*(${DIRECTIVE_BODY_PREFIX_PATTERN}[a-zA-Z-]+)\\s*:?\\s*(.*)$`);
 });
 
 // src/utils/marker-scanner.ts
@@ -27327,6 +27721,7 @@ var init_server_handlers = __esm(() => {
         undefinedVariable: "off",
         styleWarnings: "hint",
         malformedOperator: "warning",
+        spacedCompoundOperator: "information",
         invalidOperatorSequence: "error",
         cStyleLogicalInControlFlow: "information",
         mixedLogicalOperators: "warning"
@@ -27460,6 +27855,9 @@ function validate_comment_formatting_config(config, log_warning) {
       if (diagnostics.severity.malformedOperator && valid_severities.includes(diagnostics.severity.malformedOperator)) {
         validated_config.diagnostics.severity.malformedOperator = diagnostics.severity.malformedOperator;
       }
+      if (diagnostics.severity.spacedCompoundOperator && valid_severities.includes(diagnostics.severity.spacedCompoundOperator)) {
+        validated_config.diagnostics.severity.spacedCompoundOperator = diagnostics.severity.spacedCompoundOperator;
+      }
       if (diagnostics.severity.invalidOperatorSequence && valid_severities.includes(diagnostics.severity.invalidOperatorSequence)) {
         validated_config.diagnostics.severity.invalidOperatorSequence = diagnostics.severity.invalidOperatorSequence;
       }
@@ -27626,7 +28024,7 @@ function diagnostic_exceeds_threshold(diagnostic, max_severity) {
   return severity_level(diagnostic) > max_severity;
 }
 function is_truncation_diagnostic(diagnostic) {
-  return diagnostic.code === 7002 /* CROSS_FILE_TRUNCATED */;
+  return diagnostic.code === "CROSS_FILE_TRUNCATED" /* CROSS_FILE_TRUNCATED */;
 }
 function env_flag_is_set(value) {
   return value !== undefined && value.length > 0;
@@ -27657,9 +28055,14 @@ function code_text(code) {
     return code;
   return "";
 }
+function text_code_text(code) {
+  if (typeof code === "string")
+    return code.toLowerCase();
+  return code_text(code);
+}
 function sarif_rule_id(code) {
   const value = code_text(code);
-  return /^\d+$/.test(value) ? `SIGHT${value}` : value || "SIGHT";
+  return value || "SIGHT";
 }
 function severity_word(diagnostic) {
   switch (diagnostic.severity) {
@@ -27720,7 +28123,7 @@ function render_text(records, options) {
     if (is_truncation_diagnostic(record.diagnostic)) {
       truncation_count++;
     }
-    const code = code_text(record.diagnostic.code);
+    const code = text_code_text(record.diagnostic.code);
     const code_suffix = code ? ` [${code}]` : "";
     lines.push(`${record.relative_path}:` + `${record.diagnostic.range.start.line + 1}:` + `${record.diagnostic.range.start.character + 1} ` + `${colorize(word, options.use_color)}: ` + `${record.diagnostic.message}${code_suffix}`);
   }
@@ -27756,11 +28159,15 @@ function render_sarif(records, version) {
         driver: {
           name: "sight",
           version,
-          rules: rule_ids.map((id) => ({
-            id,
-            name: id,
-            shortDescription: { text: id }
-          }))
+          rules: rule_ids.map((id) => {
+            const description = id === "SIGHT" ? undefined : diagnostic_code_description(id);
+            return {
+              id,
+              name: id,
+              shortDescription: { text: id },
+              ...description ? { helpUri: description.href } : {}
+            };
+          })
         }
       },
       results: sorted.map((record) => ({
@@ -27786,6 +28193,7 @@ function render_sarif(records, version) {
 var import_vscode_languageserver5, EXIT_OK = 0, EXIT_CHECK_FAILED = 1, EXIT_OPERATOR_ERROR = 2, FORCE_COLOR_DISABLED_VALUES;
 var init_shared = __esm(() => {
   init_types();
+  init_diagnostic_code_description();
   import_vscode_languageserver5 = __toESM(require_main4(), 1);
   FORCE_COLOR_DISABLED_VALUES = new Set(["0", "false", "off"]);
 });
@@ -27884,7 +28292,8 @@ function file_level_diagnostic(code, message) {
     severity: import_vscode_languageserver6.DiagnosticSeverity.Error,
     source: "sight",
     code,
-    message
+    message,
+    ...diagnostic_code_description_fields(code)
   };
 }
 function size_limit_diagnostic(actual_bytes, limit_bytes) {
@@ -27972,6 +28381,7 @@ function read_source_file(file_path) {
 var import_vscode_languageserver6;
 var init_source_files = __esm(() => {
   init_file_path_utils();
+  init_diagnostic_code_description();
   init_shared();
   import_vscode_languageserver6 = __toESM(require_main4(), 1);
 });
@@ -30458,15 +30868,17 @@ class DefinitionProvider {
     if (cancellation_token?.isCancellationRequested) {
       return null;
     }
+    const my_context_tracker = context_tracker ?? document.context_tracker;
+    const my_context = my_context_tracker ? my_context_tracker.get_context_at_position(position) : "stata" /* STATA */;
+    if (my_context === "stata" /* STATA */ && is_cursor_in_block_comment(document, position, { require_tokens: true })) {
+      return null;
+    }
     const file_definition = this.get_include_definition(document, position);
     if (file_definition) {
       return file_definition;
     }
-    if (context_tracker) {
-      const my_context = context_tracker.get_context_at_position(position);
-      if (my_context !== "stata" /* STATA */) {
-        return await this.get_macro_definition_only(document, position, workspace_symbols, scope_resolver, workspace_indexer, cross_file_config, cancellation_token);
-      }
+    if (my_context !== "stata" /* STATA */) {
+      return await this.get_macro_definition_only(document, position, workspace_symbols, scope_resolver, workspace_indexer, cross_file_config, cancellation_token);
     }
     const word_info = this.get_word_at_position(document, position);
     if (!word_info) {
@@ -31106,22 +31518,18 @@ class DefinitionProvider {
         }
       }
     }
-    const directive_match = line_text.match(/@lsp-(done-by|included-by|do|run|include):?\s+(?:"([^"]+)"|([^\s]+))/);
-    if (directive_match) {
+    const directive_match = line_text.match(PATH_BEARING_DIRECTIVE_PATTERN);
+    if (directive_match && is_cursor_in_comment(document, position) && !is_cursor_in_block_comment(document, position)) {
       const quoted_path = directive_match[2];
       const unquoted_path = directive_match[3];
       const file_path = quoted_path || unquoted_path;
       const match_start = directive_match.index;
-      const DIRECTIVE_PREFIX = "@lsp-";
-      let cursor = match_start + DIRECTIVE_PREFIX.length + directive_match[1].length;
-      if (line_text[cursor] === ":")
-        cursor++;
-      while (cursor < line_text.length && /\s/.test(line_text[cursor])) {
-        cursor++;
-      }
-      if (quoted_path)
-        cursor++;
-      const path_start = cursor;
+      const keyword_start = directive_match[0].indexOf(directive_match[1]);
+      const path_literal = quoted_path ? `"${file_path}"` : file_path;
+      const path_literal_start = directive_match[0].indexOf(path_literal, keyword_start + directive_match[1].length);
+      if (path_literal_start < 0)
+        return null;
+      const path_start = match_start + path_literal_start + (quoted_path ? 1 : 0);
       const path_end = path_start + file_path.length;
       if (position.character >= path_start && position.character <= path_end) {
         const resolved_path = this.resolve_file_path(document.uri, file_path);
@@ -31160,12 +31568,15 @@ class DefinitionProvider {
     return null;
   }
 }
+var PATH_BEARING_DIRECTIVE_PATTERN;
 var init_definition = __esm(() => {
   init_types();
   init_scope_resolver();
   init_esm();
   init_file_path_utils();
   init_comment_utils();
+  init_directives();
+  PATH_BEARING_DIRECTIVE_PATTERN = new RegExp(`${DIRECTIVE_PREFIX_PATTERN}(${BACKWARD_DIRECTIVE_KEYWORDS}|${FORWARD_DIRECTIVE_KEYWORDS})` + String.raw`:?\s+(?:"([^"]+)"|([^\s]+))` + CALL_SITE_PARAMS_FRAGMENT + String.raw`\s*$`);
 });
 
 // src/providers/references.ts
@@ -33862,7 +34273,7 @@ function find_protected_regions(expression) {
           end: i,
           type: "nested_macro"
         });
-      }
+      } else {}
       continue;
     }
     if (expression[i] === "$" && i + 1 < expression.length && expression[i + 1] === "{") {
@@ -66692,4 +67103,4 @@ export {
   is_cli_entry_point
 };
 
-//# debugId=343582E63382658564756E2164756E21
+//# debugId=CC4BC332FB54011E64756E2164756E21