fix(vnext): isolate terminal intent timer generations

Author: Light2Dark

src/vnext/__tests__/session.test.ts

@@ -3916,6 +3916,94 @@ describe("session coverage hardening", () => {
     }
   });
 
+  it("does not let a stale intent callback erase a newer timer", async () => {
+    const nativeSetTimeout = globalThis.setTimeout;
+    const nativeClearTimeout = globalThis.clearTimeout;
+    const callbacks: Array<() => void> = [];
+    const handles: object[] = [];
+    const cleared: number[] = [];
+    Object.defineProperty(globalThis, "setTimeout", {
+      configurable: true,
+      value: (
+        callback: TimerHandler,
+        delay?: number,
+        ...arguments_: unknown[]
+      ) => {
+        if (delay !== 1_000) {
+          return nativeSetTimeout(callback, delay, ...arguments_);
+        }
+        if (typeof callback !== "function") {
+          throw new Error("Intent timer callback must be a function");
+        }
+        callbacks.push(() => {
+          Reflect.apply(callback, undefined, arguments_);
+        });
+        const handle = Object.freeze({ id: handles.length });
+        handles.push(handle);
+        return handle;
+      },
+      writable: true,
+    });
+    Object.defineProperty(globalThis, "clearTimeout", {
+      configurable: true,
+      value: (handle: unknown) => {
+        const index = handles.findIndex(
+          (candidate) => candidate === handle,
+        );
+        if (index >= 0) {
+          cleared.push(index);
+        } else {
+          Reflect.apply(nativeClearTimeout, globalThis, [handle]);
+        }
+      },
+      writable: true,
+    });
+    try {
+      const service = catalogService({
+        id: "stale-intent-timer",
+        search: async () => ({
+          epoch: { generation: 0, token: "loading" },
+          status: "loading",
+        }),
+      });
+      const session = service.openDocument({
+        context: {
+          catalog: { scope: "connection:stale-intent-timer" },
+          dialect: "duckdb",
+          engine: "local",
+        },
+        text: "SELECT * FROM ",
+      });
+      await session.complete({
+        position: 14,
+        trigger: { kind: "invoked" },
+      });
+      await session.complete({
+        position: 14,
+        trigger: { kind: "invoked" },
+      });
+      expect(callbacks).toHaveLength(2);
+      expect(cleared).toContain(0);
+
+      callbacks[0]?.();
+      session.dispose();
+
+      expect(cleared).toContain(1);
+      service.dispose();
+    } finally {
+      Object.defineProperty(globalThis, "setTimeout", {
+        configurable: true,
+        value: nativeSetTimeout,
+        writable: true,
+      });
+      Object.defineProperty(globalThis, "clearTimeout", {
+        configurable: true,
+        value: nativeClearTimeout,
+        writable: true,
+      });
+    }
+  });
+
   it("consumes settlement racing the soft response timer", async () => {
     let resolveSearch:
       | ((

src/vnext/session.ts

@@ -101,6 +101,11 @@ interface SessionChangeSubscription {
   readonly listener: (event: SqlSessionChangeEvent) => void;
 }
 
+interface SessionTimerCell {
+  active: boolean;
+  handle: ReturnType<typeof setTimeout> | undefined;
+}
+
 interface CompletionConfiguration {
   readonly catalogResponseBudgetMs: number;
 }
@@ -757,10 +762,7 @@ export class DefaultSqlDocumentSession<Context extends SqlDocumentContext>
   #refreshIntent: CompletionRequestState | null = null;
   #snapshot: SessionSnapshot<Context>;
   #statementIndexCache: StatementIndexCache | null = null;
-  #terminalIntentTimer:
-    | ReturnType<typeof setTimeout>
-    | undefined;
-  #terminalIntentTimerScheduled = false;
+  #terminalIntentTimer: SessionTimerCell | null = null;
   #updating = false;
 
   constructor(
@@ -834,11 +836,11 @@ export class DefaultSqlDocumentSession<Context extends SqlDocumentContext>
   }
 
   #clearTerminalIntent(): void {
-    if (!this.#terminalIntentTimerScheduled) return;
-    this.#terminalIntentTimerScheduled = false;
-    const timer = this.#terminalIntentTimer;
-    this.#terminalIntentTimer = undefined;
-    clearTimeout(timer);
+    const cell = this.#terminalIntentTimer;
+    if (!cell) return;
+    this.#terminalIntentTimer = null;
+    cell.active = false;
+    clearTimeout(cell.handle);
   }
 
   #dispatchChange(
@@ -1333,15 +1335,24 @@ export class DefaultSqlDocumentSession<Context extends SqlDocumentContext>
               if (outcome.response.status === "loading") {
                 remainingIntentLeaseMs =
                   TERMINAL_LOADING_INTENT_LEASE_MS;
-                this.#terminalIntentTimerScheduled = true;
-                const timer = setTimeout(() => {
-                  this.#terminalIntentTimerScheduled = false;
-                  this.#terminalIntentTimer = undefined;
+                const cell: SessionTimerCell = {
+                  active: true,
+                  handle: undefined,
+                };
+                this.#terminalIntentTimer = cell;
+                const handle = setTimeout(() => {
+                  if (!cell.active) return;
+                  cell.active = false;
+                  if (this.#terminalIntentTimer === cell) {
+                    this.#terminalIntentTimer = null;
+                  }
                 }, remainingIntentLeaseMs);
-                if (this.#terminalIntentTimerScheduled) {
-                  this.#terminalIntentTimer = timer;
-                } else {
-                  clearTimeout(timer);
+                cell.handle = handle;
+                if (
+                  !cell.active ||
+                  this.#terminalIntentTimer !== cell
+                ) {
+                  clearTimeout(handle);
                 }
               }
             }