@mrclrchtr/supi-code-intelligence 6.4.0 → 7.0.1

package/node_modules/@mrclrchtr/supi-lsp/src/client/client.ts

@@ -45,14 +45,31 @@ import { raceRequestControl } from "../session/readiness.ts";
 import {
   ClientDynamicRegistrations,
   DOCUMENT_DIAGNOSTIC_METHOD,
+  isDocumentSelectorApplicable,
   isValidDiagnosticOptions,
 } from "./client-diagnostic-capabilities.ts";
+import type {
+  DiagnosticPullRequest,
+  DiagnosticRequestAdapter,
+  DiagnosticRequestExecution,
+} from "./client-diagnostic-request.ts";
+import { createPriorityDiagnosticRequestAdapter } from "./client-diagnostic-request.ts";
+import { createTypeScriptDiagnosticRequestAdapter } from "./client-diagnostic-typescript.ts";
 import { ClientDiagnostics } from "./client-diagnostics.ts";
 import type { ClientDiagnosticSnapshot, DiagnosticEntry } from "./client-document-state.ts";
+import { SemanticInputRequestRetryGuard } from "./client-request-enrollment.ts";
+import {
+  isSemanticInputEnrollmentError,
+  SemanticInputSynchronizationError,
+} from "./client-semantic-input-errors.ts";
 import { JsonRpcClient, JsonRpcRequestError } from "./transport.ts";
 
 const SHUTDOWN_TIMEOUT_MS = 5_000;
 
+interface SemanticRequestAttemptState {
+  inputRevision: number | undefined;
+}
+
 /**
  * Fixed bound after which a running client that never became ready is
  * considered readiness-stalled and eligible for a recovery restart.
@@ -176,6 +193,7 @@ export class LspClient {
   private rpc: JsonRpcClient | null = null;
   private _status: ClientStatus = "initializing";
   private capabilities: ServerCapabilities | null = null;
+  private readonly diagnosticRequestAdapter: DiagnosticRequestAdapter;
   private readonly diagnostics: ClientDiagnostics;
   /** Dynamic capability registrations for this client instance only. */
   private readonly dynamicRegistrations = new ClientDynamicRegistrations();
@@ -205,36 +223,41 @@ export class LspClient {
   ) {
     this.name = name;
     this.root = root;
+    const nativeDiagnosticAdapter: DiagnosticRequestAdapter = {
+      supports: (uri) => this.hasApplicableDiagnosticProvider(uri),
+      sourceFor: (uri) => (this.hasApplicableDiagnosticProvider(uri) ? "pull" : undefined),
+      collect: (request) => this.startNativeDiagnosticRequest(request),
+    };
+    const typescriptDiagnosticAdapter = createTypeScriptDiagnosticRequestAdapter({
+      fileTypes: config.fileTypes,
+      cwd: cwd ?? root,
+      isSupportedRoute: () => this.isSupportedTypeScriptRoute(),
+      hasCommand: () => this.hasTypeScriptRequestCommand(),
+      getReady: () => this.getReady(),
+      sendRequestOwned: (method, params, options) => {
+        const rpc = this.rpc;
+        if (!rpc || this._status !== "running") {
+          return {
+            result: Promise.reject(new Error("client not running")),
+            settled: Promise.resolve(),
+          };
+        }
+        return rpc.sendRequestOwned(method, params, options);
+      },
+    });
+    this.diagnosticRequestAdapter = createPriorityDiagnosticRequestAdapter([
+      nativeDiagnosticAdapter,
+      typescriptDiagnosticAdapter,
+    ]);
     this.diagnostics = new ClientDiagnostics({
       server: name,
       cwd: cwd,
       isOperational: () => this.rpc !== null && this._status === "running",
-      supportsPullDiagnostics: () => this.hasDiagnosticProvider,
+      diagnosticRequestAdapter: this.diagnosticRequestAdapter,
       usesIncrementalDocumentSync: () => this.usesIncrementalDocumentSync,
       sendNotification: (method, params) => {
         if (this.rpc) void this.rpc.sendNotification(method, params);
       },
-      pullDocumentDiagnostics: async (request) => {
-        const rpc = this.rpc;
-        if (!rpc || this._status !== "running") throw new Error("client not running");
-        await this.getReady({
-          signal: request.signal,
-          deadline: request.deadline,
-        });
-        return rpc.sendRequest(
-          DOCUMENT_DIAGNOSTIC_METHOD,
-          {
-            textDocument: { uri: request.uri },
-            previousResultId: request.previousResultId,
-          },
-          {
-            timeoutMs: request.timeoutMs,
-            signal: request.signal,
-            deadline: request.deadline,
-            operationId: request.operationId,
-          },
-        ) as Promise<DocumentDiagnosticReport>;
-      },
     });
   }
 
