@ethlete/query 6.0.0-next.23 → 6.0.0-next.24

package/fesm2022/ethlete-query.mjs

@@ -1,9 +1,9 @@
 import * as i0 from '@angular/core';
-import { DestroyRef, InjectionToken, inject, Injector, EnvironmentInjector, ElementRef, ErrorHandler, createEnvironmentInjector, effect, untracked, signal, linkedSignal, computed, runInInjectionContext, isDevMode, PLATFORM_ID, resource, DOCUMENT, makeEnvironmentProviders, assertInInjectionContext, ChangeDetectorRef, ViewContainerRef, TemplateRef, Input, Directive, input, Pipe, ViewEncapsulation, Component, NgZone } from '@angular/core';
+import { DestroyRef, InjectionToken, inject, Injector, EnvironmentInjector, ElementRef, ErrorHandler, createEnvironmentInjector, effect, untracked, signal, linkedSignal, computed, runInInjectionContext, isDevMode, PLATFORM_ID, resource, DOCUMENT, makeEnvironmentProviders, assertInInjectionContext, provideEnvironmentInitializer, ChangeDetectorRef, ViewContainerRef, TemplateRef, Input, Directive, input, Pipe, ViewEncapsulation, Component, NgZone } from '@angular/core';
 import { defineStaticProvider, RuntimeError, clamp, randomId, defineRootProvider, isObject, injectUnsavedChangesCoordinator, injectRoute, getCookie, getDomain, setCookie, deleteCookie, createDestroy, computedTillTruthy, defineProvider, toProvideFn, toInjectFn, nextFrame, injectQueryParams, injectQueryParamChanges, clone, equal, ET_PROPERTY_REMOVED, previousSignalValue } from '@ethlete/core';
-import { filter, Subject, Subscription, tap, retry, throwError, timer, catchError, take, switchMap, of, firstValueFrom, merge, fromEvent, throttleTime, interval, combineLatest, map, Observable, takeUntil, startWith, pairwise, BehaviorSubject, ReplaySubject, shareReplay, skip, takeWhile, EMPTY, withLatestFrom, debounceTime } from 'rxjs';
-import { toObservable, takeUntilDestroyed, toSignal } from '@angular/core/rxjs-interop';
+import { filter, Subject, Subscription, defer, throwError, timer, switchMap, tap, retry, catchError, take, of, firstValueFrom, merge, fromEvent, throttleTime, interval, combineLatest, map, Observable, takeUntil, startWith, pairwise, BehaviorSubject, ReplaySubject, shareReplay, skip, takeWhile, EMPTY, withLatestFrom, debounceTime } from 'rxjs';
 import { HttpClient, HttpEventType, HttpErrorResponse, HttpHeaders, HttpStatusCode } from '@angular/common/http';
+import { toObservable, takeUntilDestroyed, toSignal } from '@angular/core/rxjs-interop';
 import { getActiveConsumer, setActiveConsumer } from '@angular/core/primitives/signals';
 import { isPlatformBrowser, NgClass, AsyncPipe, JsonPipe } from '@angular/common';
 import { validateAsync, form } from '@angular/forms/signals';
@@ -12,6 +12,45 @@ import { FormControl, ReactiveFormsModule, FormGroup } from '@angular/forms';
 import { Router, ActivatedRoute } from '@angular/router';
 import { io } from 'socket.io-client';
 
+/**
+ * Turns the features applied at creation into their devtools representation.
+ * @internal
+ */
+const describeQueryDevtoolsFeatures = (features) => features?.map((feature) => ({ type: feature.type, details: feature.devtools?.() ?? [] })) ?? [];
+/**
+ * Renders a millisecond duration the way feature details spell one out - `500ms`, `1.5s`, `15m`.
+ * @internal
+ */
+const formatQueryDevtoolsDuration = (ms) => {
+    if (!Number.isFinite(ms))
+        return String(ms);
+    if (ms < 1000)
+        return `${ms}ms`;
+    const round = (value, unit) => `${Number(value.toFixed(1))}${unit}`;
+    if (ms < 60_000)
+        return round(ms / 1000, 's');
+    if (ms < 3_600_000)
+        return round(ms / 60_000, 'm');
+    return round(ms / 3_600_000, 'h');
+};
+/**
+ * The name of a function passed as `options.<key>`, or `null` when it is an inline lambda. An inline
+ * `{ handler: (e) => … }` inherits the name `handler` from the key it is assigned to, which tells the
+ * reader nothing - a reference to a declared function does.
+ */
+const queryDevtoolsFnName = (fn, key) => {
+    const name = typeof fn === 'function' ? fn.name.replace(/^bound /, '') : '';
+    return !name || name === key ? null : name;
+};
+/**
+ * A detail for the function passed as `options.<key>`, omitted when it is an inline lambda.
+ * @internal
+ */
+const queryDevtoolsFnDetail = (fn, key) => {
+    const name = queryDevtoolsFnName(fn, key);
+    return name ? [{ label: key, value: name }] : [];
+};
+
 const noop$2 = () => undefined;
 let registrar = null;
 /**
@@ -33,6 +72,85 @@ const isQueryDevtoolsEnabled = () => registrar !== null;
  * @internal
  */
 const registerQueryDevtoolsEntry = (entry) => registrar?.(entry) ?? noop$2;
+let statsFactory = null;
+/**
+ * Installs the stats recorder factory. Called by `provideQueryDevtools()`; nothing else may call it.
+ * @internal
+ */
+const setQueryDevtoolsStatsFactory = (fn) => {
+    statsFactory = fn;
+};
+/**
+ * A stats recorder for one entry, or `null` unless {@link provideQueryDevtools} has been called.
+ *
+ * Instrumentation sites must go through this instead of importing `createQueryDevtoolsStats`: a static
+ * import pins the whole stats module (~1.4 kB) into every bundle that touches a query, and a runtime
+ * `isQueryDevtoolsEnabled()` guard at the call site does not undo that. Reached only from the provider,
+ * it is dead code in an app without devtools.
+ * @internal
+ */
+const createQueryDevtoolsStatsRecorder = () => statsFactory?.() ?? null;
+let formLinksFactory = null;
+/**
+ * Installs the form-links recorder factory. Called by `provideQueryDevtools()`; nothing else may call it.
+ * @internal
+ */
+const setQueryDevtoolsFormLinksFactory = (fn) => {
+    formLinksFactory = fn;
+};
+/**
+ * A form-links recorder for one query, or `null` unless {@link provideQueryDevtools} has been called.
+ * Reached only from the provider for the same reason {@link createQueryDevtoolsStatsRecorder} is.
+ * @internal
+ */
+const createQueryDevtoolsFormLinksRecorder = () => formLinksFactory?.() ?? null;
+/** The ids of the query forms read by the args build currently running, or `null` outside of one. */
+let formLinkSink = null;
+/**
+ * Runs `build` and reports which query forms it read. Nested builds are supported - the outer one
+ * resumes collecting once the inner one is done.
+ * @internal
+ */
+const collectQueryFormLinks = (build) => {
+    const outer = formLinkSink;
+    const sink = new Set();
+    formLinkSink = sink;
+    try {
+        return { value: build(), ids: [...sink] };
+    }
+    finally {
+        formLinkSink = outer;
+    }
+};
+/**
+ * Records that a query form's committed value was read. The form calls this from its `value` signal, so
+ * a read that happens while a query builds its args is what links the two - no naming convention, and
+ * nothing to keep in sync when the args change.
+ * @internal
+ */
+const noteQueryFormRead = (id) => {
+    formLinkSink?.add(id);
+};
+let faultResolver = null;
+/**
+ * Installs the fault resolver. Called by `provideQueryDevtools()`; nothing else may call it.
+ * @internal
+ */
+const setQueryDevtoolsFaultResolver = (fn) => {
+    faultResolver = fn;
+};
+/**
+ * Whether fault injection can do anything at all. Checked before building the wrapper that resolves a
+ * fault per attempt, so a request in an app without devtools keeps the pipeline it always had.
+ * @internal
+ */
+const isQueryDevtoolsFaultInjectionEnabled = () => faultResolver !== null;
+/**
+ * Resolves the fault to apply to one upcoming attempt, or `null` when nothing is armed. Consumes a
+ * `failNext` budget, so call it exactly once per attempt.
+ * @internal
+ */
+const resolveQueryDevtoolsFault = (target) => faultResolver?.(target) ?? null;
 let suppressStackRegistration = false;
 /**
  * Suppresses devtools registration for the next {@link createQueryStack} call. Used by
@@ -230,12 +348,15 @@ const invalidStateInsideSecureExecuteFactory = () => {
 const circularQueryDependency = () => {
     return new RuntimeError(QueryRuntimeErrorCode.CIRCULAR_QUERY_DEPENDENCY, `Query was executed more than 5 times in less than 100ms. This is usually a sign of a circular dependency.`);
 };
-const legacyPrepareWithoutInjectionContext = (creatorName) => {
+const legacyPrepareWithoutInjectionContext = (creatorName, method = 'prepare') => {
     const label = creatorName ? `"${creatorName}"` : 'A legacy query creator';
-    return new RuntimeError(QueryRuntimeErrorCode.LEGACY_PREPARE_WITHOUT_INJECTION_CONTEXT, `${label}.prepare() was called outside of an injection context. Unlike the v2 client, the legacy interop layer needs an injector to build the underlying query.\n\n` +
+    const example = method === 'prepare'
+        ? `  search = (term: string) => myQuery.prepare({ queryParams: { term }, injector: this.injector });`
+        : `  container = myQuery.${method}(null, { injector: this.injector });`;
+    return new RuntimeError(QueryRuntimeErrorCode.LEGACY_PREPARE_WITHOUT_INJECTION_CONTEXT, `${label}.${method}() was called outside of an injection context. Unlike the v2 client, the legacy interop layer needs an injector to build the underlying query.\n\n` +
         `Capture one where a context does exist (field initializer, constructor) and pass it along:\n\n` +
         `  private injector = inject(Injector);\n` +
-        `  search = (term: string) => myQuery.prepare({ queryParams: { term }, injector: this.injector });\n\n` +
+        `${example}\n\n` +
         `Prefer an injector that outlives the call site. A component injector passed from a callback that can still fire after the component is gone leaves prepare() with a destroyed injector, which returns an inert query instead of executing.`);
 };
 const querySequenceAlreadyRunning = () => {
@@ -322,7 +443,7 @@ const withArgs = (args) => {
             // auto-refresh) always sees the latest value with no pending-effect window. Sentinels are
             // resolved here: CLEAR -> null, `null` ("don't change") -> keep the previous value.
             let previous = null;
-            context.state.subtle.setArgsSource(() => {
+            const resolve = () => {
                 const value = args();
                 if (value === CLEAR_QUERY_ARGS) {
                     previous = null;
@@ -332,7 +453,12 @@ const withArgs = (args) => {
                     return previous;
                 previous = value;
                 return value;
-            });
+            };
+            // Only ever non-null while the devtools are installed. Wrapping the source (rather than reading
+            // `state.args` from the outside) is what puts the tracking window around the *evaluation* of the
+            // args - a cached read of the computed runs nothing and would record no form at all.
+            const formLinks = context.state.subtle.devtoolsFormLinks;
+            context.state.subtle.setArgsSource(formLinks ? () => formLinks.track(resolve) : resolve);
             // Trigger (auto-)execution whenever the resolved args change.
             nestedEffect(() => {
                 const currArgsNow = context.state.args();
@@ -362,6 +488,10 @@ const withArgs = (args) => {
 const withPolling = (options) => {
     return createQueryFeature({
         type: QueryFeatureType.WITH_POLLING,
+        devtools: () => [
+            { label: 'interval', value: formatQueryDevtoolsDuration(options.interval) },
+            { label: 'execute initially', value: options.executeInitially ? 'yes' : 'no' },
+        ],
         fn: (context) => {
             if (!context.flags.shouldAutoExecuteMethod) {
                 throw withPollingUsedOnUnsupportedHttpMethod(context.flags.method);
@@ -428,6 +558,7 @@ const withPolling = (options) => {
 const withLogging = (options) => {
     return createQueryFeature({
         type: QueryFeatureType.WITH_LOGGING,
+        devtools: () => queryDevtoolsFnDetail(options.logFn, 'logFn'),
         fn: (context) => {
             context.state.events$.pipe(takeUntilDestroyed(context.deps.destroyRef)).subscribe((event) => {
                 options.logFn(event);
@@ -439,6 +570,7 @@ const withLogging = (options) => {
 const withErrorHandling = (options) => {
     return createQueryFeature({
         type: QueryFeatureType.WITH_ERROR_HANDLING,
+        devtools: () => queryDevtoolsFnDetail(options.handler, 'handler'),
         fn: (context) => {
             context.state.events$
                 .pipe(filter((event) => event.type === 'error'), takeUntilDestroyed(context.deps.destroyRef))
@@ -452,6 +584,7 @@ const withErrorHandling = (options) => {
 const withSuccessHandling = (options) => {
     return createQueryFeature({
         type: QueryFeatureType.WITH_SUCCESS_HANDLING,
+        devtools: () => queryDevtoolsFnDetail(options.handler, 'handler'),
         fn: (context) => {
             context.state.events$
                 .pipe(filter((event) => event.type === HttpEventType.Response), takeUntilDestroyed(context.deps.destroyRef))
@@ -469,6 +602,10 @@ const withSuccessHandling = (options) => {
 const withAutoRefresh = (options) => {
     return createQueryFeature({
         type: QueryFeatureType.WITH_AUTO_REFRESH,
+        devtools: () => [
+            { label: 'signals', value: String(options.onSignalChanges.length) },
+            ...(options.ignoreOnlyManualExecution ? [{ label: 'ignores manual only', value: 'yes' }] : []),
+        ],
         fn: (context) => {
             if (!context.flags.shouldAutoExecuteMethod) {
                 throw withAutoRefreshUsedOnUnsupportedHttpMethod(context.flags.method);
@@ -495,6 +632,7 @@ const withAutoRefresh = (options) => {
 const withResponseUpdate = (options) => {
     return createQueryFeature({
         type: QueryFeatureType.WITH_RESPONSE_UPDATE,
+        devtools: () => queryDevtoolsFnDetail(options.updater, 'updater'),
         fn: (context) => {
             nestedEffect(() => {
                 const currentResponse = untracked(() => context.state.response());
@@ -545,6 +683,11 @@ const withPageResetOnError = (options) => {
     const matches = options.when ?? isPageOutOfRangeError;
     return createQueryFeature({
         type: QueryFeatureType.WITH_PAGE_RESET_ON_ERROR,
+        devtools: () => [
+            { label: 'resets', value: options.reset ? 'custom callback' : 'page signal' },
+            ...(options.reset ? [] : [{ label: 'reset to', value: String(options.resetTo ?? 1) }]),
+            { label: 'when', value: options.when ? 'custom' : 'page out of range' },
+        ],
         fn: (context) => {
             context.state.events$
                 .pipe(filter((event) => event.type === 'error'), takeUntilDestroyed(context.deps.destroyRef))
@@ -624,7 +767,10 @@ const setupQueryState = (options) => {
                 error: currentError,
             };
         }
-        else if (currentResponse) {
+        else if (currentResponse !== null || latestHttpEvent()?.type === HttpEventType.Response) {
+            // A response event having arrived is what makes the execution a success, not a truthy body: a 204 (or any
+            // other empty payload) sets `response` to `null`, which would otherwise be indistinguishable from a query
+            // that never ran - leaving `filterSuccess`, `onSuccess` and the success handlers waiting forever.
             return {
                 type: 'success',
                 response: currentResponse,
@@ -651,6 +797,8 @@ const setupQueryState = (options) => {
             rawResponse,
             bindRequestEvents,
             setArgsSource,
+            devtoolsStats: options.devtoolsStats ?? null,
+            devtoolsFormLinks: options.devtoolsFormLinks ?? null,
         },
     };
     return state;
@@ -824,8 +972,12 @@ const createBaseQuery = (options) => {
         queryConfig: options.queryConfig,
     });
     return runInInjectionContext(deps.injector, () => {
+        const devtoolsStats = createQueryDevtoolsStatsRecorder();
+        const devtoolsFormLinks = createQueryDevtoolsFormLinksRecorder();
         const state = setupQueryState({
             transformResponse: options.creator?.transformResponse,
+            devtoolsStats,
+            devtoolsFormLinks,
         });
         const flags = getQueryFeatureUsage(options);
         const execute = options.executeFactory({
@@ -844,18 +996,40 @@ const createBaseQuery = (options) => {
         applyQueryFeatures(options.features, featureFnContext);
         maybeExecute({ execute, flags });
         const query = createQueryObject({ state, execute, deps });
-        if (isQueryDevtoolsEnabled()) {
+        // Only ever non-null while the devtools are installed, so this whole block - the entry and the
+        // per-response payload measuring behind it - is dead code in an app without them.
+        if (devtoolsStats) {
+            const statsSubscription = state.events$.subscribe((event) => {
+                if (event.type === 'error') {
+                    devtoolsStats.recordError();
+                }
+                else if (event.type === HttpEventType.Response) {
+                    devtoolsStats.recordResponse({ headers: event.headers, body: event.body });
+                }
+            });
+            deps.destroyRef.onDestroy(() => statsSubscription.unsubscribe());
+            // A retry happens inside the request, which is shared by every query hitting the same cache key -
+            // so the recorder reads it off the request instead of being handed down into one. `recordRetry` is
+            // idempotent per attempt, which is what makes reading a signal a safe way to count them.
+            effect(() => {
+                const retry = state.subtle.request()?.subtle.retryState();
+                if (retry)
+                    devtoolsStats.recordRetry({ attempt: retry.attempt });
+            });
             const unregister = registerQueryDevtoolsEntry({
                 kind: 'query',
                 handle: query,
                 clientRef: client,
+                stats: devtoolsStats,
+                formLinks: devtoolsFormLinks ?? undefined,
                 route: options.creatorInternals.route ??
                     options.creator?.route ??
                     null,
+                authProviderRef: options.creatorInternals.authProvider,
                 meta: {
                     clientBaseUrl: deps.client.baseUrl,
                     method: flags.method,
-                    featureTypes: options.features.map((f) => f.type),
+                    features: describeQueryDevtoolsFeatures(options.features),
                     queryConfig: options.queryConfig,
                     creator: options.creator,
                     repository: deps.client.repository,
@@ -890,7 +1064,7 @@ const setupQueryExecuteState = () => {
 const queryExecute = (options) => {
     const { executeOptions, args, executeState, options: runQueryOptions, isSecure } = options;
     const { deps, state, creator, creatorInternals, queryConfig } = executeOptions;
-    const { key, request } = deps.client.repository.request({
+    const { key, request, executed } = deps.client.repository.request({
         route: creatorInternals.route,
         method: creatorInternals.method,
         args,
@@ -908,6 +1082,7 @@ const queryExecute = (options) => {
     state.lastTriggeredBy.set(runQueryOptions?.triggeredBy ?? null);
     state.subtle.request.set(request);
     state.subtle.bindRequestEvents(request);
+    state.subtle.devtoolsStats?.recordExecution({ didRequest: executed, body: args?.body, url: request.url });
 };
 const circularQueryDependencyChecker = () => {
     let lastTriggerTs = 0;
@@ -1009,6 +1184,10 @@ const createBaseQueryCreator = (config) => {
             options: { ...config.options, ...additionalOptions },
         });
     };
+    queryCreator.subtle = {
+        creatorInternals: config.internals,
+        creatorOptions: config.options,
+    };
     return queryCreator;
 };
 
@@ -1341,6 +1520,10 @@ const createHttpRequest = (options) => {
     ...(ngDevMode ? [{ debugName: "lastExecuteTime" }] : /* istanbul ignore next */ []));
     const expiresIn = signal(null, /* @ts-ignore */
     ...(ngDevMode ? [{ debugName: "expiresIn" }] : /* istanbul ignore next */ []));
