@bounded-sh/core 0.0.98 → 0.0.99

package/dist/client/config.d.ts

@@ -185,6 +185,7 @@ export declare function getWebhookKeysUrl(): string | undefined;
  * `verifyWebhook` to bind a webhook to THIS app by default (#072) rather than trusting any
  * app's shared-key-signed delivery.
  */
+export declare function getConfiguredSessionNamespace(): string;
 export declare function getConfiguredAppId(): string | undefined;
 /**
  * True when init() configured a Bounded network (the Cloudflare-native stack).

package/dist/{index-D-dJjY-Q.js → index-B8PpRj6x.js}

@@ -89,6 +89,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;
 }
@@ -927,6 +930,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")
@@ -986,10 +1013,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.
@@ -997,6 +1025,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})`);
@@ -1014,6 +1043,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).
@@ -1021,12 +1053,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                                                                */
@@ -1141,10 +1194,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
@@ -1291,7 +1348,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 {
@@ -4133,7 +4190,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 Promise.resolve().then(function () { return require('./solana-message-Cww3s9HW.js'); });
+        const { genSolanaMessage } = await Promise.resolve().then(function () { return require('./solana-message-w2FxOkFA.js'); });
         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);
@@ -5241,7 +5298,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)}`;
@@ -5369,34 +5425,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;
@@ -5451,8 +5479,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
@@ -5482,28 +5510,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');
     }
 }
 /**
@@ -5521,18 +5540,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) {
@@ -5543,9 +5565,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 {
@@ -5650,11 +5669,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;
@@ -5675,7 +5696,7 @@ function closeConnectionNow(connection) {
     try {
         ws.close();
     }
-    catch ( /* already closing */_a) { /* already closing */ }
+    catch ( /* already closing */_b) { /* already closing */ }
 }
 function scheduleConnectionCloseIfIdle(connection) {
     var _a;
@@ -5761,6 +5782,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
@@ -5807,9 +5829,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);
@@ -5819,6 +5838,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)) {
@@ -5861,50 +5888,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
@@ -6713,6 +6749,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.
@@ -6790,6 +6833,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);
@@ -6816,8 +6860,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);
@@ -6896,7 +6946,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
@@ -6918,7 +6968,7 @@ async function doReconnectWithNewAuth() {
         console.warn('[WS v2] Failed to clear HTTP read cache on auth change:', error);
     }
     try {
-        const { reconnectRealtimeStoreWithNewAuth } = await Promise.resolve().then(function () { return require('./realtime-store-Dytq73zO.js'); });
+        const { reconnectRealtimeStoreWithNewAuth } = await Promise.resolve().then(function () { return require('./realtime-store-D7mJ7rTj.js'); });
         await reconnectRealtimeStoreWithNewAuth();
     }
     catch (error) {
@@ -6943,6 +6993,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 {
@@ -8368,7 +8419,7 @@ async function setMany(many, options) {
                         'Nothing was signed or submitted.');
                 }
                 const solanaChain = workerChain;
-                const { handlePreBuiltTransaction, buildExpectedWriteIntent } = await Promise.resolve().then(function () { return require('./solana-operations-SR1En23U.js'); });
+                const { handlePreBuiltTransaction, buildExpectedWriteIntent } = await Promise.resolve().then(function () { return require('./solana-operations-DJQDYdrk.js'); });
                 // 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
@@ -9853,7 +9904,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 Promise.resolve().then(function () { return require('./solana-message-Cww3s9HW.js'); });
+    const implementation = await Promise.resolve().then(function () { return require('./solana-message-w2FxOkFA.js'); });
     return implementation.genSolanaMessage(address, nonce);
 }
 
@@ -10496,4 +10547,4 @@ exports.toMillis = toMillis;
 exports.toSeconds = toSeconds;
 exports.waitForSetResult = waitForSetResult;
 exports.withEffects = withEffects;
-//# sourceMappingURL=index-D-dJjY-Q.js.map
+//# sourceMappingURL=index-B8PpRj6x.js.map