@kheopskit/core 5.2.1 → 6.0.0-rc.0

package/dist/index.mjs

@@ -1,171 +1,9 @@
-import { a as isValidWalletId, c as clearAllCachedObservables, i as getWalletId, n as isWalletConnectWallet, o as parseWalletId, r as WALLET_CONNECT_WALLET_ID, s as isWalletPlatform, t as isInjectedWallet, u as clearCachedObservablesByPrefix } from "./types-jnifAAA0.mjs";
-import { i as isValidAddress, n as getWalletAccountId, r as parseWalletAccountId, t as KheopskitError } from "./errors-BLFP1dQI.mjs";
-import { a as safeLocalStorage, c as serializeAccount, l as serializeWallet, n as setCachedIcons, o as hydrateAccount, r as cookieStorage, s as hydrateWallet, t as getCachedIcon } from "./iconCache-pP2ES4pJ.mjs";
-import { BehaviorSubject, Observable, Subscription, combineLatest, debounceTime, distinctUntilChanged, filter, from, map, mergeMap, of, shareReplay, startWith, switchMap, take, tap, throttleTime, timer } from "rxjs";
+import { c as walletPendingError, d as isValidWalletId, f as parseWalletId, i as abortedError, l as WALLET_CONNECT_WALLET_ID, m as clearAllCachedObservables, n as isWalletConnectWallet, p as isWalletPlatform, r as KheopskitError, t as isInjectedWallet, u as getWalletId } from "./types-Yor672md.mjs";
+import { c as isValidAddress, n as framesOf, o as getWalletAccountId, s as parseWalletAccountId } from "./platformAccounts-yyRUrnel.mjs";
+import { a as safeLocalStorage, c as serializeAccount, l as serializeWallet, n as setCachedIcons, o as hydrateAccount, r as cookieStorage, s as hydrateWallet, t as getCachedIcon } from "./iconCache-C-U3IEbP.mjs";
+import { t as pageLoaded$ } from "./pageLoad-BZ7o8p5R.mjs";
+import { BehaviorSubject, Observable, Subscription, asapScheduler, combineLatest, debounceTime, distinctUntilChanged, filter, map, mergeMap, of, shareReplay, startWith, switchMap, take, tap, timer } from "rxjs";
 import { uniq } from "lodash-es";
