@jbearak/sight 0.14.6 → 0.15.1

package/dist/sight-server.js

@@ -52,7 +52,7 @@ var package_default;
 var init_package = __esm(() => {
   package_default = {
     name: "@jbearak/sight",
-    version: "0.14.6",
+    version: "0.15.1",
     type: "module",
     workspaces: [
       "client"
@@ -115,6 +115,7 @@ var init_package = __esm(() => {
     license: "GPL-3.0",
     dependencies: {
       "@jbearak/dta-parser": "^0.6.0",
+      ignore: "7.0.5",
       picomatch: "^4.0.2",
       "smol-toml": "^1.6.1",
       "vscode-languageserver": "^9.0.1",
@@ -917,7 +918,10 @@ function map_public_config_to_partial_config(raw, warn) {
   }
   const workspace = object_value(raw, "workspace", "workspace", warn);
   if (workspace) {
-    warn_unknown_keys(workspace, ["exclude"], "workspace", warn);
+    warn_unknown_keys(workspace, ["exclude", "respectGitignore"], "workspace", warn);
+    const mapped_workspace = {};
+    assign_boolean(mapped_workspace, "respectGitignore", workspace, "respectGitignore", "workspace.respectGitignore", warn);
+    maybe_assign_object(root, "workspace", mapped_workspace);
   }
   const canonical_exclude = workspace ? pick_key(workspace, "exclude", warn, "workspace.exclude") : undefined;
   const legacy_exclude = pick_key(raw, "exclude", warn, "exclude");
@@ -2353,6 +2357,9 @@ function ascii_to_lower(c) {
     return String.fromCharCode(code + 32);
   return c;
 }
+function ascii_case_fold(text) {
+  return text.replace(ASCII_UPPERCASE_PATTERN, ascii_to_lower);
+}
 function ascii_ci_equal(a, b) {
   if (a.length !== b.length)
     return false;
@@ -2421,12 +2428,17 @@ function resolve_path_rich(resolved_fs_path, options) {
     return { kind: "exact", path: chosen_root };
   }
   const the_components = remainder.split(sep2);
-  let current_dir = chosen_root;
-  let had_case_mismatch = false;
   const join_path = (dir, name) => dir.endsWith(sep2) ? `${dir}${name}` : `${dir}${sep2}${name}`;
-  for (let comp_idx = 0;comp_idx < the_components.length; comp_idx++) {
+  let directory_reads_left = the_components.length + MAX_CASE_VARIANT_BACKTRACK_READS;
+  let budget_exhausted = false;
+  const walk = (current_dir, comp_idx, had_case_mismatch) => {
     const my_component = the_components[comp_idx];
     const my_is_final = comp_idx === the_components.length - 1;
+    if (directory_reads_left <= 0) {
+      budget_exhausted = true;
+      return { kind: "missing", requested: resolved_fs_path };
+    }
+    directory_reads_left--;
     let my_entries;
     try {
       my_entries = the_fs.readdirSync(current_dir, {
@@ -2438,20 +2450,43 @@ function resolve_path_rich(resolved_fs_path, options) {
     if (!my_is_final) {
       const my_exact = my_entries.find((e) => e.name === my_component && entry_is_dir(e, join_path(current_dir, e.name), the_fs));
       if (my_exact !== undefined) {
-        current_dir = join_path(current_dir, my_exact.name);
-        continue;
+        const my_outcome = walk(join_path(current_dir, my_exact.name), comp_idx + 1, had_case_mismatch);
+        if (my_outcome.kind !== "missing") {
+          return my_outcome;
+        }
       }
-      const the_ci_dirs = my_entries.filter((e) => ascii_ci_equal(e.name, my_component) && entry_is_dir(e, join_path(current_dir, e.name), the_fs));
-      if (the_ci_dirs.length === 1) {
-        had_case_mismatch = true;
-        current_dir = join_path(current_dir, the_ci_dirs[0].name);
-        continue;
+      const the_hits = [];
+      for (const my_entry of my_entries) {
+        if (my_entry.name === my_component || !ascii_ci_equal(my_entry.name, my_component) || !entry_is_dir(my_entry, join_path(current_dir, my_entry.name), the_fs)) {
+          continue;
+        }
+        const my_outcome = walk(join_path(current_dir, my_entry.name), comp_idx + 1, true);
+        if (my_outcome.kind === "ambiguous") {
+          the_hits.push(...my_outcome.matches);
+        } else if (my_outcome.kind !== "missing") {
+          the_hits.push(my_outcome.path);
+        }
+        if (the_hits.length > 1) {
+          return {
+            kind: "ambiguous",
+            requested: resolved_fs_path,
+            matches: the_hits
+          };
+        }
       }
-      if (the_ci_dirs.length > 1) {
+      if (budget_exhausted) {
         return {
           kind: "ambiguous",
           requested: resolved_fs_path,
-          matches: the_ci_dirs.map((e) => join_path(current_dir, e.name))
+          matches: the_hits,
+          truncated: true
+        };
+      }
+      if (the_hits.length === 1) {
+        return {
+          kind: "case_only",
+          path: the_hits[0],
+          requested: resolved_fs_path
         };
       }
       return { kind: "missing", requested: resolved_fs_path };
@@ -2500,8 +2535,8 @@ function resolve_path_rich(resolved_fs_path, options) {
       };
     }
     return { kind: "missing", requested: resolved_fs_path };
-  }
-  return { kind: "missing", requested: resolved_fs_path };
+  };
+  return walk(chosen_root, 0, false);
 }
 function host_is_case_sensitive(seed_existing_dir, fs3) {
   if (fs3 !== undefined) {
@@ -2571,6 +2606,31 @@ function is_resolvable_static_call(call) {
 function outcome_fs_path(outcome) {
   return outcome.kind === "exact" || outcome.kind === "case_only" ? outcome.path : outcome.requested;
 }
+function case_only_matched_directory(outcome) {
+  const dir_of = (fs_path) => node_path.posix.dirname(fs_path.replace(/\\/g, "/"));
+  return dir_of(outcome.path) !== dir_of(outcome.requested);
+}
+function case_mismatch_display_paths(raw_path, outcome, display_dir) {
+  const my_normalized_raw = raw_path.replace(/\\/g, "/");
+  const my_is_abs = node_path.isAbsolute(my_normalized_raw) || /^[a-zA-Z]:\//.test(my_normalized_raw);
+  const the_raw_parts = my_normalized_raw.split("/").filter((my_part) => my_part.length > 0);
+  const my_count = the_raw_parts.length;
+  const the_requested_parts = outcome.requested.replace(/\\/g, "/").split("/");
+  const the_real_parts = outcome.path.replace(/\\/g, "/").split("/");
+  const my_base_count = the_requested_parts.length - my_count;
+  const my_pairs = !my_is_abs && my_count > 0 && the_raw_parts.every((my_part) => my_part !== "." && my_part !== "..") && my_base_count >= 0 && the_real_parts.length === the_requested_parts.length && the_requested_parts.slice(my_base_count).join("/") === the_raw_parts.join("/") && the_requested_parts.slice(0, my_base_count).join("/") === the_real_parts.slice(0, my_base_count).join("/");
+  if (my_pairs) {
+    return {
+      requested: the_raw_parts.join("/"),
+      on_disk: the_real_parts.slice(-my_count).join("/")
+    };
+  }
+  const relative_to_display_dir = (fs_path) => node_path.relative(display_dir, fs_path).replace(/\\/g, "/") || fs_path;
+  return {
+    requested: relative_to_display_dir(outcome.requested),
+    on_disk: relative_to_display_dir(outcome.path)
+  };
+}
 function resolve_forward_call_rich(raw_path, caller_dir, working_directory, options) {
   const my_normalized_raw = raw_path.replace(/\\/g, "/");
   const my_is_abs = node_path.isAbsolute(my_normalized_raw) || /^[a-zA-Z]:\//.test(my_normalized_raw);
@@ -2653,6 +2713,7 @@ function build_cd_timeline(params) {
   const { starting_wd, caller_dir, cd_commands, workspace_roots, fs: fs3 } = params;
   const the_diagnostics = [];
   const the_entries = [];
+  let depends_on_directory_casing = false;
   const the_statics = (cd_commands ?? []).filter((c) => c.is_static && c.raw_path.length > 0).sort((a, b) => position_before(a.range.start, b.range.start) ? -1 : position_before(b.range.start, a.range.start) ? 1 : 0);
   let current_wd = starting_wd;
   for (const my_cd of the_statics) {
@@ -2668,6 +2729,7 @@ function build_cd_timeline(params) {
       current_wd = my_outcome.path;
     } else if (my_outcome.kind === "case_only") {
       current_wd = my_outcome.path;
+      depends_on_directory_casing = true;
       the_diagnostics.push(make_cd_case_mismatch_diagnostic(my_cd, my_outcome, caller_dir, workspace_roots));
     } else if (my_outcome.kind === "missing") {
       current_wd = my_outcome.requested;
@@ -2679,8 +2741,9 @@ function build_cd_timeline(params) {
         code: "CROSS_FILE_MISSING_FILE" /* CROSS_FILE_MISSING_FILE */
       });
     } else {
+      depends_on_directory_casing = true;
       the_diagnostics.push({
-        message: `Ambiguous directory for cd: "${my_cd.raw_path}" ` + `(multiple case-insensitive matches)`,
+        message: `Ambiguous directory for cd: "${my_cd.raw_path}" ` + (my_outcome.truncated ? `(too many case-variant directories to search)` : `(multiple case-insensitive matches)`),
         range: my_cd.range,
         severity: "warning",
         kind: "missing_directory",
@@ -2691,15 +2754,15 @@ function build_cd_timeline(params) {
   }
   return {
     timeline: { starting_wd, entries: the_entries },
-    diagnostics: the_diagnostics
+    diagnostics: the_diagnostics,
+    depends_on_directory_casing
   };
 }
 function make_cd_case_mismatch_diagnostic(cd, outcome, caller_dir, workspace_roots) {
-  const my_req_disp = node_path.relative(caller_dir, outcome.requested).replace(/\\/g, "/") || outcome.requested;
-  const my_real_disp = node_path.relative(caller_dir, outcome.path).replace(/\\/g, "/") || outcome.path;
+  const my_display = case_mismatch_display_paths(cd.raw_path, outcome, caller_dir);
   const my_seed = workspace_roots ? get_workspace_root_for_path(workspace_roots, outcome.path) ?? node_path.dirname(outcome.path) : node_path.dirname(outcome.path);
   return {
-    message: `Path "${my_req_disp}" does not match the directory on disk ` + `"${my_real_disp}"; Stata will not find it on case-sensitive ` + `filesystems (Linux). Update the path to match.`,
+    message: `Path "${my_display.requested}" does not match the directory ` + `on disk "${my_display.on_disk}"; Stata will not find it on ` + `case-sensitive filesystems (Linux). Update the path to match.`,
     range: cd.range,
     severity: "warning",
     kind: "path_case_mismatch",
@@ -2718,7 +2781,7 @@ function apply_cd_timeline(forward_calls, timeline) {
     };
   });
 }
-var FILE_COMMANDS, PATH_DIRECTIVES, STATA_FILE_EXTENSIONS, VCS_METADATA_DIRS, entry_is_dir, entry_is_file, case_sensitivity_cache;
+var FILE_COMMANDS, PATH_DIRECTIVES, STATA_FILE_EXTENSIONS, VCS_METADATA_DIRS, MAX_CASE_VARIANT_BACKTRACK_READS = 256, ASCII_UPPERCASE_PATTERN, entry_is_dir, entry_is_file, case_sensitivity_cache;
 var init_file_path_utils = __esm(() => {
   init_types();
   init_workspace_roots();
@@ -2751,6 +2814,7 @@ var init_file_path_utils = __esm(() => {
   ]);
   STATA_FILE_EXTENSIONS = [".do", ".ado", ".doh", ".mata"];
   VCS_METADATA_DIRS = new Set([".git", ".hg", ".svn"]);
+  ASCII_UPPERCASE_PATTERN = /[A-Z]/g;
   entry_is_dir = entry_is_directory_sync;
   entry_is_file = entry_is_file_sync;
   case_sensitivity_cache = new Map;
@@ -13310,6 +13374,8 @@ var init_parser = __esm(() => {
     pending_trivia = [];
     context_tracker = null;
     inside_program = false;
+    if_brace_scan_end = -1;
+    if_brace_scan_result = false;
     static OPENING_DELIMITER_PATTERN = /^(`")+$/;
     static CLOSING_DELIMITER_PATTERN = /^("')+$/;
     parse(tokens, context_tracker) {
@@ -13317,6 +13383,8 @@ var init_parser = __esm(() => {
       this.current = 0;
       this.errors = [];
       this.pending_trivia = [];
+      this.if_brace_scan_end = -1;
+      this.if_brace_scan_result = false;
       this.context_tracker = context_tracker || null;
       const nodes = [];
       while (!this.isAtEnd()) {
@@ -13346,7 +13414,7 @@ var init_parser = __esm(() => {
         errors: this.errors
       };
     }
-    parseStatement() {
+    parseStatement(consume_terminator = true) {
       const leading_trivia = [...this.pending_trivia, ...this.collectTrivia()];
       this.pending_trivia = [];
       if (this.isAtEnd()) {
@@ -13433,7 +13501,7 @@ var init_parser = __esm(() => {
       if (node && this.isNodeWithTrivia(node) && trailing_trivia.length > 0) {
         node.trailingTrivia = trailing_trivia;
       }
-      if (this.check("STATEMENT_TERMINATOR")) {
+      if (consume_terminator && this.check("STATEMENT_TERMINATOR")) {
         this.advance();
       }
       return node;
@@ -14650,13 +14718,31 @@ var init_parser = __esm(() => {
       }
       return false;
     }
+    hasIfBrace() {
+      if (this.current <= this.if_brace_scan_end) {
+        return this.if_brace_scan_result;
+      }
+      for (let i = this.current;i < this.tokens.length; i++) {
+        const token = this.tokens[i];
+        if (token.type === "LBRACE" || token.type === "EOF" || token.type === "STATEMENT_TERMINATOR" && !is_swallowed_continuation_terminator(token, this.tokens[i - 1]?.type === "CONTINUATION")) {
+          this.if_brace_scan_end = i;
+          this.if_brace_scan_result = token.type === "LBRACE";
+          return this.if_brace_scan_result;
+        }
+      }
+      return false;
+    }
     parseIfStatement() {
       const ifToken = this.advance();
+      const has_brace = this.hasIfBrace();
       const condition_tokens = [];
       const preceded_by_continuation = [];
       const continuation = new ContinuationTracker;
       const condition_start_line = ifToken.range.start.line;
       let paren_depth = 0;
+      let bracket_depth = 0;
+      let previous_operand;
+      let is_single_statement = false;
       while (!this.check("LBRACE") && !this.isAtEnd()) {
         if (this.check("CONTINUATION")) {
           const cont_token = this.peek();
@@ -14668,7 +14754,15 @@ var init_parser = __esm(() => {
         if (this.check("STATEMENT_TERMINATOR")) {
           break;
         }
-        const token = this.advance();
+        const token = this.peek();
+        const follows_continuation = continuation.collect(token);
+        const joins_operand = previous_operand && previous_operand.type !== "RPAREN" && previous_operand.type !== "RBRACKET" && (this.isAdjacentToken(previous_operand, token) || follows_continuation && token.range.start.character === 0);
+        const starts_nested_if = this.checkWord("if");
+        if ((!has_brace || starts_nested_if) && paren_depth === 0 && bracket_depth === 0 && previous_operand && !joins_operand && (token.type === "WORD" || this.isMacroRefToken(token) || token.type === "MATA_INLINE" || token.type === "PYTHON_INLINE")) {
+          is_single_statement = true;
+          break;
+        }
+        this.advance();
         if (token.type === "LPAREN") {
           paren_depth++;
         } else if (token.type === "RPAREN") {
@@ -14678,8 +14772,16 @@ var init_parser = __esm(() => {
             paren_depth = 0;
           }
         }
+        if (token.type === "LBRACKET") {
+          bracket_depth++;
+        } else if (token.type === "RBRACKET") {
+          bracket_depth = Math.max(0, bracket_depth - 1);
+        }
+        if (token.type !== "COMMENT_LINE" && token.type !== "COMMENT_BLOCK") {
+          previous_operand = token.type === "WORD" || token.type === "NUMBER" || token.type === "STRING" || this.isMacroRefToken(token) || token.type === "RPAREN" || token.type === "RBRACKET" ? token : undefined;
+        }
         condition_tokens.push(token);
-        preceded_by_continuation.push(continuation.collect(token));
+        preceded_by_continuation.push(follows_continuation);
       }
       const condition = this.reconstruct_value_tokens(condition_tokens, preceded_by_continuation).trim();
       if (paren_depth > 0) {
@@ -14690,7 +14792,11 @@ var init_parser = __esm(() => {
       }
       const body = [];
       let blockEndingTrivia;
-      if (this.check("LBRACE")) {
+      if (is_single_statement) {
+        const statement = this.parseStatement(false);
+        if (statement)
+          body.push(statement);
+      } else if (this.check("LBRACE")) {
         const lbrace_index = this.current;
         const lbrace_token = this.advance();
         const has_condition_before = lbrace_token.range.start.line === condition_start_line;
@@ -14708,9 +14814,10 @@ var init_parser = __esm(() => {
       }
       return {
         type: "if",
+        ...is_single_statement ? { is_single_statement: true } : {},
         condition: condition.trim(),
         body,
-        range: this.makeRange(ifToken.range.start, this.previous().range.end),
+        range: this.makeRange(ifToken.range.start, is_single_statement && body.length > 0 ? body[body.length - 1].range.end : this.previous().range.end),
         blockEndingTrivia
       };
     }
@@ -20742,6 +20849,61 @@ async function with_parse_timeout(operation, timeout_ms = PARSE_TIMEOUT_MS) {
 }
 var PARSE_TIMEOUT_MS = 5000;
 
+// src/source-analysis/index.ts
+import * as path4 from "path";
+function analyze_source(content, uri) {
+  const lexer = new StataLexer;
+  const parser = new StataParser;
+  const analyzer = new SemanticAnalyzer;
+  const directive_parser = new DirectiveParser;
+  const lex_result = lexer.tokenize(content);
+  const directive_result = directive_parser.parse(content, uri, lex_result.tokens);
+  const parse_result = parser.parse(lex_result.tokens);
+  const analysis = analyzer.analyze(parse_result.ast, uri, undefined, undefined, lex_result.tokens);
+  return {
+    tokens: lex_result.tokens,
+    analysis,
+    directives: directive_result
+  };
+}
+function prepare_forward_calls(options) {
+  let command_calls = options.command_calls;
+  try {
+    const caller_dir = path4.dirname(URI.parse(options.uri).fsPath);
+    const { timeline } = build_cd_timeline({
+      starting_wd: options.working_directory,
+      caller_dir,
+      cd_commands: options.cd_commands,
+      workspace_roots: options.workspace_roots,
+      fs: options.fs
+    });
+    command_calls = apply_cd_timeline(command_calls, timeline);
+  } catch (error) {
+    if (!options.recover_command_projection) {
+      throw error;
+    }
+  }
+  const directive_calls = options.directive_calls.map((my_directive) => ({
+    type: my_directive.type,
+    raw_path: my_directive.raw_path,
+    call_site_line: my_directive.call_site_line,
+    range: my_directive.range,
+    source: "directive",
+    is_static: true,
+    caller_uri: options.uri,
+    working_directory: options.working_directory
+  }));
+  return [...command_calls, ...directive_calls];
+}
+var init_source_analysis = __esm(() => {
+  init_esm();
+  init_analyzer();
+  init_directive_parser();
+  init_lexer();
+  init_parser();
+  init_file_path_utils();
+});
+
 // src/utils/polling-cancellation-token.ts
 function polling_cancellation_token(should_continue, parent) {
   return {
@@ -20757,7 +20919,6 @@ var no_op_cancellation_event = () => ({ dispose: () => {
 
 // src/document-store.ts
 import * as fs4 from "fs";
-import * as path4 from "path";
 
 class DocumentStore {
   documents = new Map;
@@ -21156,17 +21317,16 @@ class DocumentStore {
     const directive_parser = new DirectiveParser;
     let resolved_working_directory;
     let staged_effects;
+    let parsed_directives;
     try {
       const directive_result = directive_parser.parse(content, uri, lex_result.result.tokens);
+      parsed_directives = directive_result;
       staged_effects = this.stage_cross_file_effects(directive_result, effective_scope_resolver_config);
       if (directive_result.working_directory) {
         resolved_working_directory = this.resolve_working_directory(directive_result.working_directory, uri);
       } else if (this.scope_resolver) {
         try {
-          const scope_result = await this.scope_resolver.resolve(uri, content, effective_scope_resolver_config, cancellation_token, { register_dependencies: false });
-          if (scope_result.inherited_working_directory) {
-            resolved_working_directory = scope_result.inherited_working_directory;
-          }
+          resolved_working_directory = await this.scope_resolver.resolve_document_working_directory(uri, directive_result, effective_scope_resolver_config, cancellation_token);
         } catch {}
       }
     } catch {}
@@ -21220,36 +21380,19 @@ class DocumentStore {
       };
     }
     const diagnostics = this.build_diagnostics(lex_result.result.errors, parse_result.result.errors, analyze_result.result.diagnostics);
-    let restamped_command_calls = analyze_result.result.forward_calls;
+    let the_forward_directives = [];
     try {
-      const my_caller_dir = path4.dirname(URI.parse(uri).fsPath);
-      const { timeline: cd_timeline } = build_cd_timeline({
-        starting_wd: resolved_working_directory,
-        caller_dir: my_caller_dir,
-        cd_commands: analyze_result.result.cd_commands,
-        workspace_roots: this.workspace_roots
-      });
-      restamped_command_calls = apply_cd_timeline(analyze_result.result.forward_calls, cd_timeline);
-    } catch {}
-    let all_forward_calls = restamped_command_calls;
-    try {
-      const directive_parser2 = new DirectiveParser;
-      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,
-        call_site_line: d.call_site_line,
-        range: d.range,
-        source: "directive",
-        is_static: true,
-        caller_uri: uri,
-        working_directory: resolved_working_directory
-      }));
-      all_forward_calls = [
-        ...restamped_command_calls,
-        ...directive_forward_calls
-      ];
+      the_forward_directives = parsed_directives ? parsed_directives.forward_calls ?? [] : directive_parser.parse_forward_call_directives(content, uri, lex_result.result.tokens).forward_calls;
     } catch {}
+    const all_forward_calls = prepare_forward_calls({
+      uri,
+      command_calls: analyze_result.result.forward_calls,
+      directive_calls: the_forward_directives,
+      cd_commands: analyze_result.result.cd_commands,
+      working_directory: resolved_working_directory,
+      workspace_roots: this.workspace_roots,
+      recover_command_projection: true
+    });
     return {
       state: {
         uri,
@@ -21415,8 +21558,7 @@ var init_document_store = __esm(() => {
   init_context_tracker();
   init_directive_parser();
   init_workspace_roots();
-  init_file_path_utils();
-  init_esm();
+  init_source_analysis();
   import_vscode_languageserver = __toESM(require_main4(), 1);
 });
 
@@ -21928,6 +22070,11 @@ function build_forward_closure_key(inputs) {
     inputs.dep_graph_version
   ]);
 }
+function mark_directory_casing(collector) {
+  if (collector !== undefined) {
+    collector.depends_on_directory_casing = true;
+  }
+}
 
 class ForwardScopeResolver {
   scope_resolver;
@@ -21952,6 +22099,7 @@ class ForwardScopeResolver {
   };
   standalone_in_flight = new Set;
   active_probe_collectors = [];
+  collector_by_visited = new WeakMap;
   dependency_graph;
   constructor(scope_resolver, config = {}) {
     this.scope_resolver = scope_resolver;
@@ -21984,7 +22132,7 @@ class ForwardScopeResolver {
   }
   invalidate_forward_closure_for_uri(uri) {
     this.memo_invalidation_epoch++;
-    const the_keys = this.memo_uri_to_keys.get(uri);
+    const the_keys = this.memo_uri_to_keys.get(this.memo_index_key(uri));
     if (!the_keys) {
       return 0;
     }
@@ -22014,15 +22162,19 @@ class ForwardScopeResolver {
   }
   prune_memo_uri_to_keys_for_entry(key, entry) {
     for (const my_dep_uri of entry.dependent_uris) {
-      const my_key_set = this.memo_uri_to_keys.get(my_dep_uri);
+      const my_index_key = this.memo_index_key(my_dep_uri);
+      const my_key_set = this.memo_uri_to_keys.get(my_index_key);
       if (my_key_set) {
         my_key_set.delete(key);
         if (my_key_set.size === 0) {
-          this.memo_uri_to_keys.delete(my_dep_uri);
+          this.memo_uri_to_keys.delete(my_index_key);
         }
       }
     }
   }
+  memo_index_key(uri) {
+    return ascii_case_fold(uri);
+  }
   set_forward_closure_memo_capacity(max_entries) {
     this.forward_closure_memo.set_max_size(max_entries);
   }
@@ -22036,7 +22188,7 @@ class ForwardScopeResolver {
     for (const my_fs_path of fs_paths) {
       const my_probe_uri = URI.file(my_fs_path).toString();
       for (const my_collector of this.active_probe_collectors) {
-        my_collector.add(my_probe_uri);
+        my_collector.probes.add(my_probe_uri);
       }
     }
   }
@@ -22055,7 +22207,7 @@ class ForwardScopeResolver {
     const resolved = path5.resolve(fs_path);
     return this.workspace_roots.some((root) => resolved.startsWith(root + path5.sep) || resolved === root);
   }
-  resolve_call_path(raw_path, caller_uri, working_directory) {
+  resolve_call_path(raw_path, caller_uri, working_directory, casing_collector) {
     const my_caller_dir = path5.dirname(URI.parse(caller_uri).fsPath);
     const my_missed_candidates = this.active_probe_collectors.length > 0 ? [] : undefined;
     const my_outcome = resolve_forward_call_rich(raw_path, my_caller_dir, working_directory, {
@@ -22073,6 +22225,9 @@ class ForwardScopeResolver {
       };
     }
     if (my_outcome.kind === "case_only") {
+      if (case_only_matched_directory(my_outcome)) {
+        mark_directory_casing(casing_collector);
+      }
       const my_seed = this.find_seed_dir(my_outcome.path);
       return {
         resolved_path: my_outcome.path,
@@ -22089,13 +22244,16 @@ class ForwardScopeResolver {
   find_seed_dir(fs_path) {
     return get_workspace_root_for_path(this.workspace_roots, fs_path) ?? path5.dirname(fs_path);
   }
-  resolve_call_path_simple(raw_path, caller_uri, working_directory) {
+  resolve_call_path_simple(raw_path, caller_uri, working_directory, casing_collector) {
     const my_caller_dir = path5.dirname(URI.parse(caller_uri).fsPath);
     const my_outcome = resolve_forward_call_rich(raw_path, my_caller_dir, working_directory, {
       workspace_roots: this.workspace_roots.length > 0 ? this.workspace_roots : undefined,
       fs: this.resolve_fs
     });
     if (my_outcome.kind === "exact" || my_outcome.kind === "case_only") {
+      if (my_outcome.kind === "case_only" && case_only_matched_directory(my_outcome)) {
+        mark_directory_casing(casing_collector);
+      }
       return my_outcome.path;
     }
     return null;
@@ -22123,13 +22281,21 @@ class ForwardScopeResolver {
     const the_call_sites = [];
     let accumulated_symbols = create_empty_symbol_table();
     const my_caller_dir = path5.dirname(URI.parse(file_uri).fsPath);
-    const { timeline: cd_timeline, diagnostics: cd_diagnostics } = build_cd_timeline({
+    const my_casing_collector = this.collector_by_visited.get(my_context.visited);
+    const {
+      timeline: cd_timeline,
+      diagnostics: cd_diagnostics,
+      depends_on_directory_casing
+    } = build_cd_timeline({
       starting_wd: my_context.working_directory,
       caller_dir: my_caller_dir,
       cd_commands: my_context.cd_commands ?? [],
       workspace_roots: this.workspace_roots.length > 0 ? this.workspace_roots : undefined,
       fs: this.resolve_fs
     });
+    if (depends_on_directory_casing) {
+      mark_directory_casing(my_casing_collector);
+    }
     if (my_context.diagnostic_owner_uri !== undefined && file_uri === my_context.diagnostic_owner_uri && my_context.depth === 0) {
       const my_source_filename = path5.basename(URI.parse(file_uri).fsPath);
       for (const my_cd_diag of cd_diagnostics) {
@@ -22176,16 +22342,16 @@ class ForwardScopeResolver {
         break;
       }
       const my_effective_type = this.compute_effective_call_type(my_call.type, my_context.effective_call_type);
-      const my_path_result = this.resolve_call_path(my_call.raw_path, file_uri, effective_call_wd);
+      const my_path_result = this.resolve_call_path(my_call.raw_path, file_uri, effective_call_wd, my_casing_collector);
       const resolved_path = my_path_result.resolved_path;
       const callee_uri = URI.file(resolved_path).toString();
       if (my_path_result.outcome_kind === "case_only" && my_context.diagnostic_owner_uri !== undefined && file_uri === my_context.diagnostic_owner_uri && my_context.depth === 0) {
-        const my_requested = my_path_result.requested_path ?? my_call.raw_path;
-        const my_real = my_path_result.resolved_path;
-        const my_req_disp = path5.relative(path5.dirname(URI.parse(file_uri).fsPath), my_requested).replace(/\\/g, "/") || my_requested;
-        const my_real_disp = path5.relative(path5.dirname(URI.parse(file_uri).fsPath), my_real).replace(/\\/g, "/") || my_real;
+        const my_display = case_mismatch_display_paths(my_call.raw_path, {
+          path: my_path_result.resolved_path,
+          requested: my_path_result.requested_path ?? my_call.raw_path
+        }, path5.dirname(URI.parse(file_uri).fsPath));
         my_context.diagnostics.push({
-          message: `Path "${my_req_disp}" does not match the file ` + `on disk "${my_real_disp}"; Stata will not find ` + `it on case-sensitive filesystems (Linux). ` + `Update the path to match.`,
+          message: `Path "${my_display.requested}" does not match ` + `the file on disk "${my_display.on_disk}"; ` + `Stata will not find ` + `it on case-sensitive filesystems (Linux). ` + `Update the path to match.`,
           range: my_call.range,
           severity: "warning",
           kind: "path_case_mismatch",
@@ -22233,7 +22399,7 @@ class ForwardScopeResolver {
         if ("error" in callee_result) {
           continue;
         }
-        const effective_end_state = await this.compute_effective_end_state_locals(callee_uri, resolved_path, callee_result.working_directory ?? effective_call_wd, new Set(my_stack), my_context.depth + 1, resolved_config, token);
+        const effective_end_state = await this.compute_effective_end_state_locals(callee_uri, resolved_path, callee_result.working_directory ?? effective_call_wd, new Set(my_stack), my_context.depth + 1, resolved_config, token, my_casing_collector);
         const boundary_excluded = effective_end_state.size > 0 ? effective_end_state : undefined;
         the_call_sites.push({
           callee_uri,
@@ -22281,7 +22447,7 @@ class ForwardScopeResolver {
       }
       let excluded_locals;
       if (my_call.type !== "include" && my_effective_type === "do" && my_context.depth === 0) {
-        const effective_end_state = await this.compute_effective_end_state_locals(callee_uri, resolved_path, callee_result.working_directory ?? effective_call_wd, new Set(my_stack), my_context.depth + 1, resolved_config, token);
+        const effective_end_state = await this.compute_effective_end_state_locals(callee_uri, resolved_path, callee_result.working_directory ?? effective_call_wd, new Set(my_stack), my_context.depth + 1, resolved_config, token, my_casing_collector);
         if (effective_end_state.size > 0) {
           excluded_locals = effective_end_state;
         }
@@ -22383,8 +22549,12 @@ class ForwardScopeResolver {
     const fresh_diagnostics = [];
     this.memo_metrics.misses++;
     this.standalone_in_flight.add(callee_uri);
-    const my_probe_collector = new Set;
+    const my_probe_collector = {
+      probes: new Set,
+      depends_on_directory_casing: false
+    };
     this.active_probe_collectors.push(my_probe_collector);
+    this.collector_by_visited.set(fresh_visited, my_probe_collector);
     let standalone;
     try {
       standalone = await this.resolve(callee_uri, forward_calls, effective_call_type, {
@@ -22407,6 +22577,7 @@ class ForwardScopeResolver {
       if (my_collector_index >= 0) {
         this.active_probe_collectors.splice(my_collector_index, 1);
       }
+      this.collector_by_visited.delete(fresh_visited);
     }
     if (token?.isCancellationRequested) {
       return;
@@ -22420,9 +22591,9 @@ class ForwardScopeResolver {
     const dependent_uris = new Set([
       callee_uri,
       ...fresh_visited.keys(),
-      ...my_probe_collector
+      ...my_probe_collector.probes
     ]);
-    if (fresh_diagnostics.length > 0) {
+    if (fresh_diagnostics.length > 0 || my_probe_collector.depends_on_directory_casing) {
       return this.store_memo_entry(key, {
         kind: "unservable",
         dependent_uris
@@ -22443,10 +22614,11 @@ class ForwardScopeResolver {
     }
     this.forward_closure_memo.set(key, entry);
     for (const my_dep_uri of entry.dependent_uris) {
-      let my_key_set = this.memo_uri_to_keys.get(my_dep_uri);
+      const my_index_key = this.memo_index_key(my_dep_uri);
+      let my_key_set = this.memo_uri_to_keys.get(my_index_key);
       if (!my_key_set) {
         my_key_set = new Set;
-        this.memo_uri_to_keys.set(my_dep_uri, my_key_set);
+        this.memo_uri_to_keys.set(my_index_key, my_key_set);
       }
       my_key_set.add(key);
     }
@@ -22499,7 +22671,7 @@ class ForwardScopeResolver {
     }
     return result;
   }
-  async compute_effective_end_state_locals(callee_uri, callee_fs_path, working_directory, stack, depth, resolved_config, token) {
+  async compute_effective_end_state_locals(callee_uri, callee_fs_path, working_directory, stack, depth, resolved_config, token, casing_collector) {
     if (token?.isCancellationRequested)
       return new Map;
     if (stack.has(callee_uri))
@@ -22551,13 +22723,19 @@ class ForwardScopeResolver {
       the_events.sort((a, b) => a.line - b.line || a.character - b.character);
       const the_effective = new Map;
       const nested_base_wd = callee_result.working_directory ?? working_directory;
-      const { timeline: nested_cd_timeline } = build_cd_timeline({
+      const {
+        timeline: nested_cd_timeline,
+        depends_on_directory_casing: nested_depends_on_casing
+      } = build_cd_timeline({
         starting_wd: nested_base_wd,
         caller_dir: path5.dirname(URI.parse(callee_uri).fsPath),
         cd_commands: callee_result.cd_commands,
         workspace_roots: this.workspace_roots.length > 0 ? this.workspace_roots : undefined,
         fs: this.resolve_fs
       });
+      if (nested_depends_on_casing) {
+        mark_directory_casing(casing_collector);
+      }
       for (const my_event of the_events) {
         if (token?.isCancellationRequested)
           break;
@@ -22565,12 +22743,12 @@ class ForwardScopeResolver {
           the_effective.set(my_event.name, my_event.symbol);
         } else {
           const event_wd = wd_for_position(nested_cd_timeline, my_event.call.range.start);
-          const nested_resolved = this.resolve_call_path_simple(my_event.call.raw_path, callee_uri, event_wd);
+          const nested_resolved = this.resolve_call_path_simple(my_event.call.raw_path, callee_uri, event_wd, casing_collector);
           if (nested_resolved === null) {
             continue;
           }
           const nested_uri = URI.file(nested_resolved).toString();
-          const nested_effective = await this.compute_effective_end_state_locals(nested_uri, nested_resolved, event_wd, stack, depth + 1, resolved_config, token);
+          const nested_effective = await this.compute_effective_end_state_locals(nested_uri, nested_resolved, event_wd, stack, depth + 1, resolved_config, token, casing_collector);
           for (const [my_name, my_symbol] of nested_effective) {
             the_effective.set(my_name, my_symbol);
           }
@@ -22665,9 +22843,6 @@ function scope_resolver_config_for(config) {
 
 class ScopeResolver {
   directive_parser;
-  lexer;
-  parser;
-  analyzer;
   file_cache;
   scope_cache;
   uri_to_cache_keys;
@@ -22682,9 +22857,6 @@ class ScopeResolver {
   resolve_fs;
   constructor(logger2, content_provider, cache_capacities) {
     this.directive_parser = new DirectiveParser;
-    this.lexer = new StataLexer;
-    this.parser = new StataParser;
-    this.analyzer = new SemanticAnalyzer;
     this.file_cache = new BoundedLruMap(cache_capacities?.max_cached_files ?? DEFAULT_MAX_CACHED_FILES, {
       on_evict: (_key, entry) => {
         this.cache_metrics.file.evictions++;
@@ -23364,6 +23536,16 @@ class ScopeResolver {
     };
     return this.discover_working_directory(the_backward_directives, new Set, 0, my_config, new Map, current_uri, undefined, true);
   }
+  async resolve_document_working_directory(file_uri, directive_result, config = {}, token) {
+    if (token?.isCancellationRequested || directive_result.working_directory) {
+      return;
+    }
+    const my_config = { ...DEFAULT_CONFIG2, ...config };
+    const { directives: effective_directives } = this.get_effective_backward_directives(file_uri, directive_result.directives, my_config, directive_result.standalone !== undefined);
+    const normalized_directives = this.normalize_directives(effective_directives, []);
+    const working_directory = await this.discover_working_directory(normalized_directives, new Set([file_uri]), 1, my_config, new Map, file_uri, token, true);
+    return token?.isCancellationRequested ? undefined : working_directory;
+  }
   async discover_working_directory(directives, visited, depth, config, request_cache, current_uri, token, skip_backward_registration) {
     if (depth > config.max_backward_depth) {
       return;
@@ -23733,9 +23915,10 @@ class ScopeResolver {
     }
   }
   parse_content(uri, content, inherited_working_directory) {
-    const my_directive_result = this.directive_parser.parse(content, uri);
-    const my_lex_result = this.lexer.tokenize(content);
-    const my_parse_result = this.parser.parse(my_lex_result.tokens);
+    const {
+      directives: my_directive_result,
+      analysis: my_analysis
+    } = analyze_source(content, uri);
     const my_workspace_root = get_workspace_root_for_uri(this.workspace_roots, uri);
     let own_working_directory;
     if (my_directive_result.working_directory) {
@@ -23748,32 +23931,15 @@ 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 my_caller_dir = path6.dirname(URI.parse(uri).fsPath);
-    const { timeline: cd_timeline } = build_cd_timeline({
-      starting_wd: effective_working_directory,
-      caller_dir: my_caller_dir,
+    const all_forward_calls = prepare_forward_calls({
+      uri,
+      command_calls: my_analysis.forward_calls,
+      directive_calls: my_directive_result.forward_calls ?? [],
       cd_commands: my_analysis.cd_commands,
+      working_directory: effective_working_directory,
       workspace_roots: this.workspace_roots,
       fs: this.resolve_fs
     });
-    const restamped_command_calls = apply_cd_timeline(my_analysis.forward_calls, cd_timeline);
-    const directive_forward_calls = (my_directive_result.forward_calls ?? []).map((d) => ({
-      type: d.type,
-      raw_path: d.raw_path,
-      call_site_line: d.call_site_line,
-      range: d.range,
-      source: "directive",
-      is_static: true,
-      caller_uri: uri,
-      working_directory: effective_working_directory
-    }));
-    const all_forward_calls = [
-      ...restamped_command_calls,
-      ...directive_forward_calls
-    ];
     return {
       symbols: my_analysis.symbols,
       directives: my_directive_result.directives,
@@ -24607,9 +24773,8 @@ var init_scope_resolver = __esm(() => {
   init_esm();
   init_types();
   init_directive_parser();
-  init_lexer();
-  init_parser();
   init_analyzer();
+  init_source_analysis();
   init_logger();
   init_lru_cache();
   init_dofile_locals();
@@ -25062,6 +25227,476 @@ var init_source_discovery_policy = __esm(() => {
   init_workspace_roots();
 });
 
+// node_modules/ignore/index.js
+var require_ignore = __commonJS((exports, module) => {
+  function makeArray(subject) {
+    return Array.isArray(subject) ? subject : [subject];
+  }
+  var UNDEFINED = undefined;
+  var EMPTY = "";
+  var SPACE = " ";
+  var ESCAPE = "\\";
+  var REGEX_TEST_BLANK_LINE = /^\s+$/;
+  var REGEX_INVALID_TRAILING_BACKSLASH = /(?:[^\\]|^)\\$/;
+  var REGEX_REPLACE_LEADING_EXCAPED_EXCLAMATION = /^\\!/;
+  var REGEX_REPLACE_LEADING_EXCAPED_HASH = /^\\#/;
+  var REGEX_SPLITALL_CRLF = /\r?\n/g;
+  var REGEX_TEST_INVALID_PATH = /^\.{0,2}\/|^\.{1,2}$/;
+  var REGEX_TEST_TRAILING_SLASH = /\/$/;
+  var SLASH = "/";
+  var TMP_KEY_IGNORE = "node-ignore";
+  if (typeof Symbol !== "undefined") {
+    TMP_KEY_IGNORE = Symbol.for("node-ignore");
+  }
+  var KEY_IGNORE = TMP_KEY_IGNORE;
+  var define2 = (object, key, value) => {
+    Object.defineProperty(object, key, { value });
+    return value;
+  };
+  var REGEX_REGEXP_RANGE = /([0-z])-([0-z])/g;
+  var RETURN_FALSE = () => false;
+  var sanitizeRange = (range) => range.replace(REGEX_REGEXP_RANGE, (match, from, to) => from.charCodeAt(0) <= to.charCodeAt(0) ? match : EMPTY);
+  var cleanRangeBackSlash = (slashes) => {
+    const { length } = slashes;
+    return slashes.slice(0, length - length % 2);
+  };
+  var REPLACERS = [
+    [
+      /^\uFEFF/,
+      () => EMPTY
+    ],
+    [
+      /((?:\\\\)*?)(\\?\s+)$/,
+      (_, m1, m2) => m1 + (m2.indexOf("\\") === 0 ? SPACE : EMPTY)
+    ],
+    [
+      /(\\+?)\s/g,
+      (_, m1) => {
+        const { length } = m1;
+        return m1.slice(0, length - length % 2) + SPACE;
+      }
+    ],
+    [
+      /[\\$.|*+(){^]/g,
+      (match) => `\\${match}`
+    ],
+    [
+      /(?!\\)\?/g,
+      () => "[^/]"
+    ],
+    [
+      /^\//,
+      () => "^"
+    ],
+    [
+      /\//g,
+      () => "\\/"
+    ],
+    [
+      /^\^*\\\*\\\*\\\//,
+      () => "^(?:.*\\/)?"
+    ],
+    [
+      /^(?=[^^])/,
+      function startingReplacer() {
+        return !/\/(?!$)/.test(this) ? "(?:^|\\/)" : "^";
+      }
+    ],
+    [
+      /\\\/\\\*\\\*(?=\\\/|$)/g,
+      (_, index, str) => index + 6 < str.length ? "(?:\\/[^\\/]+)*" : "\\/.+"
+    ],
+    [
+      /(^|[^\\]+)(\\\*)+(?=.+)/g,
+      (_, p1, p2) => {
+        const unescaped = p2.replace(/\\\*/g, "[^\\/]*");
+        return p1 + unescaped;
+      }
+    ],
+    [
+      /\\\\\\(?=[$.|*+(){^])/g,
+      () => ESCAPE
+    ],
+    [
+      /\\\\/g,
+      () => ESCAPE
+    ],
+    [
+      /(\\)?\[([^\]/]*?)(\\*)($|\])/g,
+      (match, leadEscape, range, endEscape, close) => leadEscape === ESCAPE ? `\\[${range}${cleanRangeBackSlash(endEscape)}${close}` : close === "]" ? endEscape.length % 2 === 0 ? `[${sanitizeRange(range)}${endEscape}]` : "[]" : "[]"
+    ],
+    [
+      /(?:[^*])$/,
+      (match) => /\/$/.test(match) ? `${match}$` : `${match}(?=$|\\/$)`
+    ]
+  ];
+  var REGEX_REPLACE_TRAILING_WILDCARD = /(^|\\\/)?\\\*$/;
+  var MODE_IGNORE = "regex";
+  var MODE_CHECK_IGNORE = "checkRegex";
+  var UNDERSCORE = "_";
+  var TRAILING_WILD_CARD_REPLACERS = {
+    [MODE_IGNORE](_, p1) {
+      const prefix = p1 ? `${p1}[^/]+` : "[^/]*";
+      return `${prefix}(?=$|\\/$)`;
+    },
+    [MODE_CHECK_IGNORE](_, p1) {
+      const prefix = p1 ? `${p1}[^/]*` : "[^/]*";
+      return `${prefix}(?=$|\\/$)`;
+    }
+  };
+  var makeRegexPrefix = (pattern) => REPLACERS.reduce((prev, [matcher, replacer]) => prev.replace(matcher, replacer.bind(pattern)), pattern);
+  var isString = (subject) => typeof subject === "string";
+  var checkPattern = (pattern) => pattern && isString(pattern) && !REGEX_TEST_BLANK_LINE.test(pattern) && !REGEX_INVALID_TRAILING_BACKSLASH.test(pattern) && pattern.indexOf("#") !== 0;
+  var splitPattern = (pattern) => pattern.split(REGEX_SPLITALL_CRLF).filter(Boolean);
+
+  class IgnoreRule {
+    constructor(pattern, mark, body, ignoreCase, negative, prefix) {
+      this.pattern = pattern;
+      this.mark = mark;
+      this.negative = negative;
+      define2(this, "body", body);
+      define2(this, "ignoreCase", ignoreCase);
+      define2(this, "regexPrefix", prefix);
+    }
+    get regex() {
+      const key = UNDERSCORE + MODE_IGNORE;
+      if (this[key]) {
+        return this[key];
+      }
+      return this._make(MODE_IGNORE, key);
+    }
+    get checkRegex() {
+      const key = UNDERSCORE + MODE_CHECK_IGNORE;
+      if (this[key]) {
+        return this[key];
+      }
+      return this._make(MODE_CHECK_IGNORE, key);
+    }
+    _make(mode, key) {
+      const str = this.regexPrefix.replace(REGEX_REPLACE_TRAILING_WILDCARD, TRAILING_WILD_CARD_REPLACERS[mode]);
+      const regex = this.ignoreCase ? new RegExp(str, "i") : new RegExp(str);
+      return define2(this, key, regex);
+    }
+  }
+  var createRule = ({
+    pattern,
+    mark
+  }, ignoreCase) => {
+    let negative = false;
+    let body = pattern;
+    if (body.indexOf("!") === 0) {
+      negative = true;
+      body = body.substr(1);
+    }
+    body = body.replace(REGEX_REPLACE_LEADING_EXCAPED_EXCLAMATION, "!").replace(REGEX_REPLACE_LEADING_EXCAPED_HASH, "#");
+    const regexPrefix = makeRegexPrefix(body);
+    return new IgnoreRule(pattern, mark, body, ignoreCase, negative, regexPrefix);
+  };
+
+  class RuleManager {
+    constructor(ignoreCase) {
+      this._ignoreCase = ignoreCase;
+      this._rules = [];
+    }
+    _add(pattern) {
+      if (pattern && pattern[KEY_IGNORE]) {
+        this._rules = this._rules.concat(pattern._rules._rules);
+        this._added = true;
+        return;
+      }
+      if (isString(pattern)) {
+        pattern = {
+          pattern
+        };
+      }
+      if (checkPattern(pattern.pattern)) {
+        const rule = createRule(pattern, this._ignoreCase);
+        this._added = true;
+        this._rules.push(rule);
+      }
+    }
+    add(pattern) {
+      this._added = false;
+      makeArray(isString(pattern) ? splitPattern(pattern) : pattern).forEach(this._add, this);
+      return this._added;
+    }
+    test(path10, checkUnignored, mode) {
+      let ignored = false;
+      let unignored = false;
+      let matchedRule;
+      this._rules.forEach((rule) => {
+        const { negative } = rule;
+        if (unignored === negative && ignored !== unignored || negative && !ignored && !unignored && !checkUnignored) {
+          return;
+        }
+        const matched = rule[mode].test(path10);
+        if (!matched) {
+          return;
+        }
+        ignored = !negative;
+        unignored = negative;
+        matchedRule = negative ? UNDEFINED : rule;
+      });
+      const ret = {
+        ignored,
+        unignored
+      };
+      if (matchedRule) {
+        ret.rule = matchedRule;
+      }
+      return ret;
+    }
+  }
+  var throwError = (message, Ctor) => {
+    throw new Ctor(message);
+  };
+  var checkPath = (path10, originalPath, doThrow) => {
+    if (!isString(path10)) {
+      return doThrow(`path must be a string, but got \`${originalPath}\``, TypeError);
+    }
+    if (!path10) {
+      return doThrow(`path must not be empty`, TypeError);
+    }
+    if (checkPath.isNotRelative(path10)) {
+      const r = "`path.relative()`d";
+      return doThrow(`path should be a ${r} string, but got "${originalPath}"`, RangeError);
+    }
+    return true;
+  };
+  var isNotRelative = (path10) => REGEX_TEST_INVALID_PATH.test(path10);
+  checkPath.isNotRelative = isNotRelative;
+  checkPath.convert = (p) => p;
+
+  class Ignore {
+    constructor({
+      ignorecase = true,
+      ignoreCase = ignorecase,
+      allowRelativePaths = false
+    } = {}) {
+      define2(this, KEY_IGNORE, true);
+      this._rules = new RuleManager(ignoreCase);
+      this._strictPathCheck = !allowRelativePaths;
+      this._initCache();
+    }
+    _initCache() {
+      this._ignoreCache = Object.create(null);
+      this._testCache = Object.create(null);
+    }
+    add(pattern) {
+      if (this._rules.add(pattern)) {
+        this._initCache();
+      }
+      return this;
+    }
+    addPattern(pattern) {
+      return this.add(pattern);
+    }
+    _test(originalPath, cache, checkUnignored, slices) {
+      const path10 = originalPath && checkPath.convert(originalPath);
+      checkPath(path10, originalPath, this._strictPathCheck ? throwError : RETURN_FALSE);
+      return this._t(path10, cache, checkUnignored, slices);
+    }
+    checkIgnore(path10) {
+      if (!REGEX_TEST_TRAILING_SLASH.test(path10)) {
+        return this.test(path10);
+      }
+      const slices = path10.split(SLASH).filter(Boolean);
+      slices.pop();
+      if (slices.length) {
+        const parent = this._t(slices.join(SLASH) + SLASH, this._testCache, true, slices);
+        if (parent.ignored) {
+          return parent;
+        }
+      }
+      return this._rules.test(path10, false, MODE_CHECK_IGNORE);
+    }
+    _t(path10, cache, checkUnignored, slices) {
+      if (path10 in cache) {
+        return cache[path10];
+      }
+      if (!slices) {
+        slices = path10.split(SLASH).filter(Boolean);
+      }
+      slices.pop();
+      if (!slices.length) {
+        return cache[path10] = this._rules.test(path10, checkUnignored, MODE_IGNORE);
+      }
+      const parent = this._t(slices.join(SLASH) + SLASH, cache, checkUnignored, slices);
+      return cache[path10] = parent.ignored ? parent : this._rules.test(path10, checkUnignored, MODE_IGNORE);
+    }
+    ignores(path10) {
+      return this._test(path10, this._ignoreCache, false).ignored;
+    }
+    createFilter() {
+      return (path10) => !this.ignores(path10);
+    }
+    filter(paths) {
+      return makeArray(paths).filter(this.createFilter());
+    }
+    test(path10) {
+      return this._test(path10, this._testCache, true);
+    }
+  }
+  var factory = (options) => new Ignore(options);
+  var isPathValid = (path10) => checkPath(path10 && checkPath.convert(path10), path10, RETURN_FALSE);
+  var setupWindows = () => {
+    const makePosix = (str) => /^\\\\\?\\/.test(str) || /["<>|\u0000-\u001F]+/u.test(str) ? str : str.replace(/\\/g, "/");
+    checkPath.convert = makePosix;
+    const REGEX_TEST_WINDOWS_PATH_ABSOLUTE = /^[a-z]:\//i;
+    checkPath.isNotRelative = (path10) => REGEX_TEST_WINDOWS_PATH_ABSOLUTE.test(path10) || isNotRelative(path10);
+  };
+  if (typeof process !== "undefined" && process.platform === "win32") {
+    setupWindows();
+  }
+  module.exports = factory;
+  factory.default = factory;
+  module.exports.isPathValid = isPathValid;
+  define2(module.exports, Symbol.for("setupWindows"), setupWindows);
+});
+
+// src/utils/gitignore-matcher.ts
+import * as fs9 from "fs";
+import * as path10 from "path";
+function rebase_patterns(content, relative_directory) {
+  const pattern_content = content.startsWith("\uFEFF") ? content.slice(1) : content;
+  const the_lines = pattern_content.split(IGNORE_LINE_BREAK);
+  if (relative_directory === "")
+    return the_lines;
+  LITERAL_DIRECTORY_METACHARACTERS.lastIndex = 0;
+  const prefix = relative_directory.replace(LITERAL_DIRECTORY_METACHARACTERS, "\\$&");
+  const the_patterns = [];
+  for (const my_line of the_lines) {
+    if (BLANK_PATTERN.test(my_line) || my_line.startsWith("#"))
+      continue;
+    const negative = my_line.startsWith("!");
+    const body = negative ? my_line.slice(1) : my_line;
+    const shape = body.replace(TRAILING_PATTERN_WHITESPACE, "");
+    if (shape === "" || shape === "/")
+      continue;
+    const anchored = body.startsWith("/") || MIDDLE_SLASH.test(shape);
+    const relative_pattern = (body.startsWith("/") ? body.slice(1) : body).replace(ESCAPED_PATTERN_PREFIX, "$1");
+    the_patterns.push(`${negative ? "!" : ""}/${prefix}/` + `${anchored ? "" : "**/"}${relative_pattern}`);
+  }
+  return the_patterns;
+}
+function is_missing(error) {
+  return typeof error === "object" && error !== null && "code" in error && (error.code === "ENOENT" || error.code === "ENOTDIR");
+}
+function contains_path(root, target) {
+  const relative5 = path10.relative(root, target);
+  return relative5 !== ".." && !relative5.startsWith(`..${path10.sep}`) && !path10.isAbsolute(relative5);
+}
+function create_gitignore_matcher(workspace_roots, respect_gitignore = true) {
+  if (!respect_gitignore || workspace_roots.length === 0) {
+    return DISABLED_MATCHER;
+  }
+  let warned = false;
+  function warn_unreadable(file_path, error) {
+    if (warned || is_missing(error))
+      return;
+    warned = true;
+    const detail = error instanceof Error ? error.message : String(error);
+    logger.warn(`Cannot read Gitignore rules at ${file_path}: ${detail}. ` + "Continuing with the available rules.");
+  }
+  function find_rule_root(workspace_root) {
+    let directory = workspace_root;
+    while (true) {
+      const marker_path = path10.join(directory, ".git");
+      try {
+        const marker = fs9.lstatSync(marker_path);
+        if (marker.isDirectory() || marker.isFile())
+          return directory;
+      } catch (error) {
+        warn_unreadable(marker_path, error);
+      }
+      const parent = path10.dirname(directory);
+      if (parent === directory)
+        return workspace_root;
+      directory = parent;
+    }
+  }
+  function read_rules(scope, directory, inherited_rules) {
+    const ignore_path = path10.join(directory, ".gitignore");
+    try {
+      if (fs9.lstatSync(ignore_path).isFile()) {
+        const content = fs9.readFileSync(ignore_path, "utf8");
+        const relative_directory = path10.relative(scope.rule_root, directory).split(path10.sep).join("/");
+        return import_ignore.default({ ignorecase: false }).add(inherited_rules ?? []).add(rebase_patterns(content, relative_directory));
+      }
+    } catch (error) {
+      warn_unreadable(ignore_path, error);
+    }
+    return inherited_rules ?? import_ignore.default({ ignorecase: false });
+  }
+  function matches_rules(context, absolute_path, kind) {
+    if (context.ignored)
+      return true;
+    const relative5 = path10.relative(context.rule_root, absolute_path).split(path10.sep).join("/");
+    return context.rules.ignores(kind === "directory" ? `${relative5}/` : relative5);
+  }
+  function directory_context(scope, directory) {
+    const cached = scope.directories.get(directory);
+    if (cached)
+      return cached;
+    const parent = path10.relative(scope.rule_root, directory) === "" ? undefined : directory_context(scope, path10.dirname(directory));
+    const ignored = parent !== undefined && matches_rules(parent, directory, "directory");
+    const context = {
+      rule_root: scope.rule_root,
+      ignored,
+      rules: ignored && parent ? parent.rules : read_rules(scope, directory, parent?.rules)
+    };
+    scope.directories.set(directory, context);
+    return context;
+  }
+  const the_scopes = Array.from(new Set(workspace_roots.map((my_root) => path10.resolve(my_root)))).sort((a, b) => b.length - a.length).map((workspace_root) => ({
+    workspace_root,
+    rule_root: find_rule_root(workspace_root),
+    directories: new Map
+  }));
+  const the_watch_directories = new Map;
+  for (const my_scope of the_scopes) {
+    the_watch_directories.set(my_scope.workspace_root, true);
+    let directory = my_scope.workspace_root;
+    while (directory !== my_scope.rule_root) {
+      directory = path10.dirname(directory);
+      if (!the_watch_directories.has(directory)) {
+        the_watch_directories.set(directory, false);
+      }
+    }
+  }
+  return {
+    watch_directories: Array.from(the_watch_directories, ([directory, recursive]) => ({ directory, recursive })),
+    is_ignored(absolute_path, kind) {
+      const target = path10.resolve(absolute_path);
+      for (const my_scope of the_scopes) {
+        if (!contains_path(my_scope.workspace_root, target))
+          continue;
+        if (path10.relative(my_scope.workspace_root, target) === "") {
+          return false;
+        }
+        const context = directory_context(my_scope, path10.dirname(target));
+        return matches_rules(context, target, kind);
+      }
+      return false;
+    }
+  };
+}
+var import_ignore, DISABLED_MATCHER, IGNORE_LINE_BREAK, BLANK_PATTERN, TRAILING_PATTERN_WHITESPACE, MIDDLE_SLASH, LITERAL_DIRECTORY_METACHARACTERS, ESCAPED_PATTERN_PREFIX;
+var init_gitignore_matcher = __esm(() => {
+  init_logger();
+  import_ignore = __toESM(require_ignore(), 1);
+  DISABLED_MATCHER = {
+    is_ignored: () => false,
+    watch_directories: []
+  };
+  IGNORE_LINE_BREAK = /\r?\n/;
+  BLANK_PATTERN = /^\s*$/;
+  TRAILING_PATTERN_WHITESPACE = /\s+$/;
+  MIDDLE_SLASH = /\/(?!$)/;
+  LITERAL_DIRECTORY_METACHARACTERS = /[\\*[\]]/g;
+  ESCAPED_PATTERN_PREFIX = /^\\([!#])/;
+});
+
 // node_modules/picomatch/lib/constants.js
 var require_constants = __commonJS((exports, module) => {
   var WIN_SLASH = "\\\\/";
@@ -25260,8 +25895,8 @@ var require_utils = __commonJS((exports) => {
     }
     return output;
   };
-  exports.basename = (path10, { windows } = {}) => {
-    const segs = path10.split(windows ? /[\\/]/ : "/");
+  exports.basename = (path11, { windows } = {}) => {
+    const segs = path11.split(windows ? /[\\/]/ : "/");
     const last = segs[segs.length - 1];
     if (last === "") {
       return segs[segs.length - 2];
@@ -26089,9 +26724,9 @@ var require_parse = __commonJS((exports, module) => {
               const idx = prev.value.lastIndexOf("[");
               const pre = prev.value.slice(0, idx);
               const rest2 = prev.value.slice(idx + 2);
-              const posix3 = POSIX_REGEX_SOURCE[rest2];
-              if (posix3) {
-                prev.value = pre + posix3;
+              const posix4 = POSIX_REGEX_SOURCE[rest2];
+              if (posix4) {
+                prev.value = pre + posix4;
                 state.backtrack = true;
                 advance();
                 if (!bos.output && tokens.indexOf(prev) === 1) {
@@ -26612,7 +27247,7 @@ var require_picomatch = __commonJS((exports, module) => {
       throw new TypeError("Expected pattern to be a non-empty string");
     }
     const opts = options || {};
-    const posix3 = opts.windows;
+    const posix4 = opts.windows;
     const regex = isState ? picomatch.compileRe(glob, options) : picomatch.makeRe(glob, options, false, true);
     const state = regex.state;
     delete regex.state;
@@ -26622,8 +27257,8 @@ var require_picomatch = __commonJS((exports, module) => {
       isIgnored = picomatch(opts.ignore, ignoreOpts, returnState);
     }
     const matcher = (input, returnObject = false) => {
-      const { isMatch, match, output } = picomatch.test(input, regex, options, { glob, posix: posix3 });
-      const result = { glob, state, regex, posix: posix3, input, output, match, isMatch };
+      const { isMatch, match, output } = picomatch.test(input, regex, options, { glob, posix: posix4 });
+      const result = { glob, state, regex, posix: posix4, input, output, match, isMatch };
       if (typeof opts.onResult === "function") {
         opts.onResult(result);
       }
@@ -26648,7 +27283,7 @@ var require_picomatch = __commonJS((exports, module) => {
     }
     return matcher;
   };
-  picomatch.test = (input, regex, options, { glob, posix: posix3 } = {}) => {
+  picomatch.test = (input, regex, options, { glob, posix: posix4 } = {}) => {
     if (typeof input !== "string") {
       throw new TypeError("Expected input to be a string");
     }
@@ -26656,7 +27291,7 @@ var require_picomatch = __commonJS((exports, module) => {
       return { isMatch: false, output: "" };
     }
     const opts = options || {};
-    const format = opts.format || (posix3 ? utils.toPosixSlashes : null);
+    const format = opts.format || (posix4 ? utils.toPosixSlashes : null);
     let match = input === glob;
     let output = match && format ? format(input) : input;
     if (match === false) {
@@ -26665,7 +27300,7 @@ var require_picomatch = __commonJS((exports, module) => {
     }
     if (match === false || opts.capture === true) {
       if (opts.matchBase === true || opts.basename === true) {
-        match = picomatch.matchBase(input, regex, options, posix3);
+        match = picomatch.matchBase(input, regex, options, posix4);
       } else {
         match = regex.exec(output);
       }
@@ -26742,7 +27377,7 @@ var require_picomatch2 = __commonJS((exports, module) => {
 });
 
 // src/utils/exclude-matcher.ts
-import path10 from "path";
+import path11 from "path";
 function normalize_pattern(raw) {
   const trimmed = raw.trim();
   if (trimmed === "")
@@ -26764,13 +27399,13 @@ function derive_dir_pattern(pattern) {
   return stripped === "" ? pattern : stripped;
 }
 function relative_to_containing_root(abs_path, workspace_roots) {
-  const target = path10.resolve(abs_path);
+  const target = path11.resolve(abs_path);
   let best = null;
   let best_root_length = -1;
   for (const my_root of workspace_roots) {
-    const root = path10.resolve(my_root);
-    const my_relative = path10.relative(root, target);
-    const contained = my_relative === "" || my_relative !== ".." && !my_relative.startsWith(`..${path10.sep}`) && !path10.isAbsolute(my_relative);
+    const root = path11.resolve(my_root);
+    const my_relative = path11.relative(root, target);
+    const contained = my_relative === "" || my_relative !== ".." && !my_relative.startsWith(`..${path11.sep}`) && !path11.isAbsolute(my_relative);
     if (contained && root.length > best_root_length) {
       best = my_relative;
       best_root_length = root.length;
@@ -26778,7 +27413,7 @@ function relative_to_containing_root(abs_path, workspace_roots) {
   }
   if (best === null)
     return null;
-  return best.split(path10.sep).join("/");
+  return best.split(path11.sep).join("/");
 }
 function create_exclude_matcher(patterns) {
   const compiled = [];
@@ -26849,15 +27484,13 @@ var init_exclude_matcher = __esm(() => {
 });
 
 // src/indexer/index.ts
-import * as fs9 from "fs";
-import * as path11 from "path";
+import * as fs10 from "fs";
+import * as path12 from "path";
 var MAX_PARALLEL = 4, YIELD_INTERVAL_MS = 100, INDEX_DEBOUNCE_MS = 200, WorkspaceIndexer;
 var init_indexer = __esm(() => {
   init_esm();
-  init_lexer();
-  init_parser();
   init_analyzer();
-  init_directive_parser();
+  init_source_analysis();
   init_scope_resolver();
   init_context_tracker();
   init_logger();
@@ -26867,6 +27500,7 @@ var init_indexer = __esm(() => {
   init_findalias_resolver();
   init_file_path_utils();
   init_source_discovery_policy();
+  init_gitignore_matcher();
   init_exclude_matcher();
   WorkspaceIndexer = class WorkspaceIndexer {
     symbol_index = new Map;
@@ -26874,10 +27508,6 @@ var init_indexer = __esm(() => {
     token_index = new Map;
     context_ranges_index = new Map;
     enabled = true;
-    lexer = new StataLexer;
-    parser = new StataParser;
-    analyzer = new SemanticAnalyzer;
-    directive_parser = new DirectiveParser;
     ado_paths = [];
     help_search_paths = [];
     findalias_resolver = new FindaliasResolver;
@@ -26892,6 +27522,8 @@ var init_indexer = __esm(() => {
     cancelled = false;
     size_threshold_bytes = 512 * 1024;
     exclude_matcher = create_exclude_matcher([]);
+    respect_gitignore = true;
+    gitignore_matcher = create_gitignore_matcher([]);
     skipped_files = new Map;
     max_indexed_files = 1000;
     max_files_reached = false;
@@ -27001,16 +27633,17 @@ var init_indexer = __esm(() => {
     async initialize(workspace_folders, ado_paths = []) {
       const generation = ++this.scan_generation;
       this.cancelled = false;
-      if (!this.enabled) {
-        this.dependency_graph?.mark_scan_complete();
-        return;
-      }
       this.ado_paths = ado_paths;
-      this.workspace_roots = workspace_folders.map((f) => path11.resolve(f));
+      this.workspace_roots = workspace_folders.map((f) => path12.resolve(f));
       this.scan_roots = [
         ...this.workspace_roots,
-        ...ado_paths.map((my_path) => path11.resolve(my_path))
+        ...ado_paths.map((my_path) => path12.resolve(my_path))
       ];
+      this.gitignore_matcher = create_gitignore_matcher(this.workspace_roots, this.respect_gitignore);
+      if (!this.enabled) {
+        this.dependency_graph?.mark_scan_complete();
+        return;
+      }
       this.help_search_paths = discover_stata_ado_paths();
       const start_time = Date.now();
       for (const folder of [...workspace_folders, ...this.ado_paths]) {
@@ -27032,8 +27665,10 @@ var init_indexer = __esm(() => {
     async scan_directory(dir_path, generation) {
       if (!this.is_active_generation(generation))
         return;
+      if (this.gitignore_matcher.is_ignored(dir_path, "directory"))
+        return;
       try {
-        const entries = await fs9.promises.readdir(dir_path, {
+        const entries = await fs10.promises.readdir(dir_path, {
           withFileTypes: true
         });
         if (!this.is_active_generation(generation))
@@ -27042,7 +27677,7 @@ var init_indexer = __esm(() => {
         for (const entry of entries) {
           if (!this.is_active_generation(generation))
             break;
-          const entry_path = path11.join(dir_path, entry.name);
+          const entry_path = path12.join(dir_path, entry.name);
           if (entry.isDirectory()) {
             if (entry.name.startsWith(".")) {
               continue;
@@ -27052,6 +27687,8 @@ var init_indexer = __esm(() => {
             }
             await this.scan_directory(entry_path, generation);
           } else if (entry.isFile() && hasStataExtension(entry.name)) {
+            if (this.is_gitignored(entry_path))
+              continue;
             if (!this.exclude_matcher.is_empty && this.exclude_matcher.is_excluded_file(entry_path, this.workspace_roots)) {
               continue;
             }
@@ -27074,7 +27711,7 @@ var init_indexer = __esm(() => {
           const now = Date.now();
           if (now - last_yield_time.value > YIELD_INTERVAL_MS) {
             last_yield_time.value = now;
-            await new Promise((resolve10) => setImmediate(resolve10));
+            await new Promise((resolve11) => setImmediate(resolve11));
           }
         }
       };
@@ -27120,6 +27757,8 @@ var init_indexer = __esm(() => {
       const file_uri = URI.file(file_path).toString();
       if (is_hidden_source_path(file_path, this.scan_roots))
         return;
+      if (this.is_gitignored(file_path))
+        return;
       if (!this.exclude_matcher.is_empty && this.exclude_matcher.is_excluded_file(file_path, this.workspace_roots)) {
         this.clear_stale_entry(file_uri);
         return;
@@ -27128,7 +27767,7 @@ var init_indexer = __esm(() => {
       if (!already_indexed && this.should_skip_for_max_indexed_files(file_uri))
         return;
       try {
-        const stats = await fs9.promises.stat(file_path);
+        const stats = await fs10.promises.stat(file_path);
         if (!this.is_active_generation(generation))
           return;
         if (stats.size > this.size_threshold_bytes) {
@@ -27138,56 +27777,41 @@ var init_indexer = __esm(() => {
           this.metrics.files_skipped++;
           return;
         }
-        const content = await fs9.promises.readFile(file_path, "utf8");
+        const content = await fs10.promises.readFile(file_path, "utf8");
         if (!this.is_active_generation(generation))
           return;
         if (!already_indexed && this.should_skip_for_max_indexed_files(file_uri))
           return;
-        if (path11.extname(file_path).toLowerCase() === ".mata") {
+        if (path12.extname(file_path).toLowerCase() === ".mata") {
           await this.index_mata_file(content, file_uri, generation);
           return;
         }
-        const directive_result = this.directive_parser.parse(content, file_uri);
-        const lexResult = this.lexer.tokenize(content);
-        const parseResult = this.parser.parse(lexResult.tokens);
+        const source_analysis = analyze_source(content, file_uri);
+        const directive_result = source_analysis.directives;
+        const analyzeResult = source_analysis.analysis;
         const workspace_root = get_workspace_root_for_path(this.workspace_roots, file_path);
-        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) {
           effective_working_directory = await this.scope_resolver.resolve_inherited_working_directory(directive_result.directives, file_uri, directive_result.standalone !== undefined, this.scope_resolver_config);
         }
-        const my_caller_dir = path11.dirname(file_path);
-        const { timeline: cd_timeline } = build_cd_timeline({
-          starting_wd: effective_working_directory,
-          caller_dir: my_caller_dir,
+        const all_forward_calls = prepare_forward_calls({
+          uri: file_uri,
+          command_calls: analyzeResult.forward_calls,
+          directive_calls: directive_result.forward_calls ?? [],
           cd_commands: analyzeResult.cd_commands,
+          working_directory: effective_working_directory,
           workspace_roots: this.workspace_roots
         });
-        const stamped_analyzer_calls = apply_cd_timeline(analyzeResult.forward_calls, cd_timeline);
         const context_tracker = new ContextTracker;
-        context_tracker.initialize_from_tokens(lexResult.tokens, content);
+        context_tracker.initialize_from_tokens(source_analysis.tokens, content);
         const context_ranges = context_tracker.get_all_context_ranges();
         if (!this.is_active_generation(generation))
           return;
         if (!already_indexed && this.should_skip_for_max_indexed_files(file_uri))
           return;
-        let all_forward_calls = stamped_analyzer_calls;
-        if (directive_result.forward_calls && directive_result.forward_calls.length > 0) {
-          const directive_forward_calls = directive_result.forward_calls.map((d) => ({
-            type: d.type,
-            raw_path: d.raw_path,
-            call_site_line: d.call_site_line,
-            range: d.range,
-            source: "directive",
-            is_static: true,
-            caller_uri: file_uri,
-            working_directory: effective_working_directory
-          }));
-          all_forward_calls = [
-            ...stamped_analyzer_calls,
-            ...directive_forward_calls
-          ].sort((a, b) => a.call_site_line - b.call_site_line);
+        if ((directive_result.forward_calls?.length ?? 0) > 0) {
+          all_forward_calls.sort((a, b) => a.call_site_line - b.call_site_line);
         }
         if (this.dependency_graph) {
           const graph_result = this.dependency_graph.update_caller(file_uri, all_forward_calls);
@@ -27195,7 +27819,7 @@ var init_indexer = __esm(() => {
             this.on_graph_change_callback(graph_result.changed_callees);
           }
         }
-        this.token_index.set(file_uri, lexResult.tokens);
+        this.token_index.set(file_uri, source_analysis.tokens);
         this.context_ranges_index.set(file_uri, context_ranges);
         const is_new_entry = !this.symbol_index.has(file_uri);
         this.symbol_index.set(file_uri, {
@@ -27274,6 +27898,8 @@ var init_indexer = __esm(() => {
         return;
       if (is_hidden_source_path(file_path, this.scan_roots))
         return;
+      if (this.is_gitignored(file_path))
+        return;
       const existing = this.pending_updates.get(file_path);
       if (existing) {
         clearTimeout(existing);
@@ -27298,7 +27924,7 @@ var init_indexer = __esm(() => {
             break;
           this.update_queue.delete(file_path);
           await this.index_file(file_path, generation);
-          await new Promise((resolve10) => setImmediate(resolve10));
+          await new Promise((resolve11) => setImmediate(resolve11));
         }
       } finally {
         this.is_processing_queue = false;
@@ -27330,10 +27956,12 @@ var init_indexer = __esm(() => {
       this.version = 0;
       this.cancelled = false;
       this.workspace_roots = [];
+      this.gitignore_matcher = create_gitignore_matcher([]);
     }
     configure(config) {
       this.scope_resolver_config = scope_resolver_config_for(config);
       this.exclude_matcher = create_exclude_matcher(config.exclude ?? []);
+      this.respect_gitignore = config.workspace?.respectGitignore !== false;
       const threshold = config?.indexing?.maxFileSizeBytes;
       if (typeof threshold === "number" && threshold > 0) {
         this.size_threshold_bytes = threshold;
@@ -27348,6 +27976,9 @@ var init_indexer = __esm(() => {
         this.enabled = true;
       }
     }
+    is_gitignored(file_path) {
+      return this.gitignore_matcher.is_ignored(file_path, "file");
+    }
     get_skipped_files() {
       return new Map(this.skipped_files);
     }
@@ -27557,17 +28188,17 @@ var init_indexer = __esm(() => {
         ...this.help_search_paths
       ];
       for (const my_dir of the_search_dirs) {
-        const my_subdir_path = path11.join(my_dir, my_first_letter, my_basename);
+        const my_subdir_path = path12.join(my_dir, my_first_letter, my_basename);
         try {
-          await fs9.promises.access(my_subdir_path);
+          await fs10.promises.access(my_subdir_path);
           return my_subdir_path;
         } catch {}
-        const my_direct_path = path11.join(my_dir, my_basename);
+        const my_direct_path = path12.join(my_dir, my_basename);
         try {
-          await fs9.promises.access(my_direct_path);
+          await fs10.promises.access(my_direct_path);
           return my_direct_path;
         } catch {}
-        if (!this.workspace_roots.includes(path11.resolve(my_dir))) {
+        if (!this.workspace_roots.includes(path12.resolve(my_dir))) {
           continue;
         }
         const my_recursive_match = await this.find_sthlp_file_recursive(my_dir, my_basename);
@@ -27591,14 +28222,14 @@ var init_indexer = __esm(() => {
         ...this.help_search_paths
       ];
       for (const my_dir of the_search_dirs) {
-        const my_subdir_path = path11.join(my_dir, my_first_letter, my_basename);
+        const my_subdir_path = path12.join(my_dir, my_first_letter, my_basename);
         try {
-          await fs9.promises.access(my_subdir_path);
+          await fs10.promises.access(my_subdir_path);
           return my_subdir_path;
         } catch {}
-        const my_direct_path = path11.join(my_dir, my_basename);
+        const my_direct_path = path12.join(my_dir, my_basename);
         try {
-          await fs9.promises.access(my_direct_path);
+          await fs10.promises.access(my_direct_path);
           return my_direct_path;
         } catch {}
       }
@@ -27606,9 +28237,9 @@ var init_indexer = __esm(() => {
     }
     async list_matching_sthlp(dir, prefix) {
       try {
-        const the_entries = await fs9.promises.readdir(dir);
+        const the_entries = await fs10.promises.readdir(dir);
         const the_matches = the_entries.filter((my_entry) => my_entry.startsWith(prefix) && my_entry.endsWith(".sthlp")).sort();
-        return the_matches.map((my_entry) => path11.join(dir, my_entry));
+        return the_matches.map((my_entry) => path12.join(dir, my_entry));
       } catch {
         return [];
       }
@@ -27632,7 +28263,7 @@ var init_indexer = __esm(() => {
         const my_prefix = `${my_variant}_`;
         const my_first_letter = my_variant.charAt(0).toLowerCase();
         for (const my_dir of the_search_dirs) {
-          const my_subdir = path11.join(my_dir, my_first_letter);
+          const my_subdir = path12.join(my_dir, my_first_letter);
           const the_subdir_matches = await this.list_matching_sthlp(my_subdir, my_prefix);
           for (const my_match of the_subdir_matches) {
             if (!the_seen.has(my_match)) {
@@ -27670,14 +28301,14 @@ var init_indexer = __esm(() => {
         }
         let the_entries;
         try {
-          the_entries = await fs9.promises.readdir(my_entry.path, {
+          the_entries = await fs10.promises.readdir(my_entry.path, {
             withFileTypes: true
           });
         } catch {
           continue;
         }
         for (const my_dirent of the_entries) {
-          const my_path = path11.join(my_entry.path, my_dirent.name);
+          const my_path = path12.join(my_entry.path, my_dirent.name);
           if (my_dirent.isDirectory()) {
             if (!WorkspaceIndexer.EXCLUDED_DIRS.has(my_dirent.name)) {
               the_dirs.push({
@@ -27687,7 +28318,7 @@ var init_indexer = __esm(() => {
             }
             continue;
           }
-          if (my_dirent.name === basename6 && await entry_is_file_async(my_dirent, my_path, fs9.promises)) {
+          if (my_dirent.name === basename6 && await entry_is_file_async(my_dirent, my_path, fs10.promises)) {
             return my_path;
           }
         }
@@ -27696,9 +28327,9 @@ var init_indexer = __esm(() => {
     }
     resolve_program(name, referring_uri) {
       const referring_path = URI.parse(referring_uri).fsPath;
-      const current_dir = path11.dirname(referring_path);
-      const local_ado = path11.join(current_dir, `${name}.ado`);
-      if (fs9.existsSync(local_ado)) {
+      const current_dir = path12.dirname(referring_path);
+      const local_ado = path12.join(current_dir, `${name}.ado`);
+      if (fs10.existsSync(local_ado)) {
         const local_uri = URI.file(local_ado).toString();
         const entry = this.symbol_index.get(local_uri);
         return entry?.symbols.programs.get(name);
@@ -27717,7 +28348,7 @@ var init_indexer = __esm(() => {
       }
       try {
         const file_path = URI.parse(file_uri).fsPath;
-        const content = await fs9.promises.readFile(file_path, "utf8");
+        const content = await fs10.promises.readFile(file_path, "utf8");
         const resolve_config = build_scope_resolver_config(cross_file_config);
         const resolved_scope = await scope_resolver.resolve(file_uri, content, resolve_config);
         return resolved_scope.symbols;
@@ -28005,8 +28636,7 @@ class IndentationDiagnosticAnalyzer {
         }
         return;
       }
-      const is_control_flow = node.type === "program" || node.type === "if" || node.type === "else" || node.type === "foreach" || node.type === "forvalues" || node.type === "while" || node.type === "frame";
-      if (is_control_flow && node.body) {
+      if (this.is_block_node_type(node) && "body" in node && node.body) {
         for (const child of node.body) {
           const child_start_line = child.range.start.line;
           if (child_start_line === start_line) {
@@ -28052,9 +28682,8 @@ class IndentationDiagnosticAnalyzer {
         }
         return;
       }
-      if (this.is_block_node_type(node)) {
-        const block_node = node;
-        for (const my_child of block_node.body) {
+      if (this.is_block_node_type(node) && "body" in node && node.body) {
+        for (const my_child of node.body) {
           const child_start_line = my_child.range.start.line;
           if (child_start_line === start_line) {
             walk_node(my_child, depth);
@@ -28067,6 +28696,10 @@ class IndentationDiagnosticAnalyzer {
             expected_depths.set(end_line, depth);
           }
         }
+      } else if ("body" in node && node.body) {
+        for (const my_child of node.body) {
+          walk_node(my_child, depth);
+        }
       }
     };
     for (const my_node of document.ast.nodes) {
@@ -28080,7 +28713,7 @@ class IndentationDiagnosticAnalyzer {
     return expected_depths;
   }
   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";
+    return node.type === "program" || node.type === "if" && !node.is_single_statement || node.type === "else" || node.type === "foreach" || node.type === "forvalues" || node.type === "while" || node.type === "frame";
   }
   should_skip_unnecessary_check(line, lineIndex, block_comment_lines2, continuation_lines) {
     if (block_comment_lines2.has(lineIndex)) {
@@ -31502,8 +32135,8 @@ function format_help_link(topic, display) {
 }
 
 // src/providers/completion.ts
-import * as fs10 from "fs";
-import * as path12 from "path";
+import * as fs11 from "fs";
+import * as path13 from "path";
 function coerce_macro_map(value) {
   if (value instanceof Map) {
     return value;
@@ -32269,15 +32902,15 @@ class CompletionProvider {
           const path_parts = clean_path.split("/");
           search_prefix = path_parts.pop() || "";
           const dir_path = path_parts.join("/");
-          base_dir = path12.resolve(workspace_root, dir_path);
+          base_dir = path13.resolve(workspace_root, dir_path);
         } else {
           search_prefix = clean_path;
         }
       }
-      if (!fs10.existsSync(base_dir) || !fs10.statSync(base_dir).isDirectory()) {
+      if (!fs11.existsSync(base_dir) || !fs11.statSync(base_dir).isDirectory()) {
         return completions;
       }
-      const entries = fs10.readdirSync(base_dir, { withFileTypes: true });
+      const entries = fs11.readdirSync(base_dir, { withFileTypes: true });
       for (const entry of entries) {
         if (entry.name.startsWith(".")) {
           continue;
@@ -32285,7 +32918,7 @@ class CompletionProvider {
         if (search_prefix && !entry.name.toLowerCase().startsWith(search_prefix.toLowerCase())) {
           continue;
         }
-        const entry_kind = classify_entry_sync(entry, path12.join(base_dir, entry.name), fs10);
+        const entry_kind = classify_entry_sync(entry, path13.join(base_dir, entry.name), fs11);
         if (entry_kind === "directory") {
           completions.push({
             label: entry.name + "/",
@@ -32313,17 +32946,17 @@ class CompletionProvider {
   get_workspace_root(document_uri) {
     try {
       const file_path = document_uri.replace(/^file:\/\//, "");
-      let current_dir = path12.dirname(file_path);
-      while (current_dir !== path12.dirname(current_dir)) {
+      let current_dir = path13.dirname(file_path);
+      while (current_dir !== path13.dirname(current_dir)) {
         const markers = [".git", "sight.toml", ".sight.json", "package.json", ".vscode"];
         for (const marker of markers) {
-          if (fs10.existsSync(path12.join(current_dir, marker))) {
+          if (fs11.existsSync(path13.join(current_dir, marker))) {
             return current_dir;
           }
         }
-        current_dir = path12.dirname(current_dir);
+        current_dir = path13.dirname(current_dir);
       }
-      return path12.dirname(file_path);
+      return path13.dirname(file_path);
     } catch {
       return null;
     }
@@ -33581,7 +34214,7 @@ var init_help_resolver = __esm(() => {
 });
 
 // src/server-handlers.ts
-import * as fs11 from "fs";
+import * as fs12 from "fs";
 function create_initialize_handler(on_capabilities_detected, on_initialization_options_detected, on_root_uri_detected) {
   return (params) => {
     const capabilities = params.capabilities;
@@ -33808,7 +34441,7 @@ function create_shutdown_handler(deps, disposables) {
       const SHUTDOWN_TIMEOUT_MS = 500;
       await Promise.race([
         deps.document_store.dispose(),
-        new Promise((resolve11) => setTimeout(resolve11, SHUTDOWN_TIMEOUT_MS))
+        new Promise((resolve12) => setTimeout(resolve12, SHUTDOWN_TIMEOUT_MS))
       ]);
     }
     deps?.scope_resolver?.dispose();
@@ -33825,10 +34458,14 @@ function create_exit_handler(on_exit) {
     }
   };
 }
-function create_did_change_watched_files_handler(deps, parse_uri, on_file_changed, on_project_config_changed) {
+function create_did_change_watched_files_handler(deps, parse_uri, on_file_changed, on_project_config_changed, on_gitignore_changed) {
   return (params) => {
     for (const my_event of params.changes) {
       const file_path = parse_uri(my_event.uri);
+      if (GITIGNORE_PATH.test(file_path)) {
+        on_gitignore_changed?.(my_event.uri);
+        continue;
+      }
       if (is_project_config_event_path(file_path)) {
         on_project_config_changed?.(my_event.uri);
         continue;
@@ -33911,7 +34548,7 @@ function create_shared_ihlp_resolver(deps, max_size = MAX_IHLP_CACHE_SIZE) {
     const my_cached = the_cache.get(my_path);
     if (my_cached !== undefined) {
       try {
-        const my_stat = await fs11.promises.stat(my_path);
+        const my_stat = await fs12.promises.stat(my_path);
         if (my_stat.mtimeMs === my_cached.mtime_ms) {
           the_cache.delete(my_path);
           the_cache.set(my_path, my_cached);
@@ -33924,8 +34561,8 @@ function create_shared_ihlp_resolver(deps, max_size = MAX_IHLP_CACHE_SIZE) {
       }
     }
     try {
-      const my_stat = await fs11.promises.stat(my_path);
-      const my_content = await fs11.promises.readFile(my_path, "utf-8");
+      const my_stat = await fs12.promises.stat(my_path);
+      const my_content = await fs12.promises.readFile(my_path, "utf-8");
       if (the_cache.size >= max_size) {
         const my_first = the_cache.keys().next().value;
         if (my_first !== undefined) {
@@ -33962,7 +34599,7 @@ function create_resolve_sthlp_file_handler(deps, shared_ihlp) {
     if (!deps.workspace_indexer)
       return null;
     try {
-      const my_content = await fs11.promises.readFile(file_path, "utf-8");
+      const my_content = await fs12.promises.readFile(file_path, "utf-8");
       return await expand_includes(my_content, my_ihlp_resolver);
     } catch {
       return null;
@@ -34041,7 +34678,7 @@ function create_expand_includes_handler(deps, shared_ihlp) {
     return { content: my_result };
   };
 }
-var import_node7, DEFAULT_SETTINGS, MAX_IHLP_CACHE_SIZE = 500, MAX_RESOLVE_STHLP_NEGATIVE_CACHE_SIZE = 1000;
+var import_node7, DEFAULT_SETTINGS, GITIGNORE_PATH, MAX_IHLP_CACHE_SIZE = 500, MAX_RESOLVE_STHLP_NEGATIVE_CACHE_SIZE = 1000;
 var init_server_handlers = __esm(() => {
   init_completion();
   init_context_tracker();
@@ -34090,6 +34727,9 @@ var init_server_handlers = __esm(() => {
     adoPaths: [],
     indexWorkspace: true,
     exclude: [],
+    workspace: {
+      respectGitignore: true
+    },
     cross_file: {
       index_workspace: true,
       max_indexed_files: 1000,
@@ -34110,6 +34750,7 @@ var init_server_handlers = __esm(() => {
     },
     debug: false
   };
+  GITIGNORE_PATH = /(?:^|[/\\])\.gitignore$/;
 });
 
 // src/utils/config-validator.ts
@@ -34251,6 +34892,13 @@ function validate_comment_formatting_config(config, log_warning) {
   if (typeof config.indexWorkspace === "boolean") {
     validated_config.indexWorkspace = config.indexWorkspace;
   }
+  if (config.workspace?.respectGitignore !== undefined) {
+    if (typeof config.workspace.respectGitignore === "boolean") {
+      validated_config.workspace.respectGitignore = config.workspace.respectGitignore;
+    } else {
+      log_warning?.("Invalid workspace.respectGitignore: " + `${config.workspace.respectGitignore}. ` + "Using default: " + `${DEFAULT_SETTINGS.workspace.respectGitignore}`);
+    }
+  }
   if (typeof config.debug === "boolean") {
     validated_config.debug = config.debug;
   }
@@ -34562,15 +35210,15 @@ var init_shared = __esm(() => {
 });
 
 // src/cli/source-files.ts
-import * as fs12 from "fs";
-import * as path13 from "path";
+import * as fs13 from "fs";
+import * as path14 from "path";
 import { TextDecoder } from "util";
 function canonicalize_existing_path(file_path) {
-  return fs12.realpathSync.native(file_path);
+  return fs13.realpathSync.native(file_path);
 }
 function workspace_relative(workspace_root, file_path) {
-  const relative6 = path13.relative(workspace_root, file_path);
-  const inside = relative6 !== ".." && !relative6.startsWith(`..${path13.sep}`) && !path13.isAbsolute(relative6);
+  const relative6 = path14.relative(workspace_root, file_path);
+  const inside = relative6 !== ".." && !relative6.startsWith(`..${path14.sep}`) && !path14.isAbsolute(relative6);
   return { relative: relative6, inside };
 }
 function relative_path(workspace_root, file_path) {
@@ -34578,30 +35226,34 @@ function relative_path(workspace_root, file_path) {
   if (relative6 === "") {
     return ".";
   }
-  return path13.isAbsolute(relative6) ? file_path : relative6.split(path13.sep).join("/");
+  return path14.isAbsolute(relative6) ? file_path : relative6.split(path14.sep).join("/");
 }
 function is_within_workspace(workspace_root, file_path) {
   const { relative: relative6, inside } = workspace_relative(workspace_root, file_path);
   return relative6 === "" || relative6.length > 0 && inside;
 }
-function walk_sources(dir_path, out, operator_errors, workspace_roots, exclude_matcher) {
+function walk_sources(dir_path, out, operator_errors, workspace_roots, exclude_matcher, gitignore_matcher) {
+  if (gitignore_matcher.is_ignored(dir_path, "directory"))
+    return;
   let entries;
   try {
-    entries = fs12.readdirSync(dir_path, { withFileTypes: true });
+    entries = fs13.readdirSync(dir_path, { withFileTypes: true });
   } catch (error) {
     operator_errors.push(`cannot read directory: ${dir_path}: ${error_message(error)}`);
     return;
   }
   for (const entry of entries) {
-    const entry_path = path13.join(dir_path, entry.name);
+    const entry_path = path14.join(dir_path, entry.name);
     if (entry.isDirectory()) {
       if (entry.name.startsWith("."))
         continue;
       if (!exclude_matcher.is_empty && exclude_matcher.is_excluded_dir(entry_path, workspace_roots)) {
         continue;
       }
-      walk_sources(entry_path, out, operator_errors, workspace_roots, exclude_matcher);
+      walk_sources(entry_path, out, operator_errors, workspace_roots, exclude_matcher, gitignore_matcher);
     } else if (entry.isFile() && hasStataExtension(entry.name)) {
+      if (gitignore_matcher.is_ignored(entry_path, "file"))
+        continue;
       if (!exclude_matcher.is_empty && exclude_matcher.is_excluded_file(entry_path, workspace_roots)) {
         continue;
       }
@@ -34609,20 +35261,21 @@ function walk_sources(dir_path, out, operator_errors, workspace_roots, exclude_m
     }
   }
 }
-function collect_report_targets(input_paths, workspace_root, cwd, exclude_patterns = []) {
+function collect_report_targets(input_paths, workspace_root, cwd, exclude_patterns = [], respect_gitignore = true) {
   const operator_errors = [];
   const source_paths = [];
-  let normalized_root = path13.resolve(workspace_root);
+  let normalized_root = path14.resolve(workspace_root);
   try {
     normalized_root = canonicalize_existing_path(normalized_root);
   } catch {}
   const exclude_matcher = create_exclude_matcher(exclude_patterns);
   const exclude_roots = [normalized_root];
+  const gitignore_matcher = create_gitignore_matcher(exclude_roots, respect_gitignore);
   const has_explicit_paths = input_paths.length > 0;
   const paths_to_collect = input_paths.length > 0 ? input_paths : [normalized_root];
   for (const input_path of paths_to_collect) {
-    const resolved_path = path13.resolve(cwd, input_path);
-    if (!fs12.existsSync(resolved_path)) {
+    const resolved_path = path14.resolve(cwd, input_path);
+    if (!fs13.existsSync(resolved_path)) {
       operator_errors.push(`path does not exist: ${input_path}`);
       continue;
     }
@@ -34635,13 +35288,13 @@ function collect_report_targets(input_paths, workspace_root, cwd, exclude_patter
     }
     let stat;
     try {
-      stat = fs12.statSync(absolute_path);
+      stat = fs13.statSync(absolute_path);
     } catch (error) {
       operator_errors.push(`cannot stat path: ${input_path}: ${error_message(error)}`);
       continue;
     }
     if (stat.isDirectory()) {
-      walk_sources(absolute_path, source_paths, operator_errors, exclude_roots, exclude_matcher);
+      walk_sources(absolute_path, source_paths, operator_errors, exclude_roots, exclude_matcher, gitignore_matcher);
     } else if (stat.isFile() && hasStataExtension(absolute_path)) {
       source_paths.push(absolute_path);
     }
@@ -34730,7 +35383,7 @@ function decode_error_diagnostic(offset) {
 function read_source_file(file_path) {
   let bytes;
   try {
-    bytes = fs12.readFileSync(file_path);
+    bytes = fs13.readFileSync(file_path);
   } catch (error) {
     return {
       kind: "read-error",
@@ -34754,6 +35407,7 @@ var init_source_files = __esm(() => {
   init_file_path_utils();
   init_exclude_matcher();
   init_diagnostic_code_description();
+  init_gitignore_matcher();
   init_shared();
   import_vscode_languageserver6 = __toESM(require_main4(), 1);
 });
@@ -34768,8 +35422,8 @@ __export(exports_check, {
   collect_check_diagnostics: () => collect_check_diagnostics,
   build_check_context: () => build_check_context
 });
-import * as fs13 from "fs";
-import * as path14 from "path";
+import * as fs14 from "fs";
+import * as path15 from "path";
 function parse_required_option_value(argv, index, flag, value_kind, inline_value) {
   if (inline_value !== undefined) {
     if (inline_value.length === 0) {
@@ -34935,7 +35589,7 @@ function load_check_config(options) {
       warnings: validation_warnings
     };
   }
-  const loaded = options.config_path ? load_toml_file(path14.resolve(options.cwd, options.config_path)) : discover_and_load_project_config(options.workspace_root);
+  const loaded = options.config_path ? load_toml_file(path15.resolve(options.cwd, options.config_path)) : discover_and_load_project_config(options.workspace_root);
   if (loaded.kind === "load-failed") {
     return {
       kind: "operator-error",
@@ -35031,7 +35685,7 @@ async function collect_check_diagnostics(context, workspace_root, config, target
     const uri = URI.file(target.path).toString();
     let stats;
     try {
-      stats = fs13.statSync(target.path);
+      stats = fs14.statSync(target.path);
     } catch (error) {
       records.push(diagnostic_record(target.relative_path, unreadable_diagnostic(read_error_detail(error))));
       return records;
@@ -35042,7 +35696,7 @@ async function collect_check_diagnostics(context, workspace_root, config, target
       }
       return records;
     }
-    if (is_within_workspace(workspace_root, target.path) && files_indexed >= config.cross_file.max_indexed_files && !context.workspace_indexer.has_indexed_file(uri) && !is_hidden_source_path(target.path, scan_roots) && !exclude_matcher.is_excluded_file(target.path, [workspace_root])) {
+    if (is_within_workspace(workspace_root, target.path) && files_indexed >= config.cross_file.max_indexed_files && !context.workspace_indexer.has_indexed_file(uri) && !context.workspace_indexer.is_gitignored(target.path) && !is_hidden_source_path(target.path, scan_roots) && !exclude_matcher.is_excluded_file(target.path, [workspace_root])) {
       records.push(diagnostic_record(target.relative_path, index_limit_diagnostic()));
       return records;
     }
@@ -35126,10 +35780,10 @@ async function run_check_with_cwd(argv, cwd, output = DEFAULT_OUTPUT) {
 `);
     return EXIT_OK;
   }
-  const resolved_workspace_root = path14.resolve(cwd, result.args.workspace ?? ".");
+  const resolved_workspace_root = path15.resolve(cwd, result.args.workspace ?? ".");
   let is_workspace_directory = false;
   try {
-    is_workspace_directory = fs13.statSync(resolved_workspace_root).isDirectory();
+    is_workspace_directory = fs14.statSync(resolved_workspace_root).isDirectory();
   } catch {
     is_workspace_directory = false;
   }
@@ -35161,7 +35815,7 @@ async function run_check_with_cwd(argv, cwd, output = DEFAULT_OUTPUT) {
 `);
     return EXIT_OPERATOR_ERROR;
   }
-  const target_result = collect_report_targets(result.args.paths, workspace_root, cwd, config_result.config.exclude);
+  const target_result = collect_report_targets(result.args.paths, workspace_root, cwd, config_result.config.exclude, config_result.config.workspace.respectGitignore);
   if (target_result.operator_errors.length > 0) {
     for (const message of target_result.operator_errors) {
       output.stderr(`sight check: ${message}
@@ -35490,7 +36144,7 @@ function is_position_in_range3(position, range) {
 }
 
 // src/providers/hover.ts
-import * as path15 from "path";
+import * as path16 from "path";
 function has_definition_index(hit) {
   return typeof hit.definition_index === "number";
 }
@@ -36840,7 +37494,7 @@ ${source_info}${footer}`
     if (this.looks_like_uri_scheme(uri_or_path)) {
       return null;
     }
-    return path15.resolve(uri_or_path);
+    return path16.resolve(uri_or_path);
   }
   escape_markdown_link_text(text) {
     return text.replace(/[\\[\]()]/g, "\\$&");
@@ -36860,8 +37514,8 @@ ${source_info}${footer}`
     if (workspace_fs_path === null) {
       return fs_path;
     }
-    const relative7 = path15.relative(workspace_fs_path, fs_path);
-    if (relative7.startsWith("..") || path15.isAbsolute(relative7)) {
+    const relative7 = path16.relative(workspace_fs_path, fs_path);
+    if (relative7.startsWith("..") || path16.isAbsolute(relative7)) {
       return fs_path;
     }
     return relative7;
@@ -37215,7 +37869,7 @@ var init_hover = __esm(() => {
 });
 
 // src/providers/definition.ts
-import * as path16 from "path";
+import * as path17 from "path";
 
 class DefinitionProvider {
   workspace_roots = [];
@@ -37960,7 +38614,7 @@ class DefinitionProvider {
     if (!the_call) {
       return { matched: false, path: null };
     }
-    const current_dir = path16.dirname(URI.parse(document.uri).fsPath);
+    const current_dir = path17.dirname(URI.parse(document.uri).fsPath);
     const my_outcome = resolve_forward_call_rich(file_path, current_dir, the_call.working_directory, { workspace_roots: this.workspace_roots });
     if (my_outcome.kind === "exact" || my_outcome.kind === "case_only") {
       return { matched: true, path: my_outcome.path };
@@ -37969,8 +38623,8 @@ class DefinitionProvider {
   }
   resolve_file_path(current_uri, file_path) {
     const current_path = URI.parse(current_uri).fsPath;
-    const current_dir = path16.dirname(current_path);
-    const resolved_path = path16.resolve(current_dir, file_path);
+    const current_dir = path17.dirname(current_path);
+    const resolved_path = path17.resolve(current_dir, file_path);
     const the_roots_set = new Set(this.workspace_roots);
     the_roots_set.add(current_dir);
     const the_roots = Array.from(the_roots_set);
@@ -38544,7 +39198,7 @@ class ReferencesProvider {
         }
         file_count++;
         if (file_count % 10 === 0) {
-          await new Promise((resolve15) => setTimeout(resolve15, 0));
+          await new Promise((resolve16) => setTimeout(resolve16, 0));
           if (cancellation_token?.isCancellationRequested) {
             break;
           }
@@ -38970,7 +39624,7 @@ var init_section_detector = __esm(() => {
 });
 
 // src/providers/symbols.ts
-import * as path17 from "path";
+import * as path18 from "path";
 function is_position_in_range4(position, range) {
   if (position.line < range.start.line) {
     return false;
@@ -39366,7 +40020,7 @@ class SymbolProvider {
       }
     }
     for (const document of all_documents) {
-      const my_basename = path17.basename(document.uri);
+      const my_basename = path18.basename(document.uri);
       for (const my_program of document.symbols.programs.values()) {
         if (my_program.name.toLowerCase().includes(lower_query)) {
           symbols.push({
@@ -39623,6 +40277,13 @@ class IndentationAnalyzer {
       this.process_embedded_block_node(node);
       return;
     }
+    if (node.type === "if" && node.is_single_statement) {
+      this.process_regular_node(node);
+      for (const my_child of node.body) {
+        this.walk_node(my_child);
+      }
+      return;
+    }
     if (this.is_block_node(node)) {
       if (node.type === "command") {
         const cmd = node;
@@ -41297,6 +41958,12 @@ class PrettyPrinter {
     return spaced.replace(/\(\s+/g, "(").replace(/\s+\)/g, ")");
   }
   printControlFlow(node) {
+    if (node.type === "if" && node.is_single_statement) {
+      const body_node = node.body[0];
+      const body = body_node ? this.printNode(body_node) : "";
+      const inline_body = body.trimStart().slice(0, -this.getStatementTerminator().length);
+      return `${this.getIndent()}if ${node.condition || ""} ${inline_body}`;
+    }
     const the_lines = [];
     let header = this.getIndent();
     switch (node.type) {
@@ -41339,7 +42006,7 @@ class PrettyPrinter {
   }
   printEmbeddedBlock(node) {
     if (node.is_single_line) {
-      return `${this.getIndent()}${node.start_command} ${node.content}${this.getStatementTerminator()}`;
+      return `${this.getIndent()}${node.start_command} ${node.content}`;
     }
     const the_lines = [];
     the_lines.push(`${this.getIndent()}${node.start_command}`);
@@ -41811,8 +42478,8 @@ class DocumentDebounceManager {
     if (prev_resolver) {
       prev_resolver();
     }
-    const promise = new Promise((resolve15) => {
-      this.pending_resolvers.set(uri, resolve15);
+    const promise = new Promise((resolve16) => {
+      this.pending_resolvers.set(uri, resolve16);
     });
     this.pending_promises.set(uri, promise);
     const timer = setTimeout(() => {
@@ -41838,9 +42505,9 @@ class DocumentDebounceManager {
     if (this.parse_queue.length >= this.MAX_QUEUE_LENGTH) {
       logger.warn(`Parse queue full, dropping ${uri} v${version}`);
       this.metrics.dropped_parses++;
-      const resolve15 = this.pending_resolvers.get(uri);
-      if (resolve15) {
-        resolve15();
+      const resolve16 = this.pending_resolvers.get(uri);
+      if (resolve16) {
+        resolve16();
         this.pending_resolvers.delete(uri);
         this.pending_promises.delete(uri);
       }
@@ -41863,7 +42530,7 @@ class DocumentDebounceManager {
     }
     this.active_parses++;
     try {
-      await new Promise((resolve15) => setImmediate(resolve15));
+      await new Promise((resolve16) => setImmediate(resolve16));
       await callback();
     } catch (error) {
       logger.error(`Parse error for ${uri}: ${error}`);
@@ -41895,9 +42562,9 @@ class DocumentDebounceManager {
       clearTimeout(existing);
       this.pending_timers.delete(uri);
     }
-    const resolve15 = this.pending_resolvers.get(uri);
-    if (resolve15) {
-      resolve15();
+    const resolve16 = this.pending_resolvers.get(uri);
+    if (resolve16) {
+      resolve16();
       this.pending_resolvers.delete(uri);
       this.pending_promises.delete(uri);
     }
@@ -72719,7 +73386,8 @@ __export(exports_server_factory, {
   create_server: () => create_server,
   build_non_capability_settings_from_sources: () => build_non_capability_settings_from_sources
 });
-import * as fs14 from "fs";
+import * as fs15 from "fs";
+import * as path19 from "path";
 function create_transport_connection(transport) {
   if (transport === "stdio") {
     return import_node8.createConnection(process.stdin, process.stdout);
@@ -72755,6 +73423,7 @@ function indexing_affecting_signature(config) {
   return JSON.stringify({
     adoPaths: config?.adoPaths ?? null,
     exclude: config?.exclude ?? null,
+    respectGitignore: config?.workspace?.respectGitignore ?? true,
     indexWorkspace: config?.indexWorkspace ?? null,
     index_workspace: config?.cross_file?.index_workspace ?? null,
     max_indexed_files: config?.cross_file?.max_indexed_files ?? null,
@@ -72797,6 +73466,13 @@ async function create_server(options) {
   let project_config_candidate_dirs = [];
   let active_workspace_roots = [];
   let project_config_watch_registration = undefined;
+  let gitignore_watch_registration;
+  let gitignore_watch_seq = 0;
+  let gitignore_watch_directories = [];
+  let gitignore_refresh_pending = false;
+  let gitignore_refresh_scheduled = false;
+  let gitignore_change_seq = 0;
+  let workspace_indexing_seq = 0;
   let last_applied_indexing_signature = "";
   let config_change_seq = 0;
   let init_options_config = undefined;
@@ -72898,6 +73574,65 @@ async function create_server(options) {
     }
     previous_registration?.dispose();
   }
+  async function refresh_gitignore_watchers() {
+    const my_seq = ++gitignore_watch_seq;
+    if (!server_capabilities.has_watched_files_dynamic_registration_capability) {
+      return;
+    }
+    const watchers = gitignore_watch_directories.map(({ directory, recursive }) => ({
+      globPattern: {
+        baseUri: URI.file(directory).toString(),
+        pattern: recursive ? "**/.gitignore" : ".gitignore"
+      },
+      kind: import_node8.WatchKind.Create | import_node8.WatchKind.Change | import_node8.WatchKind.Delete
+    }));
+    const registration = watchers.length > 0 ? await connection.client.register(import_node8.DidChangeWatchedFilesNotification.type, { watchers }) : undefined;
+    if (my_seq !== gitignore_watch_seq || shutdown_requested) {
+      registration?.dispose();
+      return;
+    }
+    const previous_registration = gitignore_watch_registration;
+    gitignore_watch_registration = registration;
+    previous_registration?.dispose();
+  }
+  function is_relevant_gitignore(uri) {
+    const directory = path19.dirname(URI.parse(uri).fsPath);
+    return gitignore_watch_directories.some((watch) => {
+      const relative8 = path19.relative(watch.directory, directory);
+      return relative8 === "" || watch.recursive && relative8 !== ".." && !relative8.startsWith(`..${path19.sep}`) && !path19.isAbsolute(relative8);
+    });
+  }
+  function schedule_gitignore_refresh() {
+    if (gitignore_refresh_scheduled || shutdown_requested)
+      return;
+    gitignore_refresh_scheduled = true;
+    queueMicrotask(() => {
+      const my_change_seq = gitignore_change_seq;
+      const my_config_seq = config_change_seq;
+      get_document_settings("").then((settings) => {
+        if (shutdown_requested || !gitignore_refresh_pending || my_change_seq !== gitignore_change_seq || my_config_seq !== config_change_seq) {
+          return;
+        }
+        configure_workspace_indexing(settings, active_workspace_roots, true);
+      }).catch((error) => {
+        connection.console.log(`[indexer] Gitignore refresh failed: ${error_message(error)}`);
+      }).finally(() => {
+        gitignore_refresh_scheduled = false;
+        if (gitignore_refresh_pending && (my_change_seq !== gitignore_change_seq || my_config_seq !== config_change_seq)) {
+          schedule_gitignore_refresh();
+        }
+      });
+    });
+  }
+  function on_gitignore_changed(uri) {
+    if (shutdown_requested || !is_relevant_gitignore(uri))
+      return;
+    gitignore_refresh_pending = true;
+    gitignore_change_seq++;
+    workspace_indexing_seq++;
+    workspace_indexer?.cancel();
+    schedule_gitignore_refresh();
+  }
   function build_non_capability_settings() {
     return build_non_capability_settings_from_sources({
       init_options_config,
@@ -73106,10 +73841,16 @@ async function create_server(options) {
     scope_resolver?.reset_reverse_deps();
   }
   function configure_workspace_indexing(settings, folder_paths, reset_indexes) {
+    const my_indexing_seq = ++workspace_indexing_seq;
+    gitignore_refresh_pending = false;
     if (reset_indexes) {
       reset_workspace_indexing_state();
     }
     last_applied_indexing_signature = indexing_affecting_signature(settings);
+    gitignore_watch_directories = create_gitignore_matcher(folder_paths, settings.workspace.respectGitignore).watch_directories;
+    refresh_gitignore_watchers().catch((error) => {
+      connection.console.log(`[indexer] Gitignore watcher registration failed: ` + error_message(error));
+    });
     configure_completion_provider(settings);
     apply_cache_capacities(settings);
     if (workspace_indexer) {
@@ -73117,8 +73858,13 @@ async function create_server(options) {
       workspace_indexer.set_max_indexed_files(settings.cross_file?.max_indexed_files ?? 1000);
     }
     const indexing_enabled = settings.indexWorkspace !== false && settings.cross_file?.index_workspace !== false;
-    if (indexing_enabled && workspace_indexer && folder_paths.length > 0) {
+    if (workspace_indexer && folder_paths.length > 0) {
+      if (!indexing_enabled) {
+        workspace_indexer.set_help_search_paths(discover_stata_ado_paths());
+      }
       workspace_indexer.initialize(folder_paths, settings.adoPaths || []).then(() => {
+        if (my_indexing_seq !== workspace_indexing_seq || shutdown_requested)
+          return;
         resolve_sthlp_handler?.clear_negative_cache();
         if (dependency_graph?.is_scan_complete()) {
           revalidate_all_open_docs();
@@ -73160,7 +73906,7 @@ async function create_server(options) {
       global_settings = build_non_capability_settings();
     }
     const settings = await get_document_settings("");
-    const indexing_changed = indexing_affecting_signature(settings) !== last_applied_indexing_signature;
+    const indexing_changed = gitignore_refresh_pending || indexing_affecting_signature(settings) !== last_applied_indexing_signature;
     if (indexing_changed) {
       configure_workspace_indexing(settings, active_workspace_roots, true);
     } else {
@@ -73415,14 +74161,14 @@ ${scope_resolver.get_reverse_deps_debug_info()}`);
           return open_doc.getText();
         }
         const fs_path = URI.parse(uri).fsPath;
-        return fs14.promises.readFile(fs_path, "utf8");
+        return fs15.promises.readFile(fs_path, "utf8");
       },
       exists: async (uri) => {
         if (documents.get(uri))
           return true;
         const fs_path = URI.parse(uri).fsPath;
         try {
-          await fs14.promises.access(fs_path);
+          await fs15.promises.access(fs_path);
           return true;
         } catch {
           return false;
@@ -73504,7 +74250,7 @@ ${scope_resolver.get_reverse_deps_debug_info()}`);
   }));
   function apply_runtime_settings_change(settings) {
     const new_signature = indexing_affecting_signature(settings);
-    if (new_signature !== last_applied_indexing_signature) {
+    if (gitignore_refresh_pending || new_signature !== last_applied_indexing_signature) {
       configure_workspace_indexing(settings, active_workspace_roots, true);
     } else {
       configure_completion_provider(settings);
@@ -73580,6 +74326,9 @@ ${scope_resolver.get_reverse_deps_debug_info()}`);
     }
     if (dependency_graph) {
       const affected_callees = new Set(dependency_graph.get_callees(e.document.uri));
+      if (workspace_indexer?.is_gitignored(URI.parse(e.document.uri).fsPath)) {
+        dependency_graph.remove_caller(e.document.uri);
+      }
       if (affected_callees.size > 0) {
         invalidate_and_revalidate_callees(affected_callees);
       }
@@ -73601,7 +74350,7 @@ ${scope_resolver.get_reverse_deps_debug_info()}`);
     }
   }, async () => {
     await reload_project_config_from_active_root();
-  }));
+  }, on_gitignore_changed));
   connection.onNotification(DIAGNOSTIC_RESOURCES_CHANGED_NOTIFICATION, (params) => {
     const next = diagnostic_uris_from_notification(params);
     if (next !== undefined) {
@@ -73636,6 +74385,9 @@ ${scope_resolver.get_reverse_deps_debug_info()}`);
   });
   connection.onShutdown(() => {
     shutdown_requested = true;
+    gitignore_watch_seq++;
+    workspace_indexing_seq++;
+    gitignore_watch_registration?.dispose();
     return shutdown_handler();
   });
   connection.onExit(create_exit_handler());
@@ -73673,6 +74425,7 @@ var init_server_factory = __esm(() => {
   init_file_path_utils();
   init_dependency_graph();
   init_esm();
+  init_gitignore_matcher();
   init_stata_install_paths();
   init_diagnostic_resources();
   init_v18();
@@ -73869,4 +74622,4 @@ export {
   is_cli_entry_point
 };
 
-//# debugId=A1706D274D80E2DC64756E2164756E21
+//# debugId=7D74EF27B76852CD64756E2164756E21