@bounded-sh/core 0.0.48 → 0.0.49

package/dist/{index-Kn7IIh5d.js → index-D6xrWKP7.js}

@@ -17,6 +17,7 @@ let clientConfig = {
     authApiUrl: 'https://wallet-auth.bounded.sh',
     humanAuthApiUrl: 'https://auth.bounded.sh',
     functionsUrl: 'https://functions.bounded.sh',
+    devApiUrl: 'https://dev-api.bounded.sh',
     appId: '',
     // No hidden modal fallback: browser clients start hosted Bounded Auth with
     // loginWithRedirect/loginWithPopup. For crypto/onchain wallet login use
@@ -41,6 +42,7 @@ const BOUNDED_NETWORKS = {
         authApiUrl: 'https://wallet-auth-staging.bounded.sh',
         humanAuthApiUrl: 'https://auth-staging.bounded.sh',
         functionsUrl: 'https://functions-staging.bounded.sh',
+        devApiUrl: 'https://dev-api-staging.bounded.sh',
     },
     'bounded-production': {
         // All on bounded.sh custom domains. authApiUrl = WALLET/SIWS issuer
@@ -51,6 +53,7 @@ const BOUNDED_NETWORKS = {
         authApiUrl: 'https://wallet-auth.bounded.sh',
         humanAuthApiUrl: 'https://auth.bounded.sh',
         functionsUrl: 'https://functions.bounded.sh',
+        devApiUrl: 'https://dev-api.bounded.sh',
     },
 };
 // `network: 'bounded'` is an alias for the current GA target.
@@ -3407,7 +3410,7 @@ class ServerSessionManager {
         const address = kp.publicKey.toBase58();
         /* fetch nonce from auth API */
         const nonce = await genAuthNonce();
-        const { genSolanaMessage } = await Promise.resolve().then(function () { return require('./solana-message-DSkrhvy8.js'); });
+        const { genSolanaMessage } = await Promise.resolve().then(function () { return require('./solana-message-CTUg0Tqd.js'); });
         const message = await genSolanaMessage(address, nonce);
         /* sign the message */
         const sigBytes = nacl.sign.detached(new TextEncoder().encode(message), kp.secretKey);
@@ -5444,11 +5447,11 @@ async function setMany(many, options) {
                 transactionResult = await handleEvmTransaction(curTx.evmTransaction, authProvider, options);
             }
             else if (curTx.serializedTransaction) {
-                const { handlePreBuiltTransaction } = await Promise.resolve().then(function () { return require('./solana-operations-C_aie1aF.js'); });
+                const { handlePreBuiltTransaction } = await Promise.resolve().then(function () { return require('./solana-operations-CSh2uF_0.js'); });
                 transactionResult = await handlePreBuiltTransaction(curTx, authProvider, options, expectedWritePaths);
             }
             else {
-                const { handleSolanaTransaction } = await Promise.resolve().then(function () { return require('./solana-operations-C_aie1aF.js'); });
+                const { handleSolanaTransaction } = await Promise.resolve().then(function () { return require('./solana-operations-CSh2uF_0.js'); });
                 transactionResult = await handleSolanaTransaction(curTx, authProvider, options, expectedWritePaths);
             }
             // Sync items after all transactions are confirmed
@@ -6106,7 +6109,10 @@ function roomKeyFromRoutePath(routePath) {
 function replaySubscriptions(connection) {
     for (const sub of connection.subscriptions.values()) {
         sub.lastData = undefined;
-        sendSubscribe(connection, sub);
+        if (!connection.pendingSubscriptions.has(sub.subscriptionId)) {
+            registerDetachedReplayConfirmation(connection, sub);
+        }
+        sendSubscribeWithConfirmation(connection, sub);
     }
 }
 /**
@@ -6146,6 +6152,9 @@ function closeConnectionNow(connection) {
     connection.isConnected = false;
     connection.isAuthenticating = false;
     const closeError = new Error('WebSocket connection closed');
+    for (const subscriptionId of Array.from(connection.pendingSubscriptions.keys())) {
+        rejectPendingSubscriptionConfirmation(connection, subscriptionId, closeError);
+    }
     for (const subscription of connection.subscriptions.values()) {
         rejectSubscriptionRefresh(subscription, closeError);
     }
@@ -6791,6 +6800,75 @@ function armSubscriptionConfirmationTimeout(connection, subscription, pending) {
         rejectPendingSubscriptionConfirmation(connection, subscription.subscriptionId, new Error('Subscription timeout'));
     }, SUBSCRIPTION_CONFIRM_TIMEOUT_MS);
 }
+/**
+ * Bind an existing confirmation promise to the exact socket session that is
+ * about to carry its subscribe frame. Cold-start registrations create the
+ * promise before the socket opens; replay uses this helper to move the timeout
+ * from the connection wait onto the authenticated socket without allocating a
+ * second promise or leaving the original timer behind.
+ */
+function sendSubscribeWithConfirmation(connection, subscription) {
+    const pending = connection.pendingSubscriptions.get(subscription.subscriptionId);
+    const socket = connection.ws;
+    if (pending && socket && socket.readyState === WS_READY_STATE_OPEN) {
+        if (pending.timer) {
+            clearTimeout(pending.timer);
+            pending.timer = null;
+        }
+        pending.socket = socket;
+        pending.socketGeneration = connection.socketGeneration;
+        pending.authTokenValue = connection.authTokenValue;
+        pending.authPrincipal = connection.authPrincipal;
+        // Arm before send: browser/test transports may synchronously dispatch
+        // the subscribed/data/error response from send().
+        armSubscriptionConfirmationTimeout(connection, subscription, pending);
+    }
+    sendSubscribe(connection, subscription);
+}
+/**
+ * A reconnect replay has no caller awaiting subscribeV2 anymore, but it still
+ * needs the same bounded confirmation/retry guarantee. Attach the rejection
+ * handler immediately so this recovery record can never become an unhandled
+ * promise. Structured server errors are delivered by handleServerMessage;
+ * terminal local timeouts are surfaced here exactly once to active callbacks.
+ */
+function registerDetachedReplayConfirmation(connection, subscription) {
+    const socket = connection.ws;
+    if (!socket || connection.pendingSubscriptions.has(subscription.subscriptionId))
+        return;
+    let resolve;
+    let reject;
+    const promise = new Promise((resolvePromise, rejectPromise) => {
+        resolve = resolvePromise;
+        reject = rejectPromise;
+    });
+    const pending = {
+        resolve,
+        reject,
+        timer: null,
+        retrySent: false,
+        socket,
+        socketGeneration: connection.socketGeneration,
+        authTokenValue: connection.authTokenValue,
+        authPrincipal: connection.authPrincipal,
+    };
+    connection.pendingSubscriptions.set(subscription.subscriptionId, pending);
+    void promise.catch((error) => {
+        if (error.__boundedDeliveredToOnError)
+            return;
+        if (connection.subscriptions.get(subscription.subscriptionId) !== subscription)
+            return;
+        // Ordinary socket/auth-change close paths will replay again and did not
+        // historically poison every established callback. Only a healthy socket
+        // exhausting its bounded confirmation retry is a new terminal condition.
+        if (error.message === 'Subscription timeout') {
+            const delivered = notifyErrorCallbacks(subscription, error);
+            if (!delivered) {
+                console.warn('[WS v2] Replayed subscription confirmation timed out:', subscription.path);
+            }
+        }
+    });
+}
 function resolveSubscriptionRefresh(subscription) {
     const refresh = subscription.refresh;
     if (!refresh)
@@ -7063,53 +7141,57 @@ async function subscribeV2(path, subscriptionOptions, roomRoutePath) {
         throw error;
     }
     releaseConnection();
-    // Send subscribe message if connected
+    // Register the confirmation before any possible synchronous send/ACK. This
+    // includes the first subscription on a cold socket: replaySubscriptions()
+    // will bind this same pending record to the authenticated socket and send it.
+    const subscriptionPromise = new Promise((resolve, reject) => {
+        const socket = connection.ws;
+        if (!socket) {
+            reject(new Error('WebSocket disconnected'));
+            return;
+        }
+        const pending = {
+            resolve,
+            reject,
+            timer: null,
+            retrySent: false,
+            socket,
+            socketGeneration: connection.socketGeneration,
+            authTokenValue: connection.authTokenValue,
+            authPrincipal: connection.authPrincipal,
+        };
+        connection.pendingSubscriptions.set(subscriptionId, pending);
+        // Bound a cold connection/auth wait as well. Once the socket becomes
+        // ready, sendSubscribeWithConfirmation() replaces this timer with a
+        // fresh per-socket confirmation window.
+        armSubscriptionConfirmationTimeout(connection, subscription, pending);
+    });
     if (connection.isConnected && !connection.isAuthenticating) {
-        // Create a promise to wait for subscription confirmation
-        const subscriptionPromise = new Promise((resolve, reject) => {
-            const socket = connection.ws;
-            if (!socket) {
-                reject(new Error('WebSocket disconnected'));
-                return;
-            }
-            const pending = {
-                resolve,
-                reject,
-                timer: null,
-                retrySent: false,
-                socket,
-                socketGeneration: connection.socketGeneration,
-                authTokenValue: connection.authTokenValue,
-                authPrincipal: connection.authPrincipal,
-            };
-            connection.pendingSubscriptions.set(subscriptionId, pending);
-            armSubscriptionConfirmationTimeout(connection, subscription, pending);
-        });
-        sendSubscribe(connection, subscription);
-        try {
-            await subscriptionPromise;
+        sendSubscribeWithConfirmation(connection, subscription);
+    }
+    try {
+        await subscriptionPromise;
+    }
+    catch (error) {
+        const err = error instanceof Error ? error : new Error(String(error));
+        let deliveredLocally = false;
+        if (!err.__boundedDeliveredToOnError) {
+            // A local confirmation timeout belongs to the caller that
+            // originated it. Joined callbacks may already have a viable
+            // same-id refresh and must not be poisoned by that old attempt.
+            deliveredLocally = notifyErrorCallback(subscriptionOptions, err);
+        }
+        if (!subscriptionOptions.onError) {
+            rejectPendingSubscriptionConfirmation(connection, subscriptionId, err);
+            // This registration may have acquired joined callbacks while
+            // its confirmation was pending. Remove only the originating
+            // callback; deleting the whole logical subscription would
+            // orphan those remounted consumers and their refresh flight.
+            await removeCallbackFromSubscription(connection, subscriptionId, subscriptionOptions);
+            throw err;
         }
-        catch (error) {
-            const err = error instanceof Error ? error : new Error(String(error));
-            let deliveredLocally = false;
-            if (!err.__boundedDeliveredToOnError) {
-                // A local confirmation timeout belongs to the caller that
-                // originated it. Joined callbacks may already have a viable
-                // same-id refresh and must not be poisoned by that old attempt.
-                deliveredLocally = notifyErrorCallback(subscriptionOptions, err);
-            }
-            if (!subscriptionOptions.onError) {
-                connection.pendingSubscriptions.delete(subscriptionId);
-                // This registration may have acquired joined callbacks while
-                // its confirmation was pending. Remove only the originating
-                // callback; deleting the whole logical subscription would
-                // orphan those remounted consumers and their refresh flight.
-                await removeCallbackFromSubscription(connection, subscriptionId, subscriptionOptions);
-                throw err;
-            }
-            if (!err.__boundedDeliveredToOnError && !deliveredLocally) {
-                console.warn('[WS v2] Subscription confirmation failed, keeping for reconnect recovery:', error);
-            }
+        if (!err.__boundedDeliveredToOnError && !deliveredLocally) {
+            console.warn('[WS v2] Subscription confirmation failed, keeping for reconnect recovery:', error);
         }
     }
     // Return unsubscribe function
@@ -7132,6 +7214,7 @@ async function removeCallbackFromSubscription(connection, subscriptionId, callba
     }
     // No more callbacks, unsubscribe from server
     connection.subscriptions.delete(subscriptionId);
+    rejectPendingSubscriptionConfirmation(connection, subscriptionId, new Error('Subscription unsubscribed'));
     if (connection.isConnected && !connection.isAuthenticating) {
         // Create a promise to wait for unsubscription confirmation
         const unsubscribePromise = new Promise((resolve, reject) => {
@@ -7159,6 +7242,9 @@ async function closeAllSubscriptionsV2() {
     for (const [appId, connection] of connections) {
         cancelIdleConnectionClose(connection);
         const closeError = new Error('Subscriptions closed');
+        for (const subscriptionId of Array.from(connection.pendingSubscriptions.keys())) {
+            rejectPendingSubscriptionConfirmation(connection, subscriptionId, closeError);
+        }
         for (const subscription of connection.subscriptions.values()) {
             rejectSubscriptionRefresh(subscription, closeError);
         }
@@ -7280,7 +7366,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-DssTn6Nr.js'); });
+        const { reconnectRealtimeStoreWithNewAuth } = await Promise.resolve().then(function () { return require('./realtime-store-HkfnxBu3.js'); });
         await reconnectRealtimeStoreWithNewAuth();
     }
     catch (error) {
@@ -7625,7 +7711,7 @@ async function buildSetDocumentsTransaction(connection, idl, programProvider, pa
 }
 /** 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-DSkrhvy8.js'); });
+    const implementation = await Promise.resolve().then(function () { return require('./solana-message-CTUg0Tqd.js'); });
     return implementation.genSolanaMessage(address, nonce);
 }
 const BASE58_ALPHABET = "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz";
@@ -8228,4 +8314,4 @@ exports.toLowerEvmAddress = toLowerEvmAddress;
 exports.toMillis = toMillis;
 exports.toSeconds = toSeconds;
 exports.withEffects = withEffects;
-//# sourceMappingURL=index-Kn7IIh5d.js.map
+//# sourceMappingURL=index-D6xrWKP7.js.map