@mrclrchtr/supi-lsp 11.1.0 → 11.3.0

package/src/client/client-diagnostics.ts

@@ -47,6 +47,7 @@ import {
 } from "./client-document-state.ts";
 import { clearTrackedDocumentState, synchronizeTrackedDocument } from "./client-document-sync.ts";
 import { getDiagnosticFileState } from "./client-file-state.ts";
+import { SemanticInputAdmission } from "./client-input-admission.ts";
 import { SemanticInputRequestRetryGuard } from "./client-request-enrollment.ts";
 import {
   SemanticInputBarrier,
@@ -103,6 +104,7 @@ export class ClientDiagnostics {
   /** URIs closed by a lifecycle operation: versioned pushes stay fail-closed. */
   readonly #closedVersionedBarrier = new Set<string>();
   readonly #inputBarrier: SemanticInputBarrier;
+  #inputAdmission = new SemanticInputAdmission();
   #evidenceRevision = 0;
   #nextSynchronizationId = 0;
   /** One active server refresh plus one coalesced newer demand generation. */
@@ -125,6 +127,60 @@ export class ClientDiagnostics {
     });
   }
 
+  /** Keep first enrollment outside a semantic query or refactor-planning attempt. */
+  withSemanticRequest<T>(
+    run: () => Promise<T>,
+    control?: CodeRequestControl,
+    uri?: string,
+  ): Promise<T> {
+    return this.#inputAdmission.request(run, control, uri);
+  }
+
+  /** Read content only after admission; tracked-document changes never wait. */
+  async openDocument(
+    filePath: string,
+    readContent: () => string,
+    control?: CodeRequestControl,
+    protectInputs = false,
+  ): Promise<void> {
+    throwIfCodeRequestInterrupted(control);
+    const open = () => {
+      throwIfCodeRequestInterrupted(control);
+      if (!this.host.isOperational()) throw new Error("LSP client is not running.");
+      this.didOpen(filePath, readContent());
+    };
+    if (this.#openDocs.has(fileToUri(filePath))) {
+      open();
+      return;
+    }
+    await this.#inputAdmission.enroll(fileToUri(filePath), open, control, protectInputs);
+  }
+
+  /** Restore only still-retained documents; a close or replacement wins over recovery. */
+  async restoreDocument(
+    filePath: string,
+    readContent: () => string,
+    isCurrent: () => boolean,
+  ): Promise<void> {
+    const uri = fileToUri(filePath);
+    const admission = this.#inputAdmission;
+    const canRestore = () =>
+      isCurrent() &&
+      this.host.isOperational() &&
+      admission === this.#inputAdmission &&
+      !this.#closedVersionedBarrier.has(uri) &&
+      !this.#openDocs.has(uri);
+    if (!canRestore()) return;
+    try {
+      await this.openDocument(filePath, () => {
+        if (!canRestore()) throw new Error("Document restoration was superseded.");
+        return readContent();
+      });
+    } catch {
+      if (canRestore()) this.markFailedFile(filePath);
+    }
+  }
+
   /** Synchronize all open document inputs, rejoining once after a new enrollment. */
   async synchronizeSemanticInputs(
     control?: CodeRequestControl,
@@ -222,17 +278,22 @@ export class ClientDiagnostics {
     this.#inputBarrier.forgetDocumentContent(uri);
   }
 
-  #ensureExplicitDocumentContent(
+  async #ensureExplicitDocumentContent(
     filePath: string,
     content: string,
     contentIsAuthoritative: boolean,
-  ): void {
+    control?: CodeRequestControl,
+  ): Promise<void> {
     const uri = fileToUri(filePath);
     const document = this.#openDocs.get(uri);
     if (!document) {
-      // An untracked file needs an initial protocol document before its barrier
-      // read can verify the manager's content.
-      this.didOpen(filePath, content);
+      // A manager read can predate admission. Re-read disk after the wait;
+      // explicit authoritative content retains its existing override semantics.
+      await this.openDocument(
+        filePath,
+        () => (contentIsAuthoritative ? content : readFileSync(filePath, "utf-8")),
+        control,
+      );
       return;
     }
     // Manager reads are not authoritative: an already tracked document can
@@ -260,6 +321,8 @@ export class ClientDiagnostics {
   }
 
   clear(options: { preserveFailedDocuments?: boolean } = {}): void {
+    this.#inputAdmission.dispose();
+    this.#inputAdmission = new SemanticInputAdmission();
     if (options.preserveFailedDocuments) {
       for (const uri of [...this.#openDocs.keys(), ...this.#diagnosticStore.keys()]) {
         this.#failedUris.add(uri);
@@ -336,6 +399,7 @@ export class ClientDiagnostics {
 
   /** Send a save after a disk change that the input barrier observed. */
   #noteExternalDiskChange(filePath: string, content: string): void {
+    this.#inputAdmission.invalidateRequests();
     if (!this.host.isOperational()) return;
     const documentSync = this.host.documentSync();
     if (!documentSync.save) return;
@@ -368,6 +432,7 @@ export class ClientDiagnostics {
 
   didClose(filePath: string): void {
     const uri = fileToUri(filePath);
+    this.#inputAdmission.close(uri);
     const wasOpen = this.#openDocs.has(uri);
     const hadState =
       wasOpen ||
@@ -627,7 +692,12 @@ export class ClientDiagnostics {
     throwIfCodeRequestInterrupted(control);
     const uri = fileToUri(filePath);
     const contentIsAuthoritative = options.contentIsAuthoritative !== false;
-    this.#ensureExplicitDocumentContent(filePath, content, contentIsAuthoritative);
+    try {
+      await this.#ensureExplicitDocumentContent(filePath, content, contentIsAuthoritative, control);
+    } catch (error) {
+      throwIfCodeRequestInterrupted(control);
+      return unavailableAfterEnrollmentRetry(error);
+    }
     const contentOverrides = this.#getDiagnosticContentOverrides(
       uri,
       content,
@@ -1044,6 +1114,7 @@ export class ClientDiagnostics {
     changeKind: SemanticInputChangeKind = "content",
   ): void {
     this.#inputBarrier.noteInputChange(changeKind);
+    if (changeKind !== "enrollment") this.#inputAdmission.invalidateRequests();
     if (invalidateEvidence) this.#advanceEvidenceRevision(false);
     if (cancelRequests) this.#cancelAllDiagnosticRequests();
   }

package/src/client/client-input-admission.ts

@@ -0,0 +1,149 @@
+import {
+  type CodeRequestControl,
+  CodeRequestDeadlineError,
+  throwIfCodeRequestInterrupted,
+} from "@mrclrchtr/supi-code-runtime/api";
+
+const MAX_PENDING_INPUT_OPERATIONS = 32;
+
+type InputOperationKind = "request" | "enrollment" | "request-enrollment";
+
+interface PendingInputOperation {
+  readonly uri: string | undefined;
+  readonly kind: InputOperationKind;
+  start(): void;
+  cancel(reason: unknown): void;
+}
+
+/**
+ * Admit first opens between semantic query and refactor-planning attempts on one client.
+ * Consecutive readers run concurrently; FIFO admission prevents either new
+ * readers or enrollments from overtaking a waiting operation. This is not
+ * diagnostic transport ownership: an interrupted semantic attempt can release
+ * its admission even when the server has not yet acknowledged cancellation.
+ */
+export class SemanticInputAdmission {
+  readonly #pending: PendingInputOperation[] = [];
+  #readers = 0;
+  #enrolling = false;
+  #disposed = false;
+
+  /** Cover one attempt's synchronization, RPCs and acceptance, never its retry. */
+  request<T>(run: () => Promise<T>, control?: CodeRequestControl, uri?: string): Promise<T> {
+    return this.#run("request", uri, run, control);
+  }
+
+  /**
+   * Commit a first open after earlier attempts leave. Demand with original
+   * semantic/refactor parameters opts into input invalidation while waiting.
+   */
+  enroll(
+    uri: string,
+    run: () => void,
+    control?: CodeRequestControl,
+    protectInputs = false,
+  ): Promise<void> {
+    return this.#run(protectInputs ? "request-enrollment" : "enrollment", uri, run, control);
+  }
+
+  /** A close cancels queued opens and queries for that document, before dispatch. */
+  close(uri: string): void {
+    const cancelled = this.#pending.filter((pending) => pending.uri === uri);
+    for (const pending of cancelled) this.#pending.splice(this.#pending.indexOf(pending), 1);
+    for (const pending of cancelled)
+      pending.cancel(new Error("Document closed before input admission."));
+  }
+
+  /** Discard queued request parameters after a known non-enrollment input change. */
+  invalidateRequests(): void {
+    const cancelled = this.#pending.filter((pending) => pending.kind !== "enrollment");
+    for (const pending of cancelled) this.#pending.splice(this.#pending.indexOf(pending), 1);
+    for (const pending of cancelled)
+      pending.cancel(new Error("Semantic inputs changed before request admission."));
+  }
+
+  /** Reject queued work without confusing caller completion with transport settlement. */
+  dispose(): void {
+    this.#disposed = true;
+    for (const pending of [...this.#pending]) {
+      pending.cancel(new Error("LSP client stopped before input admission."));
+    }
+  }
+
+  #run<T>(
+    kind: InputOperationKind,
+    uri: string | undefined,
+    run: () => T | Promise<T>,
+    control: CodeRequestControl | undefined,
+  ): Promise<T> {
+    throwIfCodeRequestInterrupted(control);
+    if (this.#disposed) return Promise.reject(new Error("LSP input admission is disposed."));
+    if (this.#pending.length >= MAX_PENDING_INPUT_OPERATIONS) {
+      return Promise.reject(new Error("LSP input admission queue is full."));
+    }
+    return new Promise<T>((resolve, reject) => {
+      let timer: ReturnType<typeof setTimeout> | undefined;
+      let waiting = true;
+      const cleanup = () => {
+        if (timer !== undefined) clearTimeout(timer);
+        control?.signal?.removeEventListener("abort", abort);
+      };
+      const operation: PendingInputOperation = {
+        uri,
+        kind,
+        cancel: (reason) => {
+          if (!waiting) return;
+          waiting = false;
+          cleanup();
+          const index = this.#pending.indexOf(operation);
+          if (index !== -1) this.#pending.splice(index, 1);
+          reject(reason);
+          this.#drain();
+        },
+        start: () => {
+          waiting = false;
+          cleanup();
+          if (kind !== "request") this.#enrolling = true;
+          else this.#readers++;
+          const finish = () => {
+            if (kind !== "request") this.#enrolling = false;
+            else this.#readers--;
+            this.#drain();
+          };
+          try {
+            throwIfCodeRequestInterrupted(control);
+            Promise.resolve(run()).then(resolve, reject).finally(finish);
+          } catch (error) {
+            reject(error);
+            finish();
+          }
+        },
+      };
+      const abort = () => {
+        try {
+          throwIfCodeRequestInterrupted(control);
+        } catch (error) {
+          operation.cancel(error);
+        }
+      };
+      this.#pending.push(operation);
+      control?.signal?.addEventListener("abort", abort, { once: true });
+      if (control?.deadline !== undefined) {
+        timer = setTimeout(
+          () => operation.cancel(new CodeRequestDeadlineError()),
+          Math.max(0, control.deadline - Date.now()),
+        );
+      }
+      this.#drain();
+    });
+  }
+
+  #drain(): void {
+    while (!this.#disposed && !this.#enrolling && this.#pending.length > 0) {
+      const next = this.#pending[0];
+      if (next.kind !== "request" && this.#readers > 0) return;
+      this.#pending.shift();
+      next.start();
+    }
+  }
+}

package/src/client/client-typescript-project.ts

@@ -0,0 +1,40 @@
+/**
+ * Whether tsserver placed an open file in a configured project.
+ *
+ * - `configured`: a `tsconfig.json` / `jsconfig.json` program owns the file.
+ * - `inferred`: tsserver created an inferred project for the file alone, so
+ *   project-wide requests such as `workspace/symbol` do not cover the
+ *   configured program.
+ * - `unknown`: the route is not TypeScript or tsserver could not answer.
+ */
+export type ProjectMembership = "configured" | "inferred" | "unknown";
+
+/** Build `workspace/executeCommand` params for tsserver `projectInfo`. */
+export function typeScriptProjectInfoParams(uri: string): unknown {
+  return {
+    command: "typescript.tsserverRequest",
+    arguments: [
+      "projectInfo",
+      { file: uri, needFileNameList: false },
+      // Semantic execution target; the project must be loaded to answer.
+      { executionTarget: 0, expectsResult: true, isAsync: false },
+    ],
+  };
+}
+
+/**
+ * Read project membership from a tsserver `projectInfo` response.
+ * tsserver names projects without a config file `/dev/null/<kind>Project<N>*`.
+ */
+export function readTypeScriptProjectMembership(response: unknown): ProjectMembership {
+  if (!isRecord(response) || response.type !== "response" || response.success !== true) {
+    return "unknown";
+  }
+  const body = response.body;
+  if (!isRecord(body) || typeof body.configFileName !== "string") return "unknown";
+  return body.configFileName.startsWith("/dev/null/") ? "inferred" : "configured";
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === "object" && value !== null;
+}