@vue-solana/vue 2.0.0 → 2.2.0

package/dist/useSolanaClient.d.ts

@@ -1,10 +1,11 @@
 import * as _solana_kit from '@solana/kit';
 
 declare function useSolanaClient(): {
-    client: _solana_kit.Client<_solana_kit.ExtendedClient<object, {
+    client: _solana_kit.Client<{
         rpc: _solana_kit.Rpc<_solana_kit.RequestAirdropApi & _solana_kit.GetAccountInfoApi & _solana_kit.GetAgGenesisCertApi & _solana_kit.GetBalanceApi & _solana_kit.GetBlockApi & _solana_kit.GetBlockCommitmentApi & _solana_kit.GetBlockHeightApi & _solana_kit.GetBlockProductionApi & _solana_kit.GetBlocksApi & _solana_kit.GetBlocksWithLimitApi & _solana_kit.GetBlockTimeApi & _solana_kit.GetClusterNodesApi & _solana_kit.GetEpochInfoApi & _solana_kit.GetEpochScheduleApi & _solana_kit.GetFeeForMessageApi & _solana_kit.GetFirstAvailableBlockApi & _solana_kit.GetGenesisHashApi & _solana_kit.GetHealthApi & _solana_kit.GetHighestSnapshotSlotApi & _solana_kit.GetIdentityApi & _solana_kit.GetInflationGovernorApi & _solana_kit.GetInflationRateApi & _solana_kit.GetInflationRewardApi & _solana_kit.GetLargestAccountsApi & _solana_kit.GetLatestBlockhashApi & _solana_kit.GetLeaderScheduleApi & _solana_kit.GetMaxRetransmitSlotApi & _solana_kit.GetMaxShredInsertSlotApi & _solana_kit.GetMinimumBalanceForRentExemptionApi & _solana_kit.GetMultipleAccountsApi & _solana_kit.GetProgramAccountsApi & _solana_kit.GetRecentPerformanceSamplesApi & _solana_kit.GetRecentPrioritizationFeesApi & _solana_kit.GetSignaturesForAddressApi & _solana_kit.GetSignatureStatusesApi & _solana_kit.GetSlotApi & _solana_kit.GetSlotLeaderApi & _solana_kit.GetSlotLeadersApi & _solana_kit.GetStakeMinimumDelegationApi & _solana_kit.GetSupplyApi & _solana_kit.GetTokenAccountBalanceApi & _solana_kit.GetTokenAccountsByDelegateApi & _solana_kit.GetTokenAccountsByOwnerApi & _solana_kit.GetTokenLargestAccountsApi & _solana_kit.GetTokenSupplyApi & _solana_kit.GetTransactionApi & _solana_kit.GetTransactionCountApi & _solana_kit.GetTransactionsForAddressApi & _solana_kit.GetVersionApi & _solana_kit.GetVoteAccountsApi & _solana_kit.IsBlockhashValidApi & _solana_kit.MinimumLedgerSlotApi & _solana_kit.SendTransactionApi & _solana_kit.SimulateTransactionApi>;
         rpcSubscriptions: _solana_kit.RpcSubscriptions<_solana_kit.SolanaRpcSubscriptionsApi>;
-    }>>;
+        airdrop: (address: _solana_kit.Address, amount: _solana_kit.Lamports, abortSignal?: AbortSignal) => Promise<_solana_kit.Signature | undefined>;
+    }>;
     rpc: _solana_kit.Rpc<_solana_kit.RequestAirdropApi & _solana_kit.GetAccountInfoApi & _solana_kit.GetAgGenesisCertApi & _solana_kit.GetBalanceApi & _solana_kit.GetBlockApi & _solana_kit.GetBlockCommitmentApi & _solana_kit.GetBlockHeightApi & _solana_kit.GetBlockProductionApi & _solana_kit.GetBlocksApi & _solana_kit.GetBlocksWithLimitApi & _solana_kit.GetBlockTimeApi & _solana_kit.GetClusterNodesApi & _solana_kit.GetEpochInfoApi & _solana_kit.GetEpochScheduleApi & _solana_kit.GetFeeForMessageApi & _solana_kit.GetFirstAvailableBlockApi & _solana_kit.GetGenesisHashApi & _solana_kit.GetHealthApi & _solana_kit.GetHighestSnapshotSlotApi & _solana_kit.GetIdentityApi & _solana_kit.GetInflationGovernorApi & _solana_kit.GetInflationRateApi & _solana_kit.GetInflationRewardApi & _solana_kit.GetLargestAccountsApi & _solana_kit.GetLatestBlockhashApi & _solana_kit.GetLeaderScheduleApi & _solana_kit.GetMaxRetransmitSlotApi & _solana_kit.GetMaxShredInsertSlotApi & _solana_kit.GetMinimumBalanceForRentExemptionApi & _solana_kit.GetMultipleAccountsApi & _solana_kit.GetProgramAccountsApi & _solana_kit.GetRecentPerformanceSamplesApi & _solana_kit.GetRecentPrioritizationFeesApi & _solana_kit.GetSignaturesForAddressApi & _solana_kit.GetSignatureStatusesApi & _solana_kit.GetSlotApi & _solana_kit.GetSlotLeaderApi & _solana_kit.GetSlotLeadersApi & _solana_kit.GetStakeMinimumDelegationApi & _solana_kit.GetSupplyApi & _solana_kit.GetTokenAccountBalanceApi & _solana_kit.GetTokenAccountsByDelegateApi & _solana_kit.GetTokenAccountsByOwnerApi & _solana_kit.GetTokenLargestAccountsApi & _solana_kit.GetTokenSupplyApi & _solana_kit.GetTransactionApi & _solana_kit.GetTransactionCountApi & _solana_kit.GetTransactionsForAddressApi & _solana_kit.GetVersionApi & _solana_kit.GetVoteAccountsApi & _solana_kit.IsBlockhashValidApi & _solana_kit.MinimumLedgerSlotApi & _solana_kit.SendTransactionApi & _solana_kit.SimulateTransactionApi>;
 };
 

