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

package/fesm2022/ethlete-query.mjs

@@ -2,7 +2,7 @@ import * as i0 from '@angular/core';
 import { inject, computed, DestroyRef, InjectionToken, Injector, EnvironmentInjector, ElementRef, ErrorHandler, createEnvironmentInjector, effect, untracked, signal, linkedSignal, runInInjectionContext, isDevMode, PLATFORM_ID, resource, DOCUMENT, VERSION, makeEnvironmentProviders, assertInInjectionContext, provideEnvironmentInitializer, ChangeDetectorRef, ViewContainerRef, TemplateRef, Input, Directive, input, Pipe, ViewEncapsulation, Component, NgZone } from '@angular/core';
 import { toObservable, takeUntilDestroyed, toSignal } from '@angular/core/rxjs-interop';
 import { UrlTree, Router, RedirectCommand, ActivatedRoute } from '@angular/router';
-import { filter, take, map, defer, from, Subject, Subscription, throwError, of, timer, switchMap, tap, retry, catchError, EMPTY, takeWhile, merge, firstValueFrom, concatMap, fromEvent, throttleTime, interval, combineLatest, Observable, takeUntil, startWith, pairwise, BehaviorSubject, ReplaySubject, shareReplay, skip, withLatestFrom, debounceTime } from 'rxjs';
+import { filter, take, map, defer, from, Subject, Subscription, throwError, of, timer, switchMap, tap, retry, catchError, merge, EMPTY, takeWhile, firstValueFrom, concatMap, fromEvent, throttleTime, interval, combineLatest, Observable, takeUntil, startWith, pairwise, BehaviorSubject, ReplaySubject, shareReplay, skip, withLatestFrom, debounceTime } from 'rxjs';
 import { defineStaticProvider, RuntimeError, clamp, randomId, defineRootProvider, isObject, injectUnsavedChangesCoordinator, injectRoute, getCookie, getDomain, deleteCookie, setCookie, CORE_VERSION, createDestroy, computedTillTruthy, defineProvider, toProvideFn, toInjectFn, nextFrame, injectQueryParams, injectQueryParamChanges, clone, equal, ET_PROPERTY_REMOVED, previousSignalValue } from '@ethlete/core';
 import { HttpClient, HttpEventType, HttpErrorResponse, HttpResponse, HttpHeaders, HttpStatusCode } from '@angular/common/http';
 import { getActiveConsumer, setActiveConsumer } from '@angular/core/primitives/signals';
@@ -265,6 +265,24 @@ const resolveQueryDevtoolsMock = (target) => mockResolver?.(target) ?? null;
  * @internal
  */
 const resolveQueryDevtoolsFault = (target) => faultResolver?.(target) ?? null;
+let tokenPayloadPatcher = null;
+/**
+ * Installs the access-token payload patcher. Called by `provideQueryDevtools()`; nothing else may call it.
+ * @internal
+ */
+const setQueryDevtoolsTokenPayloadPatcher = (fn) => {
+    tokenPayloadPatcher = fn;
+};
+/**
+ * A decoded access token as the devtools want it seen, which today means with an overridden lifetime
+ * applied. Returns the payload as decoded unless `provideQueryDevtools()` installed a patcher.
+ *
+ * Auth code must reach the override through this rather than importing the registry it lives in: a
+ * static import would pin that module into every bundle that builds an auth provider, and a runtime
+ * guard at the call site does not undo that.
+ * @internal
+ */
+const patchQueryDevtoolsTokenPayload = (options) => (tokenPayloadPatcher ? tokenPayloadPatcher(options) : options.payload);
 let suppressStackRegistration = false;
 /**
  * Suppresses devtools registration for the next {@link createQueryStack} call. Used by
@@ -1630,6 +1648,7 @@ const SPEED_BUFFER_TIME_IN_MS = 2000;
 const MOCKED_STATUS_TEXT = 'Served by the query devtools';
 const createHttpRequest = (options) => {
     let currentStreamSubscription = Subscription.EMPTY;
+    let lastSentHeaders;
     const { args, clientOptions, dependencies } = options;
     const currentEvent = signal(null, /* @ts-ignore */
     ...(ngDevMode ? [{ debugName: "currentEvent" }] : /* istanbul ignore next */ []));
