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

package/fesm2022/ethlete-query.mjs

@@ -2,7 +2,7 @@ import * as i0 from '@angular/core';
 import { inject, computed, DestroyRef, InjectionToken, Injector, EnvironmentInjector, ElementRef, ErrorHandler, createEnvironmentInjector, effect, untracked, signal, linkedSignal, runInInjectionContext, isDevMode, PLATFORM_ID, resource, DOCUMENT, VERSION, makeEnvironmentProviders, assertInInjectionContext, provideEnvironmentInitializer, ChangeDetectorRef, ViewContainerRef, TemplateRef, Input, Directive, input, Pipe, ViewEncapsulation, Component, NgZone } from '@angular/core';
 import { toObservable, takeUntilDestroyed, toSignal } from '@angular/core/rxjs-interop';
 import { UrlTree, Router, RedirectCommand, ActivatedRoute } from '@angular/router';
-import { filter, take, map, defer, from, Subject, Subscription, throwError, of, timer, switchMap, tap, retry, catchError, EMPTY, takeWhile, merge, firstValueFrom, concatMap, fromEvent, throttleTime, interval, combineLatest, Observable, takeUntil, startWith, pairwise, BehaviorSubject, ReplaySubject, shareReplay, skip, withLatestFrom, debounceTime } from 'rxjs';
+import { filter, take, map, defer, from, Subject, Subscription, throwError, of, timer, switchMap, tap, retry, catchError, merge, EMPTY, takeWhile, firstValueFrom, concatMap, fromEvent, throttleTime, interval, combineLatest, Observable, takeUntil, startWith, pairwise, BehaviorSubject, ReplaySubject, shareReplay, skip, withLatestFrom, debounceTime } from 'rxjs';
 import { defineStaticProvider, RuntimeError, clamp, randomId, defineRootProvider, isObject, injectUnsavedChangesCoordinator, injectRoute, getCookie, getDomain, deleteCookie, setCookie, CORE_VERSION, createDestroy, computedTillTruthy, defineProvider, toProvideFn, toInjectFn, nextFrame, injectQueryParams, injectQueryParamChanges, clone, equal, ET_PROPERTY_REMOVED, previousSignalValue } from '@ethlete/core';
 import { HttpClient, HttpEventType, HttpErrorResponse, HttpResponse, HttpHeaders, HttpStatusCode } from '@angular/common/http';
 import { getActiveConsumer, setActiveConsumer } from '@angular/core/primitives/signals';
@@ -265,6 +265,24 @@ const resolveQueryDevtoolsMock = (target) => mockResolver?.(target) ?? null;
  * @internal
  */
 const resolveQueryDevtoolsFault = (target) => faultResolver?.(target) ?? null;
+let tokenPayloadPatcher = null;
+/**
+ * Installs the access-token payload patcher. Called by `provideQueryDevtools()`; nothing else may call it.
+ * @internal
+ */
+const setQueryDevtoolsTokenPayloadPatcher = (fn) => {
+    tokenPayloadPatcher = fn;
+};
+/**
+ * A decoded access token as the devtools want it seen, which today means with an overridden lifetime
+ * applied. Returns the payload as decoded unless `provideQueryDevtools()` installed a patcher.
+ *
+ * Auth code must reach the override through this rather than importing the registry it lives in: a
+ * static import would pin that module into every bundle that builds an auth provider, and a runtime
+ * guard at the call site does not undo that.
+ * @internal
+ */
+const patchQueryDevtoolsTokenPayload = (options) => (tokenPayloadPatcher ? tokenPayloadPatcher(options) : options.payload);
 let suppressStackRegistration = false;
 /**
  * Suppresses devtools registration for the next {@link createQueryStack} call. Used by
@@ -362,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,
@@ -412,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.`);
 };
@@ -516,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();
@@ -537,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',
@@ -548,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).
  */
