@ethlete/query 6.0.0-next.48 → 6.0.0-next.49

package/fesm2022/ethlete-query.mjs

@@ -1,9 +1,9 @@
 import * as i0 from '@angular/core';
-import { inject, Injector, effect, DestroyRef, computed, InjectionToken, EnvironmentInjector, ElementRef, ErrorHandler, createEnvironmentInjector, untracked, signal, linkedSignal, runInInjectionContext, isDevMode, PLATFORM_ID, resource, DOCUMENT, VERSION, provideEnvironmentInitializer, afterNextRender, makeEnvironmentProviders, assertInInjectionContext, ChangeDetectorRef, ViewContainerRef, TemplateRef, Input, Directive, input, Pipe, ViewEncapsulation, Component, NgZone } from '@angular/core';
+import { inject, ApplicationRef, untracked, effect, Injector, runInInjectionContext, DestroyRef, computed, InjectionToken, EnvironmentInjector, ElementRef, ErrorHandler, createEnvironmentInjector, signal, linkedSignal, isDevMode, PLATFORM_ID, resource, DOCUMENT, VERSION, provideEnvironmentInitializer, afterNextRender, makeEnvironmentProviders, assertInInjectionContext, ChangeDetectorRef, ViewContainerRef, TemplateRef, Input, Directive, input, Pipe, ViewEncapsulation, Component, NgZone } from '@angular/core';
 import { UrlTree, Router, RedirectCommand, ActivatedRoute } from '@angular/router';
 import { Observable, defer, from, filter, Subject, Subscription, throwError, of, timer, switchMap, tap, retry, catchError, EMPTY as EMPTY$1, take, takeUntil, finalize, mergeMap, toArray, map, race, NEVER, merge, takeWhile, firstValueFrom, concatMap, fromEvent, throttleTime, interval, startWith, pairwise, BehaviorSubject, combineLatest, ReplaySubject, distinctUntilChanged, shareReplay, withLatestFrom, debounceTime } from 'rxjs';
 import { defineStaticProvider, RuntimeError, clamp, randomId, defineRootProvider, isObject, injectUnsavedChangesCoordinator, injectRoute, getCookie, setCookie, deleteCookie, CORE_VERSION, createDestroy, computedTillTruthy, defineProvider, toProvideFn, toInjectFn, nextFrame, injectQueryParams, injectQueryParamChanges, clone, equal, ET_PROPERTY_REMOVED, previousSignalValue } from '@ethlete/core';
-import { HttpClient, HttpErrorResponse, HttpEventType, HttpResponse, HttpHeaders, HttpStatusCode } from '@angular/common/http';
+import { HttpClient, HttpErrorResponse, HttpEventType, HttpHeaders, HttpResponse, HttpStatusCode } from '@angular/common/http';
 import { toObservable, takeUntilDestroyed, toSignal } from '@angular/core/rxjs-interop';
 import { getActiveConsumer, setActiveConsumer, SIGNAL } from '@angular/core/primitives/signals';
 import { isPlatformBrowser, NgClass, AsyncPipe, JsonPipe } from '@angular/common';
@@ -13,6 +13,7 @@ import { FormControl, ReactiveFormsModule, FormGroup } from '@angular/forms';
 
 const DEFAULT_RETURN_URL_PARAM = 'returnUrl';
 const DEFAULT_URL = '/';
