@vue-solana/vue 2.0.0 → 2.2.0

package/dist/shared/vue.l3UCdN7z.cjs

@@ -0,0 +1,111 @@
+'use strict';
+
+const errors = require('@vue-solana/core/errors');
+const vue = require('vue');
+
+function useSubscription(source, options = {}) {
+  const data = vue.shallowRef(void 0);
+  const error = vue.shallowRef(null);
+  const status = vue.shallowRef("loading");
+  const disposables = [];
+  let connectionCount = 0;
+  let disposed = false;
+  let activeSource;
+  let activeStore;
+  function applyState(state) {
+    if (state.status === "loaded") {
+      data.value = state.data;
+      error.value = null;
+      status.value = "loaded";
+    } else if (state.status === "error") {
+      error.value = errors.normalizeSolanaError(state.error, "RPC_FAILURE");
+      status.value = "error";
+      options.onError?.(state.error);
+    } else if (state.status === "loading") {
+      status.value = data.value === void 0 ? "loading" : status.value;
+    } else if (state.status === "idle") {
+      data.value = void 0;
+      error.value = null;
+      status.value = "loading";
+    }
+  }
+  function openConnection(store, override) {
+    activeStore = store;
+    connectionCount += 1;
+    const connection = connectionCount;
+    const callerSignal = override ? override.abortSignal : options.getAbortSignal?.(connection);
+    applyState(store.getState());
+    disposables.push(
+      store.subscribe(() => {
+        applyState(store.getState());
+      })
+    );
+    if (callerSignal?.aborted) {
+      applyState({ data: store.getState().data, error: callerSignal.reason, status: "error" });
+      return;
+    }
+    if (callerSignal) {
+      store.withSignal(callerSignal).connect();
+    } else {
+      store.connect();
+    }
+  }
+  function disconnect() {
+    disposables.forEach((dispose) => {
+      dispose();
+    });
+    disposables.length = 0;
+    if (activeStore) {
+      activeStore.reset();
+      activeStore = void 0;
+    }
+    activeSource = void 0;
+  }
+  function connectCurrent(override) {
+    if (disposed) {
+      return;
+    }
+    const resolved = vue.isRef(source) ? source.value : source;
+    if (resolved === null || resolved === void 0) {
+      disconnect();
+      data.value = void 0;
+      error.value = null;
+      status.value = "disabled";
+      return;
+    }
+    if (activeSource === resolved && activeStore) {
+      openConnection(activeStore, override);
+      return;
+    }
+    disconnect();
+    activeSource = resolved;
+    openConnection(resolved.reactiveStore(), override);
+  }
+  vue.watch(
+    () => vue.isRef(source) ? source.value : source,
+    () => {
+      connectCurrent();
+    },
+    { flush: "sync" }
+  );
+  vue.onMounted(() => {
+    connectCurrent();
+  });
+  if (!vue.getCurrentInstance()) {
+    connectCurrent();
+  }
+  vue.onScopeDispose(() => {
+    disposed = true;
+    disconnect();
+  });
+  return {
+    data: vue.computed(() => data.value),
+    error: vue.computed(() => error.value),
+    reconnect: (options2) => {
+      connectCurrent(options2);
+    },
+    status: vue.computed(() => status.value)
+  };
+}
+
+exports.useSubscription = useSubscription;

package/dist/swr.cjs