@@ -552,18 +575,108 @@ export class LspClient {
     this.diagnostics.clearPullResultIds();
   }
 
-  /** Check if server supports pull diagnostics. */
+  /** Check if the server advertises a valid native pull provider. */
   get hasDiagnosticProvider(): boolean {
-    // Static state: a valid `diagnosticProvider` in the initialize result.
-    // Dynamic state: an active registration for the diagnostic method. A
-    // malformed static shape or an empty dynamic set fails closed, so an
-    // unsupported server never gets pull requests.
     return (
       isValidDiagnosticOptions(this.capabilities?.diagnosticProvider) ||
       this.dynamicRegistrations.has(DOCUMENT_DIAGNOSTIC_METHOD)
     );
   }
 
+  /** Whether this route has either native pull or the tested TypeScript adapter. */
+  get hasDiagnosticRequestAdapter(): boolean {
+    return this.hasDiagnosticProvider || this.isSupportedTypeScriptRouteAndCommand();
+  }
+
+  /** Select a native provider that applies to one document. */
+  private getDiagnosticProviderOptions(uri: string): Record<string, unknown> | undefined {
+    const staticOptions = this.capabilities?.diagnosticProvider;
+    const staticRecord = staticOptions as Record<string, unknown> | undefined;
+    if (
+      staticRecord !== undefined &&
+      isValidDiagnosticOptions(staticRecord) &&
+      isDocumentSelectorApplicable(staticRecord.documentSelector, uri)
+    ) {
+      return staticRecord;
+    }
+    for (const registration of this.dynamicRegistrations.get(DOCUMENT_DIAGNOSTIC_METHOD)) {
+      if (isDocumentSelectorApplicable(registration.options.documentSelector, uri)) {
+        return registration.options;
+      }
+    }
+    return undefined;
+  }
+
+  private hasApplicableDiagnosticProvider(uri: string): boolean {
+    return this.getDiagnosticProviderOptions(uri) !== undefined;
+  }
+
+  private isSupportedTypeScriptRoute(): boolean {
+    const command = path.basename(this.config.command).replace(/\.(?:cmd|exe)$/i, "");
+    return command === "typescript-language-server";
+  }
+
+  private isSupportedTypeScriptRouteAndCommand(): boolean {
+    return (
+      this.isSupportedTypeScriptRoute() &&
+      Array.isArray(this.capabilities?.executeCommandProvider?.commands) &&
+      this.capabilities.executeCommandProvider.commands.includes("typescript.tsserverRequest")
+    );
+  }
+
+  private hasTypeScriptRequestCommand(): boolean {
+    return this.isSupportedTypeScriptRouteAndCommand();
+  }
+
+  /** Start one native pull request without transferring caller ownership. */
+  private startNativeDiagnosticRequest(request: DiagnosticPullRequest): DiagnosticRequestExecution<{
+    source: "pull";
+    report: DocumentDiagnosticReport;
+  }> {
+    let activeSettled = Promise.resolve();
+    const result = (async () => {
+      const ownerDeadline = Number.isFinite(request.timeoutMs)
+        ? Date.now() + request.timeoutMs
+        : undefined;
+      await raceRequestControl(this.getReady(), {
+        signal: request.signal,
+        deadline: ownerDeadline,
+      });
+      const rpc = this.rpc;
+      if (!rpc || this._status !== "running") throw new Error("client not running");
+      const provider = this.getDiagnosticProviderOptions(request.uri);
+      if (!provider) throw new Error("No native diagnostic provider applies to this document.");
+      const owned = rpc.sendRequestOwned(
+        DOCUMENT_DIAGNOSTIC_METHOD,
+        {
+          textDocument: { uri: request.uri },
+          previousResultId: request.previousResultId,
+          ...(typeof provider.identifier === "string" ? { identifier: provider.identifier } : {}),
+        },
+        {
+          timeoutMs: request.timeoutMs,
+          deadline: ownerDeadline,
+          ...(request.operationId !== undefined ? { operationId: request.operationId } : {}),
+        },
+      );
+      activeSettled = owned.settled;
+      const report = (await raceRequestControl(owned.result, {
+        signal: request.signal,
+        deadline: ownerDeadline,
+      })) as DocumentDiagnosticReport;
+      return { source: "pull" as const, report };
+    })();
+    const settled = result
+      .then(
+        () => activeSettled,
+        () => activeSettled,
+      )
+      .then(() => undefined);
+    result.catch(() => {});
+    settled.catch(() => {});
+    return { result, settled };
+  }
+
   /** Notify the server that watched workspace files changed. */
   notifyWorkspaceFileChanges(changes: FileEvent[]): void {
     if (!this.rpc || this._status !== "running" || changes.length === 0) return;
@@ -580,13 +693,18 @@ export class LspClient {
     return this.diagnostics.refreshOpenDiagnostics(options);
   }
 
-  /** Sync one file and return diagnostics with explicit evidence availability. */
+  /**
+   * Sync one file and return diagnostics with explicit evidence availability.
+   * The manager disables content authority so this barrier can detect a disk
+   * deletion between the manager read and the client request.
+   */
   async syncAndWaitForDiagnostics(
     filePath: string,
     content: string,
     control?: CodeRequestControl,
+    options: { contentIsAuthoritative?: boolean } = {},
   ): Promise<CodeQueryResult<Diagnostic[]>> {
-    return this.diagnostics.syncAndWaitForDiagnostics(filePath, content, control);
+    return this.diagnostics.syncAndWaitForDiagnostics(filePath, content, control, options);
   }
 
   // ── LSP Requests ───────────────────────────────────────────────────
@@ -707,9 +825,7 @@ export class LspClient {
       );
     }
     try {
-      await this.getReady(control);
-      const data = (await this.rpc.sendRequest(method, params, control)) as T | null | undefined;
-      return completedCodeQuery(data ?? null);
+      return await this.queryWithEnrollmentRetry(method, params, control);
     } catch (error) {
       // Cancellation and absolute-deadline expiry propagate as interruptions:
       // the caller no longer awaits a result, so no unavailable outcome may
@@ -720,6 +836,125 @@ export class LspClient {
     }
   }
 
