@bounded-sh/core 0.0.48 → 0.0.49

package/dist/client/config.d.ts

@@ -24,12 +24,17 @@ export interface ClientConfig {
      *  optional text OTP. App-origin OTP helpers are retired; use hosted
      *  loginWithRedirect/loginWithPopup against this issuer. Defaults per network. */
     humanAuthApiUrl?: string;
+    /**
+     * Base URL of the Bounded developer API used by first-party platform
+     * surfaces for app provisioning and build control. Defaults per network.
+     */
+    devApiUrl?: string;
     /**
      * Selects a Bounded backend preset. When set, the endpoint defaults
-     * (apiUrl/wsApiUrl/authApiUrl/functionsUrl) resolve to that network's Bounded
-     * services instead of the legacy defaults — so a Bounded app needs only
-     * `{ appId, network }`. Anything you pass explicitly still wins. Unset =
-     * legacy behavior (unchanged for existing apps).
+     * (apiUrl/wsApiUrl/authApiUrl/humanAuthApiUrl/functionsUrl/devApiUrl) resolve
+     * to that network's Bounded services instead of the legacy defaults — so a
+     * Bounded app needs only `{ appId, network }`. Anything you pass explicitly
+     * still wins. Unset = legacy behavior (unchanged for existing apps).
      */
     network?: 'bounded' | 'bounded-staging' | 'bounded-production';
     chain: string;
@@ -121,7 +126,7 @@ export interface ClientConfig {
     };
 }
 export declare let clientConfig: ClientConfig;
-type BoundedEndpoints = Pick<ClientConfig, 'wsApiUrl' | 'apiUrl' | 'authApiUrl' | 'humanAuthApiUrl' | 'functionsUrl'>;
+type BoundedEndpoints = Pick<ClientConfig, 'wsApiUrl' | 'apiUrl' | 'authApiUrl' | 'humanAuthApiUrl' | 'functionsUrl' | 'devApiUrl'>;
 export declare const BOUNDED_NETWORKS: Record<string, BoundedEndpoints>;
 /**
  * The hosted `/.well-known/bounded-webhook-keys.json` URL for the configured

package/dist/client/token-subscription.d.ts

@@ -0,0 +1,22 @@
+export interface TokenSubscriptionOptions {
+    limit?: number;
+    onData(data: unknown): void;
+    onError?(error: Error): void;
+}
+export interface BoundedTokenSubscribeClient {
+    subscribe(path: string, options: TokenSubscriptionOptions): Promise<() => Promise<void>>;
+    close(): void;
+}
+export interface BoundedTokenSubscribeConfig {
+    appId: string;
+    wsApiUrl: string;
+    token(): Promise<string>;
+}
+/**
+ * Narrow browser client for Bounded's authenticated WebSocket-v2 `subscribe`
+ * protocol. It exists for access-gated pages that already own a short-lived,
+ * read-only token and therefore must not pull wallet, write, or chain code into
+ * the browser bundle. Tokens are sent only in the first socket frame, never in
+ * the URL, storage, errors, or logs.
+ */
+export declare function createBoundedTokenSubscribeClient(config: BoundedTokenSubscribeConfig): BoundedTokenSubscribeClient;

package/dist/{index-Bq2Zug5X.mjs → index-CXyMnWgK.mjs}