package/dist/useSolanaClient.mjs

@@ -1,3 +1,4 @@
-export { u as useSolanaClient } from './shared/vue.BaFrF2PF.mjs';
-import './shared/vue.CnUlZSe8.mjs';
+export { u as useSolanaClient } from './shared/vue.Mxc8w6Qk.mjs';
+import './shared/vue.CQh3AUE8.mjs';
 import 'vue';
+import './shared/vue.D_P5SqqD.mjs';

package/dist/useSubscription.cjs

@@ -0,0 +1,9 @@
+'use strict';
+
+const useSubscription = require('./shared/vue.l3UCdN7z.cjs');
+require('@vue-solana/core/errors');
+require('vue');
+
+
+
+exports.useSubscription = useSubscription.useSubscription;

package/dist/useSubscription.d.cts

@@ -0,0 +1,70 @@
+import { SolanaError } from '@vue-solana/core/errors';
+import { ReactiveStreamStore } from '@vue-solana/core/kit';
+import { ComputedRef, Ref } from 'vue';
+
+type UseSubscriptionStatus = "loading" | "loaded" | "error" | "disabled";
+/**
+ * A subscription source accepted by `useSubscription`:
+ *
+ * - a Kit reactive stream source such as `PendingRpcSubscriptionsRequest`
+ *   (for example `rpcSubscriptions.accountNotifications(address)`),
+ * - a `ref`/`computed` of a source or `null` to disable, or
+ * - `null` to disable outright.
+ */
+type UseSubscriptionSource<TResult> = {
+    reactiveStore: () => ReactiveStreamStore<TResult>;
+} | Ref<{
+    reactiveStore: () => ReactiveStreamStore<TResult>;
+} | null | undefined> | null | undefined;
+interface UseSubscriptionOptions {
+    /**
+     * Returns a caller-provided `AbortSignal` per connection (for example
+     * `AbortSignal.timeout(30_000)`), composed with the per-connection signal by
+     * the underlying store. Aborting it fails the connection with the abort
+     * reason without touching other state. Read fresh from the latest render,
+     * so inline closures need no callback wrapping.
+     */
+    getAbortSignal?: (connection: number) => AbortSignal | null | undefined;
+    /**
+     * Called when the subscription transitions into `error`.
+     */
+    onError?: (error: unknown) => void;
+}
+/** Per-connection abort overrides for `reconnect()`. */
+type UseSubscriptionReconnectOptions = {
+    /**
+     * Applies only this signal to the connection, bypassing `getAbortSignal`.
+     * Passing `undefined` (or an empty options object) applies no caller signal
+     * for that connection; call `reconnect()` with no argument to keep the
+     * `getAbortSignal` factory behavior.
+     */
+    abortSignal?: AbortSignal;
+};
+interface UseSubscriptionReturn<TResult> {
+    data: ComputedRef<TResult | undefined>;
+    error: ComputedRef<SolanaError | null>;
+    /** Re-opens the connection. `reconnect({ abortSignal })` overrides `getAbortSignal`. */
+    reconnect: (options?: UseSubscriptionReconnectOptions) => void;
+    status: ComputedRef<UseSubscriptionStatus>;
+}
+/**
+ * Live data from RPC subscriptions and other reactive stream sources.
+ *
+ * Accepts a Kit reactive stream source (duck-typed on `reactiveStore()`),
+ * bridges its `{ subscribe, getState }` contract into Vue reactive state, and
+ * tears the connection down when the component unmounts.
+ *
+ * Status set: `loading` | `loaded` | `error` | `disabled`.
+ *
+ * - A `null` source disables the subscription and clears state.
+ * - `reconnect()` re-opens the connection with stale-while-revalidate: the
+ *   last known `data` stays visible until fresh data arrives.
+ * - Errors preserve the last known `data`; only the first error per connection
+ *   window is captured (matching the underlying store's contract).
+ * - Changing a ref/computed source tears down the previous subscription and
+ *   connects to the new one.
+ */
+declare function useSubscription<TResult>(source: UseSubscriptionSource<TResult>, options?: UseSubscriptionOptions): UseSubscriptionReturn<TResult>;
+
+export { useSubscription };
+export type { UseSubscriptionOptions, UseSubscriptionReconnectOptions, UseSubscriptionReturn, UseSubscriptionSource, UseSubscriptionStatus };