@@ -0,0 +1,136 @@
+'use strict';
+
+const vue = require('vue');
+const useRequest = require('./shared/vue.ZuUCEEab.cjs');
+const useSubscription = require('./shared/vue.l3UCdN7z.cjs');
+const useTrackedData = require('./shared/vue.DxM45azl.cjs');
+require('@vue-solana/core/action');
+require('@vue-solana/core/kit');
+require('@vue-solana/core/errors');
+
+const PREFIX_REQUEST = "request:";
+const PREFIX_SUBSCRIPTION = "subscription:";
+const PREFIX_TRACKED = "tracked:";
+const swrCache = /* @__PURE__ */ new Map();
+function clearSwrCache() {
+  swrCache.clear();
+}
+function readSwrCache(key) {
+  return swrCache.get(key);
+}
+function writeSwrCache(key, entry) {
+  swrCache.set(key, entry);
+}
+function deleteSwrCache(key) {
+  swrCache.delete(key);
+}
+function isPendingStatus(status) {
+  return status === "fetching" || status === "loading";
+}
+function writeSwrResult(key, data, error, status) {
+  if (status === "disabled") {
+    deleteSwrCache(key);
+    return;
+  }
+  const previous = readSwrCache(key);
+  writeSwrCache(key, {
+    data: data !== void 0 ? data : previous?.data,
+    error,
+    status
+  });
+}
+function swrError(error, status, seed) {
+  if (status === "disabled") {
+    return null;
+  }
+  return error ?? (isPendingStatus(status) ? seed?.error ?? null : null);
+}
+function useRequestSwr(key, source, options = {}) {
+  const cacheKey = `${PREFIX_REQUEST}${key}`;
+  const seed = readSwrCache(cacheKey);
+  const result = useRequest.useRequest(source, options);
+  if (result.status.value === "disabled") {
+    deleteSwrCache(cacheKey);
+  }
+  vue.watch(
+    [result.data, result.error, result.status],
+    ([data2, error2, status]) => writeSwrResult(cacheKey, data2, error2, status),
+    { flush: "sync" }
+  );
+  const data = vue.computed(() => {
+    if (result.status.value === "disabled") {
+      return void 0;
+    }
+    return result.data.value !== void 0 ? result.data.value : seed?.data;
+  });
+  const error = vue.computed(
+    () => swrError(result.error.value, result.status.value, seed)
+  );
+  return {
+    data,
+    error,
+    refresh: result.refresh,
+    status: result.status
+  };
+}
+function useSubscriptionSwr(key, source, options = {}) {
+  const cacheKey = `${PREFIX_SUBSCRIPTION}${key}`;
+  const seed = readSwrCache(cacheKey);
+  const result = useSubscription.useSubscription(source, options);
+  if (result.status.value === "disabled") {
+    deleteSwrCache(cacheKey);
+  }
+  vue.watch(
+    [result.data, result.error, result.status],
+    ([data2, error2, status]) => writeSwrResult(cacheKey, data2, error2, status),
+    { flush: "sync" }
+  );
+  const data = vue.computed(() => {
+    if (result.status.value === "disabled") {
+      return void 0;
+    }
+    return result.data.value !== void 0 ? result.data.value : seed?.data;
+  });
+  const error = vue.computed(
+    () => swrError(result.error.value, result.status.value, seed)
+  );
+  return {
+    data,
+    error,
+    reconnect: result.reconnect,
+    status: result.status
+  };
+}
+function useTrackedDataSwr(key, source, options = {}) {
+  const cacheKey = `${PREFIX_TRACKED}${key}`;
+  const seed = readSwrCache(cacheKey);
+  const result = useTrackedData.useTrackedData(source, options);
+  if (result.status.value === "disabled") {
+    deleteSwrCache(cacheKey);
+  }
+  vue.watch(
+    [result.data, result.error, result.status],
+    ([data2, error2, status]) => writeSwrResult(cacheKey, data2, error2, status),
+    { flush: "sync" }
+  );
+  const data = vue.computed(() => {
+    if (result.status.value === "disabled") {
+      return void 0;
+    }
+    return result.data.value ?? seed?.data;
+  });
+  const error = vue.computed(
+    () => swrError(result.error.value, result.status.value, seed)
+  );
+  return {
+    data,
+    error,
+    refresh: result.refresh,
+    status: result.status
+  };
+}
+
+exports.clearSwrCache = clearSwrCache;
+exports.useRequestSwr = useRequestSwr;
+exports.useSubscriptionSwr = useSubscriptionSwr;
+exports.useTrackedDataSwr = useTrackedDataSwr;

package/dist/swr.d.cts