-//#region src/api/appKit.ts
-/**
-* Dynamically import @reown/appkit/core to avoid loading browser-only code
-* during SSR or in edge runtimes like Cloudflare Workers.
-* The AppKit library uses Lit for web components which requires document.
-*/
-const loadAppKit = async () => {
-	try {
-		const { createAppKit } = await import("@reown/appkit/core");
-		return createAppKit;
-	} catch (cause) {
-		console.error("[kheopskit] WalletConnect is configured but @reown/appkit could not be loaded. Install it with `pnpm add @reown/appkit` (or remove config.walletConnect). WalletConnect wallets are disabled; injected wallets still work.", cause);
-		return null;
-	}
-};
-const WALLET_CONNECT_ICON = "data:image/svg+xml;base64,PHN2ZyBmaWxsPSJub25lIiBoZWlnaHQ9IjQwMCIgdmlld0JveD0iMCAwIDQwMCA0MDAiIHdpZHRoPSI0MDAiIHhtbG5zPSJodHRwOi8vd3d3LnczLm9yZy8yMDAwL3N2ZyIgeG1sbnM6eGxpbms9Imh0dHA6Ly93d3cudzMub3JnLzE5OTkveGxpbmsiPjxjbGlwUGF0aCBpZD0iYSI+PHBhdGggZD0ibTAgMGg0MDB2NDAwaC00MDB6Ii8+PC9jbGlwUGF0aD48ZyBjbGlwLXBhdGg9InVybCgjYSkiPjxjaXJjbGUgY3g9IjIwMCIgY3k9IjIwMCIgZmlsbD0iIzMzOTZmZiIgcj0iMTk5LjUiIHN0cm9rZT0iIzY2YjFmZiIvPjxwYXRoIGQ9Im0xMjIuNTE5IDE0OC45NjVjNDIuNzkxLTQxLjcyOSAxMTIuMTcxLTQxLjcyOSAxNTQuOTYyIDBsNS4xNSA1LjAyMmMyLjE0IDIuMDg2IDIuMTQgNS40NjkgMCA3LjU1NWwtMTcuNjE3IDE3LjE4Yy0xLjA3IDEuMDQzLTIuODA0IDEuMDQzLTMuODc0IDBsLTcuMDg3LTYuOTExYy0yOS44NTMtMjkuMTExLTc4LjI1My0yOS4xMTEtMTA4LjEwNiAwbC03LjU5IDcuNDAxYy0xLjA3IDEuMDQzLTIuODA0IDEuMDQzLTMuODc0IDBsLTE3LjYxNy0xNy4xOGMtMi4xNC0yLjA4Ni0yLjE0LTUuNDY5IDAtNy41NTV6bTE5MS4zOTcgMzUuNTI5IDE1LjY3OSAxNS4yOWMyLjE0IDIuMDg2IDIuMTQgNS40NjkgMCA3LjU1NWwtNzAuNyA2OC45NDRjLTIuMTM5IDIuMDg3LTUuNjA4IDIuMDg3LTcuNzQ4IDBsLTUwLjE3OC00OC45MzFjLS41MzUtLjUyMi0xLjQwMi0uNTIyLTEuOTM3IDBsLTUwLjE3OCA0OC45MzFjLTIuMTM5IDIuMDg3LTUuNjA4IDIuMDg3LTcuNzQ4IDBsLTcwLjcwMTUtNjguOTQ1Yy0yLjEzOTYtMi4wODYtMi4xMzk2LTUuNDY5IDAtNy41NTVsMTUuNjc5NS0xNS4yOWMyLjEzOTYtMi4wODYgNS42MDg1LTIuMDg2IDcuNzQ4MSAwbDUwLjE3ODkgNDguOTMyYy41MzUuNTIyIDEuNDAyLjUyMiAxLjkzNyAwbDUwLjE3Ny00OC45MzJjMi4xMzktMi4wODcgNS42MDgtMi4wODcgNy43NDggMGw1MC4xNzkgNDguOTMyYy41MzUuNTIyIDEuNDAyLjUyMiAxLjkzNyAwbDUwLjE3OS00OC45MzFjMi4xMzktMi4wODcgNS42MDgtMi4wODcgNy43NDggMHoiIGZpbGw9IiNmZmYiLz48L2c+PC9zdmc+";
-const APPKIT_SYMBOL = Symbol.for("kheopskit.cachedAppKit");
-const APPKIT_PROJECT_ID_SYMBOL = Symbol.for("kheopskit.cachedAppKitProjectId");
-const getCachedAppKit = () => globalThis[APPKIT_SYMBOL];
-const getCachedAppKitProjectId = () => globalThis[APPKIT_PROJECT_ID_SYMBOL];
-const setCachedAppKit = (value, projectId) => {
-	globalThis[APPKIT_SYMBOL] = value;
-	globalThis[APPKIT_PROJECT_ID_SYMBOL] = projectId;
-};
-/**
-* Clears the cached AppKit observable.
-* Use when configuration changes or for testing purposes.
-* Note: This does NOT destroy the appKit instance created by Reown.
-*/
-const resetAppKitCache = () => {
-	setCachedAppKit(void 0);
-};
-/**
-* Drops a WalletConnect namespace's cached account observables. Called when a
-* namespace transitions to disconnected — including external disconnects (from
-* the wallet app), which flip status via `subscribeProviders` without ever
-* calling `disconnect()` — so a later reconnect rebuilds the account observables
-* against the fresh session instead of a stale closure.
-*
-* Keys are `accounts:<walletId>:...`; the trailing colon scopes the prefix to
-* this wallet and avoids matching a sibling whose id is a string prefix.
-*/
-const dropAccountsCache = (platform) => {
-	clearCachedObservablesByPrefix(`accounts:${WALLET_CONNECT_WALLET_ID}:${platform}:`);
-};
-/**
-* The single, platform-less WalletConnect connector for the given config — or
-* `null` when WalletConnect isn't configured, on the server, or when
-* `@reown/appkit` isn't installed.
-*
-* @remarks
-* The AppKit instance is a process-wide singleton (Reown AppKit itself cannot
-* be instantiated twice). The **first** call with a `walletConnect` config wins;
-* later calls with a *different* `walletConnect` config reuse that first
-* instance. Call {@link resetAppKitCache} before re-initialising if the
-* WalletConnect config must change.
-*
-* One WalletConnect session is shared across every namespace, and a namespace
-* can only be established during the initial pairing — it can't be added to a
-* live session afterwards. So this exposes ONE connector (not one per platform):
-* `connect()` opens the modal; the wallet approves whichever namespaces it
-* supports in that single pairing, and `platforms` reflects what the live
-* session carries. Per-namespace accounts are derived by each platform plugin.
-*/
-const getWalletConnectWallet$ = (config) => {
-	if (!config.walletConnect) return of(null);
-	if (typeof window === "undefined") return of(null);
-	const walletConnect = config.walletConnect;
-	const cachedProjectId = getCachedAppKitProjectId();
-	if (cachedProjectId !== void 0 && cachedProjectId !== walletConnect.projectId) console.warn("[kheopskit] WalletConnect is already initialised with projectId %s; AppKit is a process-wide singleton, so the first configuration wins and projectId %s is ignored. Call resetAppKitCache() before re-initialising if the WalletConnect config must change.", cachedProjectId, walletConnect.projectId);
-	let cachedAppKit = getCachedAppKit();
-	if (!cachedAppKit) {
-		cachedAppKit = from(loadAppKit()).pipe(switchMap((createAppKit) => {
-			if (!createAppKit) return of(null);
-			return new Observable((subscriber) => {
-				const appKit = createAppKit({
-					projectId: walletConnect.projectId,
-					metadata: walletConnect.metadata,
-					networks: walletConnect.networks,
-					themeMode: walletConnect.themeMode,
-					themeVariables: walletConnect.themeVariables,
-					universalProviderConfigOverride: { methods: {
-						polkadot: ["polkadot_signTransaction", "polkadot_signMessage"],
-						solana: [
-							"solana_signTransaction",
-							"solana_signMessage",
-							"solana_signAndSendTransaction"
-						]
-					} },
-					allWallets: "HIDE",
-					debug: config.debug,
-					allowUnsupportedChain: true
-				});
-				const appKitInstance = appKit;
-				const status$ = new BehaviorSubject({
-					isPolkadotConnected: false,
-					isEthereumConnected: false,
-					isSolanaConnected: false
-				});
-				const unsubProviders = appKit.subscribeProviders((providers) => {
-					status$.next({
-						isPolkadotConnected: !!providers.polkadot,
-						isEthereumConnected: !!providers.eip155,
-						isSolanaConnected: !!providers.solana
-					});
-				});
-				const namespaceOf = {
-					polkadot: "polkadot",
-					ethereum: "eip155",
-					solana: "solana"
-				};
-				const allPlatforms = [
-					"polkadot",
-					"ethereum",
-					"solana"
-				];
-				const enabledPlatforms = allPlatforms.filter((p) => appKit.chainNamespaces.includes(namespaceOf[p]));
-				let prevConnected = {
-					polkadot: false,
-					ethereum: false,
-					solana: false
-				};
-				const sub = status$.pipe(map((s) => ({
-					polkadot: s.isPolkadotConnected,
-					ethereum: s.isEthereumConnected,
-					solana: s.isSolanaConnected
-				})), distinctUntilChanged((a, b) => a.polkadot === b.polkadot && a.ethereum === b.ethereum && a.solana === b.solana), tap((connected) => {
-					for (const platform of allPlatforms) if (prevConnected[platform] && !connected[platform]) dropAccountsCache(platform);
-					prevConnected = connected;
-				}), map((connected) => {
-					const platforms = enabledPlatforms.filter((p) => connected[p]);
-					const isConnected = platforms.length > 0;
-					const walletInfo = appKit.getWalletInfo();
-					return {
-						id: WALLET_CONNECT_WALLET_ID,
-						type: "walletconnect",
-						platforms,
-						appKit: appKitInstance,
-						name: walletInfo?.name ?? "WalletConnect",
-						icon: walletInfo?.icon ?? WALLET_CONNECT_ICON,
-						connect: async () => {
-							if (!isConnected) await appKit.open();
-						},
-						disconnect: async () => {
-							if (isConnected) await appKit.disconnect();
-						},
-						isConnected
-					};
-				})).subscribe(subscriber);
-				return () => {
-					sub.unsubscribe();
-					unsubProviders();
-				};
-			});
-		}), shareReplay({
-			refCount: false,
-			bufferSize: 1
-		}));
-		setCachedAppKit(cachedAppKit, walletConnect.projectId);
-	}
-	return cachedAppKit;
-};
-//#endregion
 //#region src/api/config.ts
 /**
 * Default storage key for persisting wallet connection state.
@@ -177,12 +15,14 @@ const DEFAULTS = {
 	autoReconnect: true,
 	debug: false,
 	storageKey: DEFAULT_STORAGE_KEY,
-	hydrationGracePeriod: 500
+	hydrationGracePeriod: 500,
+	hydrationTimeout: 3e3
 };
 const resolveConfig = (config) => {
 	const platforms = config?.platforms ?? [];
 	const invalidPlatforms = platforms.filter((p) => typeof p !== "object" || p === null || typeof p.getWallets$ !== "function");
 	if (invalidPlatforms.length > 0) throw new Error(`[kheopskit] config.platforms must contain plugin instances created by the per-platform factories (e.g. platforms: [polkadot(), ethereum(), solana()] imported from "@kheopskit/core/<platform>"). Invalid entries: ${JSON.stringify(invalidPlatforms)}. String platform names like "polkadot" were removed in v4 — see MIGRATING_TO_V4.md.`);
+	if (config?.walletConnect !== void 0 && typeof config.walletConnect?.getWallet$ !== "function") throw new KheopskitError("INVALID_CONFIG", "config.walletConnect must be created by walletConnect() imported from \"@kheopskit/core/walletconnect\", e.g. walletConnect: walletConnect({ projectId, metadata, networks }). Raw WalletConnect options were removed in v6, see MIGRATING_TO_V6.md.");
 	if (platforms.length === 0) console.warn("[kheopskit] No platforms configured; wallets and accounts will be empty. Pass e.g. platforms: [polkadot()] from \"@kheopskit/core/polkadot\".");
 	return Object.assign({}, DEFAULTS, config, { platforms });
 };
@@ -193,17 +33,14 @@ const PLATFORM_ORDER$1 = {
 	ethereum: 1,
 	solana: 2
 };
+const byPlatform = (a1, a2) => PLATFORM_ORDER$1[a1.platform] - PLATFORM_ORDER$1[a2.platform];
 const byWalletName = (a1, a2) => {
+	if (a1.walletName === a2.walletName) return 0;
 	if (a1.walletName.toLowerCase() === "talisman") return -1;
 	if (a2.walletName.toLowerCase() === "talisman") return 1;
 	return a1.walletName.localeCompare(a2.walletName);
 };
-const sortAccounts = (a1, a2) => {
-	if (a1.platform !== a2.platform) return PLATFORM_ORDER$1[a1.platform] - PLATFORM_ORDER$1[a2.platform];
-	if (a1.walletName !== a2.walletName) return byWalletName(a1, a2);
-	if (a1.platform === "polkadot" && a2.platform === "polkadot") return a1.name !== a2.name ? (a1.name ?? "").localeCompare(a2.name ?? "") : a1.address.localeCompare(a2.address);
-	return a1.id.localeCompare(a2.id);
-};
+const sortAccounts = (a1, a2) => byPlatform(a1, a2) || byWalletName(a1, a2);
 //#endregion
 //#region src/utils/sortWallets.ts
 const PLATFORM_ORDER = {
@@ -232,58 +69,80 @@ const acceptsCachedAccount = (cached, platforms) => {
 	return platforms.find((p) => p.platform === cached.platform)?.acceptsCachedAccount?.(cached) ?? true;
 };
 //#endregion
+//#region src/api/reconnectPolicy.ts
+const createReconnectPolicy = ({ maxAttempts = 3 } = {}) => {
+	const states = /* @__PURE__ */ new Map();
+	const shouldAttempt = (walletId) => {
+		const state = states.get(walletId);
+		if (!state) return true;
+		return state.kind === "failed" && state.attempts < maxAttempts;
+	};
+	const attempt = async (walletId, connect) => {
+		if (!shouldAttempt(walletId)) return false;
+		const before = states.get(walletId);
+		states.set(walletId, { kind: "pending" });
+		const recordOutcome = (outcome) => {
+			if (states.get(walletId)?.kind !== "settled") states.set(walletId, outcome);
+		};
+		try {
+			await connect();
+			recordOutcome({ kind: "reconnected" });
+			return true;
+		} catch (err) {
+			recordOutcome({
+				kind: "failed",
+				attempts: before?.kind === "failed" ? before.attempts + 1 : 1
+			});
+			throw err;
+		}
+	};
+	const settle = (walletId) => {
+		states.set(walletId, { kind: "settled" });
+	};
+	return {
+		shouldAttempt,
+		attempt,
+		settle
+	};
+};
+const reconnectAccepts = (autoReconnect, wallet) => typeof autoReconnect === "function" ? autoReconnect(wallet) : autoReconnect;
+//#endregion
 //#region src/api/hydration.ts
 /**
 * Builds the cached-state snapshot every consumer must agree on: read the
-* store's cached state, hydrate wallets/accounts into placeholders, filter
-* accounts through each platform plugin's `acceptsCachedAccount` hook, and sort
-* with the same comparators the live pipeline uses.
+* store's cached state, hydrate wallets/accounts into placeholders, apply the
+* `autoReconnect` rule (a cached connected wallet it rejects becomes
+* `disconnected` and loses its cached accounts), filter accounts through each
+* platform plugin's `acceptsCachedAccount` hook, and sort with the same
+* comparators the live pipeline uses.
 *
 * This is the single implementation behind the observable's initial seed and
 * both React snapshot sources (`serverValue`/`initialValue`). They must produce
 * the same shape in the same order or the UI flickers/reorders on reload — by
 * sharing this helper, that agreement holds by construction.
 */