package/dist/useSubscription.d.mts

@@ -0,0 +1,70 @@
+import { SolanaError } from '@vue-solana/core/errors';
+import { ReactiveStreamStore } from '@vue-solana/core/kit';
+import { ComputedRef, Ref } from 'vue';
+
+type UseSubscriptionStatus = "loading" | "loaded" | "error" | "disabled";
+/**
+ * A subscription source accepted by `useSubscription`:
+ *
+ * - a Kit reactive stream source such as `PendingRpcSubscriptionsRequest`
+ *   (for example `rpcSubscriptions.accountNotifications(address)`),
+ * - a `ref`/`computed` of a source or `null` to disable, or
+ * - `null` to disable outright.
+ */
+type UseSubscriptionSource<TResult> = {
+    reactiveStore: () => ReactiveStreamStore<TResult>;
+} | Ref<{
+    reactiveStore: () => ReactiveStreamStore<TResult>;
+} | null | undefined> | null | undefined;
+interface UseSubscriptionOptions {
+    /**
+     * Returns a caller-provided `AbortSignal` per connection (for example
+     * `AbortSignal.timeout(30_000)`), composed with the per-connection signal by
+     * the underlying store. Aborting it fails the connection with the abort
+     * reason without touching other state. Read fresh from the latest render,
+     * so inline closures need no callback wrapping.
+     */
+    getAbortSignal?: (connection: number) => AbortSignal | null | undefined;
+    /**
+     * Called when the subscription transitions into `error`.
+     */
+    onError?: (error: unknown) => void;
+}
+/** Per-connection abort overrides for `reconnect()`. */
+type UseSubscriptionReconnectOptions = {
+    /**
+     * Applies only this signal to the connection, bypassing `getAbortSignal`.
+     * Passing `undefined` (or an empty options object) applies no caller signal
+     * for that connection; call `reconnect()` with no argument to keep the
+     * `getAbortSignal` factory behavior.
+     */
+    abortSignal?: AbortSignal;
+};
+interface UseSubscriptionReturn<TResult> {
+    data: ComputedRef<TResult | undefined>;
+    error: ComputedRef<SolanaError | null>;
+    /** Re-opens the connection. `reconnect({ abortSignal })` overrides `getAbortSignal`. */
+    reconnect: (options?: UseSubscriptionReconnectOptions) => void;
+    status: ComputedRef<UseSubscriptionStatus>;
+}
+/**
+ * Live data from RPC subscriptions and other reactive stream sources.
+ *
+ * Accepts a Kit reactive stream source (duck-typed on `reactiveStore()`),
+ * bridges its `{ subscribe, getState }` contract into Vue reactive state, and
+ * tears the connection down when the component unmounts.
+ *
+ * Status set: `loading` | `loaded` | `error` | `disabled`.
+ *
+ * - A `null` source disables the subscription and clears state.
+ * - `reconnect()` re-opens the connection with stale-while-revalidate: the
+ *   last known `data` stays visible until fresh data arrives.
+ * - Errors preserve the last known `data`; only the first error per connection
+ *   window is captured (matching the underlying store's contract).
+ * - Changing a ref/computed source tears down the previous subscription and
+ *   connects to the new one.
+ */
+declare function useSubscription<TResult>(source: UseSubscriptionSource<TResult>, options?: UseSubscriptionOptions): UseSubscriptionReturn<TResult>;
+
+export { useSubscription };
+export type { UseSubscriptionOptions, UseSubscriptionReconnectOptions, UseSubscriptionReturn, UseSubscriptionSource, UseSubscriptionStatus };

package/dist/useSubscription.d.ts

