@pooflabs/web 0.0.90 → 0.0.92-rc1

package/dist/{index-CzVM_hix.esm.js → index-DOAgc25g.esm.js}

@@ -10362,9 +10362,40 @@ async function get(path, opts = {}) {
         }
         // Create a new request promise and store it
         const requestPromise = (async () => {
+            var _a;
             try {
-                // Cache miss or bypass - proceed with API request
+                // For realtime chains, prefer WebSocket reads (lower latency, already connected)
+                const config = await getConfig();
                 const pathIsDocument = normalizedPath.split("/").length % 2 === 0;
+                if (((_a = config.chain) === null || _a === void 0 ? void 0 : _a.startsWith('realtime_')) && !config.isServer && !opts.prompt && !opts.shape && !opts.cursor) {
+                    try {
+                        const { wsGet, wsQuery, hasActiveConnection } = await Promise.resolve().then(function () { return subscriptionV2; });
+                        if (hasActiveConnection()) {
+                            if (pathIsDocument) {
+                                const wsResult = await wsGet(normalizedPath);
+                                const responseData = wsResult;
+                                if (!opts.bypassCache) {
+                                    getCache[cacheKey] = { data: responseData, expiresAt: now + GET_CACHE_TTL };
+                                }
+                                return responseData;
+                            }
+                            else if (!opts.limit) {
+                                const wsResult = await wsQuery(normalizedPath, {
+                                    filter: undefined,
+                                    sort: undefined,
+                                    includeSubPaths: opts.includeSubPaths,
+                                });
+                                const responseData = wsResult;
+                                if (!opts.bypassCache) {
+                                    getCache[cacheKey] = { data: responseData, expiresAt: now + GET_CACHE_TTL };
+                                }
+                                return responseData;
+                            }
+                        }
+                    }
+                    catch ( /* fall through to HTTP */_b) { /* fall through to HTTP */ }
+                }
+                // Cache miss or bypass - proceed with HTTP API request
                 let response;
                 // Build common query params
                 const includeSubPathsParam = opts.includeSubPaths ? '&includeSubPaths=true' : '';
@@ -10373,7 +10404,6 @@ async function get(path, opts = {}) {
                 const cursorParam = opts.cursor ? `&cursor=${encodeURIComponent(opts.cursor)}` : '';
                 if (pathIsDocument) {
                     const itemId = encodeURIComponent(normalizedPath);
-                    // For documents, query params go after the path
                     const queryParams = [includeSubPathsParam, shapeParam].filter(p => p).join('');
                     const apiPath = queryParams ? `items/${itemId}?${queryParams.substring(1)}` : `items/${itemId}`;
                     response = await makeApiRequest('GET', apiPath, null, opts._overrides);
@@ -10568,7 +10598,7 @@ async function set(path, document, options) {
     return result;
 }
 async function setMany(many, options) {
-    var _a, _b, _c, _d, _e, _f, _g;
+    var _a, _b, _c, _d, _e, _f, _g, _h;
     // Returns the data that was set, or undefined if the document was already set.
     try {
         const config = await getConfig();
@@ -10605,13 +10635,28 @@ async function setMany(many, options) {
         }
         let setResponse;
         try {
-            setResponse = await makeApiRequest('PUT', `items`, { documents }, options === null || options === void 0 ? void 0 : options._overrides);
+            // For realtime chains, prefer WebSocket if a connection is active (lower latency)
+            const useWs = ((_c = config.chain) === null || _c === void 0 ? void 0 : _c.startsWith('realtime_')) && !config.isServer;
+            if (useWs) {
+                try {
+                    const { wsSet, hasActiveConnection } = await Promise.resolve().then(function () { return subscriptionV2; });
+                    if (hasActiveConnection()) {
+                        const wsResult = await wsSet(documents);
+                        // Normalize to same shape as HTTP 200 response so downstream handling is identical
+                        setResponse = { data: wsResult, status: 200 };
+                    }
+                }
+                catch ( /* fall through to HTTP */_j) { /* fall through to HTTP */ }
+            }
+            if (!setResponse) {
+                setResponse = await makeApiRequest('PUT', `items`, { documents }, options === null || options === void 0 ? void 0 : options._overrides);
+            }
         }
         catch (error) {
             if ((error === null || error === void 0 ? void 0 : error.statusCode) === 402 && (error === null || error === void 0 ? void 0 : error.error) === 'INSUFFICIENT_BALANCE') {
-                const deficitLamports = Number((_c = error.deficitLamports) !== null && _c !== void 0 ? _c : 0);
-                const deficitSol = Number((_d = error.deficitSol) !== null && _d !== void 0 ? _d : deficitLamports / 1000000000);
-                throw new InsufficientBalanceError(String((_e = error.address) !== null && _e !== void 0 ? _e : ''), Number((_f = error.balanceLamports) !== null && _f !== void 0 ? _f : 0), Number((_g = error.estimatedCostLamports) !== null && _g !== void 0 ? _g : 0), deficitLamports, deficitSol);
+                const deficitLamports = Number((_d = error.deficitLamports) !== null && _d !== void 0 ? _d : 0);
+                const deficitSol = Number((_e = error.deficitSol) !== null && _e !== void 0 ? _e : deficitLamports / 1000000000);
+                throw new InsufficientBalanceError(String((_f = error.address) !== null && _f !== void 0 ? _f : ''), Number((_g = error.balanceLamports) !== null && _g !== void 0 ? _g : 0), Number((_h = error.estimatedCostLamports) !== null && _h !== void 0 ? _h : 0), deficitLamports, deficitSol);
             }
             throw error;
         }
@@ -10655,7 +10700,7 @@ async function setMany(many, options) {
             else if (setResponse.data &&
                 typeof setResponse.data === 'object' &&
                 setResponse.data.success === true) {
-                const _h = setResponse.data, { success: _success } = _h, rest = __rest(_h, ["success"]);
+                const _k = setResponse.data, { success: _success } = _k, rest = __rest(_k, ["success"]);
                 return Object.assign(Object.assign(Object.assign({}, documents.map(d => d.document)), rest), { transactionId: null });
             }
             else {
@@ -11702,6 +11747,21 @@ async function wsGetMany(paths) {
     }));
 }
 
+var subscriptionV2 = /*#__PURE__*/Object.freeze({
+	__proto__: null,
+	clearCacheV2: clearCacheV2,
+	closeAllSubscriptionsV2: closeAllSubscriptionsV2,
+	getCachedDataV2: getCachedDataV2,
+	hasActiveConnection: hasActiveConnection,
+	reconnectWithNewAuthV2: reconnectWithNewAuthV2,
+	subscribeV2: subscribeV2,
+	wsDelete: wsDelete,
+	wsGet: wsGet,
+	wsGetMany: wsGetMany,
+	wsQuery: wsQuery,
+	wsSet: wsSet
+});
+
 /**
  * WebSocket Subscription Module
  *
@@ -11955,6 +12015,786 @@ class ReactNativeSessionManager {
 }
 ReactNativeSessionManager.TAROBASE_SESSION_STORAGE_KEY = "tarobase_session_storage";
 
+// ---------------------------------------------------------------------------
+// realtime-store.ts — Client-side state manager for realtime apps.
+//
+// Manages: WS connection, in-memory state, IDB persistence, optimistic
+// writes, delta accumulation, loading states, ephemeral/durable tiers.
+// ---------------------------------------------------------------------------
+// ---------------------------------------------------------------------------
+// IDB helpers (lazy-loaded, non-blocking)
+// ---------------------------------------------------------------------------
+const IDB_NAME = 'tarobase-realtime';
+const IDB_STORE = 'subscriptions';
+const IDB_VERSION = 1;
+let idbPromise = null;
+function getIDB() {
+    if (idbPromise)
+        return idbPromise;
+    if (typeof indexedDB === 'undefined') {
+        return Promise.reject(new Error('IndexedDB not available'));
+    }
+    idbPromise = new Promise((resolve, reject) => {
+        const req = indexedDB.open(IDB_NAME, IDB_VERSION);
+        req.onupgradeneeded = () => {
+            const db = req.result;
+            if (!db.objectStoreNames.contains(IDB_STORE)) {
+                db.createObjectStore(IDB_STORE);
+            }
+        };
+        req.onsuccess = () => resolve(req.result);
+        req.onerror = () => reject(req.error);
+    });
+    return idbPromise;
+}
+async function idbGet(key) {
+    try {
+        const db = await getIDB();
+        return new Promise((resolve) => {
+            const tx = db.transaction(IDB_STORE, 'readonly');
+            const store = tx.objectStore(IDB_STORE);
+            const req = store.get(key);
+            req.onsuccess = () => { var _a; return resolve((_a = req.result) !== null && _a !== void 0 ? _a : null); };
+            req.onerror = () => resolve(null);
+        });
+    }
+    catch (_a) {
+        return null;
+    }
+}
+async function idbSet(key, value) {
+    try {
+        const db = await getIDB();
+        return new Promise((resolve) => {
+            const tx = db.transaction(IDB_STORE, 'readwrite');
+            const store = tx.objectStore(IDB_STORE);
+            store.put(value, key);
+            tx.oncomplete = () => resolve();
+            tx.onerror = () => resolve();
+        });
+    }
+    catch (_a) {
+        // Best-effort persistence
+    }
+}
+// ---------------------------------------------------------------------------
+// RealtimeStore
+// ---------------------------------------------------------------------------
+let nextRequestId = 1;
+class RealtimeStore {
+    constructor() {
+        this.ws = null;
+        this.wsUrl = '';
+        this.appId = '';
+        this.subscriptions = new Map();
+        this.pendingRequests = new Map();
+        this.connectPromise = null;
+        this.reconnectTimer = null;
+        this.reconnectDelay = 1000;
+        this.maxReconnectDelay = 30000;
+        this.idbFlushTimer = null;
+        this.idbDirtyKeys = new Set();
+        this.closed = false;
+        this.authToken = null;
+    }
+    // -----------------------------------------------------------------------
+    // Initialization
+    // -----------------------------------------------------------------------
+    async init() {
+        var _a, _b;
+        const config = await getConfig();
+        this.appId = config.appId;
+        this.wsUrl = config.wsApiUrl;
+        if (config.authProvider) {
+            try {
+                const headers = await ((_b = (_a = config.authProvider).getAuthHeaders) === null || _b === void 0 ? void 0 : _b.call(_a));
+                if (headers === null || headers === void 0 ? void 0 : headers.Authorization) {
+                    this.authToken = headers.Authorization.replace('Bearer ', '');
+                }
+            }
+            catch ( /* no auth */_c) { /* no auth */ }
+        }
+    }
+    // -----------------------------------------------------------------------
+    // WebSocket connection
+    // -----------------------------------------------------------------------
+    async ensureConnected() {
+        var _a;
+        if (((_a = this.ws) === null || _a === void 0 ? void 0 : _a.readyState) === WebSocket.OPEN)
+            return;
+        if (this.connectPromise)
+            return this.connectPromise;
+        this.connectPromise = this.connect();
+        return this.connectPromise;
+    }
+    connect() {
+        return new Promise((resolve, reject) => {
+            if (this.closed) {
+                reject(new Error('Store closed'));
+                return;
+            }
+            const params = new URLSearchParams();
+            params.set('apiKey', this.appId);
+            // Auth token sent via subprotocol to avoid leaking in URL/logs
+            const url = `${this.wsUrl}?${params.toString()}`;
+            const protocols = this.authToken ? [`bearer-${this.authToken}`] : undefined;
+            const ws = protocols ? new WebSocket(url, protocols) : new WebSocket(url);
+            this.ws = ws;
+            const onOpen = () => {
+                ws.removeEventListener('error', onError);
+                this.reconnectDelay = 1000;
+                this.connectPromise = null;
+                this.resubscribeAll();
+                resolve();
+            };
+            const onError = (e) => {
+                ws.removeEventListener('open', onOpen);
+                this.connectPromise = null;
+                reject(new Error('WebSocket connection failed'));
+            };
+            ws.addEventListener('open', onOpen, { once: true });
+            ws.addEventListener('error', onError, { once: true });
+            ws.addEventListener('message', (event) => {
+                this.handleMessage(event.data);
+            });
+            ws.addEventListener('close', () => {
+                this.ws = null;
+                this.connectPromise = null;
+                this.rejectAllPending('WebSocket closed');
+                this.setAllSubscriptionStatus('reconnecting');
+                this.scheduleReconnect();
+            });
+        });
+    }
+    scheduleReconnect() {
+        if (this.closed)
+            return;
+        if (this.reconnectTimer)
+            clearTimeout(this.reconnectTimer);
+        this.reconnectTimer = setTimeout(() => {
+            this.ensureConnected().catch(() => {
+                this.reconnectDelay = Math.min(this.reconnectDelay * 2, this.maxReconnectDelay);
+                this.scheduleReconnect();
+            });
+        }, this.reconnectDelay);
+    }
+    resubscribeAll() {
+        for (const sub of this.subscriptions.values()) {
+            this.sendSubscribe(sub);
+        }
+    }
+    // -----------------------------------------------------------------------
+    // Message handling
+    // -----------------------------------------------------------------------
+    handleMessage(raw) {
+        const text = typeof raw === 'string' ? raw : new TextDecoder().decode(raw);
+        let msg;
+        try {
+            msg = JSON.parse(text);
+        }
+        catch (_a) {
+            return;
+        }
+        switch (msg.type) {
+            case 'snapshot':
+                this.handleSnapshot(msg);
+                break;
+            case 'delta':
+                this.handleDelta(msg);
+                break;
+            case 'result':
+                this.handleResult(msg);
+                break;
+            case 'error':
+                this.handleError(msg);
+                break;
+            case 'pong':
+                break;
+            // v1 compat: handle legacy message types during transition
+            case 'subscribed':
+                this.handleSnapshot(Object.assign(Object.assign({}, msg), { type: 'snapshot', docs: msg.data }));
+                break;
+            case 'data':
+                // Legacy full-snapshot delta — treat as snapshot replacement
+                this.handleLegacyData(msg);
+                break;
+            case 'response':
+                this.handleResult(Object.assign(Object.assign({}, msg), { type: 'result', ok: msg.status === 200, doc: msg.data }));
+                break;
+        }
+    }
+    handleSnapshot(msg) {
+        var _a, _b, _c;
+        const subId = (_a = msg.id) !== null && _a !== void 0 ? _a : msg.subscriptionId;
+        if (!subId)
+            return;
+        const sub = this.findSubscriptionById(subId);
+        if (!sub)
+            return;
+        const docs = (_c = (_b = msg.docs) !== null && _b !== void 0 ? _b : msg.data) !== null && _c !== void 0 ? _c : [];
+        const docsArray = Array.isArray(docs) ? docs : [docs];
+        sub.docs.clear();
+        for (const doc of docsArray) {
+            if (doc && doc._id) {
+                sub.docs.set(doc._id, doc);
+            }
+        }
+        sub.ref.current = sub.docs;
+        sub.status = 'live';
+        sub.isStale = false;
+        sub.error = null;
+        this.notifySubscription(sub);
+        this.markIdbDirty(sub.path);
+    }
+    handleDelta(msg) {
+        var _a, _b;
+        const subId = (_a = msg.id) !== null && _a !== void 0 ? _a : msg.subscriptionId;
+        if (!subId)
+            return;
+        const sub = this.findSubscriptionById(subId);
+        if (!sub)
+            return;
+        if (sub.tier === 'ephemeral') {
+            // Ephemeral: just overwrite, no accumulation logic
+            if (msg.change === 'removed' && msg.docId) {
+                sub.docs.delete(msg.docId);
+            }
+            else if (msg.doc && msg.doc._id) {
+                sub.docs.set(msg.doc._id, msg.doc);
+            }
+            sub.ref.current = sub.docs;
+            if (sub.options.mode !== 'ref') {
+                this.notifySubscription(sub);
+            }
+            return;
+        }
+        // Durable/checkpointed: full delta handling
+        switch (msg.change) {
+            case 'added':
+            case 'modified':
+                if (msg.doc && msg.doc._id) {
+                    sub.docs.set(msg.doc._id, msg.doc);
+                }
+                break;
+            case 'removed':
+                if (msg.docId) {
+                    sub.docs.delete(msg.docId);
+                }
+                else if ((_b = msg.doc) === null || _b === void 0 ? void 0 : _b._id) {
+                    sub.docs.delete(msg.doc._id);
+                }
+                break;
+        }
+        sub.ref.current = sub.docs;
+        this.notifySubscription(sub);
+        this.markIdbDirty(sub.path);
+    }
+    handleLegacyData(msg) {
+        // Legacy v1 format: 'data' message with full snapshot or single doc
+        const subId = msg.subscriptionId;
+        if (!subId)
+            return;
+        const sub = this.findSubscriptionById(subId);
+        if (!sub)
+            return;
+        if (Array.isArray(msg.data)) {
+            // Full snapshot replacement
+            sub.docs.clear();
+            for (const doc of msg.data) {
+                if (doc && doc._id)
+                    sub.docs.set(doc._id, doc);
+            }
+        }
+        else if (msg.data && msg.data._id) {
+            // Single doc update
+            sub.docs.set(msg.data._id, msg.data);
+        }
+        else if (msg.data === null) ;
+        sub.ref.current = sub.docs;
+        sub.status = 'live';
+        sub.isStale = false;
+        this.notifySubscription(sub);
+        this.markIdbDirty(sub.path);
+    }
+    handleResult(msg) {
+        var _a, _b, _c, _d;
+        const requestId = msg.requestId;
+        if (!requestId)
+            return;
+        const pending = this.pendingRequests.get(requestId);
+        if (!pending)
+            return;
+        this.pendingRequests.delete(requestId);
+        clearTimeout(pending.timeout);
+        const ok = (_a = msg.ok) !== null && _a !== void 0 ? _a : (msg.status === 200);
+        if (ok) {
+            pending.resolve((_c = (_b = msg.doc) !== null && _b !== void 0 ? _b : msg.data) !== null && _c !== void 0 ? _c : true);
+        }
+        else {
+            pending.reject(new Error((_d = msg.error) !== null && _d !== void 0 ? _d : 'Operation failed'));
+        }
+    }
+    handleError(msg) {
+        var _a;
+        const requestId = msg.requestId;
+        if (requestId) {
+            const pending = this.pendingRequests.get(requestId);
+            if (pending) {
+                this.pendingRequests.delete(requestId);
+                clearTimeout(pending.timeout);
+                pending.reject(new Error((_a = msg.message) !== null && _a !== void 0 ? _a : 'Server error'));
+            }
+        }
+    }
+    // -----------------------------------------------------------------------
+    // Subscribe
+    // -----------------------------------------------------------------------
+    async subscribe(path, opts = {}) {
+        var _a;
+        const tier = (_a = opts.tier) !== null && _a !== void 0 ? _a : 'durable';
+        const subKey = this.getSubKey(path, opts);
+        let sub = this.subscriptions.get(subKey);
+        if (sub) {
+            // Existing subscription — add callback
+            if (opts.onData)
+                sub.callbacks.add(opts.onData);
+            if (opts.onState)
+                sub.stateCallbacks.add(opts.onState);
+            // Immediately deliver current state
+            if (opts.onData && sub.docs.size > 0) {
+                opts.onData(this.docsToArray(sub));
+            }
+            if (opts.onState) {
+                opts.onState(this.getState(sub));
+            }
+            return this.createUnsubscribe(subKey, opts.onData, opts.onState);
+        }
+        // New subscription
+        const subId = `sub_${nextRequestId++}`;
+        sub = {
+            id: subId,
+            path,
+            tier,
+            options: opts,
+            docs: new Map(),
+            status: 'idle',
+            isStale: false,
+            error: null,
+            callbacks: new Set(opts.onData ? [opts.onData] : []),
+            stateCallbacks: new Set(opts.onState ? [opts.onState] : []),
+            ref: { current: new Map() },
+        };
+        this.subscriptions.set(subKey, sub);
+        // Step 1: Load from IDB (durable/checkpointed only)
+        if (tier !== 'ephemeral') {
+            const cached = await idbGet(this.idbKey(path));
+            if (cached && Array.isArray(cached)) {
+                for (const doc of cached) {
+                    if (doc && doc._id)
+                        sub.docs.set(doc._id, doc);
+                }
+                sub.ref.current = sub.docs;
+                sub.status = 'cached';
+                sub.isStale = true;
+                this.notifySubscription(sub);
+            }
+        }
+        // Step 2: Connect and subscribe via WS
+        sub.status = sub.docs.size > 0 ? 'cached' : 'loading';
+        this.notifyState(sub);
+        try {
+            await this.ensureConnected();
+            this.sendSubscribe(sub);
+        }
+        catch (_b) {
+            sub.status = 'error';
+            sub.error = new Error('Connection failed');
+            this.notifyState(sub);
+        }
+        return this.createUnsubscribe(subKey, opts.onData, opts.onState);
+    }
+    getRef(path, opts = {}) {
+        var _a;
+        const subKey = this.getSubKey(path, opts);
+        const sub = this.subscriptions.get(subKey);
+        if (sub)
+            return sub.ref;
+        // Auto-subscribe in ref mode
+        const ref = { current: new Map() };
+        this.subscribe(path, Object.assign(Object.assign({}, opts), { mode: 'ref', tier: 'ephemeral' })).catch(() => { });
+        const newSub = this.subscriptions.get(this.getSubKey(path, Object.assign(Object.assign({}, opts), { tier: 'ephemeral' })));
+        return (_a = newSub === null || newSub === void 0 ? void 0 : newSub.ref) !== null && _a !== void 0 ? _a : ref;
+    }
+    // -----------------------------------------------------------------------
+    // CRUD operations
+    // -----------------------------------------------------------------------
+    async set(path, doc) {
+        var _a;
+        await this.ensureConnected();
+        // Resolve operations (Increment, Time.Now) client-side for optimistic update
+        const resolvedDoc = this.resolveOperations(doc, path);
+        // Optimistic update: apply to local state immediately
+        const normalizedPath = path.startsWith('/') ? path.slice(1) : path;
+        const collectionPath = this.getCollectionPath(normalizedPath);
+        const optimisticDoc = Object.assign(Object.assign({ _id: normalizedPath, pathId: normalizedPath }, resolvedDoc), { tarobase_updated_at: Date.now() });
+        const sub = this.findSubscriptionByPath(collectionPath);
+        let prevDoc = null;
+        if (sub) {
+            prevDoc = (_a = sub.docs.get(normalizedPath)) !== null && _a !== void 0 ? _a : null;
+            sub.docs.set(normalizedPath, optimisticDoc);
+            sub.ref.current = sub.docs;
+            this.notifySubscription(sub);
+        }
+        // Send to server
+        const requestId = `r_${nextRequestId++}`;
+        try {
+            const result = await this.sendRequest(requestId, {
+                type: 'set',
+                requestId,
+                documents: [{ destinationPath: normalizedPath, document: doc }],
+            });
+            // Replace optimistic doc with server-confirmed version
+            if (sub && result && typeof result === 'object') {
+                const serverDoc = Array.isArray(result) ? result[0] : result;
+                if (serverDoc && serverDoc._id) {
+                    sub.docs.set(serverDoc._id, serverDoc);
+                    sub.ref.current = sub.docs;
+                    this.notifySubscription(sub);
+                    this.markIdbDirty(collectionPath);
+                }
+            }
+            return Array.isArray(result) ? result[0] : result;
+        }
+        catch (err) {
+            // Revert optimistic update
+            if (sub) {
+                if (prevDoc) {
+                    sub.docs.set(normalizedPath, prevDoc);
+                }
+                else {
+                    sub.docs.delete(normalizedPath);
+                }
+                sub.ref.current = sub.docs;
+                this.notifySubscription(sub);
+            }
+            throw err;
+        }
+    }
+    async get(path) {
+        const normalizedPath = path.startsWith('/') ? path.slice(1) : path;
+        // Check local subscriptions first
+        const collectionPath = this.getCollectionPath(normalizedPath);
+        const sub = this.findSubscriptionByPath(collectionPath);
+        if (sub && sub.status === 'live') {
+            const doc = sub.docs.get(normalizedPath);
+            return doc !== null && doc !== void 0 ? doc : null;
+        }
+        // One-shot WS fetch
+        await this.ensureConnected();
+        const requestId = `r_${nextRequestId++}`;
+        return this.sendRequest(requestId, {
+            type: 'get',
+            requestId,
+            path: normalizedPath,
+        });
+    }
+    async getMany(paths) {
+        await this.ensureConnected();
+        const normalizedPaths = paths.map(p => p.startsWith('/') ? p.slice(1) : p);
+        const requestId = `r_${nextRequestId++}`;
+        return this.sendRequest(requestId, {
+            type: 'getMany',
+            requestId,
+            paths: normalizedPaths,
+        });
+    }
+    async delete(path) {
+        var _a;
+        await this.ensureConnected();
+        const normalizedPath = path.startsWith('/') ? path.slice(1) : path;
+        // Optimistic: remove from local state
+        const collectionPath = this.getCollectionPath(normalizedPath);
+        const sub = this.findSubscriptionByPath(collectionPath);
+        let prevDoc = null;
+        if (sub) {
+            prevDoc = (_a = sub.docs.get(normalizedPath)) !== null && _a !== void 0 ? _a : null;
+            sub.docs.delete(normalizedPath);
+            sub.ref.current = sub.docs;
+            this.notifySubscription(sub);
+        }
+        const requestId = `r_${nextRequestId++}`;
+        try {
+            await this.sendRequest(requestId, {
+                type: 'delete',
+                requestId,
+                path: normalizedPath,
+            });
+            if (sub)
+                this.markIdbDirty(collectionPath);
+        }
+        catch (err) {
+            // Revert
+            if (sub && prevDoc) {
+                sub.docs.set(normalizedPath, prevDoc);
+                sub.ref.current = sub.docs;
+                this.notifySubscription(sub);
+            }
+            throw err;
+        }
+    }
+    async query(path, opts) {
+        await this.ensureConnected();
+        const normalizedPath = path.startsWith('/') ? path.slice(1) : path;
+        const requestId = `r_${nextRequestId++}`;
+        return this.sendRequest(requestId, Object.assign(Object.assign(Object.assign(Object.assign({ type: 'query', requestId, path: normalizedPath }, ((opts === null || opts === void 0 ? void 0 : opts.filter) ? { filter: opts.filter } : {})), ((opts === null || opts === void 0 ? void 0 : opts.sort) ? { sort: opts.sort } : {})), ((opts === null || opts === void 0 ? void 0 : opts.limit) !== undefined ? { limit: opts.limit } : {})), ((opts === null || opts === void 0 ? void 0 : opts.includeSubPaths) ? { includeSubPaths: true } : {})));
+    }
+    async count(path) {
+        var _a;
+        await this.ensureConnected();
+        const normalizedPath = path.startsWith('/') ? path.slice(1) : path;
+        const requestId = `r_${nextRequestId++}`;
+        const result = await this.sendRequest(requestId, {
+            type: 'count',
+            requestId,
+            path: normalizedPath,
+        });
+        return typeof result === 'number' ? result : ((_a = result === null || result === void 0 ? void 0 : result.value) !== null && _a !== void 0 ? _a : 0);
+    }
+    async aggregate(path, operation, opts) {
+        await this.ensureConnected();
+        const normalizedPath = path.startsWith('/') ? path.slice(1) : path;
+        const requestId = `r_${nextRequestId++}`;
+        return this.sendRequest(requestId, Object.assign({ type: 'aggregate', requestId, path: normalizedPath, operation }, ((opts === null || opts === void 0 ? void 0 : opts.field) ? { field: opts.field } : {})));
+    }
+    // -----------------------------------------------------------------------
+    // Helpers
+    // -----------------------------------------------------------------------
+    sendSubscribe(sub) {
+        if (!this.ws || this.ws.readyState !== WebSocket.OPEN)
+            return;
+        const msg = {
+            type: 'subscribe',
+            subscriptionId: sub.id,
+            path: sub.path,
+        };
+        if (sub.options.filter)
+            msg.filter = sub.options.filter;
+        if (sub.options.includeSubPaths)
+            msg.includeSubPaths = true;
+        if (sub.options.limit)
+            msg.limit = sub.options.limit;
+        if (sub.options.prompt)
+            msg.prompt = sub.options.prompt;
+        this.ws.send(JSON.stringify(msg));
+    }
+    sendRequest(requestId, msg) {
+        return new Promise((resolve, reject) => {
+            const timeout = setTimeout(() => {
+                this.pendingRequests.delete(requestId);
+                reject(new Error('Request timed out'));
+            }, 30000);
+            this.pendingRequests.set(requestId, { resolve, reject, timeout });
+            if (this.ws && this.ws.readyState === WebSocket.OPEN) {
+                this.ws.send(JSON.stringify(msg));
+            }
+            else {
+                this.pendingRequests.delete(requestId);
+                clearTimeout(timeout);
+                reject(new Error('WebSocket not connected'));
+            }
+        });
+    }
+    notifySubscription(sub) {
+        const data = this.docsToArray(sub);
+        const callbacks = Array.from(sub.callbacks);
+        for (const cb of callbacks) {
+            try {
+                cb(data);
+            }
+            catch ( /* swallow callback errors */_a) { /* swallow callback errors */ }
+        }
+        this.notifyState(sub);
+    }
+    notifyState(sub) {
+        const state = this.getState(sub);
+        const callbacks = Array.from(sub.stateCallbacks);
+        for (const cb of callbacks) {
+            try {
+                cb(state);
+            }
+            catch ( /* swallow */_a) { /* swallow */ }
+        }
+    }
+    getState(sub) {
+        return {
+            data: this.docsToArray(sub),
+            status: sub.status,
+            isStale: sub.isStale,
+            error: sub.error,
+        };
+    }
+    docsToArray(sub) {
+        return Array.from(sub.docs.values());
+    }
+    findSubscriptionById(id) {
+        for (const sub of this.subscriptions.values()) {
+            if (sub.id === id)
+                return sub;
+        }
+        return undefined;
+    }
+    findSubscriptionByPath(collectionPath) {
+        for (const sub of this.subscriptions.values()) {
+            const subPath = sub.path.startsWith('/') ? sub.path.slice(1) : sub.path;
+            if (subPath === collectionPath)
+                return sub;
+            if (collectionPath.startsWith(subPath + '/'))
+                return sub;
+        }
+        return undefined;
+    }
+    getCollectionPath(docPath) {
+        const segments = docPath.split('/');
+        if (segments.length % 2 === 0) {
+            return segments.slice(0, -1).join('/');
+        }
+        return docPath;
+    }
+    getSubKey(path, opts) {
+        const parts = [path];
+        if (opts.filter)
+            parts.push(JSON.stringify(opts.filter));
+        if (opts.prompt)
+            parts.push(opts.prompt);
+        if (opts.tier)
+            parts.push(opts.tier);
+        return parts.join('::');
+    }
+    idbKey(path) {
+        return `${this.appId}:${path}`;
+    }
+    markIdbDirty(path) {
+        const sub = this.findSubscriptionByPath(path);
+        if (sub && sub.tier === 'ephemeral')
+            return;
+        this.idbDirtyKeys.add(path);
+        if (!this.idbFlushTimer) {
+            this.idbFlushTimer = setTimeout(() => {
+                this.flushIdb();
+                this.idbFlushTimer = null;
+            }, 500);
+        }
+    }
+    async flushIdb() {
+        const keys = Array.from(this.idbDirtyKeys);
+        this.idbDirtyKeys.clear();
+        for (const path of keys) {
+            const sub = this.findSubscriptionByPath(path);
+            if (sub && sub.tier !== 'ephemeral') {
+                const docs = this.docsToArray(sub);
+                await idbSet(this.idbKey(path), docs);
+            }
+        }
+    }
+    createUnsubscribe(subKey, onData, onState) {
+        return async () => {
+            const sub = this.subscriptions.get(subKey);
+            if (!sub)
+                return;
+            if (onData)
+                sub.callbacks.delete(onData);
+            if (onState)
+                sub.stateCallbacks.delete(onState);
+            // If no more callbacks, unsubscribe entirely
+            if (sub.callbacks.size === 0 && sub.stateCallbacks.size === 0) {
+                this.subscriptions.delete(subKey);
+                if (this.ws && this.ws.readyState === WebSocket.OPEN) {
+                    this.ws.send(JSON.stringify({
+                        type: 'unsubscribe',
+                        subscriptionId: sub.id,
+                    }));
+                }
+            }
+        };
+    }
+    resolveOperations(doc, path) {
+        var _a;
+        if (!doc || typeof doc !== 'object')
+            return doc;
+        const resolved = {};
+        for (const [key, value] of Object.entries(doc)) {
+            if (value && typeof value === 'object' && !Array.isArray(value) && value.operation) {
+                const op = value;
+                if (op.operation === 'time' && op.value === 'now') {
+                    resolved[key] = Math.floor(Date.now() / 1000);
+                }
+                else if (op.operation === 'increment') {
+                    // For optimistic: get current value and add
+                    const normalizedPath = path.startsWith('/') ? path.slice(1) : path;
+                    const collectionPath = this.getCollectionPath(normalizedPath);
+                    const sub = this.findSubscriptionByPath(collectionPath);
+                    const existing = sub === null || sub === void 0 ? void 0 : sub.docs.get(normalizedPath);
+                    const current = (_a = existing === null || existing === void 0 ? void 0 : existing[key]) !== null && _a !== void 0 ? _a : 0;
+                    resolved[key] = (typeof current === 'number' ? current : 0) + op.value;
+                }
+                else {
+                    resolved[key] = value;
+                }
+            }
+            else {
+                resolved[key] = value;
+            }
+        }
+        return resolved;
+    }
+    rejectAllPending(reason) {
+        for (const [requestId, pending] of this.pendingRequests) {
+            clearTimeout(pending.timeout);
+            pending.reject(new Error(reason));
+        }
+        this.pendingRequests.clear();
+    }
+    setAllSubscriptionStatus(status) {
+        for (const sub of this.subscriptions.values()) {
+            sub.status = status;
+            this.notifyState(sub);
+        }
+    }
+    // -----------------------------------------------------------------------
+    // Lifecycle
+    // -----------------------------------------------------------------------
+    close() {
+        this.closed = true;
+        if (this.reconnectTimer)
+            clearTimeout(this.reconnectTimer);
+        if (this.idbFlushTimer)
+            clearTimeout(this.idbFlushTimer);
+        this.flushIdb();
+        if (this.ws) {
+            this.ws.close(1000, 'Store closed');
+            this.ws = null;
+        }
+        this.rejectAllPending('Store closed');
+        this.subscriptions.clear();
+    }
+}
+// ---------------------------------------------------------------------------
+// Singleton instance
+// ---------------------------------------------------------------------------
+let storeInstance = null;
+function getRealtimeStore() {
+    if (!storeInstance) {
+        storeInstance = new RealtimeStore();
+    }
+    return storeInstance;
+}
+function resetRealtimeStore() {
+    if (storeInstance) {
+        storeInstance.close();
+        storeInstance = null;
+    }
+}
+
 /**
  * Platform abstraction layer for React Native compatibility.
  *
@@ -12260,6 +13100,15 @@ class OffchainAuthProvider {
         }
         return null;
     }
+    // Forward per-call login overrides (theme/title/subtitle and the `method`
+    // directive) to the wrapped provider. Without this, the top-level login()
+    // forwarder (which duck-types `setLoginOverrides` on the active provider)
+    // skips the wrapper and the override — including `method` — is dropped on
+    // offchain/Poofnet builds.
+    setLoginOverrides(opts) {
+        var _a, _b;
+        (_b = (_a = this.wrappedProvider).setLoginOverrides) === null || _b === void 0 ? void 0 : _b.call(_a, opts);
+    }
     async logout() {
         await this.wrappedProvider.logout();
     }
@@ -12951,6 +13800,26 @@ class OffchainAuthProvider {
 let currentAuthProvider = null;
 let currentAuthMethod = null;
 let initConfig = null;
+// The effective Phantom provider (offchain-wrapped when chain:"offchain"), captured
+// when a Phantom-primary app initializes. Used to restore Phantom after a staged
+// Privy email swap is cancelled/fails, and to route method-specific login() calls
+// back to Phantom. Null for non-Phantom apps.
+let savedPhantomProvider = null;
+/**
+ * Restore the saved Phantom provider as the active auth provider. Used to undo a
+ * staged Privy email swap on cancel/failure and to re-anchor method-specific
+ * login() calls on Phantom. No-op when there is no saved Phantom provider.
+ */
+async function restoreSavedPhantomProvider() {
+    if (!savedPhantomProvider)
+        return;
+    currentAuthProvider = savedPhantomProvider;
+    currentAuthMethod = 'phantom';
+    const coreConfig = await getConfig();
+    coreConfig.authProvider = savedPhantomProvider;
+    coreConfig.authMethod = 'phantom';
+    setAuthProviderInstance(savedPhantomProvider);
+}
 // --- localStorage helpers: track which auth method the user last logged in with ---
 const STORED_AUTH_METHOD_KEY$1 = 'tarobase_last_auth_method';
 function getStoredAuthMethod() {
@@ -13023,20 +13892,59 @@ async function hotSwapToPrivyProvider(config) {
                 solana: {
                     createOnLogin: 'users-without-wallets'
                 }
-            }, appearance: Object.assign(Object.assign({}, (_f = (_e = config.privyConfig) === null || _e === void 0 ? void 0 : _e.config) === null || _f === void 0 ? void 0 : _f.appearance), { walletChainType: 'solana-only', showWalletLoginFirst: false, theme: 'dark', walletList: [] }) })
+            }, appearance: Object.assign(Object.assign({}, (_f = (_e = config.privyConfig) === null || _e === void 0 ? void 0 : _e.config) === null || _f === void 0 ? void 0 : _f.appearance), { walletChainType: 'solana-only', showWalletLoginFirst: false, theme: 'dark', walletList: [] }), 
+            // Explicitly empty external wallets — social-only mode. Setting the
+            // key (with an empty connectors array) keeps useWallets().ready able to
+            // resolve while suppressing the wallet picker, AND prevents the
+            // PrivyWalletProvider constructor from re-injecting the full Solana
+            // connector set when externalWallets is absent (see privy-wallet-provider.ts).
+            externalWallets: { solana: { connectors: [] } } })
     };
     const privyProvider = new PrivyWalletProvider((_g = config.name) !== null && _g !== void 0 ? _g : null, (_h = config.logoUrl) !== null && _h !== void 0 ? _h : null, fallbackPrivyConfig, rpcUrl);
     let provider = privyProvider;
     if (config.chain === "offchain") {
         provider = new OffchainAuthProvider(privyProvider);
     }