@@ -0,0 +1,41 @@
+import { useRequest, UseRequestOptions, UseRequestReturn } from './useRequest.cjs';
+import { UseSubscriptionSource, UseSubscriptionOptions, UseSubscriptionReturn } from './useSubscription.cjs';
+import { UseTrackedDataSource, UseTrackedDataOptions, UseTrackedDataReturn } from './useTrackedData.cjs';
+import '@vue-solana/core/errors';
+import 'vue';
+import '@vue-solana/core/kit';
+
+/**
+ * Remove every cached SWR entry (all adapters). Useful between test cases
+ * and to reset server-side caches per request.
+ */
+declare function clearSwrCache(): void;
+/**
+ * `useRequest` with cache keying. A component mounting with a key that
+ * already holds data shows it immediately (stale) while its own request
+ * revalidates; results are written back for the next mount.
+ *
+ * A `null`/`undefined` source disables the request and **clears** the
+ * cached entry for the key — including when the component mounts with the
+ * source already disabled.
+ */
+declare function useRequestSwr<TResult>(key: string, source: Parameters<typeof useRequest<TResult>>[0], options?: UseRequestOptions): UseRequestReturn<TResult>;
+/**
+ * `useSubscription` with cache keying — a freshly mounted component seeds
+ * from the last-known stream value while its own subscription connects.
+ *
+ * A `null`/`undefined` source disables the subscription and **clears** the
+ * cached entry for the key.
+ */
+declare function useSubscriptionSwr<TResult>(key: string, source: UseSubscriptionSource<TResult>, options?: UseSubscriptionOptions): UseSubscriptionReturn<TResult>;
+/**
+ * `useTrackedData` with cache keying — seeds from the last-known
+ * {@link SolanaRpcResponse} envelope (data **and** slot context) while the
+ * fetch + subscription pair revalidates.
+ *
+ * A `null`/`undefined` source disables the composable and **clears** the
+ * cached entry for the key.
+ */
+declare function useTrackedDataSwr<TInitialValue, TStreamValue, TItem>(key: string, source: UseTrackedDataSource<TInitialValue, TStreamValue, TItem>, options?: UseTrackedDataOptions): UseTrackedDataReturn<TItem>;
+
+export { clearSwrCache, useRequestSwr, useSubscriptionSwr, useTrackedDataSwr };

package/dist/swr.d.mts

@@ -0,0 +1,41 @@
+import { useRequest, UseRequestOptions, UseRequestReturn } from './useRequest.mjs';
+import { UseSubscriptionSource, UseSubscriptionOptions, UseSubscriptionReturn } from './useSubscription.mjs';
+import { UseTrackedDataSource, UseTrackedDataOptions, UseTrackedDataReturn } from './useTrackedData.mjs';
+import '@vue-solana/core/errors';
+import 'vue';
+import '@vue-solana/core/kit';
+
+/**
+ * Remove every cached SWR entry (all adapters). Useful between test cases
+ * and to reset server-side caches per request.
+ */
+declare function clearSwrCache(): void;
+/**
+ * `useRequest` with cache keying. A component mounting with a key that
+ * already holds data shows it immediately (stale) while its own request
+ * revalidates; results are written back for the next mount.
+ *
+ * A `null`/`undefined` source disables the request and **clears** the
+ * cached entry for the key — including when the component mounts with the
+ * source already disabled.
+ */
+declare function useRequestSwr<TResult>(key: string, source: Parameters<typeof useRequest<TResult>>[0], options?: UseRequestOptions): UseRequestReturn<TResult>;
+/**
+ * `useSubscription` with cache keying — a freshly mounted component seeds
+ * from the last-known stream value while its own subscription connects.
+ *
+ * A `null`/`undefined` source disables the subscription and **clears** the
+ * cached entry for the key.
+ */
+declare function useSubscriptionSwr<TResult>(key: string, source: UseSubscriptionSource<TResult>, options?: UseSubscriptionOptions): UseSubscriptionReturn<TResult>;
+/**
+ * `useTrackedData` with cache keying — seeds from the last-known
+ * {@link SolanaRpcResponse} envelope (data **and** slot context) while the
+ * fetch + subscription pair revalidates.
+ *
+ * A `null`/`undefined` source disables the composable and **clears** the
+ * cached entry for the key.
+ */
+declare function useTrackedDataSwr<TInitialValue, TStreamValue, TItem>(key: string, source: UseTrackedDataSource<TInitialValue, TStreamValue, TItem>, options?: UseTrackedDataOptions): UseTrackedDataReturn<TItem>;
+
+export { clearSwrCache, useRequestSwr, useSubscriptionSwr, useTrackedDataSwr };

package/dist/swr.d.ts