@@ -15,6 +15,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
@@ -39,6 +40,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
@@ -49,6 +51,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.
@@ -3405,7 +3408,7 @@ class ServerSessionManager {
         const address = kp.publicKey.toBase58();
         /* fetch nonce from auth API */
         const nonce = await genAuthNonce();
-        const { genSolanaMessage } = await import('./solana-message-Svo0_paO.mjs');
+        const { genSolanaMessage } = await import('./solana-message-l5OZo1j2.mjs');
         const message = await genSolanaMessage(address, nonce);
         /* sign the message */
         const sigBytes = nacl.sign.detached(new TextEncoder().encode(message), kp.secretKey);
@@ -5442,11 +5445,11 @@ async function setMany(many, options) {
                 transactionResult = await handleEvmTransaction(curTx.evmTransaction, authProvider, options);
             }
             else if (curTx.serializedTransaction) {
-                const { handlePreBuiltTransaction } = await import('./solana-operations-4MGSdS1U.mjs');
+                const { handlePreBuiltTransaction } = await import('./solana-operations-TSE5Tbgo.mjs');
                 transactionResult = await handlePreBuiltTransaction(curTx, authProvider, options, expectedWritePaths);
             }
             else {
-                const { handleSolanaTransaction } = await import('./solana-operations-4MGSdS1U.mjs');
+                const { handleSolanaTransaction } = await import('./solana-operations-TSE5Tbgo.mjs');
                 transactionResult = await handleSolanaTransaction(curTx, authProvider, options, expectedWritePaths);
             }
             // Sync items after all transactions are confirmed
@@ -6104,7 +6107,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);
     }
 }
 /**
@@ -6144,6 +6150,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);
     }
@@ -6789,6 +6798,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)
@@ -7061,53 +7139,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
@@ -7130,6 +7212,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) => {
@@ -7157,6 +7240,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);
         }
@@ -7278,7 +7364,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-XKFKDJRA.mjs');
+        const { reconnectRealtimeStoreWithNewAuth } = await import('./realtime-store-Djb_Dm-M.mjs');
         await reconnectRealtimeStoreWithNewAuth();
     }
     catch (error) {
@@ -7623,7 +7709,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 import('./solana-message-Svo0_paO.mjs');
+    const implementation = await import('./solana-message-l5OZo1j2.mjs');
     return implementation.genSolanaMessage(address, nonce);
 }
 const BASE58_ALPHABET = "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz";
@@ -8156,4 +8242,4 @@ function defineLiveModule(mod) {
 }
 
 export { normalizeEvmAddress as $, reconnectWithNewAuth as A, BoundedDeclineError as B, deriveDecline as C, dispatchDeclineEvent as D, DECLINE_EVENT_NAME as E, hasActiveConnection as F, increment as G, serverTimestamp as H, InsufficientBalanceError as I, now as J, toSeconds as K, toMillis as L, getIdToken as M, deriveUserIdentityFromIdToken as N, getActiveSessionManager as O, createSessionWithSignature as P, refreshSession as Q, ReactNativeSessionManager as R, ServerSessionManager as S, revokeSession as T, signSessionCreateMessage as U, genAuthNonce as V, WebSessionManager as W, buildSetDocumentsTransaction as X, convertRemainingAccounts as Y, genSolanaMessage as Z, genSiweMessage as _, getWebhookKeysUrl as a, toLowerEvmAddress as a0, assertCanonicalBoundedRuntimeWriteCalldata as a1, assertEvmTransactionMatchesWrite as a2, BOUNDED_RUNTIME_SET_DOCUMENTS_SELECTOR as a3, BOUNDED_RUNTIME_SET_DOCUMENTS_ATTESTED_SELECTOR as a4, functions as a5, invoke as a6, FunctionInvokeError as a7, live as a8, intent as a9, status as aa, subscribeView as ab, LiveIntentError as ac, withEffects as ad, isEffectResult as ae, defineLiveModule as af, EFFECT_INTENT_ADDRESS as ag, bufferExports as b, get as c, getMany as d, docId as e, setMany as f, getConfig as g, setFile as h, init as i, getFiles as j, search as k, runQueryMany as l, runExpression as m, runExpressionMany as n, signMessage as o, signTransaction as p, queryAggregate as q, runQuery as r, set as s, signAndSubmitTransaction as t, count as u, aggregate as v, subscribe as w, closeAllSubscriptions as x, clearCache as y, getCachedData as z };
-//# sourceMappingURL=index-Bq2Zug5X.mjs.map
+//# sourceMappingURL=index-CXyMnWgK.mjs.map