+  private async queryWithEnrollmentRetry<T>(
+    method: string,
+    params: unknown,
+    control?: CodeRequestControl,
+  ): Promise<CodeQueryResult<T | null>> {
+    const retryGuard = new SemanticInputRequestRetryGuard((revision) =>
+      this.diagnostics.getSemanticInputChangeSince(revision),
+    );
+    for (;;) {
+      const attempt: SemanticRequestAttemptState = { inputRevision: undefined };
+      try {
+        const data = await this.runSemanticRequestAttempt<T>({
+          method,
+          params,
+          control,
+          retryGuard,
+          attempt,
+        });
+        if (retryGuard.hasRetried) {
+          this.recordSemanticRetry({ method, control, retryGuard, outcome: "completed" });
+        }
+        return completedCodeQuery(data);
+      } catch (error) {
+        this.prepareSemanticRetry({ method, control, retryGuard, attempt, error });
+      }
+    }
+  }
+
+  /** Return only when another attempt is permitted; retain the cause when retry stops. */
+  private prepareSemanticRetry(options: {
+    method: string;
+    control?: CodeRequestControl;
+    retryGuard: SemanticInputRequestRetryGuard;
+    attempt: SemanticRequestAttemptState;
+    error: unknown;
+  }): void {
+    const { method, control, retryGuard, attempt, error } = options;
+    if (isCodeRequestInterruption(error, control)) {
+      if (retryGuard.hasRetried) {
+        this.recordSemanticRetry({ method, control, retryGuard, outcome: "interrupted" });
+      }
+      throwIfCodeRequestInterrupted(control);
+      throw error;
+    }
+    throwIfCodeRequestInterrupted(control);
+    const decision = retryGuard.decide(error, attempt.inputRevision);
+    if (decision.kind === "retry") {
+      throwIfCodeRequestInterrupted(control);
+      this.recordSemanticRetry({ method, control, retryGuard, outcome: "retry", error });
+      return;
+    }
+    if (retryGuard.hasRetried) {
+      const outcome = isSemanticInputEnrollmentError(decision.error) ? "exhausted" : "failed";
+      this.recordSemanticRetry({ method, control, retryGuard, outcome, error: decision.error });
+      const detail =
+        decision.error instanceof Error ? decision.error.message : String(decision.error);
+      const count = retryGuard.retryCount;
+      throw new Error(
+        `${detail} Enrollment retry ${outcome} after ${count} ${count === 1 ? "retry" : "retries"}.`,
+        {
+          cause: decision.error,
+        },
+      );
+    }
+    throw decision.error;
+  }
+
+  /** Record request acceptance separately from transport completion, without request content. */
+  private recordSemanticRetry(options: {
+    method: string;
+    control?: CodeRequestControl;
+    retryGuard: SemanticInputRequestRetryGuard;
+    outcome: "retry" | "completed" | "exhausted" | "failed" | "interrupted";
+    error?: unknown;
+  }): void {
+    recordDebugEvent({
+      source: "lsp",
+      level: "debug",
+      category: "semantic-request.enrollment-retry",
+      message: "LSP semantic request enrollment retry",
+      cwd: boundCwd(this.cwd),
+      ...(options.control?.operationId ? { operationId: options.control.operationId } : {}),
+      data: {
+        server: truncateIdentity(this.name),
+        method: truncateIdentity(options.method),
+        outcome: options.outcome,
+        retryCount: options.retryGuard.retryCount,
+        changeKind:
+          options.error instanceof SemanticInputSynchronizationError
+            ? options.error.changeKind
+            : null,
+      },
+    });
+  }
+
+  private async runSemanticRequestAttempt<T>(options: {
+    method: string;
+    params: unknown;
+    control?: CodeRequestControl;
+    retryGuard: SemanticInputRequestRetryGuard;
+    attempt: SemanticRequestAttemptState;
+  }): Promise<T | null> {
+    const { method, params, control, retryGuard, attempt } = options;
+    throwIfCodeRequestInterrupted(control);
+    retryGuard.assertCurrent();
+    await this.getReady(control);
+    const inputSnapshot = await this.diagnostics.synchronizeSemanticInputs(control);
+    attempt.inputRevision = inputSnapshot.revision;
+    throwIfCodeRequestInterrupted(control);
+    retryGuard.assertCurrent();
+    const rpc = this.rpc;
+    if (!rpc || this._status !== "running") {
+      throw new Error(`LSP request ${method} is unavailable because the client is not running.`);
+    }
+    const data = (await rpc.sendRequest(method, params, control)) as T | null | undefined;
+    await this.diagnostics.assertSemanticInputsCurrent(inputSnapshot, control);
+    return data ?? null;
+  }
+
   private async request<T>(
     method: string,
     params: unknown,
@@ -758,15 +993,15 @@ export class LspClient {
     }
   }
 
