@ethlete/query 6.0.0-next.28 → 6.0.0-next.29

package/fesm2022/ethlete-query.mjs

@@ -1,6 +1,6 @@
 import * as i0 from '@angular/core';
 import { DestroyRef, InjectionToken, inject, Injector, EnvironmentInjector, ElementRef, ErrorHandler, createEnvironmentInjector, effect, untracked, signal, linkedSignal, computed, runInInjectionContext, isDevMode, PLATFORM_ID, resource, DOCUMENT, makeEnvironmentProviders, assertInInjectionContext, provideEnvironmentInitializer, ChangeDetectorRef, ViewContainerRef, TemplateRef, Input, Directive, input, Pipe, ViewEncapsulation, Component, NgZone } from '@angular/core';
-import { defineStaticProvider, RuntimeError, clamp, randomId, defineRootProvider, isObject, injectUnsavedChangesCoordinator, injectRoute, getCookie, getDomain, setCookie, deleteCookie, createDestroy, computedTillTruthy, defineProvider, toProvideFn, toInjectFn, nextFrame, injectQueryParams, injectQueryParamChanges, clone, equal, ET_PROPERTY_REMOVED, previousSignalValue } from '@ethlete/core';
+import { defineStaticProvider, RuntimeError, clamp, randomId, defineRootProvider, isObject, injectUnsavedChangesCoordinator, injectRoute, getCookie, getDomain, deleteCookie, setCookie, createDestroy, computedTillTruthy, defineProvider, toProvideFn, toInjectFn, nextFrame, injectQueryParams, injectQueryParamChanges, clone, equal, ET_PROPERTY_REMOVED, previousSignalValue } from '@ethlete/core';
 import { filter, Subject, Subscription, defer, throwError, timer, switchMap, tap, retry, catchError, take, of, merge, firstValueFrom, fromEvent, throttleTime, interval, combineLatest, map, Observable, takeUntil, startWith, pairwise, BehaviorSubject, ReplaySubject, shareReplay, skip, takeWhile, EMPTY, withLatestFrom, debounceTime } from 'rxjs';
 import { HttpClient, HttpEventType, HttpErrorResponse, HttpHeaders, HttpStatusCode } from '@angular/common/http';
 import { toObservable, takeUntilDestroyed, toSignal } from '@angular/core/rxjs-interop';
@@ -50,7 +50,7 @@ const queryDevtoolsFnDetail = (fn, key) => {
     return name ? [{ label: key, value: name }] : [];
 };
 
-const noop$2 = () => undefined;
+const noop$3 = () => undefined;
 let registrar = null;
 /**
  * Installs the real registry. Called by `provideQueryDevtools()`; nothing else may call it.
@@ -70,7 +70,7 @@ const isQueryDevtoolsEnabled = () => registrar !== null;
  * a no-op callback) unless {@link provideQueryDevtools} has been called.
  * @internal
  */