@@ -0,0 +1,41 @@
+import { useRequest, UseRequestOptions, UseRequestReturn } from './useRequest.js';
+import { UseSubscriptionSource, UseSubscriptionOptions, UseSubscriptionReturn } from './useSubscription.js';
+import { UseTrackedDataSource, UseTrackedDataOptions, UseTrackedDataReturn } from './useTrackedData.js';
+import '@vue-solana/core/errors';
+import 'vue';
+import '@vue-solana/core/kit';
+
+/**
+ * Remove every cached SWR entry (all adapters). Useful between test cases
+ * and to reset server-side caches per request.
+ */
+declare function clearSwrCache(): void;
+/**
+ * `useRequest` with cache keying. A component mounting with a key that
+ * already holds data shows it immediately (stale) while its own request
+ * revalidates; results are written back for the next mount.
+ *
+ * A `null`/`undefined` source disables the request and **clears** the
+ * cached entry for the key — including when the component mounts with the
+ * source already disabled.
+ */
+declare function useRequestSwr<TResult>(key: string, source: Parameters<typeof useRequest<TResult>>[0], options?: UseRequestOptions): UseRequestReturn<TResult>;
+/**
+ * `useSubscription` with cache keying — a freshly mounted component seeds
+ * from the last-known stream value while its own subscription connects.
+ *
+ * A `null`/`undefined` source disables the subscription and **clears** the
+ * cached entry for the key.
+ */
+declare function useSubscriptionSwr<TResult>(key: string, source: UseSubscriptionSource<TResult>, options?: UseSubscriptionOptions): UseSubscriptionReturn<TResult>;
+/**
+ * `useTrackedData` with cache keying — seeds from the last-known
+ * {@link SolanaRpcResponse} envelope (data **and** slot context) while the
+ * fetch + subscription pair revalidates.
+ *
+ * A `null`/`undefined` source disables the composable and **clears** the
+ * cached entry for the key.
+ */
+declare function useTrackedDataSwr<TInitialValue, TStreamValue, TItem>(key: string, source: UseTrackedDataSource<TInitialValue, TStreamValue, TItem>, options?: UseTrackedDataOptions): UseTrackedDataReturn<TItem>;
+
+export { clearSwrCache, useRequestSwr, useSubscriptionSwr, useTrackedDataSwr };

package/dist/swr.mjs

@@ -0,0 +1,131 @@
+import { watch, computed } from 'vue';
+import { u as useRequest } from './shared/vue.B8VvC8d2.mjs';
+import { u as useSubscription } from './shared/vue.BDNOyiGZ.mjs';
+import { u as useTrackedData } from './shared/vue.CbJFnho-.mjs';
+import '@vue-solana/core/action';
+import '@vue-solana/core/kit';
+import '@vue-solana/core/errors';
+
+const PREFIX_REQUEST = "request:";
+const PREFIX_SUBSCRIPTION = "subscription:";
+const PREFIX_TRACKED = "tracked:";
+const swrCache = /* @__PURE__ */ new Map();
+function clearSwrCache() {
+  swrCache.clear();
+}
+function readSwrCache(key) {
+  return swrCache.get(key);
+}
+function writeSwrCache(key, entry) {
+  swrCache.set(key, entry);
+}
+function deleteSwrCache(key) {
+  swrCache.delete(key);
+}
+function isPendingStatus(status) {
+  return status === "fetching" || status === "loading";
+}
+function writeSwrResult(key, data, error, status) {
+  if (status === "disabled") {
+    deleteSwrCache(key);
+    return;
+  }
+  const previous = readSwrCache(key);
+  writeSwrCache(key, {
+    data: data !== void 0 ? data : previous?.data,
+    error,
+    status
+  });
+}
+function swrError(error, status, seed) {
+  if (status === "disabled") {
+    return null;
+  }
+  return error ?? (isPendingStatus(status) ? seed?.error ?? null : null);
+}
+function useRequestSwr(key, source, options = {}) {
+  const cacheKey = `${PREFIX_REQUEST}${key}`;
+  const seed = readSwrCache(cacheKey);
+  const result = useRequest(source, options);
+  if (result.status.value === "disabled") {
+    deleteSwrCache(cacheKey);
+  }
+  watch(
+    [result.data, result.error, result.status],
+    ([data2, error2, status]) => writeSwrResult(cacheKey, data2, error2, status),
+    { flush: "sync" }
+  );
+  const data = computed(() => {
+    if (result.status.value === "disabled") {
+      return void 0;
+    }
+    return result.data.value !== void 0 ? result.data.value : seed?.data;
+  });
+  const error = computed(
+    () => swrError(result.error.value, result.status.value, seed)
+  );
+  return {
+    data,
+    error,
+    refresh: result.refresh,
+    status: result.status
+  };
+}
+function useSubscriptionSwr(key, source, options = {}) {
+  const cacheKey = `${PREFIX_SUBSCRIPTION}${key}`;
+  const seed = readSwrCache(cacheKey);
+  const result = useSubscription(source, options);
+  if (result.status.value === "disabled") {
+    deleteSwrCache(cacheKey);
+  }
+  watch(
+    [result.data, result.error, result.status],
+    ([data2, error2, status]) => writeSwrResult(cacheKey, data2, error2, status),
+    { flush: "sync" }
+  );
+  const data = computed(() => {
+    if (result.status.value === "disabled") {
+      return void 0;
+    }
+    return result.data.value !== void 0 ? result.data.value : seed?.data;
+  });
+  const error = computed(
+    () => swrError(result.error.value, result.status.value, seed)
+  );
+  return {
+    data,
+    error,
+    reconnect: result.reconnect,
+    status: result.status
+  };
+}
+function useTrackedDataSwr(key, source, options = {}) {
+  const cacheKey = `${PREFIX_TRACKED}${key}`;
+  const seed = readSwrCache(cacheKey);
+  const result = useTrackedData(source, options);
+  if (result.status.value === "disabled") {
+    deleteSwrCache(cacheKey);
+  }
+  watch(
+    [result.data, result.error, result.status],
+    ([data2, error2, status]) => writeSwrResult(cacheKey, data2, error2, status),
+    { flush: "sync" }
+  );
+  const data = computed(() => {
+    if (result.status.value === "disabled") {
+      return void 0;
+    }
+    return result.data.value ?? seed?.data;
+  });
+  const error = computed(
+    () => swrError(result.error.value, result.status.value, seed)
+  );
+  return {
+    data,
+    error,
+    refresh: result.refresh,
+    status: result.status
+  };
+}
+
+export { clearSwrCache, useRequestSwr, useSubscriptionSwr, useTrackedDataSwr };