@@ -0,0 +1,70 @@
+import { SolanaError } from '@vue-solana/core/errors';
+import { ReactiveStreamStore } from '@vue-solana/core/kit';
+import { ComputedRef, Ref } from 'vue';
+
+type UseSubscriptionStatus = "loading" | "loaded" | "error" | "disabled";
+/**
+ * A subscription source accepted by `useSubscription`:
+ *
+ * - a Kit reactive stream source such as `PendingRpcSubscriptionsRequest`
+ *   (for example `rpcSubscriptions.accountNotifications(address)`),
+ * - a `ref`/`computed` of a source or `null` to disable, or
+ * - `null` to disable outright.
+ */
+type UseSubscriptionSource<TResult> = {
+    reactiveStore: () => ReactiveStreamStore<TResult>;
+} | Ref<{
+    reactiveStore: () => ReactiveStreamStore<TResult>;
+} | null | undefined> | null | undefined;
+interface UseSubscriptionOptions {
+    /**
+     * Returns a caller-provided `AbortSignal` per connection (for example
+     * `AbortSignal.timeout(30_000)`), composed with the per-connection signal by
+     * the underlying store. Aborting it fails the connection with the abort
+     * reason without touching other state. Read fresh from the latest render,
+     * so inline closures need no callback wrapping.
+     */
+    getAbortSignal?: (connection: number) => AbortSignal | null | undefined;
+    /**
+     * Called when the subscription transitions into `error`.
+     */
+    onError?: (error: unknown) => void;
+}
+/** Per-connection abort overrides for `reconnect()`. */
+type UseSubscriptionReconnectOptions = {
+    /**
+     * Applies only this signal to the connection, bypassing `getAbortSignal`.
+     * Passing `undefined` (or an empty options object) applies no caller signal
+     * for that connection; call `reconnect()` with no argument to keep the
+     * `getAbortSignal` factory behavior.
+     */
+    abortSignal?: AbortSignal;
+};
+interface UseSubscriptionReturn<TResult> {
+    data: ComputedRef<TResult | undefined>;
+    error: ComputedRef<SolanaError | null>;
+    /** Re-opens the connection. `reconnect({ abortSignal })` overrides `getAbortSignal`. */
+    reconnect: (options?: UseSubscriptionReconnectOptions) => void;
+    status: ComputedRef<UseSubscriptionStatus>;
+}
+/**
+ * Live data from RPC subscriptions and other reactive stream sources.
+ *
+ * Accepts a Kit reactive stream source (duck-typed on `reactiveStore()`),
+ * bridges its `{ subscribe, getState }` contract into Vue reactive state, and
+ * tears the connection down when the component unmounts.
+ *
+ * Status set: `loading` | `loaded` | `error` | `disabled`.
+ *
+ * - A `null` source disables the subscription and clears state.
+ * - `reconnect()` re-opens the connection with stale-while-revalidate: the
+ *   last known `data` stays visible until fresh data arrives.
+ * - Errors preserve the last known `data`; only the first error per connection
+ *   window is captured (matching the underlying store's contract).
+ * - Changing a ref/computed source tears down the previous subscription and
+ *   connects to the new one.
+ */
+declare function useSubscription<TResult>(source: UseSubscriptionSource<TResult>, options?: UseSubscriptionOptions): UseSubscriptionReturn<TResult>;
+
+export { useSubscription };
+export type { UseSubscriptionOptions, UseSubscriptionReconnectOptions, UseSubscriptionReturn, UseSubscriptionSource, UseSubscriptionStatus };

package/dist/useSubscription.mjs

@@ -0,0 +1,3 @@
+export { u as useSubscription } from './shared/vue.BDNOyiGZ.mjs';
+import '@vue-solana/core/errors';
+import 'vue';

package/dist/useTokenAccounts.cjs

@@ -1,13 +1,14 @@
 'use strict';
 
-const useTokenAccounts = require('./shared/vue.B_LRH8SM.cjs');
+const useTokenAccounts = require('./shared/vue.Bwd1sGAM.cjs');
 require('@vue-solana/core/token-accounts');
 require('@vue-solana/core/errors');
 require('@vue-solana/core/address');
 require('vue');
-require('./shared/vue.CZwftA0L.cjs');
-require('./shared/vue.k9Q6aN-0.cjs');
-require('./shared/vue.BaR1VPhl.cjs');
+require('./shared/vue.BVaMoz9y.cjs');
+require('./shared/vue.BIxphCAq.cjs');
+require('./shared/vue.DE3emjSF.cjs');
+require('./shared/vue.DEHxNvUX.cjs');
 
 
 

package/dist/useTokenAccounts.mjs

@@ -1,8 +1,9 @@
-export { u as useTokenAccounts } from './shared/vue.yQcL1yMv.mjs';
+export { u as useTokenAccounts } from './shared/vue.BOpgWr43.mjs';
 import '@vue-solana/core/token-accounts';
 import '@vue-solana/core/errors';
 import '@vue-solana/core/address';
 import 'vue';
