@formo/analytics 1.38.2 → 1.40.0

package/dist/esm/src/event/EventFactory.js

@@ -67,11 +67,18 @@ import { CHANNEL, CLICK_ID_PARAMS, DEFAULT_EXCLUDED_QUERY_PARAMS, DEFAULT_REFERR
 import { sanitizeTrafficSources } from "./sanitize";
 import { generateAnonymousId } from "./utils";
 import { detectBrowser } from "../browser/browsers";
+import { EVENT_CREATION_CANCELLED } from "./cancellation";
 var ISO_3166_ALPHA_2_REGEX = /^[A-Z]{2}$/;
 var EventFactory = /** @class */ (function () {
-    function EventFactory(options) {
+    function EventFactory(options, 
+    /** Consulted once per event, after the only await in creation. */
+    canCreate) {
+        if (canCreate === void 0) { canCreate = function () { return true; }; }
         var _this = this;
         var _a, _b;
+        this.canCreate = canCreate;
+        /** Bumped by invalidate(); an event created across a bump is dropped. */
+        this.generation = 0;
         this.extractUTMParameters = function (url) {
             var result = {
                 utm_campaign: "",
@@ -404,6 +411,10 @@ var EventFactory = /** @class */ (function () {
             return safeDefaults;
         }
     };
+    /** Drop every event still being created. Called on clear() and close(). */
+    EventFactory.prototype.invalidate = function () {
+        this.generation++;
+    };
     // Contextual fields that are automatically collected and populated by the Formo SDK
     EventFactory.prototype.generateContext = function (context) {
         return __awaiter(this, void 0, void 0, function () {
@@ -427,24 +438,28 @@ var EventFactory = /** @class */ (function () {
     };
     EventFactory.prototype.getEnrichedEvent = function (formoEvent, context) {
         return __awaiter(this, void 0, void 0, function () {
-            var commonEventData, eventChainId, validAddress, processedEvent;
-            var _a;
-            var _b, _c;
-            return __generator(this, function (_d) {
-                switch (_d.label) {
+            var generation, enrichedContext, commonEventData, eventChainId, validAddress, processedEvent;
+            var _a, _b;
+            return __generator(this, function (_c) {
+                switch (_c.label) {
                     case 0:
-                        _a = {};
+                        generation = this.generation;
                         return [4 /*yield*/, this.generateContext(context)];
                     case 1:
-                        commonEventData = (_a.context = _d.sent(),
-                            _a.original_timestamp = getCurrentTimeFormatted(),
-                            _a.user_id = formoEvent.user_id,
-                            _a.type = formoEvent.type,
-                            _a.channel = CHANNEL,
-                            _a.version = VERSION,
-                            _a);
-                        commonEventData.anonymous_id = generateAnonymousId(LOCAL_ANONYMOUS_ID_KEY, (_b = this.options) === null || _b === void 0 ? void 0 : _b.crossSubdomainCookies);
-                        eventChainId = (_c = formoEvent.properties) === null || _c === void 0 ? void 0 : _c.chainId;
+                        enrichedContext = _c.sent();
+                        if (generation !== this.generation || !this.canCreate()) {
+                            throw EVENT_CREATION_CANCELLED;
+                        }
+                        commonEventData = {
+                            context: enrichedContext,
+                            original_timestamp: getCurrentTimeFormatted(),
+                            user_id: formoEvent.user_id,
+                            type: formoEvent.type,
+                            channel: CHANNEL,
+                            version: VERSION,
+                        };
+                        commonEventData.anonymous_id = generateAnonymousId(LOCAL_ANONYMOUS_ID_KEY, (_a = this.options) === null || _a === void 0 ? void 0 : _a.crossSubdomainCookies);
+                        eventChainId = (_b = formoEvent.properties) === null || _b === void 0 ? void 0 : _b.chainId;
                         validAddress = this.validateEventAddress(formoEvent.address, eventChainId);
                         commonEventData.address = validAddress;
                         processedEvent = mergeDeepRight(formoEvent, commonEventData);

package/dist/esm/src/event/EventManager.d.ts

@@ -5,14 +5,16 @@ import { IEventFactory, IEventManager } from "./type";
  * A service to generate valid event payloads and queue them for processing
  */
 declare class EventManager implements IEventManager {
+    private readonly canAcceptEvent;
     eventQueue: IEventQueue;
     eventFactory: IEventFactory;
+    private generation;
     /**
      *
      * @param eventQueue Event queue instance
      * @param options Optional configuration (referral parsing, etc.)
      */
-    constructor(eventQueue: IEventQueue, options?: Options);
+    constructor(eventQueue: IEventQueue, options?: Options, canAcceptEvent?: () => boolean);
     /**
      * Consumes a new incoming event
      * @param event Incoming event data

package/dist/esm/src/event/EventManager.js

@@ -47,6 +47,7 @@ var __rest = (this && this.__rest) || function (s, e) {
 };
 import { logger } from "../logger";
 import { EventFactory } from "./EventFactory";
+import { EVENT_CREATION_CANCELLED } from "./cancellation";
 import { isBlockedAddress } from "../utils/address";
 /**
  * A service to generate valid event payloads and queue them for processing
@@ -57,9 +58,13 @@ var EventManager = /** @class */ (function () {
      * @param eventQueue Event queue instance
      * @param options Optional configuration (referral parsing, etc.)
      */
-    function EventManager(eventQueue, options) {
+    function EventManager(eventQueue, options, canAcceptEvent) {
+        if (canAcceptEvent === void 0) { canAcceptEvent = function () { return true; }; }
+        var _this = this;
+        this.canAcceptEvent = canAcceptEvent;
+        this.generation = 0;
         this.eventQueue = eventQueue;
-        this.eventFactory = new EventFactory(options);
+        this.eventFactory = new EventFactory(options, function () { return _this.canAcceptEvent(); });
     }
     /**
      * Consumes a new incoming event
@@ -67,14 +72,34 @@ var EventManager = /** @class */ (function () {
      */
     EventManager.prototype.addEvent = function (event, address, userId) {
         return __awaiter(this, void 0, void 0, function () {
-            var callback, _event, formoEvent;
+            var callback, _event, generation, shouldContinue, formoEvent, error_1;
+            var _this = this;
             return __generator(this, function (_a) {
                 switch (_a.label) {
                     case 0:
                         callback = event.callback, _event = __rest(event, ["callback"]);
-                        return [4 /*yield*/, this.eventFactory.create(_event, address, userId)];
+                        generation = this.generation;
+                        shouldContinue = function () {
+                            return generation === _this.generation && _this.canAcceptEvent();
+                        };
+                        if (!shouldContinue())
+                            return [2 /*return*/];
+                        _a.label = 1;
                     case 1:
+                        _a.trys.push([1, 3, , 4]);
+                        return [4 /*yield*/, this.eventFactory.create(_event, address, userId)];
+                    case 2:
                         formoEvent = _a.sent();
+                        return [3 /*break*/, 4];
+                    case 3:
+                        error_1 = _a.sent();
+                        if (error_1 === EVENT_CREATION_CANCELLED)
+                            return [2 /*return*/];
+                        throw error_1;
+                    case 4:
+                        // Reject work invalidated while enrichment was pending.
+                        if (!shouldContinue())
+                            return [2 /*return*/];
                         // Check if the final event has a blocked address - don't queue it
                         if (formoEvent.address && isBlockedAddress(formoEvent.address)) {
                             logger.warn("Event blocked: Address ".concat(formoEvent.address, " is in the blocked list and cannot emit events"));
@@ -95,10 +120,14 @@ var EventManager = /** @class */ (function () {
     };
     /** Drop any buffered events (consent withdrawal). Recoverable. */
     EventManager.prototype.clear = function () {
+        this.generation++;
+        this.eventFactory.invalidate();
         this.eventQueue.clear();
     };
     /** Terminal shutdown on teardown: nothing can be sent after this. */
     EventManager.prototype.close = function () {
+        this.generation++;
+        this.eventFactory.invalidate();
         this.eventQueue.close();
     };
     return EventManager;

package/dist/esm/src/event/cancellation.d.ts

@@ -0,0 +1,4 @@
+/** Internal control flow: an event invalidated by consent withdrawal. */
+declare const EVENT_CREATION_CANCELLED: unique symbol;
+export { EVENT_CREATION_CANCELLED };
+//# sourceMappingURL=cancellation.d.ts.map

package/dist/esm/src/event/cancellation.js

@@ -0,0 +1,4 @@
+/** Internal control flow: an event invalidated by consent withdrawal. */
+var EVENT_CREATION_CANCELLED = Symbol();
+export { EVENT_CREATION_CANCELLED };
+//# sourceMappingURL=cancellation.js.map

package/dist/esm/src/event/type.d.ts

@@ -5,6 +5,7 @@ export interface IEventManager {
     close(): void;
 }
 export interface IEventFactory {
+    invalidate(): void;
     create(event: APIEvent, address?: Address, userId?: string): Promise<IFormoEvent>;
 }
 //# sourceMappingURL=type.d.ts.map

package/dist/esm/src/event/utils.d.ts

@@ -1,4 +1,8 @@
 import { AnonymousID } from "../types";
 declare const generateAnonymousId: (key: string, crossSubdomainCookies?: boolean) => AnonymousID;
-export { generateAnonymousId };
+/** Clear the anonymous id from every storage layer. */
+declare const clearAnonymousId: (key: string) => void;
+/** Test hook: forget the page-lifetime memory, as a new page load would. */
+declare const __resetAnonymousIdMemory: () => void;
+export { generateAnonymousId, clearAnonymousId, __resetAnonymousIdMemory };
 //# sourceMappingURL=utils.d.ts.map

package/dist/esm/src/event/utils.js

@@ -10,13 +10,26 @@ var __assign = (this && this.__assign) || function () {
     return __assign.apply(this, arguments);
 };
 import { generateNativeUUID } from "../utils";
-import { cookie } from "../storage";
+import { cookie, local, usesCookieStorage } from "../storage";
 import { getIdentityCookieDomain, getIdentityCookieSecurity, } from "../storage/cookiePolicy";
+/** Page-lifetime fallback when persistent storage is unavailable. */
+var volatileAnonymousId;
+/** Persistent fallback when cookies are unavailable. */
+var readLocal = function (key) {
+    try {
+        var value = local().get(key);
+        return typeof value === "string" && value ? value : undefined;
+    }
+    catch (_a) {
+        return undefined;
+    }
+};
 var generateAnonymousId = function (key, crossSubdomainCookies) {
+    var _a, _b;
     var storedAnonymousId = cookie().get(key);
     var anonymousId = (storedAnonymousId && typeof storedAnonymousId === "string"
         ? storedAnonymousId
-        : generateNativeUUID());
+        : (_b = (_a = readLocal(key)) !== null && _a !== void 0 ? _a : volatileAnonymousId) !== null && _b !== void 0 ? _b : generateNativeUUID());
     var domain = getIdentityCookieDomain(crossSubdomainCookies);
     // Re-set the cookie with the configured scope. When crossSubdomainCookies
     // is true, this migrates legacy host-only cookies on the current host to the apex
@@ -24,7 +37,47 @@ var generateAnonymousId = function (key, crossSubdomainCookies) {
     // example.com is not visible from app.example.com) cannot be migrated
     // until the user revisits that host.
     cookie().set(key, anonymousId, __assign(__assign({ expires: new Date(Date.now() + 1000 * 60 * 60 * 24 * 365).toUTCString(), path: "/" }, getIdentityCookieSecurity()), (domain ? { domain: domain } : {})));
+    // Retry host-only when a domain-scoped write is rejected.
+    if (domain && cookie().get(key) !== anonymousId) {
+        cookie().set(key, anonymousId, __assign({ expires: new Date(Date.now() + 1000 * 60 * 60 * 24 * 365).toUTCString(), path: "/" }, getIdentityCookieSecurity()));
+    }
+    if (cookie().get(key) === anonymousId) {
+        // Prefer the cookie and discard the fallback copy.
+        volatileAnonymousId = undefined;
+        if (usesCookieStorage() && readLocal(key)) {
+            try {
+                local().remove(key);
+            }
+            catch (_c) {
+                // Storage is unavailable.
+            }
+        }
+        return anonymousId;
+    }
+    // Persist across embedded page loads when cookies are blocked.
+    try {
+        local().set(key, anonymousId);
+    }
+    catch (_d) {
+        // Memory remains the last fallback.
+    }
+    volatileAnonymousId = anonymousId;
     return anonymousId;
 };
-export { generateAnonymousId };
+/** Clear the anonymous id from every storage layer. */
+var clearAnonymousId = function (key) {
+    cookie().remove(key);
+    try {
+        local().remove(key);
+    }
+    catch (_a) {
+        // Storage is unavailable.
+    }
+    volatileAnonymousId = undefined;
+};
+/** Test hook: forget the page-lifetime memory, as a new page load would. */
+var __resetAnonymousIdMemory = function () {
+    volatileAnonymousId = undefined;
+};
+export { generateAnonymousId, clearAnonymousId, __resetAnonymousIdMemory };
 //# sourceMappingURL=utils.js.map

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

@@ -11,6 +11,8 @@ export interface EvmEventTrackerDeps {
     isTrackingSuppressed(): boolean;
     /** Whether an event on this chain would actually be sent. */
     willTrackEvent(chainId?: ChainID): boolean;
+    /** Retry detect events after the active chain changes. */
+    retryDetection(): void;
     /** In wagmi mode the SDK does not wrap providers itself. */
     isWagmiMode(): boolean;
     /** Emission. The tracker decides WHEN; the SDK owns the event API. */
@@ -152,6 +154,8 @@ export declare class EvmEventTracker {
      * had already replaced.
      */
     private unsubscribeDiscovery?;
+    /** Discovery store retained for complete listener cleanup. */
+    private discoveryStore?;
     constructor(wallet: WalletStateStore, registry: EvmProviderRegistry, deps: EvmEventTrackerDeps);
     /** Stop listening for wallet announcements. Called from SDK teardown. */
     cleanup(): void;
@@ -259,8 +263,11 @@ export declare class EvmEventTracker {
     private registerConnectListener;
     private registerDisconnectListener;
     private onConnected;
+    /** Whether Formo owns provider lifecycle tracking. */
+    private tracksDiscovered;
     getProviders(): Promise<readonly EIP6963ProviderDetail[]>;
     detectWallets(providers: readonly EIP6963ProviderDetail[]): Promise<void>;
+    detectableProviders(): readonly EIP6963ProviderDetail[];
     /**
      * Seed a provider's chain from whatever it already exposes synchronously.
      *

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

@@ -267,7 +267,7 @@ var EvmEventTracker = /** @class */ (function () {
     };
     /** Stop listening for wallet announcements. Called from SDK teardown. */
     EvmEventTracker.prototype.cleanup = function () {
-        var _a;
+        var _a, _b;
         // A replay in flight (awaiting the active wallet's accounts) must not
         // resume into a torn-down instance and commit a session there.
         this.disposed = true;
@@ -277,11 +277,13 @@ var EvmEventTracker = /** @class */ (function () {
         this.retryRequested = false;
         try {
             (_a = this.unsubscribeDiscovery) === null || _a === void 0 ? void 0 : _a.call(this);
+            (_b = this.discoveryStore) === null || _b === void 0 ? void 0 : _b.destroy();
         }
         catch (e) {
             logger.warn("Failed to unsubscribe from provider discovery", e);
         }
         this.unsubscribeDiscovery = undefined;
+        this.discoveryStore = undefined;
     };
     EvmEventTracker.prototype.sessionGeneration = function (provider) {
         var _a;
@@ -1015,6 +1017,7 @@ var EvmEventTracker = /** @class */ (function () {
                             this.wallet.provider = provider;
                         }
                         this.wallet.set('evm', { chainId: nextChainId });
+                        this.deps.retryDetection();
                         _a.label = 1;
                     case 1:
                         _a.trys.push([1, 5, , 6]);
@@ -1332,12 +1335,17 @@ var EvmEventTracker = /** @class */ (function () {
             });
         });
     };
+    /** Whether Formo owns provider lifecycle tracking. */
+    EvmEventTracker.prototype.tracksDiscovered = function () {
+        return !this.deps.isWagmiMode();
+    };
     EvmEventTracker.prototype.getProviders = function () {
         return __awaiter(this, void 0, void 0, function () {
             var store, providers, injected, injectedProviderInfo, injectedDetail, uniqueProviders, _i, uniqueProviders_1, detail;
             var _this = this;
             return __generator(this, function (_a) {
                 store = createStore();
+                this.discoveryStore = store;
                 providers = store.getProviders();
                 this.unsubscribeDiscovery = store.subscribe(function (providerDetails) {
                     providers = providerDetails;
@@ -1356,8 +1364,12 @@ var EvmEventTracker = /** @class */ (function () {
                         var p = detail === null || detail === void 0 ? void 0 : detail.provider;
                         return !!p && !_this.registry.isTracked(p);
                     });
-                    if (newDetails.length > 0) {
+                    // Wagmi detects only providers added by this announcement.
+                    var toDetect = _this.tracksDiscovered() ? newDetails : newlyAddedDetails;
+                    if (_this.tracksDiscovered() && newDetails.length > 0) {
                         _this.trackProviders(newDetails);
+                    }
+                    if (toDetect.length > 0) {
                         // Detect newly discovered wallets (session de-dupes) with error handling
                         (function () { return __awaiter(_this, void 0, void 0, function () {
                             var e_3;
@@ -1365,7 +1377,7 @@ var EvmEventTracker = /** @class */ (function () {
                                 switch (_a.label) {
                                     case 0:
                                         _a.trys.push([0, 2, , 3]);
-                                        return [4 /*yield*/, this.detectWallets(newDetails)];
+                                        return [4 /*yield*/, this.detectWallets(toDetect)];
                                     case 1:
                                         _a.sent();
                                         return [3 /*break*/, 3];
@@ -1391,7 +1403,7 @@ var EvmEventTracker = /** @class */ (function () {
                         if (this.registry.injected &&
                             this.registry.injected.provider === injected) {
                             // Ensure it's tracked
-                            if (!this.registry.isTracked(injected)) {
+                            if (this.tracksDiscovered() && !this.registry.isTracked(injected)) {
                                 this.trackEIP1193Provider(injected);
                             }
                             // Merge with existing providers instead of overwriting
@@ -1399,7 +1411,7 @@ var EvmEventTracker = /** @class */ (function () {
                             return [2 /*return*/, this.registry.all];
                         }
                         // Re-check if the injected provider is already tracked just before tracking
-                        if (!this.registry.isTracked(injected)) {
+                        if (this.tracksDiscovered() && !this.registry.isTracked(injected)) {
                             this.trackEIP1193Provider(injected);
                         }
                         injectedProviderInfo = detectInjectedProviderInfo(injected);
@@ -1459,6 +1471,20 @@ var EvmEventTracker = /** @class */ (function () {
             });
         });
     };
+    EvmEventTracker.prototype.detectableProviders = function () {
+        var _a;
+        var available = new Set();
+        (_a = this.discoveryStore) === null || _a === void 0 ? void 0 : _a.getProviders().forEach(function (detail) {
+            return available.add(detail.provider);
+        });
+        var injected = typeof window !== "undefined" ? window.ethereum : undefined;
+        if (injected)
+            available.add(injected);
+        this.externallyRegistered.forEach(function (provider) { return available.add(provider); });
+        return this.registry.all.filter(function (detail) {
+            return available.has(detail.provider);
+        });
+    };
     /**
      * Seed a provider's chain from whatever it already exposes synchronously.
      *

package/dist/esm/src/queue/EventQueue.d.ts

@@ -28,6 +28,7 @@ export declare class EventQueue implements IEventQueue {
     private pendingFlush;
     private payloadHashes;
     private canSend?;
+    private generation;
     private closed;
     private disposePageLeave;
     constructor(writeKey: string, options: Options);

package/dist/esm/src/queue/EventQueue.js

@@ -83,6 +83,7 @@ var EventQueue = /** @class */ (function () {
         this.queue = [];
         this.queueByteSize = 0; // running total of queued items' byteSize
         this.payloadHashes = new Set();
+        this.generation = 0;
         // Terminal shutdown flag. Once set, enqueue() and flush() are no-ops for
         // the rest of this instance's life. See close().
         this.closed = false;
@@ -216,6 +217,7 @@ var EventQueue = /** @class */ (function () {
      * withdrawal / SDK teardown so nothing buffered can be sent later.
      */
     EventQueue.prototype.clear = function () {
+        this.generation++;
         if (this.timer) {
             clearTimeout(this.timer);
             this.timer = null;
@@ -223,6 +225,8 @@ var EventQueue = /** @class */ (function () {
         this.queue = [];
         this.queueByteSize = 0;
         this.payloadHashes.clear();
+        this.flushed = false;
+        this.pendingFlush = null;
     };
     /**
      * Terminal shutdown. Unlike clear(), which only empties the buffer and can
@@ -259,11 +263,12 @@ var EventQueue = /** @class */ (function () {
     });
     EventQueue.prototype.enqueue = function (event, callback) {
         return __awaiter(this, void 0, void 0, function () {
-            var message_id, queueItem, hasReachedFlushAt, hasReachedQueueSize;
+            var generation, message_id, queueItem, hasReachedFlushAt, hasReachedQueueSize;
             return __generator(this, function (_a) {
                 switch (_a.label) {
                     case 0:
                         callback = callback || noop;
+                        generation = this.generation;
                         // A torn-down instance must never buffer, however late the caller
                         // arrives. See close().
                         if (this.closed)
@@ -276,12 +281,12 @@ var EventQueue = /** @class */ (function () {
                         return [4 /*yield*/, this.generateMessageId(event)];
                     case 1:
                         message_id = _a.sent();
-                        // Re-check after the await. A caller that entered before close() is
-                        // suspended here, and on a queue that has not flushed yet its event
-                        // would push and flush immediately - the exact shape of the bug close()
-                        // exists to stop.
-                        if (this.closed)
+                        if (this.closed || generation !== this.generation)
                             return [2 /*return*/];
+                        if (this.canSend && !this.canSend()) {
+                            this.clear();
+                            return [2 /*return*/];
+                        }
                         // check if the message already exists
                         if (this.isDuplicate(message_id)) {
                             logger.warn("Event already enqueued, try again after ".concat(millisecondsToSecond(this.flushIntervalMs), " seconds."));

package/dist/esm/src/solana/SolanaManager.d.ts

@@ -1,14 +1,27 @@
 /**
  * SolanaManager
  *
- * Manages the lifecycle of the Solana store integration.
- * Subscribes to framework-kit's zustand store for automatic event capture
- * of wallet connect/disconnect and transaction lifecycle events.
+ * Owns the two ways the SDK learns about Solana wallets:
  *
- * For signMessage/signTransaction tracking (not captured by the store),
+ *  1. `SolanaWalletStandardRegistry`: discovers wallets through the Wallet
+ *     Standard and reports detect / connect / disconnect. On by default, so
+ *     compatible wallets registered by Solana Kit, wallet-adapter,
+ *     framework-kit, or another host are covered with no configuration,
+ *     exactly like EVM wallets through EIP-6963. `solana: false` turns it off.
+ *  2. `SolanaStoreHandler`: subscribes to framework-kit's zustand store for
+ *     connect / disconnect / cluster changes AND the transaction lifecycle.
+ *     Opt-in through `solana: { store }` or `formo.solana.setStore()`.
+ *
+ * Both observe the same Wallet Standard connection when a framework-kit app
+ * connects. A store supplied at initialization owns wallet events; a store
+ * attached later takes ownership when it observes its first connection and
+ * adopts any connect the registry already reported. One connect per
+ * connection, whichever path an app is on.
+ *
+ * For signMessage/signTransaction tracking (not captured by either path),
  * use formo.signature() directly with the address and chainId.
  *
- * For manual event tracking without the store, use the core API directly:
+ * For manual event tracking, use the core API directly:
  * formo.transaction(), formo.signature(), formo.connect(), formo.disconnect().
  */
 import { FormoAnalytics } from "../FormoAnalytics";
@@ -16,9 +29,19 @@ import { SolanaCluster, SolanaOptions } from "./types";
 import { SolanaClientStore } from "./storeTypes";
 export declare class SolanaManager {
     private formo;
+    private readonly enabled;
     private storeHandler?;
+    private registry?;
     private pendingCluster?;
-    constructor(formo: FormoAnalytics, options?: SolanaOptions);
+    private storeOwnsWalletEvents;
+    /**
+     * @param formo - The SDK instance events are reported to.
+     * @param options - `options.solana` as passed to the SDK, if an object.
+     * @param enabled - Whether Solana tracking is enabled. False only when the
+     *   host app passed `solana: false`; both discovery and stores then stay off.
+     */
+    constructor(formo: FormoAnalytics, options?: SolanaOptions, enabled?: boolean);
+    private attachStore;
     /**
      * Set the framework-kit zustand store for automatic event tracking.
      * This enables autocapture mode — connect/disconnect and transaction events
@@ -39,11 +62,16 @@ export declare class SolanaManager {
         cluster?: SolanaCluster;
     }): void;
     /**
-     * Update the cluster/network. Only needed if the store endpoint doesn't
-     * contain a recognizable cluster name (e.g. custom RPC URLs).
-     * In most cases, the cluster is auto-detected from the store's endpoint.
+     * Update the cluster/network.
+     *
+     * With a framework-kit store, only needed if the store endpoint doesn't
+     * contain a recognizable cluster name (e.g. custom RPC URLs). Without one,
+     * this is how a non-mainnet app tells the SDK which cluster its Wallet
+     * Standard connections are on, since the standard itself cannot say.
      */
     setCluster(cluster: SolanaCluster): void;
+    /** Names of the Wallet Standard wallets discovered so far. */
+    get discoveredWallets(): string[];
     cleanup(): void;
 }
 //# sourceMappingURL=SolanaManager.d.ts.map