+    const attempts = signal(1, /* @ts-ignore */
+    ...(ngDevMode ? [{ debugName: "attempts" }] : /* istanbul ignore next */ []));
+    const retryState = signal(null, /* @ts-ignore */
+    ...(ngDevMode ? [{ debugName: "retryState" }] : /* istanbul ignore next */ []));
     // NOTE: This must be a plain function, not a `computed`. The freshness check compares against
     // `Date.now()`, which is not reactive, so a memoized computed would only ever recompute when
     // `expiresIn` changes - once it evaluated to `false` (fresh) it would stay `false` forever, even
@@ -1362,26 +1545,68 @@ const createHttpRequest = (options) => {
         // client-level one instead of being appended next to it.
         return argHeaders.keys().reduce((merged, key) => merged.set(key, argHeaders.getAll(key) ?? []), clientHeaders);
     };
+    const send = (headers) => dependencies.httpClient.request(options.method, options.fullPath, {
+        observe: 'events',
+        body: args?.body,
+        reportProgress: clientOptions?.reportProgress,
+        withCredentials: clientOptions?.withCredentials,
+        transferCache: clientOptions?.transferCache,
+        responseType: clientOptions?.responseType || 'json',
+        headers,
+    });
+    /**
+     * Wraps the request in the fault the devtools have armed for this client, if any.
+     *
+     * Inside a `defer` so a fault is resolved per subscription rather than per execution - which is what
+     * makes `retry` re-roll it, so an armed "fail the next two attempts" lets the third one through like a
+     * flaky server would. Injected latency delays the attempt rather than its response, so the loading
+     * state genuinely lasts that long and a retry waits it out too.
+     *
+     * A faulted attempt always goes through `timer`, even at zero latency: no real request can fail in the
+     * same tick it was started in, and settling synchronously inside `execute()` would let an injected
+     * failure land before the caller has finished wiring the request up.
+     */
+    const sendWithFaults = (headers) => defer(() => {
+        const fault = resolveQueryDevtoolsFault({
+            clientName: options.clientName ?? '',
+            method: options.method,
+            url: options.fullPath,
+        });
+        if (!fault)
+            return send(headers);
+        const { status } = fault;
+        const attempt$ = status === null
+            ? send(headers)
+            : throwError(() => new HttpErrorResponse({
+                status,
+                statusText: 'Injected by the query devtools',
+                url: options.fullPath,
+                error: { message: `Injected ${status} (query devtools)` },
+            }));
+        return timer(fault.latencyMs).pipe(switchMap(() => attempt$));
+    });
     const createStream = () => {
         const headers = resolveHeaders();
-        return dependencies.httpClient
-            .request(options.method, options.fullPath, {
-            observe: 'events',
-            body: args?.body,
-            reportProgress: clientOptions?.reportProgress,
-            withCredentials: clientOptions?.withCredentials,
-            transferCache: clientOptions?.transferCache,
-            responseType: clientOptions?.responseType || 'json',
-            headers,
-        })
-            .pipe(tap((event) => updateState(event)), retry({
+        const source$ = isQueryDevtoolsFaultInjectionEnabled() ? sendWithFaults(headers) : send(headers);
+        return source$.pipe(tap((event) => updateState(event)), retry({
             delay: (error, retryCount) => {
                 const retryOptions = { error, retryCount };
                 const retryResult = options.retryFn?.(retryOptions) || runDefaultQueryRetry(retryOptions);
                 if (!retryResult.retry) {
                     return throwError(() => error);
                 }
-                return timer(retryResult.delay);
+                // rxjs counts retries from 1, so the attempt this delay leads up to is one further along.
+                const attempt = retryCount + 1;
+                retryState.set({
+                    attempt,
+                    delayMs: retryResult.delay,
+                    startsAt: Date.now() + retryResult.delay,
+                    status: error instanceof HttpErrorResponse ? error.status : 0,
+                });
+                return timer(retryResult.delay).pipe(tap(() => {
+                    retryState.set(null);
+                    attempts.set(attempt);
+                }));
             },
         }), catchError((e) => {
             updateErrorState(e);
@@ -1402,6 +1627,8 @@ const createHttpRequest = (options) => {
         });
         error.set(null);
         expiresIn.set(null);
+        attempts.set(1);
+        retryState.set(null);
         const stream = createStream();
         currentStreamSubscription = stream.subscribe({
             error: () => {
@@ -1414,6 +1641,9 @@ const createHttpRequest = (options) => {
     const destroy = () => {
         const wasActive = !currentStreamSubscription.closed;
         currentStreamSubscription.unsubscribe();
+        // A request destroyed mid-backoff never runs the attempt it was waiting for, so leaving the state
+        // set would keep a "retrying in …" readout counting down for a request that is gone.
+        retryState.set(null);
         event$.complete();
         return wasActive;
     };
@@ -1504,6 +1734,7 @@ const createHttpRequest = (options) => {
     const httpRequest = {
         method: options.method,
         url: options.fullPath,
+        args: args ?? null,
         execute,
         destroy,
         loading: loading.asReadonly(),
@@ -1518,6 +1749,9 @@ const createHttpRequest = (options) => {
             lastExternalResponseAt: lastExternalResponseAt.asReadonly(),
             applyPersistedResponse,
             lastPersistedResponseAt: lastPersistedResponseAt.asReadonly(),
+            resolveHeaders,
+            attempts: attempts.asReadonly(),
+            retryState: retryState.asReadonly(),
         },
     };
     return httpRequest;
@@ -1685,7 +1919,7 @@ const createQueryStack = (options) => {
             kind: 'query-stack',
             handle: stack,
             meta: {
-                featureTypes: features.map((f) => f.type),
+                features: describeQueryDevtoolsFeatures(features),
             },
         });
         inject(DestroyRef).onDestroy(unregister);
@@ -1974,7 +2208,7 @@ const createPagedQueryStack = (options) => {
             kind: 'paged-query-stack',
             handle: pagedQuery,
             meta: {
-                featureTypes: features?.map((f) => f.type),
+                features: describeQueryDevtoolsFeatures(features),
             },
         });
         inject(DestroyRef).onDestroy(unregister);
@@ -2732,13 +2966,21 @@ const createQuerySyncEngine = (options) => {
         // An invalidation is something the other tab's app code asked for explicitly, so unlike the
         // mutation heuristic it is not something `refreshOnMutation: false` opts out of.
         if (message.type === 'invalidate') {
-            repository.refreshInUse(createQueryInvalidationFilter({ url: message.url }));
+            repository.refreshInUse(createQueryInvalidationFilter({ url: message.url }), {
+                type: 'invalidation',
+                url: message.url,
+                otherTab: true,
+            });
             return;
         }
         if (!refreshOnMutation)
             return;
         const mutation = { method: message.method, url: message.url };
-        repository.refreshInUse(mutationFilter ? (request) => mutationFilter(mutation, request) : undefined);
+        repository.refreshInUse(mutationFilter ? (request) => mutationFilter(mutation, request) : undefined, {
+            type: 'mutation',
+            url: message.url,
+            otherTab: true,
+        });
     };
     const postInvalidation = (url) => transport.post({ type: 'invalidate', url });
     const eventSubscription = repository.events$.subscribe(broadcast);
@@ -2853,6 +3095,13 @@ const QueryClientFeatureType = {
     DEFAULT_RETRY: 'DEFAULT_RETRY',
     ETHLETE_API_ERRORS: 'ETHLETE_API_ERRORS',
 };
+const describeRefreshOnMutation = (config) => {
+    if (config === false)
+        return 'no';
+    if (config === true || config === undefined)
+        return 'every query in use';
+    return 'filtered';
+};
 /**
  * Coordinates a query client with its own instances in the user's **other tabs**, over a
  * `BroadcastChannel` and the Web Locks API. Three things happen once it is on:
@@ -2893,7 +3142,16 @@ const withMultiTabSync = (config) => ({ clientName, repository, destroyRef, isBr
         lockManager: createQueryKeyLockManager(`et-query-poll:${channelName}`),
     });
     destroyRef.onDestroy(sync.destroy);
-    return { type: QueryClientFeatureType.MULTI_TAB_SYNC, instance: sync };
+    return {
+        type: QueryClientFeatureType.MULTI_TAB_SYNC,
+        instance: sync,
+        devtools: () => [
+            { label: 'channel', value: channelName },
+            { label: 'share responses', value: syncConfig.syncResponses === false ? 'no' : 'yes' },
+            { label: 'dedupe polling', value: syncConfig.dedupePolling === false ? 'no' : 'yes' },
+            { label: 'refresh on mutation', value: describeRefreshOnMutation(syncConfig.refreshOnMutation) },
+        ],
+    };
 };
 /**
  * Keeps a query client's successful reads on disk (IndexedDB), so a reload renders the last known
@@ -2947,7 +3205,19 @@ const withQueryPersistence = (config) => ({ clientName, repository, destroyRef,
         window.removeEventListener('pagehide', flush);
         engine.destroy();
     });
-    return { type: QueryClientFeatureType.PERSISTENCE, instance: engine };
+    return {
+        type: QueryClientFeatureType.PERSISTENCE,
+        instance: engine,
+        devtools: () => [
+            { label: 'store', value: persistenceConfig.storageName ?? `et-query-persistence-${clientName}` },
+            { label: 'version', value: String(persistenceConfig.version ?? 1) },
+            { label: 'max age', value: formatQueryDevtoolsDuration(persistenceConfig.maxAge ?? 86_400_000) },
+            { label: 'max entries', value: String(persistenceConfig.maxEntries ?? 50) },
+            { label: 'write delay', value: formatQueryDevtoolsDuration(persistenceConfig.writeDelay ?? 1000) },
+            ...(persistenceConfig.adapter ? [{ label: 'adapter', value: 'custom' }] : []),
+            ...queryDevtoolsFnDetail(persistenceConfig.filter, 'filter'),
+        ],
+    };
 };
 /**
  * Teaches the error pipeline to read an **HTML error page** - the 502 a proxy answers with, a
@@ -3104,10 +3374,10 @@ const createQueryRepository = (config) => {
                     isPersistEnabled,
                     keepUnusedFor,
                 });
-                if (!runQueryOptions?.allowCache || cacheEntry.request.isStale()) {
-                    cacheEntry.request.execute({ allowCache: runQueryOptions?.allowCache });
-                }
-                return { key: cacheKey, request: cacheEntry.request };
+                const executed = !runQueryOptions?.allowCache || cacheEntry.request.isStale()
+                    ? cacheEntry.request.execute({ allowCache: runQueryOptions?.allowCache })
+                    : false;
+                return { key: cacheKey, request: cacheEntry.request, executed };
             }
         }
         const request = createHttpRequest({
@@ -3116,11 +3386,12 @@ const createQueryRepository = (config) => {
             method: options.method,
             dependencies: config.dependencies,
             clientOptions: creatorOptions,
+            clientName: config.name,
             clientHeaders: config.headers,
             cacheAdapter: config.cacheAdapter,
             retryFn: options.retryFn ?? config.retryFn,
         });
-        request.execute();
+        const executed = request.execute();
         bind({
             key: trackingKey,
             consumerDestroyRef: options.consumerDestroyRef,
@@ -3135,7 +3406,7 @@ const createQueryRepository = (config) => {
         // on it - hydration from the persisted store - is only ever allowed to fill a gap this request has
         // not filled itself.
         eventsSubject.next({ type: 'entry-created', key: trackingKey, isCached: shouldCache, isPersistEnabled });
-        return { key: trackingKey, request };
+        return { key: trackingKey, request, executed };
     };
     /** Tears an entry down for good, whether it currently has consumers or not. */
     const destroyEntry = (key, cacheEntry) => {
@@ -3198,7 +3469,8 @@ const createQueryRepository = (config) => {
         bumpCacheVersion();
         eventsSubject.next({ type: 'unbind-all-secure' });
     };
-    const refreshInUse = (filter) => {
+    const refreshInUse = (filter, cause) => {
+        const refreshed = [];
         for (const cacheEntry of cache.values()) {
             if (cacheEntry.consumers.size === 0)
                 continue;
@@ -3209,8 +3481,14 @@ const createQueryRepository = (config) => {
                 continue;
             if (filter && !filter(cacheEntry.request))
                 continue;
+            refreshed.push(cacheEntry.request);
             cacheEntry.request.execute({ force: true });
         }
+        eventsSubject.next({
+            type: 'queries-refreshed',
+            cause: cause ?? { type: 'refresh', url: null, otherTab: false },
+            requests: refreshed,
+        });
     };
     const applyExternalResponse = (options) => {
         const cacheEntry = cache.get(options.key);
@@ -3322,6 +3600,7 @@ const createQueryClient = (options) => defineRootProvider(() => {
     const destroyRef = inject(DestroyRef);
     let sync = null;
     let persistenceEngine = null;
+    const appliedFeatures = [];
     if (options.features?.length) {
         const seen = new Set();
         for (const featureFn of options.features) {
@@ -3329,6 +3608,7 @@ const createQueryClient = (options) => defineRootProvider(() => {
             if (seen.has(feature.type))
                 throw queryClientFeatureUsedMultipleTimes(feature.type);
             seen.add(feature.type);
+            appliedFeatures.push(feature);
             if (feature.type === QueryClientFeatureType.MULTI_TAB_SYNC) {
                 sync = feature.instance;
             }
@@ -3343,7 +3623,11 @@ const createQueryClient = (options) => defineRootProvider(() => {
         refreshQueriesInUse: () => repository.refreshInUse(),
         invalidateQueries: (invalidation) => {
             const url = invalidation?.url ? resolveInvalidationUrl(options.baseUrl, invalidation.url) : null;
-            repository.refreshInUse(createQueryInvalidationFilter({ url, filter: invalidation?.filter }));
+            repository.refreshInUse(createQueryInvalidationFilter({ url, filter: invalidation?.filter }), {
+                type: 'invalidation',
+                url,
+                otherTab: false,
+            });
             // The resolved URL is what travels: the other tabs are the same client, so they would
             // resolve it identically, and a message that needs no interpretation cannot drift.
             if (invalidation?.otherTabs ?? true)
@@ -3351,7 +3635,11 @@ const createQueryClient = (options) => defineRootProvider(() => {
         },
         clearPersistedQueries: () => persistenceEngine?.clear() ?? Promise.resolve(),
         whenPersistenceReady: persistenceEngine?.whenReady ?? Promise.resolve(),
-        subtle: { sync, persistence: persistenceEngine },
+        subtle: {
+            sync,
+            persistence: persistenceEngine,
+            devtoolsFeatures: isQueryDevtoolsEnabled() ? describeQueryDevtoolsFeatures(appliedFeatures) : [],
+        },
     };
     return client;
 }, {
@@ -3998,8 +4286,10 @@ const setupBearerQueryRegistry = (builders, injector, latestExecutedQuery, lates
 };
 const setupFeatures = (featureBuilders, context) => {
     const features = {};
+    /** The features as applied, in order - what the devtools describe. */
+    const applied = [];
     if (!featureBuilders?.length) {
-        return features;
+        return { features, applied };
     }
     const featureTypes = new Set();
     for (const featureSetup of featureBuilders) {
@@ -4014,9 +4304,25 @@ const setupFeatures = (featureBuilders, context) => {
             .map((word, index) => (index === 0 ? word : word.charAt(0).toUpperCase() + word.slice(1)))
             .join('');
         features[featureName] = feature.instance;
+        applied.push({ type: feature.type, devtools: feature.devtools });
     }
-    return features;
+    return { features, applied };
 };
+/**
+ * Describes the provider's queries for the devtools from what their creators were built with, so a
+ * refresh request can be exported before the refresh query has ever run.
+ */
+const describeAuthQueries = (builders) => builders.map((builder) => {
+    const internals = builder.config.queryCreator.subtle.creatorInternals;
+    const isRefresh = builder._type === 'tokenRefreshQuery';
+    return {
+        key: builder.key,
+        kind: (isRefresh ? 'token-refresh' : 'auth'),
+        method: internals.method ?? 'POST',
+        route: internals.route,
+        buildArgs: isRefresh ? builder.buildArgs : undefined,
+    };
+});
 const alwaysLeader = () => true;
 const runEarlyFeatureSetup = (featureBuilders, context) => {
     let isLeaderFn = alwaysLeader;
@@ -4110,7 +4416,7 @@ const createBearerAuthProviderImpl = (config) => {
         queries: queries,
         executionState,
     };
-    const features = setupFeatures(config.features, featureSetupContext);
+    const { features, applied: appliedFeatures } = setupFeatures(config.features, featureSetupContext);
     const provider = {
         queries,
         features: features,
@@ -4130,11 +4436,13 @@ const createBearerAuthProviderImpl = (config) => {
             kind: 'auth-provider',
             handle: provider,
             clientRef: config.queryClientRef,
+            authQueries: describeAuthQueries(config.queries),
             meta: {
                 name: config.name,
                 clientBaseUrl: queryClient.baseUrl,
                 repository: queryClient.repository,
                 client: queryClient,
+                features: describeQueryDevtoolsFeatures(appliedFeatures),
             },
         });
         destroyRef.onDestroy(unregister);
@@ -4177,6 +4485,7 @@ const withRefreshQuery = (key, config) => {
         const delay = Math.min(exponentialDelay, maxRetryDelayMs);
         return { retry: true, delay };
     };
+    const buildArgs = (refreshToken) => ({ body: { token: refreshToken } });
     const setup = (context) => {
         const expiresInPropertyName = config.expiresInPropertyName ?? 'exp';
         const minRefreshInterval = config.minRefreshInterval ?? 30000; // 30 seconds default
@@ -4192,9 +4501,8 @@ const withRefreshQuery = (key, config) => {
             if (timeSinceLastRefresh < minRefreshInterval)
                 return;
             lastRefreshTime = now;
-            const refreshArgs = { body: { token: currentRefreshToken } };
             // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-            context.queries[key].execute(refreshArgs, {
+            context.queries[key].execute(buildArgs(currentRefreshToken), {
                 triggeredBy: triggeredInternally ? 'token-refresh' : undefined,
             });
         };
@@ -4277,6 +4585,7 @@ const withRefreshQuery = (key, config) => {
             queryCreator: config.queryCreator.clone({ retryFn: refreshRetryFn, subtle: { useQueryRepositoryCache: true } }),
         },
         setup,
+        buildArgs,
     };
 };
 
@@ -4343,6 +4652,11 @@ const withInactivityLogout = (config = {}) => {
         return {
             type: BearerAuthFeatureType.INACTIVITY_LOGOUT,
             instance,
+            devtools: () => [
+                { label: 'timeout', value: formatQueryDevtoolsDuration(inactivityTimeout) },
+                { label: 'activity events', value: activityEvents.join(', ') },
+                ...(config.customActivityCheck ? [{ label: 'custom activity check', value: 'yes' }] : []),
+            ],
         };
     };
 };
@@ -4619,6 +4933,15 @@ const withBearerAuthMultiTabSync = (config = {}) => {
     const setup = (_context) => ({
         type: BearerAuthFeatureType.MULTI_TAB_SYNC,
         instance,
+        devtools: () => [
+            { label: 'channel', value: config.channelName ?? 'ethlete-auth-sync' },
+            { label: 'tokens', value: config.syncTokens === false ? 'tab local' : 'synced' },
+            { label: 'logout', value: config.syncLogout === false ? 'tab local' : 'synced' },
+            {
+                label: 'leader election',
+                value: config.leaderElection === false ? 'every tab refreshes' : 'one tab refreshes',
+            },
+        ],
     });
     // The elected leader gates the auth queries' automatic refresh, which is wired up before the
     // regular feature setup runs - so this half has to happen earlier than `setup`.
@@ -4639,6 +4962,16 @@ const withPersistentAuth = (config) => {
         return {
             type: BearerAuthFeatureType.PERSISTENT_AUTH,
             instance,
+            devtools: () => [
+                { label: 'cookie', value: config.cookie?.name ?? 'etAuth' },
+                { label: 'remembered for', value: `${config.cookie?.expiresInDays ?? 30}d` },
+                { label: 'same site', value: config.cookie?.sameSite ?? 'lax' },
+                { label: 'remember me default', value: config.defaultRememberMe ? 'yes' : 'no' },
+                { label: 'auto login', value: config.autoLogin.queryKey },
+                ...(config.autoLogin.excludeRoutes?.length
+                    ? [{ label: 'excluded routes', value: config.autoLogin.excludeRoutes.join(', ') }]
+                    : []),
+            ],
         };
     };
 };
@@ -4745,6 +5078,10 @@ const withTokenExpirationWarning = (config = {}) => {
         return {
             type: BearerAuthFeatureType.TOKEN_EXPIRATION_WARNING,
             instance,
+            devtools: () => [
+                { label: 'warn before', value: formatQueryDevtoolsDuration(warningThreshold) },
+                { label: 'check every', value: formatQueryDevtoolsDuration(checkInterval) },
+            ],
         };
     };
 };
@@ -4799,6 +5136,10 @@ const withTokenRevocation = (config) => {
         return {
             type: BearerAuthFeatureType.TOKEN_REVOCATION,
             instance,
+            devtools: () => [
+                { label: 'query', value: config.queryKey },
+                { label: 'on logout', value: revokeOnLogout ? 'yes' : 'no' },
+            ],
         };
     };
 };
@@ -4806,9 +5147,14 @@ const withTokenRevocation = (config) => {
 const withTracking = (config) => {
     return (context) => {
         const instance = createTrackingFeature(context, config);
+        const handledEvents = Object.keys(config?.on ?? {});
         return {
             type: BearerAuthFeatureType.TRACKING,
             instance,
+            devtools: () => [
+                { label: 'internal events', value: config?.trackInternalEvents === false ? 'ignored' : 'tracked' },
+                ...(handledEvents.length ? [{ label: 'handlers', value: handledEvents.join(', ') }] : []),
+            ],
         };
     };
 };
@@ -4945,6 +5291,347 @@ const createTrackingFeature = (context, config) => {
     };
 };
 
+/** 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 EMPTY_STATS = {
+    executions: 0,
+    requests: 0,
+    responses: 0,
+    errors: 0,
+    retries: 0,
+    receivedBytes: 0,
+    sentBytes: 0,
+    hasEstimatedBytes: false,
+    firstExecutedAt: null,
+    lastResponseAt: null,
+    lastDurationMs: null,
+    totalDurationMs: 0,
+};
+const textEncoder = typeof TextEncoder === 'function' ? /* @__PURE__ */ new TextEncoder() : null;
+const byteLengthOf = (text) => textEncoder?.encode(text).length ?? text.length;
+const estimateBodySize = (body) => {
+    if (body === null || body === undefined)
+        return 0;
+    if (typeof body === 'string')
+        return byteLengthOf(body);
+    if (typeof Blob !== 'undefined' && body instanceof Blob)
+        return body.size;
+    if (body instanceof ArrayBuffer)
+        return body.byteLength;
+    if (ArrayBuffer.isView(body))
+        return body.byteLength;
+    if (typeof FormData !== 'undefined' && body instanceof FormData)
+        return 0;
+    try {
+        return byteLengthOf(JSON.stringify(body) ?? '');
+    }
+    catch {
+        // A body holding a circular reference or a BigInt has no serialized size to report.
+        return 0;
+    }
+};
+/** How many runs a query keeps. Enough to see a stampede or a chain without growing unbounded. */
+const RUN_HISTORY = 25;
+/**
+ * How many of those runs keep their response body. Bodies dominate what the buffer retains, and a diff
+ * only ever looks a couple of runs back.
+ */
+const RESPONSE_HISTORY = 5;
+/** The index of the newest run still in flight, or -1 when none is. */
+const lastPendingRunIndex = (runs) => {
+    for (let index = runs.length - 1; index >= 0; index--) {
+        if (runs[index]?.status === 'pending')
+            return index;
+    }
+    return -1;
+};
+/**
+ * Drops the response body of every run past the newest {@link RESPONSE_HISTORY} that hold one. Mutates
+ * the array it is given, which is always one this module just built.
+ */
+const trimRetainedResponses = (runs) => {
+    let kept = 0;
+    for (let index = runs.length - 1; index >= 0; index--) {
+        const run = runs[index];
+        if (!run?.hasResponse)
+            continue;
+        if (++kept > RESPONSE_HISTORY)
+            runs[index] = { ...run, response: null, hasResponse: false };
+    }
+    return runs;
+};
+/**
+ * The size of a payload in bytes, and whether that size is the one that went over the wire. Only a
+ * `content-length` header is exact; everything else is measured by serializing the body.
+ * @internal
+ */
+const measureQueryDevtoolsPayload = (payload) => {
+    const contentLength = Number(payload.headers?.get('content-length'));
+    if (Number.isFinite(contentLength) && contentLength > 0)
+        return { bytes: contentLength, isExact: true };
+    return { bytes: estimateBodySize(payload.body), isExact: false };
+};
+/**
+ * Accumulates what a query does, for the devtools panel. Only ever created while
+ * {@link provideQueryDevtools} is installed - measuring a body's size serializes it, which no app
+ * without devtools should pay for.
+ * @internal
+ */
+const createQueryDevtoolsStats = () => {
+    const stats = signal(EMPTY_STATS, /* @ts-ignore */
+    ...(ngDevMode ? [{ debugName: "stats" }] : /* istanbul ignore next */ []));
+    const runs = signal([], /* @ts-ignore */
+    ...(ngDevMode ? [{ debugName: "runs" }] : /* istanbul ignore next */ []));
+    // The baseline the next response's duration is measured against. Deliberately not part of the stats:
+    // a duration is only ever reported once the response it belongs to has arrived.
+    let lastExecutionAt = null;
+    // The URL of the last execution, whether or not it requested - so a response that arrives without a run
+    // of the query's own is still attributed to the URL the query was pointed at.
+    let lastUrl = null;
+    let runCounter = 0;
+    const appendRun = (run, previous) => {
+        const appended = { ...run, index: ++runCounter };
+        runs.set(trimRetainedResponses([...previous, appended].slice(-RUN_HISTORY)));
+    };
+    /**
+     * Ends the newest run still in flight. A response with no run of the query's own waiting for it came
+     * from elsewhere (see {@link QueryDevtoolsRun.didRequest}), so it is recorded as an instant instead.
+     */
+    const endRun = (end) => {
+        const current = runs();
+        const pending = lastPendingRunIndex(current);
+        if (pending === -1) {
+            appendRun({ ...end, startedAt: end.endedAt, didRequest: false, url: lastUrl, sentBytes: 0, attempts: 0 }, current);
+            return;
+        }
+        runs.set(trimRetainedResponses(current.map((run, index) => (index === pending ? { ...run, ...end } : run))));
+    };
+    const recordExecution = ({ didRequest, body, url }) => {
+        const now = Date.now();
+        const sent = didRequest ? measureQueryDevtoolsPayload({ body }) : null;
+        lastExecutionAt = now;
+        lastUrl = url ?? null;
+        stats.update((current) => ({
+            ...current,
+            executions: current.executions + 1,
+            requests: current.requests + (didRequest ? 1 : 0),
+            sentBytes: current.sentBytes + (sent?.bytes ?? 0),
+            hasEstimatedBytes: current.hasEstimatedBytes || (!!sent?.bytes && !sent.isExact),
+            firstExecutedAt: current.firstExecutedAt ?? now,
+        }));
+        // An execution answered from the cache, or one that joined a request already in flight, starts no
+        // run of its own - the response it eventually gets (if any) is what records one.
+        if (!didRequest)
+            return;
+        appendRun({
+            startedAt: now,
+            endedAt: null,
+            status: 'pending',
+            didRequest: true,
+            url: lastUrl,
+            attempts: 1,
+            sentBytes: sent?.bytes ?? 0,
+            receivedBytes: 0,
+            response: null,
+            hasResponse: false,
+        }, runs().map((run) => (run.status === 'pending' ? { ...run, status: 'aborted', endedAt: now } : run)));
+    };
+    const recordResponse = (payload) => {
+        const now = Date.now();
+        const received = measureQueryDevtoolsPayload(payload);
+        const duration = lastExecutionAt === null ? null : now - lastExecutionAt;
+        stats.update((current) => ({
+            ...current,
+            responses: current.responses + 1,
+            receivedBytes: current.receivedBytes + received.bytes,
+            hasEstimatedBytes: current.hasEstimatedBytes || (received.bytes > 0 && !received.isExact),
+            lastResponseAt: now,
+            lastDurationMs: duration,
+            totalDurationMs: current.totalDurationMs + (duration ?? 0),
+        }));
+        endRun({
+            endedAt: now,
+            status: 'success',
+            receivedBytes: received.bytes,
+            response: payload.body,
+            hasResponse: true,
+        });
+    };
+    const recordError = () => {
+        stats.update((current) => ({ ...current, errors: current.errors + 1 }));
+        endRun({ endedAt: Date.now(), status: 'error', receivedBytes: 0, response: null, hasResponse: false });
+    };
+    const recordRetry = ({ attempt }) => {
+        const current = runs();
+        const pending = lastPendingRunIndex(current);
+        const run = current[pending];
+        // Nothing in flight means the retry belongs to a request this query is not the one waiting on, and an
+        // attempt already accounted for is the caller reporting the same one twice.
+        if (!run || attempt <= run.attempts)
+            return;
+        stats.update((state) => ({ ...state, retries: state.retries + (attempt - run.attempts) }));
+        runs.set(current.map((entry, index) => (index === pending ? { ...entry, attempts: attempt } : entry)));
+    };
+    const reset = () => {
+        lastExecutionAt = null;
+        lastUrl = null;
+        runCounter = 0;
+        stats.set(EMPTY_STATS);
+        runs.set([]);
+    };
+    return {
+        current: stats.asReadonly(),
+        runs: runs.asReadonly(),
+        reset,
+        recordExecution,
+        recordResponse,
+        recordError,
+        recordRetry,
+    };
+};
+/**
+ * Adds up the stats of several entries, for a stack's or a client's total. `lastDurationMs` is taken from
+ * whichever entry responded most recently rather than summed.
+ */
+const sumQueryDevtoolsStats = (handles) => {
+    const total = { ...EMPTY_STATS };
+    for (const handle of handles) {
+        if (!handle)
+            continue;
+        const stats = handle.current();
+        total.executions += stats.executions;
+        total.requests += stats.requests;
+        total.responses += stats.responses;
+        total.errors += stats.errors;
+        total.retries += stats.retries;
+        total.receivedBytes += stats.receivedBytes;
+        total.sentBytes += stats.sentBytes;
+        total.totalDurationMs += stats.totalDurationMs;
+        total.hasEstimatedBytes = total.hasEstimatedBytes || stats.hasEstimatedBytes;
+        if (stats.firstExecutedAt !== null &&
+            (total.firstExecutedAt === null || stats.firstExecutedAt < total.firstExecutedAt)) {
+            total.firstExecutedAt = stats.firstExecutedAt;
+        }
+        if (stats.lastResponseAt !== null &&
+            (total.lastResponseAt === null || stats.lastResponseAt > total.lastResponseAt)) {
+            total.lastResponseAt = stats.lastResponseAt;
+            total.lastDurationMs = stats.lastDurationMs;
+        }
+    }
+    return total;
+};
+
 const entries = /* @__PURE__ */ signal([], /* @ts-ignore */
 ...(ngDevMode ? [{ debugName: "entries" }] : /* istanbul ignore next */ []));
 /**
@@ -4963,26 +5650,49 @@ const descriptorOf = (entry) => {
         return `auth-provider|${meta.name ?? ''}`;
     if (kind === 'ws-client')
         return `ws-client|${meta.name ?? ''}`;
+    if (kind === 'query-form')
+        return `query-form|${meta.name ?? ''}`;
     return kind;
 };
 /**
- * Stringifies a query creator route. Function routes are invoked with an empty args object and any
- * resulting `undefined` path segments are rendered as `:param`, matching the legacy devtools.
+ * Wraps a path param name where a route function interpolated it. A NUL cannot occur in a route, so
+ * a marked-up route stays unambiguously parseable.
+ */
+const PARAM_MARKER = '\u0000';
+/**
+ * Stands in for the path params object a route function expects, recording every param it reads as
+ * `\0<name>\0` in the returned route. A route that transforms what it reads (`p.id.slice(2)`) still
+ * yields a usable route - the recorded name is transformed along with it.
+ */
+const paramRecorder = () => new Proxy({}, {
+    get: (_, prop) => (typeof prop === 'string' ? `${PARAM_MARKER}${prop}${PARAM_MARKER}` : undefined),
+});
+/** Splits a recorded route into its literal chunks and the path params interleaved between them. */
+const parseRecordedRoute = (recorded) => recorded
+    .split(PARAM_MARKER)
+    // Markers are balanced, so every odd chunk is a param name and every even one is literal text.
+    .map((text, index) => ({ text, param: index % 2 === 1 ? text : null }))
+    .filter((part) => part.text !== '');
+/**
+ * Parses a query creator route into its literal and path-param parts, so the devtools can show which
+ * segments of a route are dynamic and fill them in with the values a query actually used.
  * @internal
  */
-const stringifyQueryRoute = (route) => {
+const parseQueryRoute = (route) => {
     if (route === undefined || route === null)
-        return '';
+        return [];
     try {
         if (typeof route === 'function') {
-            return route({}).replace(/undefined/g, ':param');
+            return parseRecordedRoute(route(paramRecorder()));
         }
-        return String(route);
+        return [{ text: String(route), param: null }];
     }
     catch {
-        return typeof route === 'function' ? '(dynamic route)' : String(route);
+        return [{ text: typeof route === 'function' ? '(dynamic route)' : String(route), param: null }];
     }
 };
+/** Renders parsed route parts as a template, e.g. `/team/:teamId/players`. */
+const stringifyQueryRouteParts = (parts) => parts.map((part) => (part.param ? `:${part.param}` : part.text)).join('');
 /**
  * Extracts the human readable client name from a query client tuple. The client's DI token is named
  * `QueryClient_<name>`, so we strip the prefix to recover the original name.
@@ -4993,16 +5703,37 @@ const getQueryClientName = (client) => {
     const desc = token?.toString?.() ?? '';
     return desc.replace('InjectionToken ', '').replace('QueryClient_', '') || 'unknown';
 };
+/**
+ * The provider name behind a bearer auth provider definition, recovered from its DI token the way
+ * {@link getQueryClientName} recovers a client's.
+ * @internal
+ */
+const getBearerAuthProviderName = (ref) => {
+    const desc = String(ref.token ?? '');
+    return desc.replace('InjectionToken ', '').replace('BearerAuthProvider_', '') || 'unknown';
+};
 /**
  * Ids are derived deterministically from a stable descriptor + a per-descriptor sequence number, so
  * they survive a page reload (letting the UI restore the selected entry) instead of being random.
  */
 const registerEntry = (registration) => {
     const meta = { ...registration.meta };
-    if (registration.route !== undefined)
-        meta.route = stringifyQueryRoute(registration.route);
+    if (registration.route !== undefined) {
+        meta.routeParts = parseQueryRoute(registration.route);
+        meta.route = stringifyQueryRouteParts(meta.routeParts);
+    }
     if (registration.clientRef)
         meta.clientName = getQueryClientName(registration.clientRef);
+    if (registration.authProviderRef) {
+        meta.isSecure = true;
+        meta.authProviderName = getBearerAuthProviderName(registration.authProviderRef);
+    }
+    if (registration.authQueries) {
+        meta.authQueries = registration.authQueries.map((authQuery) => ({
+            ...authQuery,
+            route: stringifyQueryRouteParts(parseQueryRoute(authQuery.route)),
+        }));
+    }
     let id = registration.id;
     if (!id) {
         const descriptor = descriptorOf({ kind: registration.kind, meta });
@@ -5016,6 +5747,8 @@ const registerEntry = (registration) => {
         handle: registration.handle,
         meta,
         createdAt: Date.now(),
+        stats: registration.stats,
+        formLinks: registration.formLinks,
     };
     entries.update((list) => [...list, fullEntry]);
     return () => entries.update((list) => list.filter((e) => e.id !== fullEntry.id));
@@ -5037,6 +5770,9 @@ const registerEntry = (registration) => {
  */
 const provideQueryDevtools = () => {
     setQueryDevtoolsRegistrar(registerEntry);
+    setQueryDevtoolsStatsFactory(createQueryDevtoolsStats);
+    setQueryDevtoolsFormLinksFactory(createQueryDevtoolsFormLinks);
+    setQueryDevtoolsFaultResolver(resolveQueryDevtoolsFaultForAttempt);
     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.');
     }
@@ -5246,6 +5982,9 @@ const createGqlMutationViaPost = /* @__PURE__ */ createGqlCreatorTemplate('MUTAT
 /** A query creator that creates a secure GQL mutation where the payload is sent via POST (body) */
 const createSecureGqlMutationViaPost = /* @__PURE__ */ createSecureGqlCreatorTemplate('MUTATE', 'POST');
 
+/**
+ * @deprecated Part of the legacy (v2) query system. Migrate to the current query API - see https://ethlete-sdk-docs.web.app/query/migrating-from-v2, and run `nx g @ethlete/query:migrate-to-query-v3` to rewrite the mechanical parts. Intent to remove in v7.
+ */
 class CustomHeaderAuthProvider {
     constructor(_config) {
         this._config = _config;
@@ -5258,6 +5997,9 @@ class CustomHeaderAuthProvider {
     }
 }
 
+/**
+ * @deprecated Part of the legacy (v2) query system. Migrate to the current query API - see https://ethlete-sdk-docs.web.app/query/migrating-from-v2, and run `nx g @ethlete/query:migrate-to-query-v3` to rewrite the mechanical parts. Intent to remove in v7.
+ */
 class BasicAuthProvider {
     constructor(_config) {
         this._config = _config;
@@ -5273,7 +6015,13 @@ class BasicAuthProvider {
     }
 }
 
+/**
+ * @deprecated Part of the legacy (v2) query system. Migrate to the current query API - see https://ethlete-sdk-docs.web.app/query/migrating-from-v2, and run `nx g @ethlete/query:migrate-to-query-v3` to rewrite the mechanical parts. Intent to remove in v7.
+ */
 const isRequestError = (error) => error instanceof Object && 'status' in error && 'statusText' in error && 'url' in error;
+/**
+ * @deprecated Part of the legacy (v2) query system. Migrate to the current query API - see https://ethlete-sdk-docs.web.app/query/migrating-from-v2, and run `nx g @ethlete/query:migrate-to-query-v3` to rewrite the mechanical parts. Intent to remove in v7.
+ */
 const v2ExtractExpiresInSeconds = (headers) => {
     const cacheControl = headers['cache-control'];
     const age = headers['age'];
@@ -5319,6 +6067,9 @@ const v2ExtractExpiresInSeconds = (headers) => {
     }
     return expiresIn;
 };
+/**
+ * @deprecated Part of the legacy (v2) query system. Migrate to the current query API - see https://ethlete-sdk-docs.web.app/query/migrating-from-v2, and run `nx g @ethlete/query:migrate-to-query-v3` to rewrite the mechanical parts. Intent to remove in v7.
+ */
 const serializeBody = (body) => {
     if (body === null || body === undefined) {
         return null;
@@ -5336,6 +6087,9 @@ const serializeBody = (body) => {
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
     return body.toString();
 };
+/**
+ * @deprecated Part of the legacy (v2) query system. Migrate to the current query API - see https://ethlete-sdk-docs.web.app/query/migrating-from-v2, and run `nx g @ethlete/query:migrate-to-query-v3` to rewrite the mechanical parts. Intent to remove in v7.
+ */
 const transformMethod = (config) => {
     if (config.method === 'GQL_QUERY' || config.method === 'GQL_MUTATE') {
         if (!config.transferVia) {
@@ -5345,6 +6099,9 @@ const transformMethod = (config) => {
     }
     return config.method;
 };
+/**
+ * @deprecated Part of the legacy (v2) query system. Migrate to the current query API - see https://ethlete-sdk-docs.web.app/query/migrating-from-v2, and run `nx g @ethlete/query:migrate-to-query-v3` to rewrite the mechanical parts. Intent to remove in v7.
+ */
 const detectContentTypeHeader = (body) => {
     // An empty body has no content type.
     if (body === null) {
@@ -5375,14 +6132,23 @@ const detectContentTypeHeader = (body) => {
     // No type could be inferred.
     return null;
 };
+/**
+ * @deprecated Part of the legacy (v2) query system. Migrate to the current query API - see https://ethlete-sdk-docs.web.app/query/migrating-from-v2, and run `nx g @ethlete/query:migrate-to-query-v3` to rewrite the mechanical parts. Intent to remove in v7.
+ */
 const hasHeader = (headers, header) => {
     return Object.keys(headers).some((key) => key.toLowerCase() === header.toLowerCase());
 };
+/**
+ * @deprecated Part of the legacy (v2) query system. Migrate to the current query API - see https://ethlete-sdk-docs.web.app/query/migrating-from-v2, and run `nx g @ethlete/query:migrate-to-query-v3` to rewrite the mechanical parts. Intent to remove in v7.
+ */
 const forEachHeader = (headers, callback) => {
     Object.entries(headers).forEach(([key, value]) => {
         callback(key, value);
     });
 };
+/**
+ * @deprecated Part of the legacy (v2) query system. Migrate to the current query API - see https://ethlete-sdk-docs.web.app/query/migrating-from-v2, and run `nx g @ethlete/query:migrate-to-query-v3` to rewrite the mechanical parts. Intent to remove in v7.
+ */
 const parseAllXhrResponseHeaders = (xhr) => {
     const headers = xhr.getAllResponseHeaders();
     const parsedHeaders = {};
@@ -5397,6 +6163,9 @@ const parseAllXhrResponseHeaders = (xhr) => {
     }
     return parsedHeaders;
 };
+/**
+ * @deprecated Part of the legacy (v2) query system. Migrate to the current query API - see https://ethlete-sdk-docs.web.app/query/migrating-from-v2, and run `nx g @ethlete/query:migrate-to-query-v3` to rewrite the mechanical parts. Intent to remove in v7.
+ */
 const getResponseUrl = (xhr) => {
     if ('responseURL' in xhr && xhr.responseURL) {
         return xhr.responseURL;
@@ -5406,6 +6175,9 @@ const getResponseUrl = (xhr) => {
     }
     return null;
 };
+/**
+ * @deprecated Part of the legacy (v2) query system. Migrate to the current query API - see https://ethlete-sdk-docs.web.app/query/migrating-from-v2, and run `nx g @ethlete/query:migrate-to-query-v3` to rewrite the mechanical parts. Intent to remove in v7.
+ */
 const v2ShouldRetryRequest = (config) => {
     const defaultRetryDelay = 1000 + 1000 * config.currentRetryCount;
     if (config.currentRetryCount > 3) {
@@ -5448,6 +6220,9 @@ const v2ShouldRetryRequest = (config) => {
 };
 
 const XSSI_PREFIX = /^\)\]\}',?\n/;
+/**
+ * @deprecated Part of the legacy (v2) query system. Migrate to the current query API - see https://ethlete-sdk-docs.web.app/query/migrating-from-v2, and run `nx g @ethlete/query:migrate-to-query-v3` to rewrite the mechanical parts. Intent to remove in v7.
+ */
 const request = (config) => {
     const headers = config.headers || {};
     const responseType = config.responseType || 'json';
@@ -5653,11 +6428,16 @@ const request = (config) => {
     });
 };
 
+/**
+ * @deprecated Part of the legacy (v2) query system. Migrate to the current query API - see https://ethlete-sdk-docs.web.app/query/migrating-from-v2, and run `nx g @ethlete/query:migrate-to-query-v3` to rewrite the mechanical parts. Intent to remove in v7.
+ */
 const addQueryContainerHandling = (obs, valueFn, config) => {
-    assertInInjectionContext(addQueryContainerHandling);
+    if (!config?.injector) {
+        assertInInjectionContext(addQueryContainerHandling);
+    }
     const { abortPrevious, abortOnDestroy, stopPreviousPolling } = config ?? {};
-    const injector = inject(Injector);
-    const destroy$ = createDestroy();
+    const injector = config?.injector ?? inject(Injector);
+    const destroy$ = runInInjectionContext(injector, () => createDestroy());
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
     const tNode = injector._tNode;
     const componentId = tNode?.index ?? -1;
@@ -5722,12 +6502,18 @@ const addQueryContainerHandling = (obs, valueFn, config) => {
         }
     });
 };
+/**
+ * @deprecated Part of the legacy (v2) query system. Migrate to the current query API - see https://ethlete-sdk-docs.web.app/query/migrating-from-v2, and run `nx g @ethlete/query:migrate-to-query-v3` to rewrite the mechanical parts. Intent to remove in v7.
+ */
 function toQuerySignal(source, options) {
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
     const s = toSignal(source, options);
     addQueryContainerHandling(source, () => s(), options);
     return s;
 }
+/**
+ * @deprecated Part of the legacy (v2) query system. Migrate to the current query API - see https://ethlete-sdk-docs.web.app/query/migrating-from-v2, and run `nx g @ethlete/query:migrate-to-query-v3` to rewrite the mechanical parts. Intent to remove in v7.
+ */
 function effectComputed(computation, injector) {
     let initialData = null;
     try {
@@ -5746,11 +6532,14 @@ function effectComputed(computation, injector) {
                 return;
             lastResult.set(data);
         });
-    });
+    }, { injector });
     return lastResult.asReadonly();
 }
+/**
+ * @deprecated Part of the legacy (v2) query system. Migrate to the current query API - see https://ethlete-sdk-docs.web.app/query/migrating-from-v2, and run `nx g @ethlete/query:migrate-to-query-v3` to rewrite the mechanical parts. Intent to remove in v7.
+ */
 function queryComputed(computation, options) {
-    const injector = inject(Injector);
+    const injector = options?.injector ?? inject(Injector);
     const c = effectComputed(computation, injector);
     const obs = toObservable(c, options);
     addQueryContainerHandling(obs, () => c(), options);
@@ -5759,26 +6548,37 @@ function queryComputed(computation, options) {
 /**
  * Creates a signal that will only be reactive until the first query is created.
  * All subsequent changes inside the computation will be ignored.
+ *
+ * @deprecated Part of the legacy (v2) query system. Migrate to the current query API - see https://ethlete-sdk-docs.web.app/query/migrating-from-v2, and run `nx g @ethlete/query:migrate-to-query-v3` to rewrite the mechanical parts. Intent to remove in v7.
  */
 function queryComputedTillTruthy(computation, options) {
-    const injector = inject(Injector);
+    const injector = options?.injector ?? inject(Injector);
     const c = computedTillTruthy(effectComputed(computation, injector));
     const obs = toObservable(c, options);
     addQueryContainerHandling(obs, () => c(), options);
     return c;
 }
+/**
+ * @deprecated Part of the legacy (v2) query system. Migrate to the current query API - see https://ethlete-sdk-docs.web.app/query/migrating-from-v2, and run `nx g @ethlete/query:migrate-to-query-v3` to rewrite the mechanical parts. Intent to remove in v7.
+ */
 function queryArrayComputed(computation, options) {
-    const injector = inject(Injector);
+    const injector = options?.injector ?? inject(Injector);
     const c = effectComputed(computation, injector);
     const obs = toObservable(c, options);
     addQueryContainerHandling(obs, () => c(), options);
     return c;
 }
+/**
+ * @deprecated Part of the legacy (v2) query system. Migrate to the current query API - see https://ethlete-sdk-docs.web.app/query/migrating-from-v2, and run `nx g @ethlete/query:migrate-to-query-v3` to rewrite the mechanical parts. Intent to remove in v7.
+ */
 function toQuerySubject(source, options) {
     const obs = toObservable(source, options);
     addQueryContainerHandling(obs, () => source(), options);
     return obs;
 }
+/**
+ * @deprecated Part of the legacy (v2) query system. Migrate to the current query API - see https://ethlete-sdk-docs.web.app/query/migrating-from-v2, and run `nx g @ethlete/query:migrate-to-query-v3` to rewrite the mechanical parts. Intent to remove in v7.
+ */
 function queryStateSignal(source, options) {
     const { cacheResponse } = options ?? {};
     const roSignal = toSignal(toObservable(source).pipe(switchMap((q) => extractQuery(q)?.state$ ?? of(null)), switchMap((state) => {
@@ -5793,6 +6593,9 @@ function queryStateSignal(source, options) {
     ...(ngDevMode ? [{ debugName: "rwSignal" }] : /* istanbul ignore next */ []));
     return rwSignal;
 }
+/**
+ * @deprecated Part of the legacy (v2) query system. Migrate to the current query API - see https://ethlete-sdk-docs.web.app/query/migrating-from-v2, and run `nx g @ethlete/query:migrate-to-query-v3` to rewrite the mechanical parts. Intent to remove in v7.
+ */
 function queryStateResponseSignal(source, options) {
     const s = queryStateSignal(source, options);
     const dataSignal = computed(() => {
@@ -5805,6 +6608,9 @@ function queryStateResponseSignal(source, options) {
     };
     return dataSignal;
 }
+/**
+ * @deprecated Part of the legacy (v2) query system. Migrate to the current query API - see https://ethlete-sdk-docs.web.app/query/migrating-from-v2, and run `nx g @ethlete/query:migrate-to-query-v3` to rewrite the mechanical parts. Intent to remove in v7.
+ */
 function queryStateErrorSignal(source) {
     const s = queryStateSignal(source);
     return computed(() => {
@@ -5812,6 +6618,9 @@ function queryStateErrorSignal(source) {
         return isQueryStateFailure(state) ? state.error : null;
     });
 }
+/**
+ * @deprecated Part of the legacy (v2) query system. Migrate to the current query API - see https://ethlete-sdk-docs.web.app/query/migrating-from-v2, and run `nx g @ethlete/query:migrate-to-query-v3` to rewrite the mechanical parts. Intent to remove in v7.
+ */
 function queryStateLoadingSignal(source) {
     const s = queryStateSignal(source);
     return computed(() => {
@@ -5820,6 +6629,9 @@ function queryStateLoadingSignal(source) {
     });
 }
 
+/**
+ * @deprecated Part of the legacy (v2) query system. Migrate to the current query API - see https://ethlete-sdk-docs.web.app/query/migrating-from-v2, and run `nx g @ethlete/query:migrate-to-query-v3` to rewrite the mechanical parts. Intent to remove in v7.
+ */
 const deepFreeze = (object) => {
     // check if object is actually an object or frozen
     if (!object || typeof object !== 'object' || Object.isFrozen(object)) {
@@ -5842,9 +6654,14 @@ const deepFreeze = (object) => {
  * **This function always returns null.**
  * @see https://github.com/microsoft/TypeScript/issues/26242
  * @returns null
+ *
+ * @deprecated Part of the legacy (v2) query system. Migrate to the current query API - see https://ethlete-sdk-docs.web.app/query/migrating-from-v2, and run `nx g @ethlete/query:migrate-to-query-v3` to rewrite the mechanical parts. Intent to remove in v7.
  */
 const def = () => null;
 
+/**
+ * @deprecated Part of the legacy (v2) query system. Migrate to the current query API - see https://ethlete-sdk-docs.web.app/query/migrating-from-v2, and run `nx g @ethlete/query:migrate-to-query-v3` to rewrite the mechanical parts. Intent to remove in v7.
+ */
 class V2QueryCreator {
     constructor(_queryConfig, _client, _store) {
         this._queryConfig = _queryConfig;
@@ -5891,6 +6708,9 @@ class V2QueryCreator {
     }
 }
 
+/**
+ * @deprecated Part of the legacy (v2) query system. Migrate to the current query API - see https://ethlete-sdk-docs.web.app/query/migrating-from-v2, and run `nx g @ethlete/query:migrate-to-query-v3` to rewrite the mechanical parts. Intent to remove in v7.
+ */
 class QueryStore {
     constructor(_config) {
         this._config = _config;
@@ -6034,6 +6854,9 @@ class QueryStore {
     }
 }
 
+/**
+ * @deprecated Part of the legacy (v2) query system. Migrate to the current query API - see https://ethlete-sdk-docs.web.app/query/migrating-from-v2, and run `nx g @ethlete/query:migrate-to-query-v3` to rewrite the mechanical parts. Intent to remove in v7.
+ */
 class V2QueryClient {
     constructor(_clientConfig) {
         this._clientConfig = _clientConfig;
@@ -6111,9 +6934,15 @@ class V2QueryClient {
     }
 }
 
+/**
+ * @deprecated Part of the legacy (v2) query system. Migrate to the current query API - see https://ethlete-sdk-docs.web.app/query/migrating-from-v2, and run `nx g @ethlete/query:migrate-to-query-v3` to rewrite the mechanical parts. Intent to remove in v7.
+ */
 const v2ShouldCacheQuery = (method) => {
     return method === 'GET' || method === 'OPTIONS' || method === 'HEAD' || method === 'GQL_QUERY';
 };
+/**
+ * @deprecated Part of the legacy (v2) query system. Migrate to the current query API - see https://ethlete-sdk-docs.web.app/query/migrating-from-v2, and run `nx g @ethlete/query:migrate-to-query-v3` to rewrite the mechanical parts. Intent to remove in v7.
+ */
 const v2BuildQueryCacheKey = (route, args) => {
     const variables = JSON.stringify(args?.variables || {})
         // replace all curly braces with empty string
@@ -6131,6 +6960,64 @@ const v2BuildQueryCacheKey = (route, args) => {
     return hash.toString();
 };
 
+let fallbackInjector = null;
+/**
+ * The stashed root injector, or `null` when the fallback was never provided (or was provided on the
+ * server, where stashing is refused).
+ *
+ * @internal
+ */
+const legacyPrepareFallbackInjector = () => fallbackInjector;
+/**
+ * Lets `prepare()` fall back to the application's root injector when it is called outside any injection
+ * context, instead of throwing `ET950`.
+ *
+ * Opt-in, and **browser only**. Two things degrade when the fallback is used, both matching v2, which had
+ * no injector to scope to at all:
+ *
+ * - **The query's lifetime becomes the application's.** Nothing tears it down when a component dies, so
+ *   cleanup rests entirely on a query container or `config: { destroyOnResponse: true }`.
+ * - **The devtools lose the host element**, so "inspect" cannot jump to the component. Already the case
+ *   for any query created from a root or environment injector.
+ *
+ * It refuses to stash anything on the server: a module-global injector would be shared across concurrent
+ * requests, which is data bleed rather than a leak. Server-side renders keep throwing `ET950`, so a call
+ * site that only works in the browser fails loudly where it matters.
+ *
+ * Prefer passing `injector` at the call site - it keeps the query scoped to whatever created it. Reach for
+ * this when a migration has too many call sites to thread by hand.
+ *
+ * @example
+ * ```ts
+ * bootstrapApplication(AppComponent, {
+ *   providers: [provideLegacyPrepareFallback()],
+ * });
+ * ```
+ *
+ * @deprecated Part of the legacy (v2) query system. Migrate to the current query API - see https://ethlete-sdk-docs.web.app/query/migrating-from-v2, and run `nx g @ethlete/query:migrate-to-query-v3` to rewrite the mechanical parts. Intent to remove in v7.
+ */
+const provideLegacyPrepareFallback = () => makeEnvironmentProviders([
+    provideEnvironmentInitializer(() => {
+        if (!isPlatformBrowser(inject(PLATFORM_ID))) {
+            if (isDevMode()) {
+                console.warn('provideLegacyPrepareFallback() does nothing on the server: a module-global injector would be shared ' +
+                    'between concurrent requests. prepare() calls without an injection context keep throwing ET950 there.');
+            }
+            return;
+        }
+        const injector = inject(EnvironmentInjector);
+        fallbackInjector = injector;
+        inject(DestroyRef).onDestroy(() => {
+            if (fallbackInjector === injector) {
+                fallbackInjector = null;
+            }
+        });
+    }),
+]);
+
+/**
+ * @deprecated Part of the legacy (v2) query system. Migrate to the current query API - see https://ethlete-sdk-docs.web.app/query/migrating-from-v2, and run `nx g @ethlete/query:migrate-to-query-v3` to rewrite the mechanical parts. Intent to remove in v7.
+ */
 const transformExecStateToQueryState = (execState) => {
     const meta = { id: -1, triggeredVia: 'program' };
     switch (execState?.type) {
@@ -6182,6 +7069,9 @@ const transformExecStateToQueryState = (execState) => {
         }
     }
 };
+/**
+ * @deprecated Part of the legacy (v2) query system. Migrate to the current query API - see https://ethlete-sdk-docs.web.app/query/migrating-from-v2, and run `nx g @ethlete/query:migrate-to-query-v3` to rewrite the mechanical parts. Intent to remove in v7.
+ */
 const isLegacyQuery = (query) => {
     if (!query || typeof query !== 'object' || Array.isArray(query)) {
         return false;
@@ -6191,6 +7081,9 @@ const isLegacyQuery = (query) => {
     }
     return true;
 };
+/**
+ * @deprecated Part of the legacy (v2) query system. Migrate to the current query API - see https://ethlete-sdk-docs.web.app/query/migrating-from-v2, and run `nx g @ethlete/query:migrate-to-query-v3` to rewrite the mechanical parts. Intent to remove in v7.
+ */
 class LegacyQuery {
     constructor(newQuery, _arguments, entity, 
     /**
@@ -6199,11 +7092,19 @@ class LegacyQuery {
      *
      * @internal
      */
-    _isInert = false) {
+    _isInert = false, 
+    /**
+     * Whether the underlying request is cacheable. Resolved by the creator, which is the only place that
+     * knows the method before the first execution.
+     *
+     * @internal
+     */
+    _canBeCached = false) {
         this.newQuery = newQuery;
         this._arguments = _arguments;
         this.entity = entity;
         this._isInert = _isInert;
+        this._canBeCached = _canBeCached;
         /**
          * @internal
          */
@@ -6238,17 +7139,22 @@ class LegacyQuery {
         }
         this.state$ = toObservable(this.newQuery.executionState, { injector: this.newQuery.subtle.injector }).pipe(map((execState) => transformExecStateToQueryState(execState)), switchMap((s) => this._transformState(s)), shareReplay({ bufferSize: 1, refCount: true }));
         this.storeSyncEffect = effect(() => {
-            const res = this.newQuery.response();
+            // Gated on the execution state, not on the response being non-null: the effect runs once on
+            // creation, and `response()` is null until the first one arrives - `id`/`set` are typed
+            // non-nullable, so an unguarded write feeds `null` through them on every `prepare()`. A plain
+            // null-check would be wrong the other way: a 204 is a success whose body is legitimately null.
+            const execState = this.newQuery.executionState();
             untracked(() => {
-                if (this.entity?.set) {
-                    const id = this.entity.id({ args: this._arguments, response: res });
-                    this.entity.set({
-                        args: this._arguments,
-                        response: res,
-                        id,
-                        store: this.entity.store,
-                    });
-                }
+                if (execState?.type !== 'success' || !this.entity?.set)
+                    return;
+                const res = execState.response;
+                const id = this.entity.id({ args: this._arguments, response: res });
+                this.entity.set({
+                    args: this._arguments,
+                    response: res,
+                    id,
+                    store: this.entity.store,
+                });
             });
         }, /* @ts-ignore */
         ...(ngDevMode ? [{ debugName: "storeSyncEffect" }] : /* istanbul ignore next */ []));
@@ -6292,7 +7198,7 @@ class LegacyQuery {
         return null;
     }
     get canBeCached() {
-        return false;
+        return this._canBeCached;
     }
     get _isInMockMode() {
         return false;
@@ -6484,32 +7390,61 @@ const isInjectorUsable = (injector) => {
         return false;
     }
 };
+/**
+ * Angular's NG0203, thrown by `inject()` outside an injection context. Matched on the code rather than
+ * the message: production builds strip the message, and NG0205 ("Injector has already been destroyed")
+ * comes out of the same `inject()` call for a different reason entirely.
+ */
+const isMissingInjectionContextError = (error) => typeof error === 'object' && error !== null && Math.abs(Number(error.code)) === 203;
+/**
+ * What the creator was built with, for diagnostics - `GET /person`. Lets an unnamed wrapper still point
+ * at an endpoint instead of "a legacy query creator". A route function cannot be described this way, but
+ * those wrappers come from the generator, which always emits a `name`.
+ */
+const describeCreator = (creator) => {
+    const { method, route } = creator.subtle.creatorInternals;
+    if (typeof route !== 'string')
+        return undefined;
+    return typeof method === 'string' ? `${method} ${route}` : route;
+};
+/**
+ * Mirrors the cacheability decision the query repository makes per request: cacheable HTTP methods and
+ * GraphQL queries, unless the creator opted in or out explicitly. The legacy container helpers branch on
+ * `canBeCached` for their default cleanup, so a wrapper has to answer before the first execution.
+ */
+const canCreatorBeCached = (creator) => {
+    const { method } = creator.subtle.creatorInternals;
+    const explicit = creator.subtle.creatorOptions?.subtle
+        ?.useQueryRepositoryCache;
+    if (explicit !== undefined)
+        return explicit;
+    if (method === 'QUERY')
+        return true;
+    if (method === 'MUTATE')
+        return false;
+    return typeof method === 'string' && shouldCacheQuery(method);
+};
+/**
+ * @deprecated Part of the legacy (v2) query system. Migrate to the current query API - see https://ethlete-sdk-docs.web.app/query/migrating-from-v2, and run `nx g @ethlete/query:migrate-to-query-v3` to rewrite the mechanical parts. Intent to remove in v7.
+ */
 class LegacyQueryCreator {
     constructor(options) {
         this.options = options;
         this.prepare = (args) => {
-            // v2's `prepare()` needed no injection context, so plenty of call sites are plain callbacks.
-            // Angular's raw NG0203 names neither the query nor the call site, which makes those a bisection
-            // exercise - replace it with an error that does.
-            const injector = args?.injector ??
-                (() => {
-                    try {
-                        return inject(Injector);
-                    }
-                    catch {
-                        throw legacyPrepareWithoutInjectionContext(this.options.name);
-                    }
-                })();
+            const injector = args?.injector ?? this.resolveAmbientInjector('prepare');
             let headers = new HttpHeaders();
             if (args?.headers) {
-                Object.entries(args.headers).forEach(([key, value]) => {
-                    if (value) {
-                        headers = headers.set(key, value);
-                    }
-                });
+                for (const [key, value] of Object.entries(args.headers)) {
+                    // Only an absent value is skipped - an empty string is a header the caller asked to send.
+                    if (value === undefined || value === null)
+                        continue;
+                    headers = headers.set(key, value);
+                }
             }
             const queryArgs = {
-                ...(args?.body ? { body: args.body } : {}),
+                // Presence, not truthiness: `0`, `''` and `false` are bodies, and dropping them silently sends a
+                // different request than the call site asked for.
+                ...(args?.body !== undefined ? { body: args.body } : {}),
                 ...(args?.pathParams ? { pathParams: args.pathParams } : {}),
                 ...(args?.queryParams ? { queryParams: args.queryParams } : {}),
                 headers,
@@ -6520,10 +7455,10 @@ class LegacyQueryCreator {
             // yields a query that does nothing instead of an NG0205 raised from the view's cleanup phase.
             if (!isInjectorUsable(injector)) {
                 if (isDevMode()) {
-                    console.warn(`${this.options.name ? `"${this.options.name}"` : 'A legacy query'}.prepare() was called with a destroyed injector, so an inert query was returned. ` +
+                    console.warn(`${this.label ? `"${this.label}"` : 'A legacy query'}.prepare() was called with a destroyed injector, so an inert query was returned. ` +
                         `This usually means a callback outlived the component whose injector it captured - guard the call site with DestroyRef.onDestroy, or pass an injector that outlives it.`);
                 }
-                return new LegacyQuery(createInertQuery(), queryArgs, this.options.entity, true);
+                return new LegacyQuery(createInertQuery(), queryArgs, this.options.entity, true, this.canBeCached);
             }
             return runInInjectionContext(injector, () => {
                 return untracked(() => {
@@ -6534,33 +7469,71 @@ class LegacyQueryCreator {
                         // `LegacyQuery.execute()` forwards v2's `skipCache` as `allowCache` for every method, cacheable or not.
                         silenceUncacheableAllowCacheError: true,
                     });
-                    const legacyQuery = new LegacyQuery(newQuery, queryArgs, this.options.entity);
+                    const legacyQuery = new LegacyQuery(newQuery, queryArgs, this.options.entity, false, this.canBeCached);
                     if (args?.config?.destroyOnResponse) {
-                        const destroyEffect = effect(() => {
-                            if (newQuery.executionState()?.type === 'success' || newQuery.executionState()?.type === 'failure') {
+                        // Owned by the query's own injector, not the caller's. Call sites are told to pass an injector
+                        // that outlives them, so they hand over a root or environment one - and an effect that only
+                        // tears itself down on a terminal state then outlives an aborted or never-executed query for
+                        // the lifetime of the app. Tied to the query, it dies with the thing it exists to destroy.
+                        effect(() => {
+                            const type = newQuery.executionState()?.type;
+                            if (type === 'success' || type === 'failure') {
                                 legacyQuery.destroy();
-                                destroyEffect.destroy();
                             }
-                        }, /* @ts-ignore */
-                        ...(ngDevMode ? [{ debugName: "destroyEffect" }] : /* istanbul ignore next */ []));
+                        }, { injector: newQuery.subtle.injector });
                     }
                     return legacyQuery;
                 });
             });
         };
         this.createSubject = (initialValue, config) => {
+            const injector = config?.injector ?? this.resolveAmbientInjector('createSubject');
             const subject = new BehaviorSubject(initialValue ?? null);
-            addQueryContainerHandling(subject, () => subject.getValue(), config);
+            addQueryContainerHandling(subject, () => subject.getValue(), { ...config, injector });
             return subject;
         };
         this.createSignal = (initialValue, config) => {
+            const injector = config?.injector ?? this.resolveAmbientInjector('createSignal');
             const _signal = signal(initialValue ?? null, /* @ts-ignore */
             ...(ngDevMode ? [{ debugName: "_signal" }] : /* istanbul ignore next */ []));
-            addQueryContainerHandling(toObservable(_signal), () => _signal(), config);
+            addQueryContainerHandling(toObservable(_signal, { injector }), () => _signal(), { ...config, injector });
             return _signal;
         };
         this.behaviorSubject = this.createSubject;
     }
+    /**
+     * Whether the underlying request is cacheable, which is what the legacy container helpers use to decide
+     * their default cleanup. Resolved from the creator, so it answers before the first execution.
+     */
+    get canBeCached() {
+        return canCreatorBeCached(this.options.creator);
+    }
+    get label() {
+        return this.options.name ?? describeCreator(this.options.creator);
+    }
+    /**
+     * v2 needed no injection context, so plenty of call sites are plain callbacks. Angular's raw NG0203
+     * names neither the query nor the call site, which makes those a bisection exercise - replace it with
+     * an error that does, and let every other DI failure (NG0205 from an injector mid-teardown, a missing
+     * provider) through untouched.
+     */
+    resolveAmbientInjector(method) {
+        try {
+            return inject(Injector);
+        }
+        catch (error) {
+            if (!isMissingInjectionContextError(error)) {
+                throw error;
+            }
+            const fallback = legacyPrepareFallbackInjector();
+            // A stale stash (the app injector is gone) is no injector at all - handing it over would build a
+            // query that silently never runs.
+            if (fallback && isInjectorUsable(fallback)) {
+                return fallback;
+            }
+            throw legacyPrepareWithoutInjectionContext(this.label, method);
+        }
+    }
 }
 /**
  * Creates a legacy query creator.
@@ -6568,32 +7541,49 @@ class LegacyQueryCreator {
  * **NOTE**: This is a temporary solution to support legacy queries. It will be removed in the future.
  *
  * **DO NOT TURN NEW QUERY CREATORS INTO LEGACY ONES MANUALLY. THIS IS ONLY NEEDED FOR MIGRATION PURPOSES.**
+ *
+ * @deprecated Part of the legacy (v2) query system. Migrate to the current query API - see https://ethlete-sdk-docs.web.app/query/migrating-from-v2, and run `nx g @ethlete/query:migrate-to-query-v3` to rewrite the mechanical parts. Intent to remove in v7.
  */
 const createLegacyQueryCreator = (options) => {
     return new LegacyQueryCreator(options);
 };
 
 /* eslint-disable @typescript-eslint/no-explicit-any */
+/**
+ * @deprecated Part of the legacy (v2) query system. Migrate to the current query API - see https://ethlete-sdk-docs.web.app/query/migrating-from-v2, and run `nx g @ethlete/query:migrate-to-query-v3` to rewrite the mechanical parts. Intent to remove in v7.
+ */
 function filterSuccess() {
     return function (source) {
         return source.pipe(filter((value) => isQueryStateSuccess(value)));
     };
 }
+/**
+ * @deprecated Part of the legacy (v2) query system. Migrate to the current query API - see https://ethlete-sdk-docs.web.app/query/migrating-from-v2, and run `nx g @ethlete/query:migrate-to-query-v3` to rewrite the mechanical parts. Intent to remove in v7.
+ */
 function ignoreAutoRefresh() {
     return function (source) {
         return source.pipe(filter((value) => !isAutoRefresh(value)));
     };
 }
+/**
+ * @deprecated Part of the legacy (v2) query system. Migrate to the current query API - see https://ethlete-sdk-docs.web.app/query/migrating-from-v2, and run `nx g @ethlete/query:migrate-to-query-v3` to rewrite the mechanical parts. Intent to remove in v7.
+ */
 function filterFailure() {
     return function (source) {
         return source.pipe(filter((value) => isQueryStateFailure(value)));
     };
 }
+/**
+ * @deprecated Part of the legacy (v2) query system. Migrate to the current query API - see https://ethlete-sdk-docs.web.app/query/migrating-from-v2, and run `nx g @ethlete/query:migrate-to-query-v3` to rewrite the mechanical parts. Intent to remove in v7.
+ */
 function filterQueryStates(allowedStates) {
     return function (source) {
         return source.pipe(filter((value) => value && allowedStates.includes(value.type)));
     };
 }
+/**
+ * @deprecated Part of the legacy (v2) query system. Migrate to the current query API - see https://ethlete-sdk-docs.web.app/query/migrating-from-v2, and run `nx g @ethlete/query:migrate-to-query-v3` to rewrite the mechanical parts. Intent to remove in v7.
+ */
 function takeUntilResponse(config) {
     return function (source) {
         return source.pipe(takeWhile((value) => {
@@ -6604,21 +7594,33 @@ function takeUntilResponse(config) {
         }, true));
     };
 }
+/**
+ * @deprecated Part of the legacy (v2) query system. Migrate to the current query API - see https://ethlete-sdk-docs.web.app/query/migrating-from-v2, and run `nx g @ethlete/query:migrate-to-query-v3` to rewrite the mechanical parts. Intent to remove in v7.
+ */
 function filterNull() {
     return function (source) {
         return source.pipe(filter((value) => value !== null));
     };
 }
+/**
+ * @deprecated Part of the legacy (v2) query system. Migrate to the current query API - see https://ethlete-sdk-docs.web.app/query/migrating-from-v2, and run `nx g @ethlete/query:migrate-to-query-v3` to rewrite the mechanical parts. Intent to remove in v7.
+ */
 function switchQueryState() {
     return function (source) {
         return source.pipe(switchMap((value) => value?.state$ ?? of(null)));
     };
 }
+/**
+ * @deprecated Part of the legacy (v2) query system. Migrate to the current query API - see https://ethlete-sdk-docs.web.app/query/migrating-from-v2, and run `nx g @ethlete/query:migrate-to-query-v3` to rewrite the mechanical parts. Intent to remove in v7.
+ */
 function switchQueryCollectionState() {
     return function (source) {
         return source.pipe(switchMap((value) => value?.query.state$ ?? of(null)));
     };
 }
+/**
+ * @deprecated Part of the legacy (v2) query system. Migrate to the current query API - see https://ethlete-sdk-docs.web.app/query/migrating-from-v2, and run `nx g @ethlete/query:migrate-to-query-v3` to rewrite the mechanical parts. Intent to remove in v7.
+ */
 const resetPageOnError = (config) => (source) => {
     const { queryForm, pageControlKey = 'page' } = config;
     if (isDevMode() && !queryForm.form.controls[pageControlKey]) {
@@ -6647,12 +7649,33 @@ const resetPageOnError = (config) => (source) => {
         }), takeUntilResponse());
     }));
 };
+/**
+ * @deprecated Part of the legacy (v2) query system. Migrate to the current query API - see https://ethlete-sdk-docs.web.app/query/migrating-from-v2, and run `nx g @ethlete/query:migrate-to-query-v3` to rewrite the mechanical parts. Intent to remove in v7.
+ */
 const isQueryStateLoading = (state) => state?.type === "LOADING" /* QueryStateType.Loading */;
+/**
+ * @deprecated Part of the legacy (v2) query system. Migrate to the current query API - see https://ethlete-sdk-docs.web.app/query/migrating-from-v2, and run `nx g @ethlete/query:migrate-to-query-v3` to rewrite the mechanical parts. Intent to remove in v7.
+ */
 const isQueryStateSuccess = (state) => state?.type === "SUCCESS" /* QueryStateType.Success */;
+/**
+ * @deprecated Part of the legacy (v2) query system. Migrate to the current query API - see https://ethlete-sdk-docs.web.app/query/migrating-from-v2, and run `nx g @ethlete/query:migrate-to-query-v3` to rewrite the mechanical parts. Intent to remove in v7.
+ */
 const isQueryStateFailure = (state) => state?.type === "FAILURE" /* QueryStateType.Failure */;
+/**
+ * @deprecated Part of the legacy (v2) query system. Migrate to the current query API - see https://ethlete-sdk-docs.web.app/query/migrating-from-v2, and run `nx g @ethlete/query:migrate-to-query-v3` to rewrite the mechanical parts. Intent to remove in v7.
+ */
 const isQueryStateCancelled = (state) => state?.type === "CANCELLED" /* QueryStateType.Cancelled */;
+/**
+ * @deprecated Part of the legacy (v2) query system. Migrate to the current query API - see https://ethlete-sdk-docs.web.app/query/migrating-from-v2, and run `nx g @ethlete/query:migrate-to-query-v3` to rewrite the mechanical parts. Intent to remove in v7.
+ */
 const isQueryStatePrepared = (state) => state?.type === "PREPARED" /* QueryStateType.Prepared */;
+/**
+ * @deprecated Part of the legacy (v2) query system. Migrate to the current query API - see https://ethlete-sdk-docs.web.app/query/migrating-from-v2, and run `nx g @ethlete/query:migrate-to-query-v3` to rewrite the mechanical parts. Intent to remove in v7.
+ */
 const isAutoRefresh = (state) => state?.meta.triggeredVia === 'auto';
+/**
+ * @deprecated Part of the legacy (v2) query system. Migrate to the current query API - see https://ethlete-sdk-docs.web.app/query/migrating-from-v2, and run `nx g @ethlete/query:migrate-to-query-v3` to rewrite the mechanical parts. Intent to remove in v7.
+ */
 const mergeHeaders = (...headers) => {
     return headers.reduce((acc, headers) => {
         if (!headers) {
@@ -6664,6 +7687,9 @@ const mergeHeaders = (...headers) => {
         };
     }, {});
 };
+/**
+ * @deprecated Part of the legacy (v2) query system. Migrate to the current query API - see https://ethlete-sdk-docs.web.app/query/migrating-from-v2, and run `nx g @ethlete/query:migrate-to-query-v3` to rewrite the mechanical parts. Intent to remove in v7.
+ */
 const isGqlQueryConfig = (config) => {
     if (!config || typeof config !== 'object' || Array.isArray(config)) {
         return false;
@@ -6673,6 +7699,9 @@ const isGqlQueryConfig = (config) => {
     }
     return true;
 };
+/**
+ * @deprecated Part of the legacy (v2) query system. Migrate to the current query API - see https://ethlete-sdk-docs.web.app/query/migrating-from-v2, and run `nx g @ethlete/query:migrate-to-query-v3` to rewrite the mechanical parts. Intent to remove in v7.
+ */
 const isQuery = (query) => {
     if (!query || typeof query !== 'object' || Array.isArray(query)) {
         return false;
@@ -6682,6 +7711,9 @@ const isQuery = (query) => {
     }
     return true;
 };
+/**
+ * @deprecated Part of the legacy (v2) query system. Migrate to the current query API - see https://ethlete-sdk-docs.web.app/query/migrating-from-v2, and run `nx g @ethlete/query:migrate-to-query-v3` to rewrite the mechanical parts. Intent to remove in v7.
+ */
 const isQueryCollection = (query) => {
     if (!query || typeof query !== 'object' || Array.isArray(query)) {
         return false;
@@ -6691,9 +7723,15 @@ const isQueryCollection = (query) => {
     }
     return true;
 };
+/**
+ * @deprecated Part of the legacy (v2) query system. Migrate to the current query API - see https://ethlete-sdk-docs.web.app/query/migrating-from-v2, and run `nx g @ethlete/query:migrate-to-query-v3` to rewrite the mechanical parts. Intent to remove in v7.
+ */
 const createQueryCollection = (
 // eslint-disable-next-line @typescript-eslint/no-unused-vars
 queryMap) => new BehaviorSubject(null);
+/**
+ * @deprecated Part of the legacy (v2) query system. Migrate to the current query API - see https://ethlete-sdk-docs.web.app/query/migrating-from-v2, and run `nx g @ethlete/query:migrate-to-query-v3` to rewrite the mechanical parts. Intent to remove in v7.
+ */
 const createQueryCollectionSubject = (
 // eslint-disable-next-line @typescript-eslint/no-unused-vars
 queryMap, config) => {
@@ -6702,6 +7740,9 @@ queryMap, config) => {
     addQueryContainerHandling(subject.pipe(map((s) => s?.query ?? null)), () => subject.getValue()?.query ?? null, config);
     return subject;
 };
+/**
+ * @deprecated Part of the legacy (v2) query system. Migrate to the current query API - see https://ethlete-sdk-docs.web.app/query/migrating-from-v2, and run `nx g @ethlete/query:migrate-to-query-v3` to rewrite the mechanical parts. Intent to remove in v7.
+ */
 const createQueryCollectionSignal = (
 // eslint-disable-next-line @typescript-eslint/no-unused-vars
 queryMap, config) => {
@@ -6711,7 +7752,13 @@ queryMap, config) => {
     addQueryContainerHandling(toObservable(_signal).pipe(map((s) => s?.query ?? null)), () => _signal()?.query ?? null, config);
     return _signal;
 };
+/**
+ * @deprecated Part of the legacy (v2) query system. Migrate to the current query API - see https://ethlete-sdk-docs.web.app/query/migrating-from-v2, and run `nx g @ethlete/query:migrate-to-query-v3` to rewrite the mechanical parts. Intent to remove in v7.
+ */
 const extractQuery = (v) => (isQuery(v) ? v : isLegacyQuery(v) ? v : v?.query) ?? null;
+/**
+ * @deprecated Part of the legacy (v2) query system. Migrate to the current query API - see https://ethlete-sdk-docs.web.app/query/migrating-from-v2, and run `nx g @ethlete/query:migrate-to-query-v3` to rewrite the mechanical parts. Intent to remove in v7.
+ */
 const getDefaultHeaders = (headers, method) => {
     if (!headers) {
         return {};
@@ -6721,6 +7768,9 @@ const getDefaultHeaders = (headers, method) => {
     }
     return headers;
 };
+/**
+ * @deprecated Part of the legacy (v2) query system. Migrate to the current query API - see https://ethlete-sdk-docs.web.app/query/migrating-from-v2, and run `nx g @ethlete/query:migrate-to-query-v3` to rewrite the mechanical parts. Intent to remove in v7.
+ */
 const castQueryCreatorTypes = (config) => {
     if (config.args?.pathParams) {
         console.error(config);
@@ -6728,6 +7778,9 @@ const castQueryCreatorTypes = (config) => {
     }
     return config.creator;
 };
+/**
+ * @deprecated Part of the legacy (v2) query system. Migrate to the current query API - see https://ethlete-sdk-docs.web.app/query/migrating-from-v2, and run `nx g @ethlete/query:migrate-to-query-v3` to rewrite the mechanical parts. Intent to remove in v7.
+ */
 const computeQueryMethod = (config) => {
     let method;
     if (isGqlQueryConfig(config.config)) {
@@ -6739,6 +7792,9 @@ const computeQueryMethod = (config) => {
     }
     return method;
 };
+/**
+ * @deprecated Part of the legacy (v2) query system. Migrate to the current query API - see https://ethlete-sdk-docs.web.app/query/migrating-from-v2, and run `nx g @ethlete/query:migrate-to-query-v3` to rewrite the mechanical parts. Intent to remove in v7.
+ */
 const computeQueryBody = (config) => {
     let body;
     if (config.method === 'GET' ||
@@ -6759,6 +7815,9 @@ const computeQueryBody = (config) => {
     }
     return body;
 };
+/**
+ * @deprecated Part of the legacy (v2) query system. Migrate to the current query API - see https://ethlete-sdk-docs.web.app/query/migrating-from-v2, and run `nx g @ethlete/query:migrate-to-query-v3` to rewrite the mechanical parts. Intent to remove in v7.
+ */
 const computeQueryAuthHeader = (config) => {
     let authHeader = null;
     if (config.config.secure) {
@@ -6774,11 +7833,17 @@ const computeQueryAuthHeader = (config) => {
     }
     return authHeader;
 };
+/**
+ * @deprecated Part of the legacy (v2) query system. Migrate to the current query API - see https://ethlete-sdk-docs.web.app/query/migrating-from-v2, and run `nx g @ethlete/query:migrate-to-query-v3` to rewrite the mechanical parts. Intent to remove in v7.
+ */
 const computeQueryHeaders = (config) => {
     const authHeader = computeQueryAuthHeader(config);
     const mergedHeaders = mergeHeaders(getDefaultHeaders(config.client.config.request?.headers, config.config.method), authHeader, config.args?.headers) || undefined;
     return mergedHeaders;
 };
+/**
+ * @deprecated Part of the legacy (v2) query system. Migrate to the current query API - see https://ethlete-sdk-docs.web.app/query/migrating-from-v2, and run `nx g @ethlete/query:migrate-to-query-v3` to rewrite the mechanical parts. Intent to remove in v7.
+ */
 const computeQueryQueryParams = (config) => {
     if (isGqlQueryConfig(config.config) &&
         (config.config.transferVia === 'GET' ||
@@ -6793,6 +7858,9 @@ const computeQueryQueryParams = (config) => {
     }
     return config.args?.queryParams;
 };
+/**
+ * @deprecated Part of the legacy (v2) query system. Migrate to the current query API - see https://ethlete-sdk-docs.web.app/query/migrating-from-v2, and run `nx g @ethlete/query:migrate-to-query-v3` to rewrite the mechanical parts. Intent to remove in v7.
+ */
 const paginatedEntityValueUpdater = (findFn) => ({ response, rawResponse, entity }) => {
     const indexOfEntityRaw = rawResponse.items.findIndex((item) => findFn(item, entity));
     const indexOfEntity = response.items.findIndex((item) => findFn(item, entity));
@@ -6818,6 +7886,9 @@ const paginatedEntityValueUpdater = (findFn) => ({ response, rawResponse, entity
 };
 
 let _nextQueryId = 0;
+/**
+ * @deprecated Part of the legacy (v2) query system. Migrate to the current query API - see https://ethlete-sdk-docs.web.app/query/migrating-from-v2, and run `nx g @ethlete/query:migrate-to-query-v3` to rewrite the mechanical parts. Intent to remove in v7.
+ */
 class V2Query {
     constructor(_client, 
     /**
@@ -7249,10 +8320,22 @@ class V2Query {
     }
 }
 
+/**
+ * @deprecated Part of the legacy (v2) query system. Migrate to the current query API - see https://ethlete-sdk-docs.web.app/query/migrating-from-v2, and run `nx g @ethlete/query:migrate-to-query-v3` to rewrite the mechanical parts. Intent to remove in v7.
+ */
 const isBasicAuthProvider = (authProvider) => authProvider instanceof BasicAuthProvider;
+/**
+ * @deprecated Part of the legacy (v2) query system. Migrate to the current query API - see https://ethlete-sdk-docs.web.app/query/migrating-from-v2, and run `nx g @ethlete/query:migrate-to-query-v3` to rewrite the mechanical parts. Intent to remove in v7.
+ */
 const isBearerAuthProvider = (authProvider) => authProvider instanceof V2BearerAuthProvider;
+/**
+ * @deprecated Part of the legacy (v2) query system. Migrate to the current query API - see https://ethlete-sdk-docs.web.app/query/migrating-from-v2, and run `nx g @ethlete/query:migrate-to-query-v3` to rewrite the mechanical parts. Intent to remove in v7.
+ */
 const isCustomHeaderAuthProvider = (authProvider) => authProvider instanceof CustomHeaderAuthProvider;
 
+/**
+ * @deprecated Part of the legacy (v2) query system. Migrate to the current query API - see https://ethlete-sdk-docs.web.app/query/migrating-from-v2, and run `nx g @ethlete/query:migrate-to-query-v3` to rewrite the mechanical parts. Intent to remove in v7.
+ */
 class V2BearerAuthProvider {
     constructor(_config) {
         this._config = _config;
@@ -7431,9 +8514,18 @@ const INFINITY_QUERY_RESPONSE_DELAY_DEF = /* @__PURE__ */ defineProvider(() => {
         enabled$,
     };
 }, { name: 'Infinity Query Response Delay' });
+/**
+ * @deprecated Part of the legacy (v2) query system. Migrate to the current query API - see https://ethlete-sdk-docs.web.app/query/migrating-from-v2, and run `nx g @ethlete/query:migrate-to-query-v3` to rewrite the mechanical parts. Intent to remove in v7.
+ */
 const provideInfinityQueryResponseDelay = /* @__PURE__ */ toProvideFn(INFINITY_QUERY_RESPONSE_DELAY_DEF);
+/**
+ * @deprecated Part of the legacy (v2) query system. Migrate to the current query API - see https://ethlete-sdk-docs.web.app/query/migrating-from-v2, and run `nx g @ethlete/query:migrate-to-query-v3` to rewrite the mechanical parts. Intent to remove in v7.
+ */
 const injectInfinityQueryResponseDelay = /* @__PURE__ */ toInjectFn(INFINITY_QUERY_RESPONSE_DELAY_DEF);
 
+/**
+ * @deprecated Part of the legacy (v2) query system. Migrate to the current query API - see https://ethlete-sdk-docs.web.app/query/migrating-from-v2, and run `nx g @ethlete/query:migrate-to-query-v3` to rewrite the mechanical parts. Intent to remove in v7.
+ */
 class InfinityQuery {
     constructor(_config, _destroy$) {
         this._config = _config;
@@ -7604,11 +8696,23 @@ class InfinityQuery {
     }
 }
 
+/**
+ * @deprecated Part of the legacy (v2) query system. Migrate to the current query API - see https://ethlete-sdk-docs.web.app/query/migrating-from-v2, and run `nx g @ethlete/query:migrate-to-query-v3` to rewrite the mechanical parts. Intent to remove in v7.
+ */
 const createInfinityQueryConfig = (config) => config;
+/**
+ * @deprecated Part of the legacy (v2) query system. Migrate to the current query API - see https://ethlete-sdk-docs.web.app/query/migrating-from-v2, and run `nx g @ethlete/query:migrate-to-query-v3` to rewrite the mechanical parts. Intent to remove in v7.
+ */
 const skipPaginationPageParamCalculator = ({ page, itemsPerPage }) => itemsPerPage * (page - 1);
 
 /* eslint-disable @typescript-eslint/no-explicit-any */
+/**
+ * @deprecated Part of the legacy (v2) query system. Migrate to the current query API - see https://ethlete-sdk-docs.web.app/query/migrating-from-v2, and run `nx g @ethlete/query:migrate-to-query-v3` to rewrite the mechanical parts. Intent to remove in v7.
+ */
 const INFINITY_QUERY_TOKEN = new InjectionToken('INFINITY_QUERY_TOKEN');
+/**
+ * @deprecated Part of the legacy (v2) query system. Migrate to the current query API - see https://ethlete-sdk-docs.web.app/query/migrating-from-v2, and run `nx g @ethlete/query:migrate-to-query-v3` to rewrite the mechanical parts. Intent to remove in v7.
+ */
 class InfinityQueryDirective {
     // TODO: Skipped for migration because:
     //  Accessor inputs cannot be migrated as they are too complex.
@@ -7757,6 +8861,9 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.0.7", ngImpor
                 args: ['etInfinityQuery']
             }] } });
 
+/**
+ * @deprecated Part of the legacy (v2) query system. Migrate to the current query API - see https://ethlete-sdk-docs.web.app/query/migrating-from-v2, and run `nx g @ethlete/query:migrate-to-query-v3` to rewrite the mechanical parts. Intent to remove in v7.
+ */
 class InfinityQueryTriggerDirective {
     constructor() {
         this.elementRef = inject(ElementRef);
@@ -7812,6 +8919,9 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.0.7", ngImpor
                 }]
         }], propDecorators: { scrollContainerSelector: [{ type: i0.Input, args: [{ isSignal: true, alias: "scrollContainerSelector", required: false }] }], infinityQueryOverride: [{ type: i0.Input, args: [{ isSignal: true, alias: "infinityQueryOverride", required: false }] }] } });
 
+/**
+ * @deprecated Part of the legacy (v2) query system. Migrate to the current query API - see https://ethlete-sdk-docs.web.app/query/migrating-from-v2, and run `nx g @ethlete/query:migrate-to-query-v3` to rewrite the mechanical parts. Intent to remove in v7.
+ */
 class QueryDirective {
     static ngTemplateContextGuard(_dir, _ctx) {
         return true;
@@ -7901,6 +9011,9 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.0.7", ngImpor
                 }]
         }], ctorParameters: () => [], propDecorators: { query: [{ type: i0.Input, args: [{ isSignal: true, alias: "etQuery", required: true }] }], cache: [{ type: i0.Input, args: [{ isSignal: true, alias: "etQueryCache", required: false }] }] } });
 
+/**
+ * @deprecated Part of the legacy (v2) query system. Migrate to the current query API - see https://ethlete-sdk-docs.web.app/query/migrating-from-v2, and run `nx g @ethlete/query:migrate-to-query-v3` to rewrite the mechanical parts. Intent to remove in v7.
+ */
 class QueryShortNamePipe {
     transform(value) {
         const route = value._routeWithParams;
@@ -7923,7 +9036,13 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.0.7", ngImpor
             args: [{ name: 'queryShortName' }]
         }] });
 
+/**
+ * @deprecated Part of the legacy (v2) query system. Migrate to the current query API - see https://ethlete-sdk-docs.web.app/query/migrating-from-v2, and run `nx g @ethlete/query:migrate-to-query-v3` to rewrite the mechanical parts. Intent to remove in v7.
+ */
 const QUERY_CLIENT_DEVTOOLS_TOKEN = new InjectionToken('QUERY_CLIENT_DEVTOOLS_TOKEN');
+/**
+ * @deprecated Part of the legacy (v2) query system. Migrate to the current query API - see https://ethlete-sdk-docs.web.app/query/migrating-from-v2, and run `nx g @ethlete/query:migrate-to-query-v3` to rewrite the mechanical parts. Intent to remove in v7.
+ */
 const provideQueryClientForDevtools = (queryClient) => {
     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.');
@@ -7935,6 +9054,9 @@ const provideQueryClientForDevtools = (queryClient) => {
     };
 };
 
+/**
+ * @deprecated Part of the legacy (v2) query system. Migrate to the current query API - see https://ethlete-sdk-docs.web.app/query/migrating-from-v2, and run `nx g @ethlete/query:migrate-to-query-v3` to rewrite the mechanical parts. Intent to remove in v7.
+ */
 class QueryDevtoolsComponent {
     constructor() {
         this.cdr = inject(ChangeDetectorRef);
@@ -8244,6 +9366,9 @@ class EntityStoreError extends Error {
 function flatten(arr) {
     return arr.reduce((acc, val) => acc.concat(val), []);
 }
+/**
+ * @deprecated Part of the legacy (v2) query system. Migrate to the current query API - see https://ethlete-sdk-docs.web.app/query/migrating-from-v2, and run `nx g @ethlete/query:migrate-to-query-v3` to rewrite the mechanical parts. Intent to remove in v7.
+ */
 class EntityStore {
     constructor(_config) {
         this._config = _config;
@@ -8360,12 +9485,17 @@ class EntityStore {
     }
 }
 
+/**
+ * @deprecated Part of the legacy (v2) query system. Migrate to the current query API - see https://ethlete-sdk-docs.web.app/query/migrating-from-v2, and run `nx g @ethlete/query:migrate-to-query-v3` to rewrite the mechanical parts. Intent to remove in v7.
+ */
 function mapToPaginated(response) {
     return map((items) => ({ ...response, items }));
 }
 // FIXME: This breaks if SubStoreType is an array
 /**
  * Use an other store to represent a property of the current entity.
+ *
+ * @deprecated Part of the legacy (v2) query system. Migrate to the current query API - see https://ethlete-sdk-docs.web.app/query/migrating-from-v2, and run `nx g @ethlete/query:migrate-to-query-v3` to rewrite the mechanical parts. Intent to remove in v7.
  */
 const insertFrom = (store, { for: key, id }) => switchMap((value) => {
     if (!value)
@@ -8380,6 +9510,8 @@ const insertFrom = (store, { for: key, id }) => switchMap((value) => {
 });
 /**
  * Remove entities from a store based on a where function.
+ *
+ * @deprecated Part of the legacy (v2) query system. Migrate to the current query API - see https://ethlete-sdk-docs.web.app/query/migrating-from-v2, and run `nx g @ethlete/query:migrate-to-query-v3` to rewrite the mechanical parts. Intent to remove in v7.
  */
 const removeFrom = (store, { where, id }) => {
     store
@@ -8388,9 +9520,21 @@ const removeFrom = (store, { where, id }) => {
         .subscribe();
 };
 
+/**
+ * @deprecated Part of the legacy (v2) query system. Migrate to the current query API - see https://ethlete-sdk-docs.web.app/query/migrating-from-v2, and run `nx g @ethlete/query:migrate-to-query-v3` to rewrite the mechanical parts. Intent to remove in v7.
+ */
 const queryStateAlreadyHasKeyError = (data) => new QueryError('004', 'The query state already contains the provided key', data);
+/**
+ * @deprecated Part of the legacy (v2) query system. Migrate to the current query API - see https://ethlete-sdk-docs.web.app/query/migrating-from-v2, and run `nx g @ethlete/query:migrate-to-query-v3` to rewrite the mechanical parts. Intent to remove in v7.
+ */
 const queryStateDoesNotContainKeyError = (data) => new QueryError('005', 'The query state does not contain the provided key', data);
+/**
+ * @deprecated Part of the legacy (v2) query system. Migrate to the current query API - see https://ethlete-sdk-docs.web.app/query/migrating-from-v2, and run `nx g @ethlete/query:migrate-to-query-v3` to rewrite the mechanical parts. Intent to remove in v7.
+ */
 const queryStateCannotTransformError = (data) => new QueryError('006', 'The query state cannot be transformed because it is not loading', data);
+/**
+ * @deprecated Part of the legacy (v2) query system. Migrate to the current query API - see https://ethlete-sdk-docs.web.app/query/migrating-from-v2, and run `nx g @ethlete/query:migrate-to-query-v3` to rewrite the mechanical parts. Intent to remove in v7.
+ */
 const invalidBodyError = (data) => new QueryError('007', 'The body is not valid or upsupported', data);
 
 /**
@@ -8415,6 +9559,8 @@ const invalidBodyError = (data) => new QueryError('007', 'The body is not valid
  *   });
  * });
  * ```
+ *
+ * @deprecated Part of the legacy (v2) query system. Migrate to the current query API - see https://ethlete-sdk-docs.web.app/query/migrating-from-v2, and run `nx g @ethlete/query:migrate-to-query-v3` to rewrite the mechanical parts. Intent to remove in v7.
  */
 const validateWithV2Query = (path, config) => {
     applyQueryAsyncValidator(path, {
@@ -9556,6 +10702,16 @@ const createBranch = (fields, initial, injector) => {
         resetAllFieldsToDefault: () => model.set(clone(defaults)),
     };
 };
+/**
+ * Per-name sequence behind the devtools id of a form, mirroring the registry's own scheme so the
+ * panel can restore the selected form after a reload.
+ */
+const devtoolsIdCounters = /* @__PURE__ */ new Map();
+const nextQueryFormDevtoolsId = (name) => {
+    const seq = devtoolsIdCounters.get(name) ?? 0;
+    devtoolsIdCounters.set(name, seq + 1);
+    return `query-form|${name}#${seq}`;
+};
 /**
  * A signals-first query form: binds on-screen controls to typed fields, keeps a
  * debounced committed value, syncs to the URL query params, and resets dependent
@@ -9582,6 +10738,8 @@ class QueryFormSignals {
         this.observing = signal(false, /* @ts-ignore */
         ...(ngDevMode ? [{ debugName: "observing" }] : /* istanbul ignore next */ []));
         this.pendingTimer = null;
+        this.commitPending = signal(false, /* @ts-ignore */
+        ...(ngDevMode ? [{ debugName: "commitPending" }] : /* istanbul ignore next */ []));
         this.skipNextResets = false;
         assertInInjectionContext(QueryFormSignals);
         this._fields = config.fields;
@@ -9594,7 +10752,16 @@ class QueryFormSignals {
         this.committed = signal(clone(initial), /* @ts-ignore */
         ...(ngDevMode ? [{ debugName: "committed" }] : /* istanbul ignore next */ []));
         this.fields = form(this.model);
-        this.value = this.committed.asReadonly();
+        const devtoolsName = config.name ?? (typeof this.prefix === 'string' ? this.prefix : 'form');
+        const devtoolsId = isQueryDevtoolsEnabled() ? nextQueryFormDevtoolsId(devtoolsName) : null;
+        // Reading `value` is how a query's args pick the form up, so the devtools learn which query a form
+        // drives by noting the read - see `QueryDevtoolsFormLinksHandle`.
+        this.value = devtoolsId
+            ? computed(() => {
+                noteQueryFormRead(devtoolsId);
+                return this.committed();
+            })
+            : this.committed.asReadonly();
         this.previousValue = this.previous.asReadonly();
         this.changes = computed(() => ({ previousValue: this.previous(), currentValue: this.committed() }), /* @ts-ignore */
         ...(ngDevMode ? [{ debugName: "changes" }] : /* istanbul ignore next */ []));
@@ -9614,7 +10781,16 @@ class QueryFormSignals {
                 this.applyFromUrl(changes);
             });
         });
-        inject(DestroyRef).onDestroy(() => this.cleanup());
+        const destroyRef = inject(DestroyRef);
+        destroyRef.onDestroy(() => this.cleanup());
+        if (devtoolsId) {
+            destroyRef.onDestroy(registerQueryDevtoolsEntry({
+                id: devtoolsId,
+                kind: 'query-form',
+                handle: this.devtoolsHandle(),
+                meta: { name: devtoolsName },
+            }));
+        }
     }
     observe(options) {
         if (this.observing()) {
@@ -9670,6 +10846,46 @@ class QueryFormSignals {
     branch() {
         return createBranch(this._fields, clone(this.committed()), this.injector);
     }
+    /**
+     * The live view `<et-query-devtools>` renders. Only built while the devtools are installed - it walks
+     * every field on every change, which an app without them should not pay for.
+     */
+    devtoolsHandle() {
+        const fields = computed(() => {
+            const committed = this.committed();
+            const live = this.model();
+            return Object.entries(this._fields).map(([key, def]) => {
+                const value = committed[key];
+                return {
+                    key,
+                    paramKey: this.paramKey(key),
+                    value,
+                    liveValue: live[key],
+                    defaultValue: this.defaults[key],
+                    isDefault: equal(value, this.defaults[key]),
+                    queryParam: this.queryParamFor(key, def, value),
+                    debounceMs: def.debounce ?? null,
+                    isResetBy: def.isResetBy ?? [],
+                    countsAsFilter: !IGNORED_FILTER_COUNT_FIELDS.includes(key) && !def.skipInFilterCount,
+                };
+            });
+        }, /* @ts-ignore */
+        ...(ngDevMode ? [{ debugName: "fields" }] : /* istanbul ignore next */ []));
+        return {
+            fields,
+            // Not `this.value` - reading that from the panel would link the form to whichever query happens
+            // to be building its args at the time.
+            value: computed(() => this.committed()),
+            previousValue: computed(() => this.previous() ?? null),
+            defaultValue: this.defaults,
+            activeFilterCount: this.activeFilterCount,
+            isAtDefaults: computed(() => equal(this.committed(), this.defaults)),
+            isCommitPending: this.commitPending.asReadonly(),
+            isObserving: this.observing.asReadonly(),
+            resetField: (key) => this.resetFieldToDefault(key),
+            resetAll: () => this.resetAllFieldsToDefault(),
+        };
+    }
     onLiveChange(live) {
         if (!this.observing())
             return;
@@ -9682,6 +10898,7 @@ class QueryFormSignals {
             this.flush();
         }
         else {
+            this.commitPending.set(true);
             this.pendingTimer = setTimeout(() => {
                 this.pendingTimer = null;
                 this.flush();
@@ -9782,23 +10999,21 @@ class QueryFormSignals {
             return raw;
         return autoCoerce(raw, resolveDefault(def));
     }
+    /** What a field puts in the URL for a given value, or `undefined` when it writes nothing. */
+    queryParamFor(key, def, value) {
+        const isDefault = equal(value, this.defaults[key]);
+        const writeToUrl = def.appendToUrl !== false;
+        const writeDefault = def.appendDefaultValueToUrl === true;
+        if (!writeToUrl || (isDefault && !writeDefault))
+            return undefined;
+        if (def.valueToQueryParam)
+            return def.valueToQueryParam(value);
+        return value === null ? ET_NULL_VALUE : value;
+    }
     writeToUrl(value) {
         const queryParams = {};
         for (const [key, def] of Object.entries(this._fields)) {
-            const paramKey = this.paramKey(key);
-            const fieldValue = value[key];
-            const isDefault = equal(fieldValue, this.defaults[key]);
-            const writeToUrl = def.appendToUrl !== false;
-            const writeDefault = def.appendDefaultValueToUrl === true;
-            if (!writeToUrl || (isDefault && !writeDefault)) {
-                queryParams[paramKey] = undefined;
-            }
-            else if (def.valueToQueryParam) {
-                queryParams[paramKey] = def.valueToQueryParam(fieldValue);
-            }
-            else {
-                queryParams[paramKey] = fieldValue === null ? ET_NULL_VALUE : fieldValue;
-            }
+            queryParams[this.paramKey(key)] = this.queryParamFor(key, def, value[key]);
         }
         queueMicrotask(() => {
             this.router.navigate([], {
@@ -9819,6 +11034,7 @@ class QueryFormSignals {
             clearTimeout(this.pendingTimer);
             this.pendingTimer = null;
         }
+        this.commitPending.set(false);
     }
     cleanup() {
         if (!this.observing())
@@ -10071,5 +11287,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, EntityStore, IGNORED_FILTER_COUNT_FIELDS, INFINITY_QUERY_TOKEN, InfinityQuery, InfinityQueryDirective, InfinityQueryTriggerDirective, LegacyQuery, LegacyQueryCreator, MAX_UNUSED_ENTRIES, NumberArrayQueryField, ParseHttpErrorCodeToMessageDePipe, ParseHttpErrorCodeToMessageEnPipe, ParseHttpErrorCodeToTitleDePipe, ParseHttpErrorCodeToTitleEnPipe, QUERY_CLIENT_DEVTOOLS_TOKEN, QUERY_PERSISTENCE_STORE_VERSION, QUERY_SYNC_PROTOCOL_VERSION, QueryClientFeatureType, QueryDevtoolsComponent, QueryDirective, QueryError, QueryFeatureType, QueryField, QueryForm, QueryFormSignals, QueryRuntimeErrorCode, QueryShortNamePipe, QueryStore, SERVER_ERROR_KIND, SERVER_VIOLATION_ERROR_KIND, SPEED_BUFFER_TIME_IN_MS, SearchQueryField, SortQueryField, StringArrayQueryField, V2BearerAuthProvider, V2Query, V2QueryClient, V2QueryCreator, addQueryContainerHandling, applyQueryFeatures, authExtractTokensResponseMissingAccessToken, authExtractTokensResponseMissingRefreshToken, authExtractTokensResponseNotObject, authProviderFeatureUsedMultipleTimes, booleanArrayQueryField, buildErrorMessage, buildQueryCacheKey, buildQueryString, buildRoute, buildTimestampFromSeconds, castQueryCreatorTypes, circularQueryDependency, circularQueryDependencyChecker, computeQueryAuthHeader, computeQueryBody, computeQueryHeaders, computeQueryMethod, computeQueryQueryParams, consumeSuppressQueryStackDevtools, contentfulGqlLikePaginationAdapter, createBaseQuery, createBaseQueryCreator, createBearerAuthProvider, createDeleteQuery, createExecuteFn, createGetQuery, createGqlExecuteFn, createGqlMutationViaGet, createGqlMutationViaPost, createGqlQuery, createGqlQueryCreator, createGqlQueryViaGet, createGqlQueryViaPost, createHttpRequest, createIndexedDbQueryPersistenceAdapter, createInfinityQueryConfig, createLegacyQueryCreator, createNoopQueryPersistenceAdapter, createPagedQueryStack, createPatchQuery, createPersistentAuthFeature, createPostQuery, createPutQuery, createQuery, createQueryClient, createQueryCollection, createQueryCollectionSignal, createQueryCollectionSubject, createQueryContext, createQueryCreator, createQueryErrorResponse, createQueryFeature, createQueryForm, 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, detectContentTypeHeader, dynLikePaginationAdapter, effectComputed, emptyQueryArgs, ethletePaginationAdapter, executeUntilSettled, extractExpiresInSeconds, extractFormViolations, extractHtmlErrorMessage, extractQuery, fakePaginationAdapter, filterFailure, filterNull, filterQueryStates, filterSuccess, forEachHeader, getDefaultHeaders, getQueryClientName, getQueryFeatureUsage, getResponseUrl, ggLikePaginationAdapter, gql, gqlDataPropertyMissingInResponse, hasHeader, htmlErrorPayload, htmlQueryErrorParser, ignoreAutoRefresh, injectInfinityQueryResponseDelay, injectQueryContext, insertFrom, invalidBaseRouteError, invalidBodyError, invalidRouteError, invalidStateInsideSecureExecuteFactory, isAutoRefresh, isBasicAuthProvider, isBearerAuthProvider, isClassValidatorError, isCreateGqlQueryOptions, isCustomHeaderAuthProvider, isEmptyString, isGqlQueryConfig, isHtmlErrorPayload, isLegacyQuery, isNaN$1 as isNaN, isPageOutOfRangeError, isQuery, isQueryCollection, isQueryDevtoolsEnabled, isQueryErrorResponse, isQueryStateCancelled, isQueryStateFailure, isQueryStateLoading, isQueryStatePrepared, isQueryStateSuccess, isRequestError, isSymfonyError, isSymfonyFormViolationListError, isSymfonyListError, isSymfonyPagerfantaOutOfRangeError, isUnderInvalidatedUrl, legacyPrepareWithoutInjectionContext, mapToPaginated, mapViolationsToFormErrors, maybeExecute, mergeHeaders, nestedEffect, numberArrayQueryField, pagedQueryStackNextPageCalledWithoutPreviousPage, pagedQueryStackPageBiggerThanTotalPages, pagedQueryStackPreviousPageCalledButAlreadyAtFirstPage, paginatedEntityValueUpdater, parseAllXhrResponseHeaders, parseHttpErrorCodeToMessageDe, parseHttpErrorCodeToMessageEn, parseHttpErrorCodeToTitleDe, parseHttpErrorCodeToTitleEn, pathParamsMissingInRouteFunctionError, provideInfinityQueryResponseDelay, provideQueryClientForDevtools, provideQueryDevtools, queryArrayComputed, queryClientFeatureUsedMultipleTimes, queryComputed, queryComputedTillTruthy, queryDevtoolsEntries, queryErrorMessage, queryErrorMessages, queryExecute, queryFeatureUsedMultipleTimes, queryField, querySequence, querySequenceAlreadyRunning, queryStackTotalQueriesAndExpectedQueriesMismatch, queryStackWithArgsUsed, queryStackWithResponseUpdateUsed, queryStateAlreadyHasKeyError, queryStateCannotTransformError, queryStateDoesNotContainKeyError, queryStateErrorSignal, queryStateLoadingSignal, queryStateResponseSignal, queryStateSignal, registerQueryDevtoolsEntry, registerQueryErrorParser, removeFrom, request, resetExecuteState, resetPageOnError, resolveInvalidationUrl, runDefaultQueryRetry, runQueryErrorParsers, searchQueryField, serializeBody, setDefaultQueryRetryFn, setQueryDevtoolsRegistrar, setupQueryDependencies, setupQueryExecuteState, setupQueryState, shouldAutoExecuteGqlQuery, shouldAutoExecuteQuery, shouldCacheQuery, shouldRetryRequest, silenceMissingWithArgsFeatureErrorUsedButWithArgsPresent, skipPaginationPageParamCalculator, sortQueryField, splitQueryConfig, stringArrayQueryField, stringifyQueryRoute, suppressNextQueryStackDevtools, switchQueryCollectionState, switchQueryState, symfonyQueryErrorParser, takeUntilResponse, toQuerySignal, toQuerySubject, tokensNotAvailableInsideAuthAndExec, transformArrayResponse, transformExecStateToQueryState, transformGql, transformMethod, transformPaginatedResponse, transformToBoolean, transformToBooleanArray, transformToDate, transformToDateArray, transformToNumber, transformToNumberArray, transformToSort, transformToSortQueryParam, transformToString, transformToStringArray, uncacheableRequestHasAllowCacheParam, uncacheableRequestHasCacheKeyParam, unwrapQuerySyncMessage, v2BuildQueryCacheKey, v2ExtractExpiresInSeconds, v2ShouldCacheQuery, v2ShouldRetryRequest, validateWithQuery, validateWithV2Query, withArgs, withArgsQueryFeatureMissingButRouteIsFunction, withAuthenticationQuery, withAutoRefresh, withAutoRefreshUsedInManualQuery, withAutoRefreshUsedOnUnsupportedHttpMethod, withBearerAuthMultiTabSync, withDefaultRetry, withErrorHandling, withEthleteApiErrors, withHtmlErrorParsing, withInactivityLogout, withLogging, withMultiTabSync, withPageResetOnError, withPersistentAuth, withPolling, withPollingUsedOnUnsupportedHttpMethod, withQueryPersistence, withRefreshQuery, withResponseUpdate, withSuccessHandling, withSymfonyErrors, withTokenExpirationWarning, withTokenRevocation, withTracking, wrapAsObservableSignal, wrapQuerySyncMessage };
+export { BasicAuthProvider, BearerAuthFeatureType, BooleanArrayQueryField, CLEAR_QUERY_ARGS, CustomHeaderAuthProvider, DEFAULT_KEEP_UNUSED_FOR, DEFAULT_QUERY_PERSISTENCE_MAX_AGE, DEFAULT_QUERY_PERSISTENCE_MAX_ENTRIES, DEFAULT_QUERY_PERSISTENCE_VERSION, DEFAULT_QUERY_PERSISTENCE_WRITE_DELAY, DateArrayQueryField, DateQueryField, EMPTY_QUERY_DEVTOOLS_FAULT, EntityStore, IGNORED_FILTER_COUNT_FIELDS, INFINITY_QUERY_TOKEN, InfinityQuery, InfinityQueryDirective, InfinityQueryTriggerDirective, LegacyQuery, LegacyQueryCreator, MAX_UNUSED_ENTRIES, NumberArrayQueryField, ParseHttpErrorCodeToMessageDePipe, ParseHttpErrorCodeToMessageEnPipe, ParseHttpErrorCodeToTitleDePipe, ParseHttpErrorCodeToTitleEnPipe, QUERY_CLIENT_DEVTOOLS_TOKEN, QUERY_DEVTOOLS_FAULT_STATUSES, QUERY_PERSISTENCE_STORE_VERSION, QUERY_SYNC_PROTOCOL_VERSION, QueryClientFeatureType, QueryDevtoolsComponent, QueryDirective, QueryError, QueryFeatureType, QueryField, QueryForm, QueryFormSignals, QueryRuntimeErrorCode, QueryShortNamePipe, QueryStore, SERVER_ERROR_KIND, SERVER_VIOLATION_ERROR_KIND, SPEED_BUFFER_TIME_IN_MS, SearchQueryField, SortQueryField, StringArrayQueryField, V2BearerAuthProvider, V2Query, V2QueryClient, V2QueryCreator, addQueryContainerHandling, applyQueryFeatures, authExtractTokensResponseMissingAccessToken, authExtractTokensResponseMissingRefreshToken, authExtractTokensResponseNotObject, authProviderFeatureUsedMultipleTimes, booleanArrayQueryField, buildErrorMessage, buildQueryCacheKey, buildQueryString, buildRoute, buildTimestampFromSeconds, castQueryCreatorTypes, circularQueryDependency, circularQueryDependencyChecker, clearQueryDevtoolsFaults, collectQueryFormLinks, computeQueryAuthHeader, computeQueryBody, computeQueryHeaders, computeQueryMethod, computeQueryQueryParams, consumeSuppressQueryStackDevtools, contentfulGqlLikePaginationAdapter, createBaseQuery, createBaseQueryCreator, createBearerAuthProvider, createDeleteQuery, createExecuteFn, createGetQuery, createGqlExecuteFn, createGqlMutationViaGet, createGqlMutationViaPost, createGqlQuery, createGqlQueryCreator, createGqlQueryViaGet, createGqlQueryViaPost, createHttpRequest, createIndexedDbQueryPersistenceAdapter, createInfinityQueryConfig, createLegacyQueryCreator, createNoopQueryPersistenceAdapter, createPagedQueryStack, createPatchQuery, createPersistentAuthFeature, createPostQuery, createPutQuery, createQuery, createQueryClient, createQueryCollection, createQueryCollectionSignal, createQueryCollectionSubject, createQueryContext, createQueryCreator, createQueryDevtoolsFormLinks, createQueryDevtoolsFormLinksRecorder, createQueryDevtoolsStats, createQueryDevtoolsStatsRecorder, createQueryErrorResponse, createQueryFeature, createQueryForm, 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, describeQueryDevtoolsFeatures, detectContentTypeHeader, dynLikePaginationAdapter, effectComputed, emptyQueryArgs, ethletePaginationAdapter, executeUntilSettled, extractExpiresInSeconds, extractFormViolations, extractHtmlErrorMessage, extractQuery, fakePaginationAdapter, filterFailure, filterNull, filterQueryStates, filterSuccess, forEachHeader, formatQueryDevtoolsDuration, getBearerAuthProviderName, getDefaultHeaders, getQueryClientName, getQueryFeatureUsage, getResponseUrl, ggLikePaginationAdapter, gql, gqlDataPropertyMissingInResponse, hasHeader, htmlErrorPayload, htmlQueryErrorParser, ignoreAutoRefresh, injectInfinityQueryResponseDelay, injectQueryContext, insertFrom, invalidBaseRouteError, invalidBodyError, invalidRouteError, invalidStateInsideSecureExecuteFactory, isAutoRefresh, isBasicAuthProvider, isBearerAuthProvider, isClassValidatorError, isCreateGqlQueryOptions, isCustomHeaderAuthProvider, isEmptyString, isGqlQueryConfig, isHtmlErrorPayload, isLegacyQuery, isNaN$1 as isNaN, isPageOutOfRangeError, isQuery, isQueryCollection, isQueryDevtoolsEnabled, isQueryDevtoolsFaultArmed, isQueryDevtoolsFaultInjectionEnabled, isQueryErrorResponse, isQueryStateCancelled, isQueryStateFailure, isQueryStateLoading, isQueryStatePrepared, isQueryStateSuccess, isRequestError, isSymfonyError, isSymfonyFormViolationListError, isSymfonyListError, isSymfonyPagerfantaOutOfRangeError, isUnderInvalidatedUrl, legacyPrepareFallbackInjector, legacyPrepareWithoutInjectionContext, mapToPaginated, mapViolationsToFormErrors, maybeExecute, measureQueryDevtoolsPayload, mergeHeaders, nestedEffect, noteQueryFormRead, numberArrayQueryField, pagedQueryStackNextPageCalledWithoutPreviousPage, pagedQueryStackPageBiggerThanTotalPages, pagedQueryStackPreviousPageCalledButAlreadyAtFirstPage, paginatedEntityValueUpdater, parseAllXhrResponseHeaders, parseHttpErrorCodeToMessageDe, parseHttpErrorCodeToMessageEn, parseHttpErrorCodeToTitleDe, parseHttpErrorCodeToTitleEn, parseQueryRoute, pathParamsMissingInRouteFunctionError, provideInfinityQueryResponseDelay, provideLegacyPrepareFallback, provideQueryClientForDevtools, provideQueryDevtools, queryArrayComputed, queryClientFeatureUsedMultipleTimes, queryComputed, queryComputedTillTruthy, queryDevtoolsEntries, queryDevtoolsFaults, queryDevtoolsFnDetail, queryErrorMessage, queryErrorMessages, queryExecute, queryFeatureUsedMultipleTimes, queryField, querySequence, querySequenceAlreadyRunning, queryStackTotalQueriesAndExpectedQueriesMismatch, queryStackWithArgsUsed, queryStackWithResponseUpdateUsed, queryStateAlreadyHasKeyError, queryStateCannotTransformError, queryStateDoesNotContainKeyError, queryStateErrorSignal, queryStateLoadingSignal, queryStateResponseSignal, queryStateSignal, registerQueryDevtoolsEntry, registerQueryErrorParser, removeFrom, request, resetExecuteState, resetPageOnError, resolveInvalidationUrl, resolveQueryDevtoolsFault, resolveQueryDevtoolsFaultForAttempt, runDefaultQueryRetry, runQueryErrorParsers, searchQueryField, serializeBody, setDefaultQueryRetryFn, setQueryDevtoolsFault, setQueryDevtoolsFaultResolver, setQueryDevtoolsFormLinksFactory, setQueryDevtoolsRegistrar, setQueryDevtoolsStatsFactory, setupQueryDependencies, setupQueryExecuteState, setupQueryState, shouldAutoExecuteGqlQuery, shouldAutoExecuteQuery, shouldCacheQuery, shouldRetryRequest, silenceMissingWithArgsFeatureErrorUsedButWithArgsPresent, skipPaginationPageParamCalculator, sortQueryField, splitQueryConfig, stringArrayQueryField, stringifyQueryRouteParts, sumQueryDevtoolsStats, suppressNextQueryStackDevtools, switchQueryCollectionState, switchQueryState, symfonyQueryErrorParser, takeUntilResponse, toQuerySignal, toQuerySubject, tokensNotAvailableInsideAuthAndExec, transformArrayResponse, transformExecStateToQueryState, transformGql, transformMethod, transformPaginatedResponse, transformToBoolean, transformToBooleanArray, transformToDate, transformToDateArray, transformToNumber, transformToNumberArray, transformToSort, transformToSortQueryParam, transformToString, transformToStringArray, uncacheableRequestHasAllowCacheParam, uncacheableRequestHasCacheKeyParam, unwrapQuerySyncMessage, v2BuildQueryCacheKey, v2ExtractExpiresInSeconds, v2ShouldCacheQuery, v2ShouldRetryRequest, validateWithQuery, validateWithV2Query, withArgs, withArgsQueryFeatureMissingButRouteIsFunction, withAuthenticationQuery, withAutoRefresh, withAutoRefreshUsedInManualQuery, withAutoRefreshUsedOnUnsupportedHttpMethod, withBearerAuthMultiTabSync, withDefaultRetry, withErrorHandling, withEthleteApiErrors, withHtmlErrorParsing, withInactivityLogout, withLogging, withMultiTabSync, withPageResetOnError, withPersistentAuth, withPolling, withPollingUsedOnUnsupportedHttpMethod, withQueryPersistence, withRefreshQuery, withResponseUpdate, withSuccessHandling, withSymfonyErrors, withTokenExpirationWarning, withTokenRevocation, withTracking, wrapAsObservableSignal, wrapQuerySyncMessage };
 //# sourceMappingURL=ethlete-query.mjs.map