@assistant-ui/react-google-adk 0.0.35 → 0.0.36

package/src/useAdkRuntime.ts

@@ -4,6 +4,7 @@ import {
   useMemo,
   useRef,
   useState,
+  useSyncExternalStore,
 } from "react";
 import {
   pickExternalStoreSharedOptions,
@@ -22,6 +23,8 @@ import {
   createAbortableThreadLoad,
   createCloudThreadListAdapterCreateFallback,
   isRecord,
+  RunLeases,
+  type RunLease,
 } from "@assistant-ui/core/internal";
 import {
   useCloudThreadListAdapter,
@@ -72,6 +75,7 @@ export type UseAdkRuntimeOptions = ExternalStoreSharedOptions & {
    */
   onThreadIdChange?: ((threadId: string | undefined) => void) | undefined;
   autoCancelPendingToolCalls?: boolean | undefined;
+  /** @deprecated Experimental since 2025-01-03. Not scheduled for removal; the API may change in any release. */
   unstable_allowCancellation?: boolean | undefined;
   getCheckpointId?: (
     threadId: string,
@@ -106,6 +110,11 @@ export type UseAdkRuntimeOptions = ExternalStoreSharedOptions & {
       }
     | undefined;
   cloud?: AssistantCloud | undefined;
+  /**
+   * Stable identity for the account or workspace owning Cloud runtime state.
+   * Provide it from the first render and change it when that scope changes.
+   */
+  scopeId?: string | undefined;
   /**
    * A `RemoteThreadListAdapter` to use instead of the cloud adapter.
    * Use with `createAdkSessionAdapter` for ADK session-backed persistence.
@@ -181,6 +190,7 @@ const useAdkRuntimeImpl = (options: UseAdkRuntimeOptions) => {
   }, []);
 
   const {
+    controller,
     messages,
     stateDelta,
     agentInfo,
@@ -206,6 +216,22 @@ const useAdkRuntimeImpl = (options: UseAdkRuntimeOptions) => {
     loadRef.current = load;
   }, [load]);
   const [loadController] = useState(createAbortableThreadLoad);
+  const initialLoadRef = useRef<{
+    promise: Promise<void>;
+    active: boolean;
+    snapshot: AdkThreadSnapshot | undefined;
+  } | null>(null);
+  const waitForInitialLoad = () => {
+    const load = initialLoadRef.current;
+    if (!load) return undefined;
+    return load.promise.then(() => ({
+      active:
+        load.active &&
+        (!threadListItem ||
+          aui.threads.getState().mainThreadId === threadListItem.getState().id),
+      snapshot: load.snapshot,
+    }));
+  };
   const messagesRef = useRef(messages);
   useInsertionEffect(() => {
     messagesRef.current = messages;
@@ -241,9 +267,25 @@ const useAdkRuntimeImpl = (options: UseAdkRuntimeOptions) => {
   useInsertionEffect(() => {
     isRunningRef.current = effectiveIsRunning;
   }, [effectiveIsRunning]);
-  const runGenerationRef = useRef(0);
+  const [runLeases] = useState(() => new RunLeases());
+  const reloadLookupRef = useRef<{
+    lease: RunLease;
+    beforeReload: AdkThreadSnapshot;
+  } | null>(null);
+
+  const runExclusive = async (
+    run: (isCurrent: () => boolean) => Promise<void>,
+  ) => {
+    const lease = runLeases.begin();
+    try {
+      setIsRunning(true);
+      await run(lease.isCurrent);
+    } finally {
+      if (lease.isCurrent()) setIsRunning(false);
+    }
+  };
 
-  const handleSendMessage = async (
+  const handleSendMessage = (
     msgs: AdkMessage[],
     config: AdkSendMessageConfig,
   ) => {
@@ -257,13 +299,13 @@ const useAdkRuntimeImpl = (options: UseAdkRuntimeOptions) => {
           }
         : config;
 
-    const generation = ++runGenerationRef.current;
-    try {
-      setIsRunning(true);
-      await sendMessage(msgs, continuationConfig);
-    } finally {
-      if (runGenerationRef.current === generation) setIsRunning(false);
-    }
+    return runExclusive(() => sendMessage(msgs, continuationConfig));
+  };
+
+  const stopRun = () => {
+    runLeases.invalidate();
+    setIsRunning(false);
+    cancel();
   };
 
   const { approvals: toolApprovals, key: toolApprovalsKey } =
@@ -315,43 +357,20 @@ const useAdkRuntimeImpl = (options: UseAdkRuntimeOptions) => {
     adkMessagesRef.current = messages;
   }, [messages]);
 
-  const stagedMessagesRef = useRef(
-    new Map<
-      string,
-      {
-        message: AdkMessage & { id: string };
-        runConfig: AppendMessage["runConfig"];
-      }
-    >(),
+  const stagedMessageCount = useSyncExternalStore(
+    controller.subscribe,
+    controller.getStagedMessageCount,
+    controller.getStagedMessageCount,
   );
-  const [stagedMessageCount, setStagedMessageCount] = useState(0);
   const hasStagedMessages = stagedMessageCount > 0;
 
-  const getStagedRun = (parentId: string | null) => {
-    if (!parentId || !stagedMessagesRef.current.has(parentId)) return null;
-
-    const staged: AdkMessage[] = [];
-    for (const message of adkMessagesRef.current) {
-      if (message.id && stagedMessagesRef.current.has(message.id)) {
-        staged.push(stagedMessagesRef.current.get(message.id)!.message);
-      }
-      if (message.id === parentId) break;
-    }
-
-    return {
-      messages: staged,
-      runConfig: stagedMessagesRef.current.get(parentId)!.runConfig,
-    };
-  };
-
   const stageUserMessage = (msg: AppendMessage) => {
     const stagedMessage = toAdkUserMessage(msg);
-    stagedMessagesRef.current.set(stagedMessage.id, {
-      message: stagedMessage,
-      runConfig: msg.runConfig,
+    controller.dispatch({
+      type: "staged.stage",
+      entry: { message: stagedMessage, runConfig: msg.runConfig },
     });
-    setStagedMessageCount(stagedMessagesRef.current.size);
-    const nextMessages = [...adkMessagesRef.current, stagedMessage];
+    const nextMessages = [...controller.getState().messages, stagedMessage];
     adkMessagesRef.current = nextMessages;
     setMessages(nextMessages);
   };
@@ -394,7 +413,14 @@ const useAdkRuntimeImpl = (options: UseAdkRuntimeOptions) => {
               messagesRef.current !== messagesAtLoadStart)
           )
             return;
+          reloadLookupRef.current = null;
           applySnapshot(snapshot);
+          messagesRef.current = snapshot.messages;
+          adkMessagesRef.current = snapshot.messages;
+          longRunningToolIdsRef.current = snapshot.longRunningToolIds ?? [];
+          if (purpose === "initial" && initialLoadRef.current) {
+            initialLoadRef.current.snapshot = snapshot;
+          }
         },
         onSettled: () => {
           setIsLoadingThread(false);
@@ -408,11 +434,26 @@ const useAdkRuntimeImpl = (options: UseAdkRuntimeOptions) => {
   );
 
   useReplaySafeEffect(() => {
-    runLoad();
+    let release!: () => void;
+    const barrier = {
+      promise: new Promise<void>((resolve) => {
+        release = resolve;
+      }),
+      active: true,
+      snapshot: undefined as AdkThreadSnapshot | undefined,
+    };
+    initialLoadRef.current = barrier;
+    const settle = () => {
+      if (initialLoadRef.current === barrier) initialLoadRef.current = null;
+      release();
+    };
+    void runLoad().then(settle, settle);
     return () => {
+      barrier.active = false;
       // Whatever is current, not this effect's own controller: a refetch swaps
       // the ref, and one in flight at unmount must be aborted too.
       loadController.abort();
+      settle();
       setIsLoadingThread(false);
     };
   }, [threadListItem]);
@@ -435,9 +476,17 @@ const useAdkRuntimeImpl = (options: UseAdkRuntimeOptions) => {
       authRequests,
       escalated,
       messageMetadata,
-      send: handleSendMessage,
+      send: (messages, config) => {
+        const initialLoad = waitForInitialLoad();
+        if (!initialLoad) return handleSendMessage(messages, config);
+        return initialLoad.then(({ active }) =>
+          active ? handleSendMessage(messages, config) : undefined,
+        );
+      },
     }),
     onNew: async (msg) => {
+      const initialLoad = await waitForInitialLoad();
+      if (initialLoad && !initialLoad.active) return;
       if (!(msg.startRun ?? msg.role === "user")) {
         stageUserMessage(msg);
         return;
@@ -445,7 +494,11 @@ const useAdkRuntimeImpl = (options: UseAdkRuntimeOptions) => {
 
       const cancellations =
         autoCancelPendingToolCalls !== false
-          ? getPendingCancellations(messages, longRunningToolIds)
+          ? getPendingCancellations(
+              initialLoad?.snapshot?.messages ?? messagesRef.current,
+              initialLoad?.snapshot?.longRunningToolIds ??
+                longRunningToolIdsRef.current,
+            )
           : [];
 
       return handleSendMessage(
@@ -462,6 +515,9 @@ const useAdkRuntimeImpl = (options: UseAdkRuntimeOptions) => {
     },
     onEdit: getCheckpointId
       ? async (msg) => {
+          const initialLoad = waitForInitialLoad();
+          if (initialLoad && !(await initialLoad).active) return;
+          stopRun();
           const truncated = truncateAdkMessages(
             threadMessagesRef.current,
             msg.parentId,
@@ -469,44 +525,41 @@ const useAdkRuntimeImpl = (options: UseAdkRuntimeOptions) => {
           replaceMessages(truncated);
           if (!(msg.startRun ?? msg.role === "user")) {
             const stagedMessage = toAdkUserMessage(msg);
-            stagedMessagesRef.current.set(stagedMessage.id, {
-              message: stagedMessage,
-              runConfig: msg.runConfig,
+            controller.dispatch({
+              type: "staged.stage",
+              entry: { message: stagedMessage, runConfig: msg.runConfig },
             });
-            setStagedMessageCount(stagedMessagesRef.current.size);
             const nextMessages = [...truncated, stagedMessage];
             adkMessagesRef.current = nextMessages;
             setMessages(nextMessages);
             return;
           }
+          const editedMessage = toAdkUserMessage(msg);
+          setMessages([...truncated, editedMessage]);
           const externalId = aui.threadListItem.getState().externalId;
-          const checkpointId = externalId
-            ? await getCheckpointId(externalId, truncated)
-            : null;
-          return handleSendMessage(
-            [
-              {
-                id: generateId(),
-                type: "human",
-                content: getMessageContent(msg),
-              },
-            ],
-            {
+          return runExclusive(async (isCurrent) => {
+            const checkpointId = externalId
+              ? await getCheckpointId(externalId, truncated)
+              : null;
+            if (!isCurrent()) return;
+            await sendMessage([editedMessage], {
               runConfig: msg.runConfig,
               ...(checkpointId && { checkpointId }),
-            },
-          );
+            });
+          });
         }
       : undefined,
     ...(getCheckpointId || hasStagedMessages
       ? {
           onReload: async (parentId, config) => {
-            const stagedRun = getStagedRun(parentId);
+            const initialLoad = waitForInitialLoad();
+            if (initialLoad && !(await initialLoad).active) return;
+            const stagedRun = controller.getStagedRun(parentId);
             if (stagedRun) {
-              for (const message of stagedRun.messages) {
-                stagedMessagesRef.current.delete(message.id);
-              }
-              setStagedMessageCount(stagedMessagesRef.current.size);
+              controller.dispatch({
+                type: "staged.unstage",
+                ids: stagedRun.messages.map((message) => message.id!),
+              });
               return handleSendMessage(stagedRun.messages, {
                 runConfig: config.runConfig ?? stagedRun.runConfig,
               });
@@ -515,18 +568,48 @@ const useAdkRuntimeImpl = (options: UseAdkRuntimeOptions) => {
             if (!getCheckpointId)
               throw new Error("Runtime does not support reloading messages.");
 
+            stopRun();
+            const beforeReload: AdkThreadSnapshot = {
+              messages: adkMessagesRef.current,
+              longRunningToolIds,
+              toolConfirmations,
+              authRequests,
+              escalated,
+              messageMetadata,
+              stateDelta,
+              artifactDelta,
+              agentInfo,
+            };
             const truncated = truncateAdkMessages(
               threadMessagesRef.current,
               parentId,
             );
             replaceMessages(truncated);
             const externalId = aui.threadListItem.getState().externalId;
-            const checkpointId = externalId
-              ? await getCheckpointId(externalId, truncated)
-              : null;
-            return handleSendMessage([], {
-              runConfig: config.runConfig,
-              ...(checkpointId && { checkpointId }),
+            return runExclusive(async (isCurrent) => {
+              const lookup = {
+                lease: runLeases.current(),
+                beforeReload,
+              };
+              reloadLookupRef.current = lookup;
+              let checkpointId: string | null;
+              try {
+                checkpointId = externalId
+                  ? await getCheckpointId(externalId, truncated)
+                  : null;
+              } catch (error) {
+                if (isCurrent() && reloadLookupRef.current === lookup)
+                  applySnapshot(beforeReload);
+                throw error;
+              } finally {
+                if (reloadLookupRef.current === lookup)
+                  reloadLookupRef.current = null;
+              }
+              if (!isCurrent()) return;
+              await sendMessage([], {
+                runConfig: config.runConfig,
+                ...(checkpointId && { checkpointId }),
+              });
             });
           },
         }
@@ -538,6 +621,8 @@ const useAdkRuntimeImpl = (options: UseAdkRuntimeOptions) => {
       isError,
       artifact,
     }) => {
+      const initialLoad = waitForInitialLoad();
+      if (initialLoad && !(await initialLoad).active) return;
       await handleSendMessage(
         [
           {
@@ -554,6 +639,8 @@ const useAdkRuntimeImpl = (options: UseAdkRuntimeOptions) => {
       );
     },
     onRespondToToolApproval: async (options) => {
+      const initialLoad = waitForInitialLoad();
+      if (initialLoad && !(await initialLoad).active) return;
       await handleSendMessage(
         [
           toAdkToolConfirmationReply(
@@ -566,7 +653,14 @@ const useAdkRuntimeImpl = (options: UseAdkRuntimeOptions) => {
     },
     onCancel: unstable_allowCancellation
       ? async () => {
-          cancel();
+          const lookup = reloadLookupRef.current;
+          const beforeReload = lookup?.lease.isCurrent()
+            ? lookup.beforeReload
+            : undefined;
+          stopRun();
+          // A reload stopped before it sent leaves the ADK session holding the
+          // turn it removed, so the thread shows that turn again.
+          if (beforeReload) applySnapshot(beforeReload);
         }
       : undefined,
     ...(load !== undefined && {
@@ -579,6 +673,7 @@ const useAdkRuntimeImpl = (options: UseAdkRuntimeOptions) => {
 
 export const useAdkRuntime = ({
   cloud,
+  scopeId,
   sessionAdapter,
   create,
   delete: deleteFn,
@@ -589,6 +684,7 @@ export const useAdkRuntime = ({
   const cloudAdapter = useCloudThreadListAdapter({
     sdk: ADK_SDK,
     cloud,
+    scopeId,
     create: createCloudThreadListAdapterCreateFallback(
       create,
       aui.threadListItem,

package/src/useAdkRuntimeApproval.test.tsx

@@ -1,3 +1,4 @@
+/** @vitest-environment jsdom */
 import { act, renderHook } from "@testing-library/react";
 import { afterEach, describe, expect, it, vi } from "vitest";
 import type {
@@ -7,13 +8,19 @@ import type {
   ThreadMessage,
   ToolCallMessagePart,
 } from "@assistant-ui/core";
-import type { AdkMessage, AdkSendMessageConfig } from "./types";
+import type {
+  AdkMessage,
+  AdkSendMessageConfig,
+  AdkThreadSnapshot,
+} from "./types";
 
 const mocks = vi.hoisted(() => {
   const threadListItem = {
     source: null as object | null,
+    id: "thread-a",
     externalId: undefined as string | undefined,
     getState: () => ({
+      id: threadListItem.id,
       externalId: threadListItem.externalId,
     }),
     initialize: vi.fn(),
@@ -29,6 +36,14 @@ const mocks = vi.hoisted(() => {
   };
 });
 
+const mockController = {
+  subscribe: () => () => {},
+  getStagedMessageCount: () => 0,
+  getState: () => ({ messages: mocks.messages }),
+  dispatch: vi.fn(),
+  getStagedRun: () => null,
+};
+
 vi.mock("@assistant-ui/core/react", async (importOriginal) => ({
   ...(await importOriginal<typeof import("@assistant-ui/core/react")>()),
   useCloudThreadListAdapter: () => ({}),
@@ -44,6 +59,9 @@ vi.mock("@assistant-ui/store", async (importOriginal) => ({
   ...(await importOriginal<typeof import("@assistant-ui/store")>()),
   useAui: () => ({
     threadListItem: mocks.threadListItem,
+    threads: {
+      getState: () => ({ mainThreadId: mocks.threadListItem.id }),
+    },
   }),
 }));
 
@@ -62,6 +80,7 @@ vi.mock("./useAdkMessages", async (importOriginal) => {
       }
     };
     return {
+      controller: mockController,
       messages: mocks.messages,
       stateDelta: {},
       agentInfo: {},
@@ -105,6 +124,10 @@ type RuntimeAdapter = {
   onRespondToToolApproval?: (
     options: RespondToToolApprovalOptions,
   ) => Promise<void> | void;
+  onReload?: (
+    parentId: string | null,
+    config: { runConfig?: AppendMessage["runConfig"] },
+  ) => Promise<void> | void;
   onRefetchThread?: () => Promise<void> | void;
 };
 
@@ -161,6 +184,69 @@ afterEach(() => {
 });
 
 describe("useAdkRuntime tool approvals", () => {
+  it.each([
+    "reload",
+    "tool result",
+    "approval response",
+    "extras send",
+  ] as const)("waits for the initial load before %s", async (route) => {
+    let resolveLoad!: (snapshot: AdkThreadSnapshot) => void;
+    const pendingLoad = new Promise<AdkThreadSnapshot>((resolve) => {
+      resolveLoad = resolve;
+    });
+    const load = vi.fn(() => pendingLoad);
+    mocks.threadListItem.source = {};
+    mocks.threadListItem.externalId = "thread-a";
+    renderHook(() =>
+      useAdkRuntime({
+        stream: vi.fn(),
+        load,
+        getCheckpointId: vi.fn(async () => null),
+      }),
+    );
+    expect(load).toHaveBeenCalledOnce();
+
+    let action: Promise<void>;
+    switch (route) {
+      case "reload":
+        action = Promise.resolve(latestAdapter().onReload!(null, {}));
+        break;
+      case "tool result":
+        action = Promise.resolve(
+          latestAdapter().onAddToolResult!({
+            messageId: "ai-1",
+            toolCallId: "tool-a",
+            toolName: "lookup",
+            result: { value: "done" },
+            isError: false,
+          }),
+        );
+        break;
+      case "approval response":
+        action = Promise.resolve(
+          latestAdapter().onRespondToToolApproval!({
+            approvalId: CONFIRMATION_CALL,
+            approved: true,
+          }),
+        );
+        break;
+      case "extras send":
+        action = latestAdapter().extras.send(
+          [{ id: "new-user", type: "human", content: "new question" }],
+          {},
+        );
+    }
+    void action.catch(() => {});
+    await Promise.resolve();
+    expect(mocks.sendMessage).not.toHaveBeenCalled();
+
+    await act(async () => {
+      resolveLoad({ messages: [makeConfirmationRequest()] });
+      await action;
+    });
+    expect(mocks.sendMessage).toHaveBeenCalledOnce();
+  });
+
   it("resumes a delayed tool result with its originating run config", async () => {
     const runConfigA = { custom: { model: "model-a" } };
     const runConfigB = { custom: { model: "model-b" } };

package/dist/raceWithAbortSignal.d.ts

@@ -1,2 +0,0 @@
-export declare const raceWithAbortSignal: <T>(signal: AbortSignal | undefined, operation: () => T | PromiseLike<T>) => Promise<T>;
-//# sourceMappingURL=raceWithAbortSignal.d.ts.map

package/dist/raceWithAbortSignal.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"raceWithAbortSignal.d.ts","sourceRoot":"","sources":["../src/raceWithAbortSignal.ts"],"names":[],"mappings":"AAOA,eAAO,MAAM,mBAAmB,GAAI,CAAC,EACnC,QAAQ,WAAW,GAAG,SAAS,EAC/B,WAAW,MAAM,CAAC,GAAG,WAAW,CAAC,CAAC,CAAC,KAClC,OAAO,CAAC,CAAC,CAqCX,CAAC"}

package/dist/raceWithAbortSignal.js

@@ -1,45 +0,0 @@
-//#region src/raceWithAbortSignal.ts
-const getAbortReason = (signal) => {
-	if (signal.reason !== void 0) return signal.reason;
-	const error = /* @__PURE__ */ new Error("The operation was aborted");
-	error.name = "AbortError";
-	return error;
-};
-const raceWithAbortSignal = (signal, operation) => {
-	if (!signal) try {
-		return Promise.resolve(operation());
-	} catch (error) {
-		return Promise.reject(error);
-	}
-	if (signal.aborted) return Promise.reject(getAbortReason(signal));
-	return new Promise((resolve, reject) => {
-		let settled = false;
-		const cleanup = () => signal.removeEventListener("abort", handleAbort);
-		const resolveOnce = (value) => {
-			if (settled) return;
-			settled = true;
-			cleanup();
-			resolve(value);
-		};
-		const rejectOnce = (error) => {
-			if (settled) return;
-			settled = true;
-			cleanup();
-			reject(error);
-		};
-		const handleAbort = () => rejectOnce(getAbortReason(signal));
-		signal.addEventListener("abort", handleAbort, { once: true });
-		let result;
-		try {
-			result = operation();
-		} catch (error) {
-			rejectOnce(error);
-			return;
-		}
-		Promise.resolve(result).then(resolveOnce, rejectOnce);
-	});
-};
-//#endregion
-export { raceWithAbortSignal };
-
-//# sourceMappingURL=raceWithAbortSignal.js.map

package/dist/raceWithAbortSignal.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"raceWithAbortSignal.js","names":[],"sources":["../src/raceWithAbortSignal.ts"],"sourcesContent":["const getAbortReason = (signal: AbortSignal): unknown => {\n  if (signal.reason !== undefined) return signal.reason;\n  const error = new Error(\"The operation was aborted\");\n  error.name = \"AbortError\";\n  return error;\n};\n\nexport const raceWithAbortSignal = <T>(\n  signal: AbortSignal | undefined,\n  operation: () => T | PromiseLike<T>,\n): Promise<T> => {\n  if (!signal) {\n    try {\n      return Promise.resolve(operation());\n    } catch (error) {\n      return Promise.reject(error);\n    }\n  }\n  if (signal.aborted) return Promise.reject(getAbortReason(signal));\n\n  return new Promise<T>((resolve, reject) => {\n    let settled = false;\n    const cleanup = () => signal.removeEventListener(\"abort\", handleAbort);\n    const resolveOnce = (value: T) => {\n      if (settled) return;\n      settled = true;\n      cleanup();\n      resolve(value);\n    };\n    const rejectOnce = (error: unknown) => {\n      if (settled) return;\n      settled = true;\n      cleanup();\n      reject(error);\n    };\n    const handleAbort = () => rejectOnce(getAbortReason(signal));\n\n    signal.addEventListener(\"abort\", handleAbort, { once: true });\n    let result: T | PromiseLike<T>;\n    try {\n      result = operation();\n    } catch (error) {\n      rejectOnce(error);\n      return;\n    }\n    Promise.resolve(result).then(resolveOnce, rejectOnce);\n  });\n};\n"],"mappings":";AAAA,MAAM,kBAAkB,WAAiC;CACvD,IAAI,OAAO,WAAW,KAAA,GAAW,OAAO,OAAO;CAC/C,MAAM,wBAAQ,IAAI,MAAM,2BAA2B;CACnD,MAAM,OAAO;CACb,OAAO;AACT;AAEA,MAAa,uBACX,QACA,cACe;CACf,IAAI,CAAC,QACH,IAAI;EACF,OAAO,QAAQ,QAAQ,UAAU,CAAC;CACpC,SAAS,OAAO;EACd,OAAO,QAAQ,OAAO,KAAK;CAC7B;CAEF,IAAI,OAAO,SAAS,OAAO,QAAQ,OAAO,eAAe,MAAM,CAAC;CAEhE,OAAO,IAAI,SAAY,SAAS,WAAW;EACzC,IAAI,UAAU;EACd,MAAM,gBAAgB,OAAO,oBAAoB,SAAS,WAAW;EACrE,MAAM,eAAe,UAAa;GAChC,IAAI,SAAS;GACb,UAAU;GACV,QAAQ;GACR,QAAQ,KAAK;EACf;EACA,MAAM,cAAc,UAAmB;GACrC,IAAI,SAAS;GACb,UAAU;GACV,QAAQ;GACR,OAAO,KAAK;EACd;EACA,MAAM,oBAAoB,WAAW,eAAe,MAAM,CAAC;EAE3D,OAAO,iBAAiB,SAAS,aAAa,EAAE,MAAM,KAAK,CAAC;EAC5D,IAAI;EACJ,IAAI;GACF,SAAS,UAAU;EACrB,SAAS,OAAO;GACd,WAAW,KAAK;GAChB;EACF;EACA,QAAQ,QAAQ,MAAM,CAAC,CAAC,KAAK,aAAa,UAAU;CACtD,CAAC;AACH"}

package/src/raceWithAbortSignal.test.ts

@@ -1,73 +0,0 @@
-import { describe, expect, it, vi } from "vitest";
-import { raceWithAbortSignal } from "./raceWithAbortSignal";
-
-describe("raceWithAbortSignal", () => {
-  it("invokes the operation synchronously without a signal", async () => {
-    const order: string[] = [];
-
-    const result = raceWithAbortSignal(undefined, () => {
-      order.push("operation");
-      return "done";
-    });
-    order.push("after");
-
-    expect(order).toEqual(["operation", "after"]);
-    await expect(result).resolves.toBe("done");
-  });
-
-  it("converts a synchronous operation error to a rejection", async () => {
-    const error = new Error("failed");
-
-    const result = raceWithAbortSignal(undefined, () => {
-      throw error;
-    });
-
-    await expect(result).rejects.toBe(error);
-  });
-
-  it("rejects a pending operation with the abort reason", async () => {
-    const controller = new AbortController();
-    const reason = new Error("cancelled");
-    let resolveOperation!: (value: string) => void;
-    const operation = new Promise<string>((resolve) => {
-      resolveOperation = resolve;
-    });
-
-    const result = raceWithAbortSignal(controller.signal, () => operation);
-    controller.abort(reason);
-
-    await expect(result).rejects.toBe(reason);
-    resolveOperation("late result");
-  });
-
-  it("rejects before invoking an operation for an already aborted signal", async () => {
-    const controller = new AbortController();
-    const reason = new Error("already cancelled");
-    const operation = vi.fn(() => "done");
-    controller.abort(reason);
-
-    const result = raceWithAbortSignal(controller.signal, operation);
-
-    await expect(result).rejects.toBe(reason);
-    expect(operation).not.toHaveBeenCalled();
-  });
-
-  it("removes the abort listener after the operation settles", async () => {
-    const controller = new AbortController();
-    const removeEventListener = vi.spyOn(
-      controller.signal,
-      "removeEventListener",
-    );
-    const result = raceWithAbortSignal(controller.signal, () => "done");
-
-    await expect(result).resolves.toBe("done");
-    expect(removeEventListener).toHaveBeenCalledOnce();
-    expect(removeEventListener).toHaveBeenCalledWith(
-      "abort",
-      expect.any(Function),
-    );
-
-    controller.abort(new Error("late abort"));
-    await expect(result).resolves.toBe("done");
-  });
-});