@mrclrchtr/supi-code-intelligence 6.3.0 → 7.0.0

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

@@ -1,9 +1,209 @@
+import {
+  type CodeRequestControl,
+  throwIfCodeRequestInterrupted,
+} from "@mrclrchtr/supi-code-runtime/api";
+import type { DocumentDiagnosticReport } from "../config/types.ts";
+import { raceRequestControl } from "../session/readiness.ts";
+
+/** Evidence source used by an explicit diagnostic request. */
+export type DiagnosticRequestSource = "pull" | "typescript";
+
+/** Error used when local document or client invalidation supersedes a request. */
+export class DiagnosticRequestInvalidatedError extends Error {
+  constructor(message = "Diagnostic request was invalidated.") {
+    super(message);
+    // biome-ignore lint/security/noSecrets: This is a stable error class name.
+    this.name = "DiagnosticRequestInvalidatedError";
+  }
+}
+
+/** Test whether a request stopped because its local evidence generation ended. */
+export function isDiagnosticRequestInvalidated(error: unknown): boolean {
+  return error instanceof DiagnosticRequestInvalidatedError;
+}
+
 /** Sanitized ownership and transport control for one explicit diagnostic pull. */
 export interface DiagnosticPullRequest {
   readonly uri: string;
   readonly previousResultId: string | undefined;
   readonly timeoutMs: number;
+  /** Adapter cancellation stops adapter work, not the owned transport. */
   readonly signal?: AbortSignal;
-  readonly deadline?: number;
   readonly operationId?: string;
 }