-const registerQueryDevtoolsEntry = (entry) => registrar?.(entry) ?? noop$2;
+const registerQueryDevtoolsEntry = (entry) => registrar?.(entry) ?? noop$3;
 let statsFactory = null;
 /**
  * Installs the stats recorder factory. Called by `provideQueryDevtools()`; nothing else may call it.
@@ -1023,7 +1023,7 @@ const createBaseQuery = (options) => {
         if (devtoolsStats) {
             const statsSubscription = state.events$.subscribe((event) => {
                 if (event.type === 'error') {
-                    devtoolsStats.recordError({ faulted: event.faulted });
+                    devtoolsStats.recordError({ faulted: event.faulted, error: event.error });
                 }
                 else if (event.type === HttpEventType.Response) {
                     devtoolsStats.recordResponse({ headers: event.headers, body: event.body });
@@ -1085,7 +1085,7 @@ const setupQueryExecuteState = () => {
     };
 };
 const queryExecute = (options) => {
-    const { executeOptions, args, executeState, options: runQueryOptions, isSecure } = options;
+    const { executeOptions, args, executeState, options: runQueryOptions, isSecure, isRefreshable } = options;
     const { deps, state, creator, creatorInternals, queryConfig } = executeOptions;
     const { key, request, executed } = deps.client.repository.request({
         route: creatorInternals.route,
@@ -1098,6 +1098,7 @@ const queryExecute = (options) => {
         previousKey: executeState.previousKey(),
         runQueryOptions,
         isSecure,
+        isRefreshable,
         silenceUncacheableAllowCacheError: queryConfig.silenceUncacheableAllowCacheError,
     });
     executeState.previousKey.set(key);
@@ -1850,8 +1851,13 @@ const createQueryStack = (options) => {
                         removeStrategy === 'newest' ? finalQueries.slice(0, maxQueries) : finalQueries.slice(-maxQueries);
                 }
                 queries.set(finalQueries);
-                lastQuery.set(lastAppendedQuery);
-                return lastAppendedQuery;
+                // After the eviction, not before: `removeStrategy: 'newest'` destroys the query `appendFn`
+                // just returned, and `lastQuery` must never point at a query that is no longer in the stack.
+                const last = lastAppendedQuery && finalQueries.includes(lastAppendedQuery)
+                    ? lastAppendedQuery
+                    : (finalQueries[finalQueries.length - 1] ?? null);
+                lastQuery.set(last);
+                return last;
             }
             else {
                 const keyFn = argsKeyFn ?? ((a) => JSON.stringify(a));
@@ -2084,7 +2090,7 @@ const createPagedQueryStack = (options) => {
     ...(ngDevMode ? [{ debugName: "minPagination" }] : /* istanbul ignore next */ []));
     const isFirstPageLoaded = computed(() => {
         const min = minPagination();
-        return min ? loadedMinPage() === min.currentPage : false;
+        return min ? loadedMinPage() === 1 : false;
     }, /* @ts-ignore */
     ...(ngDevMode ? [{ debugName: "isFirstPageLoaded" }] : /* istanbul ignore next */ []));
     const isLastPageLoaded = computed(() => {
@@ -2164,14 +2170,16 @@ const createPagedQueryStack = (options) => {
     };
     const canFetchPreviousPage = computed(() => {
         const currentMinPagination = minPagination();
-        if (!currentMinPagination)
+        if (!currentMinPagination || stack.anyLoading())
             return false;
         return loadedMinPage() > 1;
     }, /* @ts-ignore */
     ...(ngDevMode ? [{ debugName: "canFetchPreviousPage" }] : /* istanbul ignore next */ []));
     const canFetchNextPage = computed(() => {
         const currentMaxPagination = maxPagination();
-        return currentMaxPagination ? loadedMaxPage() < currentMaxPagination.totalPages : false;
+        if (!currentMaxPagination || stack.anyLoading())
+            return false;
+        return loadedMaxPage() < currentMaxPagination.totalPages;
     }, /* @ts-ignore */
     ...(ngDevMode ? [{ debugName: "canFetchNextPage" }] : /* istanbul ignore next */ []));
     const items = computed(() => {
@@ -2891,9 +2899,9 @@ const shouldRetryRequest = (options) => {
     return { retry: false };
 };
 
-const noop$1 = () => undefined;
+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$1 };
+const alwaysHolder = { isHolder: /* @__PURE__ */ signal(true).asReadonly(), release: noop$2 };
 const noKeyStates = /* @__PURE__ */ signal({}).asReadonly();
 const createQueryKeyLockManager = (namespace) => {
     const locks = typeof navigator === 'undefined' ? undefined : navigator.locks;
@@ -3081,10 +3089,10 @@ const unwrapQuerySyncMessage = (data) => {
     return null;
 };
 
-const noop = () => undefined;
+const noop$1 = () => undefined;
 const createQuerySyncTransport = (channelName) => {
     if (typeof BroadcastChannel === 'undefined') {
-        return { post: noop, listen: () => noop, destroy: noop, isSupported: false };
+        return { post: noop$1, listen: () => noop$1, destroy: noop$1, isSupported: false };
     }
     const channel = new BroadcastChannel(channelName);
     const listeners = new Set();
@@ -3361,6 +3369,7 @@ const createQueryRepository = (config) => {
         const shouldCache = creatorOptions?.subtle?.useQueryRepositoryCache === false
             ? false
             : shouldCacheQuery(options.method) || creatorOptions?.subtle?.useQueryRepositoryCache === true;
+        const isRefreshable = shouldCache && (options.isRefreshable ?? shouldCacheQuery(options.method));
         if (!shouldCache && options.key)
             throw uncacheableRequestHasCacheKeyParam(options.key);
         // `allowCache` is never read on the uncacheable path below - there is no cache entry to reuse - so this throw
@@ -3407,6 +3416,7 @@ const createQueryRepository = (config) => {
                     request: cacheEntry.request,
                     isSecure,
                     isCached: true,
+                    isRefreshable,
                     isMultiTabSyncEnabled,
                     isPersistEnabled,
                     keepUnusedFor,
@@ -3435,6 +3445,7 @@ const createQueryRepository = (config) => {
             request,
             isSecure,
             isCached: shouldCache,
+            isRefreshable,
             isMultiTabSyncEnabled,
             isPersistEnabled,
             keepUnusedFor,
@@ -3446,11 +3457,13 @@ const createQueryRepository = (config) => {
         return { key: trackingKey, request, executed };
     };
     /** Tears an entry down for good, whether it currently has consumers or not. */
-    const destroyEntry = (key, cacheEntry) => {
+    const destroyEntry = (key, cacheEntry, cause) => {
+        const { method, url } = cacheEntry.request;
         clearTimeout(cacheEntry.evictTimer);
         cacheEntry.request.destroy();
         cacheEntry.eventSubscription?.unsubscribe();
         cache.delete(key);
+        eventsSubject.next({ type: 'entry-destroyed', key, isSecure: cacheEntry.isSecure, method, url, cause });
     };
     const cancelEviction = (cacheEntry) => {
         if (cacheEntry.evictTimer === undefined)
@@ -3466,12 +3479,12 @@ const createQueryRepository = (config) => {
             return;
         unused.sort(([, a], [, b]) => (a.unusedSince ?? 0) - (b.unusedSince ?? 0));
         for (const [key, entry] of unused.slice(0, unused.length - MAX_UNUSED_ENTRIES)) {
-            destroyEntry(key, entry);
+            destroyEntry(key, entry, 'unused-cap');
         }
     };
     const retain = (key, cacheEntry) => {
         cacheEntry.unusedSince = Date.now();
-        cacheEntry.evictTimer = setTimeout(() => evict(key), cacheEntry.keepUnusedFor);
+        cacheEntry.evictTimer = setTimeout(() => evict(key, 'expired'), cacheEntry.keepUnusedFor);
         enforceUnusedEntryLimit();
     };
     const unbind = (key, consumerDestroyRef) => {
@@ -3488,7 +3501,7 @@ const createQueryRepository = (config) => {
                 retain(key, cacheEntry);
             }
             else {
-                destroyEntry(key, cacheEntry);
+                destroyEntry(key, cacheEntry, 'unbind');
             }
         }
         bumpCacheVersion();
@@ -3501,7 +3514,7 @@ const createQueryRepository = (config) => {
             // Force the teardown instead of routing through `unbind`: a logged out session must not leave a
             // retained response body behind waiting out its `keepUnusedFor` window.
             cacheEntry.consumers.clear();
-            destroyEntry(key, cacheEntry);
+            destroyEntry(key, cacheEntry, 'logout');
         }
         bumpCacheVersion();
         eventsSubject.next({ type: 'unbind-all-secure' });
@@ -3511,10 +3524,11 @@ const createQueryRepository = (config) => {
         for (const cacheEntry of cache.values()) {
             if (cacheEntry.consumers.size === 0)
                 continue;
-            // Re-firing a mutation would be a side effect nobody asked for, so only reads are refreshed -
-            // "read" meaning cacheable, which also covers a GQL query transported via POST that opted into
-            // the cache explicitly.
-            if (!cacheEntry.isCached)
+            // Re-firing a mutation would be a side effect nobody asked for, so only reads are refreshed:
+            // a cacheable method, or a GQL query transported via POST. Opting into the cache alone does not
+            // qualify - the auth queries do that for a stable cache key, and replaying a login POST would
+            // end the session.
+            if (!cacheEntry.isRefreshable)
                 continue;
             if (filter && !filter(cacheEntry.request))
                 continue;
@@ -3548,7 +3562,7 @@ const createQueryRepository = (config) => {
         return true;
     };
     const bind = (options) => {
-        const { key, consumerDestroyRef, request, isSecure, isCached, isMultiTabSyncEnabled, isPersistEnabled, keepUnusedFor, } = options;
+        const { key, consumerDestroyRef, request, isSecure, isCached, isRefreshable, isMultiTabSyncEnabled, isPersistEnabled, keepUnusedFor, } = options;
         const destroyListener = consumerDestroyRef.onDestroy(() => unbind(key, consumerDestroyRef));
         const cacheEntry = cache.get(key);
         if (cacheEntry && isCached) {
@@ -3585,6 +3599,7 @@ const createQueryRepository = (config) => {
                 eventSubscription,
                 keepUnusedFor,
                 isCached,
+                isRefreshable,
                 isMultiTabSyncEnabled,
                 isPersistEnabled,
             });
@@ -3598,11 +3613,11 @@ const createQueryRepository = (config) => {
         isUnused: entry.consumers.size === 0,
         request: entry.request,
     }));
-    const evict = (key) => {
+    const evict = (key, cause = 'manual') => {
         const entry = cache.get(key);
         if (!entry)
             return;
-        destroyEntry(key, entry);
+        destroyEntry(key, entry, cause);
         bumpCacheVersion();
     };
     const repository = {
@@ -4295,61 +4310,103 @@ const deriveExecutionStateType = (builder, triggeredBy) => {
         return 'revocation';
     return builder.key;
 };
-const setupBearerQueryRegistry = (builders, injector, latestExecutedQuery, latestNonInternalQuery, applyTokens, executionState) => {
+const setupBearerQueryRegistry = (builders, context) => {
+    const { injector, latestExecutedQuery, latestNonInternalQuery, applyTokens, executionState, sessionStatus } = context;
     const queries = {};
     const querySnapshots = new Map();
+    // Supersession is provider-wide, not per key. Within one key the reused query already handles it,
+    // but a token refresh landing while a login is in flight would otherwise apply its tokens over the
+    // login's and report its own outcome as the session's - two writers, two different executions.
+    let latestExecutionId = 0;
+    const currentExecutions = [];
     for (const builder of builders) {
         const querySnapshot = signal(null, /* @ts-ignore */
         ...(ngDevMode ? [{ debugName: "querySnapshot" }] : /* istanbul ignore next */ []));
         querySnapshots.set(builder.key, querySnapshot);
         const extractTokens = builder.config.extractTokens ?? defaultExtractTokens;
+        // A 2xx whose body carries no usable tokens is a failed execution, not a successful one - the
+        // state effect below reads this so it cannot report `success` for an attempt that left the tab
+        // unauthenticated.
+        const extractionError = signal(null, /* @ts-ignore */
+        ...(ngDevMode ? [{ debugName: "extractionError" }] : /* istanbul ignore next */ []));
+        const currentExecution = signal(null, /* @ts-ignore */
+        ...(ngDevMode ? [{ debugName: "currentExecution" }] : /* istanbul ignore next */ []));
+        currentExecutions.push(currentExecution);
+        const isSuperseded = (execution) => execution.id !== null && execution.id !== latestExecutionId;
+        // Runs before the state effect below, which reads the extraction error this one writes. Angular
+        // runs effects in creation order, so the two must stay in this order.
         effect(() => {
-            const snapshot = querySnapshot();
-            if (!snapshot)
+            const execution = currentExecution();
+            if (!execution)
                 return;
+            const { snapshot } = execution;
             const response = snapshot.response();
             const loading = snapshot.loading();
             const error = snapshot.error();
-            if (response && !loading && !error) {
+            if (response && !loading && !error && !isSuperseded(execution)) {
                 try {
                     const tokens = extractTokens(response);
+                    extractionError.set(null);
                     applyTokens(tokens.accessToken, tokens.refreshToken);
                 }
                 catch (extractError) {
+                    extractionError.set(createQueryErrorResponse(extractError));
                     if (isDevMode()) {
                         console.error(`Failed to extract tokens from ${builder.key} response:`, extractError);
                     }
                 }
             }
         });
+        effect(() => {
+            const execution = currentExecution();
+            if (!execution)
+                return;
+            const { type, snapshot } = execution;
+            const response = snapshot.response();
+            const loading = snapshot.loading();
+            const error = snapshot.error();
+            if (loading || isSuperseded(execution))
+                return;
+            if (error) {
+                executionState.set({ type, state: 'error', error });
+            }
+            else if (response) {
+                const failedExtraction = extractionError();
+                if (failedExtraction) {
+                    executionState.set({ type, state: 'error', error: failedExtraction });
+                }
+                else {
+                    executionState.set({ type, state: 'success', response });
+                }
+            }
+            // Keyed on `isAlive` rather than on the branches above: a cancelled restore produces neither a
+            // response nor an error, and would otherwise leave `sessionStatus` at `restoring` forever.
+            if (type === 'autoLogin' && !snapshot.isAlive() && !untracked(context.isAuthenticated)) {
+                sessionStatus.set('anonymous');
+            }
+        });
+        // One query per builder, reused by every execution. A query owns a child injector, a devtools
+        // entry and a repository binding holding the request and response bodies - creating one per login
+        // attempt or token refresh grows all of that for as long as the tab lives.
+        let query = null;
         const execute = (args, options) => {
-            const query = builder.config.queryCreator({
-                onlyManualExecution: true,
-                injector,
-            });
+            query ??= builder.config.queryCreator({ onlyManualExecution: true, injector });
+            extractionError.set(null);
             query.execute({ args, options });
             const snapshot = query.createSnapshot();
             const stateType = deriveExecutionStateType(builder, options?.triggeredBy);
-            if (stateType !== 'revocation') {
+            const isRevocation = stateType === 'revocation';
+            if (!isRevocation) {
                 latestExecutedQuery.set({ key: builder.key, snapshot });
                 if (!snapshot.triggeredBy()) {
                     latestNonInternalQuery.set({ key: builder.key, snapshot });
                 }
             }
             executionState.set({ type: stateType, state: 'loading' });
-            effect(() => {
-                const response = snapshot.response();
-                const loading = snapshot.loading();
-                const error = snapshot.error();
-                if (loading)
-                    return;
-                if (error) {
-                    executionState.set({ type: stateType, state: 'error', error });
-                }
-                else if (response) {
-                    executionState.set({ type: stateType, state: 'success', response });
-                }
-            }, { injector });
+            if (stateType === 'autoLogin') {
+                sessionStatus.set('restoring');
+            }
+            currentExecution.set({ id: isRevocation ? null : ++latestExecutionId, type: stateType, snapshot });
             querySnapshot.set(snapshot);
             return snapshot;
         };
@@ -4358,7 +4415,12 @@ const setupBearerQueryRegistry = (builders, injector, latestExecutedQuery, lates
             snapshot: querySnapshot.asReadonly(),
         };
     }
-    return { queries, querySnapshots };
+    const hasTokenIssuingExecutionInFlight = computed(() => currentExecutions.some((execution) => {
+        const current = execution();
+        return !!current && current.id !== null && current.snapshot.isAlive();
+    }), /* @ts-ignore */
+    ...(ngDevMode ? [{ debugName: "hasTokenIssuingExecutionInFlight" }] : /* istanbul ignore next */ []));
+    return { queries, querySnapshots, hasTokenIssuingExecutionInFlight };
 };
 const setupFeatures = (featureBuilders, context) => {
     const features = {};
@@ -4403,6 +4465,7 @@ const alwaysLeader = () => true;
 const runEarlyFeatureSetup = (featureBuilders, context) => {
     let isLeaderFn = alwaysLeader;
     let leaderElectionContext;
+    let refreshCoordination;
     for (const featureBuilder of featureBuilders ?? []) {
         const earlySetup = featureBuilder.earlySetup;
         if (!earlySetup)
@@ -4410,8 +4473,9 @@ const runEarlyFeatureSetup = (featureBuilders, context) => {
         const result = earlySetup(context);
         isLeaderFn = result.isLeader ?? isLeaderFn;
         leaderElectionContext = result.leaderElection ?? leaderElectionContext;
+        refreshCoordination = result.refreshCoordination ?? refreshCoordination;
     }
-    return { isLeaderFn, leaderElectionContext };
+    return { isLeaderFn, leaderElectionContext, refreshCoordination };
 };
 const createBearerAuthProviderImpl = (config) => {
     const injector = inject(Injector);
@@ -4446,9 +4510,15 @@ const createBearerAuthProviderImpl = (config) => {
     ...(ngDevMode ? [{ debugName: "latestNonInternalQuery" }] : /* istanbul ignore next */ []));
     const executionState = signal(null, /* @ts-ignore */
     ...(ngDevMode ? [{ debugName: "executionState" }] : /* istanbul ignore next */ []));
+    const sessionStatus = signal('unknown', /* @ts-ignore */
+    ...(ngDevMode ? [{ debugName: "sessionStatus" }] : /* istanbul ignore next */ []));
+    const sessionEndCause = signal(null, /* @ts-ignore */
+    ...(ngDevMode ? [{ debugName: "sessionEndCause" }] : /* istanbul ignore next */ []));
     const applyTokens = (access, refresh) => {
         accessToken.set(access);
         refreshToken.set(refresh);
+        sessionStatus.set('authenticated');
+        sessionEndCause.set(null);
         afterTokenRefresh$.next();
     };
     // Public entry point only - a query-driven login already reports its own, more specific
@@ -4458,20 +4528,37 @@ const createBearerAuthProviderImpl = (config) => {
         applyTokens(access, refresh);
         executionState.set({ type: 'tokenSeed', state: 'success' });
     };
-    const { queries } = setupBearerQueryRegistry(config.queries, injector, latestExecutedQuery, latestNonInternalQuery, applyTokens, executionState);
-    const logout = () => {
+    const { queries, hasTokenIssuingExecutionInFlight } = setupBearerQueryRegistry(config.queries, {
+        injector,
+        latestExecutedQuery,
+        latestNonInternalQuery,
+        applyTokens,
+        executionState,
+        sessionStatus,
+        isAuthenticated,
+    });
+    const logout = (cause = 'user') => {
         accessToken.set(null);
         refreshToken.set(null);
         queryClient.repository.unbindAllSecure();
         latestExecutedQuery.set(null);
         latestNonInternalQuery.set(null);
         executionState.set({ type: 'logout', state: 'success' });
+        sessionStatus.set('anonymous');
+        sessionEndCause.set(cause);
         // Unsaved edits can no longer be saved once the session is gone. Guarding them past this point
         // only strands a "discard your changes?" dialog over the login page the app redirects to, and
         // leaves the tab locked against closing. See `injectUnsavedChangesCoordinator`.
         unsavedChanges.abandonAll('logout');
     };
-    const isLeader = runEarlyFeatureSetup(config.features, { accessToken, refreshToken, queryClient });
+    const isLeader = runEarlyFeatureSetup(config.features, {
+        accessToken,
+        refreshToken,
+        queryClient,
+        name: config.name,
+        applyTokens,
+        logout,
+    });
     const querySetupContext = {
         accessToken,
         refreshToken,
@@ -4479,8 +4566,11 @@ const createBearerAuthProviderImpl = (config) => {
         queryClient,
         repository: queryClient.repository,
         isLeader: isLeader.isLeaderFn,
+        refreshCoordination: isLeader.refreshCoordination,
+        logout,
         afterTokenRefresh$,
         queries: queries,
+        hasTokenIssuingExecutionInFlight,
     };
     for (const builder of config.queries) {
         builder.setup?.(querySetupContext);
@@ -4498,8 +4588,15 @@ const createBearerAuthProviderImpl = (config) => {
         afterTokenRefresh$,
         queries: queries,
         executionState,
+        sessionStatus: sessionStatus.asReadonly(),
+        sessionEndCause: sessionEndCause.asReadonly(),
     };
     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.
+    if (sessionStatus() === 'unknown') {
+        sessionStatus.set('anonymous');
+    }
     const provider = {
         queries,
         features: features,
@@ -4510,6 +4607,8 @@ const createBearerAuthProviderImpl = (config) => {
         latestExecutedQuery: latestExecutedQuery.asReadonly(),
         latestNonInternalQuery: latestNonInternalQuery.asReadonly(),
         executionState: executionState.asReadonly(),
+        sessionStatus: sessionStatus.asReadonly(),
+        sessionEndCause: sessionEndCause.asReadonly(),
         setTokens,
         logout,
         afterTokenRefresh$,
@@ -4539,7 +4638,9 @@ const withAuthenticationQuery = (key, config, setup) => ({
     key,
     config: {
         ...config,
-        queryCreator: config.queryCreator.clone({ subtle: { useQueryRepositoryCache: true } }),
+        // A spent credential entry must not sit out a retention window: the request body holds the
+        // username and password, the response the tokens it was exchanged for.
+        queryCreator: config.queryCreator.clone({ keepUnusedFor: 0, subtle: { useQueryRepositoryCache: true } }),
     },
     setup,
 });
@@ -4574,20 +4675,30 @@ const withRefreshQuery = (key, config) => {
         const minRefreshInterval = config.minRefreshInterval ?? 30000; // 30 seconds default
         const refreshIfExpired = config.refreshIfExpired ?? true;
         let lastRefreshTime = 0;
-        const executeRefresh = (triggeredInternally = true) => {
+        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+        const refreshQuery = () => context.queries[key];
+        const executeRefresh = (reason) => {
             const currentRefreshToken = context.refreshToken();
-            if (!currentRefreshToken || !context.isLeader())
+            if (!currentRefreshToken)
                 return;
-            const now = Date.now();
-            const timeSinceLastRefresh = now - lastRefreshTime;
-            // Prevent too-frequent refreshes
-            if (timeSinceLastRefresh < minRefreshInterval)
+            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.
+                context.refreshCoordination?.request();
                 return;
-            lastRefreshTime = now;
-            // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-            context.queries[key].execute(buildArgs(currentRefreshToken), {
-                triggeredBy: triggeredInternally ? 'token-refresh' : undefined,
-            });
+            }
+            // Any token-issuing execution, not just another refresh: a login already in flight is about to
+            // issue a token pair of its own, and the refresh token this would spend belongs to the session
+            // that login is replacing.
+            if (context.hasTokenIssuingExecutionInFlight())
+                return;
+            if (reason === 'scheduled') {
+                const now = Date.now();
+                if (now - lastRefreshTime < minRefreshInterval)
+                    return;
+                lastRefreshTime = now;
+            }
+            refreshQuery().execute(buildArgs(currentRefreshToken), { triggeredBy: 'token-refresh' });
         };
         const calculateRefreshBuffer = (tokenLifetimeMs) => {
             if (typeof config.refreshStrategy === 'number') {
@@ -4638,9 +4749,24 @@ const withRefreshQuery = (key, config) => {
         }), takeUntilDestroyed())
             .subscribe((shouldRefresh) => {
             if (shouldRefresh) {
-                executeRefresh(true);
+                executeRefresh('scheduled');
             }
         });
+        context.refreshCoordination?.requests$.pipe(takeUntilDestroyed()).subscribe(() => executeRefresh('unauthorized'));
+        const onRefreshFailure = config.onRefreshFailure ??
+            (({ error, logout }) => {
+                if (!retryableStatusCodes.includes(error.code))
+                    logout();
+            });
+        effect(() => {
+            const snapshot = refreshQuery().snapshot();
+            if (!snapshot || snapshot.loading())
+                return;
+            const error = snapshot.error();
+            if (!error)
+                return;
+            onRefreshFailure({ error, logout: () => context.logout('expired') });
+        });
         // Auto-retry on 401: Listen to repository events and trigger refresh on 401 errors
         const autoRetryOn401 = config.autoRetryOn401 ?? true;
         if (autoRetryOn401) {
@@ -4656,7 +4782,7 @@ const withRefreshQuery = (key, config) => {
                 return true;
             }), takeUntilDestroyed())
                 .subscribe(() => {
-                executeRefresh(true);
+                executeRefresh('unauthorized');
             });
         }
     };
@@ -4665,7 +4791,11 @@ const withRefreshQuery = (key, config) => {
         key,
         config: {
             ...config,
-            queryCreator: config.queryCreator.clone({ retryFn: refreshRetryFn, subtle: { useQueryRepositoryCache: true } }),
+            queryCreator: config.queryCreator.clone({
+                retryFn: refreshRetryFn,
+                keepUnusedFor: 0,
+                subtle: { useQueryRepositoryCache: true },
+            }),
         },
         setup,
         buildArgs,
@@ -4697,7 +4827,7 @@ const withInactivityLogout = (config = {}) => {
         });
         const inactivityLogout$ = activity$.pipe(switchMap(() => timer(inactivityTimeout)), filter(() => enabled() && !!context.accessToken()));
         const logoutSubscription = inactivityLogout$.subscribe(() => {
-            context.logout();
+            context.logout('inactivity');
         });
         effect(() => {
             const token = context.accessToken();
@@ -4747,18 +4877,20 @@ const withInactivityLogout = (config = {}) => {
 /**
  * Namespace and key of the one lock the whole election is: whoever holds it is the leader, and every
  * other tab of the app is queued behind it. The lock name is what the instance count is derived from,
- * so the two can never disagree about who is taking part.
+ * so the two can never disagree about who is taking part. Both carry the provider's name, so two
+ * providers reachable from one origin elect a leader each instead of one between them.
  */
 const LEADER_LOCK_NAMESPACE = 'ethlete-auth';
-const LEADER_LOCK_KEY = 'leader';
-const LEADER_LOCK_NAME = 'ethlete-auth:leader';
+const leaderLockKey = (name) => `leader:${name}`;
+const leaderLockName = (name) => `${LEADER_LOCK_NAMESPACE}:${leaderLockKey(name)}`;
 /**
  * Web Locks has no "someone joined" event, so tabs announce themselves on this channel. Two messages
- * per tab lifetime, in place of the heartbeat this used to run once a second.
+ * per tab lifetime, in place of the heartbeat this used to run once a second. It also carries a
+ * follower's request for a refresh, which is the other thing a tab can only say to the leader.
  */
-const PRESENCE_CHANNEL_NAME = 'ethlete-auth-leader';
-const countLeaderRequests = (snapshot) => {
-    const isLeaderLock = (info) => info.name === LEADER_LOCK_NAME;
+const presenceChannelName = (name) => `ethlete-auth-leader:${name}`;
+const countLeaderRequests = (snapshot, lockName) => {
+    const isLeaderLock = (info) => info.name === lockName;
     // Held plus pending is exactly the tab count: every tab requests this one lock, one gets it and the
     // rest queue. The platform drops a crashed tab from both lists on its own.
     return (snapshot.held?.filter(isLeaderLock).length ?? 0) + (snapshot.pending?.filter(isLeaderLock).length ?? 0);
@@ -4775,20 +4907,29 @@ const countLeaderRequests = (snapshot) => {
  * `localStorage` implementation fell back to, and the only safe default: a session that refreshes its
  * token in every tab is wasteful, one that refreshes it in none logs the user out.
  */
-const setupLeaderElection = () => {
+const setupLeaderElection = (options) => {
     const destroyRef = inject(DestroyRef);
+    const lockName = leaderLockName(options.name);
     const lockManager = createQueryKeyLockManager(LEADER_LOCK_NAMESPACE);
-    const hold = lockManager.hold(LEADER_LOCK_KEY);
+    const hold = lockManager.hold(leaderLockKey(options.name));
     const instanceCount = signal(1, /* @ts-ignore */
     ...(ngDevMode ? [{ debugName: "instanceCount" }] : /* istanbul ignore next */ []));
-    const noopCleanup = () => {
+    const refreshRequests = new Subject();
+    const noop = () => {
         /* nothing was set up */
     };
-    // `hold.isHolder` is already `true` in this case, so the tab reads as the leader it effectively is.
+    // `hold.isHolder` is already `true` in this case, so the tab reads as the leader it effectively is,
+    // and asks nobody else for a refresh.
     if (!lockManager.isSupported) {
-        return { isLeader: hold.isHolder, instanceCount: instanceCount.asReadonly(), cleanup: noopCleanup };
+        return {
+            isLeader: hold.isHolder,
+            instanceCount: instanceCount.asReadonly(),
+            requestRefresh: noop,
+            refreshRequests$: refreshRequests.asObservable(),
+            cleanup: noop,
+        };
     }
-    const channel = typeof BroadcastChannel === 'undefined' ? null : new BroadcastChannel(PRESENCE_CHANNEL_NAME);
+    const channel = typeof BroadcastChannel === 'undefined' ? null : new BroadcastChannel(presenceChannelName(options.name));
     let isDestroyed = false;
     const recount = async () => {
         const snapshot = await navigator.locks.query();
@@ -4796,14 +4937,21 @@ const setupLeaderElection = () => {
             return;
         // Never below one: the snapshot can be taken before this tab's own request is registered, and a
         // count of zero would say the app is not running in the tab reading it.
-        instanceCount.set(Math.max(countLeaderRequests(snapshot), 1));
+        instanceCount.set(Math.max(countLeaderRequests(snapshot, lockName), 1));
     };
     const announce = () => channel?.postMessage({ type: 'presence' });
+    const requestRefresh = () => channel?.postMessage({ type: 'refresh-requested' });
     if (channel) {
         channel.onmessage = (event) => {
-            if (event.data?.type !== 'presence')
+            const message = event.data;
+            if (message?.type === 'presence') {
+                void recount();
                 return;
-            void recount();
+            }
+            // Every tab hears the request; only the one that may spend the refresh token acts on it.
+            if (message?.type === 'refresh-requested' && hold.isHolder()) {
+                refreshRequests.next();
+            }
         };
     }
     effect(() => {
@@ -4824,9 +4972,16 @@ const setupLeaderElection = () => {
         hold.release();
         announce();
         channel?.close();
+        refreshRequests.complete();
     };
     destroyRef.onDestroy(cleanup);
-    return { isLeader: hold.isHolder, instanceCount: instanceCount.asReadonly(), cleanup };
+    return {
+        isLeader: hold.isHolder,
+        instanceCount: instanceCount.asReadonly(),
+        requestRefresh,
+        refreshRequests$: refreshRequests.asObservable(),
+        cleanup,
+    };
 };
 
 const ENCRYPTION_KEY_STORAGE = '__eth_ek';
@@ -4909,13 +5064,19 @@ const resetEncryptionKey = () => {
     }
 };
 
-const setupMultiTabSync = (config, accessToken, refreshToken, queryClient) => {
+/**
+ * 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.
+ */
+const defaultSyncChannelName = (name) => `ethlete-auth-sync:${name}`;
+/** How a logout is recorded in {@link lastSyncedState}, where a token pair records its two tokens. */
+const LOGGED_OUT = 'logout';
+const tokenState = (access, refresh) => `${access}\0${refresh}`;
+const setupMultiTabSync = (config, context) => {
     const destroyRef = inject(DestroyRef);
-    const channelName = config.channelName ?? 'ethlete-auth-sync';
+    const channelName = config.channelName ?? defaultSyncChannelName(context.name);
     const syncTokens = config.syncTokens ?? true;
     const syncLogout = config.syncLogout ?? true;
-    let channel = null;
-    let isProcessingExternalUpdate = false;
     if (typeof BroadcastChannel === 'undefined') {
         if (isDevMode()) {
             console.warn('BroadcastChannel is not supported in this environment. Multi-tab sync will be disabled.');
@@ -4926,60 +5087,67 @@ const setupMultiTabSync = (config, accessToken, refreshToken, queryClient) => {
             },
         };
     }
-    channel = new BroadcastChannel(channelName);
+    const channel = new BroadcastChannel(channelName);
+    // The session state this tab last sent or received, which is what stops an incoming message from being
+    // echoed straight back out. A flag cleared once the message handler returns cannot do that job: the
+    // broadcasting effects below run after it, so they would always see it cleared.
+    let lastSyncedState = null;
+    let hadTokens = false;
     channel.onmessage = (event) => {
         const message = event.data;
-        // Prevent infinite loops
-        if (isProcessingExternalUpdate)
+        if (message.type === 'logout' && syncLogout) {
+            lastSyncedState = LOGGED_OUT;
+            hadTokens = false;
+            context.logout('otherTab');
             return;
-        isProcessingExternalUpdate = true;
-        try {
-            if (message.type === 'logout' && syncLogout) {
-                accessToken.set(null);
-                refreshToken.set(null);
-                queryClient.repository.unbindAllSecure();
-            }
-            else if (message.type === 'tokens-updated' && syncTokens) {
-                accessToken.set(decryptToken(message.accessToken));
-                refreshToken.set(decryptToken(message.refreshToken));
-            }
-        }
-        finally {
-            isProcessingExternalUpdate = false;
         }
+        if (message.type !== 'tokens-updated' || !syncTokens)
+            return;
+        const access = decryptToken(message.accessToken);
+        const refresh = decryptToken(message.refreshToken);
+        if (!access || !refresh)
+            return;
+        lastSyncedState = tokenState(access, refresh);
+        hadTokens = true;
+        context.applyTokens(access, refresh);
     };
     const cleanup = () => {
-        channel?.close();
+        channel.close();
     };
     destroyRef.onDestroy(cleanup);
     if (syncTokens) {
         effect(() => {
-            const access = accessToken();
-            const refresh = refreshToken();
-            if (access && refresh && !isProcessingExternalUpdate && channel) {
-                const message = {
-                    type: 'tokens-updated',
-                    accessToken: encryptToken(access),
-                    refreshToken: encryptToken(refresh),
-                };
-                channel.postMessage(message);
-            }
+            const access = context.accessToken();
+            const refresh = context.refreshToken();
+            if (!access || !refresh)
+                return;
+            const state = tokenState(access, refresh);
+            if (state === lastSyncedState)
+                return;
+            lastSyncedState = state;
+            const message = {
+                type: 'tokens-updated',
+                accessToken: encryptToken(access),
+                refreshToken: encryptToken(refresh),
+            };
+            channel.postMessage(message);
         });
     }
     if (syncLogout) {
-        let hadTokens = false;
         effect(() => {
-            const access = accessToken();
+            const access = context.accessToken();
             if (access) {
                 hadTokens = true;
+                return;
             }
-            else if (hadTokens && !isProcessingExternalUpdate && channel) {
-                const message = {
-                    type: 'logout',
-                };
-                channel.postMessage(message);
-                hadTokens = false;
-            }
+            if (!hadTokens)
+                return;
+            hadTokens = false;
+            if (lastSyncedState === LOGGED_OUT)
+                return;
+            lastSyncedState = LOGGED_OUT;
+            const message = { type: 'logout' };
+            channel.postMessage(message);
         });
     }
     return { cleanup };
@@ -5013,11 +5181,12 @@ const SINGLE_TAB = /* @__PURE__ */ (() => {
  */
 const withBearerAuthMultiTabSync = (config = {}) => {
     let instance = SINGLE_TAB;
+    let channelName = config.channelName ?? '';
     const setup = (_context) => ({
         type: BearerAuthFeatureType.MULTI_TAB_SYNC,
         instance,
         devtools: () => [
-            { label: 'channel', value: config.channelName ?? 'ethlete-auth-sync' },
+            { label: 'channel', value: channelName },
             { label: 'tokens', value: config.syncTokens === false ? 'tab local' : 'synced' },
             { label: 'logout', value: config.syncLogout === false ? 'tab local' : 'synced' },
             {
@@ -5029,12 +5198,23 @@ const withBearerAuthMultiTabSync = (config = {}) => {
     // The elected leader gates the auth queries' automatic refresh, which is wired up before the
     // regular feature setup runs - so this half has to happen earlier than `setup`.
     const earlySetup = (context) => {
-        setupMultiTabSync({ channelName: config.channelName, syncTokens: config.syncTokens, syncLogout: config.syncLogout }, context.accessToken, context.refreshToken, context.queryClient);
+        channelName = config.channelName ?? defaultSyncChannelName(context.name);
+        setupMultiTabSync({ channelName, syncTokens: config.syncTokens, syncLogout: config.syncLogout }, {
+            accessToken: context.accessToken,
+            refreshToken: context.refreshToken,
+            name: context.name,
+            applyTokens: context.applyTokens,
+            logout: context.logout,
+        });
         if (config.leaderElection === false)
             return {};
-        const election = setupLeaderElection();
+        const election = setupLeaderElection({ name: context.name });
         instance = { isLeader: election.isLeader, instanceCount: election.instanceCount };
-        return { isLeader: () => election.isLeader(), leaderElection: instance };
+        return {
+            isLeader: () => election.isLeader(),
+            leaderElection: instance,
+            refreshCoordination: { request: election.requestRefresh, requests$: election.refreshRequests$ },
+        };
     };
     return Object.assign(setup, { earlySetup });
 };
@@ -5059,7 +5239,7 @@ const withPersistentAuth = (config) => {
     };
 };
 const createPersistentAuthFeature = (config, context) => {
-    const { refreshToken } = context;
+    const { refreshToken, executionState } = context;
     const cookieName = config.cookie?.name ?? 'etAuth';
     const rememberMeStorageKey = `${cookieName}-rememberMe`;
     const route = injectRoute();
@@ -5076,25 +5256,36 @@ const createPersistentAuthFeature = (config, context) => {
     };
     const rememberMeSignal = signal(initializeRememberMe(), /* @ts-ignore */
     ...(ngDevMode ? [{ debugName: "rememberMeSignal" }] : /* istanbul ignore next */ []));
+    const cookieDomain = () => config.cookie?.domain ?? getDomain() ?? 'localhost';
+    const cookiePath = () => config.cookie?.path ?? '/';
+    const removeCookie = () => deleteCookie(cookieName, cookiePath(), cookieDomain());
     effect(() => {
         const token = refreshToken();
         const rememberMe = rememberMeSignal();
-        const domain = config.cookie?.domain ?? getDomain() ?? 'localhost';
-        const path = config.cookie?.path ?? '/';
-        const sameSite = config.cookie?.sameSite ?? 'lax';
-        if (token) {
-            const encryptedToken = encryptToken(token);
-            if (rememberMe) {
-                const expiresInDays = config.cookie?.expiresInDays ?? 30;
-                setCookie(cookieName, encryptedToken, expiresInDays, domain, path, sameSite);
-            }
-            else {
-                setCookie(cookieName, encryptedToken, null, domain, path, sameSite);
-            }
-        }
-        else {
-            deleteCookie(cookieName, path, domain);
+        // A missing token is not a reason to drop the cookie. It is missing on every startup - `tryLogin`
+        // reads the cookie synchronously and the auto-login only resolves a tick later - so deleting here
+        // would throw away a 30-day refresh token before it was ever used. Deletion is driven by the events
+        // that actually end a session instead, below.
+        if (!token)
+            return;
+        const expiresInDays = rememberMe ? (config.cookie?.expiresInDays ?? 30) : null;
+        setCookie(cookieName, encryptToken(token), expiresInDays, cookieDomain(), cookiePath(), config.cookie?.sameSite ?? 'lax');
+    });
+    effect(() => {
+        const state = executionState();
+        if (!state)
+            return;
+        if (state.type === 'logout') {
+            removeCookie();
+            return;
         }
+        // A token the server itself rejected is worth nothing on the next visit; anything else (offline, a
+        // 500, an aborted startup) leaves it in place so a reload can try again.
+        const wasRejected = state.state === 'error' &&
+            (state.type === 'tokenRefresh' || state.type === 'autoLogin') &&
+            (state.error.code === 401 || state.error.code === 403);
+        if (wasRejected)
+            removeCookie();
     });
     const tryLogin = () => {
         const currentRoute = route();
@@ -5340,7 +5531,7 @@ const createTrackingFeature = (context, config) => {
         const refreshToken = context.refreshToken();
         const hasTokens = !!(accessToken || refreshToken);
         if (hadTokens && !hasTokens) {
-            emit('logout', undefined);
+            emit('logout', { cause: untracked(context.sessionEndCause) });
         }
         hadTokens = hasTokens;
     });
@@ -5487,7 +5678,12 @@ const createQueryDevtoolsFormLinks = () => {
     };
 };
 
-const pathsEqual = (a, b) => a.length === b.length && a.every((step, index) => step === b[index]);
+const isPathAtOrBelow = (path, root) => path.length >= root.length && root.every((step, index) => step === path[index]);
+/**
+ * Whether any of `entries` is armed at `path` or anywhere below it - what the panel's menu asks before
+ * offering "Reset", so the destructive action is hidden where it would be a silent no-op.
+ */
+const hasQueryDevtoolsOverridesAtPath = (entries, path) => entries.some((entry) => isPathAtOrBelow(entry.op.path, path));
 /**
  * Walks `path` into `root`, stopping as soon as a step's container doesn't exist. An empty path
  * resolves to `root` itself, which is how an op targets the response's top-level value.
@@ -5695,15 +5891,84 @@ const resizePagination = (value, shape, mode, amount) => {
 const STRING_PRESETS = {
     short: 'Ab',
     long: /* @__PURE__ */ 'Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod tempor incididunt. '.repeat(4),
+    longWord: 'Rindfleischetikettierungsüberwachungsaufgabenübertragungsgesetz',
     unicode: 'مرحبا بالعالم 👋 日本語テスト 🎉 Ñoño',
 };
-const stringPresetValue = (preset, custom) => preset === 'custom' ? (custom ?? '') : STRING_PRESETS[preset];
+const stringPresetValue = (preset, custom) => custom ?? (preset === 'custom' ? '' : STRING_PRESETS[preset]);
 const NUMBER_PRESETS = {
     zero: 0,
     negative: -1,
     huge: Number.MAX_SAFE_INTEGER,
 };
-const numberPresetValue = (preset, custom) => preset === 'custom' ? (custom ?? 0) : NUMBER_PRESETS[preset];
+const numberPresetValue = (preset, custom) => custom ?? (preset === 'custom' ? 0 : NUMBER_PRESETS[preset]);
+const pickRandom = (values) => values[Math.floor(Math.random() * values.length)];
+const randomIntBetween = (min, max) => min + Math.floor(Math.random() * (max - min + 1));
+const randomHex = (length) => {
+    let out = '';
+    while (out.length < length)
+        out += Math.random().toString(16).slice(2);
+    return out.slice(0, length);
+};
+const SHORT_WORDS = ['Ok', 'Ada', 'Fig', 'Kiwi', 'Nova', 'Echo', 'Amber', 'Delta', 'Mango', 'Quartz', 'Zephyr'];
+const LOREM_SENTENCE = 'Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. ';
+const LONG_COMPOUNDS = [
+    'Rindfleischetikettierungsüberwachungsaufgabenübertragungsgesetz',
+    'Donaudampfschifffahrtsgesellschaftskapitänskajütenschlüssel',
+    'Kraftfahrzeughaftpflichtversicherungsbescheinigung',
+];
+const UNICODE_SAMPLES = [
+    'مرحبا بالعالم 👋 اختبار النص',
+    '日本語テスト 🎉 カタカナとひらがな',
+    '한국어 테스트 💡 조합형 한글',
+    'עברית מימין לשמאל 🚀 בדיקה',
+    'Ñoño über façade — Ω≈ç√∫ 🧪',
+];
+/**
+ * Generates a fresh sample value for a string preset, so filling twenty fields yields twenty different
+ * values instead of twenty identical ones. Call it at arm time and store the result in the op's
+ * `custom` field - generating inside apply would reshuffle the response on every refetch. `longWord`
+ * is a single unbreakable token (a compound word, a URL, a hex blob) - it tests overflow, where
+ * `long` tests wrapping.
+ */
+const generateQueryDevtoolsStringPreset = (preset) => {
+    switch (preset) {
+        case 'short':
+            return pickRandom(SHORT_WORDS);
+        case 'long': {
+            const length = randomIntBetween(80, 480);
+            return LOREM_SENTENCE.repeat(Math.ceil(length / LOREM_SENTENCE.length))
+                .slice(0, length)
+                .trimEnd();
+        }
+        case 'longWord':
+            return pickRandom([
+                () => pickRandom(LONG_COMPOUNDS),
+                () => `https://api.example.com/v2/resources/${randomHex(24)}/attachments?signature=${randomHex(randomIntBetween(24, 96))}`,
+                () => randomHex(randomIntBetween(64, 160)),
+            ])();
+        case 'unicode':
+            return pickRandom(UNICODE_SAMPLES);
+    }
+};
+/**
+ * Generates a fresh sample value for a number preset - same arm-time contract as
+ * {@link generateQueryDevtoolsStringPreset}. `negative` and `huge` vary in magnitude so a batch fill
+ * produces varied digit counts; `zero` is always `0`.
+ */
+const generateQueryDevtoolsNumberPreset = (preset) => {
+    switch (preset) {
+        case 'zero':
+            return 0;
+        case 'negative': {
+            const magnitude = 10 ** randomIntBetween(0, 8);
+            return -randomIntBetween(magnitude, magnitude * 10 - 1);
+        }
+        case 'huge': {
+            const magnitude = 10 ** randomIntBetween(9, 15);
+            return Math.min(randomIntBetween(magnitude, magnitude * 10 - 1), Number.MAX_SAFE_INTEGER);
+        }
+    }
+};
 const DAY_MS = 24 * 60 * 60 * 1000;
 /** `invalid` is deliberately unparseable - "the API sent a date my code can't parse" is a real bug class. */
 const datePresetValue = (preset) => {
@@ -5795,7 +6060,7 @@ const createQueryDevtoolsOverrides = () => {
     let counter = 0;
     const arm = (op) => {
         if (op.type === 'reset') {
-            list.update((current) => current.filter((entry) => !pathsEqual(entry.op.path, op.path)));
+            list.update((current) => current.filter((entry) => !isPathAtOrBelow(entry.op.path, op.path)));
             return;
         }
         list.update((current) => [...current, { id: `override-${++counter}`, op }]);
@@ -5847,10 +6112,27 @@ const estimateBodySize = (body) => {
 /** How many runs a query keeps. Enough to see a stampede or a chain without growing unbounded. */
 const RUN_HISTORY = 25;
 /**
- * How many of those runs keep their response body. Bodies dominate what the buffer retains, and a diff
- * only ever looks a couple of runs back.
+ * How many of those runs keep a body - a response, or the body an error came with. Bodies dominate what
+ * the buffer retains, which is why this is far below {@link RUN_HISTORY} and why raising it is a memory
+ * decision the app has to make for itself.
  */
-const RESPONSE_HISTORY = 5;
+const DEFAULT_RESPONSE_HISTORY = 5;
+let responseHistory = DEFAULT_RESPONSE_HISTORY;
+/**
+ * How many bodies each query retains - {@link QueryDevtoolsOptions.responseHistory}, or `5`. Only a run
+ * that still holds one can be an end of a response diff, so the panel reads this to say why an older run
+ * can no longer be picked.
+ *
+ * Part of the devtools contract. **Not part of the general public contract.**
+ */
+const queryDevtoolsResponseHistory = () => responseHistory;
+/**
+ * Sets how many bodies each query retains. Called by `provideQueryDevtools()`; nothing else may call it.
+ * @internal
+ */
+const setQueryDevtoolsResponseHistory = (count) => {
+    responseHistory = count === undefined ? DEFAULT_RESPONSE_HISTORY : Math.max(1, Math.floor(count));
+};
 /** The index of the newest run still in flight, or -1 when none is. */
 const lastPendingRunIndex = (runs) => {
     for (let index = runs.length - 1; index >= 0; index--) {
@@ -5860,17 +6142,25 @@ const lastPendingRunIndex = (runs) => {
     return -1;
 };
 /**
- * Drops the response body of every run past the newest {@link RESPONSE_HISTORY} that hold one. Mutates
- * the array it is given, which is always one this module just built.
+ * Drops the body of every run past the newest {@link queryDevtoolsResponseHistory} that hold one - a
+ * response body and an error body count against the same budget, since a run only ever has one of the
+ * two. Mutates the array it is given, which is always one this module just built.
  */
-const trimRetainedResponses = (runs) => {
+const trimRetainedBodies = (runs) => {
+    const budget = responseHistory;
     let kept = 0;
     for (let index = runs.length - 1; index >= 0; index--) {
         const run = runs[index];
-        if (!run?.hasResponse)
+        if (!run || (!run.hasResponse && !run.error?.hasBody))
+            continue;
+        if (++kept <= budget)
             continue;
-        if (++kept > RESPONSE_HISTORY)
-            runs[index] = { ...run, response: null, hasResponse: false };
+        runs[index] = {
+            ...run,
+            response: null,
+            hasResponse: false,
+            error: run.error?.hasBody ? { ...run.error, body: null, hasBody: false } : run.error,
+        };
     }
     return runs;
 };
@@ -5907,7 +6197,7 @@ const createQueryDevtoolsStats = () => {
     let runCounter = 0;
     const appendRun = (run, previous) => {
         const appended = { ...run, index: ++runCounter };
-        runs.set(trimRetainedResponses([...previous, appended].slice(-RUN_HISTORY)));
+        runs.set(trimRetainedBodies([...previous, appended].slice(-RUN_HISTORY)));
     };
     /**
      * Ends the newest run still in flight. A response with no run of the query's own waiting for it came
@@ -5920,7 +6210,7 @@ const createQueryDevtoolsStats = () => {
             appendRun({ ...end, startedAt: end.endedAt, didRequest: false, url: lastUrl, sentBytes: 0, attempts: 0 }, current);
             return;
         }
-        runs.set(trimRetainedResponses(current.map((run, index) => (index === pending ? { ...run, ...end } : run))));
+        runs.set(trimRetainedBodies(current.map((run, index) => (index === pending ? { ...run, ...end } : run))));
     };
     const recordExecution = ({ didRequest, body, url }) => {
         const now = Date.now();
@@ -5950,6 +6240,7 @@ const createQueryDevtoolsStats = () => {
             receivedBytes: 0,
             response: null,
             hasResponse: false,
+            error: null,
         }, runs().map((run) => (run.status === 'pending' ? { ...run, status: 'aborted', endedAt: now } : run)));
     };
     const recordResponse = (payload) => {
@@ -5972,15 +6263,31 @@ const createQueryDevtoolsStats = () => {
             receivedBytes: received.bytes,
             response: payload.body,
             hasResponse: true,
+            error: null,
         });
     };
     const recordError = (options) => {
+        const error = options?.error;
         stats.update((current) => ({
             ...current,
             errors: current.errors + 1,
             lastResponseWasFaulted: options?.faulted ?? false,
         }));
-        endRun({ endedAt: Date.now(), status: 'error', receivedBytes: 0, response: null, hasResponse: false });
+        endRun({
+            endedAt: Date.now(),
+            status: 'error',
+            receivedBytes: 0,
+            response: null,
+            hasResponse: false,
+            error: error
+                ? {
+                    code: error.code,
+                    messages: queryErrorMessages(error),
+                    body: error.raw.error,
+                    hasBody: error.raw.error !== null && error.raw.error !== undefined,
+                }
+                : null,
+        });
     };
     const recordRetry = ({ attempt }) => {
         const current = runs();
@@ -6042,6 +6349,106 @@ const sumQueryDevtoolsStats = (handles) => {
     return total;
 };
 
+/**
+ * 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.
+ */
+const MAX_QUERY_DEVTOOLS_TOMBSTONES = 50;
+const frozen = (value) => () => value;
+const noop = () => undefined;
+/**
+ * Reads one signal off a handle that is being destroyed. A query whose injector is already gone can
+ * throw here, and losing one field is better than losing the whole tombstone.
+ */
+const read = (get, fallback) => {
+    try {
+        return get();
+    }
+    catch {
+        return fallback;
+    }
+};
+/**
+ * A destroyed query's last state, shaped like the query itself: every signal the panel reads is
+ * replaced by a function returning the value it held when the query went away, and every action is a
+ * no-op. Rendering a tombstone therefore costs the panel no second code path - the drawer reads
+ * `entry.handle` exactly as it does for a live query, and gates its actions on
+ * {@link QueryDevtoolsEntry.destroyedAt} instead.
+ *
+ * The captured request is a plain copy, not the request itself: the real one is destroyed the moment
+ * its cache entry is, and holding it would keep its subscriptions and its cache entry alive.
+ */
+const snapshotQueryDevtoolsHandle = (handle) => {
+    const query = handle;
+    if (!query || typeof query !== 'object')
+        return handle;
+    const live = read(() => query.subtle?.request() ?? null, null);
+    const request = live
+        ? {
+            method: live.method,
+            url: live.url,
+            args: live.args,
+            execute: () => false,
+            destroy: () => false,
+            isStale: frozen(false),
+            loading: frozen(null),
+            error: read(() => frozen(live.error()), frozen(null)),
+            response: read(() => frozen(live.response()), frozen(null)),
+            currentEvent: read(() => frozen(live.currentEvent()), frozen(null)),
+            expiresAt: read(() => frozen(live.expiresAt()), frozen(null)),
+            subtle: {
+                retryState: frozen(null),
+                attempts: read(() => frozen(live.subtle.attempts()), frozen(1)),
+                lastDurationMs: read(() => frozen(live.subtle.lastDurationMs()), frozen(null)),
+                resolveHeaders: read(() => frozen(live.subtle.resolveHeaders()), frozen(undefined)),
+                lastPersistedResponseAt: read(() => frozen(live.subtle.lastPersistedResponseAt()), frozen(null)),
+                lastExternalResponseAt: read(() => frozen(live.subtle.lastExternalResponseAt()), frozen(null)),
+            },
+        }
+        : null;
+    return {
+        id: read(() => frozen(query.id()), frozen(null)),
+        args: read(() => frozen(query.args()), frozen(null)),
+        response: read(() => frozen(query.response()), frozen(null)),
+        error: read(() => frozen(query.error()), frozen(null)),
+        latestHttpEvent: read(() => frozen(query.latestHttpEvent()), frozen(null)),
+        lastTimeExecutedAt: read(() => frozen(query.lastTimeExecutedAt()), frozen(null)),
+        triggeredBy: read(() => frozen(query.triggeredBy()), frozen(null)),
+        executionState: read(() => frozen(query.executionState()), frozen(null)),
+        // A tombstone never loads: a forced loading state captured mid-flight would spin forever.
+        loading: frozen(null),
+        execute: () => false,
+        reset: noop,
+        subtle: {
+            request: frozen(request),
+            destroy: noop,
+            setResponse: noop,
+            setLoading: noop,
+            setError: noop,
+        },
+    };
+};
+/**
+ * The entry a destroyed query leaves behind: the same id, kind and metadata, a frozen
+ * {@link snapshotQueryDevtoolsHandle} in place of the live query, and no `element` - a DOM node whose
+ * component is gone must not be kept alive by the panel.
+ *
+ * `stats` is carried over as-is. The recorder closes over its own signals rather than over the query,
+ * so the run history that makes a failed request readable survives without retaining anything.
+ */
+const tombstoneOf = (entry, destroyedAt) => {
+    const { element: _element, ...meta } = entry.meta;
+    return {
+        id: entry.id,
+        kind: entry.kind,
+        meta,
+        handle: snapshotQueryDevtoolsHandle(entry.handle),
+        createdAt: entry.createdAt,
+        destroyedAt,
+        stats: entry.stats,
+    };
+};
+
 const entries = /* @__PURE__ */ signal([], /* @ts-ignore */
 ...(ngDevMode ? [{ debugName: "entries" }] : /* istanbul ignore next */ []));
 /**
@@ -6161,9 +6568,39 @@ const registerEntry = (registration) => {
         formLinks: registration.formLinks,
         overrides: registration.overrides,
     };
-    entries.update((list) => [...list, fullEntry]);
-    return () => entries.update((list) => list.filter((e) => e.id !== fullEntry.id));
+    // A registration that brings its own id can repeat one a tombstone still holds; the live entry wins.
+    entries.update((list) => [...list.filter((e) => !(e.id === id && e.destroyedAt)), fullEntry]);
+    return () => entries.update((list) => {
+        const index = list.findIndex((e) => e.id === fullEntry.id);
+        if (index === -1)
+            return list;
+        const next = list.slice();
+        // Only queries leave a tombstone. A stack, sequence, form or auth provider is a container whose
+        // interesting state is the queries it owns - each of which tombstones on its own.
+        if (fullEntry.kind !== 'query') {
+            next.splice(index, 1);
+            return next;
+        }
+        next[index] = tombstoneOf(fullEntry, Date.now());
+        return capTombstones(next);
+    });
 };
+/** Drops the oldest tombstones once there are more than {@link MAX_QUERY_DEVTOOLS_TOMBSTONES} of them. */
+const capTombstones = (list) => {
+    const excess = list.filter((e) => e.destroyedAt).length - MAX_QUERY_DEVTOOLS_TOMBSTONES;
+    if (excess <= 0)
+        return list;
+    const doomed = new Set(list
+        .filter((e) => e.destroyedAt)
+        .sort((a, b) => (a.destroyedAt ?? 0) - (b.destroyedAt ?? 0))
+        .slice(0, excess));
+    return list.filter((e) => !doomed.has(e));
+};
+/**
+ * Forgets every destroyed entry the registry is holding - the panel's "clear gone" action. Live
+ * entries are untouched.
+ */
+const clearQueryDevtoolsTombstones = () => entries.update((list) => list.filter((e) => !e.destroyedAt));
 /**
  * Enables the `@ethlete/query` devtools. Add this to your application providers (e.g. in
  * `bootstrapApplication`) to make query clients, queries, stacks, sequences and auth providers
@@ -6179,7 +6616,8 @@ const registerEntry = (registration) => {
  * });
  * ```
  */
-const provideQueryDevtools = () => {
+const provideQueryDevtools = (options) => {
+    setQueryDevtoolsResponseHistory(options?.responseHistory);
     setQueryDevtoolsRegistrar(registerEntry);
     setQueryDevtoolsStatsFactory(createQueryDevtoolsStats);
     setQueryDevtoolsFormLinksFactory(createQueryDevtoolsFormLinks);
@@ -6262,6 +6700,7 @@ const createGqlExecuteFn = (executeOptions) => {
             executeState,
             args: computedArgs,
             options,
+            isRefreshable: executeOptions.creatorInternals.method === 'QUERY',
         });
     };
     exec['reset'] = reset;
@@ -11074,6 +11513,7 @@ const buildDefaults = (fields) => {
     }
     return out;
 };
+const MAX_RESET_PASSES = 10;
 const changedKeysBetween = (previous, current) => Object.keys(current).filter((key) => !equal(previous?.[key], current[key]));
 /** Best-effort URL string → value coercion, mirroring the auto-transform of the legacy QueryForm. */
 const autoCoerce = (raw, defaultValue) => {
@@ -11236,6 +11676,26 @@ const defineQueryForm = (config) => {
         }
         return next;
     };
+    /**
+     * Resets are transitive: a field this pass reset counts as changed in the next one, so
+     * `country → league → team` clears `team` as well when only `country` moved. Passes repeat until
+     * nothing moves, which has to happen before `committed` is written - one query execution for the
+     * whole chain, not one per hop. The cap only guards a cyclic `isResetBy` graph; a field already at
+     * its default stops triggering, so a well-formed graph settles in as many passes as it is deep.
+     */
+    const resolveResets = (prev, live) => {
+        let next = live;
+        for (let pass = 0; pass < MAX_RESET_PASSES; pass++) {
+            const applied = applyResets(next, changedKeysBetween(prev, next));
+            if (equal(applied, next))
+                return applied;
+            next = applied;
+        }
+        if (isDevMode()) {
+            console.warn(`defineQueryForm: isResetBy did not settle within ${MAX_RESET_PASSES} passes. Check for a cycle.`);
+        }
+        return next;
+    };
     const flush = () => {
         clearTimer();
         const live = model();
@@ -11244,8 +11704,7 @@ const defineQueryForm = (config) => {
             skipNextResets = false;
             return;
         }
-        const changedKeys = changedKeysBetween(prev, live);
-        const next = skipNextResets ? { ...live } : applyResets(live, changedKeys);
+        const next = skipNextResets ? { ...live } : resolveResets(prev, live);
         skipNextResets = false;
         previous.set(clone(prev));
         committed.set(clone(next));
@@ -11589,12 +12048,15 @@ const createWebSocketClient = (options) => {
             const join = (name) => {
                 emit({ event: 'join-room', data: name, room: name });
                 const existingRoom = rooms.get(name);
-                if (existingRoom)
+                if (existingRoom) {
+                    existingRoom.joinCount++;
                     return existingRoom;
+                }
                 const message = signal(null, /* @ts-ignore */
                 ...(ngDevMode ? [{ debugName: "message" }] : /* istanbul ignore next */ []));
                 const newRoom = {
                     latestMessage: message,
+                    joinCount: 1,
                 };
                 rooms.set(name, newRoom);
                 syncDevtoolsRooms();
@@ -11628,10 +12090,15 @@ const createWebSocketClient = (options) => {
             return roomData.asReadonly();
         };
         const leaveRoom = (room) => {
-            if (!rooms.has(room)) {
+            const joinedRoom = rooms.get(room);
+            if (!joinedRoom) {
                 if (isDevMode())
                     throw roomNotJoined(room);
+                return;
             }
+            joinedRoom.joinCount--;
+            if (joinedRoom.joinCount > 0)
+                return;
             emit({ event: 'leave-room', data: room, room });
             rooms.delete(room);
             syncDevtoolsRooms();
@@ -11696,5 +12163,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_UNUSED_ENTRIES, NumberArrayQueryField, ParseHttpErrorCodeToMessageDePipe, ParseHttpErrorCodeToMessageEnPipe, ParseHttpErrorCodeToTitleDePipe, ParseHttpErrorCodeToTitleEnPipe, QUERY_CLIENT_DEVTOOLS_TOKEN, QUERY_DEVTOOLS_FAULT_STATUSES, QUERY_PERSISTENCE_STORE_VERSION, QUERY_SYNC_PROTOCOL_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, authExtractTokensResponseMissingAccessToken, authExtractTokensResponseMissingRefreshToken, authExtractTokensResponseNotObject, authProviderFeatureUsedMultipleTimes, booleanArrayQueryField, buildQueryCacheKey, buildQueryString, buildRoute, buildTimestampFromSeconds, castQueryCreatorTypes, circularQueryDependency, circularQueryDependencyChecker, clearQueryDevtoolsFaults, collectLeafPaths, collectQueryFormLinks, computeQueryAuthHeader, computeQueryBody, computeQueryHeaders, computeQueryMethod, computeQueryQueryParams, consumeSuppressQueryStackDevtools, contentfulGqlLikePaginationAdapter, 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, describeQueryDevtoolsFeatures, detectContentTypeHeader, detectPaginationShape, dynLikePaginationAdapter, effectComputed, emptyQueryArgs, ethletePaginationAdapter, executeUntilSettled, extractExpiresInSeconds, extractFormViolations, extractHtmlErrorMessage, extractQuery, fakePaginationAdapter, filterFailure, filterNull, filterQueryStates, filterSuccess, forEachHeader, formatQueryDevtoolsDuration, getBearerAuthProviderName, getDefaultHeaders, getQueryClientName, getQueryFeatureUsage, getResponseUrl, ggLikePaginationAdapter, gql, gqlDataPropertyMissingInResponse, hasHeader, htmlErrorPayload, htmlQueryErrorParser, ignoreAutoRefresh, 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, isQueryDevtoolsFaultInjectionEnabled, isQueryErrorResponse, isQueryStateCancelled, isQueryStateFailure, isQueryStateLoading, isQueryStatePrepared, isQueryStateSuccess, isRequestError, isSymfonyError, isSymfonyFormViolationListError, isSymfonyListError, isSymfonyPagerfantaOutOfRangeError, isUnderInvalidatedUrl, legacyPrepareFallbackInjector, legacyPrepareWithoutInjectionContext, mapToPaginated, mapViolationsToFormErrors, maybeExecute, measureQueryDevtoolsPayload, mergeHeaders, nestedEffect, noteQueryFormRead, numberArrayQueryField, pagedQueryStackNextPageCalledWithoutPreviousPage, pagedQueryStackPageBiggerThanTotalPages, pagedQueryStackPreviousPageCalledButAlreadyAtFirstPage, paginatedEntityValueUpdater, parseAllXhrResponseHeaders, parseHttpErrorCodeToMessageDe, parseHttpErrorCodeToMessageEn, parseHttpErrorCodeToTitleDe, parseHttpErrorCodeToTitleEn, parseQueryRoute, pathParamsMissingInRouteFunctionError, provideInfinityQueryResponseDelay, provideLegacyPrepareFallback, provideQueryClientForDevtools, provideQueryDevtools, queryArrayComputed, queryClientFeatureUsedMultipleTimes, queryComputed, queryComputedTillTruthy, queryDevtoolsEntries, queryDevtoolsFaults, queryDevtoolsFnDetail, queryErrorMessage, queryErrorMessages, queryExecute, queryFeatureUsedMultipleTimes, queryField, querySequence, querySequenceAlreadyRunning, queryStackTotalQueriesAndExpectedQueriesMismatch, queryStackWithArgsUsed, queryStackWithResponseUpdateUsed, queryStateAlreadyHasKeyError, queryStateCannotTransformError, queryStateDoesNotContainKeyError, queryStateErrorSignal, queryStateLoadingSignal, queryStateResponseSignal, queryStateSignal, registerQueryDevtoolsEntry, registerQueryErrorParser, removeFrom, request, resetExecuteState, resetPageOnError, resolveInvalidationUrl, resolveQueryDevtoolsFault, resolveQueryDevtoolsFaultForAttempt, runDefaultQueryRetry, runQueryErrorParsers, searchQueryField, serializeBody, setDefaultQueryRetryFn, setQueryDevtoolsFault, setQueryDevtoolsFaultResolver, setQueryDevtoolsFormLinksFactory, setQueryDevtoolsOverridesFactory, setQueryDevtoolsRegistrar, setQueryDevtoolsStatsFactory, setupQueryDependencies, setupQueryExecuteState, setupQueryState, shouldAutoExecuteGqlQuery, shouldAutoExecuteQuery, shouldCacheQuery, shouldRetryRequest, silenceMissingWithArgsFeatureErrorUsedButWithArgsPresent, skipPaginationPageParamCalculator, smartDuplicateArrayItem, sortQueryField, splitQueryConfig, stringArrayQueryField, stringifyQueryRouteParts, sumQueryDevtoolsStats, suppressNextQueryStackDevtools, switchQueryCollectionState, switchQueryState, symfonyQueryErrorParser, takeUntilResponse, toQuerySignal, toQuerySubject, tokensNotAvailableInsideAuthAndExec, 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, withQueryPersistence, withRefreshQuery, withResponseUpdate, withSuccessHandling, withSymfonyErrors, withTokenExpirationWarning, withTokenRevocation, withTracking, wrapAsObservableSignal, wrapQuerySyncMessage };
+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, 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, authExtractTokensResponseMissingAccessToken, authExtractTokensResponseMissingRefreshToken, authExtractTokensResponseNotObject, authProviderFeatureUsedMultipleTimes, booleanArrayQueryField, buildQueryCacheKey, buildQueryString, buildRoute, buildTimestampFromSeconds, castQueryCreatorTypes, circularQueryDependency, circularQueryDependencyChecker, clearQueryDevtoolsFaults, clearQueryDevtoolsTombstones, collectLeafPaths, collectQueryFormLinks, computeQueryAuthHeader, computeQueryBody, computeQueryHeaders, computeQueryMethod, computeQueryQueryParams, consumeSuppressQueryStackDevtools, contentfulGqlLikePaginationAdapter, 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, 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, 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, isQueryDevtoolsFaultInjectionEnabled, isQueryErrorResponse, isQueryStateCancelled, isQueryStateFailure, isQueryStateLoading, isQueryStatePrepared, isQueryStateSuccess, isRequestError, isSymfonyError, isSymfonyFormViolationListError, isSymfonyListError, isSymfonyPagerfantaOutOfRangeError, isUnderInvalidatedUrl, legacyPrepareFallbackInjector, legacyPrepareWithoutInjectionContext, mapToPaginated, mapViolationsToFormErrors, maybeExecute, measureQueryDevtoolsPayload, mergeHeaders, nestedEffect, noteQueryFormRead, numberArrayQueryField, pagedQueryStackNextPageCalledWithoutPreviousPage, pagedQueryStackPageBiggerThanTotalPages, pagedQueryStackPreviousPageCalledButAlreadyAtFirstPage, paginatedEntityValueUpdater, parseAllXhrResponseHeaders, parseHttpErrorCodeToMessageDe, parseHttpErrorCodeToMessageEn, parseHttpErrorCodeToTitleDe, parseHttpErrorCodeToTitleEn, parseQueryRoute, pathParamsMissingInRouteFunctionError, provideInfinityQueryResponseDelay, provideLegacyPrepareFallback, provideQueryClientForDevtools, provideQueryDevtools, queryArrayComputed, queryClientFeatureUsedMultipleTimes, queryComputed, queryComputedTillTruthy, queryDevtoolsEntries, queryDevtoolsFaults, queryDevtoolsFnDetail, queryDevtoolsResponseHistory, queryErrorMessage, queryErrorMessages, queryExecute, queryFeatureUsedMultipleTimes, queryField, querySequence, querySequenceAlreadyRunning, queryStackTotalQueriesAndExpectedQueriesMismatch, queryStackWithArgsUsed, queryStackWithResponseUpdateUsed, queryStateAlreadyHasKeyError, queryStateCannotTransformError, queryStateDoesNotContainKeyError, queryStateErrorSignal, queryStateLoadingSignal, queryStateResponseSignal, queryStateSignal, registerQueryDevtoolsEntry, registerQueryErrorParser, removeFrom, request, resetExecuteState, resetPageOnError, resolveInvalidationUrl, resolveQueryDevtoolsFault, resolveQueryDevtoolsFaultForAttempt, runDefaultQueryRetry, runQueryErrorParsers, searchQueryField, serializeBody, setDefaultQueryRetryFn, setQueryDevtoolsFault, setQueryDevtoolsFaultResolver, setQueryDevtoolsFormLinksFactory, setQueryDevtoolsOverridesFactory, setQueryDevtoolsRegistrar, setQueryDevtoolsResponseHistory, 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, withQueryPersistence, withRefreshQuery, withResponseUpdate, withSuccessHandling, withSymfonyErrors, withTokenExpirationWarning, withTokenRevocation, withTracking, wrapAsObservableSignal, wrapQuerySyncMessage };
 //# sourceMappingURL=ethlete-query.mjs.map