package/dist/useAccountInfo.cjs

@@ -1,12 +1,13 @@
 'use strict';
 
-const useAccountInfo = require('./shared/vue.BMencBpI.cjs');
+const useAccountInfo = require('./shared/vue.D-qi8PSL.cjs');
 require('@vue-solana/core/errors');
 require('vue');
 require('@vue-solana/core/address');
-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');
 require('./shared/vue.DNxOpDXz.cjs');
 
 

package/dist/useAccountInfo.mjs

@@ -1,8 +1,9 @@
-export { u as useAccountInfo } from './shared/vue.dPRo2X5y.mjs';
+export { u as useAccountInfo } from './shared/vue.BQRpjwKl.mjs';
 import '@vue-solana/core/errors';
 import 'vue';
 import '@vue-solana/core/address';
-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';
 import './shared/vue.Bfu1dCKe.mjs';

package/dist/useAction.cjs

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

package/dist/useAction.d.cts

@@ -0,0 +1,45 @@
+import { ComputedRef, Ref } from 'vue';
+
+type UseActionStatus = "idle" | "running" | "success" | "error";
+interface UseActionOptions {
+    /**
+     * Called after a dispatch settles successfully.
+     */
+    onSuccess?: (data: unknown) => void;
+    /**
+     * Called after a dispatch fails for a reason other than supersession.
+     */
+    onError?: (error: unknown) => void;
+}
+interface UseActionReturn<TArgs extends readonly unknown[], TResult> {
+    data: ComputedRef<TResult | undefined>;
+    dispatch: (...args: TArgs) => Promise<TResult>;
+    error: ComputedRef<unknown>;
+    isRunning: ComputedRef<boolean>;
+    reset: () => void;
+    status: ComputedRef<UseActionStatus>;
+}
+/**
+ * Generic async action state machine.
+ *
+ * Accepts any async function that receives a fresh `AbortSignal` per call and
+ * tracks `{ data, dispatch, error, isRunning, reset, status }` through Vue
+ * reactive state.
+ *
+ * - There is no dependencies array: pass the handler directly or as a ref;
+ *   `dispatch` always invokes the latest closure, so handlers reading
+ *   reactive state never see stale values. `dispatch` keeps a stable identity
+ *   across the component lifetime.
+ * - Calling `dispatch` again while a call is in flight aborts the previous
+ *   call. Superseded calls reject with an abort reason so callers can detect
+ *   them; they never corrupt state.
+ * - Failures surface on `error` while the previous `data` is preserved for
+ *   stale-while-revalidate rendering.
+ *
+ * The underlying state machine is `createSolanaActionStore` from
+ * `@vue-solana/core/action`, shared with non-Vue consumers.
+ */
+declare function useAction<TArgs extends readonly unknown[], TResult>(action: ((signal: AbortSignal, ...args: TArgs) => Promise<TResult>) | Ref<(signal: AbortSignal, ...args: TArgs) => Promise<TResult>>, options?: UseActionOptions): UseActionReturn<TArgs, TResult>;
+
+export { useAction };
+export type { UseActionOptions, UseActionReturn, UseActionStatus };