+
+/** Result returned by one request adapter. */
+export interface DiagnosticRequestResult {
+  readonly source: DiagnosticRequestSource;
+  readonly report: DocumentDiagnosticReport;
+}
+
+/**
+ * The result and transport lifetime of one adapter request are separate.
+ * `result` may stop at a local deadline while `settled` waits for the
+ * underlying protocol request. This prevents a replacement request from
+ * entering the same server route too early.
+ */
+export interface DiagnosticRequestExecution<T> {
+  readonly result: Promise<T>;
+  readonly settled: Promise<void>;
+}
+
+/** Internal seam for one explicit, file-scoped diagnostic request. */
+export interface DiagnosticRequestAdapter {
+  /** Whether this adapter can collect the requested URI right now. */
+  supports(uri: string): boolean;
+  /** Return the source that will be used for a URI, when known. */
+  sourceFor(uri: string): DiagnosticRequestSource | undefined;
+  /** Start one request without transferring caller cancellation to transport. */
+  collect(request: DiagnosticPullRequest): DiagnosticRequestExecution<DiagnosticRequestResult>;
+}
+
+/** Combine adapters in priority order. The first applicable adapter wins. */
+export function createPriorityDiagnosticRequestAdapter(
+  adapters: readonly DiagnosticRequestAdapter[],
+): DiagnosticRequestAdapter {
+  const find = (uri: string) => adapters.find((adapter) => adapter.supports(uri));
+  return {
+    supports: (uri) => find(uri) !== undefined,
+    sourceFor: (uri) => find(uri)?.sourceFor(uri),
+    collect: (request) => {
+      const adapter = find(request.uri);
+      if (!adapter) {
+        const error = new Error("No diagnostic request adapter applies to this document.");
+        return { result: Promise.reject(error), settled: Promise.resolve() };
+      }
+      return adapter.collect(request);
+    },
+  };
+}
+
+interface ScheduledDiagnosticRequest<T> {
+  readonly key: string;
+  readonly start: () => DiagnosticRequestExecution<T>;
+  readonly result: Promise<T>;
+  readonly resolve: (value: T | PromiseLike<T>) => void;
+  readonly reject: (reason?: unknown) => void;
+  readonly settled: Promise<void>;
+  readonly settle: () => void;
+  consumers: number;
+}
+
+/**
+ * Share duplicate file requests and serialize requests for one client route.
+ * The queue is deliberately small: callers must not create an unbounded
+ * server-side tsserver request backlog after a timeout.
+ */
+export class DiagnosticRequestScheduler {
+  static readonly MAX_PENDING_REQUESTS = 32;
+
+  readonly #jobs = new Map<string, ScheduledDiagnosticRequest<unknown>>();
+  readonly #pending: Array<ScheduledDiagnosticRequest<unknown>> = [];
+  #active: ScheduledDiagnosticRequest<unknown> | undefined;
+
+  /** Start or join one request, while keeping the underlying job shared. */
+  run<T>(
+    key: string,
+    start: () => DiagnosticRequestExecution<T>,
+    control?: CodeRequestControl,
+  ): Promise<T> {
+    throwIfCodeRequestInterrupted(control);
+    let job = this.#jobs.get(key) as ScheduledDiagnosticRequest<T> | undefined;
+    if (!job) {
+      if (this.#pending.length >= DiagnosticRequestScheduler.MAX_PENDING_REQUESTS) {
+        return Promise.reject(new Error("Diagnostic request queue is full."));
+      }
+      let resolve!: (value: T | PromiseLike<T>) => void;
+      let reject!: (reason?: unknown) => void;
+      const result = new Promise<T>((jobResolve, jobReject) => {
+        resolve = jobResolve;
+        reject = jobReject;
+      });
+      let settle!: () => void;
+      const settled = new Promise<void>((resolveSettled) => {
+        settle = resolveSettled;
+      });
+      job = {
+        key,
+        start,
+        result,
+        resolve,
+        reject,
+        settled,
+        settle,
+        consumers: 0,
+      };
+      this.#jobs.set(key, job as ScheduledDiagnosticRequest<unknown>);
+      this.#pending.push(job as ScheduledDiagnosticRequest<unknown>);
+      this.#pump();
+    }
+    const currentJob = job;
+    currentJob.consumers++;
+    const waiting = raceRequestControl(currentJob.result, control);
+    void waiting
+      .finally(() =>
+        this.#releaseConsumer(currentJob as unknown as ScheduledDiagnosticRequest<unknown>),
+      )
+      .catch(() => {});
+    return waiting;
+  }
+
+  /** Drop requests that have not reached the transport. Active work is kept. */
+  clearPending(reason = new DiagnosticRequestInvalidatedError()): void {
+    this.clearPendingWhere(() => true, reason);
+  }
+
+  /** Drop matching queued requests without disturbing other documents. */
+  clearPendingWhere(
+    predicate: (key: string) => boolean,
+    reason = new DiagnosticRequestInvalidatedError(),
+  ): void {
+    const pending = this.#pending.filter((job) => predicate(job.key));
+    for (const job of pending) {
+      const index = this.#pending.indexOf(job);
+      if (index >= 0) this.#pending.splice(index, 1);
+      this.#jobs.delete(job.key);
+      job.reject(reason);
+      job.settle();
+    }
+  }
+
+  #releaseConsumer(job: ScheduledDiagnosticRequest<unknown>): void {
+    job.consumers = Math.max(0, job.consumers - 1);
+    if (job.consumers > 0 || this.#active === job) return;
+    const pendingIndex = this.#pending.indexOf(job);
+    if (pendingIndex < 0) return;
+    this.#pending.splice(pendingIndex, 1);
+    this.#jobs.delete(job.key);
+    job.reject(new Error("Diagnostic request had no remaining callers."));
+    job.settle();
+  }
+
+  #pump(): void {
+    if (this.#active !== undefined) return;
+    const job = this.#pending.shift();
+    if (!job) return;
+    this.#active = job;
+    let execution: DiagnosticRequestExecution<unknown>;
+    try {
+      execution = job.start();
+    } catch (error) {
+      job.reject(error);
+      job.settle();
+      this.#active = undefined;
+      this.#jobs.delete(job.key);
+      this.#pump();
+      return;
+    }
+    execution.result.then(job.resolve, job.reject).catch(() => {});
+    execution.settled
+      .catch(() => {})
+      .then(() => {
+        if (this.#active !== job) return;
+        this.#active = undefined;
+        this.#jobs.delete(job.key);
+        job.settle();
+        this.#pump();
+      });
+  }
+}

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

@@ -5,24 +5,20 @@ import {
 } from "@mrclrchtr/supi-core/debug";
 import { boundCwd } from "../debug-telemetry.ts";
 
-type DiagnosticCollection = "cache" | "fallback" | "none" | "pull" | "push";
+type DiagnosticCollection =
+  | "cache"
+  | "fallback"
+  | "mixed"
+  | "none"
+  | "pull"
+  | "push"
+  | "typescript";
 type DiagnosticFreshness = "not-observed" | "observed";
 type DiagnosticOutcome = "completed" | "incomplete" | "skipped" | "timed-out";
 type DiagnosticPullOutcome = "completed" | "failed" | "not-supported" | "not-used" | "timed-out";
-type DiagnosticPushOutcome =
-  | "not-used"
-  | "published"
-  | "tentative"
-  | "released"
-  | "settled"
-  | "timed-out";
-type DiagnosticSettleOutcome =
-  | "not-used"
-  | "published"
-  | "tentative"
-  | "quiet"
-  | "released"
-  | "timed-out";
+type DiagnosticRequestSource = "pull" | "typescript" | "mixed";
+type DiagnosticPushOutcome = "not-used" | "tentative" | "released" | "settled" | "timed-out";
+type DiagnosticSettleOutcome = "not-used" | "quiet" | "released" | "timed-out";
 type DiagnosticTimingOperation = "refresh-open" | "sync-file";
 
 /** Result of waiting for a quiet push-diagnostic window. */
@@ -31,8 +27,11 @@ export interface DiagnosticSettleResult {
   readonly freshness: DiagnosticFreshness;
 }
 
-/** Result of waiting for one file's push diagnostics. */
-export type DiagnosticPushWaitOutcome = "published" | "tentative" | "released" | "timed-out";
+/** Result of collecting one file's ambient push diagnostics. */
+export type DiagnosticPushWaitOutcome = "tentative" | "released" | "timed-out";
+
+/** Result of waiting for one ambient push observation. */
+export type DiagnosticPushObservationOutcome = "observed" | "released" | "timed-out";
 
 interface DiagnosticTimingData {
   readonly collection: DiagnosticCollection;
@@ -42,21 +41,10 @@ interface DiagnosticTimingData {
   readonly outcome: DiagnosticOutcome;
   readonly pull: DiagnosticPullOutcome;
   readonly push: DiagnosticPushOutcome;
-  readonly reopen: number;
   readonly settle: DiagnosticSettleOutcome;
   readonly timedOut: boolean;
 }
 
-/** Internal pull failure that retains timeout state and failed document URIs. */
-export class DiagnosticPullError extends Error {
-  constructor(
-    readonly timedOut: boolean,
-    readonly failedUris: readonly string[] = [],
-  ) {
-    super("pull diagnostics incomplete");
-  }
-}
-
 /** Bounded identity for one diagnostic timing observation. */
 export interface DiagnosticTimingIdentity {
   /** Configured server name. */
@@ -76,15 +64,16 @@ export interface DiagnosticTimingIdentity {
 export class DiagnosticObserver {
   readonly #timer = startDebugTimer();
   #pull: "failed" | "not-supported" | "timed-out";
-  #reopened = 0;
+  #requestSource: DiagnosticRequestSource | undefined;
+  #request: "failed" | "timed-out" | undefined;
 
   constructor(
     readonly operation: DiagnosticTimingOperation,
-    readonly supportsPull: boolean,
+    readonly hasDiagnosticRequestAdapter: boolean,
     readonly control?: CodeRequestControl,
     readonly identity?: DiagnosticTimingIdentity,
   ) {
-    this.#pull = supportsPull ? "failed" : "not-supported";
+    this.#pull = hasDiagnosticRequestAdapter ? "failed" : "not-supported";
   }
 
   synchronized(): void {
@@ -100,7 +89,6 @@ export class DiagnosticObserver {
       outcome: "skipped",
       pull: "not-used",
       push: "not-used",
-      reopen: 0,
       settle: "not-used",
       timedOut: false,
     });
@@ -115,7 +103,6 @@ export class DiagnosticObserver {
       outcome: "completed",
       pull: "not-used",
       push: "not-used",
-      reopen: 0,
       settle: "not-used",
       timedOut: false,
     });
@@ -131,7 +118,6 @@ export class DiagnosticObserver {
         outcome: "completed",
         pull: "completed",
         push: "not-used",
-        reopen: 0,
         settle: "not-used",
         timedOut: false,
       },
@@ -139,40 +125,119 @@ export class DiagnosticObserver {
     );
   }
 
-  pullFailed(error: unknown): void {
-    this.#pull = isDiagnosticTimeout(error) ? "timed-out" : "failed";
-    this.#timer.mark("pull");
+  /** Record a completed request-based collection. */
+  requestCompleted(source: DiagnosticRequestSource, documentCount: number, finish = true): void {
+    this.#requestSource = source;
+    this.#request = undefined;
+    if (source === "pull" && finish) {
+      this.pullCompleted(documentCount);
+      return;
+    }
+    if (!finish) {
+      this.#timer.mark("request");
+      return;
+    }
+    this.#finish(
+      {
+        collection: source === "typescript" ? "typescript" : "mixed",
+        documentCount,
+        fallback: false,
+        freshness: "observed",
+        outcome: "completed",
+        pull: this.hasDiagnosticRequestAdapter ? "not-used" : "not-supported",
+        push: "not-used",
+        settle: "not-used",
+        timedOut: false,
+      },
+      "request",
+    );
+  }
+
+  /** Record a request failure without finishing the operation yet. */
+  requestFailed(source: DiagnosticRequestSource | undefined, error: unknown): void {
+    this.#requestSource = source;
+    this.#request = isDiagnosticTimeout(error) ? "timed-out" : "failed";
+    this.#timer.mark("request");
   }
 
-  pullTimedOut(): void {
-    this.#pull = "timed-out";
-    this.#timer.mark("pull");
+  /** Finish an incomplete request collection without using push confirmation. */
+  requestIncomplete(
+    source: DiagnosticRequestSource | undefined,
+    timedOut = false,
+    documentCount = 1,
+    finish = true,
+  ): void {
+    const requestSource = source ?? this.#requestSource ?? "pull";
+    this.#requestSource = requestSource;
+    this.#request = timedOut || this.#request === "timed-out" ? "timed-out" : "failed";
+    if (!finish) {
+      this.#timer.mark("request");
+      return;
+    }
+    this.#finish(
+      {
+        collection: requestSource === "typescript" ? "typescript" : requestSource,
+        documentCount,
+        fallback: false,
+        freshness: "not-observed",
+        outcome: this.#request === "timed-out" ? "timed-out" : "incomplete",
+        pull: requestSource === "pull" ? this.#request : "not-supported",
+        push: "not-used",
+        settle: "not-used",
+        timedOut: this.#request === "timed-out",
+      },
+      "request",
+    );
+  }
+
+  /** Finish a mixed request and push observation pass. */
+  mixedSettled(
+    source: DiagnosticRequestSource,
+    documentCount: number,
+    settle: DiagnosticSettleResult,
+  ): void {
+    const timedOut = settle.outcome === "timed-out" || this.#request === "timed-out";
+    const requestOutcome =
+      this.#request === "timed-out"
+        ? ("timed-out" as const)
+        : this.#request === "failed"
+          ? ("failed" as const)
+          : ("completed" as const);
+    this.#finish(
+      {
+        collection: "mixed",
+        documentCount,
+        fallback: false,
+        freshness: settle.freshness,
+        outcome: timedOut ? "timed-out" : "incomplete",
+        pull: source === "pull" ? requestOutcome : "not-supported",
+        push: timedOut ? "timed-out" : settle.outcome === "released" ? "released" : "settled",
+        settle: settle.outcome,
+        timedOut,
+      },
+      "push-settle",
+    );
   }
 
-  /**
-   * Record that the reopen-resync fallback re-opened unconfirmed documents.
-   *
-   * The mark fires when the second settle window starts, so the measured
-   * phase is the preceding first settle window, not the reopen work.
-   */
-  reopened(count: number): void {
-    this.#reopened += count;
-    this.#timer.mark("first-settle");
+  /** Record a request that could not start within its collection budget. */
+  requestTimedOut(source: DiagnosticRequestSource | undefined): void {
+    this.#requestSource = source;
+    this.#request = "timed-out";
+    this.#timer.mark("request");
+    this.requestIncomplete(source, true);
   }
 
   pushSettled(documentCount: number, settle: DiagnosticSettleResult): void {
     const timedOut = settle.outcome === "timed-out";
-    const completed = settle.outcome === "quiet" && settle.freshness === "observed";
     this.#finish(
       {
-        collection: this.supportsPull ? "fallback" : "push",
+        collection: this.hasDiagnosticRequestAdapter ? "fallback" : "push",
         documentCount,
-        fallback: this.supportsPull,
+        fallback: this.hasDiagnosticRequestAdapter,
         freshness: settle.freshness,
-        outcome: completed ? "completed" : timedOut ? "timed-out" : "incomplete",
+        outcome: timedOut ? "timed-out" : "incomplete",
         pull: this.#pull,
         push: timedOut ? "timed-out" : settle.outcome === "released" ? "released" : "settled",
-        reopen: this.#reopened,
         settle: settle.outcome,
         timedOut: timedOut || this.#pull === "timed-out",
       },
@@ -181,30 +246,28 @@ export class DiagnosticObserver {
   }
 
   pushWaitCompleted(documentCount: number, push: DiagnosticPushWaitOutcome): void {
-    const confirmed = push === "published";
-    // A tentative result used the full wait budget without a confirming
-    // republish. Keep its distinct push value and report the budget expiry.
     const timedOut = push === "tentative" || push === "timed-out";
-    const observed = push === "published" || push === "tentative";
+    const observed = push === "tentative";
     this.#finish(
       {
-        collection: this.supportsPull ? "fallback" : "push",
+        collection: this.hasDiagnosticRequestAdapter ? "fallback" : "push",
         documentCount,
-        fallback: this.supportsPull,
+        fallback: this.hasDiagnosticRequestAdapter,
         freshness: observed ? "observed" : "not-observed",
-        outcome: confirmed ? "completed" : timedOut ? "timed-out" : "incomplete",
+        outcome: timedOut ? "timed-out" : "incomplete",
         pull: this.#pull,
         push,
-        reopen: this.#reopened,
-        settle: push,
+        settle: timedOut ? "timed-out" : push,
         timedOut: timedOut || this.#pull === "timed-out",
       },
       "push-settle",
     );
   }
 
-  #finish(data: DiagnosticTimingData, finalPhase?: "pull" | "push-settle" | "synchronize"): void {
-    const { reopen, ...observation } = data;
+  #finish(
+    data: DiagnosticTimingData,
+    finalPhase?: "pull" | "push-settle" | "request" | "synchronize",
+  ): void {
     this.#timer.finish(
       () => ({
         operationId: this.control?.operationId,
@@ -215,10 +278,7 @@ export class DiagnosticObserver {
         cwd: boundCwd(this.identity?.cwd),
         data: {
           operation: this.operation,
-          ...observation,
-          // Reopen fallback usage is recorded only when it happened; the
-          // default event shape stays stable for consumers of #322 telemetry.
-          ...(reopen > 0 ? { reopen } : {}),
+          ...data,
           ...(this.identity?.server !== undefined
             ? { server: truncateIdentity(this.identity.server) }
             : {}),
@@ -234,6 +294,5 @@ export class DiagnosticObserver {
 
 /** Return whether a diagnostic failure represents a timeout without retaining its message. */
 export function isDiagnosticTimeout(error: unknown): boolean {
-  if (error instanceof DiagnosticPullError) return error.timedOut;
   return error instanceof Error && /\btimed? ?out\b|\btimeout\b/i.test(error.message);
 }