@ethlete/query 6.0.0-next.34 → 6.0.0-next.35

package/fesm2022/ethlete-query.mjs

@@ -380,6 +380,8 @@ const QueryRuntimeErrorCode = {
     WITH_AUTO_REFRESH_USED_ON_UNSUPPORTED_HTTP_METHOD: 102,
     WITH_AUTO_REFRESH_USED_IN_MANUAL_QUERY: 103,
     SILENCE_MISSING_WITH_ARGS_FEATURE_ERROR_USED_BUT_WITH_ARGS_PRESENT: 104,
+    WITH_LONG_POLLING_USED_ON_UNSUPPORTED_HTTP_METHOD: 105,
+    WITH_LONG_POLLING_USED_WITH_POLLING: 106,
     // Auth provider
     AUTH_EXTRACT_TOKENS_RESPONSE_NOT_OBJECT: 200,
     AUTH_EXTRACT_TOKENS_RESPONSE_MISSING_ACCESS_TOKEN: 201,
@@ -430,6 +432,13 @@ const withAutoRefreshUsedInManualQuery = () => {
     return new RuntimeError(QueryRuntimeErrorCode.WITH_AUTO_REFRESH_USED_IN_MANUAL_QUERY, `"withAutoRefresh()" has been used inside a query that has "onlyManualExecution" set to true.` +
         ` If this is intentional, set "ignoreOnlyManualExecution" to true inside the auto refresh config.`);
 };
+const withLongPollingUsedOnUnsupportedHttpMethod = (method) => {
+    return new RuntimeError(QueryRuntimeErrorCode.WITH_LONG_POLLING_USED_ON_UNSUPPORTED_HTTP_METHOD, `This is a "${method}" request, "withLongPolling()" is only supported for GET, HEAD, OPTIONS requests and GQL queries.`);
+};
+const withLongPollingUsedWithPolling = () => {
+    return new RuntimeError(QueryRuntimeErrorCode.WITH_LONG_POLLING_USED_WITH_POLLING, `"withLongPolling()" and "withPolling()" cannot be used on the same query - both would drive its re-execution.` +
+        ` Keep the long polling feature and drop the interval, or the other way around.`);
+};
 const silenceMissingWithArgsFeatureErrorUsedButWithArgsPresent = () => {
     return new RuntimeError(QueryRuntimeErrorCode.SILENCE_MISSING_WITH_ARGS_FEATURE_ERROR_USED_BUT_WITH_ARGS_PRESENT, `The "silenceMissingWithArgsFeatureError" config is set to true, but a "withArgs()" feature is present.`);
 };
@@ -534,11 +543,6 @@ const isSymfonyListError = (error) => {
         'invalidValue' in error[0]);
 };
 