-    currentAuthProvider = provider;
-    currentAuthMethod = 'privy';
-    const coreConfig = await getConfig();
-    coreConfig.authProvider = provider;
-    coreConfig.authMethod = 'privy';
-    setAuthProviderInstance(provider);
-    return privyProvider;
+    // STAGED swap: do NOT mutate the module-level auth globals here. The caller (the
+    // Phantom modal's email button / the `method:'email'` bridge) calls `.login()` on
+    // the returned provider separately. If the user cancels, committing up-front would
+    // strand the globals on Privy and break reload/signing. Instead, return a provider
+    // whose `login()` commits the globals to Privy ONLY on success and restores the
+    // saved Phantom provider on cancel/failure.
+    const commitPrivy = async () => {
+        currentAuthProvider = provider;
+        currentAuthMethod = 'privy';
+        const coreConfig = await getConfig();
+        coreConfig.authProvider = provider;
+        coreConfig.authMethod = 'privy';
+        setAuthProviderInstance(provider);
+    };
+    // Proxy intercepts only `login`; every other access delegates to `provider`. The
+    // proxy is used solely for this one `.login()` call — on success the globals are
+    // committed to the inner `provider` (not the proxy), so subsequent calls bypass it.
+    return new Proxy(provider, {
+        get(target, prop, receiver) {
+            if (prop === 'login') {
+                return async (...args) => {
+                    try {
+                        const user = await target.login(...args);
+                        if (user) {
+                            await commitPrivy();
+                        }
+                        else {
+                            await restoreSavedPhantomProvider();
+                        }
+                        return user;
+                    }
+                    catch (err) {
+                        await restoreSavedPhantomProvider();
+                        throw err;
+                    }
+                };
+            }
+            return Reflect.get(target, prop, receiver);
+        },
+    });
 }
 async function hotSwapToMWAProvider(config) {
     var _a, _b;
@@ -13067,7 +13975,7 @@ const SOLANA_DEVNET_RPC_URL = "https://idelle-8nxsep-fast-devnet.helius-rpc.com"
 const SOLANA_MAINNET_RPC_URL = "https://celestia-cegncv-fast-mainnet.helius-rpc.com";
 const SURFNET_RPC_URL$2 = "https://surfpool.fly.dev";
 async function getAuthProvider(config) {
-    var _a, _b, _c, _d;
+    var _a, _b, _c;
     if (currentAuthProvider) {
         return currentAuthProvider;
     }
@@ -13111,11 +14019,13 @@ async function getAuthProvider(config) {
             // MWA hot-swap is always available (custom modal shows MWA button on Android)
             currentAuthProvider.onSwitchToMWA =
                 () => hotSwapToMWAProvider(config);
-            // Privy hot-swap only when enablePrivyFallback is on
-            if ((_d = config.phantomConfig) === null || _d === void 0 ? void 0 : _d.enablePrivyFallback) {
-                currentAuthProvider.onSwitchToPrivy =
-                    () => hotSwapToPrivyProvider(config);
-            }
+            // Privy email bridge: ALWAYS wired, independent of enablePrivyFallback, so
+            // `login({ method: 'email' })` works even on a custom Phantom app (which
+            // sets enablePrivyFallback:false). enablePrivyFallback now only controls
+            // whether the DEFAULT modal renders its own email button (see
+            // phantom-wallet-provider.ts) — not whether the bridge exists.
+            currentAuthProvider.onSwitchToPrivy =
+                () => hotSwapToPrivyProvider(config);
             break;
         }
         case "privy-expo":
@@ -13146,6 +14056,13 @@ async function getAuthProvider(config) {
         console.log("[Offchain] Wrapping auth provider for Poofnet transaction tracking");
         currentAuthProvider = new OffchainAuthProvider(currentAuthProvider);
     }
+    // Save the EFFECTIVE Phantom provider (post offchain-wrap) so the staged Privy
+    // email swap can restore it on cancel/failure and method-specific login() calls
+    // can re-anchor on Phantom. Captured after the wrap so restore doesn't bypass the
+    // OffchainAuthProvider on Poofnet/preview.
+    if (authMethod === 'phantom') {
+        savedPhantomProvider = currentAuthProvider;
+    }
     return currentAuthProvider;
 }
 async function login$1(options) {
@@ -13161,6 +14078,14 @@ async function login$1(options) {
     if (!currentAuthProvider) {
         throw new Error("Auth provider not initialized. Please call init() first.");
     }
+    // Method-specific login() always operates on the Phantom provider (which then
+    // bridges to Privy for 'email'). If a prior email swap committed Privy, re-anchor
+    // on the saved Phantom provider before delegating so the `method` directive lands
+    // on Phantom. (Cancelled swaps already restore Phantom via the staged proxy; this
+    // covers the post-success case.) No-op for non-Phantom apps (no saved provider).
+    if ((options === null || options === void 0 ? void 0 : options.method) && currentAuthMethod !== 'phantom' && savedPhantomProvider) {
+        await restoreSavedPhantomProvider();
+    }
     // Forward per-call overrides to providers that support them (duck-typed to stay
     // lazy-load safe — no direct import of PhantomWalletProvider here).
     // Always call (even with null) so previous overrides are cleared when this
@@ -13320,7 +14245,7 @@ function useAuth() {
     // Provide a fallback so server render doesn't break
     if (isSSR) {
         return {
-            login: async () => undefined,
+            login: async (_options) => undefined,
             logout: async () => undefined,
             loading: true,
             user: null,
@@ -13340,10 +14265,10 @@ function useAuth() {
         return () => {
         };
     }, []);
-    const login$1 = async () => {
+    const login$1 = async (options) => {
         try {
             setLoading(true);
-            const user = await login();
+            const user = await login(options);
             setUser(user);
         }
         catch (error) {
@@ -15880,7 +16805,7 @@ async function loadDependencies() {
         const [reactModule, reactDomModule, phantomModule] = await Promise.all([
             import('react'),
             import('react-dom/client'),
-            import('./index-DOYZMq5N.esm.js')
+            import('./index-B8EmyNEY.esm.js')
         ]);
         // Extract default export from ESM module namespace
         // Dynamic import() returns { default: Module, ...exports }, not the module directly
@@ -15900,7 +16825,15 @@ class PhantomWalletProvider {
         this.containerElement = null;
         this.root = null;
         this.phantomMethods = null;
+        // The FULL set registered with the Phantom SDK (so login({ method:'google'|'apple' })
+        // can connect directly even when those buttons are hidden from the default modal).
         this.resolvedProviders = ['injected'];
+        // What the DEFAULT chooser modal renders as buttons (social hidden when the Privy
+        // email fallback owns vanilla email). Subset of resolvedProviders.
+        this.modalProviders = ['injected'];
+        // True only while a `login({ method: 'wallet' })` modal is open — suppresses the
+        // social + email buttons so wallet mode shows wallets only.
+        this.modalWalletOnly = false;
         this.pendingLogin = null;
         this.loginInProgress = false;
         this.autoLoginInProgress = false;
@@ -15957,10 +16890,15 @@ class PhantomWalletProvider {
         else {
             this.resolvedProviders = ['injected'];
         }
-        // When Privy handles social logins, strip them from Phantom
-        if (this.config.enablePrivyFallback) {
-            this.resolvedProviders = this.resolvedProviders.filter(p => p !== 'google' && p !== 'apple');
-        }
+        // resolvedProviders stays the FULL set (registered with the Phantom SDK), so a
+        // direct login({ method: 'google'|'apple' }) can connect even when the default
+        // modal hides those buttons. modalProviders is what the DEFAULT chooser renders:
+        // when the Privy email fallback owns vanilla email we hide social from the
+        // default modal — but it remains registered above. (Apps with their own auth UI
+        // use login({ method }) and bypass the default modal entirely.)
+        this.modalProviders = this.config.enablePrivyFallback
+            ? this.resolvedProviders.filter(p => p !== 'google' && p !== 'apple')
+            : [...this.resolvedProviders];
     }
     /**
      * Patch the Phantom extension's provider to gracefully handle `phantom_getFeatures`
@@ -16062,6 +17000,52 @@ class PhantomWalletProvider {
                         connectError,
                         showCustomModal: () => setShowWalletModal(true),
                         hideCustomModal: () => setShowWalletModal(false),
+                        // Per-method login bridge: connect a specific provider directly
+                        // (no modal). The connection-success effect resolves the pending
+                        // login. Used for login({ method: 'google' | 'apple' }).
+                        connectWithProvider: async (provider) => {
+                            walletClickedRef.current = true;
+                            setShowWalletModal(false);
+                            try {
+                                await connect({ provider });
+                            }
+                            catch (err) {
+                                // connectError effect handles failure
+                            }
+                        },
+                        // Per-method login bridge: jump straight to the Privy email
+                        // screen (mirrors the modal's email button) and resolve/reject
+                        // the pending login directly. Used for login({ method: 'email' }).
+                        switchToEmail: async () => {
+                            that.loginInProgress = false;
+                            walletClickedRef.current = true;
+                            setShowWalletModal(false);
+                            if (!that.onSwitchToPrivy) {
+                                if (that.pendingLogin) {
+                                    that.pendingLogin.reject(new Error('Email login is not available'));
+                                    that.pendingLogin = null;
+                                }
+                                return;
+                            }
+                            try {
+                                const privyProvider = await that.onSwitchToPrivy();
+                                const user = await privyProvider.login();
+                                if (that.pendingLogin && user) {
+                                    that.pendingLogin.resolve(user);
+                                    that.pendingLogin = null;
+                                }
+                                else if (that.pendingLogin) {
+                                    that.pendingLogin.reject(new Error('User cancelled login'));
+                                    that.pendingLogin = null;
+                                }
+                            }
+                            catch (error) {
+                                if (that.pendingLogin) {
+                                    that.pendingLogin.reject(error);
+                                    that.pendingLogin = null;
+                                }
+                            }
+                        },
                         solana: solana && solanaHook.isAvailable ? {
                             // Wrap methods to preserve 'this' context - direct references lose binding
                             signMessage: (message) => solana.signMessage(message),
@@ -16420,8 +17404,9 @@ class PhantomWalletProvider {
                 boxSizing: 'border-box',
             });
             const walletButtons = [];
-            // Google OAuth button — shown when 'google' is in resolved providers
-            if (sdkProviders.includes('google')) {
+            // Google OAuth button — default chooser only (hidden in wallet-only mode),
+            // gated on modalProviders (registered-but-hidden under the email fallback).
+            if (!that.modalWalletOnly && that.modalProviders.includes('google')) {
                 walletButtons.push(React$1.createElement('button', {
                     key: 'google-oauth',
                     style: buttonStyle('google-oauth'),
@@ -16445,8 +17430,9 @@ class PhantomWalletProvider {
                     fill: '#EA4335',
                 })), 'Continue with Google'));
             }
-            // Apple OAuth button — shown when 'apple' is in resolved providers
-            if (sdkProviders.includes('apple')) {
+            // Apple OAuth button — default chooser only (hidden in wallet-only mode),
+            // gated on modalProviders (registered-but-hidden under the email fallback).
+            if (!that.modalWalletOnly && that.modalProviders.includes('apple')) {
                 walletButtons.push(React$1.createElement('button', {
                     key: 'apple-oauth',
                     style: buttonStyle('apple-oauth'),
@@ -16527,8 +17513,10 @@ class PhantomWalletProvider {
                     stroke: textColor, strokeWidth: '2', strokeLinecap: 'round', strokeLinejoin: 'round', fill: 'none',
                 })), 'Connect Mobile Wallet'));
             }
-            // Email button — only when Privy fallback is enabled
-            if (that.config.enablePrivyFallback) {
+            // Email button — default chooser only (hidden in wallet-only mode), and
+            // only when the Privy email fallback owns the default modal's email button.
+            // (login({ method:'email' }) bridges to Privy directly, independent of this.)
+            if (!that.modalWalletOnly && that.config.enablePrivyFallback) {
                 walletButtons.push(React$1.createElement('button', {
                     key: 'email-login',
                     style: emailButtonStyle('email-login'),
@@ -16824,10 +17812,29 @@ class PhantomWalletProvider {
             });
         }
         const loginPromise = new Promise((resolve, reject) => {
+            var _a;
             this.pendingLogin = { resolve, reject };
             this.loginInProgress = true;
-            // Always use our custom wallet modal
-            this.phantomMethods.showCustomModal();
+            // Drive the requested flow. pendingLogin + loginInProgress are already set
+            // above, so the connection-success effect (google/apple/wallet) and the
+            // email bridge resolve THIS promise. A method-specific call goes straight to
+            // the matching connect/bridge; no method → the full chooser modal.
+            const method = (_a = this.loginOverrides) === null || _a === void 0 ? void 0 : _a.method;
+            if (method === 'google' || method === 'apple') {
+                void this.phantomMethods.connectWithProvider(method);
+            }
+            else if (method === 'email') {
+                void this.phantomMethods.switchToEmail();
+            }
+            else if (method === 'wallet') {
+                // Wallet-only modal: wallets shown, social + email hidden.
+                this.modalWalletOnly = true;
+                this.phantomMethods.showCustomModal();
+            }
+            else {
+                this.modalWalletOnly = false;
+                this.phantomMethods.showCustomModal();
+            }
             // Safety timeout
             setTimeout(() => {
                 if (this.pendingLogin) {
@@ -16839,6 +17846,7 @@ class PhantomWalletProvider {
         });
         return loginPromise.finally(() => {
             this.loginOverrides = null;
+            this.modalWalletOnly = false;
         });
     }
     async restoreSession() {
@@ -22020,7 +23028,7 @@ async function registerMobileWalletAdapter(config) {
     if (typeof window === 'undefined')
         return;
     try {
-        const walletStandardMobile = await import('./index.browser-D1uNEi4e.esm.js');
+        const walletStandardMobile = await import('./index.browser-BAtXWf8k.esm.js');
         const registerMwa = walletStandardMobile.registerMwa || ((_a = walletStandardMobile.default) === null || _a === void 0 ? void 0 : _a.registerMwa);
         if (!registerMwa) {
             console.warn('[SolanaMobileWallet] registerMwa not found in @solana-mobile/wallet-standard-mobile');
@@ -22159,7 +23167,7 @@ class SolanaMobileWalletProvider {
     async ensureWallet() {
         if (this.wallet)
             return this.wallet;
-        const mod = await import('./index.browser-D1uNEi4e.esm.js');
+        const mod = await import('./index.browser-BAtXWf8k.esm.js');
         const chain = mapChainToWalletStandard(this.cluster);
         this.wallet = new mod.LocalSolanaMobileWalletAdapterWallet({
             appIdentity: this.appIdentity,
@@ -23351,5 +24359,5 @@ class PrivyExpoProvider {
     }
 }
 
-export { getCachedData as $, subscribe as A, useAuth as B, deserializeTransaction as C, getIdToken as D, setPlatform as E, getPlatform as F, PrivyWalletProvider as G, DEFAULT_TEST_ADDRESS as H, isMobileWalletAvailable as I, registerMobileWalletAdapter as J, PrivyExpoProvider as K, InsufficientBalanceError as L, MockAuthProvider as M, ServerSessionManager as N, OffchainAuthProvider as O, PhantomWalletProvider as P, buildSetDocumentsTransaction as Q, ReactNativeSessionManager as R, SolanaMobileWalletProvider as S, clearCache as T, closeAllSubscriptions as U, convertRemainingAccounts as V, WebSessionManager as W, createSessionWithPrivy as X, createSessionWithSignature as Y, genAuthNonce as Z, genSolanaMessage as _, base58 as a, getMany as a0, hasActiveConnection as a1, reconnectWithNewAuth as a2, refreshSession as a3, signSessionCreateMessage as a4, wsDelete as a5, wsGet as a6, wsGetMany as a7, wsQuery as a8, wsSet as a9, bufferExports as b, getCurrentUser as c, onAuthLoadingChanged as d, getAuthLoading as e, logout as f, getDefaultExportFromCjs$1 as g, getConfig as h, init as i, getAuthProvider as j, get as k, login as l, setMany as m, setFile as n, onAuthStateChanged as o, getFiles as p, runQueryMany as q, runQuery as r, set as s, runExpression as t, runExpressionMany as u, signMessage as v, signTransaction as w, signAndSubmitTransaction as x, count as y, aggregate as z };
-//# sourceMappingURL=index-CzVM_hix.esm.js.map
+export { genSolanaMessage as $, subscribe as A, useAuth as B, deserializeTransaction as C, getIdToken as D, setPlatform as E, getPlatform as F, PrivyWalletProvider as G, DEFAULT_TEST_ADDRESS as H, isMobileWalletAvailable as I, registerMobileWalletAdapter as J, PrivyExpoProvider as K, InsufficientBalanceError as L, MockAuthProvider as M, RealtimeStore as N, OffchainAuthProvider as O, PhantomWalletProvider as P, ServerSessionManager as Q, ReactNativeSessionManager as R, SolanaMobileWalletProvider as S, buildSetDocumentsTransaction as T, clearCache as U, closeAllSubscriptions as V, WebSessionManager as W, convertRemainingAccounts as X, createSessionWithPrivy as Y, createSessionWithSignature as Z, genAuthNonce as _, base58 as a, getCachedData as a0, getMany as a1, getRealtimeStore as a2, hasActiveConnection as a3, reconnectWithNewAuth as a4, refreshSession as a5, resetRealtimeStore as a6, signSessionCreateMessage as a7, wsDelete as a8, wsGet as a9, wsGetMany as aa, wsQuery as ab, wsSet as ac, bufferExports as b, getCurrentUser as c, onAuthLoadingChanged as d, getAuthLoading as e, logout as f, getDefaultExportFromCjs$1 as g, getConfig as h, init as i, getAuthProvider as j, get as k, login as l, setMany as m, setFile as n, onAuthStateChanged as o, getFiles as p, runQueryMany as q, runQuery as r, set as s, runExpression as t, runExpressionMany as u, signMessage as v, signTransaction as w, signAndSubmitTransaction as x, count as y, aggregate as z };
+//# sourceMappingURL=index-DOAgc25g.esm.js.map