@solana/react 7.0.0 → 7.1.0-canary-20260812160611

package/src/query/__tests__/useSubscriptionQuery-test.browser.tsx

@@ -86,23 +86,23 @@ function makeStreamFactory<T>() {
 function createFakeStore<T>(): {
     connectCount: () => number;
     emit: (state: ReactiveState<T>) => void;
-    resetCount: () => number;
     store: ReactiveStreamStore<T>;
     withSignalArg: () => AbortSignal | undefined;
 } {
     let state: ReactiveState<T> = { data: undefined, error: undefined, status: 'idle' };
     const listeners = new Set<() => void>();
     let connects = 0;
-    let resets = 0;
     let withSignalArg: AbortSignal | undefined;
     const store: ReactiveStreamStore<T> = {
         connect: jest.fn().mockImplementation(() => {
             throw new Error('not implemented');
         }),
         getState: () => state,
-        reset: () => {
-            resets++;
-        },
+        // The hook connects via `withSignal(signal).connect()` and relies on aborting that signal for
+        // teardown — it must never `reset()` the store. Throw so an accidental reset fails loudly.
+        reset: jest.fn().mockImplementation(() => {
+            throw new Error('not implemented');
+        }),
         subscribe: (callback: () => void) => {
             listeners.add(callback);
             return () => {
@@ -124,7 +124,6 @@ function createFakeStore<T>(): {
             state = next;
             listeners.forEach(l => l());
         },
-        resetCount: () => resets,
         store,
         withSignalArg: () => withSignalArg,
     };
@@ -142,7 +141,6 @@ function makeStoreSource<T>() {
     };
     return {
         emit: (state: ReactiveState<T>) => latest!.emit(state),
-        resetCount: () => latest!.resetCount(),
         source,
         withSignalArg: () => latest!.withSignalArg(),
     };
@@ -337,7 +335,7 @@ describe('useSubscriptionQuery', () => {
             await waitFor(() => expect(result.current.error).toBe(boom));
         });
 
-        it('resets the store on unmount', async () => {
+        it('aborts the store connection on unmount', async () => {
             const src = makeStoreSource<number>();
             const { unmount } = renderHook(() => useSubscriptionQuery(['store-teardown'], src.source), {
                 wrapper: createWrapper(),
@@ -345,7 +343,7 @@ describe('useSubscriptionQuery', () => {
             await waitFor(() => expect(src.withSignalArg()).toBeInstanceOf(AbortSignal));
 
             unmount();
-            await waitFor(() => expect(src.resetCount()).toBeGreaterThan(0));
+            await waitFor(() => expect(src.withSignalArg()!.aborted).toBe(true));
         });
 
         it('does not connect when the source is null', async () => {

package/src/query/__tests__/useTrackedDataQuery-test.browser.tsx

@@ -4,7 +4,7 @@ import {
     isSolanaError,
     ReactiveActionSource,
     ReactiveStreamSource,
-    SOLANA_ERROR__REACT__SUBSCRIPTION_CLOSED_WITHOUT_ERROR,
+    SOLANA_ERROR__SUBSCRIBABLE__STREAM_CLOSED_WITHOUT_ERROR,
     SolanaRpcResponse,
 } from '@solana/kit';
 import { QueryClient, QueryClientProvider } from '@tanstack/react-query';
@@ -212,7 +212,7 @@ describe('useTrackedDataQuery', () => {
 
         await act(async () => fake.error(undefined));
         await waitFor(() =>
-            expect(isSolanaError(result.current.error, SOLANA_ERROR__REACT__SUBSCRIPTION_CLOSED_WITHOUT_ERROR)).toBe(
+            expect(isSolanaError(result.current.error, SOLANA_ERROR__SUBSCRIBABLE__STREAM_CLOSED_WITHOUT_ERROR)).toBe(
                 true,
             ),
         );
@@ -293,7 +293,7 @@ describe('useTrackedDataQuery', () => {
         await waitFor(() => expect(fake.activeConnections()).toBe(1));
     });
 
-    it('resets the store and aborts the connection on unmount', async () => {
+    it('aborts the connection on unmount', async () => {
         const fake = makeSpec();
         const { unmount } = renderHook(() => useTrackedDataQuery(['teardown'], fake.spec), { wrapper: makeWrapper() });
         await waitFor(() => expect(fake.activeConnections()).toBe(1));

package/src/query/useSubscriptionQuery.ts

@@ -1,4 +1,4 @@
-import type { ReactiveStreamSource } from '@solana/kit';
+import { bridgeStoreToAsyncIterable, type ReactiveStreamSource } from '@solana/kit';
 import {
     experimental_streamedQuery,
     type QueryFunction,
@@ -12,7 +12,6 @@ import { useCallback } from 'react';
 
 import { useLatest } from '../useLatest';
 import type { UseRequestOptions } from '../useRequest';
-import { bridgeStoreToAsyncIterable } from './bridgeStoreToAsyncIterable';
 
 /**
  * Options accepted by {@link useSubscriptionQuery}: every option `@tanstack/react-query`'s `useQuery`
@@ -50,10 +49,10 @@ export type UseSubscriptionQueryOptions<T, TError = unknown, TData = T> = Omit<
  * Because the stream never settles, the query stays in `fetchStatus: 'fetching'` for the
  * subscription's whole life — `isFetching` is permanently `true` and `isLoading` flips false
  * after the first notification. Read `data` / `error` / `status` and ignore `isFetching` for
- * subscriptions. `result.refetch()` reconnects: TanStack aborts the old signal (ending the prior
- * iterable, which resets its store) and opens a fresh stream. Fire and forget — for a never-ending
- * stream the returned promise never resolves, so don't `await refetch()` (a click handler that does
- * will hang forever).
+ * subscriptions. `result.refetch()` reconnects: TanStack aborts the old signal (tearing the prior
+ * stream's connection down) and opens a fresh stream. Fire and forget — for a never-ending stream
+ * the returned promise never resolves, so don't `await refetch()` (a click handler that does will
+ * hang forever).
  *
  * Defaults, all overridable: `retry: false` (the underlying reactive store owns retry/backoff),
  * `staleTime: Infinity` and `refetchOnWindowFocus: false` (a focus revalidation must not tear down
@@ -133,7 +132,10 @@ export function useSubscriptionQuery<T, TError = unknown, TData = T>(
                     if (typeof current === 'function') {
                         return current(combinedSignal);
                     }
-                    return bridgeStoreToAsyncIterable(current.reactiveStore(), combinedSignal);
+                    const store = current.reactiveStore();
+                    // reset not needed, the connection tears down and the store gets GCed after abort
+                    store.withSignal(combinedSignal).connect();
+                    return bridgeStoreToAsyncIterable(store, combinedSignal);
                 },
             })(context),
         [getAbortSignalRef, sourceRef],

package/src/query/useTrackedDataQuery.ts

@@ -1,4 +1,8 @@
-import { createReactiveStoreWithInitialValueAndSlotTracking, type SolanaRpcResponse } from '@solana/kit';
+import {
+    bridgeStoreToAsyncIterable,
+    createReactiveStoreWithInitialValueAndSlotTracking,
+    type SolanaRpcResponse,
+} from '@solana/kit';
 import {
     experimental_streamedQuery,
     type QueryFunction,
@@ -14,7 +18,6 @@ import { useCallback } from 'react';
 import { useLatest } from '../useLatest';
 import type { UseRequestOptions } from '../useRequest';
 import type { TrackedDataSpec } from '../useTrackedData';
-import { bridgeStoreToAsyncIterable } from './bridgeStoreToAsyncIterable';
 
 /**
  * Options accepted by {@link useTrackedDataQuery}: every option `@tanstack/react-query`'s `useQuery`
@@ -53,8 +56,8 @@ export type UseTrackedDataQueryOptions<TItem, TError = unknown, TData = SolanaRp
  * Because the subscription never settles, the query stays in `fetchStatus: 'fetching'` for its whole
  * life — `isFetching` is permanently `true` and `isLoading` flips false after the first value. Read
  * `data` / `error` / `status` and ignore `isFetching`. `result.refetch()` reconnects: TanStack aborts
- * the old signal (ending the prior iterable, which resets its store) and re-runs both the initial RPC
- * fetch and the subscription. Fire and forget — for a never-ending stream the returned promise never
+ * the old signal (tearing the prior stream's connection down) and re-runs both the initial RPC fetch
+ * and the subscription. Fire and forget — for a never-ending stream the returned promise never
  * resolves, so don't `await refetch()`.
  *
  * Defaults, all overridable: `retry: false` (the underlying reactive store owns retry/backoff),
@@ -152,6 +155,8 @@ export function useTrackedDataQuery<
                     // signal (when present) so aborting either tears the stream down.
                     const combinedSignal = userSignal ? AbortSignal.any([signal, userSignal]) : signal;
                     const store = createReactiveStoreWithInitialValueAndSlotTracking(current);
+                    // reset not needed, the connection tears down and the store gets GCed after abort
+                    store.withSignal(combinedSignal).connect();
                     // Refuse any envelope older than the slot the cache already holds. A fresh store
                     // (e.g. after a remount) tracks slots from scratch, so without this it could
                     // overwrite the cached value with an older one from a lagging RPC node.

package/src/swr/__tests__/useRequestSWR-test.browser.tsx

@@ -246,10 +246,9 @@ describe('useRequestSWR', () => {
             const withSignal = jest.fn(() => ({ dispatchAsync }));
             const source = stubActionSource<string>({ dispatchAsync, withSignal });
             const ctrl = new AbortController();
-            renderHook(
-                () => useRequestSWR(['source-signal-identity'], source, { getAbortSignal: () => ctrl.signal }),
-                { wrapper },
-            );
+            renderHook(() => useRequestSWR(['source-signal-identity'], source, { getAbortSignal: () => ctrl.signal }), {
+                wrapper,
+            });
             await waitFor(() => expect(withSignal).toHaveBeenCalledWith(ctrl.signal));
         });
 
@@ -321,8 +320,7 @@ describe('useRequestSWR', () => {
                 reactiveStore: () => createReactiveActionStore<[], string>(() => Promise.resolve(value)),
             });
             const { result, rerender } = renderHook(
-                ({ source }: { source: ReactiveActionSource<string> }) =>
-                    useRequestSWR(['source-latest'], source),
+                ({ source }: { source: ReactiveActionSource<string> }) => useRequestSWR(['source-latest'], source),
                 { initialProps: { source: sourceFor('a') }, wrapper },
             );
             await waitFor(() => expect(result.current.data).toBe('a'));

package/src/useAirdrop.ts

@@ -0,0 +1,45 @@
+import type { Address, ClientWithAirdrop, Lamports, Signature } from '@solana/kit';
+
+import { type ActionResult, useAction } from './useAction';
+
+/**
+ * Requests an airdrop of SOL to an address, as a reactive action.
+ *
+ * Wraps `client.airdrop` with {@link useAction}: each `dispatch(address, amount)` runs the airdrop
+ * with a fresh `AbortSignal` and tracks its lifecycle through React state. Calling `dispatch` again
+ * while a previous airdrop is in flight aborts the first. This is a great fit for a devnet or
+ * localnet "fund this account" button, where the `isRunning` / `data` / `error` tracking drives the
+ * UI directly.
+ *
+ * The airdrop capability is typically available on test networks (devnet, testnet) and local
+ * validators. Some implementations (e.g. LiteSVM) update balances directly without sending a
+ * transaction, in which case the resolved `data` is `undefined` rather than a {@link Signature}.
+ *
+ * @param client - A client with an airdrop plugin installed (`ClientWithAirdrop`).
+ * @returns An {@link ActionResult} whose `dispatch`/`dispatchAsync` take the recipient `address` and
+ *   the `amount` of lamports, and resolve with the transaction {@link Signature}, or `undefined`
+ *   when the airdrop was performed without a transaction.
+ *
+ * @example
+ * ```tsx
+ * import { useAirdrop } from '@solana/react';
+ * import { lamports } from '@solana/kit';
+ *
+ * function AirdropButton({ client, address }) {
+ *     const { dispatch, isRunning } = useAirdrop(client);
+ *     return (
+ *         <button disabled={isRunning} onClick={() => dispatch(address, lamports(1_000_000_000n))}>
+ *             {isRunning ? 'Airdropping…' : 'Airdrop 1 SOL'}
+ *         </button>
+ *     );
+ * }
+ * ```
+ *
+ * @see {@link ActionResult}
+ * @see {@link useAction}
+ */
+export function useAirdrop(
+    client: ClientWithAirdrop,
+): ActionResult<[address: Address, amount: Lamports], Signature | undefined> {
+    return useAction((abortSignal, address: Address, amount: Lamports) => client.airdrop(address, amount, abortSignal));
+}

package/src/useClient.ts

@@ -8,12 +8,13 @@ import { ClientContext } from './ClientProvider';
  * {@link SolanaError} with code {@link SOLANA_ERROR__REACT__MISSING_PROVIDER} if no provider is
  * mounted in the ancestor tree.
  *
- * Defaults to the base {@link Client} shape. Callers who know a specific plugin is installed may
- * widen the type via the generic — this is a pure cast with no runtime capability check, so reach
- * for {@link useClientCapability} when a missing plugin should fail loudly at mount instead of
- * surfacing later as `undefined`.
+ * Pass the shape of your client through the generic (typically the `AppClient` type you export
+ * alongside the client) so every installed capability is typed at the call site. This is a pure
+ * cast with no runtime capability check, so reach for {@link useClientCapability} when a missing
+ * plugin should fail loudly at mount instead of surfacing later as `undefined`.
  *
- * @typeParam TClient - The shape the client is expected to satisfy. Pure type assertion.
+ * @typeParam TClient - The shape the client is expected to satisfy. Pure type assertion, so this
+ *   must always be supplied — the hook can't infer it from its (absent) arguments.
  *
  * @example
  * ```tsx
@@ -29,7 +30,7 @@ import { ClientContext } from './ClientProvider';
  * @see {@link ClientProvider}
  * @see {@link useClientCapability}
  */
-export function useClient<TClient extends object = object>(): Client<TClient> {
+export function useClient<TClient extends object>(): Client<TClient> {
     const client = React.useContext(ClientContext);
     if (client == null) {
         throw new SolanaError(SOLANA_ERROR__REACT__MISSING_PROVIDER, { hookName: 'useClient' });

package/src/useIdentity.ts

@@ -0,0 +1,47 @@
+import type { ClientWithIdentity, ClientWithSubscribeToIdentity, TransactionSigner } from '@solana/kit';
+import { useCallback, useSyncExternalStore } from 'react';
+
+const NOOP_UNSUBSCRIBE = () => {};
+
+/**
+ * Reads `client.identity` and re-renders whenever it changes, returning `undefined` while no
+ * identity is available.
+ *
+ * The identity is the {@link TransactionSigner} representing the wallet whose on-chain assets the
+ * application is acting upon.
+ *
+ * When the client advertises {@link ClientWithSubscribeToIdentity},
+ * this hook subscribes via `client.subscribeToIdentity` so the returned value always reflects the
+ * latest identity. For a client whose identity is fixed for its lifetime, the hook falls back to a
+ * no-op subscription and simply reads the value once.
+ *
+ * @param client - A client with an identity plugin installed. If it also advertises
+ *   `subscribeToIdentity`, the hook tracks changes reactively.
+ * @returns The current `client.identity` signer, or `undefined` if no identity is currently
+ *   available.
+ *
+ * @example
+ * ```tsx
+ * const identity = useIdentity(client);
+ * return <span>{identity ? `Signed in as ${identity.address}` : 'Signed out'}</span>;
+ * ```
+ *
+ * @see {@link usePayer}
+ */
+export function useIdentity(
+    client: ClientWithIdentity & Partial<ClientWithSubscribeToIdentity>,
+): TransactionSigner | undefined {
+    const subscribe = useCallback(
+        (onStoreChange: () => void) =>
+            client.subscribeToIdentity ? client.subscribeToIdentity(onStoreChange) : NOOP_UNSUBSCRIBE,
+        [client],
+    );
+    const getSnapshot = useCallback((): TransactionSigner | undefined => {
+        try {
+            return client.identity;
+        } catch {
+            return undefined;
+        }
+    }, [client]);
+    return useSyncExternalStore(subscribe, getSnapshot, getSnapshot);
+}

package/src/usePayer.ts

@@ -0,0 +1,44 @@
+import type { ClientWithPayer, ClientWithSubscribeToPayer, TransactionSigner } from '@solana/kit';
+import { useCallback, useSyncExternalStore } from 'react';
+
+const NOOP_UNSUBSCRIBE = () => {};
+
+/**
+ * Reads `client.payer` and re-renders whenever it changes, returning `undefined` while no payer is
+ * available.
+ *
+ * The payer is the {@link TransactionSigner} a client uses to sign and pay for transactions by
+ * default.
+ *
+ * When the client advertises {@link ClientWithSubscribeToPayer}, this hook subscribes via
+ * `client.subscribeToPayer` so the returned value always reflects the latest payer. For a client
+ * whose payer is fixed for its lifetime, the hook falls back to a no-op subscription and simply
+ * reads the value once.
+ *
+ * @param client - A client with a payer plugin installed. If it also advertises
+ *   `subscribeToPayer`, the hook tracks changes reactively.
+ * @returns The current `client.payer` signer, or `undefined` if no payer is currently available.
+ *
+ * @example
+ * ```tsx
+ * const payer = usePayer(client);
+ * return <span>{payer ? `Paying with ${payer.address}` : 'No payer'}</span>;
+ * ```
+ *
+ * @see {@link useIdentity}
+ */
+export function usePayer(client: ClientWithPayer & Partial<ClientWithSubscribeToPayer>): TransactionSigner | undefined {
+    const subscribe = useCallback(
+        (onStoreChange: () => void) =>
+            client.subscribeToPayer ? client.subscribeToPayer(onStoreChange) : NOOP_UNSUBSCRIBE,
+        [client],
+    );
+    const getSnapshot = useCallback((): TransactionSigner | undefined => {
+        try {
+            return client.payer;
+        } catch {
+            return undefined;
+        }
+    }, [client]);
+    return useSyncExternalStore(subscribe, getSnapshot, getSnapshot);
+}

package/src/usePlanTransaction.ts

@@ -0,0 +1,30 @@
+import type { ClientWithTransactionPlanning, InstructionPlanInput, SingleTransactionPlan } from '@solana/kit';
+
+import { type ActionResult, useAction } from './useAction';
+
+/**
+ * Plans a single transaction from an instruction input, as a reactive action.
+ *
+ * Wraps `client.planTransaction` with {@link useAction}: each `dispatch(input)` runs the plan with a
+ * fresh `AbortSignal` and tracks its lifecycle through React state. Calling `dispatch` again while a
+ * previous plan is in flight aborts the first. Use this when you expect all instructions to fit in a
+ * single transaction; reach for {@link usePlanTransactions} when they might need splitting.
+ *
+ * @param client - A client with a transaction-planning plugin installed.
+ * @returns An {@link ActionResult} whose `dispatch`/`dispatchAsync` take the
+ *   {@link InstructionPlanInput} and resolve with the planned transaction message.
+ *
+ * @example
+ * ```tsx
+ * const { dispatch, data, isRunning } = usePlanTransaction(client);
+ * <button disabled={isRunning} onClick={() => dispatch(instructions)}>Plan</button>
+ * ```
+ *
+ * @see {@link usePlanTransactions}
+ * @see {@link useSendTransaction}
+ */
+export function usePlanTransaction(
+    client: ClientWithTransactionPlanning,
+): ActionResult<[input: InstructionPlanInput], SingleTransactionPlan['message']> {
+    return useAction((abortSignal, input: InstructionPlanInput) => client.planTransaction(input, { abortSignal }));
+}

package/src/usePlanTransactions.ts

@@ -0,0 +1,31 @@
+import type { ClientWithTransactionPlanning, InstructionPlanInput, TransactionPlan } from '@solana/kit';
+
+import { type ActionResult, useAction } from './useAction';
+
+/**
+ * Plans one or more transactions from an instruction input, as a reactive action.
+ *
+ * Wraps `client.planTransactions` with {@link useAction}: each `dispatch(input)` runs the plan with a
+ * fresh `AbortSignal` and tracks its lifecycle through React state. Calling `dispatch` again while a
+ * previous plan is in flight aborts the first. Use this when the instructions might be split across
+ * multiple transactions due to size limits; reach for {@link usePlanTransaction} for the single-
+ * transaction case.
+ *
+ * @param client - A client with a transaction-planning plugin installed.
+ * @returns An {@link ActionResult} whose `dispatch`/`dispatchAsync` take the
+ *   {@link InstructionPlanInput} and resolve with the full {@link TransactionPlan}.
+ *
+ * @example
+ * ```tsx
+ * const { dispatch, data, isRunning } = usePlanTransactions(client);
+ * <button disabled={isRunning} onClick={() => dispatch(instructions)}>Plan</button>
+ * ```
+ *
+ * @see {@link usePlanTransaction}
+ * @see {@link useSendTransactions}
+ */
+export function usePlanTransactions(
+    client: ClientWithTransactionPlanning,
+): ActionResult<[input: InstructionPlanInput], TransactionPlan> {
+    return useAction((abortSignal, input: InstructionPlanInput) => client.planTransactions(input, { abortSignal }));
+}

package/src/useSendTransaction.ts

@@ -0,0 +1,34 @@
+import type { ClientWithTransactionSending, SuccessfulSingleTransactionPlanResult } from '@solana/kit';
+
+import { type ActionResult, useAction } from './useAction';
+
+type SendTransactionInput = Parameters<ClientWithTransactionSending['sendTransaction']>[0];
+
+/**
+ * Sends a single transaction to the network, as a reactive action.
+ *
+ * Wraps `client.sendTransaction` with {@link useAction}, which handles signing, submission, and
+ * confirmation. Each `dispatch(input)` runs with a fresh `AbortSignal` and tracks its lifecycle
+ * through React state; calling `dispatch` again while a previous send is in flight aborts the first.
+ * Accepts flexible input: instructions, an instruction plan, a single transaction message, or a
+ * single transaction plan. Use {@link useSendTransactions} when the work may span multiple
+ * transactions.
+ *
+ * @param client - A client with a transaction-sending plugin installed.
+ * @returns An {@link ActionResult} whose `dispatch`/`dispatchAsync` take the input and resolve with
+ *   the {@link SuccessfulSingleTransactionPlanResult}.
+ *
+ * @example
+ * ```tsx
+ * const { dispatch, data, isRunning } = useSendTransaction(client);
+ * <button disabled={isRunning} onClick={() => dispatch(instructions)}>Send</button>
+ * ```
+ *
+ * @see {@link useSendTransactions}
+ * @see {@link usePlanTransaction}
+ */
+export function useSendTransaction(
+    client: ClientWithTransactionSending,
+): ActionResult<[input: SendTransactionInput], SuccessfulSingleTransactionPlanResult> {
+    return useAction((abortSignal, input: SendTransactionInput) => client.sendTransaction(input, { abortSignal }));
+}

package/src/useSendTransactions.ts

@@ -0,0 +1,33 @@
+import type { ClientWithTransactionSending, TransactionPlanResult } from '@solana/kit';
+
+import { type ActionResult, useAction } from './useAction';
+
+type SendTransactionsInput = Parameters<ClientWithTransactionSending['sendTransactions']>[0];
+
+/**
+ * Sends one or more transactions to the network, as a reactive action.
+ *
+ * Wraps `client.sendTransactions` with {@link useAction}, which handles signing, submission, and
+ * confirmation. Each `dispatch(input)` runs with a fresh `AbortSignal` and tracks its lifecycle
+ * through React state; calling `dispatch` again while a previous send is in flight aborts the first.
+ * Accepts flexible input: instructions, an instruction plan, or a transaction plan. Use
+ * {@link useSendTransaction} for the single-transaction case.
+ *
+ * @param client - A client with a transaction-sending plugin installed.
+ * @returns An {@link ActionResult} whose `dispatch`/`dispatchAsync` take the input and resolve with
+ *   the {@link TransactionPlanResult} for all transactions.
+ *
+ * @example
+ * ```tsx
+ * const { dispatch, data, isRunning } = useSendTransactions(client);
+ * <button disabled={isRunning} onClick={() => dispatch(instructions)}>Send</button>
+ * ```
+ *
+ * @see {@link useSendTransaction}
+ * @see {@link usePlanTransactions}
+ */
+export function useSendTransactions(
+    client: ClientWithTransactionSending,
+): ActionResult<[input: SendTransactionsInput], TransactionPlanResult> {
+    return useAction((abortSignal, input: SendTransactionsInput) => client.sendTransactions(input, { abortSignal }));
+}

package/dist/types/query/bridgeStoreToAsyncIterable.d.ts

@@ -1,39 +0,0 @@
-import { type ReactiveStreamStore } from '@solana/kit';
-/**
- * Bridges a {@link ReactiveStreamStore} into the `AsyncIterable` contract that TanStack Query's
- * `experimental_streamedQuery` consumes. The TanStack twin of `bridgeStoreToSwr`: where the SWR
- * bridge pushes each store update into a `next` callback, this one exposes a *pull*-based async
- * iterable, since `streamedQuery` drives the stream by `for await`-ing it.
- *
- * Subscribes to the store, `connect()`s it bound to `signal`, and yields its unified lifecycle:
- * - `loaded` → yields the value, unless an optional `shouldYield` predicate rejects it. Latest-wins:
- *   if several notifications land between pulls, only the most recent unconsumed value is yielded (a
- *   subscription consumer wants the freshest state, not a backlog).
- * - `error` → throws, so the `streamedQuery` queryFn rejects and the query surfaces `error`.
- *   Substitutes a {@link SOLANA_ERROR__REACT__SUBSCRIPTION_CLOSED_WITHOUT_ERROR} sentinel when the
- *   store reports an error with a nullish payload (mirrors `bridgeStoreToSwr`). An error takes
- *   precedence over a buffered value: if a `loaded` value is still pending when an `error` arrives,
- *   that value is dropped and the error propagates (once errored, stop yielding).
- * - `signal` aborts → ends the iterable cleanly (no error). An abort means teardown — unmount, a
- *   superseding refetch, or a caller-supplied deadline — so the subscription stops rather than
- *   failing.
- *
- * Whichever way the iterable ends — value exhaustion, error, or abort — the `finally` block
- * unsubscribes and `reset()`s the store, aborting the active connection. The store the caller hands
- * in is owned by this bridge for the iterable's lifetime.
- *
- * @typeParam T - The notification type emitted by the store.
- *
- * @param store - An idle stream store to drive.
- * @param signal - The abort signal to bind the connection to (TanStack's query-cancellation signal,
- *   optionally combined with a caller-supplied one). Aborting it tears the stream down.
- * @param shouldYield - Optional gate run against each `loaded` value before it is yielded. Return
- *   `false` to drop the value. When omitted, every loaded value is yielded.
- *
- * @returns An `AsyncIterable<T>` that yields each store value until the store errors or `signal`
- *   aborts.
- *
- * @internal
- */
-export declare function bridgeStoreToAsyncIterable<T>(store: ReactiveStreamStore<T>, signal: AbortSignal, shouldYield?: (value: T) => boolean): AsyncIterable<T>;
-//# sourceMappingURL=bridgeStoreToAsyncIterable.d.ts.map

package/dist/types/query/bridgeStoreToAsyncIterable.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"bridgeStoreToAsyncIterable.d.ts","sourceRoot":"","sources":["../../../src/query/bridgeStoreToAsyncIterable.ts"],"names":[],"mappings":"AAAA,OAAO,EACH,KAAK,mBAAmB,EAG3B,MAAM,aAAa,CAAC;AAErB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmCG;AACH,wBAAgB,0BAA0B,CAAC,CAAC,EACxC,KAAK,EAAE,mBAAmB,CAAC,CAAC,CAAC,EAC7B,MAAM,EAAE,WAAW,EACnB,WAAW,CAAC,EAAE,CAAC,KAAK,EAAE,CAAC,KAAK,OAAO,GACpC,aAAa,CAAC,CAAC,CAAC,CA0DlB"}