+const DEFAULT_RESTORE_TIMEOUT_MS = 10000;
 const resolveTarget = (router, target) => {
     if (target instanceof UrlTree)
         return target;
@@ -45,51 +46,137 @@ const readReturnUrl = (router, url, param) => {
  * ];
  * ```
  *
- * A guard pends while a session restore is in flight rather than redirecting against a session that
- * is about to exist, so a hard reload of a protected URL stays on that URL.
+ * A guard pends while a session restore is in flight, for up to `restoreTimeoutMs`, rather than
+ * redirecting against a session that is about to exist, so a hard reload of a protected URL stays on
+ * that URL.
  */
 const createAuthGuard = (providerRef, config) => {
     const param = config.returnUrlParam === false ? null : (config.returnUrlParam ?? DEFAULT_RETURN_URL_PARAM);
     const behavior = config.navigationBehaviorOptions ?? { replaceUrl: true };
-    const guardFor = (requiresSession) => () => {
+    const restoreTimeoutMs = config.restoreTimeoutMs ?? DEFAULT_RESTORE_TIMEOUT_MS;
+    const sessionGuards = new Set();
+    const watchedRouters = new WeakSet();
+    const anonymousGuards = new Set();
+    const watchedStartRouters = new WeakSet();
+    const timedOutRestores = new WeakSet();
+    const loginRedirect = (router, returnUrl) => {
+        const loginTree = resolveTarget(router, config.loginUrl);
+        return param && returnUrl ? withQueryParam(loginTree, param, returnUrl) : loginTree;
+    };
+    const usesGuard = (route, guardSet) => {
+        const guards = [...(route.routeConfig?.canMatch ?? []), ...(route.routeConfig?.canActivate ?? [])];
+        return guards.some((guard) => guardSet.has(guard)) || route.children.some((child) => usesGuard(child, guardSet));
+    };
+    const watchSessionStart = (router, provider) => {
+        if (!config.redirectOnSessionStart || watchedStartRouters.has(router))
+            return;
+        watchedStartRouters.add(router);
+        const appRef = inject(ApplicationRef);
+        let wasAuthenticated = untracked(provider.sessionStatus) === 'authenticated';
+        effect(() => {
+            const isAuthenticated = provider.sessionStatus() === 'authenticated';
+            const started = isAuthenticated && !wasAuthenticated;
+            wasAuthenticated = isAuthenticated;
+            if (!started)
+                return;
+            untracked(() => {
+                if (!usesGuard(router.routerState.snapshot.root, anonymousGuards))
+                    return;
+                const returnUrl = readReturnUrl(router, router.url, param);
+                void router.navigateByUrl(returnUrl ? router.parseUrl(returnUrl) : resolveTarget(router, config.defaultUrl ?? DEFAULT_URL), behavior);
+            });
+        }, { injector: appRef.injector });
+    };
+    const watchSessionEnd = (router, provider) => {
+        const causes = config.redirectOnSessionEnd;
+        if (!causes?.length || watchedRouters.has(router))
+            return;
+        watchedRouters.add(router);
+        const appRef = inject(ApplicationRef);
+        let handled = untracked(provider.executionState);
+        effect(() => {
+            const state = provider.executionState();
+            const cause = provider.sessionEndCause();
+            if (state === handled || state?.type !== 'logout')
+                return;
+            handled = state;
+            if (!cause || !causes.includes(cause))
+                return;
+            untracked(() => {
+                if (!usesGuard(router.routerState.snapshot.root, sessionGuards))
+                    return;
+                void router.navigateByUrl(loginRedirect(router, cause === 'user' ? null : router.url), behavior);
+            });
+        }, { injector: appRef.injector });
+    };
+    const guardFor = (requiresSession, permission, options) => () => {
         const router = inject(Router);
         const injector = inject(Injector);
         const provider = providerRef.inject();
+        if (requiresSession)
+            watchSessionEnd(router, provider);
+        else
+            watchSessionStart(router, provider);
         // Captured before the wait below: once the session settles the router has moved on, and the URL
         // the visitor actually asked for is no longer reachable from it.
         const attemptedUrl = router.currentNavigation()?.extractedUrl.toString() ?? router.url;
+        // A restore a guard stopped waiting for is not waited for again, or the redirect to the login
+        // would wait out a second timeout on the login route's own guard.
         const settled = () => {
             const status = provider.sessionStatus();
-            return status !== 'unknown' && status !== 'restoring';
+            if (status === 'unknown' || status === 'restoring')
+                return timedOutRestores.has(provider);
+            timedOutRestores.delete(provider);
+            return true;
         };
         const decide = () => {
             const authenticated = provider.sessionStatus() === 'authenticated';
-            if (authenticated === requiresSession)
-                return true;
-            if (requiresSession) {
-                const loginTree = resolveTarget(router, config.loginUrl);
-                return new RedirectCommand(param ? withQueryParam(loginTree, param, attemptedUrl) : loginTree, behavior);
+            if (authenticated !== requiresSession) {
+                if (requiresSession)
+                    return new RedirectCommand(loginRedirect(router, attemptedUrl), behavior);
+                const returnUrl = readReturnUrl(router, attemptedUrl, param);
+                return new RedirectCommand(returnUrl ? router.parseUrl(returnUrl) : resolveTarget(router, config.defaultUrl ?? DEFAULT_URL), behavior);
             }
-            const returnUrl = readReturnUrl(router, attemptedUrl, param);
-            return new RedirectCommand(returnUrl ? router.parseUrl(returnUrl) : resolveTarget(router, config.defaultUrl ?? DEFAULT_URL), behavior);
+            if (!permission || untracked(() => runInInjectionContext(injector, () => permission(provider))))
+                return true;
+            return new RedirectCommand(resolveTarget(router, options?.redirectTo ?? config.defaultUrl ?? DEFAULT_URL), behavior);
         };
         if (settled())
             return decide();
         return new Observable((subscriber) => {
-            const watcher = effect(() => {
-                if (!settled())
-                    return;
+            const finish = () => {
                 subscriber.next(decide());
                 subscriber.complete();
+            };
+            const timeout = restoreTimeoutMs === false
+                ? null
+                : setTimeout(() => {
+                    timedOutRestores.add(provider);
+                    finish();
+                }, restoreTimeoutMs);
+            const watcher = effect(() => {
+                if (settled())
+                    untracked(finish);
             }, { ...(ngDevMode ? { debugName: "watcher" } : /* istanbul ignore next */ {}), injector });
-            return () => watcher.destroy();
+            return () => {
+                watcher.destroy();
+                if (timeout !== null)
+                    clearTimeout(timeout);
+            };
         });
     };
-    const requireSession = guardFor(true);
+    const sessionGuard = (guard) => {
+        sessionGuards.add(guard);
+        return guard;
+    };
+    const requireSession = sessionGuard(guardFor(true));
     const requireAnonymous = guardFor(false);
+    anonymousGuards.add(requireAnonymous);
     return {
         canMatch: requireSession,
         canActivate: requireSession,
+        canMatchWith: (permission, options) => sessionGuard(guardFor(true, permission, options)),
+        canActivateWith: (permission, options) => sessionGuard(guardFor(true, permission, options)),
         canMatchAnonymous: requireAnonymous,
         canActivateAnonymous: requireAnonymous,
         returnUrl: () => {
@@ -397,6 +484,7 @@ const createQueryContext = (context) => defineStaticProvider(context, {
 /** @internal */
 const injectQueryContext = () => inject(QUERY_CONTEXT_TOKEN);
 
+/** @internal */
 const setupQueryDependencies = (options) => {
     const hostInjector = options.queryConfig?.injector ?? inject(Injector);
     const environmentInjector = options.queryConfig?.injector?.get(EnvironmentInjector) ?? hostInjector.get(EnvironmentInjector);
@@ -696,6 +784,7 @@ const withArgs = (args) => {
         },
     });
 };
+const readPollingInterval = (interval) => typeof interval === 'function' ? interval() : interval;
 /**
  * A query feature that will automatically execute the query at a given interval.
  * The interval will be cleared when the query is destroyed.
@@ -713,14 +802,21 @@ const withPolling = (options) => {
     return createQueryFeature({
         type: QueryFeatureType.WITH_POLLING,
         devtools: () => [
-            { label: 'interval', value: formatQueryDevtoolsDuration(options.interval) },
+            { label: 'interval', value: formatQueryDevtoolsDuration(untracked(() => readPollingInterval(options.interval))) },
             { label: 'execute initially', value: options.executeInitially ? 'yes' : 'no' },
+            ...(options.pauseWhileHidden ? [{ label: 'pause while hidden', value: 'yes' }] : []),
+            ...(options.refetchOnFocus ? [{ label: 'refetch on focus', value: 'yes' }] : []),
+            ...(options.refetchOnReconnect ? [{ label: 'refetch on reconnect', value: 'yes' }] : []),
         ],
         fn: (context) => {
             if (!context.flags.shouldAutoExecuteMethod) {
                 throw withPollingUsedOnUnsupportedHttpMethod(context.flags.method);
             }
             let intervalId = null;
+            let timeoutId = null;
+            let active = false;
+            let currentArgs = null;
+            let lastTickAt = 0;
             const sync = context.deps.client.subtle.sync;
             const lockManager = sync?.isPollingDedupeEnabled && context.flags.isMultiTabSyncEnabled ? sync.lockManager : null;
             // Only ever set while dedup is active. A tick runs unless we know another tab is taking care of
@@ -753,28 +849,98 @@ const withPolling = (options) => {
                     hold?.release();
                 });
             }
+            const currentInterval = () => untracked(() => readPollingInterval(options.interval));
+            const isPaused = () => options.pauseWhileHidden === true && document.hidden;
+            const stop = () => {
+                if (intervalId !== null)
+                    clearInterval(intervalId);
+                if (timeoutId !== null)
+                    clearTimeout(timeoutId);
+                intervalId = null;
+                timeoutId = null;
+            };
+            const tick = () => {
+                lastTickAt = Date.now();
+                // The interval keeps running while another tab is the holder, so leadership arriving
+                // mid-flight needs no restart and `executeInitially`/interval semantics stay identical.
+                if (hold && !hold.isHolder())
+                    return;
+                context.execute({ args: currentArgs });
+            };
+            const schedule = (firstDelay) => {
+                stop();
+                if (!active || isPaused())
+                    return;
+                const interval = currentInterval();
+                if (firstDelay >= interval) {
+                    intervalId = window.setInterval(tick, interval);
+                    return;
+                }
+                timeoutId = window.setTimeout(() => {
+                    timeoutId = null;
+                    tick();
+                    intervalId = window.setInterval(tick, currentInterval());
+                }, Math.max(0, firstDelay));
+            };
+            const remainingDelay = () => lastTickAt + currentInterval() - Date.now();
             nestedEffect(() => {
                 const args = context.state.args();
                 untracked(() => {
-                    if (intervalId !== null)
-                        clearInterval(intervalId);
+                    stop();
+                    currentArgs = args;
                     // Don't start polling if the query doesn't have args.
                     // It should have args because a withArgs feature is present.
-                    if (args === null && context.flags.hasWithArgsFeature)
+                    active = !(args === null && context.flags.hasWithArgsFeature);
+                    if (!active)
                         return;
-                    if (options.executeInitially && (!hold || hold.isHolder())) {
-                        context.execute({ args });
+                    lastTickAt = Date.now();
+                    if (options.executeInitially) {
+                        if (isPaused())
+                            lastTickAt -= currentInterval();
+                        else if (!hold || hold.isHolder())
+                            context.execute({ args });
                     }
-                    intervalId = window.setInterval(() => {
-                        // The interval keeps running while another tab is the holder, so leadership arriving
-                        // mid-flight needs no restart and `executeInitially`/interval semantics stay identical.
-                        if (hold && !hold.isHolder())
-                            return;
-                        context.execute({ args });
-                    }, options.interval);
+                    schedule(currentInterval());
                 });
             }, { injector: context.deps.injector });
-            context.deps.destroyRef.onDestroy(() => intervalId !== null && clearInterval(intervalId));
+            if (typeof options.interval === 'function') {
+                const interval = options.interval;
+                nestedEffect(() => {
+                    interval();
+                    untracked(() => {
+                        if (intervalId === null && timeoutId === null)
+                            return;
+                        schedule(remainingDelay());
+                    });
+                }, { injector: context.deps.injector });
+            }
+            const listen = (target, type, listener) => {
+                target.addEventListener(type, listener);
+                context.deps.destroyRef.onDestroy(() => target.removeEventListener(type, listener));
+            };
+            if (options.pauseWhileHidden) {
+                listen(document, 'visibilitychange', () => {
+                    if (!active)
+                        return;
+                    if (document.hidden) {
+                        stop();
+                    }
+                    else if (intervalId === null && timeoutId === null) {
+                        schedule(remainingDelay());
+                    }
+                });
+            }
+            const refetchNow = () => {
+                if (!active || isPaused())
+                    return;
+                tick();
+                schedule(currentInterval());
+            };
+            if (options.refetchOnFocus)
+                listen(window, 'focus', refetchNow);
+            if (options.refetchOnReconnect)
+                listen(window, 'online', refetchNow);
+            context.deps.destroyRef.onDestroy(stop);
         },
     });
 };
@@ -1064,6 +1230,74 @@ const setDefaultQueryRetryFn = (fn) => {
 /** @internal */
 const runDefaultQueryRetry = (options) => defaultRetryFn$1?.(options) ?? NO_RETRY;
 
+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 retryNonIdempotent = options.retryNonIdempotent ?? false;
+    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, idempotent }) => {
+        // 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 (!idempotent && !retryNonIdempotent)
+            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: 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` - never for a `POST`, a `PATCH` or a GraphQL mutation.
+ *
+ * Pass {@link createDefaultRetryFn} options to {@link withDefaultRetry} to configure it.
+ */
+const shouldRetryRequest = (options) => defaultRetryFn(options instanceof HttpErrorResponse ? { retryCount: 0, error: options, method: null, idempotent: true } : options);
+/** Whether a request with this method may be sent again without changing the outcome - everything but `POST` and `PATCH`. */
+const isIdempotentQueryMethod = (method) => method !== 'POST' && method !== 'PATCH';
+
 const isQueryErrorResponse = (error) => {
     return typeof error === 'object' && error !== null && 'raw' in error && 'retryState' in error && 'isList' in error;
 };
@@ -1106,7 +1340,13 @@ const createQueryErrorResponse = (error, retry) => {
             statusText: 'Unknown Error',
         });
     }
