@ethlete/query 6.0.0-next.40 → 6.0.0-next.41

package/fesm2022/ethlete-query.mjs

@@ -1,7 +1,7 @@
 import * as i0 from '@angular/core';
 import { inject, Injector, effect, DestroyRef, InjectionToken, EnvironmentInjector, ElementRef, ErrorHandler, createEnvironmentInjector, untracked, signal, linkedSignal, computed, runInInjectionContext, isDevMode, PLATFORM_ID, resource, DOCUMENT, VERSION, makeEnvironmentProviders, assertInInjectionContext, provideEnvironmentInitializer, ChangeDetectorRef, ViewContainerRef, TemplateRef, Input, Directive, input, Pipe, ViewEncapsulation, Component, NgZone } from '@angular/core';
 import { UrlTree, Router, RedirectCommand, ActivatedRoute } from '@angular/router';
-import { Observable, defer, from, filter, Subject, Subscription, throwError, of, timer, switchMap, tap, retry, catchError, EMPTY, take, takeUntil, finalize, mergeMap, toArray, map, merge, takeWhile, firstValueFrom, race, concatMap, fromEvent, throttleTime, interval, startWith, pairwise, BehaviorSubject, combineLatest, ReplaySubject, shareReplay, skip, withLatestFrom, debounceTime } from 'rxjs';
+import { Observable, defer, from, filter, Subject, Subscription, throwError, of, timer, switchMap, tap, retry, catchError, EMPTY as EMPTY$1, take, takeUntil, finalize, mergeMap, toArray, map, merge, takeWhile, firstValueFrom, race, concatMap, fromEvent, throttleTime, interval, startWith, pairwise, BehaviorSubject, combineLatest, ReplaySubject, shareReplay, skip, withLatestFrom, debounceTime } from 'rxjs';
 import { defineStaticProvider, RuntimeError, clamp, randomId, defineRootProvider, isObject, injectUnsavedChangesCoordinator, injectRoute, getCookie, 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 { toObservable, takeUntilDestroyed, toSignal } from '@angular/core/rxjs-interop';
@@ -330,6 +330,36 @@ const consumeSuppressQueryStackDevtools = () => {
     suppressStackRegistration = false;
     return value;
 };
+let authProviderRegistrar = null;
+/**
+ * Installs the session vault's provider registrar. Called by `provideQueryDevtools()`; nothing else may
+ * call it.
+ * @internal
+ */
+const setQueryDevtoolsAuthProviderRegistrar = (fn) => {
+    authProviderRegistrar = fn;
+};
+/**
+ * Hands one auth provider to the devtools' session vault, which then keeps the live session's tokens in
+ * step with the stored one. A no-op without `provideQueryDevtools()`.
+ * @internal
+ */
+const registerQueryDevtoolsAuthProvider = (registration) => authProviderRegistrar?.(registration) ?? (() => undefined);
+let authSeedReader = null;
+/**
+ * Installs the tab-local session reader. Called by `provideQueryDevtools()`; nothing else may call it.
+ * @internal
+ */
+const setQueryDevtoolsAuthSeedReader = (fn) => {
+    authSeedReader = fn;
+};
+/**
+ * The session the panel put in this tab alone, or `null` for a tab on the shared one. Read once while a
+ * provider is built, before its features run: the tokens have to be in place before `withPersistentAuth`
+ * decides whether to spend its cookie.
+ * @internal
+ */
+const readQueryDevtoolsAuthSeed = (providerName) => authSeedReader?.(providerName) ?? null;
 
 /**
  * Whether a create-query options object came from the gql layer - only gql's `creatorInternals` carries
@@ -3102,12 +3132,12 @@ const createQueryBatch = (options) => {
     const runEntry = (entry) => defer(() => {
         if (cancelRequested) {
             record({ status: 'cancelled', index: entry.index, item: entry.item });
-            return EMPTY;
+            return EMPTY$1;
         }
         const args = mapArgs(entry.item, entry.index);
         if (args === null) {
             record({ status: 'skipped', index: entry.index, item: entry.item });
-            return EMPTY;
+            return EMPTY$1;
         }
         // The args reach the query through `execute()`, never `withArgs()`, so a function route has to
         // be told the missing feature is intentional or creating the query throws ET100.
@@ -4511,7 +4541,7 @@ const createSecureExecuteFactory = (options) => {
                 injector: options.deps.injector,
             }).pipe(switchMap((latestQuery) => {
                 if (!latestQuery)
-                    return EMPTY;
+                    return EMPTY$1;
                 const query = latestQuery.snapshot;
                 return toObservable(query.isAlive, { injector: options.deps.injector }).pipe(filter((isAlive) => !isAlive), filter(() => !!query.error() || !!query.response()), map(() => query));
             }), tap((query) => {
@@ -5276,6 +5306,16 @@ const createBearerAuthProviderImpl = (config) => {
         // leaves the tab locked against closing. See `injectUnsavedChangesCoordinator`.
         unsavedChanges.abandonAll('logout');
     };
+    const isTabLocalSession = signal(false, /* @ts-ignore */
+    ...(ngDevMode ? [{ debugName: "isTabLocalSession" }] : /* istanbul ignore next */ []));
+    // Before the features: `withPersistentAuth` starts its cookie auto-login during setup, and a tab that
+    // was handed a session of its own must already hold it by then - both so the auto-login stands down,
+    // and so the sync and the cookie see the flag before they decide whether to run at all.
+    const devtoolsSeed = isQueryDevtoolsEnabled() ? readQueryDevtoolsAuthSeed(config.name) : null;
+    if (devtoolsSeed) {
+        isTabLocalSession.set(true);
+        setTokens(devtoolsSeed.accessToken, devtoolsSeed.refreshToken);
+    }
     const isLeader = runEarlyFeatureSetup(config.features, {
         accessToken,
         refreshToken,
@@ -5285,6 +5325,7 @@ const createBearerAuthProviderImpl = (config) => {
         setTokens,
         logout,
         sessionEndCause: sessionEndCause.asReadonly(),
+        isTabLocalSession: isTabLocalSession.asReadonly(),
     });
     const querySetupContext = {
         name: config.name,
@@ -5314,6 +5355,7 @@ const createBearerAuthProviderImpl = (config) => {
         destroyRef,
         setTokens,
         isLeader: isLeader.isLeaderFn,
+        isTabLocalSession: isTabLocalSession.asReadonly(),
         leaderElection: isLeader.leaderElectionContext,
         sessionAdoption: isLeader.sessionAdoption,
         activityCoordination: isLeader.activityCoordination,
@@ -5373,6 +5415,13 @@ const createBearerAuthProviderImpl = (config) => {
             },
         });
         destroyRef.onDestroy(unregister);
+        destroyRef.onDestroy(registerQueryDevtoolsAuthProvider({
+            name: config.name,
+            handle: provider,
+            client: queryClient,
+            isTabLocalSession,
+            injector,
+        }));
     }
     return provider;
 };
@@ -5706,7 +5755,7 @@ const withRefreshQuery = (key, config) => {
             const attempt = executeRefresh('scheduled');
             const retryInMs = retryScheduledIn(attempt);
             if (retryInMs === null)
-                return EMPTY;
+                return EMPTY$1;
             // Waiting on another tab does not spend the budget. Both outcomes come back at a deadline
             // rather than on a fixed interval, and both end the moment a token pair arrives, because a
             // new token restarts the schedule. Spending the budget on them leaves a follower whose
@@ -5714,7 +5763,7 @@ const withRefreshQuery = (key, config) => {
             // from: the tab then holds a dead token and cannot even ask for a new one.
             if (attempt === 'notLeader' || attempt === 'delegated')
                 return scheduledRefresh(retryInMs, attemptsLeft);
-            return attemptsLeft <= 0 ? EMPTY : scheduledRefresh(retryInMs, attemptsLeft - 1);
+            return attemptsLeft <= 0 ? EMPTY$1 : scheduledRefresh(retryInMs, attemptsLeft - 1);
         }));
         // A backgrounded tab's `timer()` does not fire on time - the browser throttles it, and a frozen
         // page stops running it altogether while keeping the Web Lock that makes it the leader. So the
@@ -5742,7 +5791,7 @@ const withRefreshQuery = (key, config) => {
         }, /* @ts-ignore */
         ...(ngDevMode ? [{ debugName: "nextScheduledRefresh" }] : /* istanbul ignore next */ []));
         toObservable(nextScheduledRefresh)
