@pooflabs/core 0.0.21 → 0.0.23

package/dist/index.js

@@ -3468,6 +3468,10 @@ async function setMany(many, options) {
                 lastTxSignature = transactionResult.transactionSignature;
                 signedTransaction = transactionResult.signedTransaction;
             }
+            // Sync items after all transactions are confirmed
+            // Wait for 1.5 seconds to ensure all transactions are confirmed
+            await new Promise(resolve => setTimeout(resolve, 1500));
+            await syncItems(many.map(m => m.path));
             // TODO: Should we wait here or do the optimistic subscription updates like below?
             return Object.assign(Object.assign({}, documents.map(d => d.document)), { transactionId: lastTxSignature, signedTransaction: signedTransaction });
         }
@@ -3679,40 +3683,102 @@ async function signAndSubmitTransaction(transaction, feePayer) {
     }
     return config.authProvider.signAndSubmitTransaction(transaction, feePayer);
 }
+async function syncItems(paths) {
+    try {
+        const response = await makeApiRequest('PUT', 'items/sync', { paths }, undefined);
+        return response.data;
+    }
+    catch (error) {
+        throw error;
+    }
+}
 
-const activeConnections = {};
-const responseCache = {};
-const CACHE_TTL = 5 * 60 * 1000; // 5 minutes cache TTL
-// Check if a JWT token is expired (with 60 second buffer)
+/**
+ * WebSocket v2 Subscription Manager
+ *
+ * This module implements multiplexed subscriptions over a single WebSocket connection.
+ * It maintains the same external API as v1 but uses the new v2 protocol internally.
+ */
+// ============ Global State ============
+// One connection per appId
+const connections = new Map();
+const responseCache = new Map();
+const CACHE_TTL = 5 * 60 * 1000; // 5 minutes
+const TOKEN_REFRESH_BUFFER = 5 * 60 * 1000; // Refresh token 5 minutes before expiry
+// ============ WebSocket Config ============
+const WS_CONFIG = {
+    maxRetries: 10,
+    minReconnectionDelay: 1000,
+    maxReconnectionDelay: 30000,
+    reconnectionDelayGrowFactor: 1.3,
+    connectionTimeout: 4000,
+};
+const WS_V2_PATH = '/ws/v2';
+// ============ Helper Functions ============
+function generateSubscriptionId() {
+    return `sub_${Date.now()}_${Math.random().toString(36).substring(2, 11)}`;
+}
+function getCacheKey(path, prompt) {
+    const normalizedPath = path.startsWith('/') ? path.slice(1) : path;
+    return `${normalizedPath}:${prompt || 'default'}`;
+}
 function isTokenExpired(token) {
     try {
         const payload = JSON.parse(atob(token.split('.')[1]));
-        const expirationTime = payload.exp * 1000; // Convert to milliseconds
+        const expirationTime = payload.exp * 1000;
         const currentTime = Date.now();
-        // Add 60 second buffer to refresh before actual expiration
-        return currentTime > (expirationTime - 60000);
+        return currentTime > (expirationTime - 60000); // 60 second buffer
     }
     catch (error) {
-        console.error('Error checking token expiration:', error);
-        return true; // Assume expired if we can't parse
+        console.error('[WS v2] Error checking token expiration:', error);
+        return true;
+    }
+}
+function getTokenExpirationTime(token) {
+    try {
+        const payload = JSON.parse(atob(token.split('.')[1]));
+        return payload.exp ? payload.exp * 1000 : null;
+    }
+    catch (_a) {
+        return null;
     }
 }