@@ -557,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();
@@ -672,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({
@@ -986,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);
@@ -1000,6 +1110,7 @@ options) => {
     }
     const featureFnContext = {
         hasWithArgsFeature,
+        hasPollingFeature,
         shouldAutoExecuteMethod,
         shouldAutoExecute,
         hasRouteFunction,
@@ -1529,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;
@@ -1630,6 +1741,7 @@ const SPEED_BUFFER_TIME_IN_MS = 2000;
 const MOCKED_STATUS_TEXT = 'Served by the query devtools';
 const createHttpRequest = (options) => {
     let currentStreamSubscription = Subscription.EMPTY;
+    let lastSentHeaders;
     const { args, clientOptions, dependencies } = options;
     const currentEvent = signal(null, /* @ts-ignore */
     ...(ngDevMode ? [{ debugName: "currentEvent" }] : /* istanbul ignore next */ []));
@@ -1751,6 +1863,7 @@ const createHttpRequest = (options) => {
     });
     const createStream = () => {
         const headers = resolveHeaders();
+        lastSentHeaders = headers;
         const source$ = isQueryDevtoolsRequestInterceptionEnabled() ? sendWithFaults(headers) : send(headers);
         return source$.pipe(tap((event) => updateState(event)), retry({
             delay: (error, retryCount) => {
@@ -1803,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;
     };
@@ -1923,9 +2043,11 @@ const createHttpRequest = (options) => {
             applyPersistedResponse,
             lastPersistedResponseAt: lastPersistedResponseAt.asReadonly(),
             resolveHeaders,
+            lastSentHeaders: () => lastSentHeaders,
             attempts: attempts.asReadonly(),
             retryState: retryState.asReadonly(),
             lastDurationMs: lastDurationMs.asReadonly(),
+            abort,
         },
     };
     return httpRequest;
@@ -3009,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. */
@@ -3454,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.
@@ -3466,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 };
 };
 /**
@@ -3488,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 };
 };
 
@@ -3512,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;
@@ -3546,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
@@ -3651,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 {
@@ -3863,6 +4008,7 @@ const createSecureExecuteFactory = (options) => {
     let lastExecuteArgs;
     /** The access token the last request went out with - what the 401 retry below compares against. */
     let lastRequestedWithToken = null;
+    const error$ = toObservable(options.state.error, { injector: options.deps.injector });
     const reset = () => {
         authQuerySubscription.unsubscribe();
         authQuerySubscription = Subscription.EMPTY;
@@ -3973,7 +4119,13 @@ const createSecureExecuteFactory = (options) => {
         // another refresh - an endless refresh/retry loop for as long as the server keeps handing out
         // tokens it rejects. A refresh that did not change the access token is therefore not a reason to
         // retry; the subscription stays open, so a later one that does change it still is.
-        tokenRefreshSubscription = options.authProvider.afterTokenRefresh$
+        //
+        // The error landing is a trigger of its own: a refresh can complete before this query's 401 has
+        // even come back (which is also why that 401 must not start another refresh - see
+        // withRefreshQuery's 401 handling), and the refresh emission alone would find no error to act
+        // on. Emissions of the error this execution armed with are not landings, only replays.
+        const errorAtArm = options.state.error();
+        tokenRefreshSubscription = merge(options.authProvider.afterTokenRefresh$, error$.pipe(filter((landedError) => landedError !== errorAtArm)))
             .pipe(filter(() => {
             const currentError = options.state.error();
             return currentError?.code === 401 && options.authProvider.accessToken() !== lastRequestedWithToken;
@@ -4629,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)
@@ -4637,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);
@@ -4655,7 +4811,12 @@ const createBearerAuthProviderImpl = (config) => {
         if (!token)
             return null;
         try {
-            return config.bearerDecryptFn?.(token) ?? decryptBearer(token);
+            const decoded = config.bearerDecryptFn?.(token) ?? decryptBearer(token);
+            return patchQueryDevtoolsTokenPayload({
+                payload: decoded,
+                providerName: config.name,
+                expiresInPropertyName: 'exp',
+            });
         }
         catch (error) {
             if (isDevMode()) {
@@ -4728,6 +4889,7 @@ const createBearerAuthProviderImpl = (config) => {
         sessionEndCause: sessionEndCause.asReadonly(),
     });
     const querySetupContext = {
+        name: config.name,
         accessToken,
         refreshToken,
         bearerDecryptFn: config.bearerDecryptFn,
@@ -4753,6 +4915,8 @@ const createBearerAuthProviderImpl = (config) => {
         setTokens,
         isLeader: isLeader.isLeaderFn,
         leaderElection: isLeader.leaderElectionContext,
+        sessionAdoption: isLeader.sessionAdoption,
+        activityCoordination: isLeader.activityCoordination,
         afterTokenRefresh$,
         queries: queries,
         executionState,
@@ -4761,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,
@@ -4803,11 +4979,25 @@ 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.
  */
 const maxRescheduleAttempts = 5;
+/**
+ * How many 401-driven refreshes may run back to back before they fall back to `minRefreshInterval`.
+ * Every refresh in such a streak means the token the previous one issued was rejected too, so an
+ * unbounded streak is a refresh loop, not recovery. A secure request succeeding ends the streak.
+ */
+const maxUnauthorizedRefreshStreak = 3;
 const withAuthenticationQuery = (key, config, setup) => ({
     _type: 'authQuery',
     key,
@@ -4849,7 +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) => {
@@ -4857,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
@@ -4867,15 +5067,50 @@ 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 {
+                if (unauthorizedRefreshStreak >= maxUnauthorizedRefreshStreak &&
+                    now - lastUnauthorizedRefreshTime < minRefreshInterval) {
+                    return 'throttled';
+                }
+                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
@@ -4890,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;
             }
         };
@@ -4907,7 +5145,12 @@ const withRefreshQuery = (key, config) => {
         /** When this access token is due to be refreshed, or `null` if it cannot be scheduled at all. */
         const scheduledRefreshDelay = (token) => {
             try {
-                const bearerDataValue = context.bearerDecryptFn ? context.bearerDecryptFn(token) : decryptBearer(token);
+                const decoded = context.bearerDecryptFn ? context.bearerDecryptFn(token) : decryptBearer(token);
+                const bearerDataValue = patchQueryDevtoolsTokenPayload({
+                    payload: decoded,
+                    providerName: context.name,
+                    expiresInPropertyName,
+                });
                 const expiresIn = bearerDataValue?.[expiresInPropertyName];
                 if (typeof expiresIn !== 'number') {
                     if (isDevMode()) {
@@ -4939,13 +5182,33 @@ const withRefreshQuery = (key, config) => {
             const retryInMs = retryScheduledIn(executeRefresh('scheduled'));
             return retryInMs === null || attemptsLeft <= 0 ? EMPTY : scheduledRefresh(retryInMs, attemptsLeft - 1);
         }));
-        toObservable(context.accessToken)
-            .pipe(switchMap((token) => {
-            if (!token)
-                return EMPTY;
-            const dueInMs = scheduledRefreshDelay(token);
-            return dueInMs === null ? EMPTY : scheduledRefresh(dueInMs, maxRescheduleAttempts);
-        }), takeUntilDestroyed())
+        // 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 */ []));
+        toObservable(nextScheduledRefresh)
+            .pipe(switchMap(({ dueInMs }) => (dueInMs === null ? EMPTY : scheduledRefresh(dueInMs, maxRescheduleAttempts))), takeUntilDestroyed())
             .subscribe();
         context.refreshCoordination?.requests$.pipe(takeUntilDestroyed()).subscribe(() => executeRefresh('unauthorized'));
         const onRefreshFailure = config.onRefreshFailure ??
@@ -4965,18 +5228,23 @@ const withRefreshQuery = (key, config) => {
         // Auto-retry on 401: Listen to repository events and trigger refresh on 401 errors
         const autoRetryOn401 = config.autoRetryOn401 ?? true;
         if (autoRetryOn401) {
-            context.repository.events$
-                .pipe(filter((event) => {
-                // Only handle 401 errors for secure queries
-                if (event.type !== 'request-error')
-                    return false;
-                if (!event.isSecure)
-                    return false;
-                if (event.error?.status !== 401)
-                    return false;
-                return true;
-            }), takeUntilDestroyed())
-                .subscribe(() => {
+            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)
+                    return;
+                // A 401 from a request that went out with an older access token asks for a refresh that
+                // already happened - the query re-runs itself with the current token (see
+                // createSecureExecuteFactory). Refreshing again here would spend the refresh token that
+                // pair came with, invalidating the tokens every other in-flight request is using; their
+                // 401s would each do the same, keeping the loop alive for as long as queries are in flight.
+                const sentAuthorization = event.request.subtle.lastSentHeaders()?.get('Authorization');
+                const currentToken = context.accessToken();
+                if (sentAuthorization && currentToken && sentAuthorization !== `Bearer ${currentToken}`)
+                    return;
                 executeRefresh('unauthorized');
             });
         }
@@ -4997,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;
@@ -5007,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
@@ -5020,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);
@@ -5045,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 = {
@@ -5063,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' }] : []),
             ],
         };
@@ -5267,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.
@@ -5296,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;
@@ -5313,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();
@@ -5353,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__ */ (() => {
@@ -5402,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,
@@ -5422,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 });
@@ -5496,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 ?? [];
@@ -5506,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') {
@@ -5811,124 +6224,13 @@ const queryDevtoolsAbout = () => ({
     app,
 });
 
-/** The neutral fault: nothing armed. */
-const EMPTY_QUERY_DEVTOOLS_FAULT = {
-    latencyMs: 0,
-    failNext: 0,
-    failRate: 0,
-    status: 503,
-};
-/**
- * Statuses worth injecting, and whether the SDK's default retry policy retries them. A picker built from
- * this cannot arm a 500 and then leave you wondering why no retry fired.
- * @see runDefaultQueryRetry
- */
-const QUERY_DEVTOOLS_FAULT_STATUSES = [
-    { status: 0, label: 'Network error', retryable: true },
-    { status: 400, label: 'Bad Request', retryable: false },
-    { status: 401, label: 'Unauthorized', retryable: false },
-    { status: 403, label: 'Forbidden', retryable: false },
-    { status: 404, label: 'Not Found', retryable: false },
-    { status: 408, label: 'Request Timeout', retryable: true },
-    { status: 429, label: 'Too Many Requests', retryable: true },
-    { status: 500, label: 'Internal Server Error', retryable: false },
-    { status: 502, label: 'Bad Gateway', retryable: true },
-    { status: 503, label: 'Service Unavailable', retryable: true },
-];
-const faults = /* @__PURE__ */ signal({}, /* @ts-ignore */
-...(ngDevMode ? [{ debugName: "faults" }] : /* istanbul ignore next */ []));
-/**
- * The faults armed per client name, consumed by the `<et-query-devtools>` UI. Clients with nothing armed
- * are absent rather than present with an {@link EMPTY_QUERY_DEVTOOLS_FAULT}.
- */
-const queryDevtoolsFaults = /* @__PURE__ */ faults.asReadonly();
-/** Whether anything at all is armed on a fault. */
-const isQueryDevtoolsFaultArmed = (fault) => fault.latencyMs > 0 || fault.failNext > 0 || fault.failRate > 0;
-/**
- * Arms (or updates) the fault of one client. Only the given fields change; the rest keep their current
- * value. A client whose resulting fault has nothing armed is dropped from {@link queryDevtoolsFaults}.
- *
- * Part of the devtools contract consumed by `<et-query-devtools>`; a fault is a debugging tool, not
- * something an application should arm on itself.
- */
-const setQueryDevtoolsFault = (options) => {
-    const { clientName, patch } = options;
-    faults.update((current) => {
-        const next = { ...(current[clientName] ?? EMPTY_QUERY_DEVTOOLS_FAULT), ...patch };
-        if (!isQueryDevtoolsFaultArmed(next)) {
-            const { [clientName]: _removed, ...rest } = current;
-            return rest;
-        }
-        return { ...current, [clientName]: next };
-    });
-};
-/**
- * Disarms every fault of one client, or of all clients when no name is given.
- *
- * @see setQueryDevtoolsFault
- */
-const clearQueryDevtoolsFaults = (clientName) => faults.update((current) => {
-    if (clientName === undefined)
-        return {};
-    const { [clientName]: _removed, ...rest } = current;
-    return rest;
-});
-/**
- * Resolves what to do with one upcoming attempt, consuming a `failNext` budget in the process - so this
- * must be called once per attempt and never speculatively.
- *
- * Installed as the fault resolver by `provideQueryDevtools()`; nothing else may call it.
- * @internal
- */
-const resolveQueryDevtoolsFaultForAttempt = (target) => {
-    const fault = faults()[target.clientName];
-    if (!fault || !isQueryDevtoolsFaultArmed(fault))
-        return null;
-    let shouldFail = false;
-    if (fault.failNext > 0) {
-        shouldFail = true;
-        setQueryDevtoolsFault({ clientName: target.clientName, patch: { failNext: fault.failNext - 1 } });
-    }
-    else if (fault.failRate > 0) {
-        shouldFail = Math.random() * 100 < fault.failRate;
-    }
-    return {
-        latencyMs: fault.latencyMs,
-        status: shouldFail ? fault.status : null,
-    };
-};
-
-/**
- * Records which query forms feed one query's args, so the devtools can answer "which query does this
- * form drive?" from the reads themselves rather than from a naming convention.
- * @internal
- */
-const createQueryDevtoolsFormLinks = () => {
-    const ids = signal([], /* @ts-ignore */
-    ...(ngDevMode ? [{ debugName: "ids" }] : /* istanbul ignore next */ []));
-    return {
-        ids: ids.asReadonly(),
-        track: (build) => {
-            const collected = collectQueryFormLinks(build);
-            // Args are built inside a reactive computation, which may not write to a signal - `untracked`
-            // lifts that restriction, and skipping the write unless something is new keeps the panel from
-            // being notified on every evaluation.
-            untracked(() => {
-                const known = ids();
-                const added = collected.ids.filter((id) => !known.includes(id));
-                if (added.length)
-                    ids.set([...known, ...added]);
-            });
-            return collected.value;
-        },
-    };
-};
-
 const DEFAULTS = {
     viewState: 'session',
     pins: 'local',
     overrides: 'none',
     mocks: 'local',
+    armedMocks: 'none',
+    armedFaults: 'none',
     maxEvents: 100,
     maxDroppedCacheEntries: 20,
     responseHistory: null,
@@ -6031,6 +6333,8 @@ const sanitize = (value) => ({
     pins: asScope(value?.pins, DEFAULTS.pins),
     overrides: asScope(value?.overrides, DEFAULTS.overrides),
     mocks: asScope(value?.mocks, DEFAULTS.mocks),
+    armedMocks: asScope(value?.armedMocks, DEFAULTS.armedMocks),
+    armedFaults: asScope(value?.armedFaults, DEFAULTS.armedFaults),
     maxEvents: asCount(value?.maxEvents, LIMITS.maxEvents, DEFAULTS.maxEvents),
     maxDroppedCacheEntries: asCount(value?.maxDroppedCacheEntries, LIMITS.maxDroppedCacheEntries, DEFAULTS.maxDroppedCacheEntries),
     responseHistory: asOptionalCount(value?.responseHistory, LIMITS.responseHistory),
@@ -6059,23 +6363,213 @@ const setQueryDevtoolsSettings = (patch) => {
     writeQueryDevtoolsStore('local', SETTINGS_KEY, next);
 };
 
+/** The neutral fault: nothing armed. */
+const EMPTY_QUERY_DEVTOOLS_FAULT = {
+    latencyMs: 0,
+    failNext: 0,
+    failRate: 0,
+    status: 503,
+};
+/**
+ * Statuses worth injecting, and whether the SDK's default retry policy retries them. A picker built from
+ * this cannot arm a 500 and then leave you wondering why no retry fired.
+ * @see runDefaultQueryRetry
+ */
+const QUERY_DEVTOOLS_FAULT_STATUSES = [
+    { status: 0, label: 'Network error', retryable: true },
+    { status: 400, label: 'Bad Request', retryable: false },
+    { status: 401, label: 'Unauthorized', retryable: false },
+    { status: 403, label: 'Forbidden', retryable: false },
+    { status: 404, label: 'Not Found', retryable: false },
+    { status: 408, label: 'Request Timeout', retryable: true },
+    { status: 429, label: 'Too Many Requests', retryable: true },
+    { status: 500, label: 'Internal Server Error', retryable: false },
+    { status: 502, label: 'Bad Gateway', retryable: true },
+    { status: 503, label: 'Service Unavailable', retryable: true },
+];
+const STORAGE_KEY$2 = 'ethlete:query:devtools:faults:v1';
+const faults = /* @__PURE__ */ signal({}, /* @ts-ignore */
+...(ngDevMode ? [{ debugName: "faults" }] : /* istanbul ignore next */ []));
+const restored$1 = /* @__PURE__ */ signal(false, /* @ts-ignore */
+...(ngDevMode ? [{ debugName: "restored" }] : /* istanbul ignore next */ []));
+const scope$2 = () => queryDevtoolsSettings().armedFaults;
+/**
+ * The faults armed per client name, consumed by the `<et-query-devtools>` UI. Clients with nothing armed
+ * are absent rather than present with an {@link EMPTY_QUERY_DEVTOOLS_FAULT}.
+ */
+const queryDevtoolsFaults = /* @__PURE__ */ faults.asReadonly();
+/**
+ * Whether what is armed right now came back from a previous page load rather than being armed by hand.
+ * The panel's armed bar says so, because injected failures nobody remembers arming look exactly like a
+ * broken API.
+ */
+const queryDevtoolsFaultsRestored = /* @__PURE__ */ restored$1.asReadonly();
+const write$1 = () => {
+    if (scope$2() === 'none') {
+        clearQueryDevtoolsStore(STORAGE_KEY$2);
+        return;
+    }
+    writeQueryDevtoolsStore(scope$2(), STORAGE_KEY$2, faults());
+};
+const asFault = (value) => {
+    const fault = value;
+    if (!fault || typeof fault !== 'object')
+        return null;
+    const next = {
+        latencyMs: Number(fault.latencyMs) || 0,
+        failNext: Number(fault.failNext) || 0,
+        failRate: Number(fault.failRate) || 0,
+        status: Number.isFinite(Number(fault.status)) ? Number(fault.status) : EMPTY_QUERY_DEVTOOLS_FAULT.status,
+    };
+    return isQueryDevtoolsFaultArmed(next) ? next : null;
+};
+/**
+ * Reads the armed faults back, when the `armedFaults` setting asks for them. Called by
+ * `provideQueryDevtools()` after the settings it takes its scope from; nothing else may call it.
+ * @internal
+ */
+const initQueryDevtoolsFaults = () => {
+    const stored = readQueryDevtoolsStore(scope$2(), STORAGE_KEY$2);
+    const inherited = {};
+    for (const [clientName, value] of Object.entries(stored ?? {})) {
+        const fault = asFault(value);
+        if (fault)
+            inherited[clientName] = fault;
+    }
+    faults.set(inherited);
+    restored$1.set(Object.keys(inherited).length > 0);
+};
+/**
+ * Where the armed faults are kept. Switching to a scope that keeps them stores whatever is armed right
+ * now; switching to `none` empties the store and leaves this page's faults exactly where they are.
+ */
+const setQueryDevtoolsFaultsScope = (next) => {
+    if (next === scope$2())
+        return;
+    // Off both stores first: whichever the previous scope was, its copy must not outlive the change.
+    clearQueryDevtoolsStore(STORAGE_KEY$2);
+    setQueryDevtoolsSettings({ armedFaults: next });
+    write$1();
+};
+/** Whether anything at all is armed on a fault. */
+const isQueryDevtoolsFaultArmed = (fault) => fault.latencyMs > 0 || fault.failNext > 0 || fault.failRate > 0;
+const patchFault = (options) => {
+    const { clientName, patch } = options;
+    faults.update((current) => {
+        const next = { ...(current[clientName] ?? EMPTY_QUERY_DEVTOOLS_FAULT), ...patch };
+        if (!isQueryDevtoolsFaultArmed(next)) {
+            const { [clientName]: _removed, ...rest } = current;
+            return rest;
+        }
+        return { ...current, [clientName]: next };
+    });
+    write$1();
+};
+/**
+ * Arms (or updates) the fault of one client. Only the given fields change; the rest keep their current
+ * value. A client whose resulting fault has nothing armed is dropped from {@link queryDevtoolsFaults}.
+ *
+ * Part of the devtools contract consumed by `<et-query-devtools>`; a fault is a debugging tool, not
+ * something an application should arm on itself.
+ */
+const setQueryDevtoolsFault = (options) => {
+    patchFault(options);
+    restored$1.set(false);
+};
+/**
+ * Disarms every fault of one client, or of all clients when no name is given.
+ *
+ * @see setQueryDevtoolsFault
+ */
+const clearQueryDevtoolsFaults = (clientName) => {
+    faults.update((current) => {
+        if (clientName === undefined)
+            return {};
+        const { [clientName]: _removed, ...rest } = current;
+        return rest;
+    });
+    restored$1.set(false);
+    write$1();
+};
+/**
+ * Resolves what to do with one upcoming attempt, consuming a `failNext` budget in the process - so this
+ * must be called once per attempt and never speculatively.
+ *
+ * Installed as the fault resolver by `provideQueryDevtools()`; nothing else may call it.
+ * @internal
+ */
+const resolveQueryDevtoolsFaultForAttempt = (target) => {
+    const fault = faults()[target.clientName];
+    if (!fault || !isQueryDevtoolsFaultArmed(fault))
+        return null;
+    let shouldFail = false;
+    if (fault.failNext > 0) {
+        shouldFail = true;
+        // Not the public setter: spending the budget is the armed fault doing its job, not someone re-arming
+        // it, so it must not clear what the panel's bar says about where the fault came from.
+        patchFault({ clientName: target.clientName, patch: { failNext: fault.failNext - 1 } });
+    }
+    else if (fault.failRate > 0) {
+        shouldFail = Math.random() * 100 < fault.failRate;
+    }
+    return {
+        latencyMs: fault.latencyMs,
+        status: shouldFail ? fault.status : null,
+    };
+};
+
+/**
+ * Records which query forms feed one query's args, so the devtools can answer "which query does this
+ * form drive?" from the reads themselves rather than from a naming convention.
+ * @internal
+ */
+const createQueryDevtoolsFormLinks = () => {
+    const ids = signal([], /* @ts-ignore */
+    ...(ngDevMode ? [{ debugName: "ids" }] : /* istanbul ignore next */ []));
+    return {
+        ids: ids.asReadonly(),
+        track: (build) => {
+            const collected = collectQueryFormLinks(build);
+            // Args are built inside a reactive computation, which may not write to a signal - `untracked`
+            // lifts that restriction, and skipping the write unless something is new keeps the panel from
+            // being notified on every evaluation.
+            untracked(() => {
+                const known = ids();
+                const added = collected.ids.filter((id) => !known.includes(id));
+                if (added.length)
+                    ids.set([...known, ...added]);
+            });
+            return collected.value;
+        },
+    };
+};
+
 /**
- * The designed library. Whether a mock is **armed** is deliberately not part of it - see
+ * The designed library. Which of them is **armed** is a separate store under a separate scope - see
  * {@link queryDevtoolsArmedMocks}.
  */
 const STORAGE_KEY$1 = 'ethlete:query:devtools:mocks:v1';
+const ARMED_STORAGE_KEY = 'ethlete:query:devtools:mocks:armed:v1';
 const mocks = /* @__PURE__ */ signal([], /* @ts-ignore */
 ...(ngDevMode ? [{ debugName: "mocks" }] : /* istanbul ignore next */ []));
 const armed = /* @__PURE__ */ signal(/* @__PURE__ */ new Set(), /* @ts-ignore */
 ...(ngDevMode ? [{ debugName: "armed" }] : /* istanbul ignore next */ []));
+const armedRestored = /* @__PURE__ */ signal(false, /* @ts-ignore */
+...(ngDevMode ? [{ debugName: "armedRestored" }] : /* istanbul ignore next */ []));
 const scope$1 = () => queryDevtoolsSettings().mocks;
+const armedScope = () => queryDevtoolsSettings().armedMocks;
 /** The designed mocks, armed or not. Persisted, because losing an hour of authoring is unacceptable. */
 const queryDevtoolsMocks = /* @__PURE__ */ mocks.asReadonly();
 /**
- * The ids currently being served. **Never persisted, at any scope**: an app that silently serves designed
- * data tomorrow morning is worse than losing which mocks were armed, so arming is per page load.
+ * The ids currently being served. Not kept across page loads unless the `armedMocks` setting asks for it -
+ * an app that silently serves designed data tomorrow morning is worse than losing which mocks were armed.
  */
 const queryDevtoolsArmedMocks = /* @__PURE__ */ armed.asReadonly();
+/**
+ * Whether what is armed right now came back from a previous page load rather than being armed by hand.
+ * The panel's armed bar says so, because mocks nobody remembers arming look exactly like a broken API.
+ */
+const queryDevtoolsArmedMocksRestored = /* @__PURE__ */ armedRestored.asReadonly();
 /**
  * The identity of a designed mock: one per client, method, route **and** declared query. The query is part
  * of it so `/posts?page=1` and `/posts?page=2` can hold different bodies.
@@ -6088,6 +6582,19 @@ const write = () => {
     }
     writeQueryDevtoolsStore(scope$1(), STORAGE_KEY$1, mocks());
 };
+const writeArmed = () => {
+    if (armedScope() === 'none') {
+        clearQueryDevtoolsStore(ARMED_STORAGE_KEY);
+        return;
+    }
+    writeQueryDevtoolsStore(armedScope(), ARMED_STORAGE_KEY, [...armed()]);
+};
+/** Every change made by hand goes through here, so none of them can leave the store or the bar behind. */
+const setArmed = (next) => {
+    armed.set(next);
+    armedRestored.set(false);
+    writeArmed();
+};
 const isMock = (value) => {
     const mock = value;
     return (!!mock &&
@@ -6106,7 +6613,15 @@ const initQueryDevtoolsMocks = () => {
     const stored = readQueryDevtoolsStore(scope$1(), STORAGE_KEY$1);
     // `query` was added after the first version of the store, so an entry written before it still loads.
     mocks.set(Array.isArray(stored) ? stored.filter(isMock).map((mock) => ({ ...mock, query: mock.query ?? '' })) : []);
-    armed.set(new Set());
+    const kept = readQueryDevtoolsStore(armedScope(), ARMED_STORAGE_KEY);
+    const library = new Set(mocks().map((mock) => mock.id));
+    // An id the library no longer holds would arm nothing, so it is dropped rather than kept waiting for a
+    // mock that may never be designed again.
+    const inherited = Array.isArray(kept)
+        ? kept.filter((id) => typeof id === 'string' && library.has(id))
+        : [];
+    armed.set(new Set(inherited));
+    armedRestored.set(inherited.length > 0);
 };
 /** The path of a request URL, without its origin or query string - what a pattern is matched against. */
 const queryDevtoolsRequestPath = (url) => {
@@ -6163,24 +6678,39 @@ const deleteQueryDevtoolsMock = (id) => {
 };
 /** Starts or stops serving one designed mock. Arming a mock that is not in the library does nothing. */
 const armQueryDevtoolsMock = (id, isArmed) => {
-    armed.update((current) => {
-        if (isArmed && !mocks().some((mock) => mock.id === id))
-            return current;
-        const next = new Set(current);
-        if (isArmed)
-            next.add(id);
-        else
-            next.delete(id);
-        return next;
-    });
-};
+    if (isArmed && !mocks().some((mock) => mock.id === id))
+        return;
+    const next = new Set(armed());
+    if (isArmed)
+        next.add(id);
+    else
+        next.delete(id);
+    setArmed(next);
+};
+/** Starts serving every mock in the library - the counterpart of {@link clearQueryDevtoolsArmedMocks}. */
+const armAllQueryDevtoolsMocks = () => setArmed(new Set(mocks().map((mock) => mock.id)));
 /** Stops serving every mock, leaving the library alone - the armed bar's one-click way out. */
-const clearQueryDevtoolsArmedMocks = () => armed.set(new Set());
+const clearQueryDevtoolsArmedMocks = () => setArmed(new Set());
+/**
+ * Where the armed set is kept. Switching to a scope that keeps it stores whatever is armed right now, so
+ * the choice reads as "keep these"; switching to `none` empties the store and leaves this page serving
+ * exactly what it was already serving.
+ */
+const setQueryDevtoolsArmedMocksScope = (next) => {
+    if (next === armedScope())
+        return;
+    // Off both stores first: whichever the previous scope was, its copy must not outlive the change.
+    clearQueryDevtoolsStore(ARMED_STORAGE_KEY);
+    setQueryDevtoolsSettings({ armedMocks: next });
+    writeArmed();
+};
 /** Empties the designed library and disarms everything - the panel's "Reset devtools". */
 const clearQueryDevtoolsMockStore = () => {
     mocks.set([]);
     armed.set(new Set());
+    armedRestored.set(false);
     clearQueryDevtoolsStore(STORAGE_KEY$1);
+    clearQueryDevtoolsStore(ARMED_STORAGE_KEY);
 };
 const declaredParamCount = (mock) => (mock.query ? [...new URLSearchParams(mock.query)].length : 0);
 /**
@@ -6916,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.33';
+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;
@@ -7248,6 +7778,89 @@ const seedQueryDevtoolsSchemaBody = (name) => {
         return null;
     return seedFrom(schema, name);
 };
+/** Where a schema was collected from, so the same name arriving from two pointers is caught. */
+const originOf = (label, pointer) => pointer ?? `named:${label}`;
+/**
+ * Copies a schema, pointing every local `$ref` at `#/components/schemas/<name>` and queueing that name -
+ * so a document assembled from these resolves against its own `components`, whether the description kept
+ * its schemas under `components.schemas`, `definitions` or `$defs`.
+ */
+const rewriteRefs = (value, queue) => {
+    if (Array.isArray(value))
+        return value.map((entry) => rewriteRefs(entry, queue));
+    if (!isRecord(value))
+        return value;
+    const result = {};
+    for (const [key, entry] of Object.entries(value)) {
+        if (key === '$ref' && typeof entry === 'string') {
+            if (!entry.startsWith('#/')) {
+                result[key] = entry;
+                continue;
+            }
+            const label = refLabel(entry);
+            queue({ label, pointer: entry });
+            result[key] = `#/components/schemas/${label}`;
+            continue;
+        }
+        result[key] = rewriteRefs(entry, queue);
+    }
+    return result;
+};
+/**
+ * Collects the named schemas a set of routes was designed against, ready to be handed back as the
+ * `components.schemas` of an exported document - so a route seeded from `MatchView` can reference
+ * `MatchView` instead of an anonymous shape inferred from one body.
+ *
+ * Part of the devtools contract. **Not part of the general public contract.**
+ */
+const collectQueryDevtoolsSchemaComponents = (names) => {
+    const declared = namedSchemas();
+    const schemas = {};
+    const notes = new Set();
+    const origins = new Map();
+    const pending = names.map((label) => ({ label, pointer: null }));
+    while (pending.length) {
+        const request = pending.shift();
+        const origin = originOf(request.label, request.pointer);
+        const seen = origins.get(request.label);
+        if (seen !== undefined) {
+            if (seen !== origin) {
+                notes.add(`Two different schemas are both called ${request.label} - only the one from ${seen} was kept.`);
+            }
+            continue;
+        }
+        const schema = request.pointer === null ? declared[request.label] : resolveRef(request.pointer);
+        if (schema === undefined) {
+            if (request.pointer !== null) {
+                notes.add(`${request.pointer} could not be resolved, so ${request.label} is missing from the export.`);
+            }
+            continue;
+        }
+        origins.set(request.label, origin);
+        schemas[request.label] = rewriteRefs(schema, (next) => pending.push(next));
+    }
+    for (const schema of Object.values(schemas)) {
+        collectRemoteRefs(schema, notes);
+    }
+    return { schemas, notes: [...notes] };
+};
+/** A `$ref` to another file is left as it was written, so a document says where it stops resolving. */
+const collectRemoteRefs = (value, notes) => {
+    if (Array.isArray(value)) {
+        for (const entry of value)
+            collectRemoteRefs(entry, notes);
+        return;
+    }
+    if (!isRecord(value))
+        return;
+    for (const [key, entry] of Object.entries(value)) {
+        if (key === '$ref' && typeof entry === 'string' && !entry.startsWith('#/')) {
+            notes.add(`${entry} points outside the description - it was exported unchanged and will not resolve.`);
+            continue;
+        }
+        collectRemoteRefs(entry, notes);
+    }
+};
 const segmentsOf = (pattern) => pattern.split('/').filter(Boolean);
 /** `/matches/{id}` and `/matches/:id` describe the same route; a mock's pattern is written the second way. */
 const toColonPattern = (path) => path.replace(/\{([^}]+)\}/g, ':$1');
@@ -7662,6 +8275,90 @@ const sumQueryDevtoolsStats = (handles) => {
     return total;
 };
 
+/**
+ * The longest lifetime an armed override may claim, in seconds (7 days). Anything beyond it is never
+ * refreshed at all, which is what arming nothing already does.
+ */
+const QUERY_DEVTOOLS_TOKEN_TTL_LIMIT = 604800;
+/** The claims an overridden lifetime is measured from, in the order they are tried. */
+const ANCHOR_CLAIMS = ['iat', 'nbf'];
+const ttls = /* @__PURE__ */ signal({}, /* @ts-ignore */
+...(ngDevMode ? [{ debugName: "ttls" }] : /* istanbul ignore next */ []));
+/**
+ * The access-token lifetime armed per auth provider name, in seconds, consumed by the
+ * `<et-query-devtools>` panel. A provider on its token's real lifetime is absent rather than present
+ * with it.
+ */
+const queryDevtoolsTokenTtls = /* @__PURE__ */ ttls.asReadonly();
+const tokenTtlAnchor = (options) => {
+    const { payload, expiresInPropertyName } = options;
+    if (!payload || typeof payload[expiresInPropertyName] !== 'number')
+        return null;
+    for (const claim of ANCHOR_CLAIMS) {
+        const value = payload[claim];
+        if (typeof value === 'number')
+            return value;
+    }
+    return null;
+};
+/**
+ * Whether an overridden lifetime can be applied to a decoded access token at all. It needs the claim
+ * carrying the expiry - so a lifetime is never invented for a token that declares none - plus `iat` or
+ * `nbf` to measure the new lifetime from.
+ */
+const canOverrideQueryDevtoolsTokenTtl = (options) => tokenTtlAnchor({ payload: options.payload, expiresInPropertyName: options.expiresInPropertyName ?? 'exp' }) !== null;
+/**
+ * Presents one auth provider's access token as living `seconds` from the moment it was issued, rather
+ * than as long as it says it does. Everything that reads the expiry sees the shortened lifetime - the
+ * proactive refresh schedule, `withBearerAuthTokenExpirationWarning`, and the panel's own countdown -
+ * so arming 60 seconds makes a real refresh happen a minute after each token is issued, and keeps
+ * happening for every token that refresh brings back.
+ *
+ * It is a lifetime, not a remaining time: `0` presents the current token as long expired, which is what
+ * makes a refresh happen at once. Nothing is persisted, so a reload leaves every provider on its real
+ * lifetime.
+ *
+ * Part of the devtools contract consumed by `<et-query-devtools>`; a token's lifetime is not something
+ * an application should override on itself.
+ */
+const setQueryDevtoolsTokenTtl = (options) => {
+    const { providerName, seconds } = options;
+    const clamped = Math.min(Math.max(Math.trunc(seconds) || 0, 0), QUERY_DEVTOOLS_TOKEN_TTL_LIMIT);
+    ttls.update((current) => ({ ...current, [providerName]: clamped }));
+};
+/**
+ * Puts one provider back on its token's real lifetime, or every provider when no name is given.
+ *
+ * @see setQueryDevtoolsTokenTtl
+ */
+const clearQueryDevtoolsTokenTtl = (providerName) => {
+    ttls.update((current) => {
+        if (providerName === undefined)
+            return {};
+        const { [providerName]: _removed, ...rest } = current;
+        return rest;
+    });
+};
+/**
+ * The decoded access token as the devtools want it seen: the claim carrying the expiry rewritten to the
+ * armed lifetime, measured from `iat`. Returns `payload` untouched when nothing is armed for the
+ * provider, or when the token cannot carry the override - see {@link canOverrideQueryDevtoolsTokenTtl}.
+ *
+ * Installed as the token payload patcher by `provideQueryDevtools()`, and called directly by the panel
+ * for its own countdown.
+ */
+const applyQueryDevtoolsTokenTtl = (options) => {
+    const { payload, providerName, expiresInPropertyName = 'exp' } = options;
+    const seconds = ttls()[providerName];
+    if (seconds === undefined || !payload || typeof payload !== 'object')
+        return payload;
+    const record = payload;
+    const anchor = tokenTtlAnchor({ payload: record, expiresInPropertyName });
+    if (anchor === null)
+        return payload;
+    return { ...record, [expiresInPropertyName]: anchor + seconds };
+};
+
 /**
  * How many destroyed queries the registry keeps. A tombstone holds the last response body it captured,
  * so the list is capped for the same reason the repository caps its unused entries.
@@ -7942,6 +8639,7 @@ const provideQueryDevtools = (options) => {
     setQueryDevtoolsAppInfo(options?.about);
     initQueryDevtoolsOverridePersistence();
     initQueryDevtoolsMocks();
+    initQueryDevtoolsFaults();
     setQueryDevtoolsSchemaLoader(options?.schema);
     setQueryDevtoolsRegistrar(registerEntry);
     setQueryDevtoolsStatsFactory(createQueryDevtoolsStats);
@@ -7949,6 +8647,7 @@ const provideQueryDevtools = (options) => {
     setQueryDevtoolsOverridesFactory(createQueryDevtoolsOverrides);
     setQueryDevtoolsFaultResolver(resolveQueryDevtoolsFaultForAttempt);
     setQueryDevtoolsMockResolver(resolveQueryDevtoolsMockForAttempt);
+    setQueryDevtoolsTokenPayloadPatcher(applyQueryDevtoolsTokenTtl);
     if (!isDevMode()) {
         console.warn('You are using the Query Devtools in production mode. This increases the size of your bundle and should only be used for development purposes.');
     }
@@ -13489,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_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, applyQueryFeatures, armQueryDevtoolsMock, armQueryDevtoolsOverrideTransfer, authExtractTokensResponseMissingAccessToken, authExtractTokensResponseMissingRefreshToken, authExtractTokensResponseNotObject, authProviderFeatureUsedMultipleTimes, booleanArrayQueryField, buildQueryCacheKey, buildQueryString, buildRoute, buildTimestampFromSeconds, castQueryCreatorTypes, circularQueryDependency, circularQueryDependencyChecker, clearQueryDevtoolsArmedMocks, clearQueryDevtoolsFaults, clearQueryDevtoolsMockStore, clearQueryDevtoolsOverrideStore, clearQueryDevtoolsStore, clearQueryDevtoolsTombstones, clearRestoredQueryDevtoolsOverrides, collectLeafPaths, 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, 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, pathParamsMissingInRouteFunctionError, provideInfinityQueryResponseDelay, provideLegacyPrepareFallback, provideQueryClientForDevtools, provideQueryDevtools, queryArrayComputed, queryClientFeatureUsedMultipleTimes, queryComputed, queryComputedTillTruthy, queryDevtoolsAbout, queryDevtoolsArmedMocks, queryDevtoolsEntries, queryDevtoolsFaults, queryDevtoolsFnDetail, queryDevtoolsMockId, queryDevtoolsMocks, queryDevtoolsOverridePersistence, queryDevtoolsRequestPath, queryDevtoolsResponseHistory, queryDevtoolsRestoredOverridesScope, queryDevtoolsSchemaNames, queryDevtoolsSchemaRoutes, queryDevtoolsSchemaState, queryDevtoolsSettings, queryDevtoolsStorage, 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, setQueryDevtoolsFault, setQueryDevtoolsFaultResolver, setQueryDevtoolsFormLinksFactory, setQueryDevtoolsMockResolver, setQueryDevtoolsOverridePersistence, setQueryDevtoolsOverridesFactory, setQueryDevtoolsOverridesScope, setQueryDevtoolsRegistrar, setQueryDevtoolsResponseHistory, setQueryDevtoolsSchemaLoader, setQueryDevtoolsSettings, setQueryDevtoolsStatsFactory, 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