-import './shared/vue.ChujsB0B.mjs';
-import './shared/vue.BaFrF2PF.mjs';
-import './shared/vue.CnUlZSe8.mjs';
+import './shared/vue.CpkwC8Th.mjs';
+import './shared/vue.Mxc8w6Qk.mjs';
+import './shared/vue.CQh3AUE8.mjs';
+import './shared/vue.D_P5SqqD.mjs';

package/dist/useTokenBalance.cjs

@@ -1,13 +1,14 @@
 'use strict';
 
-const useTokenBalance = require('./shared/vue.CXHYdyKZ.cjs');
+const useTokenBalance = require('./shared/vue.DAg5wC1G.cjs');
 require('@vue-solana/core/token-accounts');
 require('@vue-solana/core/errors');
 require('@vue-solana/core/address');
 require('vue');
-require('./shared/vue.CZwftA0L.cjs');
-require('./shared/vue.k9Q6aN-0.cjs');
-require('./shared/vue.BaR1VPhl.cjs');
+require('./shared/vue.BVaMoz9y.cjs');
+require('./shared/vue.BIxphCAq.cjs');
+require('./shared/vue.DE3emjSF.cjs');
+require('./shared/vue.DEHxNvUX.cjs');
 
 
 

package/dist/useTokenBalance.mjs

@@ -1,8 +1,9 @@
-export { u as useTokenBalance } from './shared/vue.DP7qY8Rk.mjs';
+export { u as useTokenBalance } from './shared/vue.BD6Gm1nl.mjs';
 import '@vue-solana/core/token-accounts';
 import '@vue-solana/core/errors';
 import '@vue-solana/core/address';
 import 'vue';
-import './shared/vue.ChujsB0B.mjs';
-import './shared/vue.BaFrF2PF.mjs';
-import './shared/vue.CnUlZSe8.mjs';
+import './shared/vue.CpkwC8Th.mjs';
+import './shared/vue.Mxc8w6Qk.mjs';
+import './shared/vue.CQh3AUE8.mjs';
+import './shared/vue.D_P5SqqD.mjs';

package/dist/useTrackedData.cjs

@@ -0,0 +1,10 @@
+'use strict';
+
+const useTrackedData = require('./shared/vue.DxM45azl.cjs');
+require('@vue-solana/core/kit');
+require('@vue-solana/core/errors');
+require('vue');
+
+
+
+exports.useTrackedData = useTrackedData.useTrackedData;

package/dist/useTrackedData.d.cts