-// Get a fresh auth token, refreshing if necessary
+function scheduleTokenRefresh(connection, token) {
+    // Clear any existing timer
+    if (connection.tokenRefreshTimer) {
+        clearTimeout(connection.tokenRefreshTimer);
+        connection.tokenRefreshTimer = null;
+    }
+    if (!token) {
+        return; // No token = unauthenticated, no refresh needed
+    }
+    const expirationTime = getTokenExpirationTime(token);
+    if (!expirationTime) {
+        return; // Can't parse expiration
+    }
+    const refreshTime = expirationTime - TOKEN_REFRESH_BUFFER;
+    const delay = refreshTime - Date.now();
+    if (delay <= 0) {
+        // Token already expired or about to expire, reconnect immediately
+        reconnectWithNewAuthV2();
+        return;
+    }
+    connection.tokenRefreshTimer = setTimeout(() => {
+        reconnectWithNewAuthV2();
+    }, delay);
+}
 async function getFreshAuthToken(isServer) {
     const currentToken = await getIdToken(isServer);
     if (!currentToken) {
         return null;
     }
-    // If token is not expired, return it
     if (!isTokenExpired(currentToken)) {
         return currentToken;
     }
-    // Token is expired, try to refresh
     try {
         const refreshToken = await getRefreshToken(isServer);
         if (!refreshToken) {
-            console.warn('No refresh token available for WebSocket reconnection');
-            return currentToken; // Return expired token, backend will reject
+            return currentToken;
         }
         const refreshData = await refreshSession(refreshToken);
         if (refreshData && refreshData.idToken && refreshData.accessToken) {
@@ -3721,177 +3787,507 @@ async function getFreshAuthToken(isServer) {
         }
     }
     catch (error) {
-        console.error('Error refreshing token for WebSocket:', error);
+        console.error('[WS v2] Error refreshing token:', error);
     }
-    return currentToken; // Return current token even if refresh failed
+    return currentToken;
 }
-const WS_CONFIG = {
-    maxRetries: 10,
-    minReconnectionDelay: 1000,
-    maxReconnectionDelay: 30000,
-    reconnectionDelayGrowFactor: 1.3,
-};
-async function subscribe(path, subscriptionOptions) {
-    var _a;
-    const config = await getConfig();
-    const normalizedPath = path.startsWith("/") ? path.slice(1) : path;
-    // Create unique connection key that includes prompt to support multiple subscriptions with different prompts
-    const connectionKey = `${normalizedPath}:${subscriptionOptions.prompt || 'default'}`;
-    // Deliver cached data immediately if available and not expired
-    const cachedEntry = responseCache[connectionKey];
-    if (cachedEntry && Date.now() - cachedEntry.timestamp < CACHE_TTL && subscriptionOptions.onData) {
-        setTimeout(() => {
-            var _a;
-            (_a = subscriptionOptions.onData) === null || _a === void 0 ? void 0 : _a.call(subscriptionOptions, cachedEntry.data);
-        }, 0);
-    }
-    // If there's already an active connection with the same prompt
-    if (activeConnections[connectionKey]) {
-        activeConnections[connectionKey].subscriptions.push(subscriptionOptions);
-        return async () => await removeSubscription(connectionKey, subscriptionOptions);
+// ============ Connection Management ============
+async function getOrCreateConnection(appId, isServer) {
+    let connection = connections.get(appId);
+    if (connection && connection.ws) {
+        return connection;
     }
-    // URL provider function that generates fresh URLs with refreshed tokens on each reconnect
+    // Create new connection
+    connection = {
+        ws: null,
+        subscriptions: new Map(),
+        pendingSubscriptions: new Map(),
+        pendingUnsubscriptions: new Map(),
+        isConnecting: false,
+        isConnected: false,
+        appId,
+        tokenRefreshTimer: null,
+    };
+    connections.set(appId, connection);
+    // URL provider for reconnection with fresh tokens
     const urlProvider = async () => {
+        const config = await getConfig();
         const wsUrl = new URL(config.wsApiUrl);
-        // Logic for console - preserve existing custom app ID logic
+        // Always use v2 path
+        wsUrl.pathname = WS_V2_PATH;
+        // Set appId
         if (typeof window !== 'undefined' && window.CUSTOM_TAROBASE_APP_ID_HEADER) {
-            const customAppId = window.CUSTOM_TAROBASE_APP_ID_HEADER;
-            if (customAppId) {
-                wsUrl.searchParams.append('appId', customAppId);
-            }
+            wsUrl.searchParams.append('appId', window.CUSTOM_TAROBASE_APP_ID_HEADER);
         }
         else {
             wsUrl.searchParams.append('appId', config.appId);
         }
-        wsUrl.searchParams.append('path', normalizedPath);
-        wsUrl.searchParams.append('_t', Date.now().toString()); // Add timestamp to prevent connection reuse issues
-        // Get fresh auth token (will refresh if expired)
-        const authToken = await getFreshAuthToken(config.isServer);
+        // Add timestamp to prevent connection reuse issues
+        wsUrl.searchParams.append('_t', Date.now().toString());
+        // Add auth token if available
+        const authToken = await getFreshAuthToken(isServer);
         if (authToken) {
             wsUrl.searchParams.append('authorization', authToken);
         }
-        if (subscriptionOptions.prompt) {
-            wsUrl.searchParams.append('prompt', btoa(subscriptionOptions.prompt));
-        }
         return wsUrl.toString();
     };
-    // Create a new WebSocket connection with urlProvider for token refresh on reconnect
-    const ws = new ReconnectingWebSocket(urlProvider, [], Object.assign(Object.assign({}, WS_CONFIG), { connectionTimeout: 4000, debug: typeof process !== 'undefined' && ((_a = process.env) === null || _a === void 0 ? void 0 : _a.NODE_ENV) === 'development' }));
-    // Create connection object with connecting flag
-    activeConnections[connectionKey] = {
-        ws,
-        subscriptions: [subscriptionOptions],
-        isConnecting: true,
-    };
+    // Create WebSocket connection
+    connection.isConnecting = true;
+    const ws = new ReconnectingWebSocket(urlProvider, [], Object.assign(Object.assign({}, WS_CONFIG), { debug: false }));
+    connection.ws = ws;
+    // Handle connection open
     ws.addEventListener('open', () => {
-        activeConnections[connectionKey].isConnecting = false;
-        // Fetch initial data if needed (currently commented out)
+        connection.isConnecting = false;
+        connection.isConnected = true;
+        // Schedule token refresh before expiry
         (async () => {
-            try {
-                // For ID Paths, we should fetch the initial data from the api.
-                // This helps us determine if it's null or just loading.
-                if (normalizedPath.split('/').length % 2 === 0) {
-                    const initialData = await get(path, { prompt: subscriptionOptions.prompt });
-                    if (initialData) {
-                        updateCache(connectionKey, initialData);
-                        notifySubscribers(connectionKey, initialData);
-                    }
-                }
-            }
-            catch (error) {
-                notifyError(normalizedPath, error);
-            }
+            const token = await getIdToken(isServer);
+            scheduleTokenRefresh(connection, token);
         })();
+        // Re-subscribe to all existing subscriptions after reconnect
+        for (const sub of connection.subscriptions.values()) {
+            sendSubscribe(connection, sub);
+        }
     });
+    // Handle incoming messages
     ws.addEventListener('message', (event) => {
         try {
-            let data = JSON.parse(event.data);
-            let value = null;
-            if (data && data.length && data.length > 0 && data[0] && data[0].value) {
-                value = data[0].value;
-            }
-            else if (data && data.length) {
-                // If we had a length but didn't have a proper value or element in there, then this is an empty message, and we should just send null.
-                value = null;
-            }
-            else {
-                value = data.value;
-            }
-            updateCache(connectionKey, value);
-            notifySubscribers(connectionKey, value);
+            const message = JSON.parse(event.data);
+            handleServerMessage(connection, message);
         }
         catch (error) {
-            notifyError(connectionKey, error);
+            console.error('[WS v2] Error parsing message:', error);
         }
     });
+    // Handle errors
     ws.addEventListener('error', (event) => {
-        console.error(`WebSocket error for path: ${connectionKey}`, event);
-        notifyError(connectionKey, event);
+        console.error('[WS v2] WebSocket error:', event);
+        // Reject all pending subscriptions
+        for (const [id, pending] of connection.pendingSubscriptions) {
+            pending.reject(new Error('WebSocket error'));
+            connection.pendingSubscriptions.delete(id);
+        }
     });
+    // Handle close
     ws.addEventListener('close', () => {
-        // Connection will be recreated on next subscription if needed
+        connection.isConnected = false;
+        // Clear token refresh timer
+        if (connection.tokenRefreshTimer) {
+            clearTimeout(connection.tokenRefreshTimer);
+            connection.tokenRefreshTimer = null;
+        }
     });
-    return async () => await removeSubscription(connectionKey, subscriptionOptions);
+    return connection;
 }
-function updateCache(path, data) {
-    responseCache[path] = {
-        data,
-        timestamp: Date.now()
-    };
-}
-function notifySubscribers(connectionKey, data) {
+function handleServerMessage(connection, message) {
     var _a;
-    (_a = activeConnections[connectionKey]) === null || _a === void 0 ? void 0 : _a.subscriptions.forEach(sub => {
-        var _a;
-        (_a = sub.onData) === null || _a === void 0 ? void 0 : _a.call(sub, data);
-    });
+    switch (message.type) {
+        case 'subscribed': {
+            const subscription = connection.subscriptions.get(message.subscriptionId);
+            if (subscription) {
+                // Update cache
+                const cacheKey = getCacheKey(subscription.path, subscription.prompt);
+                responseCache.set(cacheKey, { data: message.data, timestamp: Date.now() });
+                // Store last data
+                subscription.lastData = message.data;
+                // Notify callbacks
+                notifyCallbacks(subscription, message.data);
+            }
+            // Resolve pending subscription promise
+            const pending = connection.pendingSubscriptions.get(message.subscriptionId);
+            if (pending) {
+                pending.resolve();
+                connection.pendingSubscriptions.delete(message.subscriptionId);
+            }
+            break;
+        }
+        case 'unsubscribed': {
+            // Resolve pending unsubscription promise
+            const pending = connection.pendingUnsubscriptions.get(message.subscriptionId);
+            if (pending) {
+                pending.resolve();
+                connection.pendingUnsubscriptions.delete(message.subscriptionId);
+            }
+            break;
+        }
+        case 'data': {
+            const subscription = connection.subscriptions.get(message.subscriptionId);
+            if (subscription) {
+                // Update cache
+                const cacheKey = getCacheKey(subscription.path, subscription.prompt);
+                responseCache.set(cacheKey, { data: message.data, timestamp: Date.now() });
+                // Store last data
+                subscription.lastData = message.data;
+                // Notify callbacks
+                notifyCallbacks(subscription, message.data);
+            }
+            break;
+        }
+        case 'error': {
+            console.error('[WS v2] Server error:', message.code, message.message);
+            if (message.subscriptionId) {
+                // Reject pending subscription if this is a subscription error
+                const pending = connection.pendingSubscriptions.get(message.subscriptionId);
+                if (pending) {
+                    pending.reject(new Error(`${message.code}: ${message.message}`));
+                    connection.pendingSubscriptions.delete(message.subscriptionId);
+                }
+                // Notify error callbacks for this subscription
+                const subscription = connection.subscriptions.get(message.subscriptionId);
+                if (subscription) {
+                    for (const callback of subscription.callbacks) {
+                        (_a = callback.onError) === null || _a === void 0 ? void 0 : _a.call(callback, new Error(`${message.code}: ${message.message}`));
+                    }
+                }
+            }
+            break;
+        }
+    }
 }
-function notifyError(connectionKey, error) {
+function notifyCallbacks(subscription, data) {
     var _a;
-    (_a = activeConnections[connectionKey]) === null || _a === void 0 ? void 0 : _a.subscriptions.forEach(sub => {
-        var _a;
-        (_a = sub.onError) === null || _a === void 0 ? void 0 : _a.call(sub, error);
-    });
+    for (const callback of subscription.callbacks) {
+        try {
+            (_a = callback.onData) === null || _a === void 0 ? void 0 : _a.call(callback, data);
+        }
+        catch (error) {
+            console.error('[WS v2] Error in subscription callback:', error);
+        }
+    }
 }
-async function removeSubscription(connectionKey, subscription) {
-    const connection = activeConnections[connectionKey];
-    if (!connection)
+// WebSocket readyState constants
+const WS_READY_STATE_OPEN = 1;
+function sendSubscribe(connection, subscription) {
+    if (!connection.ws || connection.ws.readyState !== WS_READY_STATE_OPEN) {
         return;
-    // Remove the specific subscription
-    connection.subscriptions = connection.subscriptions.filter(sub => sub !== subscription);
-    // If there are still subscriptions, resolve immediately
-    if (connection.subscriptions.length > 0) {
+    }
+    const message = {
+        type: 'subscribe',
+        subscriptionId: subscription.subscriptionId,
+        path: subscription.path,
+        prompt: subscription.prompt ? btoa(subscription.prompt) : undefined,
+        includeSubPaths: subscription.includeSubPaths,
+    };
+    try {
+        connection.ws.send(JSON.stringify(message));
+    }
+    catch (error) {
+        console.error('[WS v2] Error sending subscribe message:', error);
+    }
+}
+function sendUnsubscribe(connection, subscriptionId) {
+    if (!connection.ws || connection.ws.readyState !== WS_READY_STATE_OPEN) {
         return;
     }
-    // No subscriptions left, close the WebSocket and wait for closure
-    const ws = connection.ws;
-    await new Promise((resolve) => {
-        ws.addEventListener('close', () => {
-            resolve();
+    const message = {
+        type: 'unsubscribe',
+        subscriptionId,
+    };
+    try {
+        connection.ws.send(JSON.stringify(message));
+    }
+    catch (error) {
+        console.error('[WS v2] Error sending unsubscribe message:', error);
+    }
+}
+// ============ Public API ============
+/**
+ * Subscribe to data at a path using WebSocket v2.
+ * Returns an unsubscribe function.
+ */
+async function subscribeV2(path, subscriptionOptions) {
+    const config = await getConfig();
+    const normalizedPath = path.startsWith('/') ? path.slice(1) : path;
+    const cacheKey = getCacheKey(normalizedPath, subscriptionOptions.prompt);
+    // Deliver cached data immediately if available
+    const cachedEntry = responseCache.get(cacheKey);
+    if (cachedEntry && Date.now() - cachedEntry.timestamp < CACHE_TTL && subscriptionOptions.onData) {
+        setTimeout(() => {
+            var _a;
+            (_a = subscriptionOptions.onData) === null || _a === void 0 ? void 0 : _a.call(subscriptionOptions, cachedEntry.data);
+        }, 0);
+    }
+    // Get or create connection for this appId
+    const connection = await getOrCreateConnection(config.appId, config.isServer);
+    // Check if we already have a subscription for this path+prompt
+    let existingSubscription;
+    for (const sub of connection.subscriptions.values()) {
+        if (sub.path === normalizedPath && sub.prompt === subscriptionOptions.prompt) {
+            existingSubscription = sub;
+            break;
+        }
+    }
+    if (existingSubscription) {
+        // Add callback to existing subscription
+        existingSubscription.callbacks.push(subscriptionOptions);
+        // Deliver last known data immediately
+        if (existingSubscription.lastData !== undefined && subscriptionOptions.onData) {
+            setTimeout(() => {
+                var _a;
+                (_a = subscriptionOptions.onData) === null || _a === void 0 ? void 0 : _a.call(subscriptionOptions, existingSubscription.lastData);
+            }, 0);
+        }
+        return async () => {
+            await removeCallbackFromSubscription(connection, existingSubscription.subscriptionId, subscriptionOptions);
+        };
+    }
+    // Create new subscription
+    const subscriptionId = generateSubscriptionId();
+    const subscription = {
+        subscriptionId,
+        path: normalizedPath,
+        prompt: subscriptionOptions.prompt,
+        includeSubPaths: false,
+        callbacks: [subscriptionOptions],
+        lastData: undefined,
+    };
+    connection.subscriptions.set(subscriptionId, subscription);
+    // Send subscribe message if connected
+    if (connection.isConnected) {
+        // Create a promise to wait for subscription confirmation
+        const subscriptionPromise = new Promise((resolve, reject) => {
+            connection.pendingSubscriptions.set(subscriptionId, { resolve, reject });
+            // Timeout after 10 seconds
+            setTimeout(() => {
+                if (connection.pendingSubscriptions.has(subscriptionId)) {
+                    connection.pendingSubscriptions.delete(subscriptionId);
+                    reject(new Error('Subscription timeout'));
+                }
+            }, 10000);
         });
-        ws.addEventListener('error', (err) => {
-            console.error(`WebSocket closure error for connection: ${connectionKey}`, err);
-            resolve(); // Resolve even on error to avoid hanging
+        sendSubscribe(connection, subscription);
+        try {
+            await subscriptionPromise;
+        }
+        catch (error) {
+            // Remove subscription on error
+            connection.subscriptions.delete(subscriptionId);
+            throw error;
+        }
+    }
+    // Return unsubscribe function
+    return async () => {
+        await removeCallbackFromSubscription(connection, subscriptionId, subscriptionOptions);
+    };
+}
+async function removeCallbackFromSubscription(connection, subscriptionId, callback) {
+    const subscription = connection.subscriptions.get(subscriptionId);
+    if (!subscription) {
+        return;
+    }
+    // Remove this callback
+    subscription.callbacks = subscription.callbacks.filter(cb => cb !== callback);
+    // If there are still callbacks, don't unsubscribe
+    if (subscription.callbacks.length > 0) {
+        return;
+    }
+    // No more callbacks, unsubscribe from server
+    connection.subscriptions.delete(subscriptionId);
+    if (connection.isConnected) {
+        // Create a promise to wait for unsubscription confirmation
+        const unsubscribePromise = new Promise((resolve, reject) => {
+            connection.pendingUnsubscriptions.set(subscriptionId, { resolve, reject });
+            // Timeout after 5 seconds
+            setTimeout(() => {
+                if (connection.pendingUnsubscriptions.has(subscriptionId)) {
+                    connection.pendingUnsubscriptions.delete(subscriptionId);
+                    resolve(); // Don't throw on unsubscribe timeout
+                }
+            }, 5000);
         });
-        ws.close();
-    });
-    // Cleanup after closure is confirmed
-    delete activeConnections[connectionKey];
+        sendUnsubscribe(connection, subscriptionId);
+        await unsubscribePromise;
+    }
+    // If no more subscriptions, close connection
+    if (connection.subscriptions.size === 0 && connection.ws) {
+        // Clear token refresh timer
+        if (connection.tokenRefreshTimer) {
+            clearTimeout(connection.tokenRefreshTimer);
+            connection.tokenRefreshTimer = null;
+        }
+        connection.ws.close();
+        connection.ws = null;
+        connections.delete(connection.appId);
+    }
+}
+/**
+ * Close all v2 subscriptions.
+ */
+async function closeAllSubscriptionsV2() {
+    const closePromises = [];
+    for (const [appId, connection] of connections) {
+        // Clear token refresh timer
+        if (connection.tokenRefreshTimer) {
+            clearTimeout(connection.tokenRefreshTimer);
+            connection.tokenRefreshTimer = null;
+        }
+        if (connection.ws) {
+            closePromises.push(new Promise((resolve) => {
+                connection.ws.addEventListener('close', () => {
+                    resolve();
+                });
+                connection.ws.close();
+            }));
+        }
+        connections.delete(appId);
+    }
+    await Promise.all(closePromises);
+}
+/**
+ * Clear the v2 cache.
+ */
+function clearCacheV2(path) {
+    if (path) {
+        const normalizedPath = path.startsWith('/') ? path.slice(1) : path;
+        // Clear all cache entries that start with this path
+        for (const key of responseCache.keys()) {
+            if (key.startsWith(normalizedPath)) {
+                responseCache.delete(key);
+            }
+        }
+    }
+    else {
+        responseCache.clear();
+    }
+}
+/**
+ * Get cached data for a path (v2).
+ */
+function getCachedDataV2(path, prompt) {
+    const cacheKey = getCacheKey(path, prompt);
+    const cachedEntry = responseCache.get(cacheKey);
+    if (cachedEntry && Date.now() - cachedEntry.timestamp < CACHE_TTL) {
+        return cachedEntry.data;
+    }
+    return null;
+}
+/**
+ * Reconnect all v2 WebSocket connections with fresh authentication.
+ * Call this when the user's auth state changes (login/logout).
+ *
+ * This will:
+ * 1. Close existing connections
+ * 2. Re-establish with new auth token
+ * 3. Re-subscribe to all active paths
+ *
+ * Note: Existing subscriptions will receive new initial data after reconnection.
+ */
+async function reconnectWithNewAuthV2() {
+    // For each active connection
+    for (const [appId, connection] of connections) {
+        if (!connection.ws) {
+            continue;
+        }
+        // Reject any pending subscriptions - they'll need to be retried after reconnect
+        // This prevents hanging promises during auth transitions
+        for (const [, pending] of connection.pendingSubscriptions) {
+            pending.reject(new Error('Connection reconnecting due to auth change'));
+        }
+        connection.pendingSubscriptions.clear();
+        // Resolve any pending unsubscriptions - connection is closing anyway
+        for (const [, pending] of connection.pendingUnsubscriptions) {
+            pending.resolve();
+        }
+        connection.pendingUnsubscriptions.clear();
+        // Close the WebSocket (this triggers reconnection in ReconnectingWebSocket)
+        // We use reconnect() which will close and re-open with fresh URL (including new token)
+        try {
+            // ReconnectingWebSocket.reconnect() closes current connection and opens a new one
+            // The urlProvider will be called again, getting a fresh auth token
+            connection.ws.reconnect();
+        }
+        catch (error) {
+            console.error('[WS v2] Error reconnecting:', error);
+        }
+    }
+}
+
+/**
+ * WebSocket Subscription Module
+ *
+ * This module provides real-time data subscriptions using WebSocket v2 protocol
+ * with multiplexed connections (one connection per client, multiple subscriptions).
+ *
+ * The external API remains unchanged - just use subscribe(path, options) as before.
+ */
+/**
+ * Subscribe to real-time updates for a path.
+ *
+ * @param path - The path to subscribe to (e.g., 'users/123' or 'posts')
+ * @param subscriptionOptions - Options including onData and onError callbacks
+ * @returns A function to unsubscribe
+ *
+ * @example
+ * ```typescript
+ * const unsubscribe = await subscribe('users/123', {
+ *   onData: (data) => console.log('User updated:', data),
+ *   onError: (error) => console.error('Subscription error:', error),
+ * });
+ *
+ * // Later, to unsubscribe:
+ * await unsubscribe();
+ * ```
+ */
+async function subscribe(path, subscriptionOptions) {
+    return subscribeV2(path, subscriptionOptions);
+}
+/**
+ * Close all active subscriptions.
+ * Call this when cleaning up (e.g., on logout or component unmount).
+ */
+async function closeAllSubscriptions() {
+    return closeAllSubscriptionsV2();
+}
+/**
+ * Clear the subscription cache.
+ *
+ * @param path - Optional path to clear. If not provided, clears all cached data.
+ */
+function clearCache(path) {
+    clearCacheV2(path);
+}
+/**
+ * Get cached data for a path without making a network request.
+ *
+ * @param path - The path to get cached data for
+ * @param prompt - Optional prompt that was used for the subscription
+ * @returns The cached data, or null if not cached or expired
+ */
+function getCachedData(path, prompt) {
+    return getCachedDataV2(path, prompt);
+}
+/**
+ * Reconnect all WebSocket connections with fresh authentication.
+ * Call this when the user's auth state changes (login/logout).
+ *
+ * This will:
+ * 1. Close existing connections
+ * 2. Re-establish with new auth token
+ * 3. Re-subscribe to all active paths
+ *
+ * Existing subscriptions will receive new initial data after reconnection.
+ */
+async function reconnectWithNewAuth() {
+    return reconnectWithNewAuthV2();
 }
 
 exports.ServerSessionManager = ServerSessionManager;
 exports.WebSessionManager = WebSessionManager;
 exports.buildSetDocumentsTransaction = buildSetDocumentsTransaction;
+exports.clearCache = clearCache;
+exports.closeAllSubscriptions = closeAllSubscriptions;
 exports.convertRemainingAccounts = convertRemainingAccounts;
 exports.createSessionWithPrivy = createSessionWithPrivy;
 exports.createSessionWithSignature = createSessionWithSignature;
 exports.genAuthNonce = genAuthNonce;
 exports.genSolanaMessage = genSolanaMessage;
 exports.get = get;
+exports.getCachedData = getCachedData;
 exports.getConfig = getConfig;
 exports.getFiles = getFiles;
 exports.getIdToken = getIdToken;
 exports.init = init;
+exports.reconnectWithNewAuth = reconnectWithNewAuth;
 exports.refreshSession = refreshSession;
 exports.runExpression = runExpression;
 exports.runExpressionMany = runExpressionMany;