-            .pipe(switchMap(({ dueInMs }) => (dueInMs === null ? EMPTY : scheduledRefresh(dueInMs, maxRescheduleAttempts))), takeUntilDestroyed())
+            .pipe(switchMap(({ dueInMs }) => (dueInMs === null ? EMPTY$1 : scheduledRefresh(dueInMs, maxRescheduleAttempts))), takeUntilDestroyed())
             .subscribe();
         context.refreshCoordination?.requests$.pipe(takeUntilDestroyed()).subscribe(() => executeRefresh('unauthorized'));
         context.refreshCoordination?.starts$.pipe(takeUntilDestroyed()).subscribe(() => {
@@ -6543,7 +6592,10 @@ const withBearerAuthMultiTabSync = (config = {}) => {
             type: BearerAuthFeatureType.MULTI_TAB_SYNC,
             instance: state.instance,
             devtools: () => [
-                { label: 'channel', value: state.channelName },
+                {
+                    label: 'channel',
+                    value: context.isTabLocalSession() ? "off (session is this tab's own)" : state.channelName,
+                },
                 { label: 'tokens', value: config.syncTokens === false ? 'tab local' : 'synced' },
                 { label: 'logout', value: config.syncLogout === false ? 'tab local' : 'synced' },
                 {
@@ -6557,6 +6609,13 @@ const withBearerAuthMultiTabSync = (config = {}) => {
     // regular feature setup runs - so this half has to happen earlier than `setup`.
     const earlySetup = (context) => {
         const channelName = config.channelName ?? defaultSyncChannelName(context.name);
+        // A tab the devtools handed a session of its own is not part of this app's shared session: it must
+        // not push its tokens at its siblings, adopt theirs, or log them out - and it refreshes for itself,
+        // because a leader that speaks for a session it is not on would refresh the wrong one.
+        if (context.isTabLocalSession()) {
+            pendingSetups.push({ instance: SINGLE_TAB, channelName });
+            return {};
+        }
         // Filled in below once the election exists. Until then this tab answers as its own leader, which
         // is what it is: the sync is set up first because the auth queries read `isLeader` while being
         // wired, and a `state-request` cannot arrive before this function returns anyway.
@@ -6643,6 +6702,11 @@ const createPersistentAuthFeature = (config, context) => {
     effect(() => {
         const token = refreshToken();
         const rememberMe = rememberMeSignal();
+        // The cookie is the whole browser's, so a tab holding a session of its own would hand its user to
+        // every other tab on the next load. Such a tab is restored from `sessionStorage` by the devtools
+        // instead - see `setQueryDevtoolsAuthTabLocal`.
+        if (context.isTabLocalSession())
+            return;
         // 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
@@ -6654,7 +6718,7 @@ const createPersistentAuthFeature = (config, context) => {
     });
     effect(() => {
         const endCause = context.sessionEndCause();
-        if (endCause)
+        if (endCause && !context.isTabLocalSession())
             removeCookie();
     });
     effect(() => {
@@ -6666,7 +6730,7 @@ const createPersistentAuthFeature = (config, context) => {
         const wasRejected = state.state === 'error' &&
             (state.type === 'tokenRefresh' || state.type === 'autoLogin') &&
             (state.error.code === 401 || state.error.code === 403);
-        if (wasRejected)
+        if (wasRejected && !context.isTabLocalSession())
             removeCookie();
     });
     const exchangeCookie = () => {
@@ -7034,6 +7098,437 @@ const queryDevtoolsAbout = () => ({
     app,
 });
 
+const HOST_ID = 'et-query-devtools-pill';
+/** What the picker writes for "let the application decide", which is the key removed. */
+const DEFAULT_VALUE = '';
+/** Prefixes a production env's name, so the open dropdown says which option is the real backend. */
+const PRODUCTION_MARK = '⚠ ';
+const STYLE = `
+  :host {
+    position: fixed;
+    display: flex;
+    flex-direction: column;
+    align-items: flex-end;
+    gap: 8px;
+    inset-block-end: 64px;
+    inset-inline-end: 16px;
+    font-family: ui-monospace, SFMono-Regular, Menlo, Consolas, monospace;
+    font-size: 13px;
+    /* One below the panel and the toggle button (2147483010), so an open panel covers the pill - the
+       panel offers the same picker on its Settings tab. Keep the three in step. */
+    z-index: 2147483009;
+  }
+
+  label {
+    --_accent: var(--et-theme-color-primary-solid, #60a5fa);
+
+    display: inline-flex;
+    align-items: center;
+    gap: 8px;
+    padding: 8px 10px 8px 12px;
+    border-radius: 999px;
+    background: linear-gradient(135deg, #1f1f23, #2a2a30);
+    color: #fafafa;
+    box-shadow:
+      0 6px 20px rgb(0 0 0 / 0.35),
+      inset 0 0 0 1px rgb(255 255 255 / 0.08);
+  }
+
+  .name {
+    color: #a1a1aa;
+    font-size: 11px;
+    font-weight: 600;
+    letter-spacing: 0.04em;
+    line-height: 1;
+    text-transform: uppercase;
+  }
+
+  select {
+    max-inline-size: 220px;
+    padding: 3px 6px;
+    border: none;
+    border-radius: 5px;
+    background: rgb(255 255 255 / 0.07);
+    box-shadow: inset 0 0 0 1px rgb(255 255 255 / 0.12);
+    color: #fafafa;
+    font: inherit;
+    font-size: 12px;
+    font-weight: 600;
+    line-height: 1;
+    cursor: pointer;
+  }
+
+  select:hover {
+    box-shadow: inset 0 0 0 1px var(--_accent);
+  }
+
+  /* The popup is painted by the browser, which does not inherit the pill's dark background. */
+  option {
+    background: #1f1f23;
+    color: #fafafa;
+  }
+
+  label[data-production] {
+    background: linear-gradient(135deg, #7f1d1d, #b91c1c);
+    color: #fff;
+    box-shadow:
+      0 6px 22px rgb(239 68 68 / 0.5),
+      inset 0 0 0 1px rgb(254 202 202 / 0.7);
+  }
+
+  label[data-production] .name {
+    color: #fee2e2;
+  }
+
+  label[data-production] .mark {
+    font-size: 15px;
+    line-height: 1;
+  }
+
+  label[data-production] select {
+    background: rgb(0 0 0 / 0.35);
+    box-shadow: inset 0 0 0 1px rgb(254 202 202 / 0.6);
+    text-transform: uppercase;
+  }
+
+  label[data-production] option {
+    background: #450a0a;
+  }
+
+  label[data-auth] {
+    --_accent: var(--et-theme-color-success-solid, #34d399);
+  }
+
+  button {
+    padding: 3px 7px;
+    border: none;
+    border-radius: 5px;
+    background: rgb(255 255 255 / 0.07);
+    box-shadow: inset 0 0 0 1px rgb(255 255 255 / 0.12);
+    color: #fafafa;
+    font: inherit;
+    font-size: 11px;
+    font-weight: 600;
+    line-height: 1.4;
+    cursor: pointer;
+  }
+
+  button:hover {
+    box-shadow: inset 0 0 0 1px var(--_accent);
+  }
+
+  button[data-on] {
+    background: rgb(52 211 153 / 0.18);
+    box-shadow: inset 0 0 0 1px rgb(52 211 153 / 0.7);
+  }
+
+  /* The whole viewport, so the warning is on screen wherever the reader is looking. Outside the pill's
+     flex flow: a fixed child of a fixed host still lays out against the viewport. */
+  .frame {
+    position: fixed;
+    inset: 0;
+    box-shadow:
+      inset 0 0 0 3px rgb(239 68 68 / 0.85),
+      inset 0 0 22px rgb(239 68 68 / 0.25);
+    opacity: 0.85;
+    pointer-events: none;
+  }
+
+  @media (prefers-reduced-motion: no-preference) {
+    label[data-production] {
+      animation: et-qd-api-env-pulse 1.6s ease-in-out infinite;
+    }
+
+    .frame {
+      animation: et-qd-api-env-frame 1.6s ease-in-out infinite;
+    }
+  }
+
+  @keyframes et-qd-api-env-pulse {
+    0%,
+    100% {
+      box-shadow:
+        0 6px 20px rgb(239 68 68 / 0.35),
+        inset 0 0 0 1px rgb(254 202 202 / 0.45);
+    }
+
+    50% {
+      box-shadow:
+        0 6px 30px rgb(239 68 68 / 0.85),
+        inset 0 0 0 2px rgb(254 226 226 / 0.95);
+    }
+  }
+
+  @keyframes et-qd-api-env-frame {
+    0%,
+    100% {
+      opacity: 0.35;
+    }
+
+    50% {
+      opacity: 1;
+    }
+  }
+`;
+/** The env a stored value lands on, which is the switch's own fallback while nothing is stored. */
+const resolvedEnvOf = (apiSwitch, stored) => apiSwitch.envs.find((env) => env.id === (stored || apiSwitch.fallback));
+const nameOf = (env) => `${env.production ? PRODUCTION_MARK : ''}${env.label ?? env.id}`;
+const optionsOf = (apiSwitch, stored) => {
+    const fallback = apiSwitch.envs.find((env) => env.id === apiSwitch.fallback);
+    const options = [
+        {
+            value: DEFAULT_VALUE,
+            label: fallback ? `default (${nameOf(fallback)})` : 'default',
+            title: `Removes ${apiSwitch.storageKey}, so the app picks for itself`,
+        },
+    ];
+    for (const env of apiSwitch.envs) {
+        options.push({ value: env.id, label: nameOf(env), title: env.url ?? env.id });
+    }
+    // A URL typed into the Settings tab is a value no env carries, and a select cannot show one.
+    if (stored !== DEFAULT_VALUE && !apiSwitch.envs.some((env) => env.id === stored)) {
+        options.push({ value: stored, label: stored, title: `Typed in: ${stored}` });
+    }
+    return options;
+};
+const buildSwitch = (doc, apiSwitch, stored, pick) => {
+    const production = resolvedEnvOf(apiSwitch, stored)?.production === true;
+    const label = doc.createElement('label');
+    label.title = production
+        ? `${apiSwitch.name} points at production. The data is real. Picking reloads the page.`
+        : `${apiSwitch.name} — picking reloads the page`;
+    if (production) {
+        label.setAttribute('data-production', '');
+        const mark = doc.createElement('span');
+        mark.className = 'mark';
+        mark.textContent = '⚠';
+        mark.setAttribute('aria-hidden', 'true');
+        label.append(mark);
+    }
+    const name = doc.createElement('span');
+    name.className = 'name';
+    name.textContent = production ? `${apiSwitch.name} · live` : apiSwitch.name;
+    const select = doc.createElement('select');
+    select.setAttribute('aria-label', apiSwitch.name);
+    for (const option of optionsOf(apiSwitch, stored)) {
+        const element = doc.createElement('option');
+        element.value = option.value;
+        element.textContent = option.label;
+        element.title = option.title;
+        element.selected = option.value === stored;
+        select.append(element);
+    }
+    select.addEventListener('change', () => pick(apiSwitch.storageKey, select.value === DEFAULT_VALUE ? null : select.value));
+    label.append(name, select);
+    return label;
+};
+let envState = null;
+let authState = null;
+const buildAuthRow = (doc, row) => {
+    const label = doc.createElement('label');
+    label.setAttribute('data-auth', '');
+    label.title = row.tabLocal
+        ? `${row.name} holds this tab's own session. The other tabs are on theirs.`
+        : `${row.name} - the session every tab of this app shares`;
+    const name = doc.createElement('span');
+    name.className = 'name';
+    name.textContent = row.tabLocal ? `${row.name} · this tab` : row.name;
+    const select = doc.createElement('select');
+    select.setAttribute('aria-label', `${row.name} session`);
+    const current = doc.createElement('option');
+    current.value = '';
+    current.textContent = row.current;
+    current.selected = !row.options.some((option) => option.selected);
+    select.append(current);
+    for (const option of row.options) {
+        const element = doc.createElement('option');
+        element.value = option.value;
+        element.textContent = option.label;
+        element.title = option.title;
+        element.selected = option.selected;
+        element.disabled = option.disabled;
+        select.append(element);
+    }
+    select.addEventListener('change', () => {
+        if (select.value)
+            row.pick(select.value);
+    });
+    const isolate = doc.createElement('button');
+    isolate.type = 'button';
+    isolate.textContent = row.tabLocal ? 'rejoin' : 'own tab';
+    isolate.title = row.tabLocal
+        ? 'Hands this tab back to the session every other tab shares. Reloads the page.'
+        : 'Keeps this session in this tab alone, so another tab can be somebody else. Reloads the page.';
+    if (row.tabLocal)
+        isolate.setAttribute('data-on', '');
+    isolate.addEventListener('click', row.toggleTabLocal);
+    label.append(name, select, isolate);
+    return label;
+};
+const render = (doc) => {
+    doc.getElementById(HOST_ID)?.remove();
+    const switches = envState?.switches ?? [];
+    const rows = authState?.rows ?? [];
+    if (!switches.length && !rows.length)
+        return;
+    const host = doc.createElement('div');
+    host.id = HOST_ID;
+    // Shadow DOM is intentional, for the same reason the toggle button uses it: this paints over the
+    // host application's page and must be as isolated from its global CSS (resets, Tailwind) as possible.
+    const shadow = host.attachShadow({ mode: 'open' });
+    const style = doc.createElement('style');
+    style.textContent = STYLE;
+    shadow.append(style);
+    let production = false;
+    for (const row of rows)
+        shadow.append(buildAuthRow(doc, row));
+    for (const apiSwitch of switches) {
+        const stored = envState?.read(apiSwitch.storageKey) ?? DEFAULT_VALUE;
+        production ||= resolvedEnvOf(apiSwitch, stored)?.production === true;
+        shadow.append(buildSwitch(doc, apiSwitch, stored, (storageKey, value) => envState?.pick(storageKey, value)));
+    }
+    if (production) {
+        const frame = doc.createElement('div');
+        frame.className = 'frame';
+        frame.setAttribute('aria-hidden', 'true');
+        shadow.append(frame);
+    }
+    doc.body.append(host);
+};
+/**
+ * Paints the devtools' pills straight onto `document.body`, outside any Angular component tree.
+ *
+ * They cannot be components: an application whose boot is stuck on the backend it was just pointed at -
+ * a blocking initial navigation waiting out an auth call that never answers - renders no component at
+ * all, and that is exactly when somebody needs to pick a different backend or a different user. Mounted
+ * from `setQueryDevtoolsApiEnvs()`, which runs while `provideQueryDevtools()` is being called, the env
+ * part of this is on the page before `bootstrapApplication` starts.
+ */
+const renderPills = () => {
+    const doc = globalThis.document;
+    if (!doc)
+        return;
+    if (doc.body)
+        render(doc);
+    else
+        doc.addEventListener('DOMContentLoaded', () => render(doc), { once: true });
+};
+/**
+ * Declares the API env part of the pill. Called by `setQueryDevtoolsApiEnvs()`.
+ * @internal
+ */
+const setQueryDevtoolsEnvPills = (state) => {
+    envState = state.switches.length ? state : null;
+    renderPills();
+};
+/**
+ * Declares the session part of the pill, which is repainted on every switch, login and logout.
+ * @internal
+ */
+const setQueryDevtoolsAuthPill = (state) => {
+    authState = state.rows.length ? state : null;
+    renderPills();
+};
+
+const switches = /* @__PURE__ */ signal([], /* @ts-ignore */
+...(ngDevMode ? [{ debugName: "switches" }] : /* istanbul ignore next */ []));
+const values = /* @__PURE__ */ signal({}, /* @ts-ignore */
+...(ngDevMode ? [{ debugName: "values" }] : /* istanbul ignore next */ []));
+/**
+ * The API env switches the application declared, or an empty list. Both the floating toggle and the
+ * panel's Settings tab render nothing at all until an application declares one.
+ *
+ * Part of the devtools contract. **Not part of the general public contract.**
+ */
+const queryDevtoolsApiEnvs = /* @__PURE__ */ switches.asReadonly();
+/**
+ * What each switch's key holds now, keyed by that key. `null` for a key nothing has written, which is
+ * the switch's own fallback.
+ *
+ * Part of the devtools contract. **Not part of the general public contract.**
+ */
+const queryDevtoolsApiEnvValues = /* @__PURE__ */ values.asReadonly();
+const read$1 = (key) => {
+    try {
+        return window.localStorage.getItem(key);
+    }
+    catch {
+        return null;
+    }
+};
+/**
+ * Declares the switches and reads what each key holds. Called by `provideQueryDevtools()` and by
+ * nothing else.
+ * @internal
+ */
+const setQueryDevtoolsApiEnvs = (list) => {
+    switches.set(list ?? []);
+    values.set(Object.fromEntries((list ?? []).map((entry) => [entry.storageKey, read$1(entry.storageKey)])));
+    setQueryDevtoolsEnvPills({ switches: list ?? [], read: read$1, pick: pickAndReload });
+};
+/**
+ * Writes one switch's key, or removes it when `value` is `null` so the application falls back. The
+ * application reads the key before Angular boots, so this takes effect on the next page load only -
+ * callers reload.
+ *
+ * The value is written as the plain string the application reads. Do not route it through
+ * `writeQueryDevtoolsStore`: that JSON-encodes, and the quotes would reach the application.
+ *
+ * Part of the devtools contract. **Not part of the general public contract.**
+ */
+const setQueryDevtoolsApiEnv = (storageKey, value) => {
+    try {
+        if (value === null)
+            window.localStorage.removeItem(storageKey);
+        else
+            window.localStorage.setItem(storageKey, value);
+    }
+    catch {
+        // ignore (private mode / disabled storage / quota)
+    }
+    values.update((current) => ({ ...current, [storageKey]: read$1(storageKey) }));
+};
+/** The env in force for one switch, which is its own fallback while nothing is stored. */
+const resolvedIdOf = (entry) => values()[entry.storageKey] ?? entry.fallback ?? '';
+/**
+ * Which backends the application is pointed at right now, as one string. Every declared switch is in it,
+ * so a session captured against staging is never offered on production.
+ *
+ * Part of the devtools contract. **Not part of the general public contract.**
+ */
+const queryDevtoolsApiEnvScope = () => {
+    const list = switches();
+    if (!list.length)
+        return 'default';
+    return list
+        .map((entry) => `${entry.storageKey}=${resolvedIdOf(entry)}`)
+        .sort()
+        .join('&');
+};
+/**
+ * The env id in force per switch, which is what an account's declared `envs` is matched against.
+ *
+ * Part of the devtools contract. **Not part of the general public contract.**
+ */
+const queryDevtoolsApiEnvIds = () => switches()
+    .map(resolvedIdOf)
+    .filter((id) => id !== '');
+/**
+ * Whether any switch's pick is an env the application declared as `production`. Everything that would
+ * keep a real user's tokens on this machine refuses while this reads `true`.
+ *
+ * Part of the devtools contract. **Not part of the general public contract.**
+ */
+const queryDevtoolsApiEnvIsProduction = () => switches().some((entry) => entry.envs.find((env) => env.id === resolvedIdOf(entry))?.production === true);
+/**
+ * What the floating pill does on a pick. The application reads the key before Angular boots, so a
+ * reload is the only way to apply one.
+ */
+const pickAndReload = (storageKey, value) => {
+    setQueryDevtoolsApiEnv(storageKey, value);
+    window.location.reload();
+};
+
 const DEFAULTS = {
     viewState: 'session',
     pins: 'local',
@@ -7041,9 +7536,11 @@ const DEFAULTS = {
     mocks: 'local',
     armedMocks: 'none',
     armedFaults: 'none',
+    authSessions: 'local',
     maxEvents: 100,
     maxDroppedCacheEntries: 20,
     responseHistory: null,
+    reloadOnAuthSwitch: true,
 };
 /**
  * `localStorage`, whatever the scopes below say - a scope of `none` still has to be remembered, or the
@@ -7138,16 +7635,18 @@ const asOptionalCount = (value, limits) => {
     return Number.isFinite(count) ? Math.min(Math.max(count, limits.min), limits.max) : null;
 };
 /** Both a hand-edited store and a number typed into the panel come through here. */
-const sanitize = (value) => ({
+const sanitize$1 = (value) => ({
     viewState: asScope(value?.viewState, DEFAULTS.viewState),
     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),
+    authSessions: asScope(value?.authSessions, DEFAULTS.authSessions),
     maxEvents: asCount(value?.maxEvents, LIMITS.maxEvents, DEFAULTS.maxEvents),
     maxDroppedCacheEntries: asCount(value?.maxDroppedCacheEntries, LIMITS.maxDroppedCacheEntries, DEFAULTS.maxDroppedCacheEntries),
     responseHistory: asOptionalCount(value?.responseHistory, LIMITS.responseHistory),
+    reloadOnAuthSwitch: typeof value?.reloadOnAuthSwitch === 'boolean' ? value.reloadOnAuthSwitch : DEFAULTS.reloadOnAuthSwitch,
 });
 /**
  * Reads the stored settings. Called by `provideQueryDevtools()` **before** the override store is read
@@ -7156,7 +7655,7 @@ const sanitize = (value) => ({
  * @internal
  */
 const initQueryDevtoolsSettings = () => {
-    settings.set(sanitize(readQueryDevtoolsStore('local', SETTINGS_KEY)));
+    settings.set(sanitize$1(readQueryDevtoolsStore('local', SETTINGS_KEY)));
 };
 /**
  * Changes part of the devtools configuration and stores it. Values outside the range a field allows are
@@ -7168,11 +7667,503 @@ const initQueryDevtoolsSettings = () => {
  * Part of the devtools contract. **Not part of the general public contract.**
  */
 const setQueryDevtoolsSettings = (patch) => {
-    const next = sanitize({ ...settings(), ...patch });
+    const next = sanitize$1({ ...settings(), ...patch });
     settings.set(next);
     writeQueryDevtoolsStore('local', SETTINGS_KEY, next);
 };
 
+const STORE_KEY = 'ethlete:query:devtools:auth:v1';
+/**
+ * `sessionStorage`: which stored session a provider's live tokens belong to is the one part of this that
+ * is the tab's own. Two tabs holding two users would otherwise overwrite each other's answer.
+ */
+const ACTIVE_KEY = 'ethlete:query:devtools:auth-active:v1';
+/** `sessionStorage`, always: a session that belongs to one tab cannot be kept where every tab reads it. */
+const SEED_KEY = 'ethlete:query:devtools:auth-tab-session:v1';
+const DEFAULT_FIELDS = [
+    { name: 'email', type: 'email' },
+    { name: 'password', type: 'password' },
+];
+const EMPTY = { sessions: [], credentials: {}, accounts: [] };
+const store = /* @__PURE__ */ signal(EMPTY, /* @ts-ignore */
+...(ngDevMode ? [{ debugName: "store" }] : /* istanbul ignore next */ []));
+const active = /* @__PURE__ */ signal({}, /* @ts-ignore */
+...(ngDevMode ? [{ debugName: "active" }] : /* istanbul ignore next */ []));
+const declared = /* @__PURE__ */ signal([], /* @ts-ignore */
+...(ngDevMode ? [{ debugName: "declared" }] : /* istanbul ignore next */ []));
+const providers = /* @__PURE__ */ signal([], /* @ts-ignore */
+...(ngDevMode ? [{ debugName: "providers" }] : /* istanbul ignore next */ []));
+const tabLocal = /* @__PURE__ */ signal({}, /* @ts-ignore */
+...(ngDevMode ? [{ debugName: "tabLocal" }] : /* istanbul ignore next */ []));
+const live = /* @__PURE__ */ new Map();
+let idCounter = 0;
+const nextId = (prefix) => `${prefix}-${Date.now().toString(36)}-${++idCounter}`;
+/**
+ * Every session the vault holds, whatever env or provider it belongs to. Read
+ * {@link queryDevtoolsAuthSessionsFor} instead where a provider is in hand.
+ *
+ * Part of the devtools contract. **Not part of the general public contract.**
+ */
+const queryDevtoolsAuthSessions = /* @__PURE__ */ computed(() => store().sessions, /* @ts-ignore */
+...(ngDevMode ? [{ debugName: "queryDevtoolsAuthSessions" }] : /* istanbul ignore next */ []));
+/**
+ * Which stored session each provider's live tokens belong to, keyed by provider name. This tab's own
+ * answer: another tab on another user has its own.
+ *
+ * Part of the devtools contract. **Not part of the general public contract.**
+ */
+const queryDevtoolsAuthActive = /* @__PURE__ */ active.asReadonly();
+/**
+ * Which providers hold a session of their own rather than the one every tab shares, keyed by provider
+ * name.
+ *
+ * Part of the devtools contract. **Not part of the general public contract.**
+ */
+const queryDevtoolsAuthTabLocal = /* @__PURE__ */ tabLocal.asReadonly();
+/** The auth providers the vault has been handed, in registration order. @internal */
+const queryDevtoolsAuthProviders = /* @__PURE__ */ providers.asReadonly();
+const scopeOf = () => queryDevtoolsApiEnvScope();
+const persist = () => {
+    const scope = queryDevtoolsSettings().authSessions;
+    writeQueryDevtoolsStore(scope, STORE_KEY, store());
+    writeQueryDevtoolsStore(scope === 'none' ? 'none' : 'session', ACTIVE_KEY, active());
+};
+const setActive = (provider, sessionId) => {
+    active.update((current) => ({ ...current, [provider]: sessionId }));
+};
+const readSeeds = () => readQueryDevtoolsStore('session', SEED_KEY) ?? {};
+const writeSeeds = (seeds) => {
+    if (Object.keys(seeds).length)
+        writeQueryDevtoolsStore('session', SEED_KEY, seeds);
+    else
+        queryDevtoolsStorage('session')?.removeItem(SEED_KEY);
+};
+/** The claims a session is named and recognised by, or nothing for a token that is not a JWT. */
+const identityOf = (accessToken) => {
+    try {
+        const payload = decryptBearer(accessToken);
+        if (!payload)
+            return { label: null, subject: null, expiresAt: null };
+        const named = ['name', 'preferred_username', 'username', 'email', 'sub'].find((claim) => typeof payload[claim] === 'string' && payload[claim] !== '');
+        return {
+            label: named ? String(payload[named]) : null,
+            subject: typeof payload['sub'] === 'string' ? payload['sub'] : null,
+            expiresAt: typeof payload['exp'] === 'number' ? payload['exp'] : null,
+        };
+    }
+    catch {
+        return { label: null, subject: null, expiresAt: null };
+    }
+};
+const sanitizeSession = (value) => {
+    if (typeof value !== 'object' || value === null)
+        return null;
+    const session = value;
+    if (typeof session.id !== 'string' ||
+        typeof session.provider !== 'string' ||
+        typeof session.accessToken !== 'string' ||
+        typeof session.refreshToken !== 'string') {
+        return null;
+    }
+    return {
+        id: session.id,
+        provider: session.provider,
+        label: typeof session.label === 'string' ? session.label : session.id,
+        scope: typeof session.scope === 'string' ? session.scope : 'default',
+        accessToken: session.accessToken,
+        refreshToken: session.refreshToken,
+        subject: typeof session.subject === 'string' ? session.subject : null,
+        expiresAt: typeof session.expiresAt === 'number' ? session.expiresAt : null,
+        savedAt: typeof session.savedAt === 'number' ? session.savedAt : 0,
+    };
+};
+const sanitize = (value) => ({
+    sessions: Array.isArray(value?.sessions)
+        ? value.sessions.map(sanitizeSession).filter((session) => session !== null)
+        : [],
+    credentials: typeof value?.credentials === 'object' && value.credentials !== null ? value.credentials : {},
+    accounts: Array.isArray(value?.accounts) ? value.accounts : [],
+});
+/**
+ * The vault is one key every tab writes, so a tab holding a stale copy of it would drop whatever another
+ * tab stored since. The event fires in the other tabs only, which is exactly the ones that need it.
+ */
+const listenForOtherTabs = () => {
+    if (typeof window === 'undefined' || listening)
+        return;
+    listening = true;
+    window.addEventListener('storage', (event) => {
+        if (event.key !== STORE_KEY)
+            return;
+        store.set(sanitize(event.newValue ? JSON.parse(event.newValue) : null));
+        syncPill();
+    });
+};
+let listening = false;
+/**
+ * Declares the accounts the panel may log in as, and reads back what a previous page stored. Called by
+ * `provideQueryDevtools()` and by nothing else.
+ * @internal
+ */
+const initQueryDevtoolsAuthSessions = (accounts) => {
+    const scope = queryDevtoolsSettings().authSessions;
+    declared.set(accounts ?? []);
+    store.set(sanitize(readQueryDevtoolsStore(scope, STORE_KEY)));
+    active.set(readQueryDevtoolsStore(scope === 'none' ? 'none' : 'session', ACTIVE_KEY) ?? {});
+    listenForOtherTabs();
+    syncPill();
+};
+/**
+ * The session the panel put in this tab alone, or `null`. A seed from another backend is dropped rather
+ * than applied: its tokens were issued by an API this page is not pointed at any more.
+ * @internal
+ */
+const readQueryDevtoolsAuthSeedFor = (providerName) => {
+    const seeds = readSeeds();
+    const seed = seeds[providerName];
+    if (!seed)
+        return null;
+    if (seed.scope !== scopeOf()) {
+        const { [providerName]: _dropped, ...rest } = seeds;
+        writeSeeds(rest);
+        return null;
+    }
+    tabLocal.update((current) => ({ ...current, [providerName]: true }));
+    setActive(providerName, seed.sessionId);
+    return { accessToken: seed.accessToken, refreshToken: seed.refreshToken };
+};
+/**
+ * Keeps the stored session in step with the live one: every rotation of a refresh token is written back,
+ * so switching away and back later does not present a token the server has already spent.
+ * @internal
+ */
+const trackQueryDevtoolsAuthProvider = (registration) => {
+    const { name, handle, injector, isTabLocalSession } = registration;
+    live.set(name, registration);
+    providers.update((current) => (current.includes(name) ? current : [...current, name]));
+    isTabLocalSession.set(tabLocal()[name] === true);
+    const stop = effect(() => {
+        const accessToken = handle.accessToken();
+        const refreshToken = handle.refreshToken();
+        untracked(() => {
+            if (accessToken && refreshToken)
+                remember({ provider: name, accessToken, refreshToken });
+            else
+                forgetActive(name);
+        });
+    }, { ...(ngDevMode ? { debugName: "stop" } : /* istanbul ignore next */ {}), injector });
+    syncPill();
+    return () => {
+        stop.destroy();
+        live.delete(name);
+        providers.update((current) => current.filter((entry) => entry !== name));
+        syncPill();
+    };
+};
+/**
+ * Writes a live token pair into the vault. A pair whose subject is already stored updates that session
+ * rather than adding another, which is what lets a plain login in the application fill the picker.
+ */
+const remember = (options) => {
+    const { provider, accessToken, refreshToken } = options;
+    // Nobody's real credentials or tokens are kept on this machine. See the Auth tab's own warning.
+    if (queryDevtoolsApiEnvIsProduction())
+        return;
+    const scope = scopeOf();
+    const identity = identityOf(accessToken);
+    const activeId = active()[provider] ?? null;
+    const activeSession = store().sessions.find((session) => session.id === activeId);
+    const bySubject = identity.subject
+        ? store().sessions.find((session) => session.provider === provider && session.scope === scope && session.subject === identity.subject)
+        : undefined;
+    // The session on record is only a rotation of the live one while both name the same user. Logging in as
+    // somebody else without logging out first would otherwise overwrite the tokens of the user this tab is
+    // switching away from - which is the one pair the vault exists to keep.
+    const isRotation = !activeSession || !identity.subject || !activeSession.subject || activeSession.subject === identity.subject;
+    const target = isRotation ? (activeSession ?? bySubject) : bySubject;
+    const session = {
+        id: target?.id ?? nextId('session'),
+        provider,
+        label: target?.label ?? identity.label ?? 'session',
+        scope,
+        accessToken,
+        refreshToken,
+        subject: identity.subject,
+        expiresAt: identity.expiresAt,
+        savedAt: Date.now(),
+    };
+    store.update((current) => ({
+        ...current,
+        sessions: target
+            ? current.sessions.map((entry) => (entry.id === target.id ? session : entry))
+            : [...current.sessions, session],
+    }));
+    setActive(provider, session.id);
+    if (tabLocal()[provider]) {
+        writeSeeds({ ...readSeeds(), [provider]: { sessionId: session.id, scope, accessToken, refreshToken } });
+    }
+    persist();
+    syncPill();
+};
+/** Lets go of the session a provider was on, without forgetting what the vault holds of it. */
+const forgetActive = (provider) => {
+    if (!active()[provider])
+        return;
+    setActive(provider, null);
+    persist();
+    syncPill();
+};
+/** The sessions offered for one provider, which are the ones this backend issued. */
+const queryDevtoolsAuthSessionsFor = (provider) => {
+    const scope = scopeOf();
+    return store().sessions.filter((session) => session.provider === provider && session.scope === scope);
+};
+/** How many sessions this provider has under a different backend, which is what a switch left behind. */
+const queryDevtoolsAuthOtherScopeCount = (provider) => {
+    const scope = scopeOf();
+    return store().sessions.filter((session) => session.provider === provider && session.scope !== scope).length;
+};
+const declaredIdOf = (account) => `declared:${account.provider}|${account.label}`;
+const viewOf = (options) => {
+    const stored = store().credentials[options.id] ?? {};
+    const values = Object.fromEntries(options.fields.map((field) => [field.name, stored[field.name] ?? field.default ?? '']));
+    return {
+        ...options,
+        values,
+        ready: options.fields.every((field) => values[field.name] !== ''),
+    };
+};
+/**
+ * The accounts on offer for one provider: the ones the application declared for the env in force, plus
+ * the ones added in the panel. Empty while a production env is the pick - nothing keeps a real user's
+ * password on a developer's machine.
+ */
+const queryDevtoolsAuthAccountsFor = (provider) => {
+    if (queryDevtoolsApiEnvIsProduction())
+        return [];
+    const scope = scopeOf();
+    const envIds = queryDevtoolsApiEnvIds();
+    const fromApp = declared()
+        .filter((account) => account.provider === provider)
+        .filter((account) => !account.envs?.length || account.envs.some((id) => envIds.includes(id)))
+        .map((account) => viewOf({
+        id: declaredIdOf(account),
+        provider,
+        label: account.label,
+        loginQuery: account.loginQuery,
+        fields: account.fields ?? DEFAULT_FIELDS,
+        declared: true,
+        buildArgs: account.buildArgs,
+        note: account.note,
+    }));
+    const fromPanel = store()
+        .accounts.filter((account) => account.provider === provider && account.scope === scope)
+        .map((account) => viewOf({
+        id: `local:${account.id}`,
+        provider,
+        label: account.label,
+        loginQuery: account.loginQuery,
+        fields: DEFAULT_FIELDS,
+        declared: false,
+    }));
+    return [...fromApp, ...fromPanel];
+};
+/** Keeps one account's credentials on this machine. Refused while a production env is the pick. */
+const setQueryDevtoolsAuthCredentials = (options) => {
+    if (queryDevtoolsApiEnvIsProduction())
+        return;
+    store.update((current) => ({
+        ...current,
+        credentials: { ...current.credentials, [options.accountId]: options.values },
+    }));
+    persist();
+    syncPill();
+};
+/** Forgets what was typed in for one account, leaving the account itself on offer. */
+const clearQueryDevtoolsAuthCredentials = (accountId) => {
+    store.update((current) => {
+        const { [accountId]: _removed, ...rest } = current.credentials;
+        return { ...current, credentials: rest };
+    });
+    persist();
+    syncPill();
+};
+/** Adds an account the application does not declare, for the backend in force. */
+const addQueryDevtoolsAuthAccount = (options) => {
+    const account = { ...options, id: nextId('account'), scope: scopeOf() };
+    store.update((current) => ({ ...current, accounts: [...current.accounts, account] }));
+    persist();
+    syncPill();
+    return `local:${account.id}`;
+};
+/** Removes an account added in the panel, and whatever was typed in for it. */
+const removeQueryDevtoolsAuthAccount = (accountId) => {
+    const id = accountId.replace(/^local:/, '');
+    store.update((current) => {
+        const { [accountId]: _removed, ...credentials } = current.credentials;
+        return { ...current, credentials, accounts: current.accounts.filter((account) => account.id !== id) };
+    });
+    persist();
+    syncPill();
+};
+const renameQueryDevtoolsAuthSession = (options) => {
+    store.update((current) => ({
+        ...current,
+        sessions: current.sessions.map((session) => session.id === options.sessionId ? { ...session, label: options.label } : session),
+    }));
+    persist();
+    syncPill();
+};
+/** Drops one stored session. The live one it describes is left alone. */
+const forgetQueryDevtoolsAuthSession = (sessionId) => {
+    store.update((current) => ({
+        ...current,
+        sessions: current.sessions.filter((session) => session.id !== sessionId),
+    }));
+    active.update((current) => Object.fromEntries(Object.entries(current).map(([provider, id]) => [provider, id === sessionId ? null : id])));
+    persist();
+    syncPill();
+};
+/** Empties the vault: every session, every account added in the panel, every credential. */
+const clearQueryDevtoolsAuthSessions = () => {
+    store.set(EMPTY);
+    active.set({});
+    writeSeeds({});
+    persist();
+    syncPill();
+};
+const reload = () => globalThis.location?.reload();
+/**
+ * Drops what the previous user left behind. Their responses are cached under keys the next user's
+ * requests hit, and a bound secure query would go on rendering a body that was fetched for somebody else.
+ */
+const clearClientData = (entry) => {
+    const { repository } = entry.client;
+    repository.unbindAllSecure();
+    for (const cacheEntry of repository.subtle.cacheEntries())
+        repository.subtle.evict(cacheEntry.key);
+    void entry.client.clearPersistedQueries();
+};
+/**
+ * Puts one stored session's tokens in force. The reload is the default because a switch only replaces
+ * what the query layer holds: an application that keeps the user anywhere else - a profile service, the
+ * router, an open form - is still showing the last one.
+ */
+const switchQueryDevtoolsAuthSession = (options) => {
+    const session = store().sessions.find((entry) => entry.id === options.sessionId);
+    if (!session)
+        return;
+    const entry = live.get(session.provider);
+    if (!entry || session.scope !== scopeOf())
+        return;
+    clearClientData(entry);
+    setActive(session.provider, session.id);
+    if (tabLocal()[session.provider]) {
+        writeSeeds({
+            ...readSeeds(),
+            [session.provider]: {
+                sessionId: session.id,
+                scope: session.scope,
+                accessToken: session.accessToken,
+                refreshToken: session.refreshToken,
+            },
+        });
+    }
+    persist();
+    entry.handle.setTokens(session.accessToken, session.refreshToken);
+    syncPill();
+    if (options.reload ?? queryDevtoolsSettings().reloadOnAuthSwitch)
+        reload();
+};
+/**
+ * Logs in as one account, through the provider's own login query - so the tokens are issued the way the
+ * application issues them, and the vault picks the session up like any other login.
+ */
+const loginQueryDevtoolsAuthAccount = (accountId) => {
+    const account = queryDevtoolsAuthProviders()
+        .flatMap((provider) => queryDevtoolsAuthAccountsFor(provider))
+        .find((entry) => entry.id === accountId);
+    if (!account?.ready)
+        return;
+    const entry = live.get(account.provider);
+    const query = entry?.handle.queries?.[account.loginQuery];
+    if (!entry || !query)
+        return;
+    clearClientData(entry);
+    setActive(account.provider, null);
+    persist();
+    query.execute(account.buildArgs?.(account.values) ?? { body: account.values });
+};
+/** Ends the live session without forgetting it, so it can be switched back to. */
+const logoutQueryDevtoolsAuthSession = (provider) => {
+    live.get(provider)?.handle.logout();
+};
+/**
+ * Makes this tab's session its own, or hands it back to its siblings. Both reload: a tab that keeps its
+ * own session runs no `BroadcastChannel` sync and writes no persistence cookie, and both are decided
+ * while the provider is built.
+ */
+const setQueryDevtoolsAuthTabLocal = (options) => {
+    const { provider } = options;
+    const seeds = readSeeds();
+    if (!options.tabLocal) {
+        const { [provider]: _dropped, ...rest } = seeds;
+        writeSeeds(rest);
+        reload();
+        return;
+    }
+    const entry = live.get(provider);
+    const accessToken = entry?.handle.accessToken();
+    const refreshToken = entry?.handle.refreshToken();
+    if (!accessToken || !refreshToken)
+        return;
+    const sessionId = active()[provider] ?? null;
+    if (!sessionId)
+        return;
+    writeSeeds({ ...seeds, [provider]: { sessionId, scope: scopeOf(), accessToken, refreshToken } });
+    reload();
+};
+/** What the floating pill offers, rebuilt whenever any of it changes. */
+const syncPill = () => {
+    const rows = untracked(() => providers().map((provider) => {
+        const sessions = queryDevtoolsAuthSessionsFor(provider);
+        const accounts = queryDevtoolsAuthAccountsFor(provider);
+        const activeId = active()[provider] ?? null;
+        const current = sessions.find((session) => session.id === activeId);
+        return {
+            name: provider,
+            current: current?.label ?? (live.get(provider)?.handle.accessToken() ? 'unnamed session' : 'anonymous'),
+            tabLocal: tabLocal()[provider] === true,
+            options: [
+                ...sessions.map((session) => ({
+                    value: `session:${session.id}`,
+                    label: session.label,
+                    title: `Switch to ${session.label}`,
+                    selected: session.id === activeId,
+                    disabled: false,
+                })),
+                ...accounts.map((account) => ({
+                    value: `account:${account.id}`,
+                    label: `log in as ${account.label}`,
+                    title: account.ready
+                        ? `Logs in through ${account.loginQuery}`
+                        : 'Needs its credentials typed into the panel first',
+                    selected: false,
+                    disabled: !account.ready,
+                })),
+            ],
+            pick: (value) => {
+                if (value.startsWith('session:'))
+                    switchQueryDevtoolsAuthSession({ sessionId: value.slice(8) });
+                else if (value.startsWith('account:'))
+                    loginQueryDevtoolsAuthAccount(value.slice(8));
+            },
+            toggleTabLocal: () => setQueryDevtoolsAuthTabLocal({ provider, tabLocal: !tabLocal()[provider] }),
+        };
+    }));
+    setQueryDevtoolsAuthPill({ rows: rows.filter((row) => row.options.length > 0) });
+};
+
 /** The neutral fault: nothing armed. */
 const EMPTY_QUERY_DEVTOOLS_FAULT = {
     latencyMs: 0,
@@ -8268,7 +9259,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.40';
+const QUERY_VERSION = '6.0.0-next.41';
 
 /** How deep a schema is expanded before a nested branch is given up on. */
 const MAX_DEPTH = 12;
@@ -9561,6 +10552,10 @@ const provideQueryDevtools = (options) => {
     initQueryDevtoolsMocks();
     initQueryDevtoolsFaults();
     setQueryDevtoolsSchemaLoader(options?.schema);
+    setQueryDevtoolsApiEnvs(options?.apiEnvs);
+    initQueryDevtoolsAuthSessions(options?.authAccounts);
+    setQueryDevtoolsAuthSeedReader(readQueryDevtoolsAuthSeedFor);
+    setQueryDevtoolsAuthProviderRegistrar(trackQueryDevtoolsAuthProvider);
     setQueryDevtoolsRegistrar(registerEntry);
     setQueryDevtoolsStatsFactory(createQueryDevtoolsStats);
     setQueryDevtoolsFormLinksFactory(createQueryDevtoolsFormLinks);
@@ -11861,14 +12856,14 @@ class V2Query {
                     authProvider.tokens$.pipe(take(1)),
                 ]).pipe(takeUntil(this.onAbort$), switchMap(([state, tokens]) => {
                     if (state && isQueryStateLoading(state)) {
-                        return EMPTY;
+                        return EMPTY$1;
                     }
                     if (isQueryStateFailure(state)) {
                         this.updateEntityState({ type: 'failure', error: state.error, headers: {} }, meta, options);
-                        return EMPTY;
+                        return EMPTY$1;
                     }
                     if (!state && !(tokens?.token || tokens?.refreshToken)) {
-                        return EMPTY;
+                        return EMPTY$1;
                     }
                     return of(true);
                 }), take(1));
@@ -15258,5 +16253,5 @@ const createWebSocketClient = (options) => {
  * Generated bundle index. Do not edit.
  */
 
-export { AuthBearerRefreshStrategy, BasicAuthProvider, BearerAuthFeatureType, BooleanArrayQueryField, CustomHeaderAuthProvider, DEFAULT_KEEP_UNUSED_FOR, DEFAULT_QUERY_PERSISTENCE_MAX_AGE, DEFAULT_QUERY_PERSISTENCE_MAX_ENTRIES, DEFAULT_QUERY_PERSISTENCE_VERSION, DEFAULT_QUERY_PERSISTENCE_WRITE_DELAY, DateArrayQueryField, DateQueryField, EMPTY_QUERY_DEVTOOLS_FAULT, EntityStore, IGNORED_FILTER_COUNT_FIELDS, INFINITY_QUERY_TOKEN, InfinityQuery, InfinityQueryDirective, InfinityQueryTriggerDirective, LegacyQuery, LegacyQueryCreator, MAX_QUERY_BATCH_TOMBSTONES, MAX_QUERY_DEVTOOLS_TOMBSTONES, MAX_UNUSED_ENTRIES, NumberArrayQueryField, ParseHttpErrorCodeToMessageDePipe, ParseHttpErrorCodeToMessageEnPipe, ParseHttpErrorCodeToTitleDePipe, ParseHttpErrorCodeToTitleEnPipe, QUERY_CLIENT_DEVTOOLS_TOKEN, QUERY_DEVTOOLS_FAULT_STATUSES, QUERY_DEVTOOLS_TOKEN_TTL_LIMIT, QUERY_PERSISTENCE_STORE_VERSION, QUERY_SYNC_PROTOCOL_VERSION, QUERY_VERSION, QueryClientFeatureType, QueryDevtoolsComponent, QueryDirective, QueryFeatureType, QueryField, QueryForm, QueryRuntimeErrorCode, QueryShortNamePipe, QueryStateType, QueryStore, SERVER_ERROR_KIND, SERVER_VIOLATION_ERROR_KIND, SPEED_BUFFER_TIME_IN_MS, SearchQueryField, SortQueryField, StringArrayQueryField, V2BearerAuthProvider, V2Query, V2QueryClient, V2QueryCreator, addQueryContainerHandling, applyQueryDevtoolsOverrides, applyQueryDevtoolsTokenTtl, applyQueryFeatures, armAllQueryDevtoolsMocks, armQueryDevtoolsMock, armQueryDevtoolsOverrideTransfer, authExtractTokensResponseMissingAccessToken, authExtractTokensResponseMissingRefreshToken, authExtractTokensResponseNotObject, authProviderFeatureUsedMultipleTimes, booleanArrayQueryField, buildQueryCacheKey, buildQueryString, buildRoute, buildTimestampFromSeconds, canOverrideQueryDevtoolsTokenTtl, castQueryCreatorTypes, circularQueryDependency, circularQueryDependencyChecker, clearQueryDevtoolsArmedMocks, clearQueryDevtoolsFaults, clearQueryDevtoolsMockStore, clearQueryDevtoolsOverrideStore, clearQueryDevtoolsStore, clearQueryDevtoolsTokenTtl, clearQueryDevtoolsTombstones, clearRestoredQueryDevtoolsOverrides, collectLeafPaths, collectQueryDevtoolsSchemaComponents, collectQueryFormLinks, computeQueryAuthHeader, computeQueryBody, computeQueryHeaders, computeQueryMethod, computeQueryQueryParams, consumeSuppressQueryStackDevtools, contentfulGqlLikePaginationAdapter, countUnresolvedQueryDevtoolsOverrides, createAuthGuard, createBaseQuery, createBaseQueryCreator, createBearerAuthProvider, createDefaultRetryFn, createDeleteQuery, createExecuteFn, createGetQuery, createGqlExecuteFn, createGqlMutationViaGet, createGqlMutationViaPost, createGqlQuery, createGqlQueryCreator, createGqlQueryViaGet, createGqlQueryViaPost, createHttpRequest, createIndexedDbQueryPersistenceAdapter, createInfinityQueryConfig, createLegacyQueryCreator, createNoopQueryPersistenceAdapter, createPagedQueryStack, createPatchQuery, createPersistentAuthFeature, createPostQuery, createPutQuery, createQuery, createQueryBatch, createQueryClient, createQueryCollection, createQueryCollectionSignal, createQueryCollectionSubject, createQueryContext, createQueryCreator, createQueryDevtoolsFormLinks, createQueryDevtoolsFormLinksRecorder, createQueryDevtoolsOverrides, createQueryDevtoolsOverridesRecorder, createQueryDevtoolsStats, createQueryDevtoolsStatsRecorder, createQueryErrorResponse, createQueryFeature, createQueryInvalidationFilter, createQueryKeyLockManager, createQueryObject, createQueryPersistenceEngine, createQueryRepository, createQuerySnapshotFn, createQueryStack, createQuerySubmission, createQuerySyncEngine, createQuerySyncTransport, createSecureDeleteQuery, createSecureExecuteFactory, createSecureExecuteFn, createSecureGetQuery, createSecureGqlExecuteFn, createSecureGqlMutationViaGet, createSecureGqlMutationViaPost, createSecureGqlQuery, createSecureGqlQueryCreator, createSecureGqlQueryViaGet, createSecureGqlQueryViaPost, createSecurePatchQuery, createSecurePostQuery, createSecurePutQuery, createSecureQuery, createSecureQueryCreator, createTrackingFeature, createWebSocketClient, currentQueryDevtoolsBatch, dateArrayQueryField, dateQueryField, decryptBearer, deepFreeze, def, defineQueryForm, deleteQueryDevtoolsMock, describeQueryDevtoolsFeatures, detectContentTypeHeader, detectPaginationShape, dynLikePaginationAdapter, effectComputed, emptyQueryArgs, ethletePaginationAdapter, executeUntilSettled, extractExpiresInSeconds, extractFormViolations, extractHtmlErrorMessage, extractQuery, fakePaginationAdapter, filterFailure, filterNull, filterQueryStates, filterSuccess, forEachHeader, formatQueryDevtoolsDuration, generateQueryDevtoolsNumberPreset, generateQueryDevtoolsSampleNumber, 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, queryBatchAlreadyRunning, queryBatchWithArgsUsed, 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, runInQueryDevtoolsBatch, runQueryErrorParsers, saveQueryDevtoolsMock, searchQueryField, seedQueryDevtoolsSchemaBody, seedQueryDevtoolsSchemaRoute, serializeBody, serializeQueryDevtoolsOverrideTransfer, setDefaultQueryRetryFn, setQueryDevtoolsAppInfo, setQueryDevtoolsArmedMocksScope, setQueryDevtoolsFault, setQueryDevtoolsFaultResolver, setQueryDevtoolsFaultsScope, setQueryDevtoolsFormLinksFactory, setQueryDevtoolsMockResolver, setQueryDevtoolsOverridePersistence, setQueryDevtoolsOverridesFactory, setQueryDevtoolsOverridesScope, setQueryDevtoolsRegistrar, setQueryDevtoolsResponseHistory, setQueryDevtoolsSchemaLoader, setQueryDevtoolsSettings, setQueryDevtoolsStatsFactory, setQueryDevtoolsTokenPayloadPatcher, setQueryDevtoolsTokenTtl, setupQueryDependencies, setupQueryExecuteState, setupQueryState, shouldAutoExecuteGqlQuery, shouldAutoExecuteQuery, shouldCacheQuery, shouldRetryRequest, silenceMissingWithArgsFeatureErrorUsedButWithArgsPresent, skipPaginationPageParamCalculator, smartDuplicateArrayItem, snapshotQueryDevtoolsHandle, sortQueryField, splitQueryConfig, stringArrayQueryField, stringifyQueryRouteParts, sumQueryDevtoolsStats, suppressNextQueryStackDevtools, switchQueryCollectionState, switchQueryState, symfonyQueryErrorParser, takeUntilResponse, toQuerySignal, toQuerySubject, tokensNotAvailableInsideAuthAndExec, tombstoneOf, transformArrayResponse, transformExecStateToQueryState, transformGql, transformMethod, transformPaginatedResponse, transformToBoolean, transformToBooleanArray, transformToDate, transformToDateArray, transformToNumber, transformToNumberArray, transformToSort, transformToSortQueryParam, transformToString, transformToStringArray, uncacheableRequestHasAllowCacheParam, uncacheableRequestHasCacheKeyParam, unwrapQuerySyncMessage, v2BuildQueryCacheKey, v2ExtractExpiresInSeconds, v2ShouldCacheQuery, v2ShouldRetryRequest, validateWithQuery, validateWithV2Query, withArgs, withArgsQueryFeatureMissingButRouteIsFunction, withAuthenticationQuery, withAutoRefresh, withAutoRefreshUsedInManualQuery, withAutoRefreshUsedOnUnsupportedHttpMethod, withBearerAuthMultiTabSync, withDefaultRetry, withErrorHandling, withEthleteApiErrors, withHtmlErrorParsing, withInactivityLogout, withLogging, withLongPolling, withLongPollingUsedOnUnsupportedHttpMethod, withLongPollingUsedWithPolling, withMultiTabSync, withPageResetOnError, withPersistentAuth, withPolling, withPollingUsedOnUnsupportedHttpMethod, withQueryDevtoolsOverridePersistence, withQueryPersistence, withRefreshQuery, withResponseUpdate, withSuccessHandling, withSymfonyErrors, withTokenExpirationWarning, withTokenRevocation, withTracking, wrapAsObservableSignal, wrapQuerySyncMessage, writeQueryDevtoolsStore };
+export { AuthBearerRefreshStrategy, BasicAuthProvider, BearerAuthFeatureType, BooleanArrayQueryField, CustomHeaderAuthProvider, DEFAULT_KEEP_UNUSED_FOR, DEFAULT_QUERY_PERSISTENCE_MAX_AGE, DEFAULT_QUERY_PERSISTENCE_MAX_ENTRIES, DEFAULT_QUERY_PERSISTENCE_VERSION, DEFAULT_QUERY_PERSISTENCE_WRITE_DELAY, DateArrayQueryField, DateQueryField, EMPTY_QUERY_DEVTOOLS_FAULT, EntityStore, IGNORED_FILTER_COUNT_FIELDS, INFINITY_QUERY_TOKEN, InfinityQuery, InfinityQueryDirective, InfinityQueryTriggerDirective, LegacyQuery, LegacyQueryCreator, MAX_QUERY_BATCH_TOMBSTONES, MAX_QUERY_DEVTOOLS_TOMBSTONES, MAX_UNUSED_ENTRIES, NumberArrayQueryField, ParseHttpErrorCodeToMessageDePipe, ParseHttpErrorCodeToMessageEnPipe, ParseHttpErrorCodeToTitleDePipe, ParseHttpErrorCodeToTitleEnPipe, QUERY_CLIENT_DEVTOOLS_TOKEN, QUERY_DEVTOOLS_FAULT_STATUSES, QUERY_DEVTOOLS_TOKEN_TTL_LIMIT, QUERY_PERSISTENCE_STORE_VERSION, QUERY_SYNC_PROTOCOL_VERSION, QUERY_VERSION, QueryClientFeatureType, QueryDevtoolsComponent, QueryDirective, QueryFeatureType, QueryField, QueryForm, QueryRuntimeErrorCode, QueryShortNamePipe, QueryStateType, QueryStore, SERVER_ERROR_KIND, SERVER_VIOLATION_ERROR_KIND, SPEED_BUFFER_TIME_IN_MS, SearchQueryField, SortQueryField, StringArrayQueryField, V2BearerAuthProvider, V2Query, V2QueryClient, V2QueryCreator, addQueryContainerHandling, addQueryDevtoolsAuthAccount, applyQueryDevtoolsOverrides, applyQueryDevtoolsTokenTtl, applyQueryFeatures, armAllQueryDevtoolsMocks, armQueryDevtoolsMock, armQueryDevtoolsOverrideTransfer, authExtractTokensResponseMissingAccessToken, authExtractTokensResponseMissingRefreshToken, authExtractTokensResponseNotObject, authProviderFeatureUsedMultipleTimes, booleanArrayQueryField, buildQueryCacheKey, buildQueryString, buildRoute, buildTimestampFromSeconds, canOverrideQueryDevtoolsTokenTtl, castQueryCreatorTypes, circularQueryDependency, circularQueryDependencyChecker, clearQueryDevtoolsArmedMocks, clearQueryDevtoolsAuthCredentials, clearQueryDevtoolsAuthSessions, clearQueryDevtoolsFaults, clearQueryDevtoolsMockStore, clearQueryDevtoolsOverrideStore, clearQueryDevtoolsStore, clearQueryDevtoolsTokenTtl, clearQueryDevtoolsTombstones, clearRestoredQueryDevtoolsOverrides, collectLeafPaths, collectQueryDevtoolsSchemaComponents, collectQueryFormLinks, computeQueryAuthHeader, computeQueryBody, computeQueryHeaders, computeQueryMethod, computeQueryQueryParams, consumeSuppressQueryStackDevtools, contentfulGqlLikePaginationAdapter, countUnresolvedQueryDevtoolsOverrides, createAuthGuard, createBaseQuery, createBaseQueryCreator, createBearerAuthProvider, createDefaultRetryFn, createDeleteQuery, createExecuteFn, createGetQuery, createGqlExecuteFn, createGqlMutationViaGet, createGqlMutationViaPost, createGqlQuery, createGqlQueryCreator, createGqlQueryViaGet, createGqlQueryViaPost, createHttpRequest, createIndexedDbQueryPersistenceAdapter, createInfinityQueryConfig, createLegacyQueryCreator, createNoopQueryPersistenceAdapter, createPagedQueryStack, createPatchQuery, createPersistentAuthFeature, createPostQuery, createPutQuery, createQuery, createQueryBatch, createQueryClient, createQueryCollection, createQueryCollectionSignal, createQueryCollectionSubject, createQueryContext, createQueryCreator, createQueryDevtoolsFormLinks, createQueryDevtoolsFormLinksRecorder, createQueryDevtoolsOverrides, createQueryDevtoolsOverridesRecorder, createQueryDevtoolsStats, createQueryDevtoolsStatsRecorder, createQueryErrorResponse, createQueryFeature, createQueryInvalidationFilter, createQueryKeyLockManager, createQueryObject, createQueryPersistenceEngine, createQueryRepository, createQuerySnapshotFn, createQueryStack, createQuerySubmission, createQuerySyncEngine, createQuerySyncTransport, createSecureDeleteQuery, createSecureExecuteFactory, createSecureExecuteFn, createSecureGetQuery, createSecureGqlExecuteFn, createSecureGqlMutationViaGet, createSecureGqlMutationViaPost, createSecureGqlQuery, createSecureGqlQueryCreator, createSecureGqlQueryViaGet, createSecureGqlQueryViaPost, createSecurePatchQuery, createSecurePostQuery, createSecurePutQuery, createSecureQuery, createSecureQueryCreator, createTrackingFeature, createWebSocketClient, currentQueryDevtoolsBatch, dateArrayQueryField, dateQueryField, decryptBearer, deepFreeze, def, defineQueryForm, deleteQueryDevtoolsMock, describeQueryDevtoolsFeatures, detectContentTypeHeader, detectPaginationShape, dynLikePaginationAdapter, effectComputed, emptyQueryArgs, ethletePaginationAdapter, executeUntilSettled, extractExpiresInSeconds, extractFormViolations, extractHtmlErrorMessage, extractQuery, fakePaginationAdapter, filterFailure, filterNull, filterQueryStates, filterSuccess, forEachHeader, forgetQueryDevtoolsAuthSession, formatQueryDevtoolsDuration, generateQueryDevtoolsNumberPreset, generateQueryDevtoolsSampleNumber, generateQueryDevtoolsStringPreset, getBearerAuthProviderName, getDefaultHeaders, getQueryClientName, getQueryFeatureUsage, getResponseUrl, ggLikePaginationAdapter, gql, gqlDataPropertyMissingInResponse, hasHeader, hasQueryDevtoolsOverridesAtPath, htmlErrorPayload, htmlQueryErrorParser, ignoreAutoRefresh, initQueryDevtoolsAuthSessions, initQueryDevtoolsFaults, initQueryDevtoolsMocks, initQueryDevtoolsOverridePersistence, initQueryDevtoolsSettings, injectInfinityQueryResponseDelay, injectQueryContext, insertFrom, invalidBaseRouteError, invalidBodyError, invalidRouteError, invalidStateInsideSecureExecuteFactory, isAutoRefresh, isBasicAuthProvider, isBearerAuthProvider, isClassValidatorError, isCreateGqlQueryOptions, isCustomHeaderAuthProvider, isDateShapedLeaf, isEmptyString, isGqlQueryConfig, isHtmlErrorPayload, isLegacyQuery, isNaN$1 as isNaN, isPageOutOfRangeError, isQuery, isQueryCollection, isQueryDevtoolsEnabled, isQueryDevtoolsFaultArmed, isQueryDevtoolsRequestInterceptionEnabled, isQueryErrorResponse, isQueryStateCancelled, isQueryStateFailure, isQueryStateLoading, isQueryStatePrepared, isQueryStateSuccess, isRequestError, isSymfonyError, isSymfonyFormViolationListError, isSymfonyListError, isSymfonyPagerfantaOutOfRangeError, isUnderInvalidatedUrl, legacyPrepareFallbackInjector, legacyPrepareWithoutInjectionContext, loadQueryDevtoolsSchema, loginQueryDevtoolsAuthAccount, logoutQueryDevtoolsAuthSession, mapToPaginated, mapViolationsToFormErrors, matchesQueryDevtoolsMockPattern, matchesQueryDevtoolsMockQuery, maybeExecute, measureQueryDevtoolsPayload, mergeHeaders, nestedEffect, noteQueryFormRead, numberArrayQueryField, pagedQueryStackNextPageCalledWithoutPreviousPage, pagedQueryStackPageBiggerThanTotalPages, pagedQueryStackPreviousPageCalledButAlreadyAtFirstPage, paginatedEntityValueUpdater, parseAllXhrResponseHeaders, parseHttpErrorCodeToMessageDe, parseHttpErrorCodeToMessageEn, parseHttpErrorCodeToTitleDe, parseHttpErrorCodeToTitleEn, parseQueryDevtoolsOverrideTransfer, parseQueryRoute, patchQueryDevtoolsTokenPayload, pathParamsMissingInRouteFunctionError, provideInfinityQueryResponseDelay, provideLegacyPrepareFallback, provideQueryClientForDevtools, provideQueryDevtools, queryArrayComputed, queryBatchAlreadyRunning, queryBatchWithArgsUsed, queryClientFeatureUsedMultipleTimes, queryComputed, queryComputedTillTruthy, queryDevtoolsAbout, queryDevtoolsApiEnvIds, queryDevtoolsApiEnvIsProduction, queryDevtoolsApiEnvScope, queryDevtoolsApiEnvValues, queryDevtoolsApiEnvs, queryDevtoolsArmedMocks, queryDevtoolsArmedMocksRestored, queryDevtoolsAuthAccountsFor, queryDevtoolsAuthActive, queryDevtoolsAuthOtherScopeCount, queryDevtoolsAuthProviders, queryDevtoolsAuthSessions, queryDevtoolsAuthSessionsFor, queryDevtoolsAuthTabLocal, 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, readQueryDevtoolsAuthSeed, readQueryDevtoolsAuthSeedFor, readQueryDevtoolsStore, registerEthleteVersion, registerQueryDevtoolsAuthProvider, registerQueryDevtoolsEntry, registerQueryErrorParser, removeFrom, removeQueryDevtoolsAuthAccount, renameQueryDevtoolsAuthSession, request, resetExecuteState, resetPageOnError, resolveInvalidationUrl, resolveQueryDevtoolsFault, resolveQueryDevtoolsFaultForAttempt, resolveQueryDevtoolsMock, resolveQueryDevtoolsMockForAttempt, restoredQueryDevtoolsOverrides, runDefaultQueryRetry, runInQueryDevtoolsBatch, runQueryErrorParsers, saveQueryDevtoolsMock, searchQueryField, seedQueryDevtoolsSchemaBody, seedQueryDevtoolsSchemaRoute, serializeBody, serializeQueryDevtoolsOverrideTransfer, setDefaultQueryRetryFn, setQueryDevtoolsApiEnv, setQueryDevtoolsApiEnvs, setQueryDevtoolsAppInfo, setQueryDevtoolsArmedMocksScope, setQueryDevtoolsAuthCredentials, setQueryDevtoolsAuthProviderRegistrar, setQueryDevtoolsAuthSeedReader, setQueryDevtoolsAuthTabLocal, setQueryDevtoolsFault, setQueryDevtoolsFaultResolver, setQueryDevtoolsFaultsScope, setQueryDevtoolsFormLinksFactory, setQueryDevtoolsMockResolver, setQueryDevtoolsOverridePersistence, setQueryDevtoolsOverridesFactory, setQueryDevtoolsOverridesScope, setQueryDevtoolsRegistrar, setQueryDevtoolsResponseHistory, setQueryDevtoolsSchemaLoader, setQueryDevtoolsSettings, setQueryDevtoolsStatsFactory, setQueryDevtoolsTokenPayloadPatcher, setQueryDevtoolsTokenTtl, setupQueryDependencies, setupQueryExecuteState, setupQueryState, shouldAutoExecuteGqlQuery, shouldAutoExecuteQuery, shouldCacheQuery, shouldRetryRequest, silenceMissingWithArgsFeatureErrorUsedButWithArgsPresent, skipPaginationPageParamCalculator, smartDuplicateArrayItem, snapshotQueryDevtoolsHandle, sortQueryField, splitQueryConfig, stringArrayQueryField, stringifyQueryRouteParts, sumQueryDevtoolsStats, suppressNextQueryStackDevtools, switchQueryCollectionState, switchQueryDevtoolsAuthSession, switchQueryState, symfonyQueryErrorParser, takeUntilResponse, toQuerySignal, toQuerySubject, tokensNotAvailableInsideAuthAndExec, tombstoneOf, trackQueryDevtoolsAuthProvider, transformArrayResponse, transformExecStateToQueryState, transformGql, transformMethod, transformPaginatedResponse, transformToBoolean, transformToBooleanArray, transformToDate, transformToDateArray, transformToNumber, transformToNumberArray, transformToSort, transformToSortQueryParam, transformToString, transformToStringArray, uncacheableRequestHasAllowCacheParam, uncacheableRequestHasCacheKeyParam, unwrapQuerySyncMessage, v2BuildQueryCacheKey, v2ExtractExpiresInSeconds, v2ShouldCacheQuery, v2ShouldRetryRequest, validateWithQuery, validateWithV2Query, withArgs, withArgsQueryFeatureMissingButRouteIsFunction, withAuthenticationQuery, withAutoRefresh, withAutoRefreshUsedInManualQuery, withAutoRefreshUsedOnUnsupportedHttpMethod, withBearerAuthMultiTabSync, withDefaultRetry, withErrorHandling, withEthleteApiErrors, withHtmlErrorParsing, withInactivityLogout, withLogging, withLongPolling, withLongPollingUsedOnUnsupportedHttpMethod, withLongPollingUsedWithPolling, withMultiTabSync, withPageResetOnError, withPersistentAuth, withPolling, withPollingUsedOnUnsupportedHttpMethod, withQueryDevtoolsOverridePersistence, withQueryPersistence, withRefreshQuery, withResponseUpdate, withSuccessHandling, withSymfonyErrors, withTokenExpirationWarning, withTokenRevocation, withTracking, wrapAsObservableSignal, wrapQuerySyncMessage, writeQueryDevtoolsStore };
 //# sourceMappingURL=ethlete-query.mjs.map