@jbearak/sight 0.13.0 → 0.14.0

package/dist/sight-server.js

@@ -52,7 +52,7 @@ var package_default;
 var init_package = __esm(() => {
   package_default = {
     name: "@jbearak/sight",
-    version: "0.13.0",
+    version: "0.14.0",
     type: "module",
     workspaces: [
       "client"
@@ -20708,6 +20708,19 @@ async function with_parse_timeout(operation, timeout_ms = PARSE_TIMEOUT_MS) {
 }
 var PARSE_TIMEOUT_MS = 5000;
 
+// src/utils/polling-cancellation-token.ts
+function polling_cancellation_token(should_continue, parent) {
+  return {
+    get isCancellationRequested() {
+      return parent?.isCancellationRequested === true || !should_continue();
+    },
+    onCancellationRequested: no_op_cancellation_event
+  };
+}
+var no_op_cancellation_event = () => ({ dispose: () => {
+  return;
+} });
+
 // src/document-store.ts
 import * as fs4 from "fs";
 import * as path4 from "path";
@@ -20775,7 +20788,7 @@ class DocumentStore {
       throw new Error("DocumentStore has been disposed");
     }
   }
-  async open(uri, content, version, workspace_symbols, scope_resolver_config) {
+  async open(uri, content, version, workspace_symbols, scope_resolver_config, is_operation_current) {
     this.check_disposed();
     const generation = (this.generations.get(uri) ?? 0) + 1;
     this.generations.set(uri, generation);
@@ -20790,9 +20803,15 @@ class DocumentStore {
       if (this.disposed) {
         return;
       }
+      if (is_operation_current && !is_operation_current()) {
+        return;
+      }
       this.evict_if_needed(content.length);
-      const outcome = await this.create_document_state(uri, content, version, workspace_symbols, scope_resolver_config);
-      this.commit_state(uri, outcome, generation);
+      const outcome = await this.create_document_state(uri, content, version, workspace_symbols, scope_resolver_config, is_operation_current);
+      if (!outcome) {
+        return;
+      }
+      this.commit_state(uri, outcome, generation, is_operation_current);
     };
     const promise = operation();
     this.active_updates.set(uri, promise);
@@ -20805,7 +20824,7 @@ class DocumentStore {
       this.decrement_in_flight(uri);
     }
   }
-  async update(uri, changes, version, workspace_symbols, scope_resolver_config) {
+  async update(uri, changes, version, workspace_symbols, scope_resolver_config, is_operation_current) {
     this.check_disposed();
     const generation = (this.generations.get(uri) ?? 0) + 1;
     this.generations.set(uri, generation);
@@ -20820,6 +20839,9 @@ class DocumentStore {
       if (this.disposed) {
         return;
       }
+      if (is_operation_current && !is_operation_current()) {
+        return;
+      }
       const state = this.documents.get(uri);
       if (!state) {
         return;
@@ -20840,8 +20862,11 @@ class DocumentStore {
         this.metrics.cache_hits++;
         return;
       }
-      const new_outcome = await this.create_document_state(uri, new_content, version, workspace_symbols, scope_resolver_config);
-      this.commit_state(uri, new_outcome, generation);
+      const new_outcome = await this.create_document_state(uri, new_content, version, workspace_symbols, scope_resolver_config, is_operation_current);
+      if (!new_outcome) {
+        return;
+      }
+      this.commit_state(uri, new_outcome, generation, is_operation_current);
     };
     const promise = operation();
     this.active_updates.set(uri, promise);
@@ -20884,10 +20909,13 @@ class DocumentStore {
   get_metrics() {
     return { ...this.metrics };
   }
-  commit_state(uri, outcome, generation) {
+  commit_state(uri, outcome, generation, is_operation_current) {
     if (this.disposed) {
       return false;
     }
+    if (is_operation_current && !is_operation_current()) {
+      return false;
+    }
     const closed_gen = this.closed_generations.get(uri);
     if (closed_gen !== undefined && generation <= closed_gen) {
       return false;
@@ -20932,11 +20960,11 @@ class DocumentStore {
       return;
     }
   }
-  async recover_staged_effects_with_timeout(content, uri, scope_resolver_config) {
+  async recover_staged_effects_with_timeout(content, uri, scope_resolver_config, is_operation_current) {
     try {
       const my_directive_parser = new DirectiveParser;
-      const my_result = await with_parse_timeout(() => my_directive_parser.parse(content, uri));
-      if (!my_result.success || my_result.timed_out || !my_result.result) {
+      const my_result = await with_parse_timeout(() => is_operation_current?.() === false ? null : my_directive_parser.parse(content, uri));
+      if (is_operation_current?.() === false || !my_result.success || my_result.timed_out || !my_result.result) {
         return;
       }
       return this.stage_cross_file_effects(my_result.result, scope_resolver_config);
@@ -21053,16 +21081,24 @@ class DocumentStore {
     }
     return total;
   }
-  async create_document_state(uri, content, version, workspace_symbols, scope_resolver_config) {
+  async create_document_state(uri, content, version, workspace_symbols, scope_resolver_config, is_operation_current) {
     const start_time = Date.now();
     this.metrics.parse_count++;
+    const operation_is_current = () => is_operation_current?.() !== false;
+    const cancellation_token = is_operation_current ? polling_cancellation_token(is_operation_current) : undefined;
     const lexer = new StataLexer;
     const parser = new StataParser;
     const analyzer = new SemanticAnalyzer;
     const effective_scope_resolver_config = scope_resolver_config ?? this.scope_resolver_config;
-    const lex_result = await with_parse_timeout(() => lexer.tokenize(content));
+    const lex_result = await with_parse_timeout(() => operation_is_current() ? lexer.tokenize(content) : null);
+    if (!operation_is_current() || lex_result.result === null) {
+      return;
+    }
     if (!lex_result.success || lex_result.timed_out) {
-      const recovered_staged_effects = lex_result.timed_out ? undefined : await this.recover_staged_effects_with_timeout(content, uri, effective_scope_resolver_config);
+      const recovered_staged_effects = lex_result.timed_out ? undefined : await this.recover_staged_effects_with_timeout(content, uri, effective_scope_resolver_config, is_operation_current);
+      if (!operation_is_current()) {
+        return;
+      }
       return {
         state: this.create_error_state(uri, content, version, lex_result.error || "Lexer timeout", lex_result.result?.line_offsets),
         staged_effects: recovered_staged_effects
@@ -21072,7 +21108,10 @@ class DocumentStore {
     my_context_tracker.initialize_from_tokens(lex_result.result.tokens, content);
     const context_ranges = my_context_tracker.get_all_context_ranges();
     this.assert_ranges_sorted(context_ranges);
-    const parse_result = await with_parse_timeout(() => parser.parse(lex_result.result.tokens, my_context_tracker));
+    const parse_result = await with_parse_timeout(() => operation_is_current() ? parser.parse(lex_result.result.tokens, my_context_tracker) : null);
+    if (!operation_is_current() || parse_result.result === null) {
+      return;
+    }
     if (!parse_result.success || parse_result.timed_out) {
       const recovered_staged_effects = this.recover_staged_effects_from_tokens(content, uri, lex_result.result.tokens, effective_scope_resolver_config);
       return {
@@ -21090,16 +21129,22 @@ class DocumentStore {
         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, undefined, { register_dependencies: false });
+          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;
           }
         } catch {}
       }
     } catch {}
-    const analyze_result = await with_parse_timeout(() => analyzer.analyze(parse_result.result.ast, uri, workspace_symbols, {
+    if (!operation_is_current()) {
+      return;
+    }
+    const analyze_result = await with_parse_timeout(() => operation_is_current() ? analyzer.analyze(parse_result.result.ast, uri, workspace_symbols, {
       working_directory: resolved_working_directory
-    }, lex_result.result.tokens));
+    }, lex_result.result.tokens) : null);
+    if (!operation_is_current() || analyze_result.result === null) {
+      return;
+    }
     const elapsed_ms = Date.now() - start_time;
     this.metrics.parse_total_ms += elapsed_ms;
     if (!analyze_result.success || analyze_result.timed_out) {
@@ -23089,22 +23134,23 @@ class ScopeResolver {
       used_auto_parents: has_auto_parents
     } = this.get_effective_backward_directives(file_uri, my_directives, my_config, is_standalone);
     const scan_complete_at_resolve_time = this.dependency_graph?.is_scan_complete();
+    const cancelled_scope = () => ({
+      chain: the_chain,
+      symbols: create_empty_symbol_table(),
+      out_of_scope_symbols: the_out_of_scope,
+      diagnostics: [],
+      has_directives,
+      has_auto_parents,
+      is_standalone,
+      scan_complete_at_resolve_time
+    });
     const normalized_directives = this.normalize_directives(effective_directives, the_diagnostics);
     if (options?.register_dependencies ?? true) {
       this.apply_normalized_backward_directives(file_uri, normalized_directives);
     }
     const directive_result = await this.follow_directives(normalized_directives, file_uri, visited, the_chain, the_diagnostics, the_out_of_scope, 1, my_config, request_cache, token);
     if (token?.isCancellationRequested) {
-      return {
-        chain: the_chain,
-        symbols: create_empty_symbol_table(),
-        out_of_scope_symbols: the_out_of_scope,
-        diagnostics: [],
-        has_directives,
-        has_auto_parents,
-        is_standalone,
-        scan_complete_at_resolve_time
-      };
+      return cancelled_scope();
     }
     const merged_symbols = this.merge_chain(the_chain);
     let own_working_directory;
@@ -23138,6 +23184,9 @@ class ScopeResolver {
           max_depth: my_config.diagnostics?.max_depth
         }
       });
+      if (token?.isCancellationRequested) {
+        return cancelled_scope();
+      }
       if (forward_result.call_sites.length > 0) {
         forward_call_symbols = forward_result.call_sites;
       }
@@ -29087,49 +29136,83 @@ var init_literal_macro_adjacency_diagnostics = __esm(() => {
 
 // src/providers/diagnostics-publish-gate.ts
 class DiagnosticsPublishGate {
-  last_published_version = new Map;
-  last_published_epoch = new Map;
-  current_epoch = new Map;
-  get_current_epoch(uri) {
-    return this.current_epoch.get(uri) ?? 0;
-  }
-  would_publish(uri, version, epoch) {
-    const my_last_version = this.last_published_version.get(uri);
-    if (my_last_version === undefined || version > my_last_version) {
-      return true;
+  lifecycle_by_uri = new Map;
+  next_lifecycle_epoch = 0;
+  begin_lifecycle(uri, version) {
+    const state = {
+      lifecycle_epoch: this.next_lifecycle_epoch++,
+      document_version: version,
+      force_epoch: 0
+    };
+    this.lifecycle_by_uri.set(uri, state);
+    return this.trigger_from(state);
+  }
+  trigger_for_validation(uri, version) {
+    const state = this.lifecycle_by_uri.get(uri);
+    if (!state) {
+      return;
     }
-    if (version < my_last_version) {
-      return false;
+    if (version > state.document_version) {
+      state.document_version = version;
     }
-    const my_current_epoch = this.current_epoch.get(uri) ?? 0;
-    const my_last_epoch = this.last_published_epoch.get(uri) ?? 0;
-    return epoch === my_current_epoch && epoch > my_last_epoch;
+    return {
+      lifecycle_epoch: state.lifecycle_epoch,
+      document_version: version,
+      force_epoch: state.force_epoch
+    };
+  }
+  is_current_trigger(uri, trigger) {
+    return !!trigger && !!this.state_for_trigger(uri, trigger);
   }
-  try_consume_publish(uri, version, epoch) {
-    const my_last_version = this.last_published_version.get(uri);
-    if (my_last_version === undefined || version > my_last_version) {
-      this.last_published_version.set(uri, version);
-      this.last_published_epoch.set(uri, epoch);
+  would_publish(uri, version, trigger) {
+    const state = this.state_for_trigger(uri, trigger);
+    if (!state || version !== trigger.document_version) {
+      return false;
+    }
+    if (state.last_published_version === undefined || version > state.last_published_version) {
       return true;
     }
-    if (version < my_last_version) {
+    if (version < state.last_published_version) {
       return false;
     }
-    const my_current_epoch = this.current_epoch.get(uri) ?? 0;
-    const my_last_epoch = this.last_published_epoch.get(uri) ?? 0;
-    if (epoch === my_current_epoch && epoch > my_last_epoch) {
-      this.last_published_epoch.set(uri, epoch);
-      return true;
+    return trigger.force_epoch > (state.last_published_force_epoch ?? -1);
+  }
+  try_consume_publish(uri, version, trigger) {
+    if (!this.would_publish(uri, version, trigger)) {
+      return false;
     }
-    return false;
+    const state = this.lifecycle_by_uri.get(uri);
+    state.last_published_version = version;
+    state.last_published_force_epoch = trigger.force_epoch;
+    return true;
   }
   mark_force_republish(uri) {
-    this.current_epoch.set(uri, (this.current_epoch.get(uri) ?? 0) + 1);
+    const state = this.lifecycle_by_uri.get(uri);
+    if (!state) {
+      return false;
+    }
+    state.force_epoch++;
+    return true;
+  }
+  retire_lifecycle(uri) {
+    this.lifecycle_by_uri.delete(uri);
+  }
+  retire_all_lifecycles() {
+    this.lifecycle_by_uri.clear();
+  }
+  trigger_from(state) {
+    return {
+      lifecycle_epoch: state.lifecycle_epoch,
+      document_version: state.document_version,
+      force_epoch: state.force_epoch
+    };
   }
-  forget(uri) {
-    this.last_published_version.delete(uri);
-    this.last_published_epoch.delete(uri);
-    this.current_epoch.delete(uri);
+  state_for_trigger(uri, trigger) {
+    const state = this.lifecycle_by_uri.get(uri);
+    if (!state || state.lifecycle_epoch !== trigger.lifecycle_epoch || state.document_version !== trigger.document_version || state.force_epoch !== trigger.force_epoch) {
+      return;
+    }
+    return state;
   }
 }
 
@@ -29167,6 +29250,7 @@ class DiagnosticsProvider {
   dependency_graph;
   publish_gate = new DiagnosticsPublishGate;
   filtered_cache = new Map;
+  cache_generation = 0;
   constructor(connection, debounce_manager) {
     this.connection = connection;
     this.debounce_manager = debounce_manager || null;
@@ -29182,25 +29266,41 @@ class DiagnosticsProvider {
   set_debounce_manager(debounce_manager) {
     this.debounce_manager = debounce_manager;
   }
+  on_document_opened(uri, version) {
+    this.publish_gate.begin_lifecycle(uri, version);
+    this.clear_cache_for_document(uri);
+  }
+  trigger_for_validation(uri, version) {
+    return this.publish_gate.trigger_for_validation(uri, version);
+  }
+  is_validation_current(uri, trigger) {
+    return this.publish_gate.is_current_trigger(uri, trigger);
+  }
   mark_force_republish(uri) {
     this.publish_gate.mark_force_republish(uri);
-    this.filtered_cache.delete(uri);
+    this.clear_cache_for_document(uri);
   }
-  async publish_diagnostics(document, config, workspace_symbols, scope_resolver, cancellation_token) {
-    const my_epoch = this.publish_gate.get_current_epoch(document.uri);
-    if (!this.publish_gate.would_publish(document.uri, document.version, my_epoch)) {
+  async publish_diagnostics(document, config, diagnostics_trigger, workspace_symbols, scope_resolver, cancellation_token) {
+    if (!this.publish_gate.would_publish(document.uri, document.version, diagnostics_trigger)) {
+      return { diagnostics: [], pending: false };
+    }
+    const computation_token = polling_cancellation_token(() => this.publish_gate.is_current_trigger(document.uri, diagnostics_trigger), cancellation_token);
+    if (computation_token.isCancellationRequested) {
       return { diagnostics: [], pending: false };
     }
     if (!config?.diagnostics?.enabled) {
-      if (!this.publish_gate.try_consume_publish(document.uri, document.version, my_epoch)) {
+      if (!this.publish_gate.try_consume_publish(document.uri, document.version, diagnostics_trigger)) {
         return { diagnostics: [], pending: false };
       }
       this.clear_diagnostics(document.uri);
       return { diagnostics: [], pending: false };
     }
     const is_pending = this.debounce_manager?.is_pending(document.uri) ?? false;
-    const the_diagnostics = await this.get_diagnostics(document, config, workspace_symbols, scope_resolver, cancellation_token);
-    if (!this.publish_gate.try_consume_publish(document.uri, document.version, my_epoch)) {
+    const the_diagnostics = await this.get_diagnostics(document, config, workspace_symbols, scope_resolver, computation_token);
+    if (computation_token.isCancellationRequested) {
+      return { diagnostics: [], pending: is_pending };
+    }
+    if (!this.publish_gate.try_consume_publish(document.uri, document.version, diagnostics_trigger)) {
       return { diagnostics: [], pending: is_pending };
     }
     this.connection.sendDiagnostics({
@@ -29210,7 +29310,10 @@ class DiagnosticsProvider {
     return { diagnostics: the_diagnostics, pending: is_pending };
   }
   async get_diagnostics(document, config, workspace_symbols, scope_resolver, cancellation_token) {
-    const cache_epoch_at_start = this.publish_gate.get_current_epoch(document.uri);
+    if (cancellation_token?.isCancellationRequested) {
+      return [];
+    }
+    const cache_generation_at_start = this.cache_generation;
     const config_hash = this.compute_config_hash(config);
     const uri_cache = this.filtered_cache.get(document.uri);
     const inner_key = `${document.version}:${config_hash}`;
@@ -29241,6 +29344,9 @@ class DiagnosticsProvider {
     }
     const my_resolve_config = scope_resolver_config_for(config);
     const resolved_scope = scope_resolver ? await scope_resolver.resolve(document.uri, document.content, my_resolve_config, cancellation_token) : undefined;
+    if (cancellation_token?.isCancellationRequested) {
+      return [];
+    }
     const backward_dep_mode = config.cross_file?.backward_dependencies ?? "auto";
     const scan_complete_for_deferral = resolved_scope?.scan_complete_at_resolve_time ?? false;
     const defer_undefined_diagnostics = backward_dep_mode === "auto" && this.dependency_graph && !scan_complete_for_deferral && resolved_scope && !resolved_scope.has_directives && !resolved_scope.has_auto_parents && !resolved_scope.is_standalone;
@@ -29404,7 +29510,7 @@ class DiagnosticsProvider {
         }
       }
     }
-    if (this.publish_gate.get_current_epoch(document.uri) === cache_epoch_at_start) {
+    if (this.cache_generation === cache_generation_at_start) {
       let cache_for_uri = this.filtered_cache.get(document.uri);
       if (!cache_for_uri) {
         cache_for_uri = new Map;
@@ -29486,12 +29592,21 @@ class DiagnosticsProvider {
   }
   clear_cache_for_document(uri) {
     this.filtered_cache.delete(uri);
+    this.cache_generation++;
   }
-  on_document_closed(uri) {
-    this.publish_gate.forget(uri);
+  on_document_hidden(uri) {
+    this.publish_gate.retire_lifecycle(uri);
     this.clear_cache_for_document(uri);
     this.clear_diagnostics(uri);
   }
+  on_document_closed(uri) {
+    this.on_document_hidden(uri);
+  }
+  on_shutdown() {
+    this.publish_gate.retire_all_lifecycles();
+    this.filtered_cache.clear();
+    this.cache_generation++;
+  }
   convert_lexer_error(error, config) {
     let severity;
     switch (error.code) {
@@ -33298,6 +33413,7 @@ function create_range_formatting_handler(deps) {
 }
 function create_shutdown_handler(deps, disposables) {
   return async () => {
+    deps?.diagnostics_provider?.on_shutdown();
     deps?.workspace_indexer?.cancel();
     if (disposables?.pending_revalidations) {
       for (const my_token of disposables.pending_revalidations.values()) {
@@ -41519,6 +41635,64 @@ var init_file_rename_handler = __esm(() => {
   init_esm();
 });
 
+// src/diagnostic-resources.ts
+function as_record(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value) ? value : undefined;
+}
+function parse_diagnostic_uri_set(value) {
+  if (!Array.isArray(value)) {
+    return;
+  }
+  const uris = new Set;
+  for (const candidate of value) {
+    if (typeof candidate !== "string") {
+      continue;
+    }
+    try {
+      const parsed = URI.parse(candidate, true);
+      if (parsed.scheme !== "") {
+        uris.add(parsed.toString());
+      }
+    } catch {}
+  }
+  return uris;
+}
+function diagnostic_uris_from_initialization_options(options) {
+  return parse_diagnostic_uri_set(as_record(options)?.["diagnosticUris"]);
+}
+function diagnostic_uris_from_notification(params) {
+  return parse_diagnostic_uri_set(as_record(params)?.["diagnosticUris"]);
+}
+function same_diagnostic_uri_set(current, next) {
+  if (current === undefined || current.size !== next.size) {
+    return false;
+  }
+  for (const uri of current) {
+    if (!next.has(uri)) {
+      return false;
+    }
+  }
+  return true;
+}
+function diagnostic_uri_set_changes(current, next) {
+  const removed = [...current].filter((uri) => !next.has(uri));
+  const added = [...next].filter((uri) => !current.has(uri));
+  return { added, removed };
+}
+function settings_initialization_options(options) {
+  const record = as_record(options);
+  if (!record || !("diagnosticUris" in record) || "sight" in record) {
+    return options;
+  }
+  const settings = { ...record };
+  delete settings["diagnosticUris"];
+  return settings;
+}
+var DIAGNOSTIC_RESOURCES_CHANGED_NOTIFICATION = "sight/diagnosticResourcesChanged";
+var init_diagnostic_resources = __esm(() => {
+  init_esm();
+});
+
 // src/command-database/caches/v18.json
 var v18_default;
 var init_v18 = __esm(() => {
@@ -72242,11 +72416,48 @@ async function create_server(options) {
   let last_applied_indexing_signature = "";
   let config_change_seq = 0;
   let init_options_config = undefined;
+  let editor_diagnostic_uris = undefined;
+  let shutdown_requested = false;
   let last_client_settings = undefined;
   let init_root_uri = null;
   const log_config_warning = (message) => {
     connection.console.log(`Configuration warning: ${message}`);
   };
+  function diagnostics_publish_allowed(uri) {
+    return editor_diagnostic_uris?.has(uri) ?? true;
+  }
+  function update_editor_diagnostic_uris(next) {
+    if (same_diagnostic_uri_set(editor_diagnostic_uris, next)) {
+      return;
+    }
+    const previous = editor_diagnostic_uris;
+    editor_diagnostic_uris = next;
+    if (!diagnostics_provider) {
+      return;
+    }
+    if (previous === undefined) {
+      for (const document of documents.all()) {
+        if (!next.has(document.uri)) {
+          diagnostics_provider.on_document_hidden(document.uri);
+        }
+      }
+      return;
+    }
+    const changes = diagnostic_uri_set_changes(previous, next);
+    for (const uri of changes.removed) {
+      const document = documents.get(uri);
+      if (document) {
+        diagnostics_provider.on_document_hidden(document.uri);
+      }
+    }
+    for (const uri of changes.added) {
+      const document = documents.get(uri);
+      if (document) {
+        diagnostics_provider.on_document_opened(document.uri, document.version);
+        validate_text_document(document);
+      }
+    }
+  }
   function log_project_config_warnings(loaded) {
     for (const my_warning of loaded.warnings) {
       connection.console.log(`Project config warning: ${my_warning.message}`);
@@ -72658,15 +72869,35 @@ async function create_server(options) {
     const snapshot_uri = text_document.uri;
     const snapshot_version = text_document.version;
     const snapshot_content = text_document.getText();
+    const diagnostics_trigger = diagnostics_provider?.trigger_for_validation(snapshot_uri, snapshot_version);
+    const snapshot_is_current = () => documents.get(snapshot_uri) === text_document && text_document.version === snapshot_version;
+    const validation_work_is_current = () => {
+      if (shutdown_requested || !snapshot_is_current()) {
+        return false;
+      }
+      if (!diagnostics_provider) {
+        return true;
+      }
+      if (!diagnostics_publish_allowed(snapshot_uri)) {
+        return true;
+      }
+      return diagnostics_trigger !== undefined && diagnostics_provider.is_validation_current(snapshot_uri, diagnostics_trigger);
+    };
     debounce_manager.schedule_validation(snapshot_uri, snapshot_version, async () => {
       const settings = await get_document_settings(snapshot_uri);
+      if (!validation_work_is_current()) {
+        return;
+      }
       const is_debug = settings.debug === true;
       const my_scope_resolver_config = scope_resolver_config_for(settings);
       const workspace_symbols = workspace_indexer ? workspace_indexer.get_all_symbols() : undefined;
       if (document_store.get(snapshot_uri)) {
-        await document_store.update(snapshot_uri, [{ text: snapshot_content }], snapshot_version, workspace_symbols, my_scope_resolver_config);
+        await document_store.update(snapshot_uri, [{ text: snapshot_content }], snapshot_version, workspace_symbols, my_scope_resolver_config, validation_work_is_current);
       } else {
-        await document_store.open(snapshot_uri, snapshot_content, snapshot_version, workspace_symbols, my_scope_resolver_config);
+        await document_store.open(snapshot_uri, snapshot_content, snapshot_version, workspace_symbols, my_scope_resolver_config, validation_work_is_current);
+      }
+      if (!validation_work_is_current()) {
+        return;
       }
       if (scope_resolver) {
         const document_state2 = document_store.get(snapshot_uri);
@@ -72725,14 +72956,20 @@ ${scope_resolver.get_reverse_deps_debug_info()}`);
           }
         }
       }
+      if (!snapshot_is_current() || !diagnostics_publish_allowed(snapshot_uri)) {
+        return;
+      }
       const document_state = document_store.get(snapshot_uri);
       if (!document_state) {
         connection.sendDiagnostics({ uri: snapshot_uri, diagnostics: [] });
         return;
       }
       if (diagnostics_provider) {
+        if (!diagnostics_trigger) {
+          return;
+        }
         const diag_workspace_symbols = workspace_indexer ? workspace_indexer.get_all_symbols() : undefined;
-        const result = await diagnostics_provider.publish_diagnostics(document_state, settings, diag_workspace_symbols, scope_resolver || undefined, undefined);
+        const result = await diagnostics_provider.publish_diagnostics(document_state, settings, diagnostics_trigger, diag_workspace_symbols, scope_resolver || undefined, undefined);
         if (result.pending) {
           if (is_debug) {
             connection.console.log(`Diagnostics pending for ${snapshot_uri}`);
@@ -72753,7 +72990,8 @@ ${scope_resolver.get_reverse_deps_debug_info()}`);
   connection.onInitialize(create_initialize_handler((caps) => {
     server_capabilities = caps;
   }, (options2) => {
-    init_options_config = options2;
+    editor_diagnostic_uris = diagnostic_uris_from_initialization_options(options2);
+    init_options_config = settings_initialization_options(options2);
   }, (root_uri) => {
     init_root_uri = root_uri;
   }));
@@ -72910,6 +73148,9 @@ ${scope_resolver.get_reverse_deps_debug_info()}`);
     }
   });
   documents.onDidOpen((e) => {
+    if (diagnostics_publish_allowed(e.document.uri)) {
+      diagnostics_provider?.on_document_opened(e.document.uri, e.document.version);
+    }
     validate_text_document(e.document);
   });
   documents.onDidClose((e) => {
@@ -72977,6 +73218,12 @@ ${scope_resolver.get_reverse_deps_debug_info()}`);
   }, async () => {
     await reload_project_config_from_active_root();
   }));
+  connection.onNotification(DIAGNOSTIC_RESOURCES_CHANGED_NOTIFICATION, (params) => {
+    const next = diagnostic_uris_from_notification(params);
+    if (next !== undefined) {
+      update_editor_diagnostic_uris(next);
+    }
+  });
   const completion_handler = create_completion_handler(handler_deps);
   const hover_handler = create_hover_handler(handler_deps);
   const definition_handler = create_definition_handler(handler_deps);
@@ -73003,7 +73250,10 @@ ${scope_resolver.get_reverse_deps_debug_info()}`);
   connection.onExecuteCommand((params) => {
     return execute_command_handler(params.command, params.arguments || []);
   });
-  connection.onShutdown(shutdown_handler);
+  connection.onShutdown(() => {
+    shutdown_requested = true;
+    return shutdown_handler();
+  });
   connection.onExit(create_exit_handler());
   connection.onRequest("sight/getWorkingDirectory", working_directory_handler);
   const shared_ihlp = create_shared_ihlp_resolver(handler_deps);
@@ -73040,6 +73290,7 @@ var init_server_factory = __esm(() => {
   init_dependency_graph();
   init_esm();
   init_stata_install_paths();
+  init_diagnostic_resources();
   init_v18();
   init_server_handlers();
   import_node8 = __toESM(require_main4(), 1);
@@ -73234,4 +73485,4 @@ export {
   is_cli_entry_point
 };
 
-//# debugId=DFA4590C23722F1564756E2164756E21
+//# debugId=5DA4F84D00AA02FC64756E2164756E21

package/dist/sight-server.js.sha256

@@ -1 +1 @@
-8765da4c18f5a23b7c4bfb2890164f0011fa1a4caf26a450fa23ce1b1b28b740  sight-server.js
+550cbf16dacdd7a66b3afb514a0d4919c3ef1d827588e2a0478cfaa85af096e0  sight-server.js

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jbearak/sight",
-  "version": "0.13.0",
+  "version": "0.14.0",
   "type": "module",
   "workspaces": [
     "client"