@@ -0,0 +1,98 @@
+import { ReactiveActionSource, SolanaRpcResponse, ReactiveStreamSource, ReactiveStreamStore } from '@vue-solana/core/kit';
+import { SolanaError } from '@vue-solana/core/errors';
+import { ComputedRef, Ref } from 'vue';
+
+type UseTrackedDataStatus = "loading" | "loaded" | "error" | "disabled";
+type SendFn<TValue> = (options?: {
+    abortSignal?: AbortSignal;
+}) => Promise<TValue>;
+/**
+ * One-shot initial-value source (satisfied by `PendingRpcRequest`).
+ */
+type UseTrackedDataInitialSource<TInitialValue> = ReactiveActionSource<SolanaRpcResponse<TInitialValue>> | {
+    send: SendFn<SolanaRpcResponse<TInitialValue>>;
+};
+/**
+ * Ongoing stream source (satisfied by `PendingRpcSubscriptionsRequest`).
+ */
+type UseTrackedDataStreamSource<TStreamValue> = ReactiveStreamSource<SolanaRpcResponse<TStreamValue>> | {
+    reactiveStore: () => ReactiveStreamStore<SolanaRpcResponse<TStreamValue>>;
+};
+/**
+ * A `useTrackedData` source bundle. Every field accepts a plain source or a
+ * `ref`/`computed` of it; a `null`/`undefined` `rpcRequest` or
+ * `rpcSubscriptionRequest` disables the composable.
+ */
+interface UseTrackedDataSource<TInitialValue, TStreamValue, TItem> {
+    /**
+     * One-shot RPC request for the initial value, for example
+     * `rpc.getBalance(address)`.
+     */
+    rpcRequest: UseTrackedDataInitialSource<TInitialValue> | Ref<UseTrackedDataInitialSource<TInitialValue> | null | undefined>;
+    /**
+     * RPC subscription request for live updates, for example
+     * `rpcSubscriptions.accountNotifications(address)`.
+     */
+    rpcSubscriptionRequest: UseTrackedDataStreamSource<TStreamValue> | Ref<UseTrackedDataStreamSource<TStreamValue> | null | undefined>;
+    /**
+     * Maps the initial fetch's response value to the stored item type.
+     */
+    rpcValueMapper: (value: TInitialValue) => TItem;
+    /**
+     * Maps a stream notification's value to the stored item type.
+     */
+    rpcSubscriptionValueMapper: (value: TStreamValue) => TItem;
+}
+interface UseTrackedDataOptions {
+    /**
+     * Returns a caller-provided `AbortSignal` per connection (for example
+     * `AbortSignal.timeout(60_000)`), composed with the per-connection signal
+     * by the underlying store. Aborting it fails the connection with the abort
+     * reason without touching other state. Read fresh from the latest render,
+     * so inline closures need no callback wrapping.
+     */
+    getAbortSignal?: (connection: number) => AbortSignal | null | undefined;
+    /**
+     * Called when the tracked data transitions into `error`.
+     */
+    onError?: (error: unknown) => void;
+}
+/** Per-connection abort overrides for `refresh()`. */
+type UseTrackedDataRefresherOptions = {
+    /**
+     * Applies only this signal to both connections, bypassing `getAbortSignal`.
+     * Passing `undefined` (or an empty options object) applies no caller signal
+     * for that refresh; call `refresh()` with no argument to keep the
+     * `getAbortSignal` factory behavior.
+     */
+    abortSignal?: AbortSignal;
+};
+interface UseTrackedDataReturn<TItem> {
+    /**
+     * The latest item, surface-mapped by `rpcValueMapper` /
+     * `rpcSubscriptionValueMapper`. The {@link SolanaRpcResponse} envelope is
+     * preserved so callers can read `data.value?.context.slot`.
+     */
+    data: ComputedRef<SolanaRpcResponse<TItem> | undefined>;
+    error: ComputedRef<SolanaError | null>;
+    /** Rebuilds both connections. `refresh({ abortSignal })` overrides `getAbortSignal`. */
+    refresh: (options?: UseTrackedDataRefresherOptions) => void;
+    status: ComputedRef<UseTrackedDataStatus>;
+}
+/**
+ * Live RPC data seeded by a one-shot fetch, slot-deduplicated between the two
+ * sources so notifications and the initial response can arrive in any order
+ * without out-of-order regressions.
+ *
+ * - `refresh()` aborts the current connection and re-runs both the fetch and
+ *   the subscription with stale-while-revalidate (last known `data` stays
+ *   visible while loading).
+ * - A `null`/`undefined` source (or `ref` of one) disables the composable and
+ *   clears state.
+ * - `getAbortSignal` attaches per-connection cancellation (timeouts, kill
+ *   switches) on top of the internal per-connection signal.
+ */
+declare function useTrackedData<TInitialValue, TStreamValue, TItem>(source: UseTrackedDataSource<TInitialValue, TStreamValue, TItem>, options?: UseTrackedDataOptions): UseTrackedDataReturn<TItem>;
+
+export { useTrackedData };
+export type { UseTrackedDataInitialSource, UseTrackedDataOptions, UseTrackedDataRefresherOptions, UseTrackedDataReturn, UseTrackedDataSource, UseTrackedDataStatus, UseTrackedDataStreamSource };

package/dist/useTrackedData.d.mts