-    const retryOptions = { retryCount: retry?.retryCount ?? 0, error: err };
+    const method = retry?.method ?? null;
+    const retryOptions = {
+        retryCount: retry?.retryCount ?? 0,
+        error: err,
+        method,
+        idempotent: retry?.idempotent ?? (method ? isIdempotentQueryMethod(method) : true),
+    };
     const retryState = typeof retry?.retryFn === 'function' ? retry.retryFn(retryOptions) : runDefaultQueryRetry(retryOptions);
     const detail = err.error;
     const errorList = [];
@@ -1570,6 +1810,14 @@ const createBaseQuery = (options) => {
     });
 };
 
+/** Resolves a {@link QueryHeadersInput} to `HttpHeaders`, or `undefined` when none is given. */
+const resolveQueryHeaders = (input) => {
+    const headers = typeof input === 'function' ? input() : input;
+    if (!headers)
+        return undefined;
+    return headers instanceof HttpHeaders ? headers : new HttpHeaders(headers);
+};
+
 const extractExpiresInSeconds = (headers) => {
     const cacheControl = headers.get('cache-control');
     const age = headers.get('age');
@@ -1625,7 +1873,7 @@ const sortObjectKeys = (_key, value) => {
  * entries written by an older version are stored under.
  */
 const buildQueryCacheKey = (route, args, method) => {
-    const headers = typeof args?.headers === 'function' ? args.headers() : args?.headers;
+    const headers = resolveQueryHeaders(args?.headers);
     const serializedHeaders = headers
         ?.keys()
         .map((name) => name.toLowerCase())
@@ -1966,6 +2214,7 @@ const createHttpRequest = (options) => {
     ...(ngDevMode ? [{ debugName: "attempts" }] : /* istanbul ignore next */ []));
     const retryState = signal(null, /* @ts-ignore */
     ...(ngDevMode ? [{ debugName: "retryState" }] : /* istanbul ignore next */ []));
+    const idempotent = options.idempotent ?? isIdempotentQueryMethod(options.method);
     const lastDurationMs = signal(null, /* @ts-ignore */
     ...(ngDevMode ? [{ debugName: "lastDurationMs" }] : /* istanbul ignore next */ []));
     // Set at the top of every `sendWithFaults` attempt (including unfaulted ones), so it always reflects
@@ -1982,8 +2231,8 @@ const createHttpRequest = (options) => {
     // Resolved per execution rather than once at creation, so a client whose headers are a function
     // reading a signal (a preview token, a tenant id) sees the current value on every re-run.
     const resolveHeaders = () => {
-        const clientHeaders = typeof options.clientHeaders === 'function' ? options.clientHeaders() : options.clientHeaders;
-        const argHeaders = typeof args?.headers === 'function' ? args.headers() : args?.headers;
+        const clientHeaders = resolveQueryHeaders(options.clientHeaders);
+        const argHeaders = resolveQueryHeaders(args?.headers);
         if (!clientHeaders)
             return argHeaders;
         if (!argHeaders)
@@ -2069,7 +2318,7 @@ const createHttpRequest = (options) => {
         const source$ = isQueryDevtoolsRequestInterceptionEnabled() ? sendWithFaults(headers) : send(headers);
         return source$.pipe(tap((event) => updateState(event)), retry({
             delay: (error, retryCount) => {
-                const retryOptions = { error, retryCount };
+                const retryOptions = { error, retryCount, method: options.method, idempotent };
                 const retryResult = options.retryFn?.(retryOptions) || runDefaultQueryRetry(retryOptions);
                 if (!retryResult.retry) {
                     return throwError(() => error);
@@ -2174,6 +2423,8 @@ const createHttpRequest = (options) => {
         const errorRes = createQueryErrorResponse(errorResponse, {
             retryCount: attempts(),
             retryFn: options.retryFn,
+            method: options.method,
+            idempotent,
         });
         error.set(errorRes);
         loading.set(null);
@@ -3766,69 +4017,6 @@ const symfonyQueryErrorParser = (detail) => {
     return null;
 };
 
-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: 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. */
 const alwaysHolder = { isHolder: /* @__PURE__ */ signal(true).asReadonly(), release: noop$2 };
@@ -3915,6 +4103,7 @@ const createQueryKeyLockManager = (namespace) => {
     return { hold, isSupported: true, keyStates: keyStates.asReadonly() };
 };
 
+/** @internal */
 const createQuerySyncEngine = (options) => {
     const { config, repository, transport, lockManager } = options;
     const syncResponses = config.syncResponses ?? true;
@@ -4248,7 +4437,8 @@ const withSymfonyErrors = () => () => {
 /**
  * Gives this client 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.
+ * times with an exponentially backing off, jittered delay - and a Pagerfanta out-of-range page never is. A `POST`,
+ * a `PATCH` and a GraphQL mutation are never retried unless the options set `retryNonIdempotent`.
  *
  * The policy belongs to the client the feature is on, so another client of the same app is not
  * affected. Without it nothing is retried automatically and `error.retryState` always reads
@@ -4386,6 +4576,7 @@ const createQueryRepository = (config) => {
             clientHeaders: config.headers,
             cacheAdapter: config.cacheAdapter,
             retryFn: options.retryFn ?? config.retryFn,
+            idempotent: options.isRefreshable ?? isIdempotentQueryMethod(options.method),
         });
         const executed = request.execute();
         bind({
@@ -4738,7 +4929,7 @@ const createQueryClient = (options) => defineRootProvider(() => {
     name: `QueryClient_${options.name}`,
 });
 
-const AUTH_HEADER = 'Authorization';
+const AUTH_HEADER$1 = 'Authorization';
 /**
  * How long a request waits for the refresh of an expired access token before it sends the expired one
  * anyway. Nothing guarantees the refresh arrives - the refresh token can be spent, and the request can
@@ -4808,12 +4999,12 @@ const createSecureExecuteFactory = (options) => {
         const args = executeArgs.args;
         const headerProvider = () => {
             const accessToken = options.authProvider.accessToken();
-            const baseHeaders = typeof args?.headers === 'function' ? args.headers() : args?.headers || new HttpHeaders();
+            const baseHeaders = resolveQueryHeaders(args?.headers) ?? new HttpHeaders();
             if (!accessToken) {
                 throw tokensNotAvailableInsideAuthAndExec();
             }
-            if (!baseHeaders.has(AUTH_HEADER)) {
-                return baseHeaders.set(AUTH_HEADER, `Bearer ${accessToken}`);
+            if (!baseHeaders.has(AUTH_HEADER$1)) {
+                return baseHeaders.set(AUTH_HEADER$1, `Bearer ${accessToken}`);
             }
             return baseHeaders;
         };
@@ -5798,6 +5989,7 @@ const createBearerAuthProviderImpl = (config) => {
         activityCoordination: isLeader.activityCoordination,
         afterTokenRefresh$,
         queries: queries,
+        queryBuilders: config.queries,
         latestExecutedQuery: latestExecutedQuery.asReadonly(),
         executionState,
         sessionStatus: sessionStatus.asReadonly(),
@@ -5834,6 +6026,11 @@ const createBearerAuthProviderImpl = (config) => {
         executionState: executionState.asReadonly(),
         sessionStatus: sessionStatus.asReadonly(),
         sessionEndCause: sessionEndCause.asReadonly(),
+        session: computed(() => ({
+            status: sessionStatus(),
+            endCause: sessionEndCause(),
+            executionState: executionState(),
+        })),
         setTokens,
         logout,
         afterTokenRefresh$,
@@ -5935,7 +6132,7 @@ const withAuthenticationQuery = (key, config, setup) => ({
 const withRefreshQuery = (key, config) => {
     const retryableStatusCodes = config.retryConfig?.retryableStatusCodes ?? [0, 408, 425, 429, 500, 502, 503, 504];
     const maxRetryDelayMs = config.retryConfig?.maxRetryDelayMs ?? 30000; // 30 seconds
-    const maxAttempts = config.retryConfig?.maxAttempts ?? 0; // 0 = unlimited
+    const maxAttempts = config.retryConfig?.maxAttempts ?? 8;
     const refreshRetryFn = ({ error, retryCount }) => {
         const { status } = error;
         if (maxAttempts > 0 && retryCount > maxAttempts) {
@@ -7316,12 +7513,20 @@ const createPersistentAuthFeature = (config, context) => {
         if (wasRejected && !context.isTabLocalSession())
             removeCookie();
     });
+    const autoLoginBuilder = context.queryBuilders.find((builder) => builder.key === config.autoLogin.queryKey);
+    const buildAutoLoginArgs = (token) => {
+        if (config.autoLogin.buildArgs)
+            return config.autoLogin.buildArgs(token);
+        if (autoLoginBuilder?._type === 'tokenRefreshQuery')
+            return autoLoginBuilder.buildArgs(token);
+        return { body: { token } };
+    };
     const exchangeCookie = () => {
         const storedToken = getCookie(cookieName);
         if (!storedToken)
             return;
         const decryptedToken = decryptToken(storedToken);
-        const args = config.autoLogin.buildArgs(decryptedToken);
+        const args = buildAutoLoginArgs(decryptedToken);
         context.queries[config.autoLogin.queryKey].execute(args, { triggeredBy: 'persistent-auth' });
     };
     const tryLogin = () => {
@@ -7369,7 +7574,10 @@ const withTokenExpirationWarning = (config = {}) => {
     return (context) => {
         const warningThreshold = config.warningThreshold ?? 5 * 60 * 1000;
         const checkInterval = config.checkInterval ?? 1000;
-        const expiresInPropertyName = config.expiresInPropertyName ?? 'exp';
+        const refreshBuilder = context.queryBuilders.find((builder) => builder._type === 'tokenRefreshQuery');
+        const expiresInPropertyName = config.expiresInPropertyName ??
+            (refreshBuilder?._type === 'tokenRefreshQuery' ? refreshBuilder.config.expiresInPropertyName : undefined) ??
+            'exp';
         const expiresAt = computed(() => {
             const decoded = context.bearerData();
             if (!decoded)
@@ -7413,9 +7621,21 @@ const withTokenExpirationWarning = (config = {}) => {
     };
 };
 
+const AUTH_HEADER = 'Authorization';
 const withTokenRevocation = (config) => {
     return (context) => {
         const revokeOnLogout = config.revokeOnLogout ?? true;
+        const withBearerHeader = (args, accessToken) => {
+            if (!config.bearer || !accessToken)
+                return args;
+            const argHeaders = args.headers;
+            const headers = () => {
+                const base = resolveQueryHeaders(argHeaders) ?? new HttpHeaders();
+                return base.has(AUTH_HEADER) ? base : base.set(AUTH_HEADER, `Bearer ${accessToken}`);
+            };
+            return { ...args, headers };
+        };
+        const shouldRevokeFor = (cause) => !config.revokeOn || (cause !== null && config.revokeOn.includes(cause));
         const enabled = signal(true, /* @ts-ignore */
         ...(ngDevMode ? [{ debugName: "enabled" }] : /* istanbul ignore next */ []));
         let previousAccessToken = null;
@@ -7427,7 +7647,7 @@ const withTokenRevocation = (config) => {
             if (!accessToken && !refreshToken) {
                 return null;
             }
-            const args = config.buildArgs({ accessToken, refreshToken });
+            const args = withBearerHeader(config.buildArgs?.({ accessToken, refreshToken }) ?? {}, accessToken);
             context.executionState.set({ type: 'revocation', state: 'loading' });
             currentRevocationSnapshot = context.queries[config.queryKey].execute(args, {
                 triggeredBy: 'token-revocation',
@@ -7447,7 +7667,10 @@ const withTokenRevocation = (config) => {
             effect(() => {
                 const currentToken = context.accessToken();
                 const currentRefreshToken = context.refreshToken();
-                if (previousAccessToken && !currentToken && enabled()) {
+                if (previousAccessToken &&
+                    !currentToken &&
+                    enabled() &&
+                    shouldRevokeFor(untracked(context.sessionEndCause))) {
                     untracked(() => revokeWithTokens(previousAccessToken, previousRefreshToken));
                 }
                 previousAccessToken = currentToken;
@@ -7465,7 +7688,8 @@ const withTokenRevocation = (config) => {
             instance,
             devtools: () => [
                 { label: 'query', value: config.queryKey },
-                { label: 'on logout', value: revokeOnLogout ? 'yes' : 'no' },
+                { label: 'on logout', value: revokeOnLogout ? (config.revokeOn?.join(', ') ?? 'yes') : 'no' },
+                { label: 'bearer', value: config.bearer ? 'yes' : 'no' },
             ],
         };
     };
@@ -8474,12 +8698,13 @@ const asScope = (value, fallback) => value === 'none' || value === 'session' ||
  * Whether the session vault may be kept in `localStorage`. Only a development build may: the vault
  * holds live access and refresh tokens plus the credentials somebody typed in, and a deployed
  * application that mounts the panel for its debugging value must not leave those on the machine of
- * whoever opened it. Every other scope stays on offer, so the vault still works for one tab.
+ * whoever opened it. Outside a development build a stored or default `local` reads back as `none`, so a
+ * plain login keeps nothing; `session` stays on offer for whoever picks it in Settings.
  *
  * Part of the devtools contract. **Not part of the general public contract.**
  */
 const queryDevtoolsAllowsLocalAuthSessions = () => isDevMode();
-const clampAuthSessions = (scope) => scope === 'local' && !queryDevtoolsAllowsLocalAuthSessions() ? 'session' : scope;
+const clampAuthSessions = (scope) => scope === 'local' && !queryDevtoolsAllowsLocalAuthSessions() ? 'none' : scope;
 const asCount = (value, limits, fallback) => {
     const count = Math.floor(Number(value));
     if (!Number.isFinite(count))
@@ -8684,11 +8909,15 @@ let listening = false;
  * @internal
  */
 const initQueryDevtoolsAuthSessions = (accounts) => {
-    // Before the read below, which never looks at `localStorage` once the scope is clamped: a vault an
-    // earlier version left there would otherwise sit on a deployed origin with nothing left to remove it.
-    if (!queryDevtoolsAllowsLocalAuthSessions())
-        queryDevtoolsStorage('local')?.removeItem(STORE_KEY);
     const scope = queryDevtoolsSettings().authSessions;
+    // The read below only looks at the store the scope names: a vault an earlier version or scope left in
+    // another store would otherwise sit there, tokens and all, with nothing left to remove it.
+    for (const other of ['local', 'session']) {
+        if (other !== scope)
+            queryDevtoolsStorage(other)?.removeItem(STORE_KEY);
+    }
+    if (scope === 'none')
+        queryDevtoolsStorage('session')?.removeItem(ACTIVE_KEY);
     declared.set(accounts ?? []);
     store.set(sanitize(readQueryDevtoolsStore(scope, STORE_KEY)));
     active.set(readQueryDevtoolsStore(scope === 'none' ? 'none' : 'session', ACTIVE_KEY) ?? {});
@@ -10283,7 +10512,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.48';
+const QUERY_VERSION = '6.0.0-next.49';
 
 /** How deep a schema is expanded before a nested branch is given up on. */
 const MAX_DEPTH = 12;
@@ -11680,6 +11909,7 @@ const gql = (strings, ...values) => {
     return str;
 };
 
+/** @internal */
 const createGqlExecuteFn = (executeOptions) => {
     const executeState = setupQueryExecuteState();
     const circularChecker = circularQueryDependencyChecker();
@@ -11737,7 +11967,7 @@ const createGqlQuery = (options) => createBaseQuery({
     executeFactory: createGqlExecuteFn,
 });
 
-const unwrapGqlResponse = (rawResponse) => {
+const readGqlEnvelope = (rawResponse) => {
     if (!rawResponse || typeof rawResponse !== 'object')
         throw gqlDataPropertyMissingInResponse();
     const data = 'data' in rawResponse ? rawResponse.data : undefined;
@@ -11746,8 +11976,14 @@ const unwrapGqlResponse = (rawResponse) => {
         throw gqlErrorsInResponse(errors);
     if (!('data' in rawResponse))
         throw gqlDataPropertyMissingInResponse();
-    return data;
+    return { data, errors: Array.isArray(errors) ? errors : [] };
 };
+const unwrapGqlResponse = (rawResponse) => readGqlEnvelope(rawResponse).data;
+/**
+ * A GQL `transformResponse` that keeps the server's `errors` next to partial data. Declare the
+ * args' `response` as `GqlDataWithErrors<TData>`; a response without data still fails with ET601.
+ */
+const unwrapGqlResponseWithErrors = (rawResponse) => readGqlEnvelope(rawResponse);
 
 const createGqlQueryCreator = (options, internals) => createBaseQueryCreator({
     options: {
@@ -11758,6 +11994,7 @@ const createGqlQueryCreator = (options, internals) => createBaseQueryCreator({
     queryFactory: createGqlQuery,
 });
 
+/** @internal */
 const createSecureGqlExecuteFn = (executeOptions) => {
     const authProvider = executeOptions.creatorInternals.authProvider.inject();
     return createSecureExecuteFactory({
@@ -16876,6 +17113,36 @@ const normalizeLive = (fieldDefs, rawLive, defaults) => {
     }
     return live;
 };
+const resolveStorage = (storage) => {
+    if (typeof storage !== 'string')
+        return storage;
+    try {
+        if (typeof globalThis.window === 'undefined')
+            return null;
+        return (storage === 'session' ? globalThis.sessionStorage : globalThis.localStorage) ?? null;
+    }
+    catch {
+        return null;
+    }
+};
+const readStoredParams = (persistence) => {
+    try {
+        const raw = resolveStorage(persistence.storage)?.getItem(persistence.key);
+        const parsed = raw ? JSON.parse(raw) : null;
+        return parsed && typeof parsed === 'object' && !Array.isArray(parsed) ? parsed : null;
+    }
+    catch {
+        return null;
+    }
+};
+const writeStoredParams = (persistence, params) => {
+    try {
+        resolveStorage(persistence.storage)?.setItem(persistence.key, JSON.stringify(params));
+    }
+    catch {
+        return;
+    }
+};
 const computeFilterCount = (fields, value, defaults) => {
     let count = 0;
     for (const [key, def] of Object.entries(fields)) {
@@ -16973,6 +17240,11 @@ const createBranch = (fields, initial, injector) => {
             model.set(clone(next));
         }
     };
+    const write = (next, options) => {
+        model.set(next);
+        if (!options?.debounce)
+            flush();
+    };
     effect(() => {
         const live = normalizedLive();
         untracked(() => {
@@ -16995,13 +17267,13 @@ const createBranch = (fields, initial, injector) => {
         value: committed.asReadonly(),
         liveValue: model.asReadonly(),
         activeFilterCount: computed(() => computeFilterCount(fields, committed(), defaults)),
-        setValue: (value) => model.set(clone(value)),
-        patchValue: (value) => model.update((cur) => ({ ...cur, ...value })),
-        resetFieldToDefault: (key) => model.update((cur) => ({ ...cur, [key]: defaultFor(key) })),
-        resetAllFieldsToDefault: () => {
+        setValue: (value, options) => write(clone(value), options),
+        patchValue: (value, options) => write({ ...model(), ...value }, options),
+        resetFieldToDefault: (key, options) => write({ ...model(), [key]: defaultFor(key) }, options),
+        resetAllFieldsToDefault: (options) => {
             for (const key of Object.keys(fields))
                 defaultFor(key);
-            model.set(clone(defaults));
+            write(clone(defaults), options);
         },
     };
 };
@@ -17063,6 +17335,7 @@ const defineQueryForm = (config) => {
     const skipResetsFor = new Set();
     let skipNextResetsFor;
     let urlWriteVersion = 0;
+    let changesSeenAtObserve;
     const urlNavigationMarker = {};
     const pathOf = (tree) => router.serializeUrl(tree).split(/[?#]/)[0];
     const fields = form(model);
@@ -17080,6 +17353,9 @@ const defineQueryForm = (config) => {
         const writeDefault = def.appendDefaultValueToUrl === true;
         if (!writeToUrl || (isDefault && !writeDefault))
             return undefined;
+        return serialize(key, def, value);
+    };
+    const serialize = (key, def, value) => {
         if (def.valueToQueryParam)
             return def.valueToQueryParam(value);
         if (value === '' && defaults[key] === null)
@@ -17088,16 +17364,47 @@ const defineQueryForm = (config) => {
             return ET_EMPTY_ARRAY_VALUE;
         return value === null ? ET_NULL_VALUE : value;
     };
+    const persistedKeys = () => {
+        const keys = observeOptions?.persistence?.fields ?? Object.keys(fieldDefs);
+        return keys.filter((key) => key in fieldDefs);
+    };
+    const persist = () => {
+        const persistence = observeOptions?.persistence;
+        if (!persistence || !observing())
+            return;
+        const value = committed();
+        const stored = {};
+        for (const key of persistedKeys()) {
+            if (equal(value[key], defaults[key]))
+                continue;
+            stored[key] = serialize(key, fieldDefs[key], value[key]);
+        }
+        writeStoredParams(persistence, stored);
+    };
+    const restoreFromStorage = (persistence, urlParams) => {
+        const keys = persistedKeys();
+        if (keys.some((key) => urlParams[paramKey(key)] !== undefined))
+            return;
+        const stored = readStoredParams(persistence);
+        if (!stored)
+            return;
+        const params = {};
+        for (const key of keys) {
+            if (stored[key] !== undefined)
+                params[paramKey(key)] = stored[key];
+        }
+        applyFromUrl(params, { base: model() });
+    };
     const deserialize = (def, raw) => {
         if (!def.skipAutoTransform && raw === ET_NULL_VALUE)
             return null;
         if (!def.skipAutoTransform && raw === ET_EMPTY_ARRAY_VALUE)
             return [];
         if (def.queryParamToValue)
-            return def.queryParamToValue(raw);
+            return def.queryParamToValue(raw) ?? resolveDefault(def);
         if (def.skipAutoTransform)
             return raw;
-        return autoCoerce(raw, resolveDefault(def));
+        return autoCoerce(raw, resolveDefault(def)) ?? resolveDefault(def);
     };
     const clearTimer = () => {
         if (pendingTimer !== null) {
@@ -17173,6 +17480,7 @@ const defineQueryForm = (config) => {
         if (observing() && observeOptions?.writeToQueryParams !== false) {
             writeToUrl(next);
         }
+        persist();
     };
     const onLiveChange = (live) => {
         if (equal(live, committed())) {
@@ -17203,6 +17511,7 @@ const defineQueryForm = (config) => {
         committed.set(clone(next));
         // Feed the URL value into the live model & bound controls; the effect no-ops (model === committed).
         model.set(clone(next));
+        persist();
     };
     const applyFromUrl = (params, options) => {
         const current = { ...(options?.base ?? committed()) };
@@ -17248,6 +17557,12 @@ const defineQueryForm = (config) => {
             }
         }
         model.set(next);
+        if (options?.debounce) {
+            onLiveChange(next);
+        }
+        else {
+            flush();
+        }
     };
     const setValue = (value, options) => writeModel(clone(value), options);
     const patchValue = (value, options) => writeModel({ ...model(), ...value }, options);
@@ -17278,6 +17593,10 @@ const defineQueryForm = (config) => {
             }
             observeOptions = options;
             observing.set(true);
+            changesSeenAtObserve = untracked(queryParamChanges);
+            if (options?.persistence) {
+                restoreFromStorage(options.persistence, route.snapshot.queryParams);
+            }
             if (options?.syncOnNavigation !== false) {
                 // A value written before `observe()` sits in the model only, so the URL merges onto the model
                 // here. Against `committed()` any single URL param would drop that value.
@@ -17293,6 +17612,7 @@ const defineQueryForm = (config) => {
             if (options?.writeToQueryParams !== false && writesAnyParam) {
                 writeToUrl(committed());
             }
+            persist();
             return queryForm;
         },
         unobserve: () => {
@@ -17325,6 +17645,10 @@ const defineQueryForm = (config) => {
         untracked(() => {
             if (!observing() || observeOptions?.syncOnNavigation === false)
                 return;
+            // The changes are shared app-wide, so the diff present at `observe()` describes a navigation this
+            // form never saw - applying its removals would wipe a restored or seeded value.
+            if (changes === changesSeenAtObserve)
+                return;
             const info = router.lastSuccessfulNavigation()?.extras.info;
             // Including the newest write: re-parsing the form's own output would coerce a committed
             // string back to a number and drop the milliseconds of a committed Date.
@@ -17474,10 +17798,12 @@ const messageMalformed = () => {
 const MAX_DEVTOOLS_MESSAGES = 100;
 const createWebSocketClient = (options) => {
     return defineRootProvider(() => {
+        const auth = options.auth;
         const socket = options.io(options.url, {
-            withCredentials: true,
+            withCredentials: options.withCredentials ?? true,
             autoConnect: false,
             transports: options.transports,
+            auth: auth ? (cb) => cb(typeof auth === 'function' ? auth() : auth) : undefined,
         });
         const rooms = new Map();
         const joinsDeliveredThisConnection = new Set();
@@ -17527,10 +17853,11 @@ const createWebSocketClient = (options) => {
                 }
                 emit({ event: 'join-room', data: name, room: name });
                 joinsDeliveredToClosedConnection.delete(name);
-                const message = signal(null, /* @ts-ignore */
-                ...(ngDevMode ? [{ debugName: "message" }] : /* istanbul ignore next */ []));
+                const messages = new Subject();
                 const newRoom = {
-                    latestMessage: message,
+                    latestMessage: signal(null),
+                    messages,
+                    messages$: messages.asObservable(),
                     joinCount: 1,
                 };
                 rooms.set(name, newRoom);
@@ -17583,6 +17910,7 @@ const createWebSocketClient = (options) => {
                 emit({ event: 'leave-room', data: room, room });
             rooms.delete(room);
             syncDevtoolsRooms();
+            joinedRoom.messages.complete();
         };
         const setupWebSocketConnectionListener = () => {
             socket.onAnyOutgoing((eventName, room) => {
@@ -17616,6 +17944,7 @@ const createWebSocketClient = (options) => {
         };
         const setupWebSocketListener = () => {
             socket.onAny((_eventName, ...args) => {
+                let json;
                 try {
                     const data = args[0];
                     if (typeof data !== 'string')
@@ -17626,11 +17955,7 @@ const createWebSocketClient = (options) => {
                         typeof parsed.room !== 'string') {
                         throw messageMalformed();
                     }
-                    const json = parsed;
-                    recordDevtoolsMessage({ room: json.room, event: json.event, data: json.data, direction: 'in' });
-                    const room = rooms.get(json.room);
-                    if (room)
-                        room.latestMessage.set(json);
+                    json = parsed;
                 }
                 catch (error) {
                     if (!isDevMode())
@@ -17638,15 +17963,26 @@ const createWebSocketClient = (options) => {
                     console.error(error);
                     throw messageMalformed();
                 }
+                recordDevtoolsMessage({ room: json.room, event: json.event, data: json.data, direction: 'in' });
+                const room = rooms.get(json.room);
+                if (!room)
+                    return;
+                room.latestMessage.set(json);
+                room.messages.next(json);
             });
         };
-        inject(DestroyRef).onDestroy(() => socket.disconnect());
+        inject(DestroyRef).onDestroy(() => {
+            socket.disconnect();
+            for (const room of rooms.values())
+                room.messages.complete();
+        });
         setupWebSocketConnectionListener();
         setupWebSocketListener();
         socket.connect();
         const client = {
             joinRoom,
             isConnected: isConnected.asReadonly(),
+            send: (message) => emit({ event: message.event, data: message.data }),
             subtle: {
                 leaveRoom,
             },
@@ -17675,5 +18011,5 @@ const createWebSocketClient = (options) => {
  * Generated bundle index. Do not edit.
  */
 
-export { AuthBearerRefreshStrategy, 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_BATCH_TOMBSTONES, 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, QueryStateType, QueryStore, SERVER_ERROR_KIND, SERVER_VIOLATION_ERROR_KIND, SPEED_BUFFER_TIME_IN_MS, SearchQueryField, SortQueryField, StringArrayQueryField, V2BearerAuthProvider, V2Query, V2QueryClient, V2QueryCreator, addQueryContainerHandling, addQueryDevtoolsAuthAccount, applyQueryDevtoolsOverrides, applyQueryDevtoolsTokenTtl, applyQueryFeatures, armAllQueryDevtoolsMocks, armQueryDevtoolsMock, armQueryDevtoolsOverrideTransfer, authExtractTokensResponseMissingAccessToken, authExtractTokensResponseMissingRefreshToken, authExtractTokensResponseNotObject, authProviderFeatureUsedMultipleTimes, booleanArrayQueryField, buildQueryCacheKey, buildQueryString, buildRoute, buildTimestampFromSeconds, canOverrideQueryDevtoolsTokenTtl, castQueryCreatorTypes, circularQueryDependency, circularQueryDependencyChecker, clearQueryDevtoolsArmedMocks, clearQueryDevtoolsAuthCredentials, clearQueryDevtoolsAuthSessions, 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, createHeadQuery, createHttpRequest, createIndexedDbQueryPersistenceAdapter, createInfinityQueryConfig, createLegacyQueryCreator, createNoopQueryPersistenceAdapter, createOptionsQuery, createPagedQueryStack, createPatchQuery, createPersistentAuthFeature, createPostQuery, createPutQuery, createQuery, createQueryBatch, createQueryClient, createQueryCollection, createQueryCollectionSignal, createQueryCollectionSubject, createQueryContext, createQueryCreator, createQueryDevtoolsFormLinks, createQueryDevtoolsFormLinksRecorder, createQueryDevtoolsOverrides, createQueryDevtoolsOverridesRecorder, createQueryDevtoolsStats, createQueryDevtoolsStatsRecorder, createQueryErrorResponse, createQueryFeature, createQueryInvalidationFilter, createQueryKeyLockManager, createQueryObject, createQueryPersistenceEngine, createQueryRepository, createQuerySnapshotFn, createQueryStack, createQuerySubmission, createQuerySyncEngine, createQuerySyncTransport, createSecureDeleteQuery, createSecureExecuteFactory, createSecureExecuteFn, createSecureGetQuery, createSecureGqlExecuteFn, createSecureGqlMutationViaGet, createSecureGqlMutationViaPost, createSecureGqlQuery, createSecureGqlQueryCreator, createSecureGqlQueryViaGet, createSecureGqlQueryViaPost, createSecureHeadQuery, createSecureOptionsQuery, createSecurePatchQuery, createSecurePostQuery, createSecurePutQuery, createSecureQuery, createSecureQueryCreator, createTrackingFeature, createWebSocketClient, currentQueryDevtoolsBatch, 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, forgetQueryDevtoolsAuthSession, forgetQueryDevtoolsAuthSessionsFor, formatQueryDevtoolsDuration, generateQueryDevtoolsNumberPreset, generateQueryDevtoolsSampleNumber, generateQueryDevtoolsStringPreset, getBearerAuthProviderName, getDefaultHeaders, getQueryClientName, getQueryFeatureUsage, getResponseUrl, ggLikePaginationAdapter, gql, gqlDataPropertyMissingInResponse, gqlErrorsInResponse, gqlTransformerFor, hasHeader, hasQueryDevtoolsOverridesAtPath, htmlErrorPayload, htmlQueryErrorParser, ignoreAutoRefresh, initQueryDevtoolsAuthSessions, 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, isQueryDevtoolsRepositoryLive, isQueryDevtoolsRequestInterceptionEnabled, isQueryErrorResponse, isQueryStateCancelled, isQueryStateFailure, isQueryStateLoading, isQueryStatePrepared, isQueryStateSuccess, isRequestError, isSymfonyError, isSymfonyFormViolationListError, isSymfonyListError, isSymfonyPagerfantaOutOfRangeError, isUnderInvalidatedUrl, legacyPrepareFallbackInjector, legacyPrepareWithoutInjectionContext, loadQueryDevtoolsSchema, loginQueryDevtoolsAuthAccount, logoutQueryDevtoolsAuthSession, mapToPaginated, mapViolationsToFormErrors, matchesQueryDevtoolsMockPattern, matchesQueryDevtoolsMockQuery, maybeExecute, measureQueryDevtoolsPayload, mergeHeaders, nestedEffect, noteQueryFormRead, noteQueryFormReads, numberArrayQueryField, pagedQueryStackNextPageCalledWithoutPreviousPage, pagedQueryStackPageBiggerThanTotalPages, pagedQueryStackPreviousPageCalledButAlreadyAtFirstPage, paginatedEntityValueUpdater, parseAllXhrResponseHeaders, parseHttpErrorCodeToMessageDe, parseHttpErrorCodeToMessageEn, parseHttpErrorCodeToTitleDe, parseHttpErrorCodeToTitleEn, parseQueryDevtoolsOverrideTransfer, parseQueryRoute, patchQueryDevtoolsTokenPayload, pathParamsMissingInRouteFunctionError, provideInfinityQueryResponseDelay, provideLegacyPrepareFallback, provideQueryClientForDevtools, provideQueryDevtools, queryArrayComputed, queryBatchAlreadyRunning, queryBatchWithArgsUsed, queryClientFeatureUsedMultipleTimes, queryComputed, queryComputedTillTruthy, queryDevtoolsAbout, queryDevtoolsAllowsLocalAuthSessions, queryDevtoolsApiEnvIds, queryDevtoolsApiEnvIsProduction, queryDevtoolsApiEnvScope, queryDevtoolsApiEnvValues, queryDevtoolsApiEnvs, queryDevtoolsArmedMocks, queryDevtoolsArmedMocksRestored, queryDevtoolsAuthAccountsFor, queryDevtoolsAuthActive, queryDevtoolsAuthFieldsFor, queryDevtoolsAuthOtherScopeCount, queryDevtoolsAuthProviders, queryDevtoolsAuthSessions, queryDevtoolsAuthSessionsFor, queryDevtoolsAuthTabLocal, queryDevtoolsEntries, queryDevtoolsFaults, queryDevtoolsFaultsRestored, queryDevtoolsFnDetail, queryDevtoolsMockId, queryDevtoolsMocks, queryDevtoolsOverridePersistence, queryDevtoolsRequestPath, queryDevtoolsResponseHistory, queryDevtoolsRestoredOverridesScope, queryDevtoolsSchemaNames, queryDevtoolsSchemaRoutes, queryDevtoolsSchemaState, queryDevtoolsSettings, queryDevtoolsStorage, queryDevtoolsTokenTtls, queryErrorMessage, queryErrorMessages, queryExecute, queryExecutedAfterDestroyMessage, queryFeatureUsedMultipleTimes, queryField, querySequence, querySequenceAlreadyRunning, queryStackWithArgsUsed, queryStackWithResponseUpdateUsed, queryStateAlreadyHasKeyError, queryStateCannotTransformError, queryStateDoesNotContainKeyError, queryStateErrorSignal, queryStateLoadingSignal, queryStateResponseSignal, queryStateSignal, readQueryDevtoolsAuthSeed, readQueryDevtoolsAuthSeedFor, readQueryDevtoolsStore, registerEthleteVersion, registerLiveQueryDevtoolsRepository, registerQueryDevtoolsAuthProvider, registerQueryDevtoolsEntry, registerQueryErrorParser, releaseQueryDevtoolsOverridePersistence, removeFrom, removeQueryDevtoolsAuthAccount, renameQueryDevtoolsAuthSession, request, resetExecuteState, resetPageOnError, resolveInvalidationUrl, resolveQueryDevtoolsFault, resolveQueryDevtoolsFaultForAttempt, resolveQueryDevtoolsMock, resolveQueryDevtoolsMockForAttempt, restoredQueryDevtoolsOverrides, runDefaultQueryRetry, runInQueryDevtoolsBatch, runQueryErrorParsers, saveQueryDevtoolsMock, searchQueryField, seedQueryDevtoolsSchemaBody, seedQueryDevtoolsSchemaRoute, serializeBody, serializeQueryDevtoolsOverrideTransfer, setDefaultQueryRetryFn, setQueryDevtoolsApiEnv, setQueryDevtoolsApiEnvs, setQueryDevtoolsAppInfo, setQueryDevtoolsArmedMocksScope, setQueryDevtoolsAuthCredentials, setQueryDevtoolsAuthProviderRegistrar, setQueryDevtoolsAuthSeedReader, setQueryDevtoolsAuthTabLocal, setQueryDevtoolsFault, setQueryDevtoolsFaultResolver, setQueryDevtoolsFaultsScope, setQueryDevtoolsFormLinksFactory, setQueryDevtoolsMockResolver, setQueryDevtoolsOverridePersistence, setQueryDevtoolsOverridesFactory, setQueryDevtoolsOverridesScope, setQueryDevtoolsRegistrar, setQueryDevtoolsResponseHistory, setQueryDevtoolsSchemaLoader, setQueryDevtoolsSettings, setQueryDevtoolsStatsFactory, setQueryDevtoolsTokenPayloadPatcher, setQueryDevtoolsTokenTtl, setQueryDevtoolsUiMounted, setupQueryDependencies, setupQueryExecuteState, setupQueryState, shouldAutoExecuteGqlQuery, shouldAutoExecuteQuery, shouldCacheQuery, shouldRetryRequest, silenceMissingWithArgsFeatureErrorUsedButWithArgsPresent, skipPaginationPageParamCalculator, smartDuplicateArrayItem, snapshotQueryDevtoolsHandle, sortQueryField, splitQueryConfig, stringArrayQueryField, stringifyQueryRouteParts, sumQueryDevtoolsStats, suppressNextQueryStackDevtools, switchQueryCollectionState, switchQueryDevtoolsAuthSession, switchQueryState, symfonyQueryErrorParser, takeUntilResponse, toQuerySignal, toQuerySubject, tokensNotAvailableInsideAuthAndExec, tombstoneOf, trackQueryDevtoolsAuthProvider, 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 };
+export { AuthBearerRefreshStrategy, 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_BATCH_TOMBSTONES, 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, QueryStateType, QueryStore, SERVER_ERROR_KIND, SERVER_VIOLATION_ERROR_KIND, SPEED_BUFFER_TIME_IN_MS, SearchQueryField, SortQueryField, StringArrayQueryField, V2BearerAuthProvider, V2Query, V2QueryClient, V2QueryCreator, addQueryContainerHandling, addQueryDevtoolsAuthAccount, applyQueryDevtoolsOverrides, applyQueryDevtoolsTokenTtl, applyQueryFeatures, armAllQueryDevtoolsMocks, armQueryDevtoolsMock, armQueryDevtoolsOverrideTransfer, authExtractTokensResponseMissingAccessToken, authExtractTokensResponseMissingRefreshToken, authExtractTokensResponseNotObject, authProviderFeatureUsedMultipleTimes, booleanArrayQueryField, buildQueryCacheKey, buildQueryString, buildRoute, buildTimestampFromSeconds, canOverrideQueryDevtoolsTokenTtl, castQueryCreatorTypes, circularQueryDependency, circularQueryDependencyChecker, clearQueryDevtoolsArmedMocks, clearQueryDevtoolsAuthCredentials, clearQueryDevtoolsAuthSessions, 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, createHeadQuery, createHttpRequest, createIndexedDbQueryPersistenceAdapter, createInfinityQueryConfig, createLegacyQueryCreator, createNoopQueryPersistenceAdapter, createOptionsQuery, createPagedQueryStack, createPatchQuery, createPersistentAuthFeature, createPostQuery, createPutQuery, createQuery, createQueryBatch, createQueryClient, createQueryCollection, createQueryCollectionSignal, createQueryCollectionSubject, createQueryContext, createQueryCreator, createQueryDevtoolsFormLinks, createQueryDevtoolsFormLinksRecorder, createQueryDevtoolsOverrides, createQueryDevtoolsOverridesRecorder, createQueryDevtoolsStats, createQueryDevtoolsStatsRecorder, createQueryErrorResponse, createQueryFeature, createQueryInvalidationFilter, createQueryKeyLockManager, createQueryObject, createQueryPersistenceEngine, createQueryRepository, createQuerySnapshotFn, createQueryStack, createQuerySubmission, createQuerySyncEngine, createQuerySyncTransport, createSecureDeleteQuery, createSecureExecuteFactory, createSecureExecuteFn, createSecureGetQuery, createSecureGqlExecuteFn, createSecureGqlMutationViaGet, createSecureGqlMutationViaPost, createSecureGqlQuery, createSecureGqlQueryCreator, createSecureGqlQueryViaGet, createSecureGqlQueryViaPost, createSecureHeadQuery, createSecureOptionsQuery, createSecurePatchQuery, createSecurePostQuery, createSecurePutQuery, createSecureQuery, createSecureQueryCreator, createTrackingFeature, createWebSocketClient, currentQueryDevtoolsBatch, 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, forgetQueryDevtoolsAuthSession, forgetQueryDevtoolsAuthSessionsFor, formatQueryDevtoolsDuration, generateQueryDevtoolsNumberPreset, generateQueryDevtoolsSampleNumber, generateQueryDevtoolsStringPreset, getBearerAuthProviderName, getDefaultHeaders, getQueryClientName, getQueryFeatureUsage, getResponseUrl, ggLikePaginationAdapter, gql, gqlDataPropertyMissingInResponse, gqlErrorsInResponse, gqlTransformerFor, hasHeader, hasQueryDevtoolsOverridesAtPath, htmlErrorPayload, htmlQueryErrorParser, ignoreAutoRefresh, initQueryDevtoolsAuthSessions, initQueryDevtoolsFaults, initQueryDevtoolsMocks, initQueryDevtoolsOverridePersistence, initQueryDevtoolsSettings, injectInfinityQueryResponseDelay, injectQueryContext, insertFrom, invalidBaseRouteError, invalidBodyError, invalidRouteError, invalidStateInsideSecureExecuteFactory, isAutoRefresh, isBasicAuthProvider, isBearerAuthProvider, isClassValidatorError, isCreateGqlQueryOptions, isCustomHeaderAuthProvider, isDateShapedLeaf, isEmptyString, isGqlQueryConfig, isHtmlErrorPayload, isIdempotentQueryMethod, isLegacyQuery, isNaN$1 as isNaN, isPageOutOfRangeError, isQuery, isQueryCollection, isQueryDevtoolsEnabled, isQueryDevtoolsFaultArmed, isQueryDevtoolsRepositoryLive, isQueryDevtoolsRequestInterceptionEnabled, isQueryErrorResponse, isQueryStateCancelled, isQueryStateFailure, isQueryStateLoading, isQueryStatePrepared, isQueryStateSuccess, isRequestError, isSymfonyError, isSymfonyFormViolationListError, isSymfonyListError, isSymfonyPagerfantaOutOfRangeError, isUnderInvalidatedUrl, legacyPrepareFallbackInjector, legacyPrepareWithoutInjectionContext, loadQueryDevtoolsSchema, loginQueryDevtoolsAuthAccount, logoutQueryDevtoolsAuthSession, mapToPaginated, mapViolationsToFormErrors, matchesQueryDevtoolsMockPattern, matchesQueryDevtoolsMockQuery, maybeExecute, measureQueryDevtoolsPayload, mergeHeaders, nestedEffect, noteQueryFormRead, noteQueryFormReads, numberArrayQueryField, pagedQueryStackNextPageCalledWithoutPreviousPage, pagedQueryStackPageBiggerThanTotalPages, pagedQueryStackPreviousPageCalledButAlreadyAtFirstPage, paginatedEntityValueUpdater, parseAllXhrResponseHeaders, parseHttpErrorCodeToMessageDe, parseHttpErrorCodeToMessageEn, parseHttpErrorCodeToTitleDe, parseHttpErrorCodeToTitleEn, parseQueryDevtoolsOverrideTransfer, parseQueryRoute, patchQueryDevtoolsTokenPayload, pathParamsMissingInRouteFunctionError, provideInfinityQueryResponseDelay, provideLegacyPrepareFallback, provideQueryClientForDevtools, provideQueryDevtools, queryArrayComputed, queryBatchAlreadyRunning, queryBatchWithArgsUsed, queryClientFeatureUsedMultipleTimes, queryComputed, queryComputedTillTruthy, queryDevtoolsAbout, queryDevtoolsAllowsLocalAuthSessions, queryDevtoolsApiEnvIds, queryDevtoolsApiEnvIsProduction, queryDevtoolsApiEnvScope, queryDevtoolsApiEnvValues, queryDevtoolsApiEnvs, queryDevtoolsArmedMocks, queryDevtoolsArmedMocksRestored, queryDevtoolsAuthAccountsFor, queryDevtoolsAuthActive, queryDevtoolsAuthFieldsFor, queryDevtoolsAuthOtherScopeCount, queryDevtoolsAuthProviders, queryDevtoolsAuthSessions, queryDevtoolsAuthSessionsFor, queryDevtoolsAuthTabLocal, queryDevtoolsEntries, queryDevtoolsFaults, queryDevtoolsFaultsRestored, queryDevtoolsFnDetail, queryDevtoolsMockId, queryDevtoolsMocks, queryDevtoolsOverridePersistence, queryDevtoolsRequestPath, queryDevtoolsResponseHistory, queryDevtoolsRestoredOverridesScope, queryDevtoolsSchemaNames, queryDevtoolsSchemaRoutes, queryDevtoolsSchemaState, queryDevtoolsSettings, queryDevtoolsStorage, queryDevtoolsTokenTtls, queryErrorMessage, queryErrorMessages, queryExecute, queryExecutedAfterDestroyMessage, queryFeatureUsedMultipleTimes, queryField, querySequence, querySequenceAlreadyRunning, queryStackWithArgsUsed, queryStackWithResponseUpdateUsed, queryStateAlreadyHasKeyError, queryStateCannotTransformError, queryStateDoesNotContainKeyError, queryStateErrorSignal, queryStateLoadingSignal, queryStateResponseSignal, queryStateSignal, readQueryDevtoolsAuthSeed, readQueryDevtoolsAuthSeedFor, readQueryDevtoolsStore, registerEthleteVersion, registerLiveQueryDevtoolsRepository, registerQueryDevtoolsAuthProvider, registerQueryDevtoolsEntry, registerQueryErrorParser, releaseQueryDevtoolsOverridePersistence, removeFrom, removeQueryDevtoolsAuthAccount, renameQueryDevtoolsAuthSession, request, resetExecuteState, resetPageOnError, resolveInvalidationUrl, resolveQueryDevtoolsFault, resolveQueryDevtoolsFaultForAttempt, resolveQueryDevtoolsMock, resolveQueryDevtoolsMockForAttempt, resolveQueryHeaders, restoredQueryDevtoolsOverrides, runDefaultQueryRetry, runInQueryDevtoolsBatch, runQueryErrorParsers, saveQueryDevtoolsMock, searchQueryField, seedQueryDevtoolsSchemaBody, seedQueryDevtoolsSchemaRoute, serializeBody, serializeQueryDevtoolsOverrideTransfer, setDefaultQueryRetryFn, setQueryDevtoolsApiEnv, setQueryDevtoolsApiEnvs, setQueryDevtoolsAppInfo, setQueryDevtoolsArmedMocksScope, setQueryDevtoolsAuthCredentials, setQueryDevtoolsAuthProviderRegistrar, setQueryDevtoolsAuthSeedReader, setQueryDevtoolsAuthTabLocal, setQueryDevtoolsFault, setQueryDevtoolsFaultResolver, setQueryDevtoolsFaultsScope, setQueryDevtoolsFormLinksFactory, setQueryDevtoolsMockResolver, setQueryDevtoolsOverridePersistence, setQueryDevtoolsOverridesFactory, setQueryDevtoolsOverridesScope, setQueryDevtoolsRegistrar, setQueryDevtoolsResponseHistory, setQueryDevtoolsSchemaLoader, setQueryDevtoolsSettings, setQueryDevtoolsStatsFactory, setQueryDevtoolsTokenPayloadPatcher, setQueryDevtoolsTokenTtl, setQueryDevtoolsUiMounted, setupQueryDependencies, setupQueryExecuteState, setupQueryState, shouldAutoExecuteGqlQuery, shouldAutoExecuteQuery, shouldCacheQuery, shouldRetryRequest, silenceMissingWithArgsFeatureErrorUsedButWithArgsPresent, skipPaginationPageParamCalculator, smartDuplicateArrayItem, snapshotQueryDevtoolsHandle, sortQueryField, splitQueryConfig, stringArrayQueryField, stringifyQueryRouteParts, sumQueryDevtoolsStats, suppressNextQueryStackDevtools, switchQueryCollectionState, switchQueryDevtoolsAuthSession, switchQueryState, symfonyQueryErrorParser, takeUntilResponse, toQuerySignal, toQuerySubject, tokensNotAvailableInsideAuthAndExec, tombstoneOf, trackQueryDevtoolsAuthProvider, transformArrayResponse, transformExecStateToQueryState, transformGql, transformMethod, transformPaginatedResponse, transformToBoolean, transformToBooleanArray, transformToDate, transformToDateArray, transformToNumber, transformToNumberArray, transformToSort, transformToSortQueryParam, transformToString, transformToStringArray, uncacheableRequestHasAllowCacheParam, uncacheableRequestHasCacheKeyParam, unwrapGqlResponseWithErrors, 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