Debounce revalidating dependents while editing an open schema

Every edit to an open schema notified schema change handlers, which
cleared the compiled schemas of its dependents and revalidated them.
When typing quickly, those revalidations overlapped and each started a
new compile, so all but the last were thrown away.

Notifications caused by edits to an open document now wait until
typing pauses for 200ms and are sent together. The registry is still
updated on every edit, so the edited document's own diagnostics aren't
delayed. Changes from the file system, opening, and closing are still
notified immediately.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

Author: jdesrosiers

language-server/src/features/diagnostics/SchemaValidationDiagnosticsProvider.test.ts

@@ -943,6 +943,41 @@ describe("Schema Validation", () => {
     await expect(secondValidation).resolves.toHaveLength(0);
   });
 
+  test("editing an open schema revalidates dependents once when typing pauses", async () => {
+    const schemaWithFooType = (type: string) => `{
+      "$schema": "https://json-schema.org/draft/2020-12/schema",
+      "type": "object",
+      "properties": {
+        "foo": { "type": "${type}" }
+      }
+    }`;
+
+    fixtureSchemaUri = await client.writeDocument("schema.json", schemaWithFooType("string"));
+    await client.openDocument("schema.json");
+
+    await client.writeDocument("instance.json", `{
+      "$schema": "${fixtureSchemaUri}",
+      "foo": 42
+    }`);
+    const initialValidation = client.getDiagnostics("instance.json");
+    const instanceUri = await client.openDocument("instance.json");
+    await expect(initialValidation).resolves.toHaveLength(1);
+
+    const instanceValidations: number[] = [];
+    client.onNotification(PublishDiagnosticsNotification.type, (params) => {
+      if (params.uri === instanceUri) {
+        instanceValidations.push(params.diagnostics.length);
+      }
+    });
+
+    await client.changeDocument("schema.json", schemaWithFooType("boolean"));
+    await client.changeDocument("schema.json", schemaWithFooType("null"));
+    await client.changeDocument("schema.json", schemaWithFooType("number"));
+    await new Promise((resolve) => setTimeout(resolve, 500));
+
+    expect(instanceValidations).toEqual([0]);
+  });
+
   test("editing an open referenced schema revalidates dependents", async () => {
     const referencedSchema = await client.writeDocument("B.schema.json", `{
       "$schema": "https://json-schema.org/draft/2020-12/schema",

language-server/src/services/JsonSchemaRegistry.ts

@@ -33,6 +33,9 @@ type DidChangeSchemaParams = {
 
 const readChunkSize = 100;
 
+// How long typing in an open document has to pause before documents that depend on it are revalidated
+const editDebounceMs = 200;
+
 export class JsonSchemaRegistry {
   private server: Server;
   private workspace: Workspace;
@@ -43,6 +46,8 @@ export class JsonSchemaRegistry {
   private failedSchemas: Map<string, { id: string; message: string }> = new Map();
   private didChangeSchemaHandlers: Set<DidChangeSchemaHandler> = new Set();
   private pending: Promise<void>;
+  private pendingEditChanges: Map<string, DidChangeSchemaParams> = new Map();
+  private editDebounceTimer: ReturnType<typeof setTimeout> | undefined;
 
   constructor(server: Server, workspace: Workspace, jsonDocuments: JsonDocuments) {
     this.server = server;
@@ -90,6 +95,7 @@ export class JsonSchemaRegistry {
     });
 
     server.onShutdown(() => {
+      clearTimeout(this.editDebounceTimer);
       for (const schemaUri of this.workspaceSchemas.values()) {
         unregisterSchema(schemaUri);
       }
@@ -192,12 +198,39 @@ export class JsonSchemaRegistry {
     const applied = this.pending.then(() => this.applyChanges(fileUris));
     this.pending = applied.then(() => undefined, () => undefined);
 
-    // Handlers aren't part of the queue because they can wait on `ready`
+    const changes: DidChangeSchemaParams[] = [];
     for (const [fileUri, schemaUris] of await applied) {
       for (const schemaUri of schemaUris) {
-        for (const handler of this.didChangeSchemaHandlers) {
-          await handler({ schemaUri, fileUri, editedDocumentUri });
-        }
+        changes.push({ schemaUri, fileUri, editedDocumentUri });
+      }
+    }
+
+    if (editedDocumentUri) {
+      // Typing in a schema changes it on every keystroke, and revalidating its dependents means
+      // recompiling them. The registry is already up to date, so only the notification waits.
+      for (const change of changes) {
+        this.pendingEditChanges.set(`${change.fileUri} ${change.schemaUri}`, change);
+      }
+
+      clearTimeout(this.editDebounceTimer);
+      this.editDebounceTimer = setTimeout(() => {
+        const pendingChanges = [...this.pendingEditChanges.values()];
+        this.pendingEditChanges.clear();
+        this.notify(pendingChanges).catch((error: unknown) => {
+          const message = error instanceof Error ? error.message : String(error);
+          this.server.console.error(`Failed to process schema changes: ${message}`);
+        });
+      }, editDebounceMs);
+    } else {
+      await this.notify(changes);
+    }
+  }
+
+  // Handlers aren't part of the queue because they can wait on `ready`
+  private async notify(changes: DidChangeSchemaParams[]) {
+    for (const change of changes) {
+      for (const handler of this.didChangeSchemaHandlers) {
+        await handler(change);
       }
     }
   }