-/**
- * Returning this inside a withArgs feature will reset the query args to null.
- * This will also pause polling and auto refresh until new args are set.
- */
-const CLEAR_QUERY_ARGS = /* @__PURE__ */ Symbol('CLEAR_QUERY_ARGS');
 /** A angular effect that can be nested inside another effect */
 const nestedEffect = (fn, options) => {
     const activeConsumer = getActiveConsumer();
@@ -555,6 +559,7 @@ const QueryFeatureType = {
     WITH_ERROR_HANDLING: 'WITH_ERROR_HANDLING',
     WITH_SUCCESS_HANDLING: 'WITH_SUCCESS_HANDLING',
     WITH_POLLING: 'WITH_POLLING',
+    WITH_LONG_POLLING: 'WITH_LONG_POLLING',
     WITH_AUTO_REFRESH: 'WITH_AUTO_REFRESH',
     WITH_RESPONSE_UPDATE: 'WITH_RESPONSE_UPDATE',
     WITH_PAGE_RESET_ON_ERROR: 'WITH_PAGE_RESET_ON_ERROR',
@@ -566,8 +571,8 @@ const createQueryFeature = (config) => {
  * A query feature that allows you to set the arguments of the query.
  * The arguments are read within a computed function, so you can use reactive values.
  *
- * To set the arguments to `null`, return the symbol `CLEAR_QUERY_ARGS`.
- * If you instead return `null`, the arguments won't change.
+ * Return `null` to park the query: its args are reset to `null`, and polling and auto refresh
+ * pause until args are set again.
  *
  * Changing arguments will automatically trigger a new execution of the query if it is eligible for auto execution (e.g. a GET request).
  */
@@ -575,26 +580,11 @@ const withArgs = (args) => {
     return createQueryFeature({
         type: QueryFeatureType.WITH_ARGS,
         fn: (context) => {
-            // `state.args` is reactively backed by this source, so every reader (exec, polling,
-            // auto-refresh) always sees the latest value with no pending-effect window. Sentinels are
-            // resolved here: CLEAR -> null, `null` ("don't change") -> keep the previous value.
-            let previous = null;
-            const resolve = () => {
-                const value = args();
-                if (value === CLEAR_QUERY_ARGS) {
-                    previous = null;
-                    return null;
-                }
-                if (value === null)
-                    return previous;
-                previous = value;
-                return value;
-            };
             // Only ever non-null while the devtools are installed. Wrapping the source (rather than reading
             // `state.args` from the outside) is what puts the tracking window around the *evaluation* of the
             // args - a cached read of the computed runs nothing and would record no form at all.
             const formLinks = context.state.subtle.devtoolsFormLinks;
-            context.state.subtle.setArgsSource(formLinks ? () => formLinks.track(resolve) : resolve);
+            context.state.subtle.setArgsSource(formLinks ? () => formLinks.track(args) : args);
             // Trigger (auto-)execution whenever the resolved args change.
             nestedEffect(() => {
                 const currArgsNow = context.state.args();
@@ -690,6 +680,107 @@ const withPolling = (options) => {
         },
     });
 };
+const DEFAULT_LONG_POLLING_DELAY = 250;
+const DEFAULT_LONG_POLLING_ERROR_DELAY = 1_000;
+const DEFAULT_LONG_POLLING_MAX_ERROR_DELAY = 30_000;
+const DEFAULT_LONG_POLLING_STOP_AFTER_ERRORS = 10;
+/**
+ * A query feature for long polling: a chain of requests where each round starts once the previous one
+ * settled, with args derived from what it returned. Unlike {@link withPolling} there is no interval -
+ * the server decides the cadence by holding each request open until it has something to say.
+ *
+ * A failed round is repeated after a growing delay, so a transient failure does not silently end the
+ * feed. A new value from the `withArgs` source cancels the pending round and starts over from it.
+ *
+ * Rounds do not share the cache: each one is requested with `keepUnusedFor: 0`, because a cursor is
+ * asked for once and never again. They are also not deduped across tabs - `withMultiTabSync` elects a
+ * poller per cache key, and a chain's key moves with every round.
+ *
+ * @example
+ * const events = getEvents(
+ *   withArgs(() => ({ queryParams: { cursor: null } })),
+ *   withLongPolling({
+ *     nextArgs: (response) => (response ? { queryParams: { cursor: response.cursor } } : null),
+ *   }),
+ * );
+ *
+ * @throws If the query is not eligible for auto execution (e.g. a POST request)
+ * @throws If the query also has a `withPolling` feature
+ */
+const withLongPolling = (options) => {
+    return createQueryFeature({
+        type: QueryFeatureType.WITH_LONG_POLLING,
+        devtools: () => [
+            { label: 'delay', value: formatQueryDevtoolsDuration(options.delay ?? DEFAULT_LONG_POLLING_DELAY) },
+            ...queryDevtoolsFnDetail(options.nextArgs, 'nextArgs'),
+        ],
+        fn: (context) => {
+            if (!context.flags.shouldAutoExecuteMethod) {
+                throw withLongPollingUsedOnUnsupportedHttpMethod(context.flags.method);
+            }
+            if (context.flags.hasPollingFeature) {
+                throw withLongPollingUsedWithPolling();
+            }
+            const delay = options.delay ?? DEFAULT_LONG_POLLING_DELAY;
+            const errorDelay = options.errorDelay ?? DEFAULT_LONG_POLLING_ERROR_DELAY;
+            const maxErrorDelay = options.maxErrorDelay ?? DEFAULT_LONG_POLLING_MAX_ERROR_DELAY;
+            const stopAfterErrors = options.stopAfterErrors ?? DEFAULT_LONG_POLLING_STOP_AFTER_ERRORS;
+            let timeoutId = null;
+            let consecutiveErrors = 0;
+            const stop = () => {
+                if (timeoutId !== null)
+                    clearTimeout(timeoutId);
+                timeoutId = null;
+            };
+            const schedule = (args, wait) => {
+                stop();
+                timeoutId = setTimeout(() => {
+                    timeoutId = null;
+                    context.execute({ args, options: { keepUnusedFor: 0, triggeredBy: 'long-polling' } });
+                }, wait);
+            };
+            // The chain never writes `state.args`, so what a round was sent with lives on the request itself -
+            // which is also the only place a manual `execute({ args })` records them.
+            const settledArgs = () => context.state.subtle.request()?.args ?? null;
+            context.state.events$.pipe(takeUntilDestroyed(context.deps.destroyRef)).subscribe((event) => {
+                if (event.type === HttpEventType.Response) {
+                    consecutiveErrors = 0;
+                    const next = options.nextArgs(context.state.response(), settledArgs());
+                    if (next === null)
+                        return stop();
+                    schedule(next, delay);
+                }
+                else if (event.type === 'error') {
+                    consecutiveErrors++;
+                    if (consecutiveErrors >= stopAfterErrors)
+                        return stop();
+                    schedule(settledArgs(), Math.min(errorDelay * 2 ** (consecutiveErrors - 1), maxErrorDelay));
+                }
+            });
+            // A pending round belongs to the args it was derived from, so a fresh value from the `withArgs`
+            // source must cancel it - the source's own re-execution is what starts the new chain.
+            //
+            // Only an actual change may cancel: the effect's first run can land after the chain already
+            // scheduled a round (effects flush later than the response that scheduled it), and cancelling
+            // there would end the chain before its second round.
+            let hasSeenArgs = false;
+            let seenArgs = null;
+            nestedEffect(() => {
+                const args = context.state.args();
+                untracked(() => {
+                    const hasChanged = hasSeenArgs && args !== seenArgs;
+                    hasSeenArgs = true;
+                    seenArgs = args;
+                    if (!hasChanged)
+                        return;
+                    consecutiveErrors = 0;
+                    stop();
+                });
+            }, { injector: context.deps.injector });
+            context.deps.destroyRef.onDestroy(stop);
+        },
+    });
+};
 /** A query feature that can be used to log the latest http event */
 const withLogging = (options) => {
     return createQueryFeature({
@@ -1004,6 +1095,7 @@ const getQueryFeatureUsage = (
 options) => {
     const { creator, features, queryConfig, creatorInternals } = options;
     const hasWithArgsFeature = features.some((f) => f.type === QueryFeatureType.WITH_ARGS);
+    const hasPollingFeature = features.some((f) => f.type === QueryFeatureType.WITH_POLLING);
     const shouldAutoExecuteMethod = isCreateGqlQueryOptions(options)
         ? shouldAutoExecuteGqlQuery(options.creatorInternals.method)
         : shouldAutoExecuteQuery(options.creatorInternals.method);
@@ -1018,6 +1110,7 @@ options) => {
     }
     const featureFnContext = {
         hasWithArgsFeature,
+        hasPollingFeature,
         shouldAutoExecuteMethod,
         shouldAutoExecute,
         hasRouteFunction,
@@ -1547,16 +1640,16 @@ const runQueryErrorParsers = (detail, response) => {
     return null;
 };
 const NO_RETRY = { retry: false };
-let defaultRetryFn = null;
+let defaultRetryFn$1 = null;
 /**
  * Installs the retry policy used by every request that does not bring its own `retryFn`. Installed
  * by the {@link withDefaultRetry} query client feature; without it nothing is retried automatically.
  */
 const setDefaultQueryRetryFn = (fn) => {
-    defaultRetryFn = fn;
+    defaultRetryFn$1 = fn;
 };
 /** @internal */
-const runDefaultQueryRetry = (options) => defaultRetryFn?.(options) ?? NO_RETRY;
+const runDefaultQueryRetry = (options) => defaultRetryFn$1?.(options) ?? NO_RETRY;
 
 const isQueryErrorResponse = (error) => {
     return typeof error === 'object' && error !== null && 'raw' in error && 'retryState' in error && 'isList' in error;
@@ -1823,12 +1916,19 @@ const createHttpRequest = (options) => {
         });
         return true;
     };
-    const destroy = () => {
+    const abort = () => {
         const wasActive = !currentStreamSubscription.closed;
         currentStreamSubscription.unsubscribe();
-        // A request destroyed mid-backoff never runs the attempt it was waiting for, so leaving the state
-        // set would keep a "retrying in …" readout counting down for a request that is gone.
+        currentStreamSubscription = Subscription.EMPTY;
+        // A request stopped mid-backoff never runs the attempt it was waiting for, so leaving the state
+        // set would keep a "retrying in …" readout counting down for a request that is not coming.
         retryState.set(null);
+        // Nothing is on its way any more, and `execute()` refuses to run while this is set.
+        loading.set(null);
+        return wasActive;
+    };
+    const destroy = () => {
+        const wasActive = abort();
         event$.complete();
         return wasActive;
     };
@@ -1947,6 +2047,7 @@ const createHttpRequest = (options) => {
             attempts: attempts.asReadonly(),
             retryState: retryState.asReadonly(),
             lastDurationMs: lastDurationMs.asReadonly(),
+            abort,
         },
     };
     return httpRequest;
@@ -3030,48 +3131,68 @@ const symfonyQueryErrorParser = (detail) => {
     return null;
 };
 
-const shouldRetryRequest = (options) => {
-    const normalizedOptions = options instanceof HttpErrorResponse ? { retryCount: 0, error: options } : options;
-    const { retryCount, error } = normalizedOptions;
-    const defaultRetryDelay = clamp(1000 + 1000 * retryCount, 1000, 5000);
-    const { status, error: detail, headers } = error;
-    // Code 0 usually means the internet connection is down. We retry in this case.
-    // It could also be a CORS issue but that should not be the case in production.
-    // We will retry in this case until the connection is back.
-    if (status === 0) {
-        return { retry: true, delay: defaultRetryDelay };
-    }
-    // Don't retry if we already retried 3 times
-    if (retryCount > 3) {
-        return { retry: false };
-    }
-    // Don't retry if it's not an http error
-    if (!(error instanceof HttpErrorResponse)) {
-        return { retry: false };
-    }
-    // Retry on 5xx errors (except 500 internal server error since those are usually not recoverable)
-    if (status >= 501) {
-        // Don't retry if a requested page is out of range
-        if (isSymfonyPagerfantaOutOfRangeError(detail)) {
+const DEFAULT_MAX_ATTEMPTS = 3;
+const DEFAULT_BASE_DELAY_MS = 1000;
+const DEFAULT_MAX_DELAY_MS = 30_000;
+const DEFAULT_JITTER = 0.25;
+// 500 is left out on purpose: an internal server error is a bug in the backend far more often than a
+// blip, and repeating the request that triggered it does not make it go away.
+const isRetryableByDefault = (status) => status === 0 || status === 408 || status === 425 || status === 429 || status >= 501;
+/**
+ * Builds a retry policy: an exponentially backing off, jittered {@link ShouldRetryRequestFn} bounded by
+ * an attempt ceiling. What {@link withDefaultRetry} installs - reach for this directly to hand a single
+ * client or creator its own `retryFn`.
+ *
+ * @example
+ * const flakyEndpointRetry = createDefaultRetryFn({ maxAttempts: 8, maxDelayMs: 10_000 });
+ *
+ * const getReport = myApiGet<GetReportArgs>('/report').clone({ retryFn: flakyEndpointRetry });
+ */
+const createDefaultRetryFn = (options = {}) => {
+    const maxAttempts = options.maxAttempts ?? DEFAULT_MAX_ATTEMPTS;
+    const baseDelayMs = options.baseDelayMs ?? DEFAULT_BASE_DELAY_MS;
+    const maxDelayMs = options.maxDelayMs ?? DEFAULT_MAX_DELAY_MS;
+    const jitter = clamp(options.jitter ?? DEFAULT_JITTER, 0, 1);
+    const retryableStatusCodes = options.retryableStatusCodes;
+    const isRetryableStatus = (status) => retryableStatusCodes ? retryableStatusCodes.includes(status) : isRetryableByDefault(status);
+    const backoff = (retryCount) => {
+        const exponential = baseDelayMs * Math.pow(2, retryCount);
+        const spread = jitter === 0 ? 1 : 1 + (Math.random() * 2 - 1) * jitter;
+        return Math.round(clamp(exponential * spread, 0, maxDelayMs));
+    };
+    return ({ retryCount, error }) => {
+        // Not an HTTP failure at all, so nothing about it says a second attempt would go any better.
+        if (!(error instanceof HttpErrorResponse))
             return { retry: false };
+        if (maxAttempts > 0 && retryCount > maxAttempts)
+            return { retry: false };
+        const { status, error: detail, headers } = error;
+        if (!isRetryableStatus(status))
+            return { retry: false };
+        // A page past the end of a Pagerfanta collection answers 5xx, and asking for it again keeps
+        // answering 5xx - the request is wrong, not the server.
+        if (status >= 501 && isSymfonyPagerfantaOutOfRangeError(detail))
+            return { retry: false };
+        if (status === 429) {
+            const retryAfter = headers.get('retry-after') || headers.get('x-retry-after');
+            const delay = retryAfter ? parseInt(retryAfter) * 1000 : NaN;
+            // The server named a time, so it is used as named rather than jittered - only capped, since a
+            // `retry-after` of an hour would otherwise arm a timer nobody is still around for.
+            if (!Number.isNaN(delay))
+                return { retry: true, delay: Math.min(delay, maxDelayMs) };
         }
-        return { retry: true, delay: defaultRetryDelay };
-    }
-    // Retry on 408 or 425 errors
-    if (status === 408 || status === 425) {
-        return { retry: true, delay: defaultRetryDelay };
-    }
-    // Retry on 429 errors
-    if (status === 429) {
-        const retryAfter = headers.get('retry-after') || headers.get('x-retry-after');
-        if (retryAfter) {
-            const delay = parseInt(retryAfter) * 1000;
-            return { retry: true, delay: Number.isNaN(delay) ? defaultRetryDelay : delay };
-        }
-        return { retry: true, delay: defaultRetryDelay };
-    }
-    return { retry: false };
+        return { retry: true, delay: backoff(retryCount) };
+    };
 };
+const defaultRetryFn = /* @__PURE__ */ createDefaultRetryFn();
+/**
+ * The SDK's default retry policy, installed by {@link withDefaultRetry}: three retries with an
+ * exponentially backing off, jittered delay, for a connection failure, a `408`, a `425`, a `429`
+ * (honouring `retry-after`) and a 5xx above `500`.
+ *
+ * Pass {@link createDefaultRetryFn} options to {@link withDefaultRetry} to configure it.
+ */
+const shouldRetryRequest = (options) => defaultRetryFn(options instanceof HttpErrorResponse ? { retryCount: 0, error: options } : options);
 
 const noop$2 = () => undefined;
 /** Shared because it never changes: without Web Locks, every hold is granted and never lost. */
@@ -3475,10 +3596,9 @@ const withSymfonyErrors = () => () => {
     return { type: QueryClientFeatureType.SYMFONY_ERRORS, instance: null };
 };
 /**
- * Installs the SDK's default retry policy for every request that does not bring its own `retryFn`:
- * retry a connection failure indefinitely, a 5xx above 500, a 408/425, and a 429 (honouring
- * `retry-after`), up to three times with a backing-off delay - and never a Pagerfanta out-of-range
- * page.
+ * Installs the SDK's default retry policy for every request that does not bring its own `retryFn`: a
+ * connection failure, a 5xx above 500, a 408/425 and a 429 (honouring `retry-after`) are retried three
+ * times with an exponentially backing off, jittered delay - and a Pagerfanta out-of-range page never is.
  *
  * Without it nothing is retried automatically and `error.retryState` always reads `{ retry: false }`.
  * A per-client or per-creator `retryFn` keeps working either way.
@@ -3487,11 +3607,11 @@ const withSymfonyErrors = () => () => {
  * const MY_CLIENT = createQueryClient({
  *   name: 'my-api',
  *   baseUrl: 'https://api.example.com',
- *   features: [withDefaultRetry()],
+ *   features: [withDefaultRetry({ maxAttempts: 5 })],
  * });
  */
-const withDefaultRetry = () => () => {
-    setDefaultQueryRetryFn(shouldRetryRequest);
+const withDefaultRetry = (options) => () => {
+    setDefaultQueryRetryFn(options ? createDefaultRetryFn(options) : shouldRetryRequest);
     return { type: QueryClientFeatureType.DEFAULT_RETRY, instance: null };
 };
 /**
@@ -3509,10 +3629,10 @@ const withDefaultRetry = () => () => {
  *   features: [withEthleteApiErrors()],
  * });
  */
-const withEthleteApiErrors = () => () => {
+const withEthleteApiErrors = (options) => () => {
     registerQueryErrorParser(htmlQueryErrorParser);
     registerQueryErrorParser(symfonyQueryErrorParser);
-    setDefaultQueryRetryFn(shouldRetryRequest);
+    setDefaultQueryRetryFn(options?.retry ? createDefaultRetryFn(options.retry) : shouldRetryRequest);
     return { type: QueryClientFeatureType.ETHLETE_API_ERRORS, instance: null };
 };
 
@@ -3533,10 +3653,10 @@ const createQueryRepository = (config) => {
     const cacheVersion = signal(0, /* @ts-ignore */
     ...(ngDevMode ? [{ debugName: "cacheVersion" }] : /* istanbul ignore next */ []));
     const bumpCacheVersion = () => cacheVersion.update((v) => v + 1);
-    const resolveKeepUnusedFor = (creatorOptions, shouldCache) => {
+    const resolveKeepUnusedFor = (creatorOptions, shouldCache, override) => {
         if (config.retentionEnabled === false || !shouldCache)
             return 0;
-        return Math.max(0, creatorOptions?.keepUnusedFor ?? config.keepUnusedFor ?? DEFAULT_KEEP_UNUSED_FOR);
+        return Math.max(0, override ?? creatorOptions?.keepUnusedFor ?? config.keepUnusedFor ?? DEFAULT_KEEP_UNUSED_FOR);
     };
     const request = (options) => {
         const { args, creatorOptions, runQueryOptions } = options;
@@ -3567,7 +3687,7 @@ const createQueryRepository = (config) => {
             })
             : false;
         const trackingKey = cacheKey || generateUuid();
-        const keepUnusedFor = resolveKeepUnusedFor(creatorOptions, shouldCache);
+        const keepUnusedFor = resolveKeepUnusedFor(creatorOptions, shouldCache, runQueryOptions?.keepUnusedFor);
         const isMultiTabSyncEnabled = creatorOptions?.multiTabSync !== false;
         const isSecure = options.isSecure ?? false;
         // A secure response needs an explicit `persistence: true` to reach the disk: leaving an
@@ -3672,6 +3792,10 @@ const createQueryRepository = (config) => {
             // Only data is worth keeping around: an entry that never produced a response has nothing to
             // hand back to a returning consumer, so it is aborted immediately as it always was.
             if (cacheEntry.keepUnusedFor > 0 && cacheEntry.request.response() !== null) {
+                // Retention keeps the response, not the work: a revalidation nobody is waiting for is stopped
+                // rather than left running - and a failing one left running would go on retrying into an empty
+                // room. A consumer that binds again re-executes anyway.
+                cacheEntry.request.subtle.abort();
                 retain(key, cacheEntry);
             }
             else {
@@ -4657,6 +4781,8 @@ const runEarlyFeatureSetup = (featureBuilders, context) => {
     let isLeaderFn = alwaysLeader;
     let leaderElectionContext;
     let refreshCoordination;
+    let sessionAdoption;
+    let activityCoordination;
     for (const featureBuilder of featureBuilders ?? []) {
         const earlySetup = featureBuilder.earlySetup;
         if (!earlySetup)
@@ -4665,8 +4791,10 @@ const runEarlyFeatureSetup = (featureBuilders, context) => {
         isLeaderFn = result.isLeader ?? isLeaderFn;
         leaderElectionContext = result.leaderElection ?? leaderElectionContext;
         refreshCoordination = result.refreshCoordination ?? refreshCoordination;
+        sessionAdoption = result.sessionAdoption ?? sessionAdoption;
+        activityCoordination = result.activityCoordination ?? activityCoordination;
     }
-    return { isLeaderFn, leaderElectionContext, refreshCoordination };
+    return { isLeaderFn, leaderElectionContext, refreshCoordination, sessionAdoption, activityCoordination };
 };
 const createBearerAuthProviderImpl = (config) => {
     const injector = inject(Injector);
@@ -4787,6 +4915,8 @@ const createBearerAuthProviderImpl = (config) => {
         setTokens,
         isLeader: isLeader.isLeaderFn,
         leaderElection: isLeader.leaderElectionContext,
+        sessionAdoption: isLeader.sessionAdoption,
+        activityCoordination: isLeader.activityCoordination,
         afterTokenRefresh$,
         queries: queries,
         executionState,
@@ -4795,9 +4925,21 @@ const createBearerAuthProviderImpl = (config) => {
     };
     const { features, applied: appliedFeatures } = setupFeatures(config.features, featureSetupContext);
     // Runs after the features, because `withPersistentAuth` starts its auto-login during setup. Still
-    // `unknown` here means nothing is trying to restore a session, so there is nothing to wait for.
+    // `unknown` here means nothing is trying to restore a session, so there is nothing to wait for -
+    // unless the join handshake is still out, in which case another tab may be about to hand this one a
+    // live session. Saying `anonymous` in that window would send the auth guard to the login page for a
+    // session that exists, so the fallback waits for the handshake instead.
     if (sessionStatus() === 'unknown') {
-        sessionStatus.set('anonymous');
+        const adoption = isLeader.sessionAdoption;
+        if (adoption?.isPending()) {
+            void adoption.settled.then(() => {
+                if (sessionStatus() === 'unknown')
+                    sessionStatus.set('anonymous');
+            });
+        }
+        else {
+            sessionStatus.set('anonymous');
+        }
     }
     const provider = {
         queries,
@@ -4837,6 +4979,14 @@ const createBearerAuthProvider = (config) => defineRootProvider(() => createBear
 
 /** How long a scheduled refresh waits before retrying an attempt that could not run yet. */
 const rescheduleDelayMs = 5000;
+/**
+ * How long a follower waits for the leader to answer a delegated refresh before asking again. The
+ * request is a `BroadcastChannel` message with no ack, so a leader that was frozen or handed the
+ * leadership over mid-flight simply never acts on it.
+ */
+const delegatedRefreshRetryMs = 3000;
+/** How often a delegated refresh is re-asked for before the tab leaves it to the next 401. */
+const maxDelegatedRefreshAttempts = 3;
 /**
  * How often a scheduled refresh may re-arm before it waits for a new token pair. A tab that keeps
  * declining is either not the leader or busy issuing tokens; either way a 401 still forces a refresh.
@@ -4889,9 +5039,12 @@ const withRefreshQuery = (key, config) => {
         const expiresInPropertyName = config.expiresInPropertyName ?? 'exp';
         const minRefreshInterval = config.minRefreshInterval ?? 30000; // 30 seconds default
         const refreshIfExpired = config.refreshIfExpired ?? true;
+        const destroyRef = inject(DestroyRef);
         let lastRefreshTime = 0;
         let lastUnauthorizedRefreshTime = 0;
         let unauthorizedRefreshStreak = 0;
+        let delegatedRefreshAttempts = 0;
+        let isWatchingDelegatedRefresh = false;
         // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
         const refreshQuery = () => context.queries[key];
         const executeRefresh = (reason) => {
@@ -4899,9 +5052,14 @@ const withRefreshQuery = (key, config) => {
             if (!currentRefreshToken)
                 return 'noToken';
             if (!context.isLeader()) {
-                // Only the leader may spend a single-use refresh token, but the event is still real - hand it
-                // over instead of dropping it, or this tab waits out the leader's timer with a dead token.
+                // A scheduled tick on a follower is pure duplicate: multi-tab sync keeps the access token
+                // identical across tabs, so the leader's own timer is due at the same instant and it is the
+                // only tab allowed to act. Delegation is for the 401 path, where this tab has a request that
+                // really failed and the leader has no way of knowing.
+                if (reason === 'scheduled')
+                    return 'notLeader';
                 context.refreshCoordination?.request();
+                watchDelegatedRefresh(context.accessToken());
                 return 'delegated';
             }
             // Any token-issuing execution, not just another refresh: a login already in flight is about to
@@ -4909,14 +5067,12 @@ const withRefreshQuery = (key, config) => {
             // that login is replacing.
             if (context.hasTokenIssuingExecutionInFlight())
                 return 'busy';
+            const now = Date.now();
             if (reason === 'scheduled') {
-                const now = Date.now();
                 if (now - lastRefreshTime < minRefreshInterval)
                     return 'throttled';
-                lastRefreshTime = now;
             }
             else {
-                const now = Date.now();
                 if (unauthorizedRefreshStreak >= maxUnauthorizedRefreshStreak &&
                     now - lastUnauthorizedRefreshTime < minRefreshInterval) {
                     return 'throttled';
@@ -4924,9 +5080,37 @@ const withRefreshQuery = (key, config) => {
                 unauthorizedRefreshStreak++;
                 lastUnauthorizedRefreshTime = now;
             }
+            // Stamped whatever the reason, so the scheduled floor covers a 401-driven rotation too - a
+            // scheduled tick right behind one would otherwise spend a second refresh token. The 401 path
+            // deliberately does not *gate* on it: a token revoked seconds after a refresh is exactly when
+            // the request has to go out.
+            lastRefreshTime = now;
             refreshQuery().execute(buildArgs(currentRefreshToken), { triggeredBy: 'token-refresh' });
             return 'executed';
         };
+        /**
+         * Asks the leader again if a delegated refresh went unanswered - the request is a channel message
+         * with no ack, so a frozen leader, or one that handed the leadership over mid-flight, drops it
+         * silently. One watch at a time, and by the time it re-asks this tab may be the leader itself;
+         * `executeRefresh` re-decides that on every attempt.
+         */
+        function watchDelegatedRefresh(tokenAtRequest) {
+            if (isWatchingDelegatedRefresh || delegatedRefreshAttempts >= maxDelegatedRefreshAttempts)
+                return;
+            delegatedRefreshAttempts++;
+            isWatchingDelegatedRefresh = true;
+            timer(delegatedRefreshRetryMs)
+                .pipe(takeUntilDestroyed(destroyRef))
+                .subscribe(() => {
+                isWatchingDelegatedRefresh = false;
+                // A new access token is the leader's answer - nothing to re-ask for.
+                if (context.accessToken() !== tokenAtRequest) {
+                    delegatedRefreshAttempts = 0;
+                    return;
+                }
+                executeRefresh('unauthorized');
+            });
+        }
         /**
          * How long a scheduled refresh that did not spend the refresh token waits before trying again.
          * `null` re-arms nothing, because only a new token pair can change the outcome - and that restarts
@@ -4941,7 +5125,10 @@ const withRefreshQuery = (key, config) => {
                     return Math.max(minRefreshInterval - (Date.now() - lastRefreshTime), rescheduleDelayMs);
                 case 'busy':
                     return rescheduleDelayMs;
+                // Both wait for the leader: `delegated` asked it to act, `notLeader` left it to its own timer.
+                // Coming back keeps this tab covered if the leadership moves here in the meantime.
                 case 'delegated':
+                case 'notLeader':
                     return minRefreshInterval;
             }
         };
@@ -4995,12 +5182,28 @@ const withRefreshQuery = (key, config) => {
             const retryInMs = retryScheduledIn(executeRefresh('scheduled'));
             return retryInMs === null || attemptsLeft <= 0 ? EMPTY : scheduledRefresh(retryInMs, attemptsLeft - 1);
         }));
+        // A backgrounded tab's `timer()` does not fire on time - the browser throttles it, and a frozen
+        // page stops running it altogether while keeping the Web Lock that makes it the leader. So the
+        // schedule is recomputed whenever the page becomes visible again: an overdue token resolves to a
+        // delay of 0 and refreshes immediately, instead of waiting for a secure query to 401.
+        const foregroundEpoch = signal(0, /* @ts-ignore */
+        ...(ngDevMode ? [{ debugName: "foregroundEpoch" }] : /* istanbul ignore next */ []));
+        if (typeof document !== 'undefined') {
+            fromEvent(document, 'visibilitychange')
+                .pipe(takeUntilDestroyed(destroyRef))
+                .subscribe(() => {
+                if (document.visibilityState !== 'visible')
+                    return;
+                foregroundEpoch.update((epoch) => epoch + 1);
+            });
+        }
         // The delay is read in a computed rather than in the `switchMap` so that a devtools-armed token
         // lifetime re-arms the schedule: the override is a signal, and only a reactive read of it moves the
         // timer before the next token arrives. The wrapper object keeps every recomputation an emission, so
         // two tokens that happen to be due at the same moment still restart the timer.
         const nextScheduledRefresh = computed(() => {
             const token = context.accessToken();
+            foregroundEpoch();
             return { dueInMs: token ? scheduledRefreshDelay(token) : null };
         }, /* @ts-ignore */
         ...(ngDevMode ? [{ debugName: "nextScheduledRefresh" }] : /* istanbul ignore next */ []));
@@ -5028,6 +5231,7 @@ const withRefreshQuery = (key, config) => {
             context.repository.events$.pipe(takeUntilDestroyed()).subscribe((event) => {
                 if (event.type === 'request-success' && event.isSecure) {
                     unauthorizedRefreshStreak = 0;
+                    delegatedRefreshAttempts = 0;
                     return;
                 }
                 if (event.type !== 'request-error' || !event.isSecure || event.error?.status !== 401)
@@ -5061,6 +5265,23 @@ const withRefreshQuery = (key, config) => {
     };
 };
 
+/**
+ * Ends the session once the user has been inactive for {@link InactivityLogoutConfig.inactivityTimeout},
+ * with `sessionEndCause` reporting `'inactivity'`.
+ *
+ * Idleness is a property of the session, not of a tab: with `withBearerAuthMultiTabSync` on, tabs tell
+ * each other about activity, so the tab the user is typing in keeps the forgotten one from logging
+ * everybody out. Without it - or with `syncLogout: false`, where a logout stays in the tab that
+ * decided it - each tab times out on its own.
+ *
+ * @example
+ * export const AUTH_PROVIDER = createBearerAuthProvider({
+ *   name: 'my-auth',
+ *   queryClientRef: MY_CLIENT,
+ *   queries: [loginQuery, refreshQuery],
+ *   features: [withBearerAuthMultiTabSync(), withInactivityLogout({ inactivityTimeout: 5 * 60 * 1000 })],
+ * });
+ */
 const withInactivityLogout = (config = {}) => {
     return (context) => {
         const inactivityTimeout = config.inactivityTimeout ?? 15 * 60 * 1000;
@@ -5071,8 +5292,25 @@ const withInactivityLogout = (config = {}) => {
         ...(ngDevMode ? [{ debugName: "enabled" }] : /* istanbul ignore next */ []));
         const lastActivityTime = signal(Date.now(), /* @ts-ignore */
         ...(ngDevMode ? [{ debugName: "lastActivityTime" }] : /* istanbul ignore next */ []));
+        const activityCoordination = context.activityCoordination;
+        // Announcing every throttled event would wake every other tab once a second for as long as the
+        // user scrolls. A quarter of the timeout is far more than the other tabs need to never expire,
+        // and it is one message per several minutes at the default.
+        const announceInterval = inactivityTimeout / 4;
+        let lastAnnouncedAt = 0;
+        const markActive = () => lastActivityTime.set(Date.now());
+        const announceActivity = () => {
+            if (!activityCoordination)
+                return;
+            const now = Date.now();
+            if (now - lastAnnouncedAt < announceInterval)
+                return;
+            lastAnnouncedAt = now;
+            activityCoordination.announce();
+        };
         const resetTimer = () => {
-            lastActivityTime.set(Date.now());
+            markActive();
+            announceActivity();
         };
         const activityFromEvents$ = merge(...activityEvents.map((event) => fromEvent(document, event))).pipe(throttleTime(1000));
         const activityFromCustomCheck$ = config.customActivityCheck
@@ -5084,15 +5322,35 @@ const withInactivityLogout = (config = {}) => {
                 resetTimer();
             }
         });
-        const inactivityLogout$ = activity$.pipe(switchMap(() => timer(inactivityTimeout)), filter(() => enabled() && !!context.accessToken()));
+        // Activity from another tab is never announced onwards - two tabs would echo one keystroke back
+        // and forth for as long as they are both open.
+        const remoteActivitySubscription = activityCoordination?.activity$.subscribe(() => {
+            if (enabled() && context.accessToken()) {
+                markActive();
+            }
+        });
+        const isIdle = () => Date.now() - lastActivityTime() >= inactivityTimeout;
+        // Driven off `lastActivityTime` rather than off the activity stream, so the countdown this feature
+        // reports and the logout it performs cannot disagree: a tab that has seen no event still has a
+        // deadline, and `resetTimer()` postpones the logout it says it resets.
+        //
+        // `isIdle` re-checks at the moment the deadline fires, because the re-arm goes through an effect:
+        // activity recorded in the same tick as the old deadline has not moved it yet. The write that was
+        // missed is what schedules that re-arm, so nothing is dropped by waiting for it.
+        const inactivityLogout$ = toObservable(lastActivityTime).pipe(switchMap((last) => timer(last + inactivityTimeout - Date.now())), filter(() => enabled() && !!context.accessToken() && isIdle()));
         const logoutSubscription = inactivityLogout$.subscribe(() => {
             context.logout('inactivity');
         });
+        let hadToken = false;
+        // Only the start of a session counts as activity. A token _refresh_ is the app working, not the
+        // user, and resetting on one would mean an app that refreshes faster than this timeout never logs
+        // an idle user out at all.
         effect(() => {
-            const token = context.accessToken();
-            if (token && enabled()) {
-                resetTimer();
+            const hasToken = !!context.accessToken();
+            if (hasToken && !hadToken) {
+                markActive();
             }
+            hadToken = hasToken;
         });
         const enable = () => {
             enabled.set(true);
@@ -5109,9 +5367,9 @@ const withInactivityLogout = (config = {}) => {
             const remaining = inactivityTimeout - elapsed;
             return remaining > 0 ? remaining : 0;
         };
-        resetTimer();
         destroyRef.onDestroy(() => {
             activitySubscription.unsubscribe();
+            remoteActivitySubscription?.unsubscribe();
             logoutSubscription.unsubscribe();
         });
         const instance = {
@@ -5127,6 +5385,7 @@ const withInactivityLogout = (config = {}) => {
             devtools: () => [
                 { label: 'timeout', value: formatQueryDevtoolsDuration(inactivityTimeout) },
                 { label: 'activity events', value: activityEvents.join(', ') },
+                { label: 'idleness', value: activityCoordination ? 'shared across tabs' : 'this tab only' },
                 ...(config.customActivityCheck ? [{ label: 'custom activity check', value: 'yes' }] : []),
             ],
         };
@@ -5331,6 +5590,12 @@ const resetEncryptionKey = () => {
  * through. A message without one comes from a tab running an older version.
  */
 const incomingCause = (cause) => !cause || cause === 'user' ? 'otherTab' : cause;
+/**
+ * The bounded wait a joining tab gives the leader to send the live session over. Short enough to be
+ * invisible in front of the network request it defers, long enough for a same-origin channel message
+ * plus the answer to come back.
+ */
+const sessionAdoptionTimeoutMs = 250;
 /**
  * The channel a provider syncs on unless the consumer names one. Carries the provider's name, so two
  * providers reachable from the same origin do not push each other's tokens around.
@@ -5360,8 +5625,32 @@ const setupMultiTabSync = (config, context) => {
     // broadcasting effects below run after it, so they would always see it cleared.
     let lastSyncedState = null;
     let hadTokens = false;
+    let isAdoptionPending = false;
+    let settleAdoption = () => {
+        /* replaced below when the handshake actually runs */
+    };
+    const remoteActivity = new Subject();
     channel.onmessage = (event) => {
         const message = event.data;
+        if (message.type === 'activity') {
+            if (syncLogout)
+                remoteActivity.next();
+            return;
+        }
+        if (message.type === 'state-request') {
+            if (!syncTokens || !context.isLeader())
+                return;
+            const access = context.accessToken();
+            const refresh = context.refreshToken();
+            if (!access || !refresh)
+                return;
+            channel.postMessage({
+                type: 'tokens-updated',
+                accessToken: encryptToken(access),
+                refreshToken: encryptToken(refresh),
+            });
+            return;
+        }
         if (message.type === 'logout' && syncLogout) {
             lastSyncedState = LOGGED_OUT;
             hadTokens = false;
@@ -5377,11 +5666,34 @@ const setupMultiTabSync = (config, context) => {
         lastSyncedState = tokenState(access, refresh);
         hadTokens = true;
         context.applyTokens(access, refresh);
+        settleAdoption();
     };
+    let adoptionTimeout;
     const cleanup = () => {
+        clearTimeout(adoptionTimeout);
+        settleAdoption();
+        remoteActivity.complete();
         channel.close();
     };
     destroyRef.onDestroy(cleanup);
+    // Sync is push-only otherwise: a tab only broadcasts tokens that just changed, so a tab joining a
+    // live session would hear nothing and start its own login. Asking is the missing half.
+    const sessionAdoption = syncTokens
+        ? (() => {
+            isAdoptionPending = true;
+            const settled = new Promise((resolve) => {
+                settleAdoption = () => {
+                    if (!isAdoptionPending)
+                        return;
+                    isAdoptionPending = false;
+                    resolve();
+                };
+            });
+            adoptionTimeout = setTimeout(settleAdoption, sessionAdoptionTimeoutMs);
+            channel.postMessage({ type: 'state-request' });
+            return { isPending: () => isAdoptionPending, settled };
+        })()
+        : undefined;
     if (syncTokens) {
         effect(() => {
             const access = context.accessToken();
@@ -5417,7 +5729,15 @@ const setupMultiTabSync = (config, context) => {
             channel.postMessage(message);
         });
     }
-    return { cleanup };
+    // Only where a logout travels: with `syncLogout: false` each tab already ends its own session and
+    // nothing else's, so its idleness is genuinely its own.
+    const activityCoordination = syncLogout
+        ? {
+            announce: () => channel.postMessage({ type: 'activity' }),
+            activity$: remoteActivity.asObservable(),
+        }
+        : undefined;
+    return { cleanup, sessionAdoption, activityCoordination };
 };
 
 const SINGLE_TAB = /* @__PURE__ */ (() => {
@@ -5466,17 +5786,24 @@ const withBearerAuthMultiTabSync = (config = {}) => {
     // regular feature setup runs - so this half has to happen earlier than `setup`.
     const earlySetup = (context) => {
         channelName = config.channelName ?? defaultSyncChannelName(context.name);
-        setupMultiTabSync({ channelName, syncTokens: config.syncTokens, syncLogout: config.syncLogout }, {
+        // Filled in below once the election exists. Until then this tab answers as its own leader, which
+        // is what it is: the sync is set up first because the auth queries read `isLeader` while being
+        // wired, and a `state-request` cannot arrive before this function returns anyway.
+        let isLeaderRef = () => true;
+        const sync = setupMultiTabSync({ channelName, syncTokens: config.syncTokens, syncLogout: config.syncLogout }, {
             accessToken: context.accessToken,
             refreshToken: context.refreshToken,
             sessionEndCause: context.sessionEndCause,
             name: context.name,
+            isLeader: () => isLeaderRef(),
             applyTokens: context.applyTokens,
             logout: context.logout,
         });
-        if (config.leaderElection === false)
-            return {};
+        if (config.leaderElection === false) {
+            return { sessionAdoption: sync.sessionAdoption, activityCoordination: sync.activityCoordination };
+        }
         const election = setupLeaderElection({ name: context.name });
+        isLeaderRef = () => election.isLeader();
         instance = {
             isLeader: election.isLeader,
             instanceCount: election.instanceCount,
@@ -5486,6 +5813,8 @@ const withBearerAuthMultiTabSync = (config = {}) => {
             isLeader: () => election.isLeader(),
             leaderElection: instance,
             refreshCoordination: { request: election.requestRefresh, requests$: election.refreshRequests$ },
+            sessionAdoption: sync.sessionAdoption,
+            activityCoordination: sync.activityCoordination,
         };
     };
     return Object.assign(setup, { earlySetup });
@@ -5560,6 +5889,14 @@ const createPersistentAuthFeature = (config, context) => {
         if (wasRejected)
             removeCookie();
     });
+    const exchangeCookie = () => {
+        const storedToken = getCookie(cookieName);
+        if (!storedToken)
+            return;
+        const decryptedToken = decryptToken(storedToken);
+        const args = config.autoLogin.buildArgs(decryptedToken);
+        context.queries[config.autoLogin.queryKey].execute(args, { triggeredBy: 'persistent-auth' });
+    };
     const tryLogin = () => {
         const currentRoute = route();
         const excludeRoutes = config.autoLogin.excludeRoutes ?? [];
@@ -5570,12 +5907,24 @@ const createPersistentAuthFeature = (config, context) => {
         if (config.autoLogin.shouldAutoLogin && !config.autoLogin.shouldAutoLogin(currentRoute)) {
             return;
         }
-        const storedToken = getCookie(cookieName);
-        if (storedToken) {
-            const decryptedToken = decryptToken(storedToken);
-            const args = config.autoLogin.buildArgs(decryptedToken);
-            context.queries[config.autoLogin.queryKey].execute(args, { triggeredBy: 'persistent-auth' });
+        // A session is already here - synced in from another tab, or restored by a previous call. Spending
+        // the cookie now would rotate a refresh token every other tab is holding, for nothing.
+        if (refreshToken())
+            return;
+        const adoption = context.sessionAdoption;
+        // With multi-tab sync on, another tab may be about to hand this one its live session. Wait for
+        // that answer before exchanging the cookie - bounded, so a lone tab is not held up by a reply
+        // that is never coming - and only when there is a cookie to spend, so a tab with nothing to
+        // restore still starts up synchronously.
+        if (adoption?.isPending() && getCookie(cookieName)) {
+            void adoption.settled.then(() => {
+                if (refreshToken())
+                    return;
+                exchangeCookie();
+            });
+            return;
         }
+        exchangeCookie();
     };
     const setRememberMe = (enabled) => {
         if (typeof localStorage !== 'undefined') {
@@ -7097,7 +7446,7 @@ const armQueryDevtoolsOverrideTransfer = (recorder, ops) => {
 
 // Generated from package.json by tools/scripts/generate-version.js - do not edit.
 /** The version of `@ethlete/query` this build was cut from. */
-const QUERY_VERSION = '6.0.0-next.34';
+const QUERY_VERSION = '6.0.0-next.35';
 
 /** How deep a schema is expanded before a nested branch is given up on. */
 const MAX_DEPTH = 12;
@@ -13839,5 +14188,5 @@ const createWebSocketClient = (options) => {
  * Generated bundle index. Do not edit.
  */
 
-export { BasicAuthProvider, BearerAuthFeatureType, BooleanArrayQueryField, CLEAR_QUERY_ARGS, CustomHeaderAuthProvider, DEFAULT_KEEP_UNUSED_FOR, DEFAULT_QUERY_PERSISTENCE_MAX_AGE, DEFAULT_QUERY_PERSISTENCE_MAX_ENTRIES, DEFAULT_QUERY_PERSISTENCE_VERSION, DEFAULT_QUERY_PERSISTENCE_WRITE_DELAY, DateArrayQueryField, DateQueryField, EMPTY_QUERY_DEVTOOLS_FAULT, EntityStore, IGNORED_FILTER_COUNT_FIELDS, INFINITY_QUERY_TOKEN, InfinityQuery, InfinityQueryDirective, InfinityQueryTriggerDirective, LegacyQuery, LegacyQueryCreator, MAX_QUERY_DEVTOOLS_TOMBSTONES, MAX_UNUSED_ENTRIES, NumberArrayQueryField, ParseHttpErrorCodeToMessageDePipe, ParseHttpErrorCodeToMessageEnPipe, ParseHttpErrorCodeToTitleDePipe, ParseHttpErrorCodeToTitleEnPipe, QUERY_CLIENT_DEVTOOLS_TOKEN, QUERY_DEVTOOLS_FAULT_STATUSES, QUERY_DEVTOOLS_TOKEN_TTL_LIMIT, QUERY_PERSISTENCE_STORE_VERSION, QUERY_SYNC_PROTOCOL_VERSION, QUERY_VERSION, QueryClientFeatureType, QueryDevtoolsComponent, QueryDirective, QueryFeatureType, QueryField, QueryForm, QueryRuntimeErrorCode, QueryShortNamePipe, QueryStore, SERVER_ERROR_KIND, SERVER_VIOLATION_ERROR_KIND, SPEED_BUFFER_TIME_IN_MS, SearchQueryField, SortQueryField, StringArrayQueryField, V2BearerAuthProvider, V2Query, V2QueryClient, V2QueryCreator, addQueryContainerHandling, applyQueryDevtoolsOverrides, applyQueryDevtoolsTokenTtl, applyQueryFeatures, armAllQueryDevtoolsMocks, armQueryDevtoolsMock, armQueryDevtoolsOverrideTransfer, authExtractTokensResponseMissingAccessToken, authExtractTokensResponseMissingRefreshToken, authExtractTokensResponseNotObject, authProviderFeatureUsedMultipleTimes, booleanArrayQueryField, buildQueryCacheKey, buildQueryString, buildRoute, buildTimestampFromSeconds, canOverrideQueryDevtoolsTokenTtl, castQueryCreatorTypes, circularQueryDependency, circularQueryDependencyChecker, clearQueryDevtoolsArmedMocks, clearQueryDevtoolsFaults, clearQueryDevtoolsMockStore, clearQueryDevtoolsOverrideStore, clearQueryDevtoolsStore, clearQueryDevtoolsTokenTtl, clearQueryDevtoolsTombstones, clearRestoredQueryDevtoolsOverrides, collectLeafPaths, collectQueryDevtoolsSchemaComponents, collectQueryFormLinks, computeQueryAuthHeader, computeQueryBody, computeQueryHeaders, computeQueryMethod, computeQueryQueryParams, consumeSuppressQueryStackDevtools, contentfulGqlLikePaginationAdapter, countUnresolvedQueryDevtoolsOverrides, createAuthGuard, createBaseQuery, createBaseQueryCreator, createBearerAuthProvider, createDeleteQuery, createExecuteFn, createGetQuery, createGqlExecuteFn, createGqlMutationViaGet, createGqlMutationViaPost, createGqlQuery, createGqlQueryCreator, createGqlQueryViaGet, createGqlQueryViaPost, createHttpRequest, createIndexedDbQueryPersistenceAdapter, createInfinityQueryConfig, createLegacyQueryCreator, createNoopQueryPersistenceAdapter, createPagedQueryStack, createPatchQuery, createPersistentAuthFeature, createPostQuery, createPutQuery, createQuery, createQueryClient, createQueryCollection, createQueryCollectionSignal, createQueryCollectionSubject, createQueryContext, createQueryCreator, createQueryDevtoolsFormLinks, createQueryDevtoolsFormLinksRecorder, createQueryDevtoolsOverrides, createQueryDevtoolsOverridesRecorder, createQueryDevtoolsStats, createQueryDevtoolsStatsRecorder, createQueryErrorResponse, createQueryFeature, createQueryInvalidationFilter, createQueryKeyLockManager, createQueryObject, createQueryPersistenceEngine, createQueryRepository, createQuerySnapshotFn, createQueryStack, createQuerySyncEngine, createQuerySyncTransport, createSecureDeleteQuery, createSecureExecuteFactory, createSecureExecuteFn, createSecureGetQuery, createSecureGqlExecuteFn, createSecureGqlMutationViaGet, createSecureGqlMutationViaPost, createSecureGqlQuery, createSecureGqlQueryCreator, createSecureGqlQueryViaGet, createSecureGqlQueryViaPost, createSecurePatchQuery, createSecurePostQuery, createSecurePutQuery, createSecureQuery, createSecureQueryCreator, createTrackingFeature, createWebSocketClient, dateArrayQueryField, dateQueryField, decryptBearer, deepFreeze, def, defineQueryForm, deleteQueryDevtoolsMock, describeQueryDevtoolsFeatures, detectContentTypeHeader, detectPaginationShape, dynLikePaginationAdapter, effectComputed, emptyQueryArgs, ethletePaginationAdapter, executeUntilSettled, extractExpiresInSeconds, extractFormViolations, extractHtmlErrorMessage, extractQuery, fakePaginationAdapter, filterFailure, filterNull, filterQueryStates, filterSuccess, forEachHeader, formatQueryDevtoolsDuration, generateQueryDevtoolsNumberPreset, generateQueryDevtoolsStringPreset, getBearerAuthProviderName, getDefaultHeaders, getQueryClientName, getQueryFeatureUsage, getResponseUrl, ggLikePaginationAdapter, gql, gqlDataPropertyMissingInResponse, hasHeader, hasQueryDevtoolsOverridesAtPath, htmlErrorPayload, htmlQueryErrorParser, ignoreAutoRefresh, initQueryDevtoolsFaults, initQueryDevtoolsMocks, initQueryDevtoolsOverridePersistence, initQueryDevtoolsSettings, injectInfinityQueryResponseDelay, injectQueryContext, insertFrom, invalidBaseRouteError, invalidBodyError, invalidRouteError, invalidStateInsideSecureExecuteFactory, isAutoRefresh, isBasicAuthProvider, isBearerAuthProvider, isClassValidatorError, isCreateGqlQueryOptions, isCustomHeaderAuthProvider, isDateShapedLeaf, isEmptyString, isGqlQueryConfig, isHtmlErrorPayload, isLegacyQuery, isNaN$1 as isNaN, isPageOutOfRangeError, isQuery, isQueryCollection, isQueryDevtoolsEnabled, isQueryDevtoolsFaultArmed, isQueryDevtoolsRequestInterceptionEnabled, isQueryErrorResponse, isQueryStateCancelled, isQueryStateFailure, isQueryStateLoading, isQueryStatePrepared, isQueryStateSuccess, isRequestError, isSymfonyError, isSymfonyFormViolationListError, isSymfonyListError, isSymfonyPagerfantaOutOfRangeError, isUnderInvalidatedUrl, legacyPrepareFallbackInjector, legacyPrepareWithoutInjectionContext, loadQueryDevtoolsSchema, mapToPaginated, mapViolationsToFormErrors, matchesQueryDevtoolsMockPattern, matchesQueryDevtoolsMockQuery, maybeExecute, measureQueryDevtoolsPayload, mergeHeaders, nestedEffect, noteQueryFormRead, numberArrayQueryField, pagedQueryStackNextPageCalledWithoutPreviousPage, pagedQueryStackPageBiggerThanTotalPages, pagedQueryStackPreviousPageCalledButAlreadyAtFirstPage, paginatedEntityValueUpdater, parseAllXhrResponseHeaders, parseHttpErrorCodeToMessageDe, parseHttpErrorCodeToMessageEn, parseHttpErrorCodeToTitleDe, parseHttpErrorCodeToTitleEn, parseQueryDevtoolsOverrideTransfer, parseQueryRoute, patchQueryDevtoolsTokenPayload, pathParamsMissingInRouteFunctionError, provideInfinityQueryResponseDelay, provideLegacyPrepareFallback, provideQueryClientForDevtools, provideQueryDevtools, queryArrayComputed, queryClientFeatureUsedMultipleTimes, queryComputed, queryComputedTillTruthy, queryDevtoolsAbout, queryDevtoolsArmedMocks, queryDevtoolsArmedMocksRestored, queryDevtoolsEntries, queryDevtoolsFaults, queryDevtoolsFaultsRestored, queryDevtoolsFnDetail, queryDevtoolsMockId, queryDevtoolsMocks, queryDevtoolsOverridePersistence, queryDevtoolsRequestPath, queryDevtoolsResponseHistory, queryDevtoolsRestoredOverridesScope, queryDevtoolsSchemaNames, queryDevtoolsSchemaRoutes, queryDevtoolsSchemaState, queryDevtoolsSettings, queryDevtoolsStorage, queryDevtoolsTokenTtls, queryErrorMessage, queryErrorMessages, queryExecute, queryFeatureUsedMultipleTimes, queryField, querySequence, querySequenceAlreadyRunning, queryStackTotalQueriesAndExpectedQueriesMismatch, queryStackWithArgsUsed, queryStackWithResponseUpdateUsed, queryStateAlreadyHasKeyError, queryStateCannotTransformError, queryStateDoesNotContainKeyError, queryStateErrorSignal, queryStateLoadingSignal, queryStateResponseSignal, queryStateSignal, readQueryDevtoolsStore, registerEthleteVersion, registerQueryDevtoolsEntry, registerQueryErrorParser, removeFrom, request, resetExecuteState, resetPageOnError, resolveInvalidationUrl, resolveQueryDevtoolsFault, resolveQueryDevtoolsFaultForAttempt, resolveQueryDevtoolsMock, resolveQueryDevtoolsMockForAttempt, restoredQueryDevtoolsOverrides, runDefaultQueryRetry, runQueryErrorParsers, saveQueryDevtoolsMock, searchQueryField, seedQueryDevtoolsSchemaBody, seedQueryDevtoolsSchemaRoute, serializeBody, serializeQueryDevtoolsOverrideTransfer, setDefaultQueryRetryFn, setQueryDevtoolsAppInfo, setQueryDevtoolsArmedMocksScope, setQueryDevtoolsFault, setQueryDevtoolsFaultResolver, setQueryDevtoolsFaultsScope, setQueryDevtoolsFormLinksFactory, setQueryDevtoolsMockResolver, setQueryDevtoolsOverridePersistence, setQueryDevtoolsOverridesFactory, setQueryDevtoolsOverridesScope, setQueryDevtoolsRegistrar, setQueryDevtoolsResponseHistory, setQueryDevtoolsSchemaLoader, setQueryDevtoolsSettings, setQueryDevtoolsStatsFactory, setQueryDevtoolsTokenPayloadPatcher, setQueryDevtoolsTokenTtl, setupQueryDependencies, setupQueryExecuteState, setupQueryState, shouldAutoExecuteGqlQuery, shouldAutoExecuteQuery, shouldCacheQuery, shouldRetryRequest, silenceMissingWithArgsFeatureErrorUsedButWithArgsPresent, skipPaginationPageParamCalculator, smartDuplicateArrayItem, snapshotQueryDevtoolsHandle, sortQueryField, splitQueryConfig, stringArrayQueryField, stringifyQueryRouteParts, sumQueryDevtoolsStats, suppressNextQueryStackDevtools, switchQueryCollectionState, switchQueryState, symfonyQueryErrorParser, takeUntilResponse, toQuerySignal, toQuerySubject, tokensNotAvailableInsideAuthAndExec, tombstoneOf, transformArrayResponse, transformExecStateToQueryState, transformGql, transformMethod, transformPaginatedResponse, transformToBoolean, transformToBooleanArray, transformToDate, transformToDateArray, transformToNumber, transformToNumberArray, transformToSort, transformToSortQueryParam, transformToString, transformToStringArray, uncacheableRequestHasAllowCacheParam, uncacheableRequestHasCacheKeyParam, unwrapQuerySyncMessage, v2BuildQueryCacheKey, v2ExtractExpiresInSeconds, v2ShouldCacheQuery, v2ShouldRetryRequest, validateWithQuery, validateWithV2Query, withArgs, withArgsQueryFeatureMissingButRouteIsFunction, withAuthenticationQuery, withAutoRefresh, withAutoRefreshUsedInManualQuery, withAutoRefreshUsedOnUnsupportedHttpMethod, withBearerAuthMultiTabSync, withDefaultRetry, withErrorHandling, withEthleteApiErrors, withHtmlErrorParsing, withInactivityLogout, withLogging, withMultiTabSync, withPageResetOnError, withPersistentAuth, withPolling, withPollingUsedOnUnsupportedHttpMethod, withQueryDevtoolsOverridePersistence, withQueryPersistence, withRefreshQuery, withResponseUpdate, withSuccessHandling, withSymfonyErrors, withTokenExpirationWarning, withTokenRevocation, withTracking, wrapAsObservableSignal, wrapQuerySyncMessage, writeQueryDevtoolsStore };
+export { BasicAuthProvider, BearerAuthFeatureType, BooleanArrayQueryField, CustomHeaderAuthProvider, DEFAULT_KEEP_UNUSED_FOR, DEFAULT_QUERY_PERSISTENCE_MAX_AGE, DEFAULT_QUERY_PERSISTENCE_MAX_ENTRIES, DEFAULT_QUERY_PERSISTENCE_VERSION, DEFAULT_QUERY_PERSISTENCE_WRITE_DELAY, DateArrayQueryField, DateQueryField, EMPTY_QUERY_DEVTOOLS_FAULT, EntityStore, IGNORED_FILTER_COUNT_FIELDS, INFINITY_QUERY_TOKEN, InfinityQuery, InfinityQueryDirective, InfinityQueryTriggerDirective, LegacyQuery, LegacyQueryCreator, MAX_QUERY_DEVTOOLS_TOMBSTONES, MAX_UNUSED_ENTRIES, NumberArrayQueryField, ParseHttpErrorCodeToMessageDePipe, ParseHttpErrorCodeToMessageEnPipe, ParseHttpErrorCodeToTitleDePipe, ParseHttpErrorCodeToTitleEnPipe, QUERY_CLIENT_DEVTOOLS_TOKEN, QUERY_DEVTOOLS_FAULT_STATUSES, QUERY_DEVTOOLS_TOKEN_TTL_LIMIT, QUERY_PERSISTENCE_STORE_VERSION, QUERY_SYNC_PROTOCOL_VERSION, QUERY_VERSION, QueryClientFeatureType, QueryDevtoolsComponent, QueryDirective, QueryFeatureType, QueryField, QueryForm, QueryRuntimeErrorCode, QueryShortNamePipe, QueryStore, SERVER_ERROR_KIND, SERVER_VIOLATION_ERROR_KIND, SPEED_BUFFER_TIME_IN_MS, SearchQueryField, SortQueryField, StringArrayQueryField, V2BearerAuthProvider, V2Query, V2QueryClient, V2QueryCreator, addQueryContainerHandling, applyQueryDevtoolsOverrides, applyQueryDevtoolsTokenTtl, applyQueryFeatures, armAllQueryDevtoolsMocks, armQueryDevtoolsMock, armQueryDevtoolsOverrideTransfer, authExtractTokensResponseMissingAccessToken, authExtractTokensResponseMissingRefreshToken, authExtractTokensResponseNotObject, authProviderFeatureUsedMultipleTimes, booleanArrayQueryField, buildQueryCacheKey, buildQueryString, buildRoute, buildTimestampFromSeconds, canOverrideQueryDevtoolsTokenTtl, castQueryCreatorTypes, circularQueryDependency, circularQueryDependencyChecker, clearQueryDevtoolsArmedMocks, clearQueryDevtoolsFaults, clearQueryDevtoolsMockStore, clearQueryDevtoolsOverrideStore, clearQueryDevtoolsStore, clearQueryDevtoolsTokenTtl, clearQueryDevtoolsTombstones, clearRestoredQueryDevtoolsOverrides, collectLeafPaths, collectQueryDevtoolsSchemaComponents, collectQueryFormLinks, computeQueryAuthHeader, computeQueryBody, computeQueryHeaders, computeQueryMethod, computeQueryQueryParams, consumeSuppressQueryStackDevtools, contentfulGqlLikePaginationAdapter, countUnresolvedQueryDevtoolsOverrides, createAuthGuard, createBaseQuery, createBaseQueryCreator, createBearerAuthProvider, createDefaultRetryFn, createDeleteQuery, createExecuteFn, createGetQuery, createGqlExecuteFn, createGqlMutationViaGet, createGqlMutationViaPost, createGqlQuery, createGqlQueryCreator, createGqlQueryViaGet, createGqlQueryViaPost, createHttpRequest, createIndexedDbQueryPersistenceAdapter, createInfinityQueryConfig, createLegacyQueryCreator, createNoopQueryPersistenceAdapter, createPagedQueryStack, createPatchQuery, createPersistentAuthFeature, createPostQuery, createPutQuery, createQuery, createQueryClient, createQueryCollection, createQueryCollectionSignal, createQueryCollectionSubject, createQueryContext, createQueryCreator, createQueryDevtoolsFormLinks, createQueryDevtoolsFormLinksRecorder, createQueryDevtoolsOverrides, createQueryDevtoolsOverridesRecorder, createQueryDevtoolsStats, createQueryDevtoolsStatsRecorder, createQueryErrorResponse, createQueryFeature, createQueryInvalidationFilter, createQueryKeyLockManager, createQueryObject, createQueryPersistenceEngine, createQueryRepository, createQuerySnapshotFn, createQueryStack, createQuerySyncEngine, createQuerySyncTransport, createSecureDeleteQuery, createSecureExecuteFactory, createSecureExecuteFn, createSecureGetQuery, createSecureGqlExecuteFn, createSecureGqlMutationViaGet, createSecureGqlMutationViaPost, createSecureGqlQuery, createSecureGqlQueryCreator, createSecureGqlQueryViaGet, createSecureGqlQueryViaPost, createSecurePatchQuery, createSecurePostQuery, createSecurePutQuery, createSecureQuery, createSecureQueryCreator, createTrackingFeature, createWebSocketClient, dateArrayQueryField, dateQueryField, decryptBearer, deepFreeze, def, defineQueryForm, deleteQueryDevtoolsMock, describeQueryDevtoolsFeatures, detectContentTypeHeader, detectPaginationShape, dynLikePaginationAdapter, effectComputed, emptyQueryArgs, ethletePaginationAdapter, executeUntilSettled, extractExpiresInSeconds, extractFormViolations, extractHtmlErrorMessage, extractQuery, fakePaginationAdapter, filterFailure, filterNull, filterQueryStates, filterSuccess, forEachHeader, formatQueryDevtoolsDuration, generateQueryDevtoolsNumberPreset, generateQueryDevtoolsStringPreset, getBearerAuthProviderName, getDefaultHeaders, getQueryClientName, getQueryFeatureUsage, getResponseUrl, ggLikePaginationAdapter, gql, gqlDataPropertyMissingInResponse, hasHeader, hasQueryDevtoolsOverridesAtPath, htmlErrorPayload, htmlQueryErrorParser, ignoreAutoRefresh, initQueryDevtoolsFaults, initQueryDevtoolsMocks, initQueryDevtoolsOverridePersistence, initQueryDevtoolsSettings, injectInfinityQueryResponseDelay, injectQueryContext, insertFrom, invalidBaseRouteError, invalidBodyError, invalidRouteError, invalidStateInsideSecureExecuteFactory, isAutoRefresh, isBasicAuthProvider, isBearerAuthProvider, isClassValidatorError, isCreateGqlQueryOptions, isCustomHeaderAuthProvider, isDateShapedLeaf, isEmptyString, isGqlQueryConfig, isHtmlErrorPayload, isLegacyQuery, isNaN$1 as isNaN, isPageOutOfRangeError, isQuery, isQueryCollection, isQueryDevtoolsEnabled, isQueryDevtoolsFaultArmed, isQueryDevtoolsRequestInterceptionEnabled, isQueryErrorResponse, isQueryStateCancelled, isQueryStateFailure, isQueryStateLoading, isQueryStatePrepared, isQueryStateSuccess, isRequestError, isSymfonyError, isSymfonyFormViolationListError, isSymfonyListError, isSymfonyPagerfantaOutOfRangeError, isUnderInvalidatedUrl, legacyPrepareFallbackInjector, legacyPrepareWithoutInjectionContext, loadQueryDevtoolsSchema, mapToPaginated, mapViolationsToFormErrors, matchesQueryDevtoolsMockPattern, matchesQueryDevtoolsMockQuery, maybeExecute, measureQueryDevtoolsPayload, mergeHeaders, nestedEffect, noteQueryFormRead, numberArrayQueryField, pagedQueryStackNextPageCalledWithoutPreviousPage, pagedQueryStackPageBiggerThanTotalPages, pagedQueryStackPreviousPageCalledButAlreadyAtFirstPage, paginatedEntityValueUpdater, parseAllXhrResponseHeaders, parseHttpErrorCodeToMessageDe, parseHttpErrorCodeToMessageEn, parseHttpErrorCodeToTitleDe, parseHttpErrorCodeToTitleEn, parseQueryDevtoolsOverrideTransfer, parseQueryRoute, patchQueryDevtoolsTokenPayload, pathParamsMissingInRouteFunctionError, provideInfinityQueryResponseDelay, provideLegacyPrepareFallback, provideQueryClientForDevtools, provideQueryDevtools, queryArrayComputed, queryClientFeatureUsedMultipleTimes, queryComputed, queryComputedTillTruthy, queryDevtoolsAbout, queryDevtoolsArmedMocks, queryDevtoolsArmedMocksRestored, queryDevtoolsEntries, queryDevtoolsFaults, queryDevtoolsFaultsRestored, queryDevtoolsFnDetail, queryDevtoolsMockId, queryDevtoolsMocks, queryDevtoolsOverridePersistence, queryDevtoolsRequestPath, queryDevtoolsResponseHistory, queryDevtoolsRestoredOverridesScope, queryDevtoolsSchemaNames, queryDevtoolsSchemaRoutes, queryDevtoolsSchemaState, queryDevtoolsSettings, queryDevtoolsStorage, queryDevtoolsTokenTtls, queryErrorMessage, queryErrorMessages, queryExecute, queryFeatureUsedMultipleTimes, queryField, querySequence, querySequenceAlreadyRunning, queryStackTotalQueriesAndExpectedQueriesMismatch, queryStackWithArgsUsed, queryStackWithResponseUpdateUsed, queryStateAlreadyHasKeyError, queryStateCannotTransformError, queryStateDoesNotContainKeyError, queryStateErrorSignal, queryStateLoadingSignal, queryStateResponseSignal, queryStateSignal, readQueryDevtoolsStore, registerEthleteVersion, registerQueryDevtoolsEntry, registerQueryErrorParser, removeFrom, request, resetExecuteState, resetPageOnError, resolveInvalidationUrl, resolveQueryDevtoolsFault, resolveQueryDevtoolsFaultForAttempt, resolveQueryDevtoolsMock, resolveQueryDevtoolsMockForAttempt, restoredQueryDevtoolsOverrides, runDefaultQueryRetry, runQueryErrorParsers, saveQueryDevtoolsMock, searchQueryField, seedQueryDevtoolsSchemaBody, seedQueryDevtoolsSchemaRoute, serializeBody, serializeQueryDevtoolsOverrideTransfer, setDefaultQueryRetryFn, setQueryDevtoolsAppInfo, setQueryDevtoolsArmedMocksScope, setQueryDevtoolsFault, setQueryDevtoolsFaultResolver, setQueryDevtoolsFaultsScope, setQueryDevtoolsFormLinksFactory, setQueryDevtoolsMockResolver, setQueryDevtoolsOverridePersistence, setQueryDevtoolsOverridesFactory, setQueryDevtoolsOverridesScope, setQueryDevtoolsRegistrar, setQueryDevtoolsResponseHistory, setQueryDevtoolsSchemaLoader, setQueryDevtoolsSettings, setQueryDevtoolsStatsFactory, setQueryDevtoolsTokenPayloadPatcher, setQueryDevtoolsTokenTtl, setupQueryDependencies, setupQueryExecuteState, setupQueryState, shouldAutoExecuteGqlQuery, shouldAutoExecuteQuery, shouldCacheQuery, shouldRetryRequest, silenceMissingWithArgsFeatureErrorUsedButWithArgsPresent, skipPaginationPageParamCalculator, smartDuplicateArrayItem, snapshotQueryDevtoolsHandle, sortQueryField, splitQueryConfig, stringArrayQueryField, stringifyQueryRouteParts, sumQueryDevtoolsStats, suppressNextQueryStackDevtools, switchQueryCollectionState, switchQueryState, symfonyQueryErrorParser, takeUntilResponse, toQuerySignal, toQuerySubject, tokensNotAvailableInsideAuthAndExec, tombstoneOf, transformArrayResponse, transformExecStateToQueryState, transformGql, transformMethod, transformPaginatedResponse, transformToBoolean, transformToBooleanArray, transformToDate, transformToDateArray, transformToNumber, transformToNumberArray, transformToSort, transformToSortQueryParam, transformToString, transformToStringArray, uncacheableRequestHasAllowCacheParam, uncacheableRequestHasCacheKeyParam, unwrapQuerySyncMessage, v2BuildQueryCacheKey, v2ExtractExpiresInSeconds, v2ShouldCacheQuery, v2ShouldRetryRequest, validateWithQuery, validateWithV2Query, withArgs, withArgsQueryFeatureMissingButRouteIsFunction, withAuthenticationQuery, withAutoRefresh, withAutoRefreshUsedInManualQuery, withAutoRefreshUsedOnUnsupportedHttpMethod, withBearerAuthMultiTabSync, withDefaultRetry, withErrorHandling, withEthleteApiErrors, withHtmlErrorParsing, withInactivityLogout, withLogging, withLongPolling, withLongPollingUsedOnUnsupportedHttpMethod, withLongPollingUsedWithPolling, withMultiTabSync, withPageResetOnError, withPersistentAuth, withPolling, withPollingUsedOnUnsupportedHttpMethod, withQueryDevtoolsOverridePersistence, withQueryPersistence, withRefreshQuery, withResponseUpdate, withSuccessHandling, withSymfonyErrors, withTokenExpirationWarning, withTokenRevocation, withTracking, wrapAsObservableSignal, wrapQuerySyncMessage, writeQueryDevtoolsStore };
 //# sourceMappingURL=ethlete-query.mjs.map