@formo/analytics 1.38.0 → 1.38.1

package/dist/esm/src/FormoAnalytics.d.ts

@@ -402,9 +402,9 @@ export declare class FormoAnalytics implements IFormoAnalytics {
      *
      * With several live SDK instances (multi write-key pages) registering
      * the SAME provider, request-derived events (signatures, transactions)
-     * go to the most recently registered live instance - the same
-     * single-observer semantics discovery has always had for the request
-     * wrapper. Lifecycle events (connect, chain, disconnect) reach every
+     * go to the most recently CREATED live instance, regardless of the
+     * order registrations happen to land in - the same single-observer
+     * semantics discovery has always had for the request wrapper. Lifecycle events (connect, chain, disconnect) reach every
      * instance. Fanning request observations out to all instances is a
      * separate feature.
      *
@@ -429,7 +429,9 @@ export declare class FormoAnalytics implements IFormoAnalytics {
      * request wrapper installs here. Double counting is prevented in the
      * wrapper via `shouldSkipRequestCapture`.
      */
-    _wrapWagmiProvider(provider: EIP1193Provider): void;
+    _wrapWagmiProvider(provider: EIP1193Provider, chainId?: number): boolean;
+    /** INTERNAL. Chain updates for the fallback-wrapped provider. */
+    _rememberWagmiProviderChain(provider: EIP1193Provider, chainId: number | undefined): void;
     registerProvider(provider: EIP1193Provider, info?: {
         name?: string;
         rdns?: string;

package/dist/esm/src/FormoAnalytics.js

@@ -1334,9 +1334,9 @@ var FormoAnalytics = /** @class */ (function () {
      *
      * With several live SDK instances (multi write-key pages) registering
      * the SAME provider, request-derived events (signatures, transactions)
-     * go to the most recently registered live instance - the same
-     * single-observer semantics discovery has always had for the request
-     * wrapper. Lifecycle events (connect, chain, disconnect) reach every
+     * go to the most recently CREATED live instance, regardless of the
+     * order registrations happen to land in - the same single-observer
+     * semantics discovery has always had for the request wrapper. Lifecycle events (connect, chain, disconnect) reach every
      * instance. Fanning request observations out to all instances is a
      * separate feature.
      *
@@ -1361,14 +1361,35 @@ var FormoAnalytics = /** @class */ (function () {
      * request wrapper installs here. Double counting is prevented in the
      * wrapper via `shouldSkipRequestCapture`.
      */
-    FormoAnalytics.prototype._wrapWagmiProvider = function (provider) {
+    FormoAnalytics.prototype._wrapWagmiProvider = function (provider, chainId) {
         if (this.isCleanedUp || !isValidProvider(provider))
-            return;
+            return false;
         try {
-            this.evmRequests.registerRequestListeners(provider);
+            // The tracker reports refusals (frozen provider, unrebindable
+            // wrapper) by returning false rather than throwing; treat those as
+            // failures too so the caller can retry later.
+            if (!this.evmRequests.registerRequestListeners(provider)) {
+                return false;
+            }
+            if (chainId !== undefined) {
+                this.evm.rememberChain(provider, chainId);
+            }
+            return true;
         }
         catch (e) {
             logger.warn("Failed to wrap wagmi provider for hybrid capture", e);
+            return false;
+        }
+    };
+    /** INTERNAL. Chain updates for the fallback-wrapped provider. */
+    FormoAnalytics.prototype._rememberWagmiProviderChain = function (provider, chainId) {
+        if (this.isCleanedUp)
+            return;
+        try {
+            this.evm.rememberChain(provider, chainId);
+        }
+        catch (_a) {
+            /* bookkeeping only */
         }
     };
     FormoAnalytics.prototype.registerProvider = function (provider, info) {

package/dist/esm/src/FormoAnalyticsProvider.d.ts

@@ -7,6 +7,14 @@ export interface FormoAnalyticsProviderProps {
     children: ReactNode;
 }
 export declare const FormoAnalyticsContext: import("react").Context<IFormoAnalytics>;
+/**
+ * A stable key over the serializable parts of Options. The provider effect
+ * re-initialises the SDK when this key changes; anything that alters SDK
+ * behaviour must be represented here, or a runtime change to it is silently
+ * ignored. Complex objects are tracked by presence, plus the flags that
+ * change what the SDK does with them.
+ */
+export declare const computeOptionsKey: (options?: Options) => string;
 export declare const FormoAnalyticsProvider: FC<FormoAnalyticsProviderProps>;
 export declare const useFormo: () => IFormoAnalytics;
 //# sourceMappingURL=FormoAnalyticsProvider.d.ts.map

package/dist/esm/src/FormoAnalyticsProvider.js

@@ -69,6 +69,44 @@ var defaultContext = {
     hasOptedOutTracking: function () { return false; },
 };
 export var FormoAnalyticsContext = createContext(defaultContext);
+/**
+ * A stable key over the serializable parts of Options. The provider effect
+ * re-initialises the SDK when this key changes; anything that alters SDK
+ * behaviour must be represented here, or a runtime change to it is silently
+ * ignored. Complex objects are tracked by presence, plus the flags that
+ * change what the SDK does with them.
+ */
+export var computeOptionsKey = function (options) {
+    var _a;
+    if (!options)
+        return 'undefined';
+    var serializableOptions = {
+        tracking: options.tracking,
+        autocapture: options.autocapture,
+        crossSubdomainCookies: options.crossSubdomainCookies,
+        apiHost: options.apiHost,
+        flushAt: options.flushAt,
+        flushInterval: options.flushInterval,
+        retryCount: options.retryCount,
+        maxQueueSize: options.maxQueueSize,
+        logger: options.logger,
+        referral: options.referral,
+        evm: options.evm,
+        // For complex objects, just track their presence, not their content
+        hasProvider: !!options.provider,
+        hasWagmi: !!options.wagmi,
+        wagmiEip1193Fallback: !!((_a = options.wagmi) === null || _a === void 0 ? void 0 : _a.eip1193Fallback),
+        hasReady: !!options.ready,
+    };
+    try {
+        return JSON.stringify(serializableOptions);
+    }
+    catch (error) {
+        // Fallback to timestamp if serialization fails
+        logger.warn('Failed to serialize options, using timestamp', error);
+        return Date.now().toString();
+    }
+};
 export var FormoAnalyticsProvider = function (props) {
     var writeKey = props.writeKey, _a = props.disabled, disabled = _a === void 0 ? false : _a, children = props.children;
     // Keep the app running without analytics if no Write Key is provided or disabled
@@ -87,37 +125,7 @@ var InitializedAnalytics = function (_a) {
     var _b = useState(defaultContext), sdk = _b[0], setSdk = _b[1];
     var sdkRef = useRef(defaultContext);
     initStorageManager(writeKey);
-    // Create a stable key from options that ignores complex objects and functions
-    // We only care about serializable config values that would affect SDK behavior
-    var optionsKey = useMemo(function () {
-        if (!options)
-            return 'undefined';
-        // Extract only the serializable parts of options
-        var serializableOptions = {
-            tracking: options.tracking,
-            autocapture: options.autocapture,
-            crossSubdomainCookies: options.crossSubdomainCookies,
-            apiHost: options.apiHost,
-            flushAt: options.flushAt,
-            flushInterval: options.flushInterval,
-            retryCount: options.retryCount,
-            maxQueueSize: options.maxQueueSize,
-            logger: options.logger,
-            referral: options.referral,
-            // For complex objects, just track their presence, not their content
-            hasProvider: !!options.provider,
-            hasWagmi: !!options.wagmi,
-            hasReady: !!options.ready,
-        };
-        try {
-            return JSON.stringify(serializableOptions);
-        }
-        catch (error) {
-            // Fallback to timestamp if serialization fails
-            logger.warn('Failed to serialize options, using timestamp', error);
-            return Date.now().toString();
-        }
-    }, [options]);
+    var optionsKey = useMemo(function () { return computeOptionsKey(options); }, [options]);
     useEffect(function () {
         var isCleanedUp = false;
         var initialize = function () { return __awaiter(void 0, void 0, void 0, function () {

package/dist/esm/src/evm/EvmRequestTracker.d.ts

@@ -57,6 +57,18 @@ export declare class EvmRequestTracker {
      * never retry it, and every signature and transaction from that wallet
      * would be missed for the rest of the session.
      */
+    /** Monotonic creation stamp; owner precedence is decided by it. */
+    private static nextCreationSeq;
+    readonly creationSeq: number;
+    /**
+     * Put this tracker into an owner list at its CREATION-ORDER position.
+     * Registration can arrive out of order - an older instance's async wrap
+     * kick may resolve after a newer instance's - and dispatch picks from
+     * the END of the list, so append-on-registration would let resolution
+     * order decide which instance owns capture. Creation order is what the
+     * newest-live contract promises.
+     */
+    private insertBySeniority;
     registerRequestListeners(provider: EIP1193Provider): boolean;
     /** Install the wrapper function onto the provider; separated so the
      * routing shim above stays small. */

package/dist/esm/src/evm/EvmRequestTracker.js

@@ -137,6 +137,7 @@ var EvmRequestTracker = /** @class */ (function () {
         this.disposed = false;
         /** Providers whose owner list includes this instance; pruned on cleanup. */
         this.wrappedProviders = new Set();
+        this.creationSeq = EvmRequestTracker.nextCreationSeq++;
     }
     /** Stop every poll in flight. Terminal, like the event queue's close(). */
     EvmRequestTracker.prototype.cleanup = function () {
@@ -170,11 +171,24 @@ var EvmRequestTracker = /** @class */ (function () {
         this.polls.add(timer);
     };
     /**
-     * Wrap a provider's `request`. Returns whether the wrapper is installed:
-     * a caller that marks the provider as tracked on a false return would
-     * never retry it, and every signature and transaction from that wallet
-     * would be missed for the rest of the session.
+     * Put this tracker into an owner list at its CREATION-ORDER position.
+     * Registration can arrive out of order - an older instance's async wrap
+     * kick may resolve after a newer instance's - and dispatch picks from
+     * the END of the list, so append-on-registration would let resolution
+     * order decide which instance owns capture. Creation order is what the
+     * newest-live contract promises.
      */
+    EvmRequestTracker.prototype.insertBySeniority = function (owners) {
+        var _this = this;
+        var idx = owners.indexOf(this);
+        if (idx !== -1)
+            owners.splice(idx, 1);
+        var insertAt = owners.findIndex(function (o) { return o.creationSeq > _this.creationSeq; });
+        if (insertAt === -1)
+            owners.push(this);
+        else
+            owners.splice(insertAt, 0, this);
+    };
     EvmRequestTracker.prototype.registerRequestListeners = function (provider) {
         var _this = this;
         logger.info("registerRequestListeners");
@@ -196,10 +210,7 @@ var EvmRequestTracker = /** @class */ (function () {
                 logger.warn("wrapped without owner list; cannot rebind");
                 return false;
             }
-            var idx = owners.indexOf(this);
-            if (idx !== -1)
-                owners.splice(idx, 1);
-            owners.push(this);
+            this.insertBySeniority(owners);
             this.wrappedProviders.add(provider);
             logger.info("Provider already wrapped; rebinding the wrapper to this instance.");
             return true;
@@ -240,10 +251,7 @@ var EvmRequestTracker = /** @class */ (function () {
             var slot = provider;
             var prior = slot[WRAPPED_REQUEST_OWNER_SYMBOL];
             var owners = Array.isArray(prior) ? prior : [];
-            var idx = owners.indexOf(this);
-            if (idx !== -1)
-                owners.splice(idx, 1);
-            owners.push(this);
+            this.insertBySeniority(owners);
             if (!Array.isArray(prior)) {
                 slot[WRAPPED_REQUEST_OWNER_SYMBOL] = owners;
             }
@@ -848,6 +856,14 @@ var EvmRequestTracker = /** @class */ (function () {
             });
         });
     };
+    /**
+     * Wrap a provider's `request`. Returns whether the wrapper is installed:
+     * a caller that marks the provider as tracked on a false return would
+     * never retry it, and every signature and transaction from that wallet
+     * would be missed for the rest of the session.
+     */
+    /** Monotonic creation stamp; owner precedence is decided by it. */
+    EvmRequestTracker.nextCreationSeq = 0;
     return EvmRequestTracker;
 }());
 export { EvmRequestTracker };

package/dist/esm/src/version.d.ts

@@ -1,2 +1,2 @@
-export declare const version = "1.38.0";
+export declare const version = "1.38.1";
 //# sourceMappingURL=version.d.ts.map

package/dist/esm/src/version.js

@@ -1,4 +1,4 @@
 // This file is auto-generated by scripts/update-version.js during npm version
 // Do not edit manually - it will be overwritten
-export var version = '1.38.0';
+export var version = '1.38.1';
 //# sourceMappingURL=version.js.map

package/dist/esm/src/wagmi/WagmiEventHandler.d.ts

@@ -362,6 +362,43 @@ export declare class WagmiEventHandler {
      * dedup. Fire-and-forget per connection; a provider that cannot be
      * produced simply keeps mutation-only capture.
      */
+    /**
+     * Connections THIS instance has wrapped. Deliberately per-instance, not
+     * module-level: a module-level guard let a rebuilt SDK instance skip
+     * re-wrapping, so ownership stayed with the torn-down instance and every
+     * capture died in its closed queue - and it also stopped a second
+     * write-key instance from ever registering. Re-wrapping is safe and
+     * cheap: the request tracker rebinds ownership of an intact wrapper.
+     */
+    /**
+     * Latest wrap attempt per connector. Every kick re-resolves
+     * getProvider() - a connector can hand out a REPLACEMENT provider after
+     * a reconnect, so a once-only guard would leave the new session's
+     * provider unwrapped forever. Re-wrapping is idempotent: the request
+     * tracker rebinds ownership of an intact wrapper. The epoch lets a slow
+     * resolution from a superseded kick (an earlier session, an earlier
+     * chain) be discarded instead of overwriting fresher state.
+     */
+    private wrapEpochs;
+    /** Consecutive automatic wrap retries per connector; see below. */
+    private wrapRetryCounts;
+    /** Pending retry timers, cancelled by cleanup(). */
+    private wrapRetryTimers;
+    /**
+     * Bumped on every observed disconnect. Every wrap attempt captures it
+     * at kick time and its resolution stands down on a mismatch, so a
+     * disconnect invalidates ALL pending wraps at once - including ones
+     * whose getProvider() had not resolved yet, which no per-connector
+     * bookkeeping can reach because nothing has been recorded for them.
+     */
+    private wrapSessionGeneration;
+    /** The active connector this instance wrapped, and its provider, for
+     * chain updates. Kept as a pair so a chain report is only ever applied
+     * to the provider of the connector it describes. Keyed by connector,
+     * not by connection record: wagmi REPLACES the connection object on
+     * every account or chain update, so record identity is not stable. */
+    private fallbackConnector?;
+    private fallbackProvider?;
     private wrapActiveConnectorProvider;
     private kickWalletConnectPeerLookup;
     /**

package/dist/esm/src/wagmi/WagmiEventHandler.js

@@ -238,8 +238,6 @@ var walletConnectPeerLookups = new WeakSet();
  * newest kicked one, so a slow resolution from a PREVIOUS session cannot
  * land after the current session's and overwrite it. */
 var walletConnectPeerLatest = new WeakMap();
-/** Connections whose provider already has the hybrid-capture wrapper. */
-var wagmiWrappedConnections = new WeakSet();
 /**
  * Pending transactions, shared per destination rather than per handler.
  *
@@ -424,6 +422,57 @@ var WagmiEventHandler = /** @class */ (function () {
          * Key format: `${queryHash}:${status}`
          */
         this.processedQueries = new Set();
+        /**
+         * Start resolving the wallet behind a WalletConnect connection.
+         *
+         * Fire-and-forget on purpose: emission paths are synchronous by design
+         * and must never wait (see the connect marker comment). Called at the
+         * START of the status/address flows rather than only at read time - the
+         * lookup is one microtask for an initialised connector, and the emission
+         * sits behind several awaits, so kicking early usually means even the
+         * FIRST connect names the real wallet. When the race is lost the event
+         * honestly says "WalletConnect" and every later event names the peer.
+         */
+        /**
+         * Install the request wrapper on the active connector's provider.
+         *
+         * This is what lets wagmi mode capture IMPERATIVE viem calls
+         * (walletClient.sendTransaction / .signMessage / .writeContract / raw
+         * request), which create no mutation and were silently lost. Hook-driven
+         * calls stay owned by the mutation handlers via the pending-mutation
+         * dedup. Fire-and-forget per connection; a provider that cannot be
+         * produced simply keeps mutation-only capture.
+         */
+        /**
+         * Connections THIS instance has wrapped. Deliberately per-instance, not
+         * module-level: a module-level guard let a rebuilt SDK instance skip
+         * re-wrapping, so ownership stayed with the torn-down instance and every
+         * capture died in its closed queue - and it also stopped a second
+         * write-key instance from ever registering. Re-wrapping is safe and
+         * cheap: the request tracker rebinds ownership of an intact wrapper.
+         */
+        /**
+         * Latest wrap attempt per connector. Every kick re-resolves
+         * getProvider() - a connector can hand out a REPLACEMENT provider after
+         * a reconnect, so a once-only guard would leave the new session's
+         * provider unwrapped forever. Re-wrapping is idempotent: the request
+         * tracker rebinds ownership of an intact wrapper. The epoch lets a slow
+         * resolution from a superseded kick (an earlier session, an earlier
+         * chain) be discarded instead of overwriting fresher state.
+         */
+        this.wrapEpochs = new WeakMap();
+        /** Consecutive automatic wrap retries per connector; see below. */
+        this.wrapRetryCounts = new WeakMap();
+        /** Pending retry timers, cancelled by cleanup(). */
+        this.wrapRetryTimers = new Set();
+        /**
+         * Bumped on every observed disconnect. Every wrap attempt captures it
+         * at kick time and its resolution stands down on a mismatch, so a
+         * disconnect invalidates ALL pending wraps at once - including ones
+         * whose getProvider() had not resolved yet, which no per-connector
+         * bookkeeping can reach because nothing has been recorded for them.
+         */
+        this.wrapSessionGeneration = 0;
         this.formo = formoAnalytics;
         this.wagmiConfig = wagmiConfig;
         this.queryClient = queryClient;
@@ -598,6 +647,10 @@ var WagmiEventHandler = /** @class */ (function () {
         var connectionUnsubscribe = this.wagmiConfig.subscribe(function (state) { var _a, _b; return "".concat((_a = state.current) !== null && _a !== void 0 ? _a : "", "|").concat((_b = _this.getConnectedAddress(state)) !== null && _b !== void 0 ? _b : ""); }, function (key, prevKey) {
             var _a = key.split("|"), address = _a[1];
             var _b = (prevKey !== null && prevKey !== void 0 ? prevKey : "|").split("|"), prevAddress = _b[1];
+            // A connector switch keeps status "connected", so the status
+            // subscription never re-wraps; the NEW active connection's provider
+            // must be instrumented from here or its imperative calls are lost.
+            _this.wrapActiveConnectorProvider(_this.getState());
             _this.handleActiveAddressChange(address || undefined, prevAddress || undefined);
         });
         this.unsubscribers.push(connectionUnsubscribe);
@@ -903,6 +956,19 @@ var WagmiEventHandler = /** @class */ (function () {
             return __generator(this, function (_e) {
                 switch (_e.label) {
                     case 0:
+                        if (status === "disconnected" || status === "reconnecting") {
+                            // The wrapped session is over - or, for "reconnecting", about to be
+                            // replaced without ever passing through "disconnected". This must
+                            // run for EVERY such transition, before the processing lock and
+                            // regardless of whether a wallet was being tracked, or a rapid
+                            // same-connector reconnect retains the old provider and the chain
+                            // callback writes the new session's chain onto it. The generation
+                            // bump invalidates every wrap still in flight from the ended
+                            // session, resolved or not. The "connected" that follows re-wraps.
+                            this.wrapSessionGeneration += 1;
+                            this.fallbackConnector = undefined;
+                            this.fallbackProvider = undefined;
+                        }
                         // Prevent concurrent processing
                         if (this.trackingState.isProcessing) {
                             // Dropped, not queued - but remember that a disconnect went past.
@@ -1439,10 +1505,31 @@ var WagmiEventHandler = /** @class */ (function () {
      */
     WagmiEventHandler.prototype.handleChainChange = function (chainId, prevChainId) {
         return __awaiter(this, void 0, void 0, function () {
-            var state, address, hadAddress, wasAnnounced, announcedNow;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
+            var live, activeConnector, state, address, hadAddress, wasAnnounced, announcedNow;
+            var _a, _b, _c;
+            return __generator(this, function (_d) {
+                switch (_d.label) {
                     case 0:
+                        // Keep the fallback-wrapped provider's registry chain in step with the
+                        // store, so request-derived events are labelled correctly even when the
+                        // provider exposes no synchronous chainId. Only when the report is
+                        // about the connection that provider belongs to: after a connector
+                        // switch the store's chain describes the NEW connection, and writing it
+                        // to the old provider would mislabel that wallet's events.
+                        if (this.fallbackProvider !== undefined) {
+                            live = this.getState();
+                            activeConnector = live.current
+                                ? (_a = live.connections.get(live.current)) === null || _a === void 0 ? void 0 : _a.connector
+                                : undefined;
+                            if (activeConnector === this.fallbackConnector) {
+                                try {
+                                    (_c = (_b = this.formo)._rememberWagmiProviderChain) === null || _c === void 0 ? void 0 : _c.call(_b, this.fallbackProvider, chainId);
+                                }
+                                catch (_e) {
+                                    /* never let bookkeeping break the chain flow */
+                                }
+                            }
+                        }
                         if (chainId === prevChainId || chainId === undefined) {
                             return [2 /*return*/];
                         }
@@ -1488,7 +1575,7 @@ var WagmiEventHandler = /** @class */ (function () {
                         });
                         return [4 /*yield*/, this.applyChainForTrackedWallet(address, chainId)];
                     case 1:
-                        _a.sent();
+                        _d.sent();
                         return [2 /*return*/];
                 }
             });
@@ -2267,30 +2354,10 @@ var WagmiEventHandler = /** @class */ (function () {
         this.kickWalletConnectPeerLookup(state);
         return connector.name;
     };
-    /**
-     * Start resolving the wallet behind a WalletConnect connection.
-     *
-     * Fire-and-forget on purpose: emission paths are synchronous by design
-     * and must never wait (see the connect marker comment). Called at the
-     * START of the status/address flows rather than only at read time - the
-     * lookup is one microtask for an initialised connector, and the emission
-     * sits behind several awaits, so kicking early usually means even the
-     * FIRST connect names the real wallet. When the race is lost the event
-     * honestly says "WalletConnect" and every later event names the peer.
-     */
-    /**
-     * Install the request wrapper on the active connector's provider.
-     *
-     * This is what lets wagmi mode capture IMPERATIVE viem calls
-     * (walletClient.sendTransaction / .signMessage / .writeContract / raw
-     * request), which create no mutation and were silently lost. Hook-driven
-     * calls stay owned by the mutation handlers via the pending-mutation
-     * dedup. Fire-and-forget per connection; a provider that cannot be
-     * produced simply keeps mutation-only capture.
-     */
-    WagmiEventHandler.prototype.wrapActiveConnectorProvider = function (state) {
+    WagmiEventHandler.prototype.wrapActiveConnectorProvider = function (state, isRetry) {
         var _this = this;
-        var _a, _b;
+        var _a, _b, _c;
+        if (isRetry === void 0) { isRetry = false; }
         // OPT-IN only. Wagmi mode's baseline never touches the signing
         // transport; instrumenting the provider is an explicit integrator
         // decision (options.wagmi.eip1193Fallback), made auditable in
@@ -2299,25 +2366,124 @@ var WagmiEventHandler = /** @class */ (function () {
         if (!optedIn) {
             return;
         }
+        if (state.status !== "connected") {
+            // Status kicks run for every transition; only a connected snapshot
+            // describes a session worth wrapping.
+            return;
+        }
         var connection = state.current
             ? state.connections.get(state.current)
             : undefined;
         var connector = connection === null || connection === void 0 ? void 0 : connection.connector;
-        if (!connection ||
-            typeof (connector === null || connector === void 0 ? void 0 : connector.getProvider) !== "function" ||
-            wagmiWrappedConnections.has(connection)) {
+        if (!connection || typeof (connector === null || connector === void 0 ? void 0 : connector.getProvider) !== "function") {
             return;
         }
-        wagmiWrappedConnections.add(connection);
-        connector
-            .getProvider()
+        var epoch = ((_c = this.wrapEpochs.get(connector)) !== null && _c !== void 0 ? _c : 0) + 1;
+        this.wrapEpochs.set(connector, epoch);
+        var session = this.wrapSessionGeneration;
+        // A store-driven kick resets the retry budget; automatic retries
+        // (below) spend it.
+        if (!isRetry) {
+            this.wrapRetryCounts.delete(connector);
+        }
+        // When the NEWEST attempt fails, older in-flight resolutions have
+        // been epoch-discarded (they may describe an earlier session) and
+        // nothing else would wrap the provider until the next store update.
+        // Recover by re-kicking fresh with live state, bounded so a
+        // persistently failing connector cannot loop: after the budget is
+        // spent, recovery waits for a real store update, which resets it.
+        var retryAfterFailure = function () {
+            var _a;
+            if (_this.disposed)
+                return;
+            if (_this.wrapEpochs.get(connector) !== epoch) {
+                // Superseded: the newer attempt owns recovery.
+                return;
+            }
+            var failures = ((_a = _this.wrapRetryCounts.get(connector)) !== null && _a !== void 0 ? _a : 0) + 1;
+            _this.wrapRetryCounts.set(connector, failures);
+            if (failures > 3)
+                return;
+            var timer = setTimeout(function () {
+                var _a;
+                _this.wrapRetryTimers.delete(timer);
+                if (_this.disposed)
+                    return;
+                // Re-kick only while THIS connector is still the active one and
+                // no newer attempt superseded this one. A retry for a connector
+                // the user has left must not fire at the current connector: with
+                // the retry flag it would skip the budget reset and, worse, its
+                // fresh epoch would discard the current connector's own in-flight
+                // resolution.
+                var live = _this.getState();
+                var stillCurrent = live.current !== undefined &&
+                    ((_a = live.connections.get(live.current)) === null || _a === void 0 ? void 0 : _a.connector) === connector;
+                if (stillCurrent && _this.wrapEpochs.get(connector) === epoch) {
+                    _this.wrapActiveConnectorProvider(live, true);
+                }
+            }, 25 * failures);
+            _this.wrapRetryTimers.add(timer);
+        };
+        var resolution;
+        try {
+            resolution = connector.getProvider();
+        }
+        catch (_d) {
+            // A synchronous throw must not escape into the subscription
+            // callback: address-change handling runs after this kick and a
+            // propagated throw would silently skip it.
+            retryAfterFailure();
+            return;
+        }
+        resolution
             .then(function (provider) {
-            var _a, _b;
-            (_b = (_a = _this.formo)._wrapWagmiProvider) === null || _b === void 0 ? void 0 : _b.call(_a, provider);
+            var _a, _b, _c, _d;
+            if (_this.wrapEpochs.get(connector) !== epoch) {
+                // A newer kick is in flight or already resolved; this answer may
+                // describe an earlier session. Let the newest one win.
+                return;
+            }
+            // The fallback installs only the request wrapper, so a provider
+            // without a synchronous chainId property would never teach the
+            // registry its chain and its events would carry chain 0. The wagmi
+            // store knows; feed it here and on every later chain change. Read
+            // the chain from LIVE state, not from a snapshot taken before this
+            // asynchronous resolution: a switch that lands while getProvider is
+            // in flight fires handleChainChange before fallbackProvider exists,
+            // so a pre-resolution snapshot would stick as the recorded chain.
+            // Activity is judged by CONNECTOR identity: wagmi replaces the
+            // connection record itself on every account or chain update.
+            var live = _this.getState();
+            // A wrap only describes a CONNECTED session. Status changes kick
+            // this path for every transition, and a resolution landing while
+            // disconnected would re-point the fallback pair at a provider
+            // whose session is over.
+            var stillActive = !_this.disposed &&
+                _this.wrapSessionGeneration === session &&
+                live.status === "connected" &&
+                live.current !== undefined &&
+                ((_a = live.connections.get(live.current)) === null || _a === void 0 ? void 0 : _a.connector) === connector;
+            if (!stillActive) {
+                // The user moved on while getProvider was in flight. Wrapping
+                // now would instrument a provider whose chain nobody feeds -
+                // its requests would report chain 0. Switching back re-kicks.
+                return;
+            }
+            var chainId = (_b = _this.getActiveConnectionChainId(live)) !== null && _b !== void 0 ? _b : live.chainId;
+            var wrapped = (_d = (_c = _this.formo)._wrapWagmiProvider) === null || _d === void 0 ? void 0 : _d.call(_c, provider, typeof chainId === "number" ? chainId : undefined);
+            if (wrapped !== true) {
+                // The provider was refused (invalid shape, frozen provider,
+                // torn-down SDK).
+                retryAfterFailure();
+                return;
+            }
+            _this.wrapRetryCounts.delete(connector);
+            _this.fallbackConnector = connector;
+            _this.fallbackProvider = provider;
         })
             .catch(function () {
-            // Mutation-only capture remains; retry on the next connection.
-            wagmiWrappedConnections.delete(connection);
+            // Mutation-only capture remains.
+            retryAfterFailure();
         });
     };
     WagmiEventHandler.prototype.kickWalletConnectPeerLookup = function (state) {
@@ -2407,6 +2573,8 @@ var WagmiEventHandler = /** @class */ (function () {
      * Clean up all subscriptions
      */
     WagmiEventHandler.prototype.cleanup = function () {
+        this.wrapRetryTimers.forEach(function (t) { return clearTimeout(t); });
+        this.wrapRetryTimers.clear();
         logger.debug("WagmiEventHandler: Cleaning up subscriptions");
         if (!this.disposed) {
             this.disposed = true;