@@ -0,0 +1,98 @@
+import { ReactiveActionSource, SolanaRpcResponse, ReactiveStreamSource, ReactiveStreamStore } from '@vue-solana/core/kit';
+import { SolanaError } from '@vue-solana/core/errors';
+import { ComputedRef, Ref } from 'vue';
+
+type UseTrackedDataStatus = "loading" | "loaded" | "error" | "disabled";
+type SendFn<TValue> = (options?: {
+    abortSignal?: AbortSignal;
+}) => Promise<TValue>;
+/**
+ * One-shot initial-value source (satisfied by `PendingRpcRequest`).
+ */
+type UseTrackedDataInitialSource<TInitialValue> = ReactiveActionSource<SolanaRpcResponse<TInitialValue>> | {
+    send: SendFn<SolanaRpcResponse<TInitialValue>>;
+};
+/**
+ * Ongoing stream source (satisfied by `PendingRpcSubscriptionsRequest`).
+ */
+type UseTrackedDataStreamSource<TStreamValue> = ReactiveStreamSource<SolanaRpcResponse<TStreamValue>> | {
+    reactiveStore: () => ReactiveStreamStore<SolanaRpcResponse<TStreamValue>>;
+};
+/**
+ * A `useTrackedData` source bundle. Every field accepts a plain source or a
+ * `ref`/`computed` of it; a `null`/`undefined` `rpcRequest` or
+ * `rpcSubscriptionRequest` disables the composable.
+ */
+interface UseTrackedDataSource<TInitialValue, TStreamValue, TItem> {
+    /**
+     * One-shot RPC request for the initial value, for example
+     * `rpc.getBalance(address)`.
+     */
+    rpcRequest: UseTrackedDataInitialSource<TInitialValue> | Ref<UseTrackedDataInitialSource<TInitialValue> | null | undefined>;
+    /**
+     * RPC subscription request for live updates, for example
+     * `rpcSubscriptions.accountNotifications(address)`.
+     */
+    rpcSubscriptionRequest: UseTrackedDataStreamSource<TStreamValue> | Ref<UseTrackedDataStreamSource<TStreamValue> | null | undefined>;
+    /**
+     * Maps the initial fetch's response value to the stored item type.
+     */
+    rpcValueMapper: (value: TInitialValue) => TItem;
+    /**
+     * Maps a stream notification's value to the stored item type.
+     */
+    rpcSubscriptionValueMapper: (value: TStreamValue) => TItem;
+}
+interface UseTrackedDataOptions {
+    /**
+     * Returns a caller-provided `AbortSignal` per connection (for example
+     * `AbortSignal.timeout(60_000)`), composed with the per-connection signal
+     * by the underlying store. Aborting it fails the connection with the abort
+     * reason without touching other state. Read fresh from the latest render,
+     * so inline closures need no callback wrapping.
+     */
+    getAbortSignal?: (connection: number) => AbortSignal | null | undefined;
+    /**
+     * Called when the tracked data transitions into `error`.
+     */
+    onError?: (error: unknown) => void;
+}
+/** Per-connection abort overrides for `refresh()`. */
+type UseTrackedDataRefresherOptions = {
+    /**
+     * Applies only this signal to both connections, bypassing `getAbortSignal`.
+     * Passing `undefined` (or an empty options object) applies no caller signal
+     * for that refresh; call `refresh()` with no argument to keep the
+     * `getAbortSignal` factory behavior.
+     */
+    abortSignal?: AbortSignal;
+};
+interface UseTrackedDataReturn<TItem> {
+    /**
+     * The latest item, surface-mapped by `rpcValueMapper` /
+     * `rpcSubscriptionValueMapper`. The {@link SolanaRpcResponse} envelope is
+     * preserved so callers can read `data.value?.context.slot`.
+     */
+    data: ComputedRef<SolanaRpcResponse<TItem> | undefined>;
+    error: ComputedRef<SolanaError | null>;
+    /** Rebuilds both connections. `refresh({ abortSignal })` overrides `getAbortSignal`. */
+    refresh: (options?: UseTrackedDataRefresherOptions) => void;
+    status: ComputedRef<UseTrackedDataStatus>;
+}
+/**
+ * Live RPC data seeded by a one-shot fetch, slot-deduplicated between the two
+ * sources so notifications and the initial response can arrive in any order
+ * without out-of-order regressions.
+ *
+ * - `refresh()` aborts the current connection and re-runs both the fetch and
+ *   the subscription with stale-while-revalidate (last known `data` stays
+ *   visible while loading).
+ * - A `null`/`undefined` source (or `ref` of one) disables the composable and
+ *   clears state.
+ * - `getAbortSignal` attaches per-connection cancellation (timeouts, kill
+ *   switches) on top of the internal per-connection signal.
+ */
+declare function useTrackedData<TInitialValue, TStreamValue, TItem>(source: UseTrackedDataSource<TInitialValue, TStreamValue, TItem>, options?: UseTrackedDataOptions): UseTrackedDataReturn<TItem>;
+
+export { useTrackedData };
+export type { UseTrackedDataInitialSource, UseTrackedDataOptions, UseTrackedDataRefresherOptions, UseTrackedDataReturn, UseTrackedDataSource, UseTrackedDataStatus, UseTrackedDataStreamSource };

package/dist/useTrackedData.d.ts

