@bounded-sh/core 0.0.52 → 0.0.53-next.0

package/dist/{index-DpfaeNTQ.mjs → index-DHigIn6m.mjs}

@@ -3019,8 +3019,13 @@ class WebSessionManager {
             const { exp } = JSON.parse(this.decodeBase64Url(idToken.split(".")[1]));
             if (Date.now() > exp * 1000) {
                 const { refreshToken } = sessionObj;
-                if (!refreshToken)
+                // Expired token with no way to refresh — clear the stale session
+                // (mirrors the refresh-failed branch below) so isAuthenticated()
+                // does not stay true and every request does not 401 + retry forever.
+                if (!refreshToken) {
+                    this.clearSession();
                     return null;
+                }
                 const refreshed = await refreshSession(refreshToken, sessionObj.issuer);
                 if ((refreshed === null || refreshed === void 0 ? void 0 : refreshed.idToken) && (refreshed === null || refreshed === void 0 ? void 0 : refreshed.accessToken)) {
                     await this.updateIdTokenAndAccessToken(refreshed.idToken, refreshed.accessToken, 
@@ -3231,8 +3236,13 @@ class ReactNativeSessionManager {
             const { exp } = JSON.parse(this.decodeBase64Url(idToken.split(".")[1]));
             if (Date.now() > exp * 1000) {
                 const { refreshToken } = sessionObj;
-                if (!refreshToken)
+                // Expired token with no way to refresh — clear the stale session
+                // (mirrors the refresh-failed branch below) so isAuthenticated()
+                // does not stay true and every request does not 401 + retry forever.
+                if (!refreshToken) {
+                    this.clearSession();
                     return null;
+                }
                 const refreshed = await refreshSession(refreshToken, sessionObj.issuer);
                 if ((refreshed === null || refreshed === void 0 ? void 0 : refreshed.idToken) && (refreshed === null || refreshed === void 0 ? void 0 : refreshed.accessToken)) {
                     await this.updateIdTokenAndAccessToken(refreshed.idToken, refreshed.accessToken, refreshed.refreshToken);
@@ -3408,7 +3418,7 @@ class ServerSessionManager {
         const address = kp.publicKey.toBase58();
         /* fetch nonce from auth API */
         const nonce = await genAuthNonce();
-        const { genSolanaMessage } = await import('./solana-message-kTeT43eQ.mjs');
+        const { genSolanaMessage } = await import('./solana-message-DoiFXEx_.mjs');
         const message = await genSolanaMessage(address, nonce);
         /* sign the message */
         const sigBytes = nacl.sign.detached(new TextEncoder().encode(message), kp.secretKey);
@@ -5555,11 +5565,11 @@ async function setMany(many, options) {
                 transactionResult = await handleEvmTransaction(curTx.evmTransaction, authProvider, options);
             }
             else if (curTx.serializedTransaction) {
-                const { handlePreBuiltTransaction } = await import('./solana-operations-B8UyHL26.mjs');
+                const { handlePreBuiltTransaction } = await import('./solana-operations-SSv6xHs-.mjs');
                 transactionResult = await handlePreBuiltTransaction(curTx, authProvider, options, expectedWritePaths);
             }
             else {
-                const { handleSolanaTransaction } = await import('./solana-operations-B8UyHL26.mjs');
+                const { handleSolanaTransaction } = await import('./solana-operations-SSv6xHs-.mjs');
                 transactionResult = await handleSolanaTransaction(curTx, authProvider, options, expectedWritePaths);
             }
             // Sync items after all transactions are confirmed
@@ -5668,6 +5678,18 @@ function clearCacheByPrefix(prefix) {
         }
     });
 }
+/**
+ * Listeners notified after an identity change wipes the read caches. Registered
+ * via `onReadCacheAuthChange` so downstream modules (e.g. the subscribeQuery poll
+ * manager) can re-key/drop stale in-flight work WITHOUT operations.ts importing
+ * them (avoids a static cycle; keeps the coalesce test bundle lean).
+ */
+const authChangeListeners = new Set();
+/** Register a callback invoked after `clearReadCacheForAuthChange`. Returns an unregister fn. */
+function onReadCacheAuthChange(listener) {
+    authChangeListeners.add(listener);
+    return () => { authChangeListeners.delete(listener); };
+}
 /**
  * SECURITY (H1): Wipe ALL HTTP read caches + in-flight reads. Call this whenever
  * the logged-in identity changes (login / logout / switch identity) so a freshly
@@ -5677,6 +5699,12 @@ function clearCacheByPrefix(prefix) {
 function clearReadCacheForAuthChange() {
     Object.keys(getCache).forEach(key => delete getCache[key]);
     Object.keys(pendingRequests).forEach(key => delete pendingRequests[key]);
+    authChangeListeners.forEach(fn => {
+        try {
+            fn();
+        }
+        catch ( /* a listener throwing must not abort the cache wipe */_a) { /* a listener throwing must not abort the cache wipe */ }
+    });
 }
 async function getFiles(path, options) {
     try {
@@ -5684,7 +5712,7 @@ async function getFiles(path, options) {
         if (!normalizedPath || normalizedPath.length === 0) {
             throw new Error("Invalid path provided.");
         }
-        const apiPath = `storage?path=${normalizedPath}`;
+        const apiPath = `storage?path=${encodeURIComponent(normalizedPath)}`;
         const response = await makeApiRequest('GET', apiPath, null, options === null || options === void 0 ? void 0 : options._overrides);
         return response.data;
     }
@@ -5778,6 +5806,7 @@ var operations = /*#__PURE__*/Object.freeze({
     get: get,
     getFiles: getFiles,
     getMany: getMany,
+    onReadCacheAuthChange: onReadCacheAuthChange,
     queryAggregate: queryAggregate,
     runExpression: runExpression,
     runExpressionMany: runExpressionMany,
@@ -7474,7 +7503,7 @@ async function doReconnectWithNewAuth() {
         console.warn('[WS v2] Failed to clear HTTP read cache on auth change:', error);
     }
     try {
-        const { reconnectRealtimeStoreWithNewAuth } = await import('./realtime-store-CBdRkQfZ.mjs');
+        const { reconnectRealtimeStoreWithNewAuth } = await import('./realtime-store-DkvVNYdn.mjs');
         await reconnectRealtimeStoreWithNewAuth();
     }
     catch (error) {
@@ -7709,6 +7738,564 @@ async function reconnectWithNewAuth() {
     return reconnectWithNewAuthV2();
 }
 
+/**
+ * Live named-query subscriptions (subscribeQuery) - HTTP client poller (v1).
+ *
+ * A standardized client-side poller for a policy's computed/named queries. Same
+ * callback contract as `subscribe()` (onData/onError), but instead of a socket it
+ * polls `runQuery` on an interval. It exists to replace ad-hoc app-side polling
+ * with one controlled, deduped, backoff-aware poller.
+ *
+ * v1 is HTTP-only and requires ZERO server change: it rides the existing
+ * `runQuery` microtask coalescer (operations.ts), which batches due keys into
+ * <=10-per-POST chunks, surfaces per-row errors, and (via utils/api) does a
+ * bounded in-request 429 retry. The websocket transport and true server-push are
+ * deferred; see LIVE-QUERIES-SDK-PLAN.md section 9. The public contract here is
+ * pinned so either upgrade stays transparent.
+ *
+ * Design notes that are load-bearing (do not "simplify" away):
+ *  - The coalescer does NOT dedupe; the manager's refcount dedupe below is the
+ *    ONLY dedupe, so it is load-bearing for billed-read correctness.
+ *  - There is no durable transport backoff: `utils/api` retries twice then
+ *    rejects. Steady-state backoff on a rejected poll is owned HERE.
+ *  - A transport rejection (429/network/chunk) must NOT reach onError - it would
+ *    blast the whole up-to-10-key chunk every interval and rebuild the exact 429
+ *    noise this feature removes. Only a genuine per-row query error / policy
+ *    decline reaches onError.
+ */
+/** Default poll cadence. Sits on the hot named-query cadence oapps already runs. */
+const DEFAULT_QUERY_POLL_INTERVAL_MS = 5000;
+/** Hard lower clamp so an app cannot rebuild the 429 storm. */
+const MIN_QUERY_POLL_INTERVAL_MS = 1000;
+/** Ceiling for the manager-owned exponential backoff on a rejected poll. */
+const QUERY_POLL_BACKOFF_CAP_MS = 60000;
+/** Max extra delay sprinkled on a visibility-resume refresh so N keys don't burst-sync. */
+const RESUME_JITTER_MS = 250;
+/** Retry cadence for a re-key that could not (re-)attach - so a live query is never
+ * silently orphaned by a transient auth failure during an identity change. */
+const REATTACH_RETRY_MS = 3000;
+/**
+ * Server sentinel for a query that cannot be polled (e.g. onchain/EVM live-call).
+ * Absorbed internally: keep polling, never surface. Pin it to the design-of-record
+ * `unsupported` frame.
+ */
+const UNSUPPORTED_QUERY_SENTINEL = 'unsupported';
+const registry = new Map();
+/**
+ * Every live subscriber, INCLUDING ones momentarily detached from the registry
+ * mid-re-key (see reattach). Teardown walks this - not just the registry - so a
+ * pending re-key retry can never revive polling after closeAllQuerySubscriptions.
+ */
+const liveSubscribers = new Set();
+/** Poll ticks pause while the document is hidden (env-guarded / test-injectable). */
+let hidden = false;
+// ---------------------------------------------------------------------------
+// Canonicalization (shared with a future server group key).
+// ---------------------------------------------------------------------------
+function sortDeep(value) {
+    if (Array.isArray(value))
+        return value.map(sortDeep);
+    if (value && typeof value === 'object') {
+        const out = {};
+        for (const k of Object.keys(value).sort())
+            out[k] = sortDeep(value[k]);
+        return out;
+    }
+    return value;
+}
+/** Deterministic key-sorted serialization of query args. */
+function canonicalizeArgs(args) {
+    return JSON.stringify(sortDeep(args !== null && args !== void 0 ? args : null));
+}
+/**
+ * Deterministic key-sorted serialization of a query RESULT for change detection.
+ * Robust to shuffled object key order and the JSON-wire shapes the endpoint
+ * yields (string u64, ISO-date string). BigInt/Date OBJECTS never cross the HTTP
+ * boundary, so they are intentionally not handled here.
+ */
+function canonicalizeResult(result) {
+    return JSON.stringify(sortDeep(result === undefined ? null : result));
+}
+// ---------------------------------------------------------------------------
+// Identity (two-part: compact bucket + exact bearer, mirroring subscribe()'s H1).
+// ---------------------------------------------------------------------------
+function hashToken(value) {
+    let h = 5381;
+    for (let i = 0; i < value.length; i++)
+        h = ((h << 5) + h + value.charCodeAt(i)) & 0x7fffffff;
+    return h.toString(36);
+}
+async function currentIdentity(appId) {
+    const token = await getIdToken(clientConfig.isServer);
+    return token ? { bucket: `${appId}:t${hashToken(token)}`, token } : { bucket: `${appId}:anon`, token: null };
+}
+function makeKey(appId, path, queryName, args, identity) {
+    var _a;
+    return [appId, path, queryName, canonicalizeArgs(args), identity.bucket, (_a = identity.token) !== null && _a !== void 0 ? _a : ''].join('\u0000');
+}
+// ---------------------------------------------------------------------------
+// Error classification.
+// ---------------------------------------------------------------------------
+/** A genuine query-level error (surfaced to onError), as opposed to transport. */
+function isQueryLevelError(error) {
+    return (error === null || error === void 0 ? void 0 : error.isQueryError) === true || (error === null || error === void 0 ? void 0 : error.isBoundedDecline) === true || (error === null || error === void 0 ? void 0 : error.decline) != null;
+}
+/**
+ * A RECOGNIZED transient transport failure that a retry might clear (HTTP status like
+ * 429/5xx, a network/abort error). These back off SILENTLY - surfacing them per-poll
+ * would rebuild the 429 noise. Anything else (a bad path, a malformed response - things
+ * a retry won't fix) is NOT transient, so it gets surfaced once to onError instead of a
+ * silently-dead subscription.
+ */
+function isTransientTransportError(error) {
+    if (error == null)
+        return true; // unknown - be conservative and keep retrying
+    if (typeof error.status === 'number' || typeof error.statusCode === 'number')
+        return true;
+    const code = error.code;
+    if (code === 'ECONNABORTED' || code === 'ERR_NETWORK' || code === 'ETIMEDOUT' || code === 'ERR_CANCELED')
+        return true;
+    if (error.name === 'AbortError' || error.name === 'CanceledError')
+        return true;
+    if (error.request && !error.response)
+        return true; // request sent, no response - network
+    return false;
+}
+function enrichError(error, phase, willRetry) {
+    var _a;
+    const err = error instanceof Error ? error : new Error(String((_a = error === null || error === void 0 ? void 0 : error.message) !== null && _a !== void 0 ? _a : error));
+    try {
+        err.phase = phase;
+        err.willRetry = willRetry;
+    }
+    catch (_b) {
+        /* frozen error object - deliver as-is */
+    }
+    return err;
+}
+// ---------------------------------------------------------------------------
+// Interval / scheduling.
+// ---------------------------------------------------------------------------
+function clampInterval(value) {
+    const n = typeof value === 'number' && isFinite(value) ? value : DEFAULT_QUERY_POLL_INTERVAL_MS;
+    return Math.max(MIN_QUERY_POLL_INTERVAL_MS, n);
+}
+function recomputeInterval(entry) {
+    let min = Infinity;
+    for (const s of entry.subscribers)
+        if (s.intervalMs < min)
+            min = s.intervalMs;
+    const next = isFinite(min) ? min : DEFAULT_QUERY_POLL_INTERVAL_MS;
+    const changed = next !== entry.effectiveInterval;
+    entry.effectiveInterval = next;
+    // Realign a pending (not in-flight) timer to the new cadence so a newly-joined
+    // faster subscriber does not wait out a slower subscriber's interval (and a
+    // departed fast subscriber relaxes the survivors back to their own cadence).
+    // But NEVER while backing off - realigning to the (shorter) steady cadence would
+    // discard the backoff and re-hit a still-failing transport (the 429 storm).
+    if (changed && entry.timer && !entry.inFlight && entry.consecutiveFailures === 0) {
+        scheduleNext(entry, entry.effectiveInterval);
+    }
+}
+function clearTimer(entry) {
+    if (entry.timer) {
+        clearTimeout(entry.timer);
+        entry.timer = null;
+    }
+}
+function backoffDelay(entry) {
+    const base = Math.min(QUERY_POLL_BACKOFF_CAP_MS, entry.effectiveInterval * 2 ** entry.consecutiveFailures);
+    // Full jitter over the capped exponential, floored at the base interval so a
+    // backed-off key never polls FASTER than its steady cadence.
+    return entry.effectiveInterval + Math.floor(Math.random() * Math.max(0, base - entry.effectiveInterval));
+}
+function scheduleNext(entry, delayMs) {
+    clearTimer(entry);
+    if (entry.subscribers.size === 0)
+        return;
+    if (hidden)
+        return; // paused; resume reschedules
+    entry.timer = setTimeout(() => {
+        entry.timer = null;
+        void pollEntry(entry);
+    }, delayMs);
+}
+// ---------------------------------------------------------------------------
+// Polling.
+// ---------------------------------------------------------------------------
+function pollEntry(entry) {
+    if (entry.inFlight)
+        return Promise.resolve(); // single-flight
+    if (entry.subscribers.size === 0)
+        return Promise.resolve();
+    entry.inFlight = true;
+    const gen = entry.generation;
+    return runQuery(entry.path, entry.queryName, entry.args).then((value) => onPollResult(entry, gen, value, undefined), (error) => onPollResult(entry, gen, undefined, error));
+}
+// Staleness is caught by the per-entry generation (bumped on teardown/re-key) and
+// the registry identity check (the entry was removed/replaced) - so an old
+// principal's late result can never reach a re-keyed subscriber. No global epoch
+// is needed, which is why a plain reconnect (identity unchanged) is a no-op.
+function onPollResult(entry, gen, value, error) {
+    var _a;
+    entry.inFlight = false;
+    const stale = gen !== entry.generation || registry.get(entry.key) !== entry;
+    if (error !== undefined) {
+        if (isQueryLevelError(error)) {
+            // Query executed but this row errored (or was declined): transport is
+            // healthy, so keep the steady cadence and reset backoff.
+            entry.consecutiveFailures = 0;
+            if (!stale) {
+                if (!((error === null || error === void 0 ? void 0 : error.isQueryError) === true && (error === null || error === void 0 ? void 0 : error.message) === UNSUPPORTED_QUERY_SENTINEL)) {
+                    const phase = entry.hasValue ? 'refresh' : 'initial';
+                    // De-dupe: a permanently-broken query must not toast onError every
+                    // interval - fire only when the error (phase + message) changes.
+                    const sig = `${phase}${String((_a = (error && error.message)) !== null && _a !== void 0 ? _a : error)}`;
+                    if (entry.lastErrorSig !== sig) {
+                        entry.lastErrorSig = sig;
+                        const enriched = enrichError(error, phase, true);
+                        entry.lastError = enriched; // remembered so a late joiner learns it's broken (F6)
+                        for (const s of entry.subscribers)
+                            safeCall(s.onError, enriched);
+                    }
+                }
+                scheduleNext(entry, entry.effectiveInterval);
+            }
+            return;
+        }
+        // Transport-level rejection: back off. A RECOGNIZED transient (429/5xx/network/abort)
+        // stays SILENT (surfacing it per-poll would rebuild the 429 noise); an UNRECOGNIZED
+        // rejection (a bad path, a malformed response - things a retry won't fix) is surfaced
+        // ONCE so the subscription is never silently dead. Both keep backing off in case it
+        // was misclassified / recovers.
+        entry.consecutiveFailures += 1;
+        if (!stale) {
+            if (!isTransientTransportError(error)) {
+                fireEntryError(entry, error, entry.hasValue ? 'refresh' : 'initial', true);
+            }
+            scheduleNext(entry, backoffDelay(entry));
+        }
+        return;
+    }
+    entry.consecutiveFailures = 0;
+    if (!stale) {
+        entry.lastErrorSig = null; // a good result clears the error-dedup latch...
+        entry.lastError = undefined; // ...and the remembered error (joiners no longer replay it)
+        deliver(entry, value);
+        scheduleNext(entry, entry.effectiveInterval);
+    }
+}
+/**
+ * Fire onError to all current subscribers, de-duped (a persistently-broken query must not
+ * toast every interval) and REMEMBER the error so a late joiner with no value yet can learn
+ * the query is broken instead of spinning forever (F6).
+ */
+function fireEntryError(entry, error, phase, willRetry) {
+    var _a;
+    const sig = `${phase} ${String((_a = (error && error.message)) !== null && _a !== void 0 ? _a : error)}`;
+    if (entry.lastErrorSig === sig)
+        return;
+    entry.lastErrorSig = sig;
+    const enriched = enrichError(error, phase, willRetry);
+    entry.lastError = enriched;
+    for (const s of entry.subscribers)
+        safeCall(s.onError, enriched);
+}
+function deliver(entry, value) {
+    const canonical = canonicalizeResult(value);
+    if (entry.hasValue && entry.lastCanonical === canonical)
+        return; // no change
+    entry.hasValue = true;
+    entry.lastValue = value;
+    entry.lastCanonical = canonical;
+    for (const s of entry.subscribers)
+        safeCall(s.onData, value);
+}
+function safeCall(fn, arg) {
+    if (!fn)
+        return;
+    try {
+        fn(arg);
+    }
+    catch (_a) {
+        /* an app callback throwing must not break the fan-out loop */
+    }
+}
+// ---------------------------------------------------------------------------
+// Attach / detach.
+// ---------------------------------------------------------------------------
+function createEntry(key, sub, identity) {
+    return {
+        key,
+        appId: sub.appId,
+        path: sub.path,
+        queryName: sub.queryName,
+        args: sub.args,
+        identity,
+        subscribers: new Set(),
+        generation: 0,
+        lastErrorSig: null,
+        lastError: undefined,
+        effectiveInterval: sub.intervalMs,
+        timer: null,
+        inFlight: false,
+        consecutiveFailures: 0,
+        hasValue: false,
+        lastValue: undefined,
+        lastCanonical: '',
+        readyPromise: Promise.resolve(),
+    };
+}
+/** Register (or re-register, on identity change) a subscriber under its current identity. */
+async function attach(sub) {
+    const identity = await currentIdentity(sub.appId);
+    // The sub may have been unsubscribed / torn down WHILE we awaited identity. The
+    // registry+generation staleness guards can't catch this because the entry would be
+    // created fresh inside the race, so re-check here before touching the registry.
+    if (sub.detached)
+        return;
+    const key = makeKey(sub.appId, sub.path, sub.queryName, sub.args, identity);
+    let entry = registry.get(key);
+    let created = false;
+    if (!entry) {
+        entry = createEntry(key, sub, identity);
+        registry.set(key, entry);
+        created = true;
+    }
+    entry.subscribers.add(sub);
+    sub.entry = entry;
+    recomputeInterval(entry);
+    if (created) {
+        // Eager initial fetch: do NOT wait a tick. The returned promise resolves
+        // after the first fetch settles; an initial failure surfaces via onError
+        // (phase 'initial') and still resolves - never leaves the sub in limbo.
+        // While hidden, do NOT poll - stay registered so visibility-resume schedules
+        // it (covers fresh-subscribe, reconcile re-key, and reattach-retry uniformly).
+        if (hidden) {
+            entry.readyPromise = Promise.resolve();
+            return;
+        }
+        entry.readyPromise = pollEntry(entry);
+        await entry.readyPromise;
+        return;
+    }
+    if (entry.hasValue) {
+        // Joiner of an established key gets the last good value immediately.
+        safeCall(sub.onData, entry.lastValue);
+        return;
+    }
+    if (entry.lastError) {
+        // Joiner of a key that has NO value yet but is in a latched error state: replay the
+        // error so a late-mounting component learns the query is broken instead of spinning
+        // forever with neither data nor error (F6).
+        safeCall(sub.onError, entry.lastError);
+    }
+    // Joined during the first in-flight fetch: piggyback it (deliver fans out to us).
+    await entry.readyPromise;
+}
+function detach(sub) {
+    const entry = sub.entry;
+    if (!entry || !entry.subscribers.has(sub))
+        return; // idempotent
+    entry.subscribers.delete(sub);
+    sub.entry = null;
+    if (entry.subscribers.size === 0) {
+        entry.generation += 1; // drop any in-flight result
+        clearTimer(entry);
+        if (registry.get(entry.key) === entry)
+            registry.delete(entry.key);
+    }
+    else {
+        recomputeInterval(entry);
+    }
+}
+// ---------------------------------------------------------------------------
+// Public API.
+// ---------------------------------------------------------------------------
+/**
+ * Subscribe to the live value of a named (computed) query.
+ *
+ * @param path - The document path the query is declared on (e.g. 'market/mytoken').
+ * @param queryName - The named query to run (e.g. 'tokensForOneSol').
+ * @param args - Query arguments (canonicalized; drives the dedupe key).
+ * @param options - onData/onError callbacks and optional intervalMs; a bare
+ *   function is coerced to `{ onData }` (mirrors subscribe()).
+ * @returns An async unsubscribe function.
+ *
+ * @example
+ * ```typescript
+ * const unsubscribe = await subscribeQuery('market/mytoken', 'tokensForOneSol', {}, {
+ *   onData: (price) => setPrice(price),
+ *   onError: (err) => { if (err.phase === 'initial') showSpinnerError(); },
+ * });
+ * await unsubscribe();
+ * ```
+ */
+async function subscribeQuery(path, queryName, args, options) {
+    const opts = typeof options === 'function' ? { onData: options } : (options !== null && options !== void 0 ? options : {});
+    const sub = {
+        onData: opts.onData,
+        onError: opts.onError,
+        intervalMs: clampInterval(opts.intervalMs),
+        appId: clientConfig.appId, // v1 single-app: see QuerySubscriptionOptions
+        path,
+        queryName,
+        args,
+        entry: null,
+        detached: false,
+        reattachTimer: null,
+    };
+    liveSubscribers.add(sub);
+    try {
+        await attach(sub);
+    }
+    catch (error) {
+        // Initial identity resolution threw (auth flux) - do not leak the sub into
+        // liveSubscribers (it holds the app's callbacks). The caller gets the rejection
+        // and no unsubscribe handle, so retire it here. (reattach tolerates this on the
+        // re-key path; the initial path must too.)
+        stopSubscriber(sub);
+        throw error;
+    }
+    return async () => {
+        stopSubscriber(sub); // mark detached + cancel any pending re-key retry
+        detach(sub);
+    };
+}
+/** Permanently retire a subscriber: no future re-key retry can revive it. */
+function stopSubscriber(sub) {
+    sub.detached = true;
+    if (sub.reattachTimer) {
+        clearTimeout(sub.reattachTimer);
+        sub.reattachTimer = null;
+    }
+    liveSubscribers.delete(sub);
+}
+/**
+ * Wired to the SDK's auth-change chokepoint (operations.clearReadCacheForAuthChange,
+ * driven by reconnectWithNewAuth). That chokepoint fires on ANY reconnect - including
+ * a transient browser `online` nudge - not only on a real identity change, so this
+ * MUST be idempotent when the principal is unchanged: it re-resolves identity per
+ * key and re-keys ONLY the entries whose principal actually changed, preserving the
+ * timer and backoff of every unchanged entry (otherwise a flaky connection would
+ * rebuild the exact 429 re-poll storm this feature removes).
+ */
+function notifyQueryAuthChanged() {
+    void reconcileIdentity();
+}
+async function reconcileIdentity() {
+    var _a;
+    const resolvedByApp = new Map();
+    for (const entry of [...registry.values()]) {
+        // The entry may have been torn down while we awaited a prior identity.
+        if (registry.get(entry.key) !== entry || entry.subscribers.size === 0)
+            continue;
+        let current = (_a = resolvedByApp.get(entry.appId)) !== null && _a !== void 0 ? _a : null;
+        if (!current) {
+            try {
+                current = await currentIdentity(entry.appId);
+                resolvedByApp.set(entry.appId, current);
+            }
+            catch (_b) {
+                // Could not resolve the current identity (e.g. getIdToken threw during
+                // an auth-state flux). Treat identity as UNKNOWN and re-key
+                // conservatively below - reattach() retries until it resolves, so we
+                // neither leak the previous principal's data nor freeze the sub.
+                current = null;
+            }
+        }
+        if (registry.get(entry.key) !== entry)
+            continue; // re-check across the await
+        if (current && current.bucket === entry.identity.bucket && current.token === entry.identity.token) {
+            continue; // identity unchanged - keep the entry, its timer, and its backoff
+        }
+        // Identity changed (or is momentarily unresolvable): drop the entry (its in-flight
+        // result is caught by the generation + registry staleness checks) and re-key its
+        // subscribers under the new principal. reattach() owns the eager fetch AND a retry,
+        // so a transient failure here can never silently orphan a live subscription.
+        const subs = [...entry.subscribers].filter((s) => s.entry === entry);
+        entry.generation += 1;
+        clearTimer(entry);
+        // Only delete if THIS entry still owns the key - a replacement entry may have taken
+        // it over while we awaited identity (line 499 guards the same window; mirror the
+        // check at the delete site so it stays correct if code is inserted between them).
+        if (registry.get(entry.key) === entry)
+            registry.delete(entry.key);
+        for (const s of subs) {
+            s.entry = null;
+            reattach(s);
+        }
+    }
+}
+/**
+ * Re-register a re-keyed subscriber under its current identity, retrying on failure.
+ * A re-keyed subscriber has already been removed from the registry, so if attach()
+ * fails there is no other path that would ever bring it back - reattach() IS that
+ * path. It stops only when the subscriber re-attaches or the caller unsubscribes.
+ */
+function reattach(sub) {
+    sub.reattachTimer = null; // this run consumes any scheduled retry
+    if (sub.detached)
+        return;
+    attach(sub).then(() => {
+        // The caller may have unsubscribed (or the manager been torn down) while this
+        // attach was in flight; if so, tear the freshly-revived entry back down instead
+        // of leaving a zombie poll.
+        if (sub.detached)
+            detach(sub);
+    }, () => {
+        if (sub.detached)
+            return;
+        sub.reattachTimer = setTimeout(() => reattach(sub), REATTACH_RETRY_MS);
+    });
+}
+/** Tear down every query subscription: cancel timers, clear the registry. */
+function closeAllQuerySubscriptions() {
+    // Retire EVERY live subscriber first (including any detached mid-re-key and waiting
+    // on a retry) so a pending reattach can never revive polling after teardown.
+    for (const sub of [...liveSubscribers])
+        stopSubscriber(sub);
+    liveSubscribers.clear();
+    for (const entry of registry.values()) {
+        entry.generation += 1;
+        clearTimer(entry);
+        entry.subscribers.clear();
+    }
+    registry.clear();
+}
+// ---------------------------------------------------------------------------
+// Visibility (pause polling while hidden; single realigned refresh on resume).
+// ---------------------------------------------------------------------------
+function setHidden(next) {
+    if (next === hidden)
+        return;
+    hidden = next;
+    if (hidden) {
+        for (const entry of registry.values())
+            clearTimer(entry);
+        return;
+    }
+    // Resume: one refresh per key at a small jitter so N keys don't burst-sync;
+    // single-flight collapses it with any still-outstanding poll, and the recurring
+    // tick is (re)scheduled by that poll's completion - so exactly one POST resumes.
+    // A key that was BACKING OFF resumes on its remaining backoff, not the jitter, so a
+    // hide/resume can't be used to bypass 429 throttling.
+    for (const entry of registry.values()) {
+        const delay = entry.consecutiveFailures > 0
+            ? backoffDelay(entry)
+            : Math.floor(Math.random() * RESUME_JITTER_MS);
+        scheduleNext(entry, delay);
+    }
+}
+if (typeof document !== 'undefined' && typeof document.addEventListener === 'function') {
+    hidden = !!document.hidden;
+    document.addEventListener('visibilitychange', () => {
+        setHidden(!!document.hidden);
+    });
+}
+// Auto-wire the identity-change signal to the SDK's existing chokepoint.
+onReadCacheAuthChange(notifyQueryAuthChanged);
+
 // ---------------------------------------------------------------------------
 // field-values.ts -- Server-resolved field-value operations for set()/setMany().
 //
@@ -7814,12 +8401,12 @@ function toMillis(seconds) {
 
 /** Load the Anchor/Web3 transaction builder only when an onchain write uses it. */
 async function buildSetDocumentsTransaction(connection, idl, programProvider, payerPublicKey, args, remainingAccounts, lutKey, preInstructions, simulate, additionalLutAddresses) {
-    const implementation = await import('./sol-utils-D0Tdlpsc.mjs');
+    const implementation = await import('./sol-utils-v8cCs2pm.mjs');
     return implementation.buildSetDocumentsTransaction(connection, idl, programProvider, payerPublicKey, args, remainingAccounts, lutKey, preInstructions, simulate, additionalLutAddresses);
 }
 /** SIWS message creation is async already, so its onchain module can be lazy. */
 async function genSolanaMessage(address, nonce) {
-    const implementation = await import('./solana-message-kTeT43eQ.mjs');
+    const implementation = await import('./solana-message-DoiFXEx_.mjs');
     return implementation.genSolanaMessage(address, nonce);
 }
 const BASE58_ALPHABET = "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz";
@@ -8351,5 +8938,5 @@ function defineLiveModule(mod) {
     return mod;
 }
 
-export { genSolanaMessage as $, reconnectWithNewAuth as A, BoundedDeclineError as B, deriveDecline as C, dispatchDeclineEvent as D, DECLINE_EVENT_NAME as E, dispatchRateLimitEvent as F, hasActiveConnection as G, increment as H, InsufficientBalanceError as I, serverTimestamp as J, now as K, toSeconds as L, toMillis as M, getIdToken as N, deriveUserIdentityFromIdToken as O, ReactNativeSessionManager as P, getActiveSessionManager as Q, RATE_LIMIT_EVENT_NAME as R, ServerSessionManager as S, createSessionWithSignature as T, refreshSession as U, revokeSession as V, WebSessionManager as W, signSessionCreateMessage as X, genAuthNonce as Y, buildSetDocumentsTransaction as Z, convertRemainingAccounts as _, getWebhookKeysUrl as a, genSiweMessage as a0, normalizeEvmAddress as a1, toLowerEvmAddress as a2, assertCanonicalBoundedRuntimeWriteCalldata as a3, assertEvmTransactionMatchesWrite as a4, BOUNDED_RUNTIME_SET_DOCUMENTS_SELECTOR as a5, BOUNDED_RUNTIME_SET_DOCUMENTS_ATTESTED_SELECTOR as a6, functions as a7, invoke as a8, FunctionInvokeError as a9, live as aa, intent as ab, status as ac, subscribeView as ad, LiveIntentError as ae, withEffects as af, isEffectResult as ag, defineLiveModule as ah, EFFECT_INTENT_ADDRESS as ai, bufferExports as b, get as c, getMany as d, docId as e, setMany as f, getConfig as g, setFile as h, init as i, getFiles as j, search as k, runQueryMany as l, runExpression as m, runExpressionMany as n, signMessage as o, signTransaction as p, queryAggregate as q, runQuery as r, set as s, signAndSubmitTransaction as t, count as u, aggregate as v, subscribe as w, closeAllSubscriptions as x, clearCache as y, getCachedData as z };
-//# sourceMappingURL=index-DpfaeNTQ.mjs.map
+export { refreshSession as $, reconnectWithNewAuth as A, subscribeQuery as B, closeAllQuerySubscriptions as C, canonicalizeArgs as D, canonicalizeResult as E, DEFAULT_QUERY_POLL_INTERVAL_MS as F, BoundedDeclineError as G, deriveDecline as H, InsufficientBalanceError as I, dispatchDeclineEvent as J, DECLINE_EVENT_NAME as K, dispatchRateLimitEvent as L, MIN_QUERY_POLL_INTERVAL_MS as M, hasActiveConnection as N, increment as O, serverTimestamp as P, now as Q, RATE_LIMIT_EVENT_NAME as R, toSeconds as S, toMillis as T, getIdToken as U, deriveUserIdentityFromIdToken as V, WebSessionManager as W, ReactNativeSessionManager as X, getActiveSessionManager as Y, ServerSessionManager as Z, createSessionWithSignature as _, getWebhookKeysUrl as a, revokeSession as a0, signSessionCreateMessage as a1, genAuthNonce as a2, buildSetDocumentsTransaction as a3, convertRemainingAccounts as a4, genSolanaMessage as a5, genSiweMessage as a6, normalizeEvmAddress as a7, toLowerEvmAddress as a8, assertCanonicalBoundedRuntimeWriteCalldata as a9, assertEvmTransactionMatchesWrite as aa, BOUNDED_RUNTIME_SET_DOCUMENTS_SELECTOR as ab, BOUNDED_RUNTIME_SET_DOCUMENTS_ATTESTED_SELECTOR as ac, functions as ad, invoke as ae, FunctionInvokeError as af, live as ag, intent as ah, status as ai, subscribeView as aj, LiveIntentError as ak, withEffects as al, isEffectResult as am, defineLiveModule as an, EFFECT_INTENT_ADDRESS as ao, bufferExports as b, get as c, getMany as d, docId as e, setMany as f, getConfig as g, setFile as h, init as i, getFiles as j, search as k, runQueryMany as l, runExpression as m, runExpressionMany as n, signMessage as o, signTransaction as p, queryAggregate as q, runQuery as r, set as s, signAndSubmitTransaction as t, count as u, aggregate as v, subscribe as w, closeAllSubscriptions as x, clearCache as y, getCachedData as z };
+//# sourceMappingURL=index-DHigIn6m.mjs.map