-const getHydratedSnapshot = (store, platforms, options = {}) => {
+const getHydratedSnapshot = (store, config, options = {}) => {
 	const cached = store.getCachedState();
+	const wallets = cached.wallets.map(hydrateWallet).map((wallet) => wallet.status === "connecting" && isInjectedWallet(wallet) && !reconnectAccepts(config.autoReconnect, wallet) ? {
+		...wallet,
+		status: "disconnected"
+	} : wallet).map((wallet) => {
+		if (!options.icons || wallet.icon) return wallet;
+		const icon = getCachedIcon(wallet.id);
+		return icon ? {
+			...wallet,
+			icon
+		} : wallet;
+	}).sort(sortWallets);
+	const disconnected = new Set(wallets.filter((w) => w.status === "disconnected").map((w) => w.id));
 	return {
-		wallets: cached.wallets.map((cachedWallet) => {
-			const wallet = hydrateWallet(cachedWallet);
-			if (!options.icons || wallet.icon) return wallet;
-			const icon = getCachedIcon(wallet.id);
-			return icon ? {
-				...wallet,
-				icon
-			} : wallet;
-		}).sort(sortWallets),
-		accounts: cached.accounts.filter((account) => acceptsCachedAccount(account, platforms)).map(hydrateAccount).sort(sortAccounts)
+		wallets,
+		accounts: cached.accounts.filter((account) => !disconnected.has(account.walletId)).filter((account) => acceptsCachedAccount(account, config.platforms)).map(hydrateAccount).sort(sortAccounts)
 	};
 };
 //#endregion
 //#region src/utils/createHydrationBuffer.ts
-/**
-* Core hydration buffer logic shared between wallets and accounts.
-*
-* During the grace period:
-* - Emits cached items immediately (before any live emissions)
-* - As live items arrive, merges them using the provided merge function
-*
-* After the grace period (and convergence, if provided):
-* - Only live items are returned
-* - isHydrating becomes false
-*
-* If an `isConverged` function is provided, hydration ends only when BOTH
-* the grace period has elapsed AND the live items have converged with cached
-* items (e.g., all previously-connected wallets have reconnected).
-* A max timeout (6x grace period) prevents infinite hydration.
-*
-* @param cachedItems - Initial cached items from storage
-* @param liveItems$ - Observable of live items as they become available
-* @param gracePeriodMs - Time in ms to wait before syncing to live state
-* @param mergeFn - Function to merge live and cached items during hydration
-* @param isConverged - Optional function to check if live items have caught up to cached items
-*/
-const createBufferCore = (cachedItems, liveItems$, gracePeriodMs, mergeFn, isConverged) => {
+const createBufferCore = (cachedItems, liveItems$, gracePeriodMs, timeoutMs, mergeFn, settled$) => {
 	if (gracePeriodMs <= 0 || cachedItems.length === 0) return liveItems$.pipe(map((items) => ({
 		items,
 		isHydrating: false
@@ -291,30 +150,19 @@ const createBufferCore = (cachedItems, liveItems$, gracePeriodMs, mergeFn, isCon
 	return new Observable((subscriber) => {
 		const subscriptions = new Subscription();
 		const isHydrating$ = new BehaviorSubject(true);
-		const liveWithInitial$ = liveItems$.pipe(startWith([]));
-		if (isConverged) {
-			const timerFired$ = timer(gracePeriodMs).pipe(map(() => true), startWith(false), shareReplay({
-				bufferSize: 1,
-				refCount: true
-			}));
-			subscriptions.add(combineLatest([liveWithInitial$, timerFired$]).pipe(filter(([, timerFired]) => timerFired), filter(([liveItems]) => isConverged(liveItems, cachedItems)), take(1)).subscribe(() => {
-				isHydrating$.next(false);
-			}));
-			subscriptions.add(timer(gracePeriodMs * 6).subscribe(() => {
-				if (isHydrating$.value) isHydrating$.next(false);
-			}));
-		} else subscriptions.add(timer(gracePeriodMs).subscribe(() => {
-			isHydrating$.next(false);
-		}));
-		subscriptions.add(combineLatest([liveWithInitial$, isHydrating$]).pipe(map(([liveItems, isHydrating]) => {
-			if (!isHydrating) return {
-				items: liveItems,
-				isHydrating: false
-			};
-			return {
-				items: mergeFn(liveItems, cachedItems),
-				isHydrating: true
-			};
+		const endHydration = () => {
+			if (isHydrating$.value) isHydrating$.next(false);
+		};
+		const graceElapsed$ = timer(gracePeriodMs).pipe(map(() => true), startWith(false));
+		const ended$ = settled$ ? combineLatest([graceElapsed$, settled$]).pipe(filter(([graceElapsed, settled]) => graceElapsed && settled), take(1)) : timer(gracePeriodMs);
+		subscriptions.add(ended$.subscribe(endHydration));
+		subscriptions.add(timer(timeoutMs).subscribe(endHydration));
+		subscriptions.add(combineLatest([liveItems$.pipe(startWith([])), isHydrating$]).pipe(map(([liveItems, isHydrating]) => isHydrating ? {
+			items: mergeFn(liveItems, cachedItems),
+			isHydrating
+		} : {
+			items: liveItems,
+			isHydrating
 		})).subscribe(subscriber));
 		return () => {
 			subscriptions.unsubscribe();
@@ -331,14 +179,15 @@ const createBufferCore = (cachedItems, liveItems$, gracePeriodMs, mergeFn, isCon
 *
 * @param cachedItems - Initial cached items from storage
 * @param liveItems$ - Observable of live items as they become available
-* @param gracePeriodMs - Time in ms to wait before syncing to live state
+* @param gracePeriodMs - Minimum time in ms the cached items are shown
+* @param timeoutMs - Upper bound in ms on hydration
 * @param getKey - Function to extract a unique key from an item
-* @param isConverged - Optional function to check if live items have caught up to cached items
+* @param settled$ - Whether the live state has caught up with the cache
 * @param mergeItem - Optional function to merge a live item with its cached counterpart
 * @param transformCachedOnly - Optional function to transform cached items not yet in the live stream
 */
-const createHydrationBuffer = (cachedItems, liveItems$, gracePeriodMs, getKey, isConverged, mergeItem, transformCachedOnly) => {
-	return createBufferCore(cachedItems, liveItems$, gracePeriodMs, (liveItems, cached) => {
+const createHydrationBuffer = (cachedItems, liveItems$, gracePeriodMs, timeoutMs, getKey, settled$, mergeItem, transformCachedOnly) => {
+	return createBufferCore(cachedItems, liveItems$, gracePeriodMs, timeoutMs, (liveItems, cached) => {
 		const cachedByKey = new Map(cached.map((item) => [getKey(item), item]));
 		const liveKeys = new Set(liveItems.map(getKey));
 		const mergedItems = liveItems.map((liveItem) => {
@@ -352,7 +201,7 @@ const createHydrationBuffer = (cachedItems, liveItems$, gracePeriodMs, getKey, i
 			mergedItems.push(transformed);
 		}
 		return mergedItems;
-	}, isConverged);
+	}, settled$);
 };
 /**
 * Creates a hydration buffer specifically for accounts, which need special handling.
@@ -363,17 +212,18 @@ const createHydrationBuffer = (cachedItems, liveItems$, gracePeriodMs, getKey, i
 *
 * @param cachedAccounts - Initial cached accounts from storage
 * @param liveAccounts$ - Observable of live accounts as they become available
-* @param gracePeriodMs - Time in ms to wait before syncing to live state
+* @param gracePeriodMs - Minimum time in ms the cached accounts are shown
+* @param timeoutMs - Upper bound in ms on hydration
 * @param getWalletId - Function to extract the wallet ID from an account
-* @param isConverged - Optional function to check if live accounts have caught up to cached accounts
+* @param settled$ - Whether the live state has caught up with the cache
 */
-const createAccountHydrationBuffer = (cachedAccounts, liveAccounts$, gracePeriodMs, getWalletId, isConverged) => {
-	return createBufferCore(cachedAccounts, liveAccounts$, gracePeriodMs, (liveAccounts, cached) => {
+const createAccountHydrationBuffer = (cachedAccounts, liveAccounts$, gracePeriodMs, timeoutMs, getWalletId, settled$) => {
+	return createBufferCore(cachedAccounts, liveAccounts$, gracePeriodMs, timeoutMs, (liveAccounts, cached) => {
 		const walletsWithLiveAccounts = new Set(liveAccounts.map(getWalletId));
 		const mergedAccounts = [...liveAccounts];
 		for (const cachedAccount of cached) if (!walletsWithLiveAccounts.has(getWalletId(cachedAccount))) mergedAccounts.push(cachedAccount);
 		return mergedAccounts;
-	}, isConverged);
+	}, settled$);
 };
 //#endregion
 //#region src/utils/logObservable.ts
@@ -388,8 +238,14 @@ const logObservable = (label, opts) => tap((value) => {
 //#region src/api/accounts.ts
 const getAccounts$ = (config, wallets) => {
 	return new Observable((subscriber) => {
-		const sources = config.platforms.map((plugin) => plugin.getAccounts$(wallets.pipe(map((ws) => ws.filter((w) => isWalletConnectWallet(w) || w.platform === plugin.platform)))));
-		const sub = (sources.length ? combineLatest(sources).pipe(map((accounts) => accounts.flat().sort(sortAccounts))) : of([])).subscribe(subscriber);
+		const sources = config.platforms.map((plugin) => framesOf(plugin.getAccounts$(wallets.pipe(map((ws) => ws.filter((w) => isWalletConnectWallet(w) || w.platform === plugin.platform))))));
+		const sub = (sources.length ? combineLatest(sources).pipe(map((frames) => ({
+			accounts: frames.flatMap((frame) => frame.accounts).sort(sortAccounts),
+			answered: frames.flatMap((frame) => frame.answered)
+		}))) : of({
+			accounts: [],
+			answered: []
+		})).subscribe(subscriber);
 		return () => {
 			sub.unsubscribe();
 		};
@@ -400,28 +256,41 @@ const getAccounts$ = (config, wallets) => {
 };
 //#endregion
 //#region src/utils/createStore.ts
-const createStore = (key, defaultValue, storage = safeLocalStorage) => {
-	const subject = new BehaviorSubject(getStoredData(key, defaultValue, storage));
-	let unsubscribeStorage;
-	if (typeof window !== "undefined" && storage.subscribe) unsubscribeStorage = storage.subscribe(key, (newValue) => {
-		subject.next(parseData(newValue, defaultValue));
+const createStore = (key, defaultValue, storage = safeLocalStorage, normalize = (value) => value) => {
+	const read = (str) => normalize(parseData(str, defaultValue));
+	const syncsAcrossTabs = typeof window !== "undefined" && storage.subscribe !== void 0;
+	const subject = new BehaviorSubject(read(storage.getItem(key)));
+	let observers = 0;
+	let stopSync;
+	const latestValue = () => {
+		if (syncsAcrossTabs && observers === 0) subject.next(read(storage.getItem(key)));
+		return subject.getValue();
+	};
+	const observable = new Observable((subscriber) => {
+		if (observers === 0 && syncsAcrossTabs) {
+			latestValue();
+			stopSync = storage.subscribe?.(key, (newValue) => {
+				subject.next(read(newValue));
+			});
+		}
+		observers++;
+		const subscription = subject.subscribe(subscriber);
+		return () => {
+			subscription.unsubscribe();
+			observers--;
+			if (observers === 0) stopSync?.();
+		};
 	});
 	const update = (val) => {
-		setStoredData(key, val, storage);
+		persistBestEffort(key, val, storage);
 		subject.next(val);
 	};
 	return {
-		observable: subject.asObservable(),
+		observable,
 		set: (val) => update(val),
-		mutate: (transform) => update(transform(subject.getValue())),
-		get: () => structuredClone(subject.getValue()),
-		/**
-		* Cleanup subscriptions. Call this when the store is no longer needed.
-		*/
-		destroy: () => {
-			unsubscribeStorage?.();
-			subject.complete();
-		}
+		mutate: (transform) => update(transform(latestValue())),
+		get: () => structuredClone(latestValue()),
+		destroy: () => subject.complete()
 	};
 };
 const parseData = (str, defaultValue) => {
@@ -430,17 +299,23 @@ const parseData = (str, defaultValue) => {
 	} catch {}
 	return defaultValue;
 };
-const getStoredData = (key, defaultValue, storage) => {
-	const str = storage.getItem(key);
-	return parseData(str, defaultValue);
-};
-const setStoredData = (key, val, storage) => {
+const persistBestEffort = (key, val, storage) => {
 	const str = JSON.stringify(val);
-	storage.setItem(key, str);
+	try {
+		storage.setItem(key, str);
+	} catch {}
 };
 //#endregion
 //#region src/api/compactStore.ts
 const EMPTY_STORE_DATA = {};
+const migratePreV6StoreData = (data) => {
+	if (data?.autoReconnect === void 0) return data;
+	const { autoReconnect, ...rest } = data;
+	return rest.remembered === void 0 && Array.isArray(autoReconnect) ? {
+		...rest,
+		remembered: autoReconnect
+	} : rest;
+};
 const toCompactPolkadotAccountType = (type) => {
 	switch (type) {
 		case "sr25519": return 0;
@@ -496,7 +371,7 @@ const toCompactStore = (data) => {
 	]);
 	return {
 		v: 1,
-		r: data.autoReconnect,
+		r: data.remembered,
 		w: wallets?.length ? wallets : void 0,
 		a: accounts?.length ? accounts : void 0
 	};
@@ -539,7 +414,7 @@ const fromCompactStore = (data) => {
 		});
 	}
 	return {
-		autoReconnect: data.r,
+		remembered: data.r,
 		cachedWallets: wallets,
 		cachedAccounts: accounts
 	};
@@ -548,7 +423,7 @@ const decodeStore = (raw, fallback) => {
 	try {
 		const parsed = JSON.parse(raw);
 		if (isCompactStore(parsed)) return fromCompactStore(parsed);
-		return parsed;
+		return migratePreV6StoreData(parsed);
 	} catch {
 		return fallback;
 	}
@@ -616,26 +491,26 @@ const isValidCachedAccount = (value) => {
 };
 /**
 * Creates a kheopskit store with the appropriate storage backend.
-* Uses cookieStorage when ssrCookies is provided (for SSR hydration),
-* otherwise falls back to safeLocalStorage.
+* Uses the given `storage` when provided, else cookieStorage when ssrCookies is
+* provided (for SSR hydration), otherwise safeLocalStorage.
 *
 * @param options - Configuration options for the store
 */
 const createKheopskitStore = (options = {}) => {
 	const { ssrCookies, storageKey = DEFAULT_STORAGE_KEY } = options;
-	const storage = ssrCookies !== void 0 ? createCompactCookieStorage(ssrCookies) : safeLocalStorage;
-	const store = createStore(storageKey, DEFAULT_SETTINGS, storage);
-	const addEnabledWalletId = (walletId) => {
+	const storage = options.storage ?? (ssrCookies !== void 0 ? createCompactCookieStorage(ssrCookies) : safeLocalStorage);
+	const store = createStore(storageKey, DEFAULT_SETTINGS, storage, migratePreV6StoreData);
+	const rememberWallet = (walletId) => {
 		parseWalletId(walletId);
 		store.mutate((prev) => ({
 			...prev,
-			autoReconnect: uniq((prev.autoReconnect ?? []).concat(walletId))
+			remembered: uniq((prev.remembered ?? []).concat(walletId))
 		}));
 	};
-	const removeEnabledWalletId = (walletId) => {
+	const forgetWallet = (walletId) => {
 		store.mutate((prev) => ({
 			...prev,
-			autoReconnect: uniq((prev.autoReconnect ?? []).filter((id) => id !== walletId))
+			remembered: uniq((prev.remembered ?? []).filter((id) => id !== walletId))
 		}));
 	};
 	const getCachedState = () => {
@@ -656,10 +531,11 @@ const createKheopskitStore = (options = {}) => {
 	};
 	return {
 		observable: store.observable,
-		addEnabledWalletId,
-		removeEnabledWalletId,
+		rememberWallet,
+		forgetWallet,
 		getCachedState,
-		setCachedState
+		setCachedState,
+		destroy: store.destroy
 	};
 };
 /**
@@ -679,43 +555,9 @@ const getDefaultStore = () => {
 	return g[DEFAULT_STORE_SYMBOL];
 };
 //#endregion
-//#region src/api/reconnectPolicy.ts
-const createReconnectPolicy = ({ maxAttempts = 3 } = {}) => {
-	const reconnecting = /* @__PURE__ */ new Set();
-	const reconnected = /* @__PURE__ */ new Set();
-	const failedAttempts = /* @__PURE__ */ new Map();
-	const shouldAttempt = (walletId) => !reconnecting.has(walletId) && !reconnected.has(walletId) && (failedAttempts.get(walletId) ?? 0) < maxAttempts;
-	/**
-	* Runs `connect` under the policy. Resolves `false` without connecting when
-	* an attempt is already in flight, the wallet already reconnected, or it
-	* exhausted its attempts; resolves `true` on success. A rejection from
-	* `connect` is recorded as a failed attempt and rethrown for the caller to
-	* report.
-	*/
-	const attempt = async (walletId, connect) => {
-		if (!shouldAttempt(walletId)) return false;
-		reconnecting.add(walletId);
-		try {
-			await connect();
-			reconnected.add(walletId);
-			failedAttempts.delete(walletId);
-			return true;
-		} catch (err) {
-			failedAttempts.set(walletId, (failedAttempts.get(walletId) ?? 0) + 1);
-			throw err;
-		} finally {
-			reconnecting.delete(walletId);
-		}
-	};
-	return {
-		shouldAttempt,
-		attempt
-	};
-};
-//#endregion
 //#region src/api/wallets.ts
 const getWallets$ = (config, store) => {
-	const autoReconnectWalletIds$ = store.observable.pipe(map((s) => s.autoReconnect ?? []), take(1), shareReplay({
+	const rememberedWalletIds$ = store.observable.pipe(map((s) => s.remembered ?? []), take(1), shareReplay({
 		bufferSize: 1,
 		refCount: true
 	}));
@@ -725,20 +567,39 @@ const getWallets$ = (config, store) => {
 			store
 		};
 		const observables = config.platforms.map((plugin) => plugin.getWallets$(ctx));
-		const platformWallets$ = observables.length ? combineLatest(observables).pipe(map((wallets) => wallets.flat())) : of([]);
-		const wallets$ = combineLatest([platformWallets$, getWalletConnectWallet$(config)]).pipe(map(([platformWallets, walletConnect]) => {
-			return (walletConnect ? [...platformWallets, walletConnect] : platformWallets).sort(sortWallets);
-		}));
 		const reconnectPolicy = createReconnectPolicy();
-		const subAutoReconnect = combineLatest([wallets$, autoReconnectWalletIds$]).pipe(filter(([, walletIds]) => config.autoReconnect && !!walletIds?.length), mergeMap(([wallets, walletIds]) => wallets.filter((wallet) => walletIds?.includes(wallet.id)))).subscribe(async (wallet) => {
-			if (wallet.isConnected) return;
+		const settleOnUserCall = (wallet) => ({
+			...wallet,
+			connect: (options) => {
+				reconnectPolicy.settle(wallet.id);
+				return wallet.connect(options);
+			},
+			disconnect: () => {
+				reconnectPolicy.settle(wallet.id);
+				return wallet.disconnect();
+			}
+		});
+		const platformWallets$ = observables.length ? combineLatest(observables).pipe(map((wallets) => wallets.flat())) : of([]);
+		const walletConnect$ = config.walletConnect?.getWallet$(ctx);
+		const rawWallets$ = (walletConnect$ ? combineLatest([platformWallets$, walletConnect$]).pipe(map(([platformWallets, walletConnect]) => walletConnect ? [...platformWallets, walletConnect] : platformWallets)) : platformWallets$).pipe(map((all) => all.sort(sortWallets)));
+		const wallets$ = rawWallets$.pipe(map((wallets) => wallets.map((wallet) => isInjectedWallet(wallet) ? settleOnUserCall(wallet) : wallet)));
+		const reconnect = async (wallet) => {
 			try {
 				await reconnectPolicy.attempt(wallet.id, () => wallet.connect());
 			} catch (err) {
-				console.error("Failed to reconnect wallet %s", wallet.id, { err });
+				if (subscriber.closed) return;
+				if (err instanceof KheopskitError) {
+					if (err.code === "USER_REJECTED") store.forgetWallet(wallet.id);
+					if (err.code === "USER_REJECTED" || err.code === "ABORTED") reconnectPolicy.settle(wallet.id);
+				}
+				if (config.debug) console.debug("[kheopskit] reconnect of %s failed", wallet.id, err);
 			}
-		});
+		};
 		const subWallets = wallets$.subscribe(subscriber);
+		if (subscriber.closed) return subWallets;
+		const subAutoReconnect = combineLatest([rawWallets$, rememberedWalletIds$]).pipe(filter(([, walletIds]) => config.autoReconnect !== false && walletIds.length > 0), mergeMap(([wallets, walletIds]) => wallets.filter(isInjectedWallet).filter((wallet) => walletIds.includes(wallet.id))), tap((wallet) => {
+			if (wallet.status === "connected") reconnectPolicy.settle(wallet.id);
+		}), filter((wallet) => wallet.status === "disconnected" && reconnectAccepts(config.autoReconnect, wallet))).subscribe(reconnect);
 		return () => {
 			subAutoReconnect.unsubscribe();
 			subWallets.unsubscribe();
@@ -759,33 +620,129 @@ const getKheopskit$ = (config, options = {}) => {
 	});
 	if (kc.debug) console.debug("[kheopskit] config", kc);
 	if (kc.debug && typeof window === "undefined" && ssrCookies === void 0) console.warn("[kheopskit] Running on server without `ssrCookies`. Wallet state will not be hydrated. Pass cookies for SSR support.");
-	const { wallets: cachedWallets, accounts: cachedAccounts } = getHydratedSnapshot(store, kc.platforms, { icons: true });
+	const { wallets: cachedWallets, accounts: cachedAccounts } = getHydratedSnapshot(store, kc, { icons: true });
 	if (kc.debug && cachedWallets.length > 0) console.debug("[kheopskit] hydrating from cache:", {
 		wallets: cachedWallets.length,
 		accounts: cachedAccounts.length
 	});
 	return new Observable((subscriber) => {
+		let latest;
+		let closed = false;
+		const waiters = /* @__PURE__ */ new Set();
+		const liveWaiters = /* @__PURE__ */ new Set();
+		const wrapped = /* @__PURE__ */ new WeakMap();
+		const abandon = (waiter) => {
+			waiters.delete(waiter);
+			if (waiter.isConnected) waiter.reject(abortedError(waiter.walletId, "connect"));
+			else waiter.resolve();
+		};
+		const settleIn = (waiter, state) => {
+			const wallet = state.wallets.find((w) => w.id === waiter.walletId);
+			if (!wallet || wallet.isConnected === waiter.isConnected) {
+				waiters.delete(waiter);
+				waiter.resolve();
+			}
+		};
+		const supersede = (walletId, isConnected) => {
+			for (const waiter of waiters) if (waiter.walletId === walletId && waiter.isConnected !== isConnected) abandon(waiter);
+		};
+		const whenState = (walletId, isConnected) => new Promise((resolve, reject) => {
+			const waiter = {
+				walletId,
+				isConnected,
+				resolve,
+				reject
+			};
+			waiters.add(waiter);
+			if (latest) settleIn(waiter, latest);
+			if (closed && waiters.has(waiter)) abandon(waiter);
+		});
+		const whenLive = (walletId, signal) => new Promise((resolve, reject) => {
+			const settle = (finish) => {
+				liveWaiters.delete(check);
+				signal?.removeEventListener("abort", onAbort);
+				finish();
+			};
+			const onAbort = () => settle(() => reject(abortedError(walletId, "connect")));
+			const check = (state) => {
+				if (!state) return onAbort();
+				const live = state.wallets.find((w) => w.id === walletId && !w.isPlaceholder);
+				if (live) settle(() => resolve(live));
+				else if (!state.isHydrating) settle(() => reject(walletPendingError(walletId)));
+			};
+			if (closed || signal?.aborted) return onAbort();
+			signal?.addEventListener("abort", onAbort, { once: true });
+			liveWaiters.add(check);
+			if (latest) check(latest);
+		});
+		const deferToLive = (placeholder) => ({
+			...placeholder,
+			connect: async (options) => {
+				const live = await whenLive(placeholder.id, options?.signal);
+				if (closed) throw abortedError(placeholder.id, "connect");
+				await live.connect(options);
+			}
+		});
+		const settleWithState = (wallet) => {
+			const existing = wrapped.get(wallet);
+			if (existing) return existing;
+			if (wallet.isPlaceholder) {
+				const deferred = deferToLive(wallet);
+				wrapped.set(wallet, deferred);
+				return deferred;
+			}
+			if (!isInjectedWallet(wallet)) return wallet;
+			const settled = {
+				...wallet,
+				connect: async (options) => {
+					if (closed) throw abortedError(wallet.id, "connect");
+					await wallet.connect(options);
+					supersede(wallet.id, true);
+					await whenState(wallet.id, true);
+				},
+				disconnect: async () => {
+					if (closed) throw abortedError(wallet.id, "disconnect");
+					await wallet.disconnect();
+					supersede(wallet.id, false);
+					await whenState(wallet.id, false);
+				}
+			};
+			wrapped.set(wallet, settled);
+			return settled;
+		};
 		const liveWallets$ = getWallets$(kc, store);
-		const liveAccounts$ = getAccounts$(kc, liveWallets$);
-		const bufferedWallets$ = createHydrationBuffer(cachedWallets, liveWallets$, kc.hydrationGracePeriod, (w) => w.id, (liveWallets, cached) => {
-			const cachedConnectedIds = new Set(cached.filter((w) => w.isConnected).map((w) => w.id));
-			if (cachedConnectedIds.size === 0) return true;
-			return [...cachedConnectedIds].every((id) => liveWallets.some((w) => w.id === id && w.isConnected));
-		}, (live, cached) => ({
-			...cached,
-			icon: cached.icon || getCachedIcon(cached.id) || live.icon,
-			connect: live.connect,
-			disconnect: live.disconnect
-		}), (cached) => ({
+		const accountFrames$ = getAccounts$(kc, liveWallets$);
+		const liveAccounts$ = accountFrames$.pipe(map(({ accounts }) => accounts.map(asLive)));
+		const isDiscovering$ = pageLoaded$.pipe(switchMap((loaded) => loaded ? liveWallets$.pipe(take(1), map(() => false)) : of(true)), shareReplay({
+			bufferSize: 1,
+			refCount: true
+		}));
+		const reconnecting = cachedWallets.filter((w) => w.status === "connecting");
+		const hydrationSettled$ = combineLatest([
+			liveWallets$,
+			accountFrames$.pipe(startWith(noAnswerYet)),
+			isDiscovering$,
+			store.observable.pipe(map((s) => s.remembered ?? []), take(1))
+		]).pipe(map(([wallets, { accounts, answered }, isDiscovering, remembered]) => !isDiscovering && reconnecting.every((cached) => reconnectSettled(cached, {
+			wallets,
+			accounts,
+			answered,
+			cachedAccounts,
+			remembered
+		}))), debounceTime(0, asapScheduler), distinctUntilChanged());
+		const bufferedWallets$ = createHydrationBuffer(cachedWallets, liveWallets$.pipe(map((wallets) => wallets.map(asLive))), kc.hydrationGracePeriod, kc.hydrationTimeout, (w) => w.id, hydrationSettled$, (live, cached) => {
+			const status = sessionRestoring(live, cached) ? "connecting" : live.status;
+			return {
+				...live,
+				status,
+				isConnected: status === "connected",
+				icon: cached.icon || getCachedIcon(cached.id) || live.icon
+			};
+		}, (cached) => ({
 			...cached,
 			icon: cached.icon || getCachedIcon(cached.id) || ""
 		}));
-		const bufferedAccounts$ = createAccountHydrationBuffer(cachedAccounts, liveAccounts$, kc.hydrationGracePeriod, (a) => a.walletId, (liveAccounts, cached) => {
-			const cachedWalletIds = new Set(cached.map((a) => a.walletId));
-			if (cachedWalletIds.size === 0) return true;
-			const liveWalletIds = new Set(liveAccounts.map((a) => a.walletId));
-			return [...cachedWalletIds].every((id) => liveWalletIds.has(id));
-		});
+		const bufferedAccounts$ = createAccountHydrationBuffer(cachedAccounts, liveAccounts$, kc.hydrationGracePeriod, kc.hydrationTimeout, (a) => a.walletId, hydrationSettled$);
 		const sharedWallets$ = bufferedWallets$.pipe(shareReplay({
 			bufferSize: 1,
 			refCount: true
@@ -796,38 +753,44 @@ const getKheopskit$ = (config, options = {}) => {
 		}));
 		const subscription = combineLatest({
 			wallets: sharedWallets$,
-			accounts: sharedAccounts$
-		}).pipe(map(({ wallets, accounts }) => {
+			accounts: sharedAccounts$,
+			isDiscovering: isDiscovering$
+		}).pipe(map(({ wallets, accounts, isDiscovering }) => {
 			if (kc.debug) console.debug("[kheopskit] hydration state", {
 				walletsHydrating: wallets.isHydrating,
 				accountsHydrating: accounts.isHydrating,
+				isDiscovering,
 				walletsConnected: wallets.items.filter((w) => w.isConnected).length,
 				walletsTotal: wallets.items.length
 			});
 			return {
 				config: kc,
-				wallets: [...wallets.items].sort(sortWallets),
+				wallets: [...wallets.items].sort(sortWallets).map(settleWithState),
 				accounts: [...accounts.items].sort(sortAccounts),
-				isHydrating: wallets.isHydrating || accounts.isHydrating
+				isHydrating: wallets.isHydrating || accounts.isHydrating,
+				isDiscovering
 			};
+		}), debounceTime(0, asapScheduler), distinctUntilChanged(statesEqual), tap((state) => {
+			latest = state;
+			for (const check of liveWaiters) check(state);
+			for (const waiter of waiters) settleIn(waiter, state);
 		})).subscribe(subscriber);
 		const persistSub = combineLatest({
 			wallets: sharedWallets$,
 			accounts: sharedAccounts$
 		}).pipe(filter(({ wallets, accounts }) => !wallets.isHydrating && !accounts.isHydrating), debounceTime(1e3), distinctUntilChanged((prev, curr) => {
-			const prevWalletKeys = prev.wallets.items.map(walletPersistKey);
-			const currWalletKeys = curr.wallets.items.map(walletPersistKey);
+			const prevWalletKeys = prev.wallets.items.map(persistedWalletKey);
+			const currWalletKeys = curr.wallets.items.map(persistedWalletKey);
 			const prevAccountKeys = prev.accounts.items.map(accountChangeKey);
 			const currAccountKeys = curr.accounts.items.map(accountChangeKey);
 			return arraysEqual(prevWalletKeys, currWalletKeys) && arraysEqual(prevAccountKeys, currAccountKeys);
 		})).subscribe(({ wallets, accounts }) => {
-			const connectedWalletIds = new Set(wallets.items.filter((w) => w.isConnected).map((w) => w.id));
-			const relevantAccounts = accounts.items.filter((a) => connectedWalletIds.has(a.walletId));
+			const snapshot = persistedSnapshot(wallets.items, accounts.items, store.getCachedState());
 			if (kc.debug) console.debug("[kheopskit] persisting state snapshot:", {
-				wallets: wallets.items.length,
-				accounts: relevantAccounts.length
+				wallets: snapshot.wallets.length,
+				accounts: snapshot.accounts.length
 			});
-			store.setCachedState(wallets.items.map(serializeWallet), relevantAccounts.map(serializeAccount));
+			store.setCachedState(snapshot.wallets, snapshot.accounts);
 			const icons = {};
 			for (const wallet of wallets.items) if (wallet.icon) icons[wallet.id] = wallet.icon;
 			setCachedIcons(icons);
@@ -835,11 +798,11 @@ const getKheopskit$ = (config, options = {}) => {
 		return () => {
 			subscription.unsubscribe();
 			persistSub.unsubscribe();
+			closed = true;
+			for (const waiter of waiters) abandon(waiter);
+			for (const check of liveWaiters) check(void 0);
 		};
-	}).pipe(distinctUntilChanged(statesEqual), throttleTime(16, void 0, {
-		leading: true,
-		trailing: true
-	}), logObservable("kheopskit$", {
+	}).pipe(logObservable("kheopskit$", {
 		enabled: kc.debug,
 		printValue: true
 	}), shareReplay({
@@ -847,14 +810,60 @@ const getKheopskit$ = (config, options = {}) => {
 		refCount: true
 	}));
 };
+const sessionRestoring = (live, cached) => isWalletConnectWallet(live) && live.status === "disconnected" && cached.status === "connecting";
+const flagged = /* @__PURE__ */ new WeakMap();
+const asLive = (item) => {
+	const existing = flagged.get(item);
+	if (existing) return existing;
+	const live = {
+		...item,
+		isPlaceholder: false
+	};
+	flagged.set(item, live);
+	return live;
+};
+const noAnswerYet = {
+	accounts: [],
+	answered: []
+};
+/**
+* A remembered wallet that reads disconnected without an error is still
+* waiting for its reconnect: getWallets$ emits the wallet list before its
+* connect() flips the status to connecting.
+*/
+const reconnectSettled = (cached, live) => {
+	const wallet = live.wallets.find((w) => w.id === cached.id);
+	if (!wallet) return true;
+	const status = sessionRestoring(wallet, cached) ? "connecting" : wallet.status;
+	if (status === "connecting") return false;
+	if (status === "disconnected") return wallet.error !== void 0 || !live.remembered.includes(cached.id);
+	return live.answered.includes(cached.id) || !live.cachedAccounts.some((a) => a.walletId === cached.id) || live.accounts.some((a) => a.walletId === cached.id);
+};
+/**
+* A wallet still connecting keeps its previous cache entry and accounts:
+* written live it would read isConnected: false with no accounts, and the
+* next load would hydrate it as disconnected without placeholders while its
+* reconnect runs.
+*/
+const persistedSnapshot = (wallets, accounts, previous) => {
+	const connecting = new Set(wallets.filter((w) => w.status === "connecting").map((w) => w.id));
+	const connected = new Set(wallets.filter((w) => w.isConnected).map((w) => w.id));
+	const previousWallets = new Map(previous.wallets.map((w) => [w.id, w]));
+	return {
+		wallets: wallets.map((w) => connecting.has(w.id) && previousWallets.get(w.id) || serializeWallet(w)),
+		accounts: [...accounts.filter((a) => connected.has(a.walletId)).map(serializeAccount), ...previous.accounts.filter((a) => connecting.has(a.walletId))]
+	};
+};
 const arraysEqual = (a, b) => a.length === b.length && a.every((v, i) => v === b[i]);
 /**
-* A signature of an account covering its id plus the platform-specific fields
-* that can change without the id changing (Ethereum chainId, Polkadot key type,
-* Solana clusters). Used to detect both UI-relevant changes and changes worth
-* re-persisting, so the two comparators can't drift apart.
+* A signature of an account covering its id, its name, plus the
+* platform-specific fields that can change without the id changing (Ethereum
+* chainId, Polkadot key type, Solana clusters). Used to detect both UI-relevant
+* changes and changes worth re-persisting, so the two comparators can't drift
+* apart.
 */
-const accountChangeKey = (account) => {
+const accountChangeKey = (account) => `${account.name ?? ""}|${accountPlatformKey(account)}`;
+const accountPlatformKey = (account) => {
 	switch (account.platform) {
 		case "ethereum": return `${account.id}|${account.chainId ?? ""}`;
 		case "polkadot": return `${account.id}|${account.type ?? ""}`;
@@ -867,24 +876,30 @@ const walletPlatforms = (wallet) => isWalletConnectWallet(wallet) ? wallet.platf
 /** Fields persisted to the cache for a wallet (icon is stored separately). */
 const walletPersistKey = (wallet) => `${wallet.id}|${wallet.isConnected ? 1 : 0}|${wallet.name}`;
 /**
+* What decides a cache write: the persisted fields plus `status`, because a
+* wallet whose kept entry was written while connecting must be rewritten live
+* once its reconnect fails, and `isConnected` reads false on both sides.
+*/
+const persistedWalletKey = (wallet) => `${walletPersistKey(wallet)}|${wallet.status}`;
+/**
 * UI-significant signature of a wallet: the persisted fields plus icon and the
 * WalletConnect connector's `platforms` array, which drive what the UI shows but
 * aren't part of the id (icon and platforms can arrive asynchronously after
 * connect without isConnected flipping).
 */
-const walletUiKey = (wallet) => `${walletPersistKey(wallet)}|${wallet.icon}|${walletPlatforms(wallet)}`;
+const walletUiKey = (wallet) => `${walletPersistKey(wallet)}|${wallet.status}|${wallet.error?.code ?? ""}|${wallet.icon}|${walletPlatforms(wallet)}`;
 /**
 * Equality check for KheopskitState to prevent unnecessary emissions. Compares
 * the UI-significant signature of every wallet and account, in order.
 */
-const statesEqual = (a, b) => a.isHydrating === b.isHydrating && a.wallets.length === b.wallets.length && a.accounts.length === b.accounts.length && a.wallets.every((w, i) => {
+const statesEqual = (a, b) => a.isHydrating === b.isHydrating && a.isDiscovering === b.isDiscovering && a.wallets.length === b.wallets.length && a.accounts.length === b.accounts.length && a.wallets.every((w, i) => {
 	const other = b.wallets[i];
-	return !!other && walletUiKey(w) === walletUiKey(other);
+	return !!other && w.isPlaceholder === other.isPlaceholder && walletUiKey(w) === walletUiKey(other);
 }) && a.accounts.every((acc, i) => {
 	const other = b.accounts[i];
-	return !!other && accountChangeKey(acc) === accountChangeKey(other);
+	return !!other && acc.isPlaceholder === other.isPlaceholder && accountChangeKey(acc) === accountChangeKey(other);
 });
 //#endregion
-export { DEFAULT_STORAGE_KEY, KheopskitError, clearAllCachedObservables, createKheopskitStore, getDefaultStore, getHydratedSnapshot, getKheopskit$, getWalletAccountId, getWalletId, isInjectedWallet, isValidAddress, isValidWalletId, isWalletConnectWallet, parseWalletAccountId, parseWalletId, resetAppKitCache, resolveConfig };
+export { DEFAULT_STORAGE_KEY, KheopskitError, clearAllCachedObservables, createKheopskitStore, getDefaultStore, getHydratedSnapshot, getKheopskit$, getWalletAccountId, getWalletId, isInjectedWallet, isValidAddress, isValidWalletId, isWalletConnectWallet, parseWalletAccountId, parseWalletId, resolveConfig };
 
 //# sourceMappingURL=index.mjs.map