@@ -1751,6 +1770,7 @@ const createHttpRequest = (options) => {
     });
     const createStream = () => {
         const headers = resolveHeaders();
+        lastSentHeaders = headers;
         const source$ = isQueryDevtoolsRequestInterceptionEnabled() ? sendWithFaults(headers) : send(headers);
         return source$.pipe(tap((event) => updateState(event)), retry({
             delay: (error, retryCount) => {
@@ -1923,6 +1943,7 @@ const createHttpRequest = (options) => {
             applyPersistedResponse,
             lastPersistedResponseAt: lastPersistedResponseAt.asReadonly(),
             resolveHeaders,
+            lastSentHeaders: () => lastSentHeaders,
             attempts: attempts.asReadonly(),
             retryState: retryState.asReadonly(),
             lastDurationMs: lastDurationMs.asReadonly(),
@@ -3863,6 +3884,7 @@ const createSecureExecuteFactory = (options) => {
     let lastExecuteArgs;
     /** The access token the last request went out with - what the 401 retry below compares against. */
     let lastRequestedWithToken = null;
+    const error$ = toObservable(options.state.error, { injector: options.deps.injector });
     const reset = () => {
         authQuerySubscription.unsubscribe();
         authQuerySubscription = Subscription.EMPTY;
@@ -3973,7 +3995,13 @@ const createSecureExecuteFactory = (options) => {
         // another refresh - an endless refresh/retry loop for as long as the server keeps handing out
         // tokens it rejects. A refresh that did not change the access token is therefore not a reason to
         // retry; the subscription stays open, so a later one that does change it still is.
-        tokenRefreshSubscription = options.authProvider.afterTokenRefresh$
+        //
+        // The error landing is a trigger of its own: a refresh can complete before this query's 401 has
+        // even come back (which is also why that 401 must not start another refresh - see
+        // withRefreshQuery's 401 handling), and the refresh emission alone would find no error to act
+        // on. Emissions of the error this execution armed with are not landings, only replays.
+        const errorAtArm = options.state.error();
+        tokenRefreshSubscription = merge(options.authProvider.afterTokenRefresh$, error$.pipe(filter((landedError) => landedError !== errorAtArm)))
             .pipe(filter(() => {
             const currentError = options.state.error();
             return currentError?.code === 401 && options.authProvider.accessToken() !== lastRequestedWithToken;
@@ -4655,7 +4683,12 @@ const createBearerAuthProviderImpl = (config) => {
         if (!token)
             return null;
         try {
-            return config.bearerDecryptFn?.(token) ?? decryptBearer(token);
+            const decoded = config.bearerDecryptFn?.(token) ?? decryptBearer(token);
+            return patchQueryDevtoolsTokenPayload({
+                payload: decoded,
+                providerName: config.name,
+                expiresInPropertyName: 'exp',
+            });
         }
         catch (error) {
             if (isDevMode()) {
@@ -4728,6 +4761,7 @@ const createBearerAuthProviderImpl = (config) => {
         sessionEndCause: sessionEndCause.asReadonly(),
     });
     const querySetupContext = {
+        name: config.name,
         accessToken,
         refreshToken,
         bearerDecryptFn: config.bearerDecryptFn,
@@ -4808,6 +4842,12 @@ const rescheduleDelayMs = 5000;
  * declining is either not the leader or busy issuing tokens; either way a 401 still forces a refresh.
  */
 const maxRescheduleAttempts = 5;
+/**
+ * How many 401-driven refreshes may run back to back before they fall back to `minRefreshInterval`.
+ * Every refresh in such a streak means the token the previous one issued was rejected too, so an
+ * unbounded streak is a refresh loop, not recovery. A secure request succeeding ends the streak.
+ */
+const maxUnauthorizedRefreshStreak = 3;
 const withAuthenticationQuery = (key, config, setup) => ({
     _type: 'authQuery',
     key,
@@ -4850,6 +4890,8 @@ const withRefreshQuery = (key, config) => {
         const minRefreshInterval = config.minRefreshInterval ?? 30000; // 30 seconds default
         const refreshIfExpired = config.refreshIfExpired ?? true;
         let lastRefreshTime = 0;
+        let lastUnauthorizedRefreshTime = 0;
+        let unauthorizedRefreshStreak = 0;
         // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
         const refreshQuery = () => context.queries[key];
         const executeRefresh = (reason) => {
@@ -4873,6 +4915,15 @@ const withRefreshQuery = (key, config) => {
                     return 'throttled';
                 lastRefreshTime = now;
             }
+            else {
+                const now = Date.now();
+                if (unauthorizedRefreshStreak >= maxUnauthorizedRefreshStreak &&
+                    now - lastUnauthorizedRefreshTime < minRefreshInterval) {
+                    return 'throttled';
+                }
+                unauthorizedRefreshStreak++;
+                lastUnauthorizedRefreshTime = now;
+            }
             refreshQuery().execute(buildArgs(currentRefreshToken), { triggeredBy: 'token-refresh' });
             return 'executed';
         };
@@ -4907,7 +4958,12 @@ const withRefreshQuery = (key, config) => {
         /** When this access token is due to be refreshed, or `null` if it cannot be scheduled at all. */
         const scheduledRefreshDelay = (token) => {
             try {
-                const bearerDataValue = context.bearerDecryptFn ? context.bearerDecryptFn(token) : decryptBearer(token);
+                const decoded = context.bearerDecryptFn ? context.bearerDecryptFn(token) : decryptBearer(token);
+                const bearerDataValue = patchQueryDevtoolsTokenPayload({
+                    payload: decoded,
+                    providerName: context.name,
+                    expiresInPropertyName,
+                });
                 const expiresIn = bearerDataValue?.[expiresInPropertyName];
                 if (typeof expiresIn !== 'number') {
                     if (isDevMode()) {
@@ -4939,13 +4995,17 @@ const withRefreshQuery = (key, config) => {
             const retryInMs = retryScheduledIn(executeRefresh('scheduled'));
             return retryInMs === null || attemptsLeft <= 0 ? EMPTY : scheduledRefresh(retryInMs, attemptsLeft - 1);
         }));
-        toObservable(context.accessToken)
-            .pipe(switchMap((token) => {
-            if (!token)
-                return EMPTY;
-            const dueInMs = scheduledRefreshDelay(token);
-            return dueInMs === null ? EMPTY : scheduledRefresh(dueInMs, maxRescheduleAttempts);
-        }), takeUntilDestroyed())
+        // The delay is read in a computed rather than in the `switchMap` so that a devtools-armed token
+        // lifetime re-arms the schedule: the override is a signal, and only a reactive read of it moves the
+        // timer before the next token arrives. The wrapper object keeps every recomputation an emission, so
+        // two tokens that happen to be due at the same moment still restart the timer.
+        const nextScheduledRefresh = computed(() => {
+            const token = context.accessToken();
+            return { dueInMs: token ? scheduledRefreshDelay(token) : null };
+        }, /* @ts-ignore */
+        ...(ngDevMode ? [{ debugName: "nextScheduledRefresh" }] : /* istanbul ignore next */ []));
+        toObservable(nextScheduledRefresh)
+            .pipe(switchMap(({ dueInMs }) => (dueInMs === null ? EMPTY : scheduledRefresh(dueInMs, maxRescheduleAttempts))), takeUntilDestroyed())
             .subscribe();
         context.refreshCoordination?.requests$.pipe(takeUntilDestroyed()).subscribe(() => executeRefresh('unauthorized'));
         const onRefreshFailure = config.onRefreshFailure ??
@@ -4965,18 +5025,22 @@ const withRefreshQuery = (key, config) => {
         // Auto-retry on 401: Listen to repository events and trigger refresh on 401 errors
         const autoRetryOn401 = config.autoRetryOn401 ?? true;
         if (autoRetryOn401) {
-            context.repository.events$
-                .pipe(filter((event) => {
-                // Only handle 401 errors for secure queries
-                if (event.type !== 'request-error')
-                    return false;
-                if (!event.isSecure)
-                    return false;
-                if (event.error?.status !== 401)
-                    return false;
-                return true;
-            }), takeUntilDestroyed())
-                .subscribe(() => {
+            context.repository.events$.pipe(takeUntilDestroyed()).subscribe((event) => {
+                if (event.type === 'request-success' && event.isSecure) {
+                    unauthorizedRefreshStreak = 0;
+                    return;
+                }
+                if (event.type !== 'request-error' || !event.isSecure || event.error?.status !== 401)
+                    return;
+                // A 401 from a request that went out with an older access token asks for a refresh that
+                // already happened - the query re-runs itself with the current token (see
+                // createSecureExecuteFactory). Refreshing again here would spend the refresh token that
+                // pair came with, invalidating the tokens every other in-flight request is using; their
+                // 401s would each do the same, keeping the loop alive for as long as queries are in flight.
+                const sentAuthorization = event.request.subtle.lastSentHeaders()?.get('Authorization');
+                const currentToken = context.accessToken();
+                if (sentAuthorization && currentToken && sentAuthorization !== `Bearer ${currentToken}`)
+                    return;
                 executeRefresh('unauthorized');
             });
         }
@@ -5811,124 +5875,13 @@ const queryDevtoolsAbout = () => ({
     app,
 });
 
-/** The neutral fault: nothing armed. */
-const EMPTY_QUERY_DEVTOOLS_FAULT = {
-    latencyMs: 0,
-    failNext: 0,
-    failRate: 0,
-    status: 503,
-};
-/**
- * Statuses worth injecting, and whether the SDK's default retry policy retries them. A picker built from
- * this cannot arm a 500 and then leave you wondering why no retry fired.
- * @see runDefaultQueryRetry
- */
-const QUERY_DEVTOOLS_FAULT_STATUSES = [
-    { status: 0, label: 'Network error', retryable: true },
-    { status: 400, label: 'Bad Request', retryable: false },
-    { status: 401, label: 'Unauthorized', retryable: false },
-    { status: 403, label: 'Forbidden', retryable: false },
-    { status: 404, label: 'Not Found', retryable: false },
-    { status: 408, label: 'Request Timeout', retryable: true },
-    { status: 429, label: 'Too Many Requests', retryable: true },
-    { status: 500, label: 'Internal Server Error', retryable: false },
-    { status: 502, label: 'Bad Gateway', retryable: true },
-    { status: 503, label: 'Service Unavailable', retryable: true },
-];
-const faults = /* @__PURE__ */ signal({}, /* @ts-ignore */
-...(ngDevMode ? [{ debugName: "faults" }] : /* istanbul ignore next */ []));
-/**
- * The faults armed per client name, consumed by the `<et-query-devtools>` UI. Clients with nothing armed
- * are absent rather than present with an {@link EMPTY_QUERY_DEVTOOLS_FAULT}.
- */
-const queryDevtoolsFaults = /* @__PURE__ */ faults.asReadonly();
-/** Whether anything at all is armed on a fault. */
-const isQueryDevtoolsFaultArmed = (fault) => fault.latencyMs > 0 || fault.failNext > 0 || fault.failRate > 0;
-/**
- * Arms (or updates) the fault of one client. Only the given fields change; the rest keep their current
- * value. A client whose resulting fault has nothing armed is dropped from {@link queryDevtoolsFaults}.
- *
- * Part of the devtools contract consumed by `<et-query-devtools>`; a fault is a debugging tool, not
- * something an application should arm on itself.
- */
-const setQueryDevtoolsFault = (options) => {
-    const { clientName, patch } = options;
-    faults.update((current) => {
-        const next = { ...(current[clientName] ?? EMPTY_QUERY_DEVTOOLS_FAULT), ...patch };
-        if (!isQueryDevtoolsFaultArmed(next)) {
-            const { [clientName]: _removed, ...rest } = current;
-            return rest;
-        }
-        return { ...current, [clientName]: next };
-    });
-};
-/**
- * Disarms every fault of one client, or of all clients when no name is given.
- *
- * @see setQueryDevtoolsFault
- */
-const clearQueryDevtoolsFaults = (clientName) => faults.update((current) => {
-    if (clientName === undefined)
-        return {};
-    const { [clientName]: _removed, ...rest } = current;
-    return rest;
-});
-/**
- * Resolves what to do with one upcoming attempt, consuming a `failNext` budget in the process - so this
- * must be called once per attempt and never speculatively.
- *
- * Installed as the fault resolver by `provideQueryDevtools()`; nothing else may call it.
- * @internal
- */
-const resolveQueryDevtoolsFaultForAttempt = (target) => {
-    const fault = faults()[target.clientName];
-    if (!fault || !isQueryDevtoolsFaultArmed(fault))
-        return null;
-    let shouldFail = false;
-    if (fault.failNext > 0) {
-        shouldFail = true;
-        setQueryDevtoolsFault({ clientName: target.clientName, patch: { failNext: fault.failNext - 1 } });
-    }
-    else if (fault.failRate > 0) {
-        shouldFail = Math.random() * 100 < fault.failRate;
-    }
-    return {
-        latencyMs: fault.latencyMs,
-        status: shouldFail ? fault.status : null,
-    };
-};
-
-/**
- * Records which query forms feed one query's args, so the devtools can answer "which query does this
- * form drive?" from the reads themselves rather than from a naming convention.
- * @internal
- */
-const createQueryDevtoolsFormLinks = () => {
-    const ids = signal([], /* @ts-ignore */
-    ...(ngDevMode ? [{ debugName: "ids" }] : /* istanbul ignore next */ []));
-    return {
-        ids: ids.asReadonly(),
-        track: (build) => {
-            const collected = collectQueryFormLinks(build);
-            // Args are built inside a reactive computation, which may not write to a signal - `untracked`
-            // lifts that restriction, and skipping the write unless something is new keeps the panel from
-            // being notified on every evaluation.
-            untracked(() => {
-                const known = ids();
-                const added = collected.ids.filter((id) => !known.includes(id));
-                if (added.length)
-                    ids.set([...known, ...added]);
-            });
-            return collected.value;
-        },
-    };
-};
-
 const DEFAULTS = {
     viewState: 'session',
     pins: 'local',
     overrides: 'none',
     mocks: 'local',
+    armedMocks: 'none',
+    armedFaults: 'none',
     maxEvents: 100,
     maxDroppedCacheEntries: 20,
     responseHistory: null,
@@ -6031,6 +5984,8 @@ const sanitize = (value) => ({
     pins: asScope(value?.pins, DEFAULTS.pins),
     overrides: asScope(value?.overrides, DEFAULTS.overrides),
     mocks: asScope(value?.mocks, DEFAULTS.mocks),
+    armedMocks: asScope(value?.armedMocks, DEFAULTS.armedMocks),
+    armedFaults: asScope(value?.armedFaults, DEFAULTS.armedFaults),
     maxEvents: asCount(value?.maxEvents, LIMITS.maxEvents, DEFAULTS.maxEvents),
     maxDroppedCacheEntries: asCount(value?.maxDroppedCacheEntries, LIMITS.maxDroppedCacheEntries, DEFAULTS.maxDroppedCacheEntries),
     responseHistory: asOptionalCount(value?.responseHistory, LIMITS.responseHistory),
@@ -6059,23 +6014,213 @@ const setQueryDevtoolsSettings = (patch) => {
     writeQueryDevtoolsStore('local', SETTINGS_KEY, next);
 };
 
+/** The neutral fault: nothing armed. */
+const EMPTY_QUERY_DEVTOOLS_FAULT = {
+    latencyMs: 0,
+    failNext: 0,
+    failRate: 0,
+    status: 503,
+};
 /**
- * The designed library. Whether a mock is **armed** is deliberately not part of it - see
+ * Statuses worth injecting, and whether the SDK's default retry policy retries them. A picker built from
+ * this cannot arm a 500 and then leave you wondering why no retry fired.
+ * @see runDefaultQueryRetry
+ */
+const QUERY_DEVTOOLS_FAULT_STATUSES = [
+    { status: 0, label: 'Network error', retryable: true },
+    { status: 400, label: 'Bad Request', retryable: false },
+    { status: 401, label: 'Unauthorized', retryable: false },
+    { status: 403, label: 'Forbidden', retryable: false },
+    { status: 404, label: 'Not Found', retryable: false },
+    { status: 408, label: 'Request Timeout', retryable: true },
+    { status: 429, label: 'Too Many Requests', retryable: true },
+    { status: 500, label: 'Internal Server Error', retryable: false },
+    { status: 502, label: 'Bad Gateway', retryable: true },
+    { status: 503, label: 'Service Unavailable', retryable: true },
+];
+const STORAGE_KEY$2 = 'ethlete:query:devtools:faults:v1';
+const faults = /* @__PURE__ */ signal({}, /* @ts-ignore */
+...(ngDevMode ? [{ debugName: "faults" }] : /* istanbul ignore next */ []));
+const restored$1 = /* @__PURE__ */ signal(false, /* @ts-ignore */
+...(ngDevMode ? [{ debugName: "restored" }] : /* istanbul ignore next */ []));
+const scope$2 = () => queryDevtoolsSettings().armedFaults;
+/**
+ * The faults armed per client name, consumed by the `<et-query-devtools>` UI. Clients with nothing armed
+ * are absent rather than present with an {@link EMPTY_QUERY_DEVTOOLS_FAULT}.
+ */
+const queryDevtoolsFaults = /* @__PURE__ */ faults.asReadonly();
+/**
+ * Whether what is armed right now came back from a previous page load rather than being armed by hand.
+ * The panel's armed bar says so, because injected failures nobody remembers arming look exactly like a
+ * broken API.
+ */
+const queryDevtoolsFaultsRestored = /* @__PURE__ */ restored$1.asReadonly();
+const write$1 = () => {
+    if (scope$2() === 'none') {
+        clearQueryDevtoolsStore(STORAGE_KEY$2);
+        return;
+    }
+    writeQueryDevtoolsStore(scope$2(), STORAGE_KEY$2, faults());
+};
+const asFault = (value) => {
+    const fault = value;
+    if (!fault || typeof fault !== 'object')
+        return null;
+    const next = {
+        latencyMs: Number(fault.latencyMs) || 0,
+        failNext: Number(fault.failNext) || 0,
+        failRate: Number(fault.failRate) || 0,
+        status: Number.isFinite(Number(fault.status)) ? Number(fault.status) : EMPTY_QUERY_DEVTOOLS_FAULT.status,
+    };
+    return isQueryDevtoolsFaultArmed(next) ? next : null;
+};
+/**
+ * Reads the armed faults back, when the `armedFaults` setting asks for them. Called by
+ * `provideQueryDevtools()` after the settings it takes its scope from; nothing else may call it.
+ * @internal
+ */
+const initQueryDevtoolsFaults = () => {
+    const stored = readQueryDevtoolsStore(scope$2(), STORAGE_KEY$2);
+    const inherited = {};
+    for (const [clientName, value] of Object.entries(stored ?? {})) {
+        const fault = asFault(value);
+        if (fault)
+            inherited[clientName] = fault;
+    }
+    faults.set(inherited);
+    restored$1.set(Object.keys(inherited).length > 0);
+};
+/**
+ * Where the armed faults are kept. Switching to a scope that keeps them stores whatever is armed right
+ * now; switching to `none` empties the store and leaves this page's faults exactly where they are.
+ */
+const setQueryDevtoolsFaultsScope = (next) => {
+    if (next === scope$2())
+        return;
+    // Off both stores first: whichever the previous scope was, its copy must not outlive the change.
+    clearQueryDevtoolsStore(STORAGE_KEY$2);
+    setQueryDevtoolsSettings({ armedFaults: next });
+    write$1();
+};
+/** Whether anything at all is armed on a fault. */
+const isQueryDevtoolsFaultArmed = (fault) => fault.latencyMs > 0 || fault.failNext > 0 || fault.failRate > 0;
+const patchFault = (options) => {
+    const { clientName, patch } = options;
+    faults.update((current) => {
+        const next = { ...(current[clientName] ?? EMPTY_QUERY_DEVTOOLS_FAULT), ...patch };
+        if (!isQueryDevtoolsFaultArmed(next)) {
+            const { [clientName]: _removed, ...rest } = current;
+            return rest;
+        }
+        return { ...current, [clientName]: next };
+    });
+    write$1();
+};
+/**
+ * Arms (or updates) the fault of one client. Only the given fields change; the rest keep their current
+ * value. A client whose resulting fault has nothing armed is dropped from {@link queryDevtoolsFaults}.
+ *
+ * Part of the devtools contract consumed by `<et-query-devtools>`; a fault is a debugging tool, not
+ * something an application should arm on itself.
+ */
+const setQueryDevtoolsFault = (options) => {
+    patchFault(options);
+    restored$1.set(false);
+};
+/**
+ * Disarms every fault of one client, or of all clients when no name is given.
+ *
+ * @see setQueryDevtoolsFault
+ */
+const clearQueryDevtoolsFaults = (clientName) => {
+    faults.update((current) => {
+        if (clientName === undefined)
+            return {};
+        const { [clientName]: _removed, ...rest } = current;
+        return rest;
+    });
+    restored$1.set(false);
+    write$1();
+};
+/**
+ * Resolves what to do with one upcoming attempt, consuming a `failNext` budget in the process - so this
+ * must be called once per attempt and never speculatively.
+ *
+ * Installed as the fault resolver by `provideQueryDevtools()`; nothing else may call it.
+ * @internal
+ */
+const resolveQueryDevtoolsFaultForAttempt = (target) => {
+    const fault = faults()[target.clientName];
+    if (!fault || !isQueryDevtoolsFaultArmed(fault))
+        return null;
+    let shouldFail = false;
+    if (fault.failNext > 0) {
+        shouldFail = true;
+        // Not the public setter: spending the budget is the armed fault doing its job, not someone re-arming
+        // it, so it must not clear what the panel's bar says about where the fault came from.
+        patchFault({ clientName: target.clientName, patch: { failNext: fault.failNext - 1 } });
+    }
+    else if (fault.failRate > 0) {
+        shouldFail = Math.random() * 100 < fault.failRate;
+    }
+    return {
+        latencyMs: fault.latencyMs,
+        status: shouldFail ? fault.status : null,
+    };
+};
+
+/**
+ * Records which query forms feed one query's args, so the devtools can answer "which query does this
+ * form drive?" from the reads themselves rather than from a naming convention.
+ * @internal
+ */
+const createQueryDevtoolsFormLinks = () => {
+    const ids = signal([], /* @ts-ignore */
+    ...(ngDevMode ? [{ debugName: "ids" }] : /* istanbul ignore next */ []));
+    return {
+        ids: ids.asReadonly(),
+        track: (build) => {
+            const collected = collectQueryFormLinks(build);
+            // Args are built inside a reactive computation, which may not write to a signal - `untracked`
+            // lifts that restriction, and skipping the write unless something is new keeps the panel from
+            // being notified on every evaluation.
+            untracked(() => {
+                const known = ids();
+                const added = collected.ids.filter((id) => !known.includes(id));
+                if (added.length)
+                    ids.set([...known, ...added]);
+            });
+            return collected.value;
+        },
+    };
+};
+
+/**
+ * The designed library. Which of them is **armed** is a separate store under a separate scope - see
  * {@link queryDevtoolsArmedMocks}.
  */
 const STORAGE_KEY$1 = 'ethlete:query:devtools:mocks:v1';
+const ARMED_STORAGE_KEY = 'ethlete:query:devtools:mocks:armed:v1';
 const mocks = /* @__PURE__ */ signal([], /* @ts-ignore */
 ...(ngDevMode ? [{ debugName: "mocks" }] : /* istanbul ignore next */ []));
 const armed = /* @__PURE__ */ signal(/* @__PURE__ */ new Set(), /* @ts-ignore */
 ...(ngDevMode ? [{ debugName: "armed" }] : /* istanbul ignore next */ []));
+const armedRestored = /* @__PURE__ */ signal(false, /* @ts-ignore */
+...(ngDevMode ? [{ debugName: "armedRestored" }] : /* istanbul ignore next */ []));
 const scope$1 = () => queryDevtoolsSettings().mocks;
+const armedScope = () => queryDevtoolsSettings().armedMocks;
 /** The designed mocks, armed or not. Persisted, because losing an hour of authoring is unacceptable. */
 const queryDevtoolsMocks = /* @__PURE__ */ mocks.asReadonly();
 /**
- * The ids currently being served. **Never persisted, at any scope**: an app that silently serves designed
- * data tomorrow morning is worse than losing which mocks were armed, so arming is per page load.
+ * The ids currently being served. Not kept across page loads unless the `armedMocks` setting asks for it -
+ * an app that silently serves designed data tomorrow morning is worse than losing which mocks were armed.
  */
 const queryDevtoolsArmedMocks = /* @__PURE__ */ armed.asReadonly();
+/**
+ * Whether what is armed right now came back from a previous page load rather than being armed by hand.
+ * The panel's armed bar says so, because mocks nobody remembers arming look exactly like a broken API.
+ */
+const queryDevtoolsArmedMocksRestored = /* @__PURE__ */ armedRestored.asReadonly();
 /**
  * The identity of a designed mock: one per client, method, route **and** declared query. The query is part
  * of it so `/posts?page=1` and `/posts?page=2` can hold different bodies.
@@ -6088,6 +6233,19 @@ const write = () => {
     }
     writeQueryDevtoolsStore(scope$1(), STORAGE_KEY$1, mocks());
 };
+const writeArmed = () => {
+    if (armedScope() === 'none') {
+        clearQueryDevtoolsStore(ARMED_STORAGE_KEY);
+        return;
+    }
+    writeQueryDevtoolsStore(armedScope(), ARMED_STORAGE_KEY, [...armed()]);
+};
+/** Every change made by hand goes through here, so none of them can leave the store or the bar behind. */
+const setArmed = (next) => {
+    armed.set(next);
+    armedRestored.set(false);
+    writeArmed();
+};
 const isMock = (value) => {
     const mock = value;
     return (!!mock &&
@@ -6106,7 +6264,15 @@ const initQueryDevtoolsMocks = () => {
     const stored = readQueryDevtoolsStore(scope$1(), STORAGE_KEY$1);
     // `query` was added after the first version of the store, so an entry written before it still loads.
     mocks.set(Array.isArray(stored) ? stored.filter(isMock).map((mock) => ({ ...mock, query: mock.query ?? '' })) : []);
-    armed.set(new Set());
+    const kept = readQueryDevtoolsStore(armedScope(), ARMED_STORAGE_KEY);
+    const library = new Set(mocks().map((mock) => mock.id));
+    // An id the library no longer holds would arm nothing, so it is dropped rather than kept waiting for a
+    // mock that may never be designed again.
+    const inherited = Array.isArray(kept)
+        ? kept.filter((id) => typeof id === 'string' && library.has(id))
+        : [];
+    armed.set(new Set(inherited));
+    armedRestored.set(inherited.length > 0);
 };
 /** The path of a request URL, without its origin or query string - what a pattern is matched against. */
 const queryDevtoolsRequestPath = (url) => {
@@ -6163,24 +6329,39 @@ const deleteQueryDevtoolsMock = (id) => {
 };
 /** Starts or stops serving one designed mock. Arming a mock that is not in the library does nothing. */
 const armQueryDevtoolsMock = (id, isArmed) => {
-    armed.update((current) => {
-        if (isArmed && !mocks().some((mock) => mock.id === id))
-            return current;
-        const next = new Set(current);
-        if (isArmed)
-            next.add(id);
-        else
-            next.delete(id);
-        return next;
-    });
-};
+    if (isArmed && !mocks().some((mock) => mock.id === id))
+        return;
+    const next = new Set(armed());
+    if (isArmed)
+        next.add(id);
+    else
+        next.delete(id);
+    setArmed(next);
+};
+/** Starts serving every mock in the library - the counterpart of {@link clearQueryDevtoolsArmedMocks}. */
+const armAllQueryDevtoolsMocks = () => setArmed(new Set(mocks().map((mock) => mock.id)));
 /** Stops serving every mock, leaving the library alone - the armed bar's one-click way out. */
-const clearQueryDevtoolsArmedMocks = () => armed.set(new Set());
+const clearQueryDevtoolsArmedMocks = () => setArmed(new Set());
+/**
+ * Where the armed set is kept. Switching to a scope that keeps it stores whatever is armed right now, so
+ * the choice reads as "keep these"; switching to `none` empties the store and leaves this page serving
+ * exactly what it was already serving.
+ */
+const setQueryDevtoolsArmedMocksScope = (next) => {
+    if (next === armedScope())
+        return;
+    // Off both stores first: whichever the previous scope was, its copy must not outlive the change.
+    clearQueryDevtoolsStore(ARMED_STORAGE_KEY);
+    setQueryDevtoolsSettings({ armedMocks: next });
+    writeArmed();
+};
 /** Empties the designed library and disarms everything - the panel's "Reset devtools". */
 const clearQueryDevtoolsMockStore = () => {
     mocks.set([]);
     armed.set(new Set());
+    armedRestored.set(false);
     clearQueryDevtoolsStore(STORAGE_KEY$1);
+    clearQueryDevtoolsStore(ARMED_STORAGE_KEY);
 };
 const declaredParamCount = (mock) => (mock.query ? [...new URLSearchParams(mock.query)].length : 0);
 /**
@@ -6916,7 +7097,7 @@ const armQueryDevtoolsOverrideTransfer = (recorder, ops) => {
 
 // Generated from package.json by tools/scripts/generate-version.js - do not edit.
 /** The version of `@ethlete/query` this build was cut from. */
-const QUERY_VERSION = '6.0.0-next.33';
+const QUERY_VERSION = '6.0.0-next.34';
 
 /** How deep a schema is expanded before a nested branch is given up on. */
 const MAX_DEPTH = 12;
@@ -7248,6 +7429,89 @@ const seedQueryDevtoolsSchemaBody = (name) => {
         return null;
     return seedFrom(schema, name);
 };
+/** Where a schema was collected from, so the same name arriving from two pointers is caught. */
+const originOf = (label, pointer) => pointer ?? `named:${label}`;
+/**
+ * Copies a schema, pointing every local `$ref` at `#/components/schemas/<name>` and queueing that name -
+ * so a document assembled from these resolves against its own `components`, whether the description kept
+ * its schemas under `components.schemas`, `definitions` or `$defs`.
+ */
+const rewriteRefs = (value, queue) => {
+    if (Array.isArray(value))
+        return value.map((entry) => rewriteRefs(entry, queue));
+    if (!isRecord(value))
+        return value;
+    const result = {};
+    for (const [key, entry] of Object.entries(value)) {
+        if (key === '$ref' && typeof entry === 'string') {
+            if (!entry.startsWith('#/')) {
+                result[key] = entry;
+                continue;
+            }
+            const label = refLabel(entry);
+            queue({ label, pointer: entry });
+            result[key] = `#/components/schemas/${label}`;
+            continue;
+        }
+        result[key] = rewriteRefs(entry, queue);
+    }
+    return result;
+};
+/**
+ * Collects the named schemas a set of routes was designed against, ready to be handed back as the
+ * `components.schemas` of an exported document - so a route seeded from `MatchView` can reference
+ * `MatchView` instead of an anonymous shape inferred from one body.
+ *
+ * Part of the devtools contract. **Not part of the general public contract.**
+ */
+const collectQueryDevtoolsSchemaComponents = (names) => {
+    const declared = namedSchemas();
+    const schemas = {};
+    const notes = new Set();
+    const origins = new Map();
+    const pending = names.map((label) => ({ label, pointer: null }));
+    while (pending.length) {
+        const request = pending.shift();
+        const origin = originOf(request.label, request.pointer);
+        const seen = origins.get(request.label);
+        if (seen !== undefined) {
+            if (seen !== origin) {
+                notes.add(`Two different schemas are both called ${request.label} - only the one from ${seen} was kept.`);
+            }
+            continue;
+        }
+        const schema = request.pointer === null ? declared[request.label] : resolveRef(request.pointer);
+        if (schema === undefined) {
+            if (request.pointer !== null) {
+                notes.add(`${request.pointer} could not be resolved, so ${request.label} is missing from the export.`);
+            }
+            continue;
+        }
+        origins.set(request.label, origin);
+        schemas[request.label] = rewriteRefs(schema, (next) => pending.push(next));
+    }
+    for (const schema of Object.values(schemas)) {
+        collectRemoteRefs(schema, notes);
+    }
+    return { schemas, notes: [...notes] };
+};
+/** A `$ref` to another file is left as it was written, so a document says where it stops resolving. */
+const collectRemoteRefs = (value, notes) => {
+    if (Array.isArray(value)) {
+        for (const entry of value)
+            collectRemoteRefs(entry, notes);
+        return;
+    }
+    if (!isRecord(value))
+        return;
+    for (const [key, entry] of Object.entries(value)) {
+        if (key === '$ref' && typeof entry === 'string' && !entry.startsWith('#/')) {
+            notes.add(`${entry} points outside the description - it was exported unchanged and will not resolve.`);
+            continue;
+        }
+        collectRemoteRefs(entry, notes);
+    }
+};
 const segmentsOf = (pattern) => pattern.split('/').filter(Boolean);
 /** `/matches/{id}` and `/matches/:id` describe the same route; a mock's pattern is written the second way. */
 const toColonPattern = (path) => path.replace(/\{([^}]+)\}/g, ':$1');
@@ -7662,6 +7926,90 @@ const sumQueryDevtoolsStats = (handles) => {
     return total;
 };
 
+/**
+ * The longest lifetime an armed override may claim, in seconds (7 days). Anything beyond it is never
+ * refreshed at all, which is what arming nothing already does.
+ */
+const QUERY_DEVTOOLS_TOKEN_TTL_LIMIT = 604800;
+/** The claims an overridden lifetime is measured from, in the order they are tried. */
+const ANCHOR_CLAIMS = ['iat', 'nbf'];
+const ttls = /* @__PURE__ */ signal({}, /* @ts-ignore */
+...(ngDevMode ? [{ debugName: "ttls" }] : /* istanbul ignore next */ []));
+/**
+ * The access-token lifetime armed per auth provider name, in seconds, consumed by the
+ * `<et-query-devtools>` panel. A provider on its token's real lifetime is absent rather than present
+ * with it.
+ */
+const queryDevtoolsTokenTtls = /* @__PURE__ */ ttls.asReadonly();
+const tokenTtlAnchor = (options) => {
+    const { payload, expiresInPropertyName } = options;
+    if (!payload || typeof payload[expiresInPropertyName] !== 'number')
+        return null;
+    for (const claim of ANCHOR_CLAIMS) {
+        const value = payload[claim];
+        if (typeof value === 'number')
+            return value;
+    }
+    return null;
+};
+/**
+ * Whether an overridden lifetime can be applied to a decoded access token at all. It needs the claim
+ * carrying the expiry - so a lifetime is never invented for a token that declares none - plus `iat` or
+ * `nbf` to measure the new lifetime from.
+ */
+const canOverrideQueryDevtoolsTokenTtl = (options) => tokenTtlAnchor({ payload: options.payload, expiresInPropertyName: options.expiresInPropertyName ?? 'exp' }) !== null;
+/**
+ * Presents one auth provider's access token as living `seconds` from the moment it was issued, rather
+ * than as long as it says it does. Everything that reads the expiry sees the shortened lifetime - the
+ * proactive refresh schedule, `withBearerAuthTokenExpirationWarning`, and the panel's own countdown -
+ * so arming 60 seconds makes a real refresh happen a minute after each token is issued, and keeps
+ * happening for every token that refresh brings back.
+ *
+ * It is a lifetime, not a remaining time: `0` presents the current token as long expired, which is what
+ * makes a refresh happen at once. Nothing is persisted, so a reload leaves every provider on its real
+ * lifetime.
+ *
+ * Part of the devtools contract consumed by `<et-query-devtools>`; a token's lifetime is not something
+ * an application should override on itself.
+ */
+const setQueryDevtoolsTokenTtl = (options) => {
+    const { providerName, seconds } = options;
+    const clamped = Math.min(Math.max(Math.trunc(seconds) || 0, 0), QUERY_DEVTOOLS_TOKEN_TTL_LIMIT);
+    ttls.update((current) => ({ ...current, [providerName]: clamped }));
+};
+/**
+ * Puts one provider back on its token's real lifetime, or every provider when no name is given.
+ *
+ * @see setQueryDevtoolsTokenTtl
+ */
+const clearQueryDevtoolsTokenTtl = (providerName) => {
+    ttls.update((current) => {
+        if (providerName === undefined)
+            return {};
+        const { [providerName]: _removed, ...rest } = current;
+        return rest;
+    });
+};
+/**
+ * The decoded access token as the devtools want it seen: the claim carrying the expiry rewritten to the
+ * armed lifetime, measured from `iat`. Returns `payload` untouched when nothing is armed for the
+ * provider, or when the token cannot carry the override - see {@link canOverrideQueryDevtoolsTokenTtl}.
+ *
+ * Installed as the token payload patcher by `provideQueryDevtools()`, and called directly by the panel
+ * for its own countdown.
+ */
+const applyQueryDevtoolsTokenTtl = (options) => {
+    const { payload, providerName, expiresInPropertyName = 'exp' } = options;
+    const seconds = ttls()[providerName];
+    if (seconds === undefined || !payload || typeof payload !== 'object')
+        return payload;
+    const record = payload;
+    const anchor = tokenTtlAnchor({ payload: record, expiresInPropertyName });
+    if (anchor === null)
+        return payload;
+    return { ...record, [expiresInPropertyName]: anchor + seconds };
+};
+
 /**
  * How many destroyed queries the registry keeps. A tombstone holds the last response body it captured,
  * so the list is capped for the same reason the repository caps its unused entries.
@@ -7942,6 +8290,7 @@ const provideQueryDevtools = (options) => {
     setQueryDevtoolsAppInfo(options?.about);
     initQueryDevtoolsOverridePersistence();
     initQueryDevtoolsMocks();
+    initQueryDevtoolsFaults();
     setQueryDevtoolsSchemaLoader(options?.schema);
     setQueryDevtoolsRegistrar(registerEntry);
     setQueryDevtoolsStatsFactory(createQueryDevtoolsStats);
@@ -7949,6 +8298,7 @@ const provideQueryDevtools = (options) => {
     setQueryDevtoolsOverridesFactory(createQueryDevtoolsOverrides);
     setQueryDevtoolsFaultResolver(resolveQueryDevtoolsFaultForAttempt);
     setQueryDevtoolsMockResolver(resolveQueryDevtoolsMockForAttempt);
+    setQueryDevtoolsTokenPayloadPatcher(applyQueryDevtoolsTokenTtl);
     if (!isDevMode()) {
         console.warn('You are using the Query Devtools in production mode. This increases the size of your bundle and should only be used for development purposes.');
     }
@@ -13489,5 +13839,5 @@ const createWebSocketClient = (options) => {
  * Generated bundle index. Do not edit.
  */
 
-export { BasicAuthProvider, BearerAuthFeatureType, BooleanArrayQueryField, CLEAR_QUERY_ARGS, CustomHeaderAuthProvider, DEFAULT_KEEP_UNUSED_FOR, DEFAULT_QUERY_PERSISTENCE_MAX_AGE, DEFAULT_QUERY_PERSISTENCE_MAX_ENTRIES, DEFAULT_QUERY_PERSISTENCE_VERSION, DEFAULT_QUERY_PERSISTENCE_WRITE_DELAY, DateArrayQueryField, DateQueryField, EMPTY_QUERY_DEVTOOLS_FAULT, EntityStore, IGNORED_FILTER_COUNT_FIELDS, INFINITY_QUERY_TOKEN, InfinityQuery, InfinityQueryDirective, InfinityQueryTriggerDirective, LegacyQuery, LegacyQueryCreator, MAX_QUERY_DEVTOOLS_TOMBSTONES, MAX_UNUSED_ENTRIES, NumberArrayQueryField, ParseHttpErrorCodeToMessageDePipe, ParseHttpErrorCodeToMessageEnPipe, ParseHttpErrorCodeToTitleDePipe, ParseHttpErrorCodeToTitleEnPipe, QUERY_CLIENT_DEVTOOLS_TOKEN, QUERY_DEVTOOLS_FAULT_STATUSES, QUERY_PERSISTENCE_STORE_VERSION, QUERY_SYNC_PROTOCOL_VERSION, QUERY_VERSION, QueryClientFeatureType, QueryDevtoolsComponent, QueryDirective, QueryFeatureType, QueryField, QueryForm, QueryRuntimeErrorCode, QueryShortNamePipe, QueryStore, SERVER_ERROR_KIND, SERVER_VIOLATION_ERROR_KIND, SPEED_BUFFER_TIME_IN_MS, SearchQueryField, SortQueryField, StringArrayQueryField, V2BearerAuthProvider, V2Query, V2QueryClient, V2QueryCreator, addQueryContainerHandling, applyQueryDevtoolsOverrides, applyQueryFeatures, armQueryDevtoolsMock, armQueryDevtoolsOverrideTransfer, authExtractTokensResponseMissingAccessToken, authExtractTokensResponseMissingRefreshToken, authExtractTokensResponseNotObject, authProviderFeatureUsedMultipleTimes, booleanArrayQueryField, buildQueryCacheKey, buildQueryString, buildRoute, buildTimestampFromSeconds, castQueryCreatorTypes, circularQueryDependency, circularQueryDependencyChecker, clearQueryDevtoolsArmedMocks, clearQueryDevtoolsFaults, clearQueryDevtoolsMockStore, clearQueryDevtoolsOverrideStore, clearQueryDevtoolsStore, clearQueryDevtoolsTombstones, clearRestoredQueryDevtoolsOverrides, collectLeafPaths, collectQueryFormLinks, computeQueryAuthHeader, computeQueryBody, computeQueryHeaders, computeQueryMethod, computeQueryQueryParams, consumeSuppressQueryStackDevtools, contentfulGqlLikePaginationAdapter, countUnresolvedQueryDevtoolsOverrides, createAuthGuard, createBaseQuery, createBaseQueryCreator, createBearerAuthProvider, createDeleteQuery, createExecuteFn, createGetQuery, createGqlExecuteFn, createGqlMutationViaGet, createGqlMutationViaPost, createGqlQuery, createGqlQueryCreator, createGqlQueryViaGet, createGqlQueryViaPost, createHttpRequest, createIndexedDbQueryPersistenceAdapter, createInfinityQueryConfig, createLegacyQueryCreator, createNoopQueryPersistenceAdapter, createPagedQueryStack, createPatchQuery, createPersistentAuthFeature, createPostQuery, createPutQuery, createQuery, createQueryClient, createQueryCollection, createQueryCollectionSignal, createQueryCollectionSubject, createQueryContext, createQueryCreator, createQueryDevtoolsFormLinks, createQueryDevtoolsFormLinksRecorder, createQueryDevtoolsOverrides, createQueryDevtoolsOverridesRecorder, createQueryDevtoolsStats, createQueryDevtoolsStatsRecorder, createQueryErrorResponse, createQueryFeature, createQueryInvalidationFilter, createQueryKeyLockManager, createQueryObject, createQueryPersistenceEngine, createQueryRepository, createQuerySnapshotFn, createQueryStack, createQuerySyncEngine, createQuerySyncTransport, createSecureDeleteQuery, createSecureExecuteFactory, createSecureExecuteFn, createSecureGetQuery, createSecureGqlExecuteFn, createSecureGqlMutationViaGet, createSecureGqlMutationViaPost, createSecureGqlQuery, createSecureGqlQueryCreator, createSecureGqlQueryViaGet, createSecureGqlQueryViaPost, createSecurePatchQuery, createSecurePostQuery, createSecurePutQuery, createSecureQuery, createSecureQueryCreator, createTrackingFeature, createWebSocketClient, dateArrayQueryField, dateQueryField, decryptBearer, deepFreeze, def, defineQueryForm, deleteQueryDevtoolsMock, describeQueryDevtoolsFeatures, detectContentTypeHeader, detectPaginationShape, dynLikePaginationAdapter, effectComputed, emptyQueryArgs, ethletePaginationAdapter, executeUntilSettled, extractExpiresInSeconds, extractFormViolations, extractHtmlErrorMessage, extractQuery, fakePaginationAdapter, filterFailure, filterNull, filterQueryStates, filterSuccess, forEachHeader, formatQueryDevtoolsDuration, generateQueryDevtoolsNumberPreset, generateQueryDevtoolsStringPreset, getBearerAuthProviderName, getDefaultHeaders, getQueryClientName, getQueryFeatureUsage, getResponseUrl, ggLikePaginationAdapter, gql, gqlDataPropertyMissingInResponse, hasHeader, hasQueryDevtoolsOverridesAtPath, htmlErrorPayload, htmlQueryErrorParser, ignoreAutoRefresh, initQueryDevtoolsMocks, initQueryDevtoolsOverridePersistence, initQueryDevtoolsSettings, injectInfinityQueryResponseDelay, injectQueryContext, insertFrom, invalidBaseRouteError, invalidBodyError, invalidRouteError, invalidStateInsideSecureExecuteFactory, isAutoRefresh, isBasicAuthProvider, isBearerAuthProvider, isClassValidatorError, isCreateGqlQueryOptions, isCustomHeaderAuthProvider, isDateShapedLeaf, isEmptyString, isGqlQueryConfig, isHtmlErrorPayload, isLegacyQuery, isNaN$1 as isNaN, isPageOutOfRangeError, isQuery, isQueryCollection, isQueryDevtoolsEnabled, isQueryDevtoolsFaultArmed, isQueryDevtoolsRequestInterceptionEnabled, isQueryErrorResponse, isQueryStateCancelled, isQueryStateFailure, isQueryStateLoading, isQueryStatePrepared, isQueryStateSuccess, isRequestError, isSymfonyError, isSymfonyFormViolationListError, isSymfonyListError, isSymfonyPagerfantaOutOfRangeError, isUnderInvalidatedUrl, legacyPrepareFallbackInjector, legacyPrepareWithoutInjectionContext, loadQueryDevtoolsSchema, mapToPaginated, mapViolationsToFormErrors, matchesQueryDevtoolsMockPattern, matchesQueryDevtoolsMockQuery, maybeExecute, measureQueryDevtoolsPayload, mergeHeaders, nestedEffect, noteQueryFormRead, numberArrayQueryField, pagedQueryStackNextPageCalledWithoutPreviousPage, pagedQueryStackPageBiggerThanTotalPages, pagedQueryStackPreviousPageCalledButAlreadyAtFirstPage, paginatedEntityValueUpdater, parseAllXhrResponseHeaders, parseHttpErrorCodeToMessageDe, parseHttpErrorCodeToMessageEn, parseHttpErrorCodeToTitleDe, parseHttpErrorCodeToTitleEn, parseQueryDevtoolsOverrideTransfer, parseQueryRoute, pathParamsMissingInRouteFunctionError, provideInfinityQueryResponseDelay, provideLegacyPrepareFallback, provideQueryClientForDevtools, provideQueryDevtools, queryArrayComputed, queryClientFeatureUsedMultipleTimes, queryComputed, queryComputedTillTruthy, queryDevtoolsAbout, queryDevtoolsArmedMocks, queryDevtoolsEntries, queryDevtoolsFaults, queryDevtoolsFnDetail, queryDevtoolsMockId, queryDevtoolsMocks, queryDevtoolsOverridePersistence, queryDevtoolsRequestPath, queryDevtoolsResponseHistory, queryDevtoolsRestoredOverridesScope, queryDevtoolsSchemaNames, queryDevtoolsSchemaRoutes, queryDevtoolsSchemaState, queryDevtoolsSettings, queryDevtoolsStorage, queryErrorMessage, queryErrorMessages, queryExecute, queryFeatureUsedMultipleTimes, queryField, querySequence, querySequenceAlreadyRunning, queryStackTotalQueriesAndExpectedQueriesMismatch, queryStackWithArgsUsed, queryStackWithResponseUpdateUsed, queryStateAlreadyHasKeyError, queryStateCannotTransformError, queryStateDoesNotContainKeyError, queryStateErrorSignal, queryStateLoadingSignal, queryStateResponseSignal, queryStateSignal, readQueryDevtoolsStore, registerEthleteVersion, registerQueryDevtoolsEntry, registerQueryErrorParser, removeFrom, request, resetExecuteState, resetPageOnError, resolveInvalidationUrl, resolveQueryDevtoolsFault, resolveQueryDevtoolsFaultForAttempt, resolveQueryDevtoolsMock, resolveQueryDevtoolsMockForAttempt, restoredQueryDevtoolsOverrides, runDefaultQueryRetry, runQueryErrorParsers, saveQueryDevtoolsMock, searchQueryField, seedQueryDevtoolsSchemaBody, seedQueryDevtoolsSchemaRoute, serializeBody, serializeQueryDevtoolsOverrideTransfer, setDefaultQueryRetryFn, setQueryDevtoolsAppInfo, setQueryDevtoolsFault, setQueryDevtoolsFaultResolver, setQueryDevtoolsFormLinksFactory, setQueryDevtoolsMockResolver, setQueryDevtoolsOverridePersistence, setQueryDevtoolsOverridesFactory, setQueryDevtoolsOverridesScope, setQueryDevtoolsRegistrar, setQueryDevtoolsResponseHistory, setQueryDevtoolsSchemaLoader, setQueryDevtoolsSettings, setQueryDevtoolsStatsFactory, setupQueryDependencies, setupQueryExecuteState, setupQueryState, shouldAutoExecuteGqlQuery, shouldAutoExecuteQuery, shouldCacheQuery, shouldRetryRequest, silenceMissingWithArgsFeatureErrorUsedButWithArgsPresent, skipPaginationPageParamCalculator, smartDuplicateArrayItem, snapshotQueryDevtoolsHandle, sortQueryField, splitQueryConfig, stringArrayQueryField, stringifyQueryRouteParts, sumQueryDevtoolsStats, suppressNextQueryStackDevtools, switchQueryCollectionState, switchQueryState, symfonyQueryErrorParser, takeUntilResponse, toQuerySignal, toQuerySubject, tokensNotAvailableInsideAuthAndExec, tombstoneOf, transformArrayResponse, transformExecStateToQueryState, transformGql, transformMethod, transformPaginatedResponse, transformToBoolean, transformToBooleanArray, transformToDate, transformToDateArray, transformToNumber, transformToNumberArray, transformToSort, transformToSortQueryParam, transformToString, transformToStringArray, uncacheableRequestHasAllowCacheParam, uncacheableRequestHasCacheKeyParam, unwrapQuerySyncMessage, v2BuildQueryCacheKey, v2ExtractExpiresInSeconds, v2ShouldCacheQuery, v2ShouldRetryRequest, validateWithQuery, validateWithV2Query, withArgs, withArgsQueryFeatureMissingButRouteIsFunction, withAuthenticationQuery, withAutoRefresh, withAutoRefreshUsedInManualQuery, withAutoRefreshUsedOnUnsupportedHttpMethod, withBearerAuthMultiTabSync, withDefaultRetry, withErrorHandling, withEthleteApiErrors, withHtmlErrorParsing, withInactivityLogout, withLogging, withMultiTabSync, withPageResetOnError, withPersistentAuth, withPolling, withPollingUsedOnUnsupportedHttpMethod, withQueryDevtoolsOverridePersistence, withQueryPersistence, withRefreshQuery, withResponseUpdate, withSuccessHandling, withSymfonyErrors, withTokenExpirationWarning, withTokenRevocation, withTracking, wrapAsObservableSignal, wrapQuerySyncMessage, writeQueryDevtoolsStore };
+export { BasicAuthProvider, BearerAuthFeatureType, BooleanArrayQueryField, CLEAR_QUERY_ARGS, CustomHeaderAuthProvider, DEFAULT_KEEP_UNUSED_FOR, DEFAULT_QUERY_PERSISTENCE_MAX_AGE, DEFAULT_QUERY_PERSISTENCE_MAX_ENTRIES, DEFAULT_QUERY_PERSISTENCE_VERSION, DEFAULT_QUERY_PERSISTENCE_WRITE_DELAY, DateArrayQueryField, DateQueryField, EMPTY_QUERY_DEVTOOLS_FAULT, EntityStore, IGNORED_FILTER_COUNT_FIELDS, INFINITY_QUERY_TOKEN, InfinityQuery, InfinityQueryDirective, InfinityQueryTriggerDirective, LegacyQuery, LegacyQueryCreator, MAX_QUERY_DEVTOOLS_TOMBSTONES, MAX_UNUSED_ENTRIES, NumberArrayQueryField, ParseHttpErrorCodeToMessageDePipe, ParseHttpErrorCodeToMessageEnPipe, ParseHttpErrorCodeToTitleDePipe, ParseHttpErrorCodeToTitleEnPipe, QUERY_CLIENT_DEVTOOLS_TOKEN, QUERY_DEVTOOLS_FAULT_STATUSES, QUERY_DEVTOOLS_TOKEN_TTL_LIMIT, QUERY_PERSISTENCE_STORE_VERSION, QUERY_SYNC_PROTOCOL_VERSION, QUERY_VERSION, QueryClientFeatureType, QueryDevtoolsComponent, QueryDirective, QueryFeatureType, QueryField, QueryForm, QueryRuntimeErrorCode, QueryShortNamePipe, QueryStore, SERVER_ERROR_KIND, SERVER_VIOLATION_ERROR_KIND, SPEED_BUFFER_TIME_IN_MS, SearchQueryField, SortQueryField, StringArrayQueryField, V2BearerAuthProvider, V2Query, V2QueryClient, V2QueryCreator, addQueryContainerHandling, applyQueryDevtoolsOverrides, applyQueryDevtoolsTokenTtl, applyQueryFeatures, armAllQueryDevtoolsMocks, armQueryDevtoolsMock, armQueryDevtoolsOverrideTransfer, authExtractTokensResponseMissingAccessToken, authExtractTokensResponseMissingRefreshToken, authExtractTokensResponseNotObject, authProviderFeatureUsedMultipleTimes, booleanArrayQueryField, buildQueryCacheKey, buildQueryString, buildRoute, buildTimestampFromSeconds, canOverrideQueryDevtoolsTokenTtl, castQueryCreatorTypes, circularQueryDependency, circularQueryDependencyChecker, clearQueryDevtoolsArmedMocks, clearQueryDevtoolsFaults, clearQueryDevtoolsMockStore, clearQueryDevtoolsOverrideStore, clearQueryDevtoolsStore, clearQueryDevtoolsTokenTtl, clearQueryDevtoolsTombstones, clearRestoredQueryDevtoolsOverrides, collectLeafPaths, collectQueryDevtoolsSchemaComponents, collectQueryFormLinks, computeQueryAuthHeader, computeQueryBody, computeQueryHeaders, computeQueryMethod, computeQueryQueryParams, consumeSuppressQueryStackDevtools, contentfulGqlLikePaginationAdapter, countUnresolvedQueryDevtoolsOverrides, createAuthGuard, createBaseQuery, createBaseQueryCreator, createBearerAuthProvider, createDeleteQuery, createExecuteFn, createGetQuery, createGqlExecuteFn, createGqlMutationViaGet, createGqlMutationViaPost, createGqlQuery, createGqlQueryCreator, createGqlQueryViaGet, createGqlQueryViaPost, createHttpRequest, createIndexedDbQueryPersistenceAdapter, createInfinityQueryConfig, createLegacyQueryCreator, createNoopQueryPersistenceAdapter, createPagedQueryStack, createPatchQuery, createPersistentAuthFeature, createPostQuery, createPutQuery, createQuery, createQueryClient, createQueryCollection, createQueryCollectionSignal, createQueryCollectionSubject, createQueryContext, createQueryCreator, createQueryDevtoolsFormLinks, createQueryDevtoolsFormLinksRecorder, createQueryDevtoolsOverrides, createQueryDevtoolsOverridesRecorder, createQueryDevtoolsStats, createQueryDevtoolsStatsRecorder, createQueryErrorResponse, createQueryFeature, createQueryInvalidationFilter, createQueryKeyLockManager, createQueryObject, createQueryPersistenceEngine, createQueryRepository, createQuerySnapshotFn, createQueryStack, createQuerySyncEngine, createQuerySyncTransport, createSecureDeleteQuery, createSecureExecuteFactory, createSecureExecuteFn, createSecureGetQuery, createSecureGqlExecuteFn, createSecureGqlMutationViaGet, createSecureGqlMutationViaPost, createSecureGqlQuery, createSecureGqlQueryCreator, createSecureGqlQueryViaGet, createSecureGqlQueryViaPost, createSecurePatchQuery, createSecurePostQuery, createSecurePutQuery, createSecureQuery, createSecureQueryCreator, createTrackingFeature, createWebSocketClient, dateArrayQueryField, dateQueryField, decryptBearer, deepFreeze, def, defineQueryForm, deleteQueryDevtoolsMock, describeQueryDevtoolsFeatures, detectContentTypeHeader, detectPaginationShape, dynLikePaginationAdapter, effectComputed, emptyQueryArgs, ethletePaginationAdapter, executeUntilSettled, extractExpiresInSeconds, extractFormViolations, extractHtmlErrorMessage, extractQuery, fakePaginationAdapter, filterFailure, filterNull, filterQueryStates, filterSuccess, forEachHeader, formatQueryDevtoolsDuration, generateQueryDevtoolsNumberPreset, generateQueryDevtoolsStringPreset, getBearerAuthProviderName, getDefaultHeaders, getQueryClientName, getQueryFeatureUsage, getResponseUrl, ggLikePaginationAdapter, gql, gqlDataPropertyMissingInResponse, hasHeader, hasQueryDevtoolsOverridesAtPath, htmlErrorPayload, htmlQueryErrorParser, ignoreAutoRefresh, initQueryDevtoolsFaults, initQueryDevtoolsMocks, initQueryDevtoolsOverridePersistence, initQueryDevtoolsSettings, injectInfinityQueryResponseDelay, injectQueryContext, insertFrom, invalidBaseRouteError, invalidBodyError, invalidRouteError, invalidStateInsideSecureExecuteFactory, isAutoRefresh, isBasicAuthProvider, isBearerAuthProvider, isClassValidatorError, isCreateGqlQueryOptions, isCustomHeaderAuthProvider, isDateShapedLeaf, isEmptyString, isGqlQueryConfig, isHtmlErrorPayload, isLegacyQuery, isNaN$1 as isNaN, isPageOutOfRangeError, isQuery, isQueryCollection, isQueryDevtoolsEnabled, isQueryDevtoolsFaultArmed, isQueryDevtoolsRequestInterceptionEnabled, isQueryErrorResponse, isQueryStateCancelled, isQueryStateFailure, isQueryStateLoading, isQueryStatePrepared, isQueryStateSuccess, isRequestError, isSymfonyError, isSymfonyFormViolationListError, isSymfonyListError, isSymfonyPagerfantaOutOfRangeError, isUnderInvalidatedUrl, legacyPrepareFallbackInjector, legacyPrepareWithoutInjectionContext, loadQueryDevtoolsSchema, mapToPaginated, mapViolationsToFormErrors, matchesQueryDevtoolsMockPattern, matchesQueryDevtoolsMockQuery, maybeExecute, measureQueryDevtoolsPayload, mergeHeaders, nestedEffect, noteQueryFormRead, numberArrayQueryField, pagedQueryStackNextPageCalledWithoutPreviousPage, pagedQueryStackPageBiggerThanTotalPages, pagedQueryStackPreviousPageCalledButAlreadyAtFirstPage, paginatedEntityValueUpdater, parseAllXhrResponseHeaders, parseHttpErrorCodeToMessageDe, parseHttpErrorCodeToMessageEn, parseHttpErrorCodeToTitleDe, parseHttpErrorCodeToTitleEn, parseQueryDevtoolsOverrideTransfer, parseQueryRoute, patchQueryDevtoolsTokenPayload, pathParamsMissingInRouteFunctionError, provideInfinityQueryResponseDelay, provideLegacyPrepareFallback, provideQueryClientForDevtools, provideQueryDevtools, queryArrayComputed, queryClientFeatureUsedMultipleTimes, queryComputed, queryComputedTillTruthy, queryDevtoolsAbout, queryDevtoolsArmedMocks, queryDevtoolsArmedMocksRestored, queryDevtoolsEntries, queryDevtoolsFaults, queryDevtoolsFaultsRestored, queryDevtoolsFnDetail, queryDevtoolsMockId, queryDevtoolsMocks, queryDevtoolsOverridePersistence, queryDevtoolsRequestPath, queryDevtoolsResponseHistory, queryDevtoolsRestoredOverridesScope, queryDevtoolsSchemaNames, queryDevtoolsSchemaRoutes, queryDevtoolsSchemaState, queryDevtoolsSettings, queryDevtoolsStorage, queryDevtoolsTokenTtls, queryErrorMessage, queryErrorMessages, queryExecute, queryFeatureUsedMultipleTimes, queryField, querySequence, querySequenceAlreadyRunning, queryStackTotalQueriesAndExpectedQueriesMismatch, queryStackWithArgsUsed, queryStackWithResponseUpdateUsed, queryStateAlreadyHasKeyError, queryStateCannotTransformError, queryStateDoesNotContainKeyError, queryStateErrorSignal, queryStateLoadingSignal, queryStateResponseSignal, queryStateSignal, readQueryDevtoolsStore, registerEthleteVersion, registerQueryDevtoolsEntry, registerQueryErrorParser, removeFrom, request, resetExecuteState, resetPageOnError, resolveInvalidationUrl, resolveQueryDevtoolsFault, resolveQueryDevtoolsFaultForAttempt, resolveQueryDevtoolsMock, resolveQueryDevtoolsMockForAttempt, restoredQueryDevtoolsOverrides, runDefaultQueryRetry, runQueryErrorParsers, saveQueryDevtoolsMock, searchQueryField, seedQueryDevtoolsSchemaBody, seedQueryDevtoolsSchemaRoute, serializeBody, serializeQueryDevtoolsOverrideTransfer, setDefaultQueryRetryFn, setQueryDevtoolsAppInfo, setQueryDevtoolsArmedMocksScope, setQueryDevtoolsFault, setQueryDevtoolsFaultResolver, setQueryDevtoolsFaultsScope, setQueryDevtoolsFormLinksFactory, setQueryDevtoolsMockResolver, setQueryDevtoolsOverridePersistence, setQueryDevtoolsOverridesFactory, setQueryDevtoolsOverridesScope, setQueryDevtoolsRegistrar, setQueryDevtoolsResponseHistory, setQueryDevtoolsSchemaLoader, setQueryDevtoolsSettings, setQueryDevtoolsStatsFactory, setQueryDevtoolsTokenPayloadPatcher, setQueryDevtoolsTokenTtl, setupQueryDependencies, setupQueryExecuteState, setupQueryState, shouldAutoExecuteGqlQuery, shouldAutoExecuteQuery, shouldCacheQuery, shouldRetryRequest, silenceMissingWithArgsFeatureErrorUsedButWithArgsPresent, skipPaginationPageParamCalculator, smartDuplicateArrayItem, snapshotQueryDevtoolsHandle, sortQueryField, splitQueryConfig, stringArrayQueryField, stringifyQueryRouteParts, sumQueryDevtoolsStats, suppressNextQueryStackDevtools, switchQueryCollectionState, switchQueryState, symfonyQueryErrorParser, takeUntilResponse, toQuerySignal, toQuerySubject, tokensNotAvailableInsideAuthAndExec, tombstoneOf, transformArrayResponse, transformExecStateToQueryState, transformGql, transformMethod, transformPaginatedResponse, transformToBoolean, transformToBooleanArray, transformToDate, transformToDateArray, transformToNumber, transformToNumberArray, transformToSort, transformToSortQueryParam, transformToString, transformToStringArray, uncacheableRequestHasAllowCacheParam, uncacheableRequestHasCacheKeyParam, unwrapQuerySyncMessage, v2BuildQueryCacheKey, v2ExtractExpiresInSeconds, v2ShouldCacheQuery, v2ShouldRetryRequest, validateWithQuery, validateWithV2Query, withArgs, withArgsQueryFeatureMissingButRouteIsFunction, withAuthenticationQuery, withAutoRefresh, withAutoRefreshUsedInManualQuery, withAutoRefreshUsedOnUnsupportedHttpMethod, withBearerAuthMultiTabSync, withDefaultRetry, withErrorHandling, withEthleteApiErrors, withHtmlErrorParsing, withInactivityLogout, withLogging, withMultiTabSync, withPageResetOnError, withPersistentAuth, withPolling, withPollingUsedOnUnsupportedHttpMethod, withQueryDevtoolsOverridePersistence, withQueryPersistence, withRefreshQuery, withResponseUpdate, withSuccessHandling, withSymfonyErrors, withTokenExpirationWarning, withTokenRevocation, withTracking, wrapAsObservableSignal, wrapQuerySyncMessage, writeQueryDevtoolsStore };
 //# sourceMappingURL=ethlete-query.mjs.map