@ulearning/ai-sdk 0.0.0-stage → 1.0.0-next.0

package/src/unstable/useLiveCompletionAdapter.test.tsx

@@ -0,0 +1,760 @@
+/** @vitest-environment jsdom */
+import {
+  defineComponent,
+  h,
+  KeepAlive,
+  nextTick,
+  onMounted,
+  Suspense,
+} from "vue";
+import { actAsync as act, cleanup, render, renderHook } from "../tests/vue";
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import type { Unstable_TriggerItem } from "@ulearning/ai-core";
+import { unstable_useLiveCompletionAdapter } from "./useLiveCompletionAdapter";
+
+const item = (id: string): Unstable_TriggerItem => ({
+  id,
+  type: "x",
+  label: id,
+});
+
+describe("unstable_useLiveCompletionAdapter", () => {
+  beforeEach(() => vi.useFakeTimers());
+  afterEach(() => {
+    cleanup();
+    vi.useRealTimers();
+  });
+
+  it("returns cached items synchronously and schedules a debounced fetch", async () => {
+    let resolve!: (value: readonly Unstable_TriggerItem[]) => void;
+    const fetcher = vi.fn(
+      () =>
+        new Promise<readonly Unstable_TriggerItem[]>((r) => {
+          resolve = r;
+        }),
+    );
+    const { result } = renderHook(() =>
+      unstable_useLiveCompletionAdapter({ fetcher, debounceMs: 50 }),
+    );
+
+    let returned: readonly Unstable_TriggerItem[] = [];
+    await act(async () => {
+      returned = result.current.adapter.search!("ab");
+    });
+    expect(returned).toEqual([]);
+    expect(result.current.isLoading).toBe(true);
+    expect(fetcher).not.toHaveBeenCalled();
+
+    await act(async () => {
+      await vi.advanceTimersByTimeAsync(50);
+    });
+    expect(fetcher).toHaveBeenCalledTimes(1);
+    expect(fetcher).toHaveBeenCalledWith("ab");
+
+    await act(async () => {
+      resolve([item("ab")]);
+    });
+    expect(result.current.isLoading).toBe(false);
+    expect(result.current.adapter.search!("ab")).toEqual([item("ab")]);
+    expect(fetcher).toHaveBeenCalledTimes(1);
+  });
+
+  it("defers its state update out of search() so it is safe to call during render", () => {
+    const fetcher = vi.fn(async () => []);
+    const { result } = renderHook(() =>
+      unstable_useLiveCompletionAdapter({ fetcher, debounceMs: 0 }),
+    );
+
+    const returned = result.current.adapter.search!("ab");
+    expect(returned).toEqual([]);
+    // the fetch (and its setIsLoading) is queued, not run synchronously
+    expect(result.current.isLoading).toBe(false);
+    expect(fetcher).not.toHaveBeenCalled();
+  });
+
+  it("does not start a queued fetch after unmount", async () => {
+    const fetcher = vi.fn(async () => []);
+    const { result, unmount } = renderHook(() =>
+      unstable_useLiveCompletionAdapter({ fetcher, debounceMs: 0 }),
+    );
+
+    result.current.adapter.search!("alice");
+    unmount();
+    await Promise.resolve();
+
+    expect(vi.getTimerCount()).toBe(0);
+    await vi.runAllTimersAsync();
+
+    expect(fetcher).not.toHaveBeenCalled();
+  });
+
+  it("keeps an in-flight fetch when the debounce changes", async () => {
+    let resolve!: (items: readonly Unstable_TriggerItem[]) => void;
+    const fetcher = vi.fn(
+      () =>
+        new Promise<readonly Unstable_TriggerItem[]>((r) => {
+          resolve = r;
+        }),
+    );
+    const { result, rerender } = renderHook(
+      (props) =>
+        unstable_useLiveCompletionAdapter(() => ({
+          fetcher,
+          debounceMs: props.value.debounceMs,
+        })),
+      { initialProps: { debounceMs: 0 } },
+    );
+
+    await act(async () => {
+      result.current.adapter.search!("alice");
+      await vi.advanceTimersByTimeAsync(0);
+    });
+    expect(fetcher).toHaveBeenCalledOnce();
+
+    await rerender({ debounceMs: 50 });
+
+    await nextTick();
+    await act(async () => resolve([item("alice")]));
+
+    expect(result.current.adapter.search!("alice")).toEqual([item("alice")]);
+    expect(result.current.isLoading).toBe(false);
+  });
+
+  it("replays a search queued while the adapter is hidden", async () => {
+    const fetcher = vi.fn(async () => []);
+    let committed!: ReturnType<typeof unstable_useLiveCompletionAdapter>;
+    const Harness = defineComponent({
+      setup() {
+        committed = unstable_useLiveCompletionAdapter({
+          fetcher,
+          debounceMs: 0,
+        });
+        return () => null;
+      },
+    });
+    const view = (blocked: boolean) =>
+      h(KeepAlive, null, { default: () => (blocked ? null : h(Harness)) });
+    const rendered = render(view(false));
+
+    await act(async () => rendered.rerender(view(true)));
+    committed.value.adapter.search!("alice");
+    await Promise.resolve();
+
+    expect(vi.getTimerCount()).toBe(0);
+    await act(async () => rendered.rerender(view(false)));
+    await act(async () => vi.advanceTimersByTimeAsync(0));
+
+    expect(fetcher).toHaveBeenCalledOnce();
+    expect(fetcher).toHaveBeenCalledWith("alice");
+  });
+
+  it("drops a hidden search superseded by a cached query", async () => {
+    const fetcher = vi.fn(async (query: string) => [item(query)]);
+    let committed!: ReturnType<typeof unstable_useLiveCompletionAdapter>;
+    const Harness = defineComponent({
+      setup() {
+        committed = unstable_useLiveCompletionAdapter({
+          fetcher,
+          debounceMs: 0,
+        });
+        return () => null;
+      },
+    });
+    const view = (blocked: boolean) =>
+      h(KeepAlive, null, { default: () => (blocked ? null : h(Harness)) });
+    const rendered = render(view(false));
+
+    await act(async () => {
+      committed.value.adapter.search!("alice");
+      await vi.advanceTimersByTimeAsync(0);
+    });
+    expect(committed.value.adapter.search!("alice")).toEqual([item("alice")]);
+
+    await act(async () => rendered.rerender(view(true)));
+    committed.value.adapter.search!("bob");
+    await Promise.resolve();
+    committed.value.adapter.search!("alice");
+    await Promise.resolve();
+
+    await act(async () => rendered.rerender(view(false)));
+    await act(async () => vi.advanceTimersByTimeAsync(0));
+
+    expect(fetcher).toHaveBeenCalledOnce();
+    expect(fetcher).toHaveBeenCalledWith("alice");
+  });
+
+  it("settles loading when a suspended adapter is shown again", async () => {
+    const fetcher = vi.fn(() => new Promise<never>(() => {}));
+    let committed!: ReturnType<typeof unstable_useLiveCompletionAdapter>;
+    const Harness = defineComponent({
+      setup() {
+        committed = unstable_useLiveCompletionAdapter({
+          fetcher,
+          debounceMs: 0,
+        });
+        return () =>
+          h(
+            "output",
+            { "data-testid": "status" },
+            String(committed.value.isLoading),
+          );
+      },
+    });
+    const view = (blocked: boolean) =>
+      h(KeepAlive, null, { default: () => (blocked ? null : h(Harness)) });
+    const rendered = render(view(false));
+
+    await act(async () => {
+      committed.value.adapter.search!("alice");
+      await vi.advanceTimersByTimeAsync(0);
+    });
+    expect(fetcher).toHaveBeenCalledOnce();
+    expect(rendered.getByTestId("status").textContent).toBe("true");
+
+    await act(async () => rendered.rerender(view(true)));
+    await act(async () => rendered.rerender(view(false)));
+
+    expect(rendered.getByTestId("status").textContent).toBe("false");
+  });
+
+  it("does not fetch when disabled and clears cached items", async () => {
+    const fetcher = vi.fn(async () => [item("a")]);
+    const { result, rerender } = renderHook(
+      (props) =>
+        unstable_useLiveCompletionAdapter(() => ({
+          fetcher,
+          enabled: props.value.enabled,
+          debounceMs: 0,
+        })),
+      { initialProps: { enabled: true } },
+    );
+
+    await act(async () => {
+      result.current.adapter.search!("ab");
+    });
+    await act(async () => {
+      await vi.advanceTimersByTimeAsync(0);
+    });
+    expect(result.current.adapter.search!("ab")).toEqual([item("a")]);
+
+    fetcher.mockClear();
+    await act(async () => {
+      await rerender({ enabled: false });
+      await nextTick();
+    });
+    expect(result.current.adapter.search!("ab")).toEqual([]);
+    await act(async () => {
+      await vi.advanceTimersByTimeAsync(10);
+    });
+    expect(fetcher).not.toHaveBeenCalled();
+    expect(result.current.isLoading).toBe(false);
+  });
+
+  it.each(["queued", "debounced"] as const)(
+    "cancels a %s search when disabled and allows searching after re-enabling",
+    async (phase) => {
+      const fetcher = vi.fn(async () => [item("alice")]);
+      const { result, rerender } = renderHook(
+        (props) =>
+          unstable_useLiveCompletionAdapter(() => ({
+            fetcher,
+            enabled: props.value.enabled,
+            debounceMs: 50,
+          })),
+        { initialProps: { enabled: true } },
+      );
+
+      if (phase === "debounced") {
+        await act(async () => {
+          result.current.adapter.search!("alice");
+        });
+        await rerender({ enabled: false });
+        await nextTick();
+      } else {
+        await act(async () => {
+          result.current.adapter.search!("alice");
+          await rerender({ enabled: false });
+          await nextTick();
+        });
+      }
+      await act(async () => {
+        await vi.advanceTimersByTimeAsync(50);
+      });
+
+      expect(fetcher).not.toHaveBeenCalled();
+      expect(result.current.adapter.search!("alice")).toEqual([]);
+      expect(result.current.isLoading).toBe(false);
+
+      await rerender({ enabled: true });
+
+      await nextTick();
+      await act(async () => {
+        result.current.adapter.search!("alice");
+        await vi.advanceTimersByTimeAsync(50);
+      });
+      expect(fetcher).toHaveBeenCalledExactlyOnceWith("alice");
+      expect(result.current.adapter.search!("alice")).toEqual([item("alice")]);
+      expect(result.current.isLoading).toBe(false);
+    },
+  );
+
+  it("drops a stale in-flight result when the query changes", async () => {
+    const resolvers: Record<
+      string,
+      (value: readonly Unstable_TriggerItem[]) => void
+    > = {};
+    const fetcher = vi.fn(
+      (q: string) =>
+        new Promise<readonly Unstable_TriggerItem[]>((r) => {
+          resolvers[q] = r;
+        }),
+    );
+    const { result } = renderHook(() =>
+      unstable_useLiveCompletionAdapter({ fetcher, debounceMs: 0 }),
+    );
+
+    await act(async () => {
+      result.current.adapter.search!("a");
+    });
+    await act(async () => {
+      await vi.advanceTimersByTimeAsync(0);
+    });
+    await act(async () => {
+      result.current.adapter.search!("ab");
+    });
+    await act(async () => {
+      await vi.advanceTimersByTimeAsync(0);
+    });
+    expect(fetcher).toHaveBeenCalledTimes(2);
+
+    await act(async () => {
+      resolvers["a"]!([item("a")]);
+    });
+    expect(result.current.adapter.search!("ab")).toEqual([]);
+
+    await act(async () => {
+      resolvers["ab"]!([item("ab")]);
+    });
+    expect(result.current.adapter.search!("ab")).toEqual([item("ab")]);
+  });
+
+  it("refreshes cached results when the fetcher cache key changes", async () => {
+    const fetcherA = vi.fn(async () => [item("workspace-a")]);
+    const fetcherB = vi.fn(async () => [item("workspace-b")]);
+    const { result, rerender } = renderHook(
+      (props) =>
+        unstable_useLiveCompletionAdapter(() => ({
+          fetcher: props.value.fetcher,
+          cacheKey: props.value.cacheKey,
+          debounceMs: 0,
+        })),
+      { initialProps: { fetcher: fetcherA, cacheKey: "workspace-a" } },
+    );
+
+    await act(async () => {
+      result.current.adapter.search!("alice");
+      await vi.advanceTimersByTimeAsync(0);
+    });
+    expect(result.current.adapter.search!("alice")).toEqual([
+      item("workspace-a"),
+    ]);
+
+    await act(async () => {
+      await rerender({ fetcher: fetcherB, cacheKey: "workspace-b" });
+      await nextTick();
+    });
+    expect(result.current.adapter.search!("alice")).toEqual([]);
+
+    await act(async () => {
+      await vi.advanceTimersByTimeAsync(0);
+    });
+    expect(fetcherB).toHaveBeenCalledWith("alice");
+    expect(result.current.adapter.search!("alice")).toEqual([
+      item("workspace-b"),
+    ]);
+  });
+
+  it("drops pending results after the fetcher cache key changes", async () => {
+    let resolveA!: (items: readonly Unstable_TriggerItem[]) => void;
+    const fetcherA = vi.fn(
+      () =>
+        new Promise<readonly Unstable_TriggerItem[]>((resolve) => {
+          resolveA = resolve;
+        }),
+    );
+    const fetcherB = vi.fn(async () => [item("workspace-b")]);
+    const { result, rerender } = renderHook(
+      (props) =>
+        unstable_useLiveCompletionAdapter(() => ({
+          fetcher: props.value.fetcher,
+          cacheKey: props.value.cacheKey,
+          debounceMs: 0,
+        })),
+      { initialProps: { fetcher: fetcherA, cacheKey: "workspace-a" } },
+    );
+
+    await act(async () => {
+      result.current.adapter.search!("alice");
+      await vi.advanceTimersByTimeAsync(0);
+    });
+    await act(async () => {
+      await rerender({ fetcher: fetcherB, cacheKey: "workspace-b" });
+      await nextTick();
+    });
+    await act(async () => {
+      result.current.adapter.search!("alice");
+      await vi.advanceTimersByTimeAsync(0);
+    });
+    await act(async () => {
+      resolveA([item("workspace-a")]);
+    });
+
+    expect(result.current.adapter.search!("alice")).toEqual([
+      item("workspace-b"),
+    ]);
+  });
+
+  it("keeps cached results when only the fetcher identity changes", async () => {
+    const first = vi.fn(async () => [item("alice")]);
+    const second = vi.fn(async () => [item("bob")]);
+    const { result, rerender } = renderHook(
+      (props) =>
+        unstable_useLiveCompletionAdapter(() => ({
+          fetcher: props.value.fetcher,
+          cacheKey: "workspace-a",
+          debounceMs: 0,
+        })),
+      { initialProps: { fetcher: first } },
+    );
+
+    await act(async () => {
+      result.current.adapter.search!("alice");
+      await vi.advanceTimersByTimeAsync(0);
+    });
+    expect(result.current.adapter.search!("alice")).toEqual([item("alice")]);
+
+    await act(async () => {
+      await rerender({ fetcher: second });
+      await nextTick();
+      await vi.advanceTimersByTimeAsync(0);
+    });
+    expect(second).not.toHaveBeenCalled();
+    expect(result.current.adapter.search!("alice")).toEqual([item("alice")]);
+  });
+
+  it("keeps pending queries scoped to the committed fetcher", async () => {
+    const fetcherA = vi.fn(async () => [item("workspace-a")]);
+    const fetcherB = vi.fn(async () => [item("workspace-b")]);
+    const interruptedRender = vi.fn();
+    const pending = new Promise<never>(() => {});
+    let adapter!: ReturnType<
+      typeof unstable_useLiveCompletionAdapter
+    >["value"]["adapter"];
+    const Block = defineComponent({
+      async setup() {
+        interruptedRender();
+        await pending;
+        return () => null;
+      },
+    });
+    const Harness = defineComponent(
+      (props: {
+        fetcher: typeof fetcherA;
+        cacheKey: string;
+        blocked: boolean;
+      }) => {
+        const result = unstable_useLiveCompletionAdapter(() => ({
+          fetcher: props.fetcher,
+          cacheKey: props.cacheKey,
+          debounceMs: 50,
+        }));
+        onMounted(() => {
+          adapter = result.value.adapter;
+        });
+        return () => (props.blocked ? h(Block) : null);
+      },
+      { props: ["fetcher", "cacheKey", "blocked"] },
+    );
+    const view = (
+      fetcher: typeof fetcherA,
+      cacheKey: string,
+      blocked: boolean,
+    ) =>
+      h(Suspense, null, {
+        default: () =>
+          h(Harness, {
+            key: blocked ? "pending" : "committed",
+            fetcher,
+            cacheKey,
+            blocked,
+          }),
+        fallback: () => null,
+      });
+    const rendered = render(view(fetcherA, "workspace-a", false));
+
+    await act(async () => {
+      adapter.search!("alice");
+      await vi.advanceTimersByTimeAsync(0);
+    });
+    await rendered.rerender(view(fetcherB, "workspace-b", true));
+    expect(interruptedRender).toHaveBeenCalled();
+    await act(async () => {
+      await vi.advanceTimersByTimeAsync(50);
+    });
+
+    expect(fetcherA).toHaveBeenCalledOnce();
+    expect(fetcherB).not.toHaveBeenCalled();
+  });
+
+  it("drops a pending result when only the cache key changes", async () => {
+    let resolveFirst!: (items: readonly Unstable_TriggerItem[]) => void;
+    const first = new Promise<readonly Unstable_TriggerItem[]>((resolve) => {
+      resolveFirst = resolve;
+    });
+    const fetcher = vi.fn(() => first);
+    const { result, rerender } = renderHook(
+      (props) =>
+        unstable_useLiveCompletionAdapter(() => ({
+          fetcher,
+          cacheKey: props.value.cacheKey,
+          debounceMs: 0,
+        })),
+      { initialProps: { cacheKey: "workspace-a" } },
+    );
+
+    await act(async () => {
+      result.current.adapter.search!("alice");
+      await vi.advanceTimersByTimeAsync(0);
+    });
+    expect(fetcher).toHaveBeenCalledTimes(1);
+
+    await act(async () => {
+      await rerender({ cacheKey: "workspace-b" });
+      await nextTick();
+    });
+    await act(async () => {
+      resolveFirst([item("workspace-a")]);
+    });
+
+    expect(result.current.isLoading).toBe(false);
+    expect(fetcher).toHaveBeenCalledTimes(1);
+    expect(result.current.adapter.search!("alice")).toEqual([]);
+  });
+
+  it("allows a failed query to be retried", async () => {
+    const fetcher = vi
+      .fn<(query: string) => Promise<readonly Unstable_TriggerItem[]>>()
+      .mockRejectedValueOnce(new Error("temporarily unavailable"))
+      .mockRejectedValueOnce(new Error("still unavailable"))
+      .mockResolvedValueOnce([item("alice")]);
+    const { result } = renderHook(() =>
+      unstable_useLiveCompletionAdapter({ fetcher, debounceMs: 0 }),
+    );
+
+    for (const attempt of [1, 2]) {
+      await act(async () => {
+        result.current.adapter.search!("alice");
+        await vi.advanceTimersByTimeAsync(0);
+      });
+      expect(fetcher).toHaveBeenCalledTimes(attempt);
+      expect(result.current.isLoading).toBe(false);
+    }
+
+    await act(async () => {
+      result.current.adapter.search!("alice");
+      await vi.advanceTimersByTimeAsync(0);
+    });
+    expect(fetcher).toHaveBeenCalledTimes(3);
+    expect(result.current.adapter.search!("alice")).toEqual([item("alice")]);
+  });
+
+  it("allows a synchronously failed query to be retried", async () => {
+    const fetcher = vi
+      .fn<(query: string) => Promise<readonly Unstable_TriggerItem[]>>()
+      .mockImplementationOnce(() => {
+        throw new Error("invalid request configuration");
+      })
+      .mockResolvedValueOnce([item("alice")]);
+    const { result } = renderHook(() =>
+      unstable_useLiveCompletionAdapter({ fetcher, debounceMs: 0 }),
+    );
+
+    await act(async () => {
+      result.current.adapter.search!("alice");
+      await vi.advanceTimersByTimeAsync(0);
+    });
+    expect(fetcher).toHaveBeenCalledTimes(1);
+    expect(result.current.isLoading).toBe(false);
+
+    await act(async () => {
+      result.current.adapter.search!("alice");
+      await vi.advanceTimersByTimeAsync(0);
+    });
+    expect(fetcher).toHaveBeenCalledTimes(2);
+    expect(result.current.adapter.search!("alice")).toEqual([item("alice")]);
+  });
+
+  it("does not automatically retry when search runs during every render", async () => {
+    const fetcher = vi
+      .fn<(query: string) => Promise<readonly Unstable_TriggerItem[]>>()
+      .mockRejectedValueOnce(new Error("temporarily unavailable"))
+      .mockImplementation(
+        () => new Promise<readonly Unstable_TriggerItem[]>(() => {}),
+      );
+    let completion!: ReturnType<typeof unstable_useLiveCompletionAdapter>;
+    render(
+      h(
+        defineComponent({
+          setup() {
+            completion = unstable_useLiveCompletionAdapter({
+              fetcher,
+              debounceMs: 0,
+            });
+            return () => {
+              completion.value.adapter.search!("alice");
+              return null;
+            };
+          },
+        }),
+      ),
+    );
+    const result = {
+      get current() {
+        return completion.value;
+      },
+    };
+
+    await act(async () => {
+      await vi.advanceTimersByTimeAsync(0);
+    });
+    expect(result.current.isLoading).toBe(false);
+
+    await act(async () => {
+      await vi.advanceTimersByTimeAsync(1_000);
+    });
+    expect(fetcher).toHaveBeenCalledTimes(1);
+  });
+
+  it("re-arms a failed query when its pending retry is interrupted", async () => {
+    const fetcher = vi
+      .fn<(query: string) => Promise<readonly Unstable_TriggerItem[]>>()
+      .mockRejectedValueOnce(new Error("temporarily unavailable"))
+      .mockImplementationOnce(
+        () => new Promise<readonly Unstable_TriggerItem[]>(() => {}),
+      )
+      .mockResolvedValueOnce([item("alice")]);
+    const { result } = renderHook(() =>
+      unstable_useLiveCompletionAdapter({ fetcher, debounceMs: 0 }),
+    );
+
+    await act(async () => {
+      result.current.adapter.search!("alice");
+      await vi.advanceTimersByTimeAsync(0);
+    });
+
+    await act(async () => {
+      result.current.adapter.search!("alice");
+      await vi.advanceTimersByTimeAsync(0);
+    });
+    expect(fetcher).toHaveBeenCalledTimes(2);
+
+    await act(async () => {
+      result.current.adapter.search!("alicex");
+    });
+    await act(async () => {
+      result.current.adapter.search!("alice");
+      await vi.advanceTimersByTimeAsync(0);
+    });
+
+    expect(fetcher).toHaveBeenCalledTimes(3);
+    expect(fetcher).toHaveBeenLastCalledWith("alice");
+    expect(result.current.adapter.search!("alice")).toEqual([item("alice")]);
+  });
+
+  it("re-arms a failed query when its retry is hidden", async () => {
+    const fetcher = vi
+      .fn<(query: string) => Promise<readonly Unstable_TriggerItem[]>>()
+      .mockRejectedValueOnce(new Error("temporarily unavailable"))
+      .mockImplementationOnce(() => new Promise(() => {}))
+      .mockResolvedValueOnce([item("alice")]);
+    let committed!: ReturnType<typeof unstable_useLiveCompletionAdapter>;
+    const Harness = defineComponent({
+      setup() {
+        committed = unstable_useLiveCompletionAdapter({
+          fetcher,
+          debounceMs: 0,
+        });
+        return () => null;
+      },
+    });
+    const view = (blocked: boolean) =>
+      h(KeepAlive, null, { default: () => (blocked ? null : h(Harness)) });
+    const rendered = render(view(false));
+
+    await act(async () => {
+      committed.value.adapter.search!("alice");
+      await vi.advanceTimersByTimeAsync(0);
+    });
+    expect(fetcher).toHaveBeenCalledOnce();
+
+    await act(async () => {
+      committed.value.adapter.search!("alice");
+      await vi.advanceTimersByTimeAsync(0);
+    });
+    expect(fetcher).toHaveBeenCalledTimes(2);
+
+    await act(async () => rendered.rerender(view(true)));
+    await act(async () => rendered.rerender(view(false)));
+    await act(async () => {
+      committed.value.adapter.search!("alice");
+      await vi.advanceTimersByTimeAsync(0);
+    });
+
+    expect(fetcher).toHaveBeenCalledTimes(3);
+  });
+
+  it("drops an in-flight fetch when the query returns to a cached value", async () => {
+    const resolvers: Record<
+      string,
+      (value: readonly Unstable_TriggerItem[]) => void
+    > = {};
+    const fetcher = vi.fn(
+      (q: string) =>
+        new Promise<readonly Unstable_TriggerItem[]>((r) => {
+          resolvers[q] = r;
+        }),
+    );
+    const { result } = renderHook(() =>
+      unstable_useLiveCompletionAdapter({ fetcher, debounceMs: 0 }),
+    );
+
+    await act(async () => {
+      result.current.adapter.search!("ab");
+    });
+    await act(async () => {
+      await vi.advanceTimersByTimeAsync(0);
+    });
+    await act(async () => {
+      resolvers["ab"]!([item("ab")]);
+    });
+    expect(result.current.adapter.search!("ab")).toEqual([item("ab")]);
+
+    // type "abc": a fetch goes in flight
+    await act(async () => {
+      result.current.adapter.search!("abc");
+    });
+    await act(async () => {
+      await vi.advanceTimersByTimeAsync(0);
+    });
+    expect(resolvers["abc"]).toBeTypeOf("function");
+
+    // delete back to the cached "ab": the in-flight "abc" must be invalidated
+    await act(async () => {
+      result.current.adapter.search!("ab");
+    });
+    await act(async () => {
+      resolvers["abc"]!([item("abc")]);
+    });
+    expect(result.current.adapter.search!("ab")).toEqual([item("ab")]);
+  });
+});