-  /** Run a server-requested refresh through the forced diagnostic path. */
+  /** Run a server-requested refresh through the diagnostic-only path. */
   private refreshForServerRequest(): Promise<DiagnosticEvidenceSummary> {
     return this.diagnostics.refreshForServerRequest();
   }
 
   private handleServerDiagnosticRefreshRequest(): null {
-    // Defer the pass before invoking it. Its setup rereads and resynchronizes
-    // tracked documents, so even an async method can otherwise delay the null
-    // response on the JSON-RPC request stack.
+    // Defer the pass before invoking it. Its setup can read and synchronize
+    // genuinely changed tracked documents, so even an async method can delay
+    // the null response on the JSON-RPC request stack.
     void Promise.resolve()
       .then(() => this.refreshForServerRequest())
       .then(
@@ -820,6 +1055,10 @@ export class LspClient {
    */
   private handleRegisterCapability(params: unknown): null {
     const registrations = readRegistrations(params, "client/registerCapability");
+    const diagnosticRegistrations: Array<{
+      id: string;
+      options: Record<string, unknown>;
+    }> = [];
     for (const registration of registrations) {
       if (registration.method !== DOCUMENT_DIAGNOSTIC_METHOD) continue;
       if (!isValidDiagnosticOptions(registration.registerOptions)) {
@@ -828,7 +1067,17 @@ export class LspClient {
           "Malformed textDocument/diagnostic registration options.",
         );
       }
-      this.dynamicRegistrations.register(registration.method, registration.id);
+      diagnosticRegistrations.push({
+        id: registration.id,
+        options: registration.registerOptions as Record<string, unknown>,
+      });
+    }
+    for (const registration of diagnosticRegistrations) {
+      this.dynamicRegistrations.register(
+        DOCUMENT_DIAGNOSTIC_METHOD,
+        registration.id,
+        registration.options,
+      );
     }
     return null;
   }
@@ -844,10 +1093,14 @@ export class LspClient {
     if (!isRecord(params) || !Array.isArray(params.unregisterations)) {
       throw new JsonRpcRequestError(-32602, "Malformed client/unregisterCapability params.");
     }
+    const unregistrations: Array<{ id: string; method: string }> = [];
     for (const entry of params.unregisterations) {
       if (!isRecord(entry) || typeof entry.id !== "string" || typeof entry.method !== "string") {
         throw new JsonRpcRequestError(-32602, "Malformed client/unregisterCapability entry.");
       }
+      unregistrations.push({ id: entry.id, method: entry.method });
+    }
+    for (const entry of unregistrations) {
       if (entry.method !== DOCUMENT_DIAGNOSTIC_METHOD) continue;
       this.dynamicRegistrations.unregister(entry.method, entry.id);
     }

package/node_modules/@mrclrchtr/supi-lsp/src/client/transport.ts

@@ -1,6 +1,7 @@
 // JSON-RPC 2.0 transport — thin wrapper around vscode-jsonrpc.
 // Handles Content-Length framing, request/response correlation, timeouts,
 // and notification/request dispatching through vscode-jsonrpc's MessageConnection.
+// biome-ignore-all lint/style/noExcessiveLinesPerFile: Transport lifetime and protocol handling stay together.
 
 import type { Readable, Writable } from "node:stream";
 import {
@@ -103,13 +104,44 @@ export class JsonRpcClient {
     this.requestHandler = handler;
   }
 
+  /**
+   * Send one request while exposing its underlying transport lifetime.
+   * Callers that time out can stop waiting on `result` and keep the route
+   * occupied until `settled` resolves.
+   */
+  sendRequestOwned(
+    method: string,
+    params?: unknown,
+    options?: { timeoutMs?: number } & CodeRequestControl,
+  ): { result: Promise<unknown>; settled: Promise<void> } {
+    let settle!: () => void;
+    const settled = new Promise<void>((resolve) => {
+      settle = resolve;
+    });
+    let result: Promise<unknown>;
+    try {
+      result = this.sendRequest(method, params, {
+        ...options,
+        onSettled: settle,
+        owned: true,
+      });
+    } catch (error) {
+      settle();
+      result = Promise.reject(error);
+    }
+    result.catch(() => {});
+    return { result, settled };
+  }
+
   /** Send a request and wait for the correlated response, optionally overriding the timeout. */
+  // biome-ignore lint/complexity/noExcessiveLinesPerFunction: Request timeout and cancellation races stay together.
   sendRequest(
     method: string,
     params?: unknown,
-    options?: { timeoutMs?: number } & CodeRequestControl,
+    options?: { timeoutMs?: number; onSettled?: () => void; owned?: boolean } & CodeRequestControl,
   ): Promise<unknown> {
     const timeoutMs = options?.timeoutMs ?? this.timeoutMs;
+    const owned = options?.owned === true;
     const signal = options?.signal;
     const deadlineMs = options?.deadline === undefined ? undefined : options.deadline - Date.now();
     const methodClass = classifyRequestMethod(method);
@@ -117,7 +149,7 @@ export class JsonRpcClient {
     const timer = startDebugTimer();
     // A request cancelled before dispatch must not produce protocol traffic.
     if (signal?.aborted) {
-      return rejectUndispatchedRequest(
+      const result = rejectUndispatchedRequest(
         signal.reason ?? new Error(`Request ${method} was cancelled`),
         {
           timer,
@@ -126,11 +158,13 @@ export class JsonRpcClient {
           identity: { server: this.server, cwd: this.cwd },
         },
       );
+      options?.onSettled?.();
+      return result;
     }
     // An expired absolute deadline must not even send the request: the caller
     // no longer awaits a result, so no protocol traffic may start.
     if (deadlineMs !== undefined && deadlineMs <= 0) {
-      return rejectUndispatchedRequest(new CodeRequestDeadlineError(), {
+      const result = rejectUndispatchedRequest(new CodeRequestDeadlineError(), {
         timer,
         operationId: options?.operationId,
         observation: {
@@ -141,18 +175,24 @@ export class JsonRpcClient {
         },
         identity: { server: this.server, cwd: this.cwd },
       });
+      options?.onSettled?.();
+      return result;
     }
     if (this.closed || !this.connection) {
-      return rejectUndispatchedRequest(new Error("JSON-RPC client is closed"), {
+      const result = rejectUndispatchedRequest(new Error("JSON-RPC client is closed"), {
         timer,
         operationId: options?.operationId,
         observation: { method: boundedMethod, methodClass, outcome: "cancelled" },
         identity: { server: this.server, cwd: this.cwd },
       });
+      options?.onSettled?.();
+      return result;
     }
     const tokenSource = new CancellationTokenSource();
     let timeout: ReturnType<typeof setTimeout> | undefined;
+    let transportTimeout: ReturnType<typeof setTimeout> | undefined;
     let timedOut = false;
+    let transportTimedOut = false;
     let aborted = false;
     const timerDelayMs = deadlineMs === undefined ? timeoutMs : Math.min(timeoutMs, deadlineMs);
     const timeoutError = Object.assign(
@@ -165,16 +205,34 @@ export class JsonRpcClient {
     // Catch the raw request promise to prevent unhandled rejections when
     // dispose() cancels the token without a preceding timeout.
     request.catch(() => {});
+    request.then(
+      () => {
+        if (transportTimeout !== undefined) clearTimeout(transportTimeout);
+        options?.onSettled?.();
+      },
+      () => {
+        if (transportTimeout !== undefined) clearTimeout(transportTimeout);
+        options?.onSettled?.();
+      },
+    );
+    if (owned) {
+      const transportTimeoutMs = Number.isFinite(timeoutMs)
+        ? Math.max(this.timeoutMs, timeoutMs)
+        : this.timeoutMs;
+      transportTimeout = setTimeout(() => {
+        transportTimedOut = true;
+        tokenSource.cancel();
+      }, transportTimeoutMs);
+    }
 
-    // Race the request against a single shared timeout that both cancels
-    // the JSON-RPC token and rejects the caller. Using one timer avoids
-    // a leak where the rejecting timer in a second Promise stays alive
-    // after a successful response.
+    // Race the request against the caller's timeout. Ordinary requests cancel
+    // the JSON-RPC token; owned requests leave it active so the route stays
+    // occupied until the raw request settles.
     let abortHandler: (() => void) | undefined;
     const abort = new Promise<never>((_resolve, reject) => {
       abortHandler = () => {
         aborted = true;
-        tokenSource.cancel();
+        if (!owned) tokenSource.cancel();
         // Reject with the caller's abort reason when one exists, matching the
         // canonical throwIfCodeRequestInterrupted() behavior.
         reject(signal?.reason ?? abortError);
@@ -187,7 +245,7 @@ export class JsonRpcClient {
       new Promise<never>((_resolve, reject) => {
         timeout = setTimeout(() => {
           timedOut = true;
-          tokenSource.cancel();
+          if (!owned) tokenSource.cancel();
           // A deadline that binds earlier than the timeout is a deadline
           // outcome, distinct from an ordinary per-request timeout.
           reject(
@@ -214,12 +272,10 @@ export class JsonRpcClient {
           return result;
         },
         (error: unknown) => {
-          const cancelled = timedOut || aborted || this.closed || isCancellationError(error);
-          const outcome: RequestOutcome = timedOut
-            ? "timed-out"
-            : cancelled
-              ? "cancelled"
-              : "failed";
+          const cancelled =
+            timedOut || transportTimedOut || aborted || this.closed || isCancellationError(error);
+          const outcome: RequestOutcome =
+            timedOut || transportTimedOut ? "timed-out" : cancelled ? "cancelled" : "failed";
           const errorCode = requestErrorCode(outcome, error);
           this.countProtocolStallFailure(outcome, errorCode, error);
           recordRequestTiming(

package/node_modules/@mrclrchtr/supi-lsp/src/config/capabilities.ts

@@ -49,6 +49,7 @@ export const CLIENT_CAPABILITIES: ClientCapabilities = {
     },
     publishDiagnostics: {
       relatedInformation: true,
+      tagSupport: { valueSet: [1, 2] },
       versionSupport: true,
     },
     diagnostic: {

package/node_modules/@mrclrchtr/supi-lsp/src/config/tsconfig-scope.ts

@@ -1,9 +1,9 @@
 // tsconfig-aware file scope detection.
 //
-// Determines whether a file is within the compilation scope of its nearest
-// tsconfig.json or jsconfig.json using the TypeScript compiler's own config
-// parsing APIs. Used by the diagnostic filter to suppress LSP errors on files
-// that TypeScript itself would not include in the project.
+// Determines whether a TypeScript or JavaScript-family file is within the
+// compilation scope of its nearest tsconfig.json or jsconfig.json using the
+// TypeScript compiler's own config parsing APIs. Used by the diagnostic filter
+// to suppress LSP errors on files that TypeScript itself would not include.
 
 import * as path from "node:path";
 import ts from "typescript";
@@ -54,6 +54,23 @@ export interface FileScopeDecision {
   caseSensitiveFileNames: boolean;
 }
 
+const TYPESCRIPT_JAVASCRIPT_EXTENSIONS = new Set([
+  ".ts",
+  ".tsx",
+  ".mts",
+  ".cts",
+  ".js",
+  ".jsx",
+  ".mjs",
+  ".cjs",
+]);
+
+/** Whether tsconfig/jsconfig filtering applies to a TypeScript or JavaScript-family file. */
+export function isTsconfigApplicableFile(filePath: string): boolean {
+  const normalizedPath = filePath.replaceAll("\\", "/");
+  return TYPESCRIPT_JAVASCRIPT_EXTENSIONS.has(path.extname(normalizedPath).toLowerCase());
+}
+
 const nearestConfigCache = new Map<string, string | null>();
 const parsedConfigCache = new Map<string, ParsedProjectConfigCacheEntry>();
 
@@ -82,6 +99,10 @@ const tsInternal = ts as typeof ts & {
  * @returns `true` if the file is excluded from compilation scope
  */
 export function isFileExcludedByTsconfig(filePath: string, cwd: string): boolean {
+  // TypeScript project scope does not decide whether another language's LSP
+  // diagnostics belong in the automatic workspace summary.
+  if (!isTsconfigApplicableFile(filePath)) return false;
+
   // Legacy filter semantics: only a resolved "excluded" decision filters a
   // file. Out-of-tree and no-config files stay unfiltered; the decision API
   // still reports those statuses honestly for consumers that want them.
@@ -91,6 +112,11 @@ export function isFileExcludedByTsconfig(filePath: string, cwd: string): boolean
 /**
  * Compute the explainable tsconfig scope decision for one file.
  *
+ * This low-level TypeScript compilation-membership query returns an
+ * extension-based decision for other languages. Diagnostic filtering and
+ * display first use {@link isTsconfigApplicableFile}; language-neutral
+ * consumers should use that helper or {@link isFileExcludedByTsconfig} instead.
+ *
  * The decision carries the mechanism that produced it (the scope decision
  * basis) so consumers can report why a file is inside or outside the nearest
  * project config without re-deriving the scope logic.

package/node_modules/@mrclrchtr/supi-lsp/src/diagnostics/evidence.ts

@@ -1,6 +1,6 @@
 /** Reason for a partial or unavailable single-file result when the push stays tentative. */
 export const TENTATIVE_PUSH_UNAVAILABLE_REASON =
-  "The current push publication is tentative: a later diagnostic republish for the same document synchronization is required.";
+  "The current diagnostic publication is ambient evidence and cannot confirm the document synchronization.";
 
 /** A final evidence state for one tracked document. */
 export type DiagnosticEvidenceStatus = "confirmed" | "unconfirmed" | "failed" | "removed";