@@ -0,0 +1,98 @@
+import { ReactiveActionSource, SolanaRpcResponse, ReactiveStreamSource, ReactiveStreamStore } from '@vue-solana/core/kit';
+import { SolanaError } from '@vue-solana/core/errors';
+import { ComputedRef, Ref } from 'vue';
+
+type UseTrackedDataStatus = "loading" | "loaded" | "error" | "disabled";
+type SendFn<TValue> = (options?: {
+    abortSignal?: AbortSignal;
+}) => Promise<TValue>;
+/**
+ * One-shot initial-value source (satisfied by `PendingRpcRequest`).
+ */
+type UseTrackedDataInitialSource<TInitialValue> = ReactiveActionSource<SolanaRpcResponse<TInitialValue>> | {
+    send: SendFn<SolanaRpcResponse<TInitialValue>>;
+};
+/**
+ * Ongoing stream source (satisfied by `PendingRpcSubscriptionsRequest`).
+ */
+type UseTrackedDataStreamSource<TStreamValue> = ReactiveStreamSource<SolanaRpcResponse<TStreamValue>> | {
+    reactiveStore: () => ReactiveStreamStore<SolanaRpcResponse<TStreamValue>>;
+};
+/**
+ * A `useTrackedData` source bundle. Every field accepts a plain source or a
+ * `ref`/`computed` of it; a `null`/`undefined` `rpcRequest` or
+ * `rpcSubscriptionRequest` disables the composable.
+ */
+interface UseTrackedDataSource<TInitialValue, TStreamValue, TItem> {
+    /**
+     * One-shot RPC request for the initial value, for example
+     * `rpc.getBalance(address)`.
+     */
+    rpcRequest: UseTrackedDataInitialSource<TInitialValue> | Ref<UseTrackedDataInitialSource<TInitialValue> | null | undefined>;
+    /**
+     * RPC subscription request for live updates, for example
+     * `rpcSubscriptions.accountNotifications(address)`.
+     */
+    rpcSubscriptionRequest: UseTrackedDataStreamSource<TStreamValue> | Ref<UseTrackedDataStreamSource<TStreamValue> | null | undefined>;
+    /**
+     * Maps the initial fetch's response value to the stored item type.
+     */
+    rpcValueMapper: (value: TInitialValue) => TItem;
+    /**
+     * Maps a stream notification's value to the stored item type.
+     */
+    rpcSubscriptionValueMapper: (value: TStreamValue) => TItem;
+}
+interface UseTrackedDataOptions {
+    /**
+     * Returns a caller-provided `AbortSignal` per connection (for example
+     * `AbortSignal.timeout(60_000)`), composed with the per-connection signal
+     * by the underlying store. Aborting it fails the connection with the abort
+     * reason without touching other state. Read fresh from the latest render,
+     * so inline closures need no callback wrapping.
+     */
+    getAbortSignal?: (connection: number) => AbortSignal | null | undefined;
+    /**
+     * Called when the tracked data transitions into `error`.
+     */
+    onError?: (error: unknown) => void;
+}
+/** Per-connection abort overrides for `refresh()`. */
+type UseTrackedDataRefresherOptions = {
+    /**
+     * Applies only this signal to both connections, bypassing `getAbortSignal`.
+     * Passing `undefined` (or an empty options object) applies no caller signal
+     * for that refresh; call `refresh()` with no argument to keep the
+     * `getAbortSignal` factory behavior.
+     */
+    abortSignal?: AbortSignal;
+};
+interface UseTrackedDataReturn<TItem> {
+    /**
+     * The latest item, surface-mapped by `rpcValueMapper` /
+     * `rpcSubscriptionValueMapper`. The {@link SolanaRpcResponse} envelope is
+     * preserved so callers can read `data.value?.context.slot`.
+     */
+    data: ComputedRef<SolanaRpcResponse<TItem> | undefined>;
+    error: ComputedRef<SolanaError | null>;
+    /** Rebuilds both connections. `refresh({ abortSignal })` overrides `getAbortSignal`. */
+    refresh: (options?: UseTrackedDataRefresherOptions) => void;
+    status: ComputedRef<UseTrackedDataStatus>;
+}
+/**
+ * Live RPC data seeded by a one-shot fetch, slot-deduplicated between the two
+ * sources so notifications and the initial response can arrive in any order
+ * without out-of-order regressions.
+ *
+ * - `refresh()` aborts the current connection and re-runs both the fetch and
+ *   the subscription with stale-while-revalidate (last known `data` stays
+ *   visible while loading).
+ * - A `null`/`undefined` source (or `ref` of one) disables the composable and
+ *   clears state.
+ * - `getAbortSignal` attaches per-connection cancellation (timeouts, kill
+ *   switches) on top of the internal per-connection signal.
+ */
+declare function useTrackedData<TInitialValue, TStreamValue, TItem>(source: UseTrackedDataSource<TInitialValue, TStreamValue, TItem>, options?: UseTrackedDataOptions): UseTrackedDataReturn<TItem>;
+
+export { useTrackedData };
+export type { UseTrackedDataInitialSource, UseTrackedDataOptions, UseTrackedDataRefresherOptions, UseTrackedDataReturn, UseTrackedDataSource, UseTrackedDataStatus, UseTrackedDataStreamSource };

package/dist/useTrackedData.mjs

@@ -0,0 +1,4 @@
+export { u as useTrackedData } from './shared/vue.CbJFnho-.mjs';
+import '@vue-solana/core/kit';
+import '@vue-solana/core/errors';
+import 'vue';

package/dist/useTransaction.cjs

@@ -1,6 +1,7 @@
 'use strict';
 
-const useTransaction = require('./shared/vue.CE5i8KZZ.cjs');
+const useTransaction = require('./shared/vue.Bk5xjlUx.cjs');
+require('@vue-solana/core/action');
 require('@vue-solana/core/errors');
 require('@vue-solana/core/timeout');
 require('vue');