@bounded-sh/core 0.0.98 → 0.0.99

package/dist/{index-BDW82Uxu.mjs → index-DW5yMQwV.mjs}

@@ -87,6 +87,9 @@ function getWebhookKeysUrl() {
  * `verifyWebhook` to bind a webhook to THIS app by default (#072) rather than trusting any
  * app's shared-key-signed delivery.
  */
+function getConfiguredSessionNamespace() {
+    return JSON.stringify([(clientConfig.humanAuthApiUrl || "https://auth.bounded.sh").replace(/\/$/, ""), clientConfig.appId]);
+}
 function getConfiguredAppId() {
     return clientConfig.appId || undefined;
 }
@@ -925,6 +928,30 @@ function decideCommit(current, expected, next) {
 }
 
 class WebSessionManager {
+    static scopedStorageKey() {
+        return 'bounded_session_storage:v2:' + getConfiguredSessionNamespace();
+    }
+    static get BOUNDED_SESSION_STORAGE_KEY() {
+        const scoped = this.scopedStorageKey();
+        return localStorage.getItem(scoped + ':scope') === 'app' || localStorage.getItem(scoped) !== null
+            ? scoped : 'bounded_session_storage';
+    }
+    static logoutKey() { return this.scopedStorageKey() + ':logout'; }
+    /** Capture before login's network work; checked under the session mutation lock. */
+    static captureSessionEstablishment() {
+        var _a, _b;
+        const namespace = getConfiguredSessionNamespace();
+        const epoch = this.establishmentEpoch;
+        const generation = (_b = (_a = this.readRaw()) === null || _a === void 0 ? void 0 : _a.sessionGeneration) !== null && _b !== void 0 ? _b : null;
+        const logout = localStorage.getItem(this.logoutKey());
+        return () => {
+            var _a, _b;
+            if (namespace !== getConfiguredSessionNamespace() || epoch !== this.establishmentEpoch
+                || generation !== ((_b = (_a = this.readRaw()) === null || _a === void 0 ? void 0 : _a.sessionGeneration) !== null && _b !== void 0 ? _b : null)
+                || logout !== localStorage.getItem(this.logoutKey()))
+                throw new Error('session_establishment_superseded');
+        };
+    }
     /** Raw read of the stored blob. Callers inside the lock use this, never a cached copy. */
     static readRaw() {
         if (typeof window === "undefined")
@@ -984,10 +1011,11 @@ class WebSessionManager {
     /* ------------------------------------------------------------------ */
     /* STORE                                                              */
     /* ------------------------------------------------------------------ */
-    static async storeSession(address, accessToken, idToken, refreshToken, issuer) {
+    static async storeSession(address, accessToken, idToken, refreshToken, issuer, beforeCommit) {
         var _a;
         if (typeof window === "undefined")
             return;
+        let appScoped = false;
         // JWT-wallet binding: refuse to store a session whose idToken is bound
         // to a different wallet than `address`. Prevents races that would otherwise
         // leave localStorage with mismatched address/token state.
@@ -995,6 +1023,7 @@ class WebSessionManager {
             const payloadB64 = idToken.split(".")[1];
             if (payloadB64) {
                 const payload = JSON.parse(this.decodeBase64Url(payloadB64));
+                appScoped = payload["custom:walletScope"] === "app";
                 const tokenWallet = payload["custom:walletAddress"];
                 if (tokenWallet && tokenWallet !== address) {
                     throw new Error(`[WebSessionManager] Refusing to store session: address (${address}) does not match idToken custom:walletAddress (${tokenWallet})`);
@@ -1012,6 +1041,9 @@ class WebSessionManager {
         }
         const config = await getConfig();
         const currentAppId = config.appId;
+        const namespace = getConfiguredSessionNamespace();
+        const storageKey = appScoped || localStorage.getItem(this.scopedStorageKey() + ":scope") === "app"
+            ? this.scopedStorageKey() : "bounded_session_storage";
         // The auth issuer base that minted this session, so silent refresh POSTs to
         // the RIGHT /session/refresh. Email overrides with humanAuthApiUrl; all
         // wallet/guest/signature flows default to authApiUrl (the bounded-auth issuer).
@@ -1019,12 +1051,33 @@ class WebSessionManager {
         // A login always starts a NEW generation. Refresh commits preserve it, so
         // "same generation" means "same login", which is what lets a post-refresh
         // retry be told apart from a re-login by the same wallet.
+        const generation = mintSessionGeneration();
         await withSessionLock(() => {
-            this.writeRaw(Object.assign({ address,
+            beforeCommit === null || beforeCommit === void 0 ? void 0 : beforeCommit();
+            if (namespace !== getConfiguredSessionNamespace())
+                throw new Error("session_establishment_superseded");
+            ++this.establishmentEpoch;
+            if (appScoped)
+                localStorage.setItem(this.scopedStorageKey() + ":scope", "app");
+            localStorage.setItem(storageKey, JSON.stringify(Object.assign({ address,
                 accessToken,
                 idToken,
-                refreshToken, appId: currentAppId, sessionGeneration: mintSessionGeneration() }, (sessionIssuer ? { issuer: sessionIssuer } : {})));
+                refreshToken, appId: currentAppId, sessionGeneration: generation }, (sessionIssuer ? { issuer: sessionIssuer } : {}))));
         });
+        // Adoption can fail after persistence (for example, logout while the
+        // provider is loading). Remove only this incomplete login, even if the
+        // caller has since switched app configuration or another tab signed in.
+        return async () => {
+            const removed = await withSessionLock(() => {
+                const raw = localStorage.getItem(storageKey);
+                if (!raw || JSON.parse(raw).sessionGeneration !== generation)
+                    return false;
+                localStorage.removeItem(storageKey);
+                return true;
+            });
+            if (removed)
+                notifySessionCleared();
+        };
     }
     /* ------------------------------------------------------------------ */
     /* GET                                                                */
@@ -1139,10 +1192,14 @@ class WebSessionManager {
     static async clearSession() {
         if (typeof window === "undefined")
             return;
+        ++this.establishmentEpoch;
+        const key = this.BOUNDED_SESSION_STORAGE_KEY;
+        const logoutKey = this.logoutKey();
         const removed = await withSessionLock(() => {
-            if (localStorage.getItem(this.BOUNDED_SESSION_STORAGE_KEY) === null)
+            localStorage.setItem(logoutKey, mintSessionGeneration());
+            if (localStorage.getItem(key) === null)
                 return false;
-            localStorage.removeItem(this.BOUNDED_SESSION_STORAGE_KEY);
+            localStorage.removeItem(key);
             return true;
         });
         // Only announce a clear that actually happened, so a no-op cannot sign out
@@ -1289,7 +1346,7 @@ class WebSessionManager {
         return { outcome: result.outcome, session: result.session };
     }
 }
-WebSessionManager.BOUNDED_SESSION_STORAGE_KEY = "bounded_session_storage";
+WebSessionManager.establishmentEpoch = 0;
 
 let _config = null;
 class ReactNativeSessionManager {
@@ -4131,7 +4188,7 @@ class ServerSessionManager {
         const sessionConfig = (_a = this.sessionConfig) !== null && _a !== void 0 ? _a : undefined;
         /* fetch nonce from auth API (bound to the snapshotted app+issuer) */
         const nonce = await genAuthNonce(sessionConfig);
-        const { genSolanaMessage } = await import('./solana-message-j1s9osZD.mjs');
+        const { genSolanaMessage } = await import('./solana-message-BGkYFU3C.mjs');
         const message = await genSolanaMessage(address, nonce, sessionConfig === null || sessionConfig === void 0 ? void 0 : sessionConfig.appId);
         /* sign the message */
         const sigBytes = nacl.sign.detached(new TextEncoder().encode(message), kp.secretKey);
@@ -5239,7 +5296,6 @@ const WS_V2_PATH = '/ws/v2';
 let browserReconnectHooksAttached = false;
 let lastBrowserTriggeredReconnectAt = 0;
 let reconnectInProgress = null;
-let ambientAuthFailure = null;
 // ============ Helper Functions ============
 function generateSubscriptionId() {
     return `sub_${Date.now()}_${Math.random().toString(36).substring(2, 11)}`;
@@ -5367,34 +5423,6 @@ function getTokenExpirationTime(token) {
         return null;
     }
 }
-/**
- * Latch a failure so a dead session does not re-hammer /session/refresh every tick.
- *
- * NOT latched when the failure came with the session being cleared or replaced.
- * The clear notifies auth-state listeners, which kicks a reconnect that resets this
- * — and if we re-latched afterwards, `getConnectionAuthToken` would keep throwing
- * even though storage is now empty, so an ordinary expiry left WebSocket
- * acquisition permanently broken instead of falling back to an anonymous socket.
- */
-function rememberAmbientAuthFailure(error) {
-    if ((error === null || error === void 0 ? void 0 : error.code) === AUTH_CHANGED_CODE)
-        return error;
-    // The session is gone: the right next move is an anonymous connection, not a
-    // remembered failure.
-    if (!getIdTokenSync())
-        return error;
-    ambientAuthFailure = error;
-    return error;
-}
-/** Best-effort synchronous peek, only for deciding whether a session still exists. */
-function getIdTokenSync() {
-    try {
-        return getActiveSessionManager().getIdToken();
-    }
-    catch (_a) {
-        return null;
-    }
-}
 function failConnectionAuth(connection, error) {
     connection.authFailure = error;
     connection.pendingAuthToken = null;
@@ -5449,8 +5477,8 @@ function scheduleTokenRefresh(connection, isServer) {
                     console.info('[WS v2] Token refreshed successfully, stored for next connection');
                 }
                 catch (refreshError) {
-                    const definitive = (refreshError === null || refreshError === void 0 ? void 0 : refreshError.code) === AUTH_EXPIRED_CODE
-                        || (refreshError === null || refreshError === void 0 ? void 0 : refreshError.code) === AUTH_CHANGED_CODE;
+                    const definitive = (refreshError === null || refreshError === void 0 ? void 0 : refreshError.code) === AUTH_CHANGED_CODE
+                        || !await getIdToken(isServer);
                     if (definitive) {
                         // The session is dead or belongs to someone else now. The shared
                         // helper has already cleared storage and notified auth-state
@@ -5480,28 +5508,19 @@ function scheduleTokenRefresh(connection, isServer) {
  * WS-local wrapper around the shared freshness helper.
  *
  * The shared helper owns expiry classification, the deduplicated
- * snapshot -> refresh -> commit transaction, and conditional clearing. This adds
- * only the WS-specific storm guard: without it, a dead session would retry the
- * refresh on every reconnect attempt and every 5-minute tick.
+ * snapshot -> refresh -> commit transaction, and conditional clearing. A transient
+ * failure must remain retryable; reconnect backoff bounds automatic attempts.
  */
 async function getWsAuthToken(isServer) {
     var _a, _b;
-    // A remembered failure short-circuits, but only while a session still exists.
-    // See rememberAmbientAuthFailure: once storage is cleared the correct next move
-    // is an anonymous connection, not a replayed error.
-    if (ambientAuthFailure && getIdTokenSync()) {
-        throw ambientAuthFailure;
-    }
     try {
-        const token = await getFreshAuthToken(isServer);
-        ambientAuthFailure = null;
-        return token;
+        return await getFreshAuthToken(isServer);
     }
     catch (error) {
         // Status only — the raw axios error carries config.data (the refresh token)
         // and must never reach a console or log sink.
         console.error('[WS v2] Error acquiring auth token. status:', (_b = (_a = error === null || error === void 0 ? void 0 : error.status) !== null && _a !== void 0 ? _a : error === null || error === void 0 ? void 0 : error.code) !== null && _b !== void 0 ? _b : 'unknown');
-        throw rememberAmbientAuthFailure(normalizeAuthExpiredError(error, 'Authentication expired and refresh failed'));
+        throw normalizeAuthExpiredError(error, 'Authentication expired and refresh failed');
     }
 }
 /**
@@ -5519,18 +5538,21 @@ async function recoverFromServerAuthRejection(connection) {
     const rejected = connection.pendingAuthToken;
     if (!rejected)
         return;
-    // One forced refresh per distinct rejected token value: a transiently
-    // unreachable issuer must not turn the reconnect loop into a refresh storm.
+    // Share an in-flight attempt and stop retrying a definitively refused token.
+    // Transient failures may retry on the next socket reconnect, with its backoff.
     if (connection.serverRejectedAuthToken === rejected)
         return;
     connection.serverRejectedAuthToken = rejected;
     try {
         await getFreshAuthToken(connection.isServer, { force: true });
     }
-    catch (_a) {
-        // Every failure mode is already handled inside the helper: a dead
-        // session was cleared (auth listeners notified), a transient refresh
-        // failure keeps the session and the latch above stops the storm.
+    catch (error) {
+        if ((error === null || error === void 0 ? void 0 : error.code) !== AUTH_CHANGED_CODE && (error === null || error === void 0 ? void 0 : error.status) !== 401 && (error === null || error === void 0 ? void 0 : error.status) !== 403
+            && connection.serverRejectedAuthToken === rejected) {
+            connection.serverRejectedAuthToken = null;
+        }
+        // The shared helper clears definitively rejected sessions and preserves
+        // transient failures. Never reuse the failed result as a credential.
     }
 }
 async function getConnectionAuthToken(isServer, authTokenProvider, anonymous) {
@@ -5541,9 +5563,6 @@ async function getConnectionAuthToken(isServer, authTokenProvider, anonymous) {
         return null;
     }
     if (!authTokenProvider) {
-        // getWsAuthToken, not the shared helper directly: the wrapper carries the
-        // reconnect-storm guard that keeps a dead session from re-refreshing on
-        // every reconnect attempt.
         return getWsAuthToken(isServer);
     }
     try {
@@ -5648,11 +5667,13 @@ function cancelIdleConnectionClose(connection) {
     connection.idleCloseTimer = null;
 }
 function closeConnectionNow(connection) {
+    var _a;
     if (connections.get(connection.key) !== connection)
         return;
     if (!connection.ws)
         return;
     cancelIdleConnectionClose(connection);
+    (_a = connection.authRetryWake) === null || _a === void 0 ? void 0 : _a.call(connection);
     if (connection.tokenRefreshTimer) {
         clearInterval(connection.tokenRefreshTimer);
         connection.tokenRefreshTimer = null;
@@ -5673,7 +5694,7 @@ function closeConnectionNow(connection) {
     try {
         ws.close();
     }
-    catch ( /* already closing */_a) { /* already closing */ }
+    catch ( /* already closing */_b) { /* already closing */ }
 }
 function scheduleConnectionCloseIfIdle(connection) {
     var _a;
@@ -5759,6 +5780,7 @@ async function getOrCreateConnection(appId, isServer, routePath, authTokenProvid
     }
 }
 async function getOrCreateConnectionOnce(appId, isServer, routePath, authTokenProvider, principalKey, principalToken, leaseKey, source) {
+    var _a, _b;
     attachBrowserReconnectHooksOnce();
     const anonymous = (source === null || source === void 0 ? void 0 : source.anonymous) === true;
     // A per-room subscription gets its OWN connection routed to the room DO; all
@@ -5805,9 +5827,6 @@ async function getOrCreateConnectionOnce(appId, isServer, routePath, authTokenPr
         // lease also guards this window, but cancelling here avoids a needless
         // grace-timer round-trip on the common reuse path.
         cancelIdleConnectionClose(connection);
-        if (connection.authFailure) {
-            throw connection.authFailure;
-        }
         let currentAuthToken;
         try {
             currentAuthToken = await getConnectionAuthToken(isServer, authTokenProvider, anonymous);
@@ -5817,6 +5836,14 @@ async function getOrCreateConnectionOnce(appId, isServer, routePath, authTokenPr
             failConnectionAuth(connection, authError);
             throw authError;
         }
+        if (connection.authFailure) {
+            // The preflight recovered, but failConnectionAuth invalidated this
+            // socket's auth state. Authenticate again before replaying any reads.
+            connection.authFailure = null;
+            (_a = connection.authRetryWake) === null || _a === void 0 ? void 0 : _a.call(connection);
+            connection.ws.reconnect();
+            return connection;
+        }
         if (connection.isConnected &&
             !connection.isAuthenticating &&
             !connectionMatchesAuthToken(connection, currentAuthToken)) {
@@ -5859,50 +5886,59 @@ async function getOrCreateConnectionOnce(appId, isServer, routePath, authTokenPr
         isServer,
         serverRejectedAuthToken: null,
     };
+    // Resolve configuration before handing control to reconnecting-websocket.
+    // Its 4.4.0 URL-provider promise has no rejection handler and a rejected
+    // provider permanently holds _connectLock. Credential failures therefore
+    // stay inside this bounded, cancellable acquisition loop.
+    const wsApiUrl = (_b = source === null || source === void 0 ? void 0 : source.wsApiUrl) !== null && _b !== void 0 ? _b : (await getConfig()).wsApiUrl;
+    const wsUrl = new URL(wsApiUrl);
+    wsUrl.pathname = WS_V2_PATH;
+    wsUrl.searchParams.append('appId', appId || (await getConfig()).appId);
+    if (connection.routePath)
+        wsUrl.searchParams.append('routePath', connection.routePath);
     connections.set(connKey, connection);
-    // URL provider for reconnection with fresh tokens
     const urlProvider = async () => {
-        var _a;
-        // A scoped createClient() connection targets its own realtime endpoint;
-        // the default path reads the module-global config.
-        const wsApiUrl = (_a = source === null || source === void 0 ? void 0 : source.wsApiUrl) !== null && _a !== void 0 ? _a : (await getConfig()).wsApiUrl;
-        const wsUrl = new URL(wsApiUrl);
-        // Always use v2 path
-        wsUrl.pathname = WS_V2_PATH;
-        // Set appId from the configured SDK source, or an explicit per-call
-        // override passed through subscribeV2. Do not consult ambient globals:
-        // app identity must come from init({ appId }) or an explicit call option.
-        // `appId` here is already the resolved effectiveAppId; fall back to the
-        // global only on the default path when it was somehow empty.
-        wsUrl.searchParams.append('appId', appId || (await getConfig()).appId);
-        // Per-room connection: carry the room path so the worker routes this WS
-        // to the room DO (appId#room#roomId) where the live view fan-out lives.
-        if (connection.routePath) {
-            wsUrl.searchParams.append('routePath', connection.routePath);
-        }
-        // Resolve auth token if available. A wallet-scoped connection resolves
-        // its token from the wallet's own session (self-refreshing); all others
-        // use the browser session or fail closed for top-level server calls. The token is sent as the first WS
-        // frame after open, never as a URL query parameter.
-        let authToken;
-        try {
-            authToken = initialAuthToken !== undefined
-                ? initialAuthToken
-                : await getConnectionAuthToken(isServer, connection.authTokenProvider, connection.anonymous);
-            initialAuthToken = undefined;
-        }
-        catch (error) {
-            const authError = normalizeAuthExpiredError(error, 'Authentication expired and refresh failed');
-            failConnectionAuth(connection, authError);
-            throw authError;
-        }
-        connection.pendingAuthToken = authToken || null;
-        connection.pendingAuthSnapshot = authSnapshotFromToken(authToken);
-        if (authToken) {
-            // Successful token acquisition — reset failure counter
+        let retryDelay = WS_CONFIG.minReconnectionDelay;
+        while (connections.get(connKey) === connection) {
+            let authToken;
+            try {
+                authToken = initialAuthToken !== undefined
+                    ? initialAuthToken
+                    : await getConnectionAuthToken(isServer, connection.authTokenProvider, connection.anonymous);
+                initialAuthToken = undefined;
+            }
+            catch (error) {
+                if (connections.get(connKey) !== connection)
+                    break;
+                const authError = normalizeAuthExpiredError(error, 'Authentication expired and refresh failed');
+                failConnectionAuth(connection, authError);
+                // An error callback may synchronously tear down or replace this
+                // connection. Do not install a retry after its cleanup completed.
+                if (connections.get(connKey) !== connection)
+                    break;
+                await new Promise((resolve) => {
+                    const wake = () => {
+                        clearTimeout(timer);
+                        if (connection.authRetryWake === wake)
+                            connection.authRetryWake = undefined;
+                        resolve();
+                    };
+                    const timer = setTimeout(wake, retryDelay);
+                    connection.authRetryWake = wake;
+                });
+                retryDelay = Math.min(MAX_RECONNECT_DELAY_MS, retryDelay * RECONNECT_DELAY_GROW_FACTOR);
+                continue;
+            }
+            if (connections.get(connKey) !== connection)
+                break;
+            connection.pendingAuthToken = authToken || null;
+            connection.pendingAuthSnapshot = authSnapshotFromToken(authToken);
             connection.consecutiveAuthFailures = 0;
             connection.authFailure = null;
+            return wsUrl.toString();
         }
+        // Teardown has called close() on the wrapper, which prevents creation
+        // of a native socket when this abandoned provider resolves.
         return wsUrl.toString();
     };
     // Create WebSocket connection
@@ -6711,6 +6747,13 @@ async function subscribeV2(path, subscriptionOptions, roomRoutePath) {
             authPrincipal: connection.authPrincipal,
         };
         connection.pendingSubscriptions.set(subscriptionId, pending);
+        // A fast auth refusal can open and close the socket before the first
+        // caller finishes acquiring it. Keep this subscription for recovery,
+        // but report the already observed disconnect without a timeout delay.
+        if (pending.socketGeneration > 0 && socket.readyState === WS_READY_STATE_CLOSED) {
+            rejectPendingSubscriptionConfirmation(connection, subscriptionId, new Error('WebSocket disconnected'));
+            return;
+        }
         // Bound a cold connection/auth wait as well. Once the socket becomes
         // ready, sendSubscribeWithConfirmation() replaces this timer with a
         // fresh per-socket confirmation window.
@@ -6788,6 +6831,7 @@ async function removeCallbackFromSubscription(connection, subscriptionId, callba
  * Close all v2 subscriptions.
  */
 async function closeAllSubscriptionsV2() {
+    var _a;
     const closePromises = [];
     for (const [appId, connection] of connections) {
         cancelIdleConnectionClose(connection);
@@ -6814,8 +6858,14 @@ async function closeAllSubscriptionsV2() {
                     ws.close();
                 }));
             }
+            else {
+                // CLOSED may mean a URL/auth acquisition is still pending.
+                // close() also disables the wrapper's future native socket.
+                ws.close();
+            }
         }
         connections.delete(appId);
+        (_a = connection.authRetryWake) === null || _a === void 0 ? void 0 : _a.call(connection);
     }
     connectionAcquisitions.clear();
     await Promise.all(closePromises);
@@ -6894,7 +6944,7 @@ async function reconnectWithNewAuthV2() {
     }
 }
 async function doReconnectWithNewAuth() {
-    ambientAuthFailure = null;
+    var _a;
     // SECURITY (H1): the logged-in identity is changing (login / logout / switch).
     // Wipe ALL principal-scoped read caches so the new identity can never observe
     // data cached for the previous one. Clear both the WS response cache and the
@@ -6916,7 +6966,7 @@ async function doReconnectWithNewAuth() {
         console.warn('[WS v2] Failed to clear HTTP read cache on auth change:', error);
     }
     try {
-        const { reconnectRealtimeStoreWithNewAuth } = await import('./realtime-store-DTS5OLm2.mjs');
+        const { reconnectRealtimeStoreWithNewAuth } = await import('./realtime-store-CeDT7vJF.mjs');
         await reconnectRealtimeStoreWithNewAuth();
     }
     catch (error) {
@@ -6941,6 +6991,7 @@ async function doReconnectWithNewAuth() {
         // Reset auth failure counter — this is a proactive reconnect (login, token refresh)
         connection.consecutiveAuthFailures = 0;
         connection.authFailure = null;
+        (_a = connection.authRetryWake) === null || _a === void 0 ? void 0 : _a.call(connection);
         // Close the WebSocket (this triggers reconnection in ReconnectingWebSocket)
         // We use reconnect() which will close and re-open with fresh URL (including new token)
         try {
@@ -8366,7 +8417,7 @@ async function setMany(many, options) {
                         'Nothing was signed or submitted.');
                 }
                 const solanaChain = workerChain;
-                const { handlePreBuiltTransaction, buildExpectedWriteIntent } = await import('./solana-operations-da26Ject.mjs');
+                const { handlePreBuiltTransaction, buildExpectedWriteIntent } = await import('./solana-operations-CHgW7Pue.mjs');
                 // OA-0001: derive the expected intent from OUR OWN request (the one
                 // ground truth a tampered builder response cannot change) so the
                 // validator can reject any transaction whose operation semantics
@@ -9851,7 +9902,7 @@ function toMillis(seconds) {
 
 /** SIWS message creation is async already, so its onchain module can be lazy. */
 async function genSolanaMessage(address, nonce) {
-    const implementation = await import('./solana-message-j1s9osZD.mjs');
+    const implementation = await import('./solana-message-BGkYFU3C.mjs');
     return implementation.genSolanaMessage(address, nonce);
 }
 
@@ -10401,4 +10452,4 @@ function defineLiveModule(mod) {
 }
 
 export { getIdToken as $, subscribe as A, closeAllSubscriptions as B, clearCache as C, getCachedData as D, reconnectWithNewAuth as E, createClient as F, ScopedClientReadOnlyError as G, subscribeQuery as H, InsufficientBalanceError as I, closeAllQuerySubscriptions as J, canonicalizeArgs as K, canonicalizeResult as L, DEFAULT_QUERY_POLL_INTERVAL_MS as M, MIN_QUERY_POLL_INTERVAL_MS as N, BoundedDeclineError as O, deriveDecline as P, dispatchDeclineEvent as Q, DECLINE_EVENT_NAME as R, SOLANA_MAX_SUPPORTED_TRANSACTION_VERSION as S, dispatchRateLimitEvent as T, RATE_LIMIT_EVENT_NAME as U, hasActiveConnection as V, increment as W, serverTimestamp as X, now as Y, toSeconds as Z, toMillis as _, getTransactionJson as a, deriveUserIdentityFromIdToken as a0, getSessionGeneration as a1, WebSessionManager as a2, ReactNativeSessionManager as a3, getActiveSessionManager as a4, onSessionCleared as a5, SessionEnvironmentError as a6, UNSUPPORTED_ENVIRONMENT_CODE as a7, AUTH_CHANGED_CODE as a8, AUTH_EXPIRED_CODE as a9, withEffects as aA, isEffectResult as aB, defineLiveModule as aC, EFFECT_INTENT_ADDRESS as aD, isAuthExpiredError as aa, getFreshAuthToken as ab, ServerSessionManager as ac, createSessionWithSignature as ad, refreshSession as ae, revokeSession as af, signSessionCreateMessage as ag, genAuthNonce as ah, genSolanaMessage as ai, createSolanaSignInRequest as aj, createSolanaSignInMessageText as ak, genSolanaSignInRequest as al, genSolanaSignInMessage as am, browserSignInDomain as an, SOLANA_SIGN_IN_STATEMENT as ao, genSiweMessage as ap, normalizeEvmAddress as aq, toLowerEvmAddress as ar, functions as as, invoke as at, FunctionInvokeError as au, live as av, intent as aw, status as ax, subscribeView as ay, LiveIntentError as az, bufferExports as b, getWebhookKeysUrl as c, getConfiguredAppId as d, get as e, getMany as f, getConfig as g, docId as h, init as i, setMany as j, setFile as k, getFiles as l, search as m, runQueryMany as n, runExpression as o, runExpressionMany as p, queryAggregate as q, runQuery as r, set as s, signMessage as t, signTransaction as u, signAndSubmitTransaction as v, count as w, aggregate as x, reconcileSetResult as y, waitForSetResult as z };
-//# sourceMappingURL=index-BDW82Uxu.mjs.map
+//# sourceMappingURL=index-DW5yMQwV.mjs.map