package/dist/useAction.d.mts

@@ -0,0 +1,45 @@
+import { ComputedRef, Ref } from 'vue';
+
+type UseActionStatus = "idle" | "running" | "success" | "error";
+interface UseActionOptions {
+    /**
+     * Called after a dispatch settles successfully.
+     */
+    onSuccess?: (data: unknown) => void;
+    /**
+     * Called after a dispatch fails for a reason other than supersession.
+     */
+    onError?: (error: unknown) => void;
+}
+interface UseActionReturn<TArgs extends readonly unknown[], TResult> {
+    data: ComputedRef<TResult | undefined>;
+    dispatch: (...args: TArgs) => Promise<TResult>;
+    error: ComputedRef<unknown>;
+    isRunning: ComputedRef<boolean>;
+    reset: () => void;
+    status: ComputedRef<UseActionStatus>;
+}
+/**
+ * Generic async action state machine.
+ *
+ * Accepts any async function that receives a fresh `AbortSignal` per call and
+ * tracks `{ data, dispatch, error, isRunning, reset, status }` through Vue
+ * reactive state.
+ *
+ * - There is no dependencies array: pass the handler directly or as a ref;
+ *   `dispatch` always invokes the latest closure, so handlers reading
+ *   reactive state never see stale values. `dispatch` keeps a stable identity
+ *   across the component lifetime.
+ * - Calling `dispatch` again while a call is in flight aborts the previous
+ *   call. Superseded calls reject with an abort reason so callers can detect
+ *   them; they never corrupt state.
+ * - Failures surface on `error` while the previous `data` is preserved for
+ *   stale-while-revalidate rendering.
+ *
+ * The underlying state machine is `createSolanaActionStore` from
+ * `@vue-solana/core/action`, shared with non-Vue consumers.
+ */
+declare function useAction<TArgs extends readonly unknown[], TResult>(action: ((signal: AbortSignal, ...args: TArgs) => Promise<TResult>) | Ref<(signal: AbortSignal, ...args: TArgs) => Promise<TResult>>, options?: UseActionOptions): UseActionReturn<TArgs, TResult>;
+
+export { useAction };
+export type { UseActionOptions, UseActionReturn, UseActionStatus };

package/dist/useAction.d.ts

@@ -0,0 +1,45 @@
+import { ComputedRef, Ref } from 'vue';
+
+type UseActionStatus = "idle" | "running" | "success" | "error";
+interface UseActionOptions {
+    /**
+     * Called after a dispatch settles successfully.
+     */
+    onSuccess?: (data: unknown) => void;
+    /**
+     * Called after a dispatch fails for a reason other than supersession.
+     */
+    onError?: (error: unknown) => void;
+}
+interface UseActionReturn<TArgs extends readonly unknown[], TResult> {
+    data: ComputedRef<TResult | undefined>;
+    dispatch: (...args: TArgs) => Promise<TResult>;
+    error: ComputedRef<unknown>;
+    isRunning: ComputedRef<boolean>;
+    reset: () => void;
+    status: ComputedRef<UseActionStatus>;
+}
+/**
+ * Generic async action state machine.
+ *
+ * Accepts any async function that receives a fresh `AbortSignal` per call and
+ * tracks `{ data, dispatch, error, isRunning, reset, status }` through Vue
+ * reactive state.
+ *
+ * - There is no dependencies array: pass the handler directly or as a ref;
+ *   `dispatch` always invokes the latest closure, so handlers reading
+ *   reactive state never see stale values. `dispatch` keeps a stable identity
+ *   across the component lifetime.
+ * - Calling `dispatch` again while a call is in flight aborts the previous
+ *   call. Superseded calls reject with an abort reason so callers can detect
+ *   them; they never corrupt state.
+ * - Failures surface on `error` while the previous `data` is preserved for
+ *   stale-while-revalidate rendering.
+ *
+ * The underlying state machine is `createSolanaActionStore` from
+ * `@vue-solana/core/action`, shared with non-Vue consumers.
+ */
+declare function useAction<TArgs extends readonly unknown[], TResult>(action: ((signal: AbortSignal, ...args: TArgs) => Promise<TResult>) | Ref<(signal: AbortSignal, ...args: TArgs) => Promise<TResult>>, options?: UseActionOptions): UseActionReturn<TArgs, TResult>;
+
+export { useAction };
+export type { UseActionOptions, UseActionReturn, UseActionStatus };