fix(lint-framework): coalesce lint requests dropped while one is in flight

`requestLintUpdate` used `lintRequested` as a single-flight mutex, but a
request arriving while one was in flight was discarded rather than queued.
The default delay is 0, so there is no debounce to coalesce them either. A
burst of input could therefore leave the rendered lints belonging to a stale
prefix of the text, recovered only by the 1000ms safety-net timer.

That staleness is invisible on screen, because `remapLintToCurrentSource`
keeps the highlight correctly positioned. It is not invisible to the ignore
path: `LintContext` hashes the tokens following a lint, so a lint computed
against a prefix carries a `context_hash` that never matches the one derived
from the final text. Dismissing such a lint records a hash that matches
nothing, and the highlight comes straight back and stays.

Track a `lintDirty` flag and re-run once after the in-flight pass releases
the mutex. The re-run must happen after that release, or it hits the same
guard and is dropped in turn.

Also wrap the lint in try/finally. A rejected `lintProvider` previously left
`lintRequested` stuck at true, permanently stopping all linting.

Refs #3911

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
Entire-Checkpoint: b3fb75386990

Author: rodbegbie

packages/lint-framework/src/lint/LintFramework.ts

@@ -48,6 +48,8 @@ export default class LintFramework {
 	private targets: Set<Node>;
 	private scrollableAncestors: Set<HTMLElement>;
 	private lintRequested = false;
+	/** Set when a lint request arrives while one is already in flight. */
+	private lintDirty = false;
 	private renderRequested = false;
 	private lintDelayTimer: number | null = null;
 	private lastInputAt = 0;
@@ -149,51 +151,66 @@ export default class LintFramework {
 			// Avoid duplicate requests in the queue
 			if (!immediate) {
 				this.lintRequested = true;
+				// This pass reads the text as it is now, so it already covers every
+				// request made before it started.
+				this.lintDirty = false;
 			}
 
-			const lintResults = await Promise.all(
-				this.onScreenTargets().map(async (target) => {
-					if (!document.contains(target)) {
-						this.targets.delete(target);
-						return { target: null as HTMLElement | null, lints: {} };
-					}
+			try {
+				const lintResults = await Promise.all(
+					this.onScreenTargets().map(async (target) => {
+						if (!document.contains(target)) {
+							this.targets.delete(target);
+							return { target: null as HTMLElement | null, lints: {} };
+						}
 
-					const { text, isCM, newLineIndices } = this.getTargetText(target);
+						const { text, isCM, newLineIndices } = this.getTargetText(target);
 
-					if (!text || text.length > 120000) {
-						return { target: null as HTMLElement | null, lints: {} };
-					}
+						if (!text || text.length > 120000) {
+							return { target: null as HTMLElement | null, lints: {} };
+						}
 
-					const language = getTargetLanguage(target);
-					let lintsBySource = await this.lintProvider(text, window.location.hostname, {
-						forceAllHeadings: isHeading(target),
-						language,
-					});
+						const language = getTargetLanguage(target);
+						let lintsBySource = await this.lintProvider(text, window.location.hostname, {
+							forceAllHeadings: isHeading(target),
+							language,
+						});
 
-					if (isCM) {
-						// We're about to modify a reference, so let's work on a copy.
-						lintsBySource = window.structuredClone(lintsBySource);
+						if (isCM) {
+							// We're about to modify a reference, so let's work on a copy.
+							lintsBySource = window.structuredClone(lintsBySource);
 
-						for (const lints of Object.values(lintsBySource)) {
-							for (const lint of lints) {
-								const offset_start = newLineIndices.findIndex((i) => i > lint.span.start);
-								const offset_end = newLineIndices.findIndex((i) => i > lint.span.end);
+							for (const lints of Object.values(lintsBySource)) {
+								for (const lint of lints) {
+									const offset_start = newLineIndices.findIndex((i) => i > lint.span.start);
+									const offset_end = newLineIndices.findIndex((i) => i > lint.span.end);
 
-								lint.span.start -= offset_start;
-								lint.span.end -= offset_end;
+									lint.span.start -= offset_start;
+									lint.span.end -= offset_end;
+								}
 							}
 						}
-					}
 
-					return { target: target as HTMLElement, lints: lintsBySource };
-				}),
-			);
+						return { target: target as HTMLElement, lints: lintsBySource };
+					}),
+				);
 
-			this.lastLints = lintResults.filter((r) => r.target != null) as any;
-			if (!immediate) {
-				this.lintRequested = false;
+				this.lastLints = lintResults.filter((r) => r.target != null) as any;
+				this.requestRender();
+			} finally {
+				if (!immediate) {
+					this.lintRequested = false;
+				}
+			}
+
+			// Must run after the flag above is cleared, otherwise this call hits the
+			// same guard, marks the framework dirty again and is dropped.
+			if (!immediate && this.lintDirty) {
+				this.lintDirty = false;
+				void this.requestLintUpdate();
 			}
-			this.requestRender();
+		} else if (!immediate && this.lintRequested) {
+			this.lintDirty = true;
 		}
 	}