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

package/dist/{index-BaSw33ec.js → index-Dmnzhzk1.js}

@@ -3021,8 +3021,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, 
@@ -3233,8 +3238,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);
@@ -3410,7 +3420,7 @@ class ServerSessionManager {
         const address = kp.publicKey.toBase58();
         /* fetch nonce from auth API */
         const nonce = await genAuthNonce();
-        const { genSolanaMessage } = await Promise.resolve().then(function () { return require('./solana-message-BVJWVB6C.js'); });
+        const { genSolanaMessage } = await Promise.resolve().then(function () { return require('./solana-message-BP0L24CQ.js'); });
         const message = await genSolanaMessage(address, nonce);
         /* sign the message */
         const sigBytes = nacl.sign.detached(new TextEncoder().encode(message), kp.secretKey);
@@ -5557,11 +5567,11 @@ async function setMany(many, options) {
                 transactionResult = await handleEvmTransaction(curTx.evmTransaction, authProvider, options);
             }
             else if (curTx.serializedTransaction) {
-                const { handlePreBuiltTransaction } = await Promise.resolve().then(function () { return require('./solana-operations-bXuuPlov.js'); });
+                const { handlePreBuiltTransaction } = await Promise.resolve().then(function () { return require('./solana-operations-DZldDVeJ.js'); });
                 transactionResult = await handlePreBuiltTransaction(curTx, authProvider, options, expectedWritePaths);
             }
             else {
-                const { handleSolanaTransaction } = await Promise.resolve().then(function () { return require('./solana-operations-bXuuPlov.js'); });
+                const { handleSolanaTransaction } = await Promise.resolve().then(function () { return require('./solana-operations-DZldDVeJ.js'); });
                 transactionResult = await handleSolanaTransaction(curTx, authProvider, options, expectedWritePaths);
             }
             // Sync items after all transactions are confirmed
@@ -5670,6 +5680,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
@@ -5679,6 +5701,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 {
@@ -5686,7 +5714,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;
     }
@@ -5780,6 +5808,7 @@ var operations = /*#__PURE__*/Object.freeze({
     get: get,
     getFiles: getFiles,
     getMany: getMany,
+    onReadCacheAuthChange: onReadCacheAuthChange,
     queryAggregate: queryAggregate,
     runExpression: runExpression,
     runExpressionMany: runExpressionMany,
@@ -7476,7 +7505,7 @@ async function doReconnectWithNewAuth() {
         console.warn('[WS v2] Failed to clear HTTP read cache on auth change:', error);
     }
     try {
-        const { reconnectRealtimeStoreWithNewAuth } = await Promise.resolve().then(function () { return require('./realtime-store-PVPxsvPr.js'); });
+        const { reconnectRealtimeStoreWithNewAuth } = await Promise.resolve().then(function () { return require('./realtime-store-4Yr6LyTX.js'); });
         await reconnectRealtimeStoreWithNewAuth();
     }
     catch (error) {
@@ -7711,6 +7740,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().
 //
@@ -7816,12 +8403,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 Promise.resolve().then(function () { return require('./sol-utils-pVrt7VOx.js'); });
+    const implementation = await Promise.resolve().then(function () { return require('./sol-utils-Dni65Z63.js'); });
     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 Promise.resolve().then(function () { return require('./solana-message-BVJWVB6C.js'); });
+    const implementation = await Promise.resolve().then(function () { return require('./solana-message-BP0L24CQ.js'); });
     return implementation.genSolanaMessage(address, nonce);
 }
 const BASE58_ALPHABET = "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz";
@@ -8357,10 +8944,12 @@ exports.BOUNDED_RUNTIME_SET_DOCUMENTS_ATTESTED_SELECTOR = BOUNDED_RUNTIME_SET_DO
 exports.BOUNDED_RUNTIME_SET_DOCUMENTS_SELECTOR = BOUNDED_RUNTIME_SET_DOCUMENTS_SELECTOR;
 exports.BoundedDeclineError = BoundedDeclineError;
 exports.DECLINE_EVENT_NAME = DECLINE_EVENT_NAME;
+exports.DEFAULT_QUERY_POLL_INTERVAL_MS = DEFAULT_QUERY_POLL_INTERVAL_MS;
 exports.EFFECT_INTENT_ADDRESS = EFFECT_INTENT_ADDRESS;
 exports.FunctionInvokeError = FunctionInvokeError;
 exports.InsufficientBalanceError = InsufficientBalanceError;
 exports.LiveIntentError = LiveIntentError;
+exports.MIN_QUERY_POLL_INTERVAL_MS = MIN_QUERY_POLL_INTERVAL_MS;
 exports.RATE_LIMIT_EVENT_NAME = RATE_LIMIT_EVENT_NAME;
 exports.ReactNativeSessionManager = ReactNativeSessionManager;
 exports.ServerSessionManager = ServerSessionManager;
@@ -8370,7 +8959,10 @@ exports.assertCanonicalBoundedRuntimeWriteCalldata = assertCanonicalBoundedRunti
 exports.assertEvmTransactionMatchesWrite = assertEvmTransactionMatchesWrite;
 exports.bufferExports = bufferExports;
 exports.buildSetDocumentsTransaction = buildSetDocumentsTransaction;
+exports.canonicalizeArgs = canonicalizeArgs;
+exports.canonicalizeResult = canonicalizeResult;
 exports.clearCache = clearCache;
+exports.closeAllQuerySubscriptions = closeAllQuerySubscriptions;
 exports.closeAllSubscriptions = closeAllSubscriptions;
 exports.convertRemainingAccounts = convertRemainingAccounts;
 exports.count = count;
@@ -8421,9 +9013,10 @@ exports.signSessionCreateMessage = signSessionCreateMessage;
 exports.signTransaction = signTransaction;
 exports.status = status;
 exports.subscribe = subscribe;
+exports.subscribeQuery = subscribeQuery;
 exports.subscribeView = subscribeView;
 exports.toLowerEvmAddress = toLowerEvmAddress;
 exports.toMillis = toMillis;
 exports.toSeconds = toSeconds;
 exports.withEffects = withEffects;
-//# sourceMappingURL=index-BaSw33ec.js.map
+//# sourceMappingURL=index-Dmnzhzk1.js.map