@ethlete/query 6.0.0-next.54 → 6.0.0-next.56

package/fesm2022/ethlete-query.mjs

@@ -1,11 +1,11 @@
 import * as i0 from '@angular/core';
 import { signal, inject, DestroyRef, computed, effect, isDevMode, untracked, ApplicationRef, Injector, runInInjectionContext, InjectionToken, EnvironmentInjector, ElementRef, ErrorHandler, createEnvironmentInjector, linkedSignal, PLATFORM_ID, resource, DOCUMENT, VERSION, provideEnvironmentInitializer, CSP_NONCE, afterNextRender, makeEnvironmentProviders, assertInInjectionContext, ChangeDetectorRef, ViewContainerRef, TemplateRef, Input, Directive, input, Pipe, ViewEncapsulation, Component, NgZone } from '@angular/core';
 import { UrlTree, Router, RedirectCommand, ActivatedRoute } from '@angular/router';
-import { Subject, Observable, defer, from, filter, Subscription, of, throwError, timer, switchMap, tap, retry, catchError, EMPTY as EMPTY$1, take, takeUntil, finalize, mergeMap, toArray, map, race, NEVER, merge, takeWhile, defaultIfEmpty, firstValueFrom, concatMap, fromEvent, throttleTime, interval, startWith, pairwise, BehaviorSubject, combineLatest, ReplaySubject, distinctUntilChanged, shareReplay, withLatestFrom, debounceTime } from 'rxjs';
-import { defineStaticProvider, RuntimeError, equal, clamp, randomId, defineRootProvider, isObject, injectUnsavedChangesCoordinator, injectRoute, getCookie, setCookie, deleteCookie, CORE_VERSION, createDestroy, computedTillTruthy, defineProvider, toProvideFn, toInjectFn, nextFrame, injectQueryParams, injectQueryParamChanges, clone, ET_PROPERTY_REMOVED, previousSignalValue } from '@ethlete/core';
+import { Subject, Observable, defer, from, ReplaySubject, filter, Subscription, of, throwError, timer, switchMap, tap, retry, catchError, EMPTY as EMPTY$1, take, takeUntil, finalize, mergeMap, toArray, map, race, NEVER, merge, takeWhile, share, defaultIfEmpty, firstValueFrom, concatMap, fromEvent, throttleTime, interval, startWith, pairwise, BehaviorSubject, combineLatest, distinctUntilChanged, shareReplay, withLatestFrom, debounceTime } from 'rxjs';
+import { RuntimeError, defineStaticProvider, equal, clamp, randomId, defineRootProvider, isObject, injectUnsavedChangesCoordinator, injectRoute, getCookie, setCookie, deleteCookie, CORE_VERSION, createDestroy, computedTillTruthy, defineProvider, toProvideFn, toInjectFn, nextFrame, injectQueryParams, injectQueryParamChanges, clone, ET_PROPERTY_REMOVED } from '@ethlete/core';
+import { HttpErrorResponse, HttpClient, HttpEventType, HttpHeaders, HttpContextToken, HttpContext, HttpResponse, HttpStatusCode } from '@angular/common/http';
 import { getActiveConsumer, setActiveConsumer, SIGNAL, createWatch } from '@angular/core/primitives/signals';
-import { HttpClient, HttpErrorResponse, HttpEventType, HttpHeaders, HttpContextToken, HttpContext, HttpResponse, HttpStatusCode } from '@angular/common/http';
-import { toObservable, takeUntilDestroyed, toSignal } from '@angular/core/rxjs-interop';
+import { takeUntilDestroyed, toObservable, toSignal } from '@angular/core/rxjs-interop';
 import { isPlatformBrowser, isPlatformServer, NgClass, AsyncPipe, JsonPipe } from '@angular/common';
 import { validateAsync, form } from '@angular/forms/signals';
 import * as i1 from '@angular/forms';
@@ -703,6 +703,585 @@ const registerSessionEnd = (owner, sessionEnd) => {
 };
 const readSessionEnd = (owner) => sessionEnds.get(owner) ?? null;
 
+const noop$2 = () => undefined;
+let registrar = null;
+/**
+ * Installs the real registry, or removes it with `null`. Called by `provideQueryDevtools()` and its test reset only.
+ * @internal
+ */
+const setQueryDevtoolsRegistrar = (fn) => {
+    registrar = fn;
+};
+/**
+ * Whether `provideQueryDevtools()` has been called on this page. When `false` every instrumentation
+ * site is a no-op, which is what a devtools UI gates itself on so a build that omits the provider
+ * renders nothing.
+ *
+ * It is answered by the `provideQueryDevtools()` call itself, which runs while the providers array is
+ * built - so it is already settled by the time an application bootstraps and needs no signal.
+ */
+const isQueryDevtoolsEnabled = () => registrar !== null;
+/**
+ * Registers an entry with the devtools registry. Returns an unregister callback. A no-op (returning
+ * a no-op callback) unless {@link provideQueryDevtools} has been called.
+ * @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;
+let overridesFactory = null;
+/**
+ * Installs the overrides recorder factory. Called by `provideQueryDevtools()`; nothing else may call it.
+ * @internal
+ */
+const setQueryDevtoolsOverridesFactory = (fn) => {
+    overridesFactory = fn;
+};
+/**
+ * An overrides 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 createQueryDevtoolsOverridesRecorder = () => overridesFactory?.() ?? 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;
+let mockResolver = null;
+/**
+ * Installs the fault resolver. Called by `provideQueryDevtools()`; nothing else may call it.
+ * @internal
+ */
+const setQueryDevtoolsFaultResolver = (fn) => {
+    faultResolver = fn;
+};
+/**
+ * Installs the mock resolver. Called by `provideQueryDevtools()`; nothing else may call it.
+ * @internal
+ */
+const setQueryDevtoolsMockResolver = (fn) => {
+    mockResolver = fn;
+};
+/**
+ * Whether the devtools can do anything to a request at all - inject a fault, or serve a mock instead of
+ * sending it. Checked before building the wrapper that resolves both per attempt, so a request in an app
+ * without devtools keeps the pipeline it always had.
+ * @internal
+ */
+const isQueryDevtoolsRequestInterceptionEnabled = () => faultResolver !== null || mockResolver !== null;
+/**
+ * The mock to serve one upcoming attempt instead of sending it, or `null` to let it through.
+ * @internal
+ */
+const resolveQueryDevtoolsMock = (target) => mockResolver?.(target) ?? 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 tokenPayloadPatcher = null;
+/**
+ * Installs the access-token payload patcher. Called by `provideQueryDevtools()`; nothing else may call it.
+ * @internal
+ */
+const setQueryDevtoolsTokenPayloadPatcher = (fn) => {
+    tokenPayloadPatcher = fn;
+};
+/**
+ * A decoded access token as the devtools want it seen, which today means with an overridden lifetime
+ * applied. Returns the payload as decoded unless `provideQueryDevtools()` installed a patcher.
+ *
+ * Auth code must reach the override through this rather than importing the registry it lives in: a
+ * static import would pin that module into every bundle that builds an auth provider, and a runtime
+ * guard at the call site does not undo that.
+ * @internal
+ */
+const patchQueryDevtoolsTokenPayload = (options) => (tokenPayloadPatcher ? tokenPayloadPatcher(options) : options.payload);
+/** The batch item being created right now, or `null` outside one. */
+let batchOwner = null;
+/**
+ * Runs `create` with every query it creates attributed to `owner`'s batch and item. The attribution has
+ * to be ambient: a batch's item query is built by the query creator the caller handed it, which takes no
+ * devtools argument - so there is nothing to thread the owner through. Nested runs restore the outer one.
+ * @internal
+ */
+const runInQueryDevtoolsBatch = (owner, create) => {
+    const outer = batchOwner;
+    batchOwner = owner;
+    try {
+        return create();
+    }
+    finally {
+        batchOwner = outer;
+    }
+};
+/** The batch item a query being created belongs to, or `null` for one created outside a batch. @internal */
+const currentQueryDevtoolsBatch = () => batchOwner;
+let suppressStackRegistration = false;
+/**
+ * Suppresses devtools registration for the next {@link createQueryStack} call. Used by
+ * `createPagedQueryStack` so its backing stack is not registered as a separate `query-stack` entry.
+ * @internal
+ */
+const suppressNextQueryStackDevtools = () => {
+    suppressStackRegistration = true;
+};
+/**
+ * Reads and clears the suppress-next-stack flag. Always call this from `createQueryStack` (even when
+ * devtools are disabled) so a suppression request never leaks into a later stack.
+ * @internal
+ */
+const consumeSuppressQueryStackDevtools = () => {
+    const value = suppressStackRegistration;
+    suppressStackRegistration = false;
+    return value;
+};
+let authProviderRegistrar = null;
+/**
+ * Installs the session vault's provider registrar. Called by `provideQueryDevtools()`; nothing else may
+ * call it.
+ * @internal
+ */
+const setQueryDevtoolsAuthProviderRegistrar = (fn) => {
+    authProviderRegistrar = fn;
+};
+/**
+ * Hands one auth provider to the devtools' session vault, which then keeps the live session's tokens in
+ * step with the stored one. A no-op without `provideQueryDevtools()`.
+ * @internal
+ */
+const registerQueryDevtoolsAuthProvider = (registration) => authProviderRegistrar?.(registration) ?? (() => undefined);
+let authSeedReader = null;
+/**
+ * Installs the tab-local session reader. Called by `provideQueryDevtools()`; nothing else may call it.
+ * @internal
+ */
+const setQueryDevtoolsAuthSeedReader = (fn) => {
+    authSeedReader = fn;
+};
+/**
+ * The session the panel put in this tab alone, or `null` for a tab on the shared one. Read once while a
+ * provider is built, before its features run: the tokens have to be in place before `withPersistentAuth`
+ * decides whether to spend its cookie.
+ * @internal
+ */
+const readQueryDevtoolsAuthSeed = (providerName) => authSeedReader?.(providerName) ?? null;
+
+// codes 0-999
+const QueryRuntimeErrorCode = {
+    // Query
+    QUERY_FEATURE_USED_MULTIPLE_TIMES: 0,
+    QUERY_CREATED_IN_REACTIVE_CONTEXT: 1,
+    INVALIDATES_USED_ON_READ: 2,
+    QUERY_CREATED_OUTSIDE_INJECTION_CONTEXT: 3,
+    // Routes
+    INVALID_BASE_URL: 10,
+    INVALID_ROUTE: 11,
+    PATH_PARAMS_MISSING_IN_ROUTE_FUNCTION: 12,
+    // Query features
+    WITH_ARGS_QUERY_FEATURE_MISSING_BUT_ROUTE_IS_FUNCTION: 100,
+    WITH_POLLING_USED_ON_UNSUPPORTED_HTTP_METHOD: 101,
+    WITH_AUTO_REFRESH_USED_ON_UNSUPPORTED_HTTP_METHOD: 102,
+    WITH_AUTO_REFRESH_USED_IN_MANUAL_QUERY: 103,
+    SILENCE_MISSING_WITH_ARGS_FEATURE_ERROR_USED_BUT_WITH_ARGS_PRESENT: 104,
+    WITH_LONG_POLLING_USED_ON_UNSUPPORTED_HTTP_METHOD: 105,
+    WITH_LONG_POLLING_USED_WITH_POLLING: 106,
+    WITH_OPTIMISTIC_UPDATE_USED_ON_READ: 107,
+    // Auth provider
+    AUTH_EXTRACT_TOKENS_RESPONSE_NOT_OBJECT: 200,
+    AUTH_EXTRACT_TOKENS_RESPONSE_MISSING_ACCESS_TOKEN: 201,
+    AUTH_EXTRACT_TOKENS_RESPONSE_MISSING_REFRESH_TOKEN: 202,
+    AUTH_PROVIDER_FEATURE_USED_MULTIPLE_TIMES: 203,
+    AUTH_ACCESS_TOKEN_EXPIRY_UNREADABLE: 204,
+    // Query client
+    QUERY_CLIENT_FEATURE_USED_MULTIPLE_TIMES: 250,
+    // Query Repository
+    UNCACHEABLE_REQUEST_HAS_CACHE_KEY_PARAM: 300,
+    UNCACHEABLE_REQUEST_HAS_ALLOW_CACHE_PARAM: 301,
+    // Paged Query Stack
+    PAGED_QUERY_STACK_PAGE_BIGGER_THAN_TOTAL_PAGES: 400,
+    PAGED_QUERY_STACK_NEXT_PAGE_CALLED_WITHOUT_PREVIOUS_PAGE: 401,
+    PAGED_QUERY_STACK_PREVIOUS_PAGE_CALLED_BUT_ALREADY_AT_FIRST_PAGE: 402,
+    // Query Stack
+    QUERY_STACK_WITH_ARGS_USED: 500,
+    QUERY_STACK_WITH_RESPONSE_UPDATE_USED: 501,
+    // GQL
+    GQL_DATA_PROPERTY_MISSING_IN_RESPONSE: 600,
+    GQL_ERRORS_IN_RESPONSE: 601,
+    // Secure Execute
+    TOKENS_NOT_AVAILABLE_INSIDE_AUTH_AND_EXEC: 700,
+    INVALID_STATE_INSIDE_SECURE_EXECUTE_FACTORY: 701,
+    // Query Execution
+    CIRCULAR_QUERY_DEPENDENCY: 800,
+    // Query Sequence
+    QUERY_SEQUENCE_ALREADY_RUNNING: 900,
+    // Query Batch
+    QUERY_BATCH_ALREADY_RUNNING: 910,
+    QUERY_BATCH_WITH_ARGS_USED: 911,
+    // Legacy interop
+    LEGACY_PREPARE_WITHOUT_INJECTION_CONTEXT: 950,
+    LEGACY_QUERY_STATE_ALREADY_HAS_KEY: 951,
+    LEGACY_QUERY_STATE_DOES_NOT_CONTAIN_KEY: 952,
+    LEGACY_QUERY_STATE_CANNOT_TRANSFORM: 953,
+    LEGACY_INVALID_BODY: 954,
+};
+const queryFeatureUsedMultipleTimes = (type) => {
+    return new RuntimeError(QueryRuntimeErrorCode.QUERY_FEATURE_USED_MULTIPLE_TIMES, `The query feature "${type}()" was used multiple times.`);
+};
+const queryCreatedInReactiveContext = () => {
+    return new RuntimeError(QueryRuntimeErrorCode.QUERY_CREATED_IN_REACTIVE_CONTEXT, `A query was created inside a reactive context (a computed, an effect or a template). Every re-run would create another query that lives until its injector is destroyed. Create the query in a field initializer or constructor and change its args instead.`);
+};
+const invalidatesUsedOnRead = (method) => {
+    return new RuntimeError(QueryRuntimeErrorCode.INVALIDATES_USED_ON_READ, `This is a "${method}" request, "invalidates" is only supported on mutations. Give the read "tags" and invalidate them from the mutation.`);
+};
+const withOptimisticUpdateUsedOnRead = (method) => {
+    return new RuntimeError(QueryRuntimeErrorCode.WITH_OPTIMISTIC_UPDATE_USED_ON_READ, `This is a "${method}" request, "withOptimisticUpdate()" is only supported on mutations.`);
+};
+const withArgsQueryFeatureMissingButRouteIsFunction = () => {
+    return new RuntimeError(QueryRuntimeErrorCode.WITH_ARGS_QUERY_FEATURE_MISSING_BUT_ROUTE_IS_FUNCTION, `This queries route is a function, but a "withArgs()" feature is missing. Mutations need one too: create the query with "withArgs(() => ({ body: form.value() }))", then call ".execute()". The "silenceMissingWithArgsFeatureError" config is an escape hatch for args that only exist at call time.`);
+};
+const withPollingUsedOnUnsupportedHttpMethod = (method) => {
+    return new RuntimeError(QueryRuntimeErrorCode.WITH_POLLING_USED_ON_UNSUPPORTED_HTTP_METHOD, `This is a "${method}" request, "withPolling()" is only supported for GET, HEAD, OPTIONS requests and GQL queries.`);
+};
+const withAutoRefreshUsedOnUnsupportedHttpMethod = (method) => {
+    return new RuntimeError(QueryRuntimeErrorCode.WITH_AUTO_REFRESH_USED_ON_UNSUPPORTED_HTTP_METHOD, `This is a "${method}" request, "withAutoRefresh()" is only supported for GET, HEAD, OPTIONS requests and GQL queries.`);
+};
+const withAutoRefreshUsedInManualQuery = () => {
+    return new RuntimeError(QueryRuntimeErrorCode.WITH_AUTO_REFRESH_USED_IN_MANUAL_QUERY, `"withAutoRefresh()" has been used inside a query that has "onlyManualExecution" set to true.` +
+        ` If this is intentional, set "ignoreOnlyManualExecution" to true inside the auto refresh config.`);
+};
+const withLongPollingUsedOnUnsupportedHttpMethod = (method) => {
+    return new RuntimeError(QueryRuntimeErrorCode.WITH_LONG_POLLING_USED_ON_UNSUPPORTED_HTTP_METHOD, `This is a "${method}" request, "withLongPolling()" is only supported for GET, HEAD, OPTIONS requests and GQL queries.`);
+};
+const withLongPollingUsedWithPolling = () => {
+    return new RuntimeError(QueryRuntimeErrorCode.WITH_LONG_POLLING_USED_WITH_POLLING, `"withLongPolling()" and "withPolling()" cannot be used on the same query - both would drive its re-execution.` +
+        ` Keep the long polling feature and drop the interval, or the other way around.`);
+};
+const silenceMissingWithArgsFeatureErrorUsedButWithArgsPresent = () => {
+    return new RuntimeError(QueryRuntimeErrorCode.SILENCE_MISSING_WITH_ARGS_FEATURE_ERROR_USED_BUT_WITH_ARGS_PRESENT, `The "silenceMissingWithArgsFeatureError" config is set to true, but a "withArgs()" feature is present.`);
+};
+const authExtractTokensResponseNotObject = () => {
+    return new RuntimeError(QueryRuntimeErrorCode.AUTH_EXTRACT_TOKENS_RESPONSE_NOT_OBJECT, `The auth token extractor expects the response to be an object.`);
+};
+const authExtractTokensResponseMissingAccessToken = () => {
+    return new RuntimeError(QueryRuntimeErrorCode.AUTH_EXTRACT_TOKENS_RESPONSE_MISSING_ACCESS_TOKEN, `The auth token extractor expects the response to contain a string "accessToken" property.`);
+};
+const authExtractTokensResponseMissingRefreshToken = () => {
+    return new RuntimeError(QueryRuntimeErrorCode.AUTH_EXTRACT_TOKENS_RESPONSE_MISSING_REFRESH_TOKEN, `The auth token extractor expects the response to contain a string "refreshToken" property.`);
+};
+const authProviderFeatureUsedMultipleTimes = (type) => {
+    return new RuntimeError(QueryRuntimeErrorCode.AUTH_PROVIDER_FEATURE_USED_MULTIPLE_TIMES, `Bearer auth feature "${type}" was used multiple times.`);
+};
+const authAccessTokenExpiryUnreadable = (claim) => {
+    return new RuntimeError(QueryRuntimeErrorCode.AUTH_ACCESS_TOKEN_EXPIRY_UNREADABLE, `The access token has no numeric "${claim}" claim, neither in what bearerDecryptFn returned nor in its JWT payload, so it is never refreshed before it expires. Keep the claim in the bearerDecryptFn result, or set the refresh query's expiresInPropertyName to the claim that carries the expiry.`);
+};
+const queryClientFeatureUsedMultipleTimes = (type) => {
+    return new RuntimeError(QueryRuntimeErrorCode.QUERY_CLIENT_FEATURE_USED_MULTIPLE_TIMES, `Query client feature "${type}" was used multiple times.`);
+};
+const uncacheableRequestHasCacheKeyParam = (key) => {
+    return new RuntimeError(QueryRuntimeErrorCode.UNCACHEABLE_REQUEST_HAS_CACHE_KEY_PARAM, `This request is uncacheable, but a cache key was provided: ${key}. Please remove it.`);
+};
+const uncacheableRequestHasAllowCacheParam = () => {
+    return new RuntimeError(QueryRuntimeErrorCode.UNCACHEABLE_REQUEST_HAS_ALLOW_CACHE_PARAM, `This request is uncacheable, but allowCache is set to true. Please remove it.`);
+};
+const pagedQueryStackPageBiggerThanTotalPages = (page, totalPages) => {
+    return new RuntimeError(QueryRuntimeErrorCode.PAGED_QUERY_STACK_PAGE_BIGGER_THAN_TOTAL_PAGES, `The page "${page}" is bigger than the total pages "${totalPages}".`);
+};
+const pagedQueryStackNextPageCalledWithoutPreviousPage = () => {
+    return new RuntimeError(QueryRuntimeErrorCode.PAGED_QUERY_STACK_NEXT_PAGE_CALLED_WITHOUT_PREVIOUS_PAGE, `fetchNextPage() has been called but the current page is not yet loaded. Please call it after the previous page has been loaded.`);
+};
+const pagedQueryStackPreviousPageCalledButAlreadyAtFirstPage = () => {
+    return new RuntimeError(QueryRuntimeErrorCode.PAGED_QUERY_STACK_PREVIOUS_PAGE_CALLED_BUT_ALREADY_AT_FIRST_PAGE, `fetchPreviousPage() has been called but the current page is already the first page.`);
+};
+const queryStackWithArgsUsed = () => {
+    return new RuntimeError(QueryRuntimeErrorCode.QUERY_STACK_WITH_ARGS_USED, `withArgs() has been used in a query stack or a paged query stack. This is not supported.`);
+};
+const queryStackWithResponseUpdateUsed = () => {
+    return new RuntimeError(QueryRuntimeErrorCode.QUERY_STACK_WITH_RESPONSE_UPDATE_USED, `withResponseUpdate() has been used in a query stack or a paged query stack. This is not supported.`);
+};
+const gqlDataPropertyMissingInResponse = () => {
+    return new RuntimeError(QueryRuntimeErrorCode.GQL_DATA_PROPERTY_MISSING_IN_RESPONSE, `The GraphQL response is missing the required "data" property. Please add a custom transformResponse param to the query creator to handle this response format.`);
+};
+const gqlErrorsInResponse = (errors) => {
+    return new HttpErrorResponse({
+        error: errors,
+        status: 0,
+        statusText: new RuntimeError(QueryRuntimeErrorCode.GQL_ERRORS_IN_RESPONSE, `The GraphQL response carries errors and no data. The server's errors are in raw.error.`).message,
+    });
+};
+const tokensNotAvailableInsideAuthAndExec = () => {
+    return new RuntimeError(QueryRuntimeErrorCode.TOKENS_NOT_AVAILABLE_INSIDE_AUTH_AND_EXEC, `Tokens are not available inside authAndExec.`);
+};
+const invalidStateInsideSecureExecuteFactory = () => {
+    return new RuntimeError(QueryRuntimeErrorCode.INVALID_STATE_INSIDE_SECURE_EXECUTE_FACTORY, `An invalid state occurred inside the secure execute factory.`);
+};
+const circularQueryDependency = () => {
+    return new RuntimeError(QueryRuntimeErrorCode.CIRCULAR_QUERY_DEPENDENCY, `The same query was executed with identical args more than 5 times in a row, less than 100ms apart. This is usually a sign of a circular dependency.`);
+};
+const queryExecutedAfterDestroyMessage = (route) => {
+    const target = typeof route === 'string' ? `The query for "${route}"` : 'A query with a function route';
+    return `${target} was executed after the scope that created it was destroyed. The call was ignored - drop the reference to the query when its component or injector goes away.`;
+};
+const queryExecutedWhileParkedMessage = (route) => {
+    const target = typeof route === 'string' ? `The query for "${route}"` : 'A query with a function route';
+    return `${target} was executed while its withArgs source returned null (parked). The call was ignored - pass args to execute(), or let the source return them.`;
+};
+const legacyPrepareWithoutInjectionContext = (creatorName, method = 'prepare') => {
+    const label = creatorName ? `"${creatorName}"` : 'A legacy query creator';
+    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` +
+        `${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 = () => {
+    return new RuntimeError(QueryRuntimeErrorCode.QUERY_SEQUENCE_ALREADY_RUNNING, `run() was called on a query sequence that is already running. Wait for the current run to settle before starting another.`);
+};
+const queryBatchAlreadyRunning = () => {
+    return new RuntimeError(QueryRuntimeErrorCode.QUERY_BATCH_ALREADY_RUNNING, `run() or retryFailed() was called on a query batch that is already running. Await the current run, or call cancel() first.`);
+};
+const queryBatchWithArgsUsed = () => {
+    return new RuntimeError(QueryRuntimeErrorCode.QUERY_BATCH_WITH_ARGS_USED, `The "withArgs()" feature cannot be used inside a query batch. Each item's args come from the batch's "args" option.`);
+};
+
+/**
+ * Route building, query-string serialization and the token clock - shared by the current generation and
+ * the legacy V2 client, which re-exports them under their original names.
+ */
+const invalidBaseRouteError$1 = (base) => new RuntimeError(QueryRuntimeErrorCode.INVALID_BASE_URL, `The client base URL "${base}" must not end with "/". Drop the trailing slash.`);
+const invalidRouteError$1 = (route) => new RuntimeError(QueryRuntimeErrorCode.INVALID_ROUTE, `The route "${route}" must start with "/". Write it as "/${route}".`);
+const pathParamsMissingInRouteFunctionError$1 = (route) => new RuntimeError(QueryRuntimeErrorCode.PATH_PARAMS_MISSING_IN_ROUTE_FUNCTION, `The route "${route}" is a function, but the query was executed without pathParams. Pass them through withArgs(() => ({ pathParams })) or execute({ args: { pathParams } }).`);
+const isNaN$2 = (value) => typeof value === 'number' && Number.isNaN(value);
+const isEmptyString$1 = (value) => typeof value === 'string' && value.trim() === '';
+const buildQueryString$1 = (params, config) => {
+    const objectNotation = config?.objectNotation ?? 'bracket';
+    const writeArrayIndexes = config?.writeArrayIndexes ?? false;
+    const ignoredValues = config?.ignoredValues ?? [undefined, null, Infinity, -Infinity];
+    const ignoredValuesFns = config?.ignoredValuesFns ?? [isNaN$2, isEmptyString$1];
+    const queryParams = [];
+    function processValue(key, rawValue) {
+        if (rawValue instanceof Date && Number.isNaN(rawValue.getTime()))
+            return false;
+        const value = rawValue instanceof Date ? rawValue.toISOString() : rawValue;
+        if (config?.objectNotation === 'json-stringify') {
+            if (value === undefined) {
+                return false;
+            }
+            if (ignoredValues.includes(value)) {
+                return false;
+            }
+            if (ignoredValuesFns.some((fn) => fn(value))) {
+                return false;
+            }
+            const encodedKey = encodeURIComponent(key);
+            const val = typeof value === 'object' ? JSON.stringify(value) : value;
+            const encodedValue = encodeURIComponent(val);
+            queryParams.push(`${encodedKey}=${encodedValue}`);
+            return true;
+        }
+        else if (Array.isArray(value)) {
+            let currentFilteredIndex = 0;
+            let didAddAnyValue = false;
+            for (const arrayValue of value) {
+                const nestedKey = writeArrayIndexes ? `${key}[${currentFilteredIndex}]` : `${key}[]`;
+                const didAddValue = processValue(nestedKey, arrayValue);
+                if (didAddValue) {
+                    currentFilteredIndex++;
+                    didAddAnyValue = true;
+                }
+            }
+            return didAddAnyValue;
+        }
+        else if (typeof value === 'object' && value !== null) {
+            let didAddAnyValue = false;
+            for (const [objKey, val] of Object.entries(value)) {
+                const nestedKey = objectNotation === 'dot' ? `${key}.${objKey}` : `${key}[${objKey}]`;
+                didAddAnyValue = processValue(nestedKey, val) || didAddAnyValue;
+            }
+            return didAddAnyValue;
+        }
+        else {
+            if (ignoredValues.includes(value)) {
+                return false;
+            }
+            if (ignoredValuesFns.some((fn) => fn(value))) {
+                return false;
+            }
+            const encodedKey = encodeURIComponent(key);
+            const encodedValue = encodeURIComponent(value);
+            queryParams.push(`${encodedKey}=${encodedValue}`);
+            return true;
+        }
+    }
+    for (const [key, val] of Object.entries(params)) {
+        processValue(key, val);
+    }
+    return queryParams.length ? queryParams.join('&') : null;
+};
+const isPlainObject = (value) => {
+    if (!value || typeof value !== 'object')
+        return false;
+    const proto = Object.getPrototypeOf(value);
+    return proto === Object.prototype || proto === null;
+};
+/** Copies query params with every plain object's keys sorted, so key order never reaches a cache key. */
+const sortQueryParamKeys = (value) => {
+    if (Array.isArray(value))
+        return value.map(sortQueryParamKeys);
+    if (!isPlainObject(value))
+        return value;
+    return Object.fromEntries(Object.keys(value)
+        .sort()
+        .map((key) => [key, sortQueryParamKeys(value[key])]));
+};
+const buildRoute$1 = (options) => {
+    if (options.base.endsWith('/')) {
+        throw invalidBaseRouteError$1(options.base);
+    }
+    let route;
+    if (typeof options.route === 'function') {
+        if (!options.pathParams) {
+            throw pathParamsMissingInRouteFunctionError$1(options.route({}));
+        }
+        route = options.route(options.pathParams);
+    }
+    else {
+        route = options.route ?? null;
+    }
+    if (route && !route.startsWith('/')) {
+        throw invalidRouteError$1(route);
+    }
+    if (options.queryParams) {
+        const queryString = buildQueryString$1(options.queryParams, options.queryParamConfig);
+        if (queryString) {
+            route = route ? `${route}${route.includes('?') ? '&' : '?'}${queryString}` : `/?${queryString}`;
+        }
+    }
+    return `${options.base}${route ?? ''}`;
+};
+const buildTimestampFromSeconds$1 = (seconds) => {
+    if (seconds === null || Number.isNaN(seconds)) {
+        return null;
+    }
+    return new Date(Date.now() + seconds * 1000).getTime();
+};
+/** Reads a bearer token's payload. */
+const decryptBearer$1 = (token) => {
+    try {
+        const base64Url = token.split('.')[1];
+        if (!base64Url) {
+            return null;
+        }
+        const base64 = base64Url.replace(/-/g, '+').replace(/_/g, '/');
+        const jsonPayload = decodeURIComponent(atob(base64)
+            .split('')
+            .map((c) => '%' + ('00' + c.charCodeAt(0).toString(16)).slice(-2))
+            .join(''));
+        return JSON.parse(jsonPayload);
+    }
+    catch (error) {
+        console.error('Invalid bearer token', error);
+        return null;
+    }
+};
+
+const readClaim = (payload, claim) => {
+    const value = payload?.[claim];
+    return typeof value === 'number' ? value : null;
+};
+/**
+ * The expiry and issue time of an access token. `decoded` (what `bearerDecryptFn` returned) is tried
+ * first and the raw JWT payload second, so a `bearerDecryptFn` that maps the claims to an app user does
+ * not hide the expiry.
+ */
+const readAccessTokenTimes = (options) => {
+    const { token, claim, providerName } = options;
+    const patch = (payload) => patchQueryDevtoolsTokenPayload({ payload, providerName, expiresInPropertyName: claim });
+    const candidates = [() => patch(options.decoded), () => patch(decryptBearer$1(token))];
+    for (const candidate of candidates) {
+        let payload;
+        try {
+            payload = candidate();
+        }
+        catch {
+            continue;
+        }
+        const exp = readClaim(payload, claim);
+        if (exp === null)
+            continue;
+        const iat = readClaim(payload, 'iat');
+        return { expiresAtMs: exp * 1000, issuedAtMs: iat === null ? null : iat * 1000 };
+    }
+    return null;
+};
+const refreshBufferMs = (strategy, tokenLifetimeMs) => {
+    if (typeof strategy === 'number') {
+        return strategy >= 0 && strategy <= 1 ? tokenLifetimeMs * (1 - strategy) : Math.max(strategy, 0);
+    }
+    const percentage = strategy?.percentage ?? 0.75;
+    const minBufferMs = strategy?.minBufferMs ?? 60_000;
+    const maxBufferMs = strategy?.maxBufferMs ?? 600_000;
+    return Math.max(minBufferMs, Math.min(maxBufferMs, tokenLifetimeMs * (1 - percentage)));
+};
+
 const DEFAULT_RETURN_URL_PARAM = 'returnUrl';
 const DEFAULT_URL = '/';
 const DEFAULT_RESTORE_TIMEOUT_MS = 10000;
@@ -879,272 +1458,53 @@ const createAuthGuard = (providerRef, config) => {
             return readReturnUrl(router, router.url, param);
         },
         navigateAfterLogin: () => {
-            const router = inject(Router);
-            return defer(() => {
-                const returnUrl = readReturnUrl(router, router.url, param);
-                return from(router.navigateByUrl(returnUrl ?? resolveTarget(router, config.defaultUrl ?? DEFAULT_URL)));
-            });
-        },
-    };
-};
-
-/**
- * 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;
-/**
- * Installs the real registry. Called by `provideQueryDevtools()`; nothing else may call it.
- * @internal
- */
-const setQueryDevtoolsRegistrar = (fn) => {
-    registrar = fn;
-};
-/**
- * Whether `provideQueryDevtools()` has been called on this page. When `false` every instrumentation
- * site is a no-op, which is what a devtools UI gates itself on so a build that omits the provider
- * renders nothing.
- *
- * It is answered by the `provideQueryDevtools()` call itself, which runs while the providers array is
- * built - so it is already settled by the time an application bootstraps and needs no signal.
- */
-const isQueryDevtoolsEnabled = () => registrar !== null;
-/**
- * Registers an entry with the devtools registry. Returns an unregister callback. A no-op (returning
- * a no-op callback) unless {@link provideQueryDevtools} has been called.
- * @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;
-let overridesFactory = null;
-/**
- * Installs the overrides recorder factory. Called by `provideQueryDevtools()`; nothing else may call it.
- * @internal
- */
-const setQueryDevtoolsOverridesFactory = (fn) => {
-    overridesFactory = fn;
-};
-/**
- * An overrides 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 createQueryDevtoolsOverridesRecorder = () => overridesFactory?.() ?? 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;
-let mockResolver = null;
-/**
- * Installs the fault resolver. Called by `provideQueryDevtools()`; nothing else may call it.
- * @internal
- */
-const setQueryDevtoolsFaultResolver = (fn) => {
-    faultResolver = fn;
-};
-/**
- * Installs the mock resolver. Called by `provideQueryDevtools()`; nothing else may call it.
- * @internal
- */
-const setQueryDevtoolsMockResolver = (fn) => {
-    mockResolver = fn;
-};
-/**
- * Whether the devtools can do anything to a request at all - inject a fault, or serve a mock instead of
- * sending it. Checked before building the wrapper that resolves both per attempt, so a request in an app
- * without devtools keeps the pipeline it always had.
- * @internal
- */
-const isQueryDevtoolsRequestInterceptionEnabled = () => faultResolver !== null || mockResolver !== null;
-/**
- * The mock to serve one upcoming attempt instead of sending it, or `null` to let it through.
- * @internal
- */
-const resolveQueryDevtoolsMock = (target) => mockResolver?.(target) ?? 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 tokenPayloadPatcher = null;
-/**
- * Installs the access-token payload patcher. Called by `provideQueryDevtools()`; nothing else may call it.
- * @internal
- */
-const setQueryDevtoolsTokenPayloadPatcher = (fn) => {
-    tokenPayloadPatcher = fn;
-};
-/**
- * A decoded access token as the devtools want it seen, which today means with an overridden lifetime
- * applied. Returns the payload as decoded unless `provideQueryDevtools()` installed a patcher.
- *
- * Auth code must reach the override through this rather than importing the registry it lives in: a
- * static import would pin that module into every bundle that builds an auth provider, and a runtime
- * guard at the call site does not undo that.
- * @internal
- */
-const patchQueryDevtoolsTokenPayload = (options) => (tokenPayloadPatcher ? tokenPayloadPatcher(options) : options.payload);
-/** The batch item being created right now, or `null` outside one. */
-let batchOwner = null;
-/**
- * Runs `create` with every query it creates attributed to `owner`'s batch and item. The attribution has
- * to be ambient: a batch's item query is built by the query creator the caller handed it, which takes no
- * devtools argument - so there is nothing to thread the owner through. Nested runs restore the outer one.
- * @internal
- */
-const runInQueryDevtoolsBatch = (owner, create) => {
-    const outer = batchOwner;
-    batchOwner = owner;
-    try {
-        return create();
-    }
-    finally {
-        batchOwner = outer;
-    }
-};
-/** The batch item a query being created belongs to, or `null` for one created outside a batch. @internal */
-const currentQueryDevtoolsBatch = () => batchOwner;
-let suppressStackRegistration = false;
-/**
- * Suppresses devtools registration for the next {@link createQueryStack} call. Used by
- * `createPagedQueryStack` so its backing stack is not registered as a separate `query-stack` entry.
- * @internal
- */
-const suppressNextQueryStackDevtools = () => {
-    suppressStackRegistration = true;
+            const router = inject(Router);
+            return defer(() => {
+                const returnUrl = readReturnUrl(router, router.url, param);
+                return from(router.navigateByUrl(returnUrl ?? resolveTarget(router, config.defaultUrl ?? DEFAULT_URL)));
+            });
+        },
+    };
 };
+
 /**
- * Reads and clears the suppress-next-stack flag. Always call this from `createQueryStack` (even when
- * devtools are disabled) so a suppression request never leaks into a later stack.
+ * Turns the features applied at creation into their devtools representation.
  * @internal
  */
-const consumeSuppressQueryStackDevtools = () => {
-    const value = suppressStackRegistration;
-    suppressStackRegistration = false;
-    return value;
-};
-let authProviderRegistrar = null;
+const describeQueryDevtoolsFeatures = (features) => features?.map((feature) => ({ type: feature.type, details: feature.devtools?.() ?? [] })) ?? [];
 /**
- * Installs the session vault's provider registrar. Called by `provideQueryDevtools()`; nothing else may
- * call it.
+ * Renders a millisecond duration the way feature details spell one out - `500ms`, `1.5s`, `15m`.
  * @internal
  */
-const setQueryDevtoolsAuthProviderRegistrar = (fn) => {
-    authProviderRegistrar = fn;
+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');
 };
 /**
- * Hands one auth provider to the devtools' session vault, which then keeps the live session's tokens in
- * step with the stored one. A no-op without `provideQueryDevtools()`.
- * @internal
- */
-const registerQueryDevtoolsAuthProvider = (registration) => authProviderRegistrar?.(registration) ?? (() => undefined);
-let authSeedReader = null;
-/**
- * Installs the tab-local session reader. Called by `provideQueryDevtools()`; nothing else may call it.
- * @internal
+ * 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 setQueryDevtoolsAuthSeedReader = (fn) => {
-    authSeedReader = fn;
+const queryDevtoolsFnName = (fn, key) => {
+    const name = typeof fn === 'function' ? fn.name.replace(/^bound /, '') : '';
+    return !name || name === key ? null : name;
 };
 /**
- * The session the panel put in this tab alone, or `null` for a tab on the shared one. Read once while a
- * provider is built, before its features run: the tokens have to be in place before `withPersistentAuth`
- * decides whether to spend its cookie.
+ * A detail for the function passed as `options.<key>`, omitted when it is an inline lambda.
  * @internal
  */
-const readQueryDevtoolsAuthSeed = (providerName) => authSeedReader?.(providerName) ?? null;
+const queryDevtoolsFnDetail = (fn, key) => {
+    const name = queryDevtoolsFnName(fn, key);
+    return name ? [{ label: key, value: name }] : [];
+};
 
 /**
  * Whether a create-query options object came from the gql layer - only gql's `creatorInternals` carries
@@ -1153,21 +1513,105 @@ const readQueryDevtoolsAuthSeed = (providerName) => authSeedReader?.(providerNam
  */
 const isCreateGqlQueryOptions = (options) => 'transport' in options.creatorInternals;
 
-const wrapAsObservableSignal = (source, defaultInjector) => {
-    const default$ = toObservable(source, { injector: defaultInjector });
-    const overrides = new WeakMap();
-    const asObservable = (options) => {
-        const injector = options?.injector;
-        if (!injector)
+const createObservableSignalWatcher = (injector) => {
+    const destroyRef = injector.get(DestroyRef);
+    const watched = [];
+    const registrations = signal(0, /* @ts-ignore */
+    ...(ngDevMode ? [{ debugName: "registrations" }] : /* istanbul ignore next */ []));
+    let watching = false;
+    let destroyed = false;
+    const push = (entry) => {
+        if (entry.subject.closed || entry.subject.isStopped)
+            return;
+        let value;
+        try {
+            value = entry.source();
+        }
+        catch (error) {
+            untracked(() => entry.subject.error(error));
+            return;
+        }
+        if (entry.hasValue && Object.is(value, entry.last))
+            return;
+        entry.hasValue = true;
+        entry.last = value;
+        untracked(() => entry.subject.next(value));
+    };
+    const startWatching = () => {
+        if (watching)
+            return;
+        watching = true;
+        effect(() => {
+            registrations();
+            for (const entry of watched)
+                push(entry);
+        }, { injector });
+        destroyRef.onDestroy(() => {
+            destroyed = true;
+            for (const entry of watched)
+                entry.subject.complete();
+        });
+    };
+    const watch = (source) => {
+        const entry = { source, subject: new ReplaySubject(1), hasValue: false, last: undefined };
+        if (destroyed || destroyRef.destroyed) {
+            push(entry);
+            entry.subject.complete();
+            return entry;
+        }
+        startWatching();
+        watched.push(entry);
+        push(entry);
+        registrations.update((count) => count + 1);
+        return entry;
+    };
+    const wrap = (source) => {
+        let default$ = null;
+        const overrides = new WeakMap();
+        const getDefault = () => {
+            if (default$)
+                return default$;
+            const entry = untracked(() => watch(source));
+            default$ = new Observable((subscriber) => {
+                untracked(() => push(entry));
+                return entry.subject.subscribe(subscriber);
+            });
             return default$;
-        const existing = overrides.get(injector);
-        if (existing)
-            return existing;
-        const override$ = untracked(() => toObservable(source, { injector }).pipe(takeUntilDestroyed(defaultInjector.get(DestroyRef))));
-        overrides.set(injector, override$);
-        return override$;
+        };
+        const asObservable = (options) => {
+            const overrideInjector = options?.injector;
+            if (!overrideInjector)
+                return getDefault();
+            const existing = overrides.get(overrideInjector);
+            if (existing)
+                return existing;
+            const override$ = getDefault().pipe(takeUntilDestroyed(overrideInjector.get(DestroyRef)));
+            overrides.set(overrideInjector, override$);
+            return override$;
+        };
+        return Object.assign(computed(() => source()), { asObservable });
     };
-    return Object.assign(computed(() => source()), { asObservable });
+    return { wrap };
+};
+
+// Angular has no public check for an injection context; `inject()` outside one throws NG0203 (`code: -203`).
+const MISSING_INJECTION_CONTEXT = -203;
+const queryCreatedOutsideInjectionContext = (kind) => {
+    const fix = kind === 'query'
+        ? 'or pass an injector as the first creator argument: getPost({ injector: this.injector }, withArgs(...))'
+        : 'or wrap the call in runInInjectionContext(this.injector, () => ...)';
+    return new RuntimeError(QueryRuntimeErrorCode.QUERY_CREATED_OUTSIDE_INJECTION_CONTEXT, `A ${kind} was created outside an injection context (in ngOnInit, an event handler or a timer). Create it in a field initializer or constructor, ${fix}.`);
+};
+const injectInQueryContext = (token, kind) => {
+    try {
+        return inject(token);
+    }
+    catch (error) {
+        if (error?.code === MISSING_INJECTION_CONTEXT) {
+            throw queryCreatedOutsideInjectionContext(kind);
+        }
+        throw error;
+    }
 };
 
 const QUERY_CONTEXT_TOKEN = new InjectionToken('QUERY_CONTEXT');
@@ -1181,7 +1625,7 @@ const injectQueryContext = () => inject(QUERY_CONTEXT_TOKEN);
 
 /** @internal */
 const setupQueryDependencies = (options) => {
-    const hostInjector = options.queryConfig?.injector ?? inject(Injector);
+    const hostInjector = options.queryConfig?.injector ?? injectInQueryContext(Injector, 'query');
     const environmentInjector = options.queryConfig?.injector?.get(EnvironmentInjector) ?? hostInjector.get(EnvironmentInjector);
     const clientToken = options.client.token;
     const dependencies = {
@@ -1223,165 +1667,6 @@ const setupQueryDependencies = (options) => {
     return dependencies;
 };
 
-// codes 0-999
-const QueryRuntimeErrorCode = {
-    // Query
-    QUERY_FEATURE_USED_MULTIPLE_TIMES: 0,
-    QUERY_CREATED_IN_REACTIVE_CONTEXT: 1,
-    // Query features
-    WITH_ARGS_QUERY_FEATURE_MISSING_BUT_ROUTE_IS_FUNCTION: 100,
-    WITH_POLLING_USED_ON_UNSUPPORTED_HTTP_METHOD: 101,
-    WITH_AUTO_REFRESH_USED_ON_UNSUPPORTED_HTTP_METHOD: 102,
-    WITH_AUTO_REFRESH_USED_IN_MANUAL_QUERY: 103,
-    SILENCE_MISSING_WITH_ARGS_FEATURE_ERROR_USED_BUT_WITH_ARGS_PRESENT: 104,
-    WITH_LONG_POLLING_USED_ON_UNSUPPORTED_HTTP_METHOD: 105,
-    WITH_LONG_POLLING_USED_WITH_POLLING: 106,
-    // Auth provider
-    AUTH_EXTRACT_TOKENS_RESPONSE_NOT_OBJECT: 200,
-    AUTH_EXTRACT_TOKENS_RESPONSE_MISSING_ACCESS_TOKEN: 201,
-    AUTH_EXTRACT_TOKENS_RESPONSE_MISSING_REFRESH_TOKEN: 202,
-    AUTH_PROVIDER_FEATURE_USED_MULTIPLE_TIMES: 203,
-    // Query client
-    QUERY_CLIENT_FEATURE_USED_MULTIPLE_TIMES: 250,
-    // Query Repository
-    UNCACHEABLE_REQUEST_HAS_CACHE_KEY_PARAM: 300,
-    UNCACHEABLE_REQUEST_HAS_ALLOW_CACHE_PARAM: 301,
-    // Paged Query Stack
-    PAGED_QUERY_STACK_PAGE_BIGGER_THAN_TOTAL_PAGES: 400,
-    PAGED_QUERY_STACK_NEXT_PAGE_CALLED_WITHOUT_PREVIOUS_PAGE: 401,
-    PAGED_QUERY_STACK_PREVIOUS_PAGE_CALLED_BUT_ALREADY_AT_FIRST_PAGE: 402,
-    // Query Stack
-    QUERY_STACK_WITH_ARGS_USED: 500,
-    QUERY_STACK_WITH_RESPONSE_UPDATE_USED: 501,
-    // GQL
-    GQL_DATA_PROPERTY_MISSING_IN_RESPONSE: 600,
-    GQL_ERRORS_IN_RESPONSE: 601,
-    // Secure Execute
-    TOKENS_NOT_AVAILABLE_INSIDE_AUTH_AND_EXEC: 700,
-    INVALID_STATE_INSIDE_SECURE_EXECUTE_FACTORY: 701,
-    // Query Execution
-    CIRCULAR_QUERY_DEPENDENCY: 800,
-    // Query Sequence
-    QUERY_SEQUENCE_ALREADY_RUNNING: 900,
-    // Query Batch
-    QUERY_BATCH_ALREADY_RUNNING: 910,
-    QUERY_BATCH_WITH_ARGS_USED: 911,
-    // Legacy interop
-    LEGACY_PREPARE_WITHOUT_INJECTION_CONTEXT: 950,
-    LEGACY_QUERY_STATE_ALREADY_HAS_KEY: 951,
-    LEGACY_QUERY_STATE_DOES_NOT_CONTAIN_KEY: 952,
-    LEGACY_QUERY_STATE_CANNOT_TRANSFORM: 953,
-    LEGACY_INVALID_BODY: 954,
-};
-const queryFeatureUsedMultipleTimes = (type) => {
-    return new RuntimeError(QueryRuntimeErrorCode.QUERY_FEATURE_USED_MULTIPLE_TIMES, `The query feature "${type}()" was used multiple times.`);
-};
-const queryCreatedInReactiveContext = () => {
-    return new RuntimeError(QueryRuntimeErrorCode.QUERY_CREATED_IN_REACTIVE_CONTEXT, `A query was created inside a reactive context (a computed, an effect or a template). Every re-run would create another query that lives until its injector is destroyed. Create the query in a field initializer or constructor and change its args instead.`);
-};
-const withArgsQueryFeatureMissingButRouteIsFunction = () => {
-    return new RuntimeError(QueryRuntimeErrorCode.WITH_ARGS_QUERY_FEATURE_MISSING_BUT_ROUTE_IS_FUNCTION, `This queries route is a function, but a "withArgs()" feature is missing. Mutations need one too: create the query with "withArgs(() => ({ body: form.value() }))", then call ".execute()". The "silenceMissingWithArgsFeatureError" config is an escape hatch for args that only exist at call time.`);
-};
-const withPollingUsedOnUnsupportedHttpMethod = (method) => {
-    return new RuntimeError(QueryRuntimeErrorCode.WITH_POLLING_USED_ON_UNSUPPORTED_HTTP_METHOD, `This is a "${method}" request, "withPolling()" is only supported for GET, HEAD, OPTIONS requests and GQL queries.`);
-};
-const withAutoRefreshUsedOnUnsupportedHttpMethod = (method) => {
-    return new RuntimeError(QueryRuntimeErrorCode.WITH_AUTO_REFRESH_USED_ON_UNSUPPORTED_HTTP_METHOD, `This is a "${method}" request, "withAutoRefresh()" is only supported for GET, HEAD, OPTIONS requests and GQL queries.`);
-};
-const withAutoRefreshUsedInManualQuery = () => {
-    return new RuntimeError(QueryRuntimeErrorCode.WITH_AUTO_REFRESH_USED_IN_MANUAL_QUERY, `"withAutoRefresh()" has been used inside a query that has "onlyManualExecution" set to true.` +
-        ` If this is intentional, set "ignoreOnlyManualExecution" to true inside the auto refresh config.`);
-};
-const withLongPollingUsedOnUnsupportedHttpMethod = (method) => {
-    return new RuntimeError(QueryRuntimeErrorCode.WITH_LONG_POLLING_USED_ON_UNSUPPORTED_HTTP_METHOD, `This is a "${method}" request, "withLongPolling()" is only supported for GET, HEAD, OPTIONS requests and GQL queries.`);
-};
-const withLongPollingUsedWithPolling = () => {
-    return new RuntimeError(QueryRuntimeErrorCode.WITH_LONG_POLLING_USED_WITH_POLLING, `"withLongPolling()" and "withPolling()" cannot be used on the same query - both would drive its re-execution.` +
-        ` Keep the long polling feature and drop the interval, or the other way around.`);
-};
-const silenceMissingWithArgsFeatureErrorUsedButWithArgsPresent = () => {
-    return new RuntimeError(QueryRuntimeErrorCode.SILENCE_MISSING_WITH_ARGS_FEATURE_ERROR_USED_BUT_WITH_ARGS_PRESENT, `The "silenceMissingWithArgsFeatureError" config is set to true, but a "withArgs()" feature is present.`);
-};
-const authExtractTokensResponseNotObject = () => {
-    return new RuntimeError(QueryRuntimeErrorCode.AUTH_EXTRACT_TOKENS_RESPONSE_NOT_OBJECT, `The auth token extractor expects the response to be an object.`);
-};
-const authExtractTokensResponseMissingAccessToken = () => {
-    return new RuntimeError(QueryRuntimeErrorCode.AUTH_EXTRACT_TOKENS_RESPONSE_MISSING_ACCESS_TOKEN, `The auth token extractor expects the response to contain a string "accessToken" property.`);
-};
-const authExtractTokensResponseMissingRefreshToken = () => {
-    return new RuntimeError(QueryRuntimeErrorCode.AUTH_EXTRACT_TOKENS_RESPONSE_MISSING_REFRESH_TOKEN, `The auth token extractor expects the response to contain a string "refreshToken" property.`);
-};
-const authProviderFeatureUsedMultipleTimes = (type) => {
-    return new RuntimeError(QueryRuntimeErrorCode.AUTH_PROVIDER_FEATURE_USED_MULTIPLE_TIMES, `Bearer auth feature "${type}" was used multiple times.`);
-};
-const queryClientFeatureUsedMultipleTimes = (type) => {
-    return new RuntimeError(QueryRuntimeErrorCode.QUERY_CLIENT_FEATURE_USED_MULTIPLE_TIMES, `Query client feature "${type}" was used multiple times.`);
-};
-const uncacheableRequestHasCacheKeyParam = (key) => {
-    return new RuntimeError(QueryRuntimeErrorCode.UNCACHEABLE_REQUEST_HAS_CACHE_KEY_PARAM, `This request is uncacheable, but a cache key was provided: ${key}. Please remove it.`);
-};
-const uncacheableRequestHasAllowCacheParam = () => {
-    return new RuntimeError(QueryRuntimeErrorCode.UNCACHEABLE_REQUEST_HAS_ALLOW_CACHE_PARAM, `This request is uncacheable, but allowCache is set to true. Please remove it.`);
-};
-const pagedQueryStackPageBiggerThanTotalPages = (page, totalPages) => {
-    return new RuntimeError(QueryRuntimeErrorCode.PAGED_QUERY_STACK_PAGE_BIGGER_THAN_TOTAL_PAGES, `The page "${page}" is bigger than the total pages "${totalPages}".`);
-};
-const pagedQueryStackNextPageCalledWithoutPreviousPage = () => {
-    return new RuntimeError(QueryRuntimeErrorCode.PAGED_QUERY_STACK_NEXT_PAGE_CALLED_WITHOUT_PREVIOUS_PAGE, `fetchNextPage() has been called but the current page is not yet loaded. Please call it after the previous page has been loaded.`);
-};
-const pagedQueryStackPreviousPageCalledButAlreadyAtFirstPage = () => {
-    return new RuntimeError(QueryRuntimeErrorCode.PAGED_QUERY_STACK_PREVIOUS_PAGE_CALLED_BUT_ALREADY_AT_FIRST_PAGE, `fetchPreviousPage() has been called but the current page is already the first page.`);
-};
-const queryStackWithArgsUsed = () => {
-    return new RuntimeError(QueryRuntimeErrorCode.QUERY_STACK_WITH_ARGS_USED, `withArgs() has been used in a query stack or a paged query stack. This is not supported.`);
-};
-const queryStackWithResponseUpdateUsed = () => {
-    return new RuntimeError(QueryRuntimeErrorCode.QUERY_STACK_WITH_RESPONSE_UPDATE_USED, `withResponseUpdate() has been used in a query stack or a paged query stack. This is not supported.`);
-};
-const gqlDataPropertyMissingInResponse = () => {
-    return new RuntimeError(QueryRuntimeErrorCode.GQL_DATA_PROPERTY_MISSING_IN_RESPONSE, `The GraphQL response is missing the required "data" property. Please add a custom transformResponse param to the query creator to handle this response format.`);
-};
-const gqlErrorsInResponse = (errors) => {
-    return new HttpErrorResponse({
-        error: errors,
-        status: 0,
-        statusText: new RuntimeError(QueryRuntimeErrorCode.GQL_ERRORS_IN_RESPONSE, `The GraphQL response carries errors and no data. The server's errors are in raw.error.`).message,
-    });
-};
-const tokensNotAvailableInsideAuthAndExec = () => {
-    return new RuntimeError(QueryRuntimeErrorCode.TOKENS_NOT_AVAILABLE_INSIDE_AUTH_AND_EXEC, `Tokens are not available inside authAndExec.`);
-};
-const invalidStateInsideSecureExecuteFactory = () => {
-    return new RuntimeError(QueryRuntimeErrorCode.INVALID_STATE_INSIDE_SECURE_EXECUTE_FACTORY, `An invalid state occurred inside the secure execute factory.`);
-};
-const circularQueryDependency = () => {
-    return new RuntimeError(QueryRuntimeErrorCode.CIRCULAR_QUERY_DEPENDENCY, `The same query was executed with identical args more than 5 times in a row, less than 100ms apart. This is usually a sign of a circular dependency.`);
-};
-const queryExecutedAfterDestroyMessage = (route) => {
-    const target = typeof route === 'string' ? `The query for "${route}"` : 'A query with a function route';
-    return `${target} was executed after the scope that created it was destroyed. The call was ignored - drop the reference to the query when its component or injector goes away.`;
-};
-const legacyPrepareWithoutInjectionContext = (creatorName, method = 'prepare') => {
-    const label = creatorName ? `"${creatorName}"` : 'A legacy query creator';
-    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` +
-        `${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 = () => {
-    return new RuntimeError(QueryRuntimeErrorCode.QUERY_SEQUENCE_ALREADY_RUNNING, `run() was called on a query sequence that is already running. Wait for the current run to settle before starting another.`);
-};
-const queryBatchAlreadyRunning = () => {
-    return new RuntimeError(QueryRuntimeErrorCode.QUERY_BATCH_ALREADY_RUNNING, `run() or retryFailed() was called on a query batch that is already running. Await the current run, or call cancel() first.`);
-};
-const queryBatchWithArgsUsed = () => {
-    return new RuntimeError(QueryRuntimeErrorCode.QUERY_BATCH_WITH_ARGS_USED, `The "withArgs()" feature cannot be used inside a query batch. Each item's args come from the batch's "args" option.`);
-};
-
 const isClassValidatorError = (error) => {
     return (typeof error === 'object' &&
         error !== null &&
@@ -1448,6 +1733,7 @@ const QueryFeatureType = {
     WITH_AUTO_REFRESH: 'WITH_AUTO_REFRESH',
     WITH_RESPONSE_UPDATE: 'WITH_RESPONSE_UPDATE',
     WITH_PAGE_RESET_ON_ERROR: 'WITH_PAGE_RESET_ON_ERROR',
+    WITH_OPTIMISTIC_UPDATE: 'WITH_OPTIMISTIC_UPDATE',
 };
 const createQueryFeature = (config) => {
     return config;
@@ -1458,7 +1744,8 @@ const createQueryFeature = (config) => {
  *
  * Return `null` to park the query: it is reset (`response()` and `executionState()` become `null`),
  * and polling and auto refresh pause until args are set again. A mutation that is still in flight
- * finishes first and the query parks once it has settled.
+ * finishes first and the query parks once it has settled. `execute({ args })` runs and keeps other args
+ * until this function produces new non-null ones.
  *
  * Changing arguments will automatically trigger a new execution of the query if it is eligible for auto execution (e.g. a GET request).
  */
@@ -1484,6 +1771,8 @@ const withArgs = (args) => {
                     return;
                 }
                 untracked(() => {
+                    if (context.state.subtle.isExplicitArgs(currArgsNow))
+                        return;
                     const guard = context.state.subtle.autoExecuteGuard();
                     if (context.flags.shouldAutoExecute && (guard === null || guard()))
                         context.execute({ args: currArgsNow });
@@ -1593,9 +1882,9 @@ const withPolling = (options) => {
                 }, Math.max(0, firstDelay));
             };
             const remainingDelay = () => lastTickAt + currentInterval() - Date.now();
-            // Without an args source, `state.args` only changes when `execute({ args })` records them - and
-            // that execution already sent the request.
-            const wasJustExecutedWith = (args) => !context.state.subtle.hasArgsSource() && args !== null && equal(context.state.subtle.request()?.args, args);
+            // Args an `execute({ args })` recorded already went out with that execution.
+            const wasJustExecutedWith = (args) => context.state.subtle.isExplicitArgs(args) ||
+                (!context.state.subtle.hasArgsSource() && args !== null && equal(context.state.subtle.request()?.args, args));
             nestedEffect(() => {
                 const args = context.state.args();
                 untracked(() => {
@@ -1898,7 +2187,7 @@ const withResponseUpdate = (options) => {
                 if (response === null)
                     return;
                 untracked(() => {
-                    context.state.rawResponse.set(response);
+                    context.state.response.set(response);
                 });
             }, { injector: context.deps.injector });
         },
@@ -1963,6 +2252,62 @@ const withPageResetOnError = (options) => {
     });
 };
 
+/**
+ * Resolves an {@link QueryInvalidationOptions.url} to the absolute form request URLs are built in, so
+ * the comparison - and the message the other tabs receive - never depends on who resolves it.
+ */
+const resolveInvalidationUrl = (baseUrl, url) => {
+    const absolute = url.startsWith('/') ? `${baseUrl}${url}` : url;
+    // A trailing slash would put the boundary check below one character past where the URL actually
+    // ends, which is the one way `/players/` could fail to match `/players/1`.
+    return absolute.endsWith('/') ? absolute.slice(0, -1) : absolute;
+};
+/**
+ * Whether a query URL is the invalidated one or sits below it. The check on what follows the prefix
+ * is what keeps `/players` from matching `/players-archive`, which a `startsWith` alone would.
+ */
+const isUnderInvalidatedUrl = (queryUrl, invalidatedUrl) => {
+    if (!queryUrl.startsWith(invalidatedUrl))
+        return false;
+    const rest = queryUrl.slice(invalidatedUrl.length);
+    return rest === '' || rest.startsWith('/') || rest.startsWith('?') || rest.startsWith('#');
+};
+/**
+ * Turns an invalidation into the filter the repository refreshes by, or `undefined` when nothing
+ * narrows it - "everything in use" is the repository's own cheapest path.
+ */
+const createQueryInvalidationFilter = (options) => {
+    const { url, tag, filter } = options;
+    if (!url && !tag && !filter)
+        return undefined;
+    return (request, tags) => {
+        if (url && !isUnderInvalidatedUrl(request.url, url))
+            return false;
+        if (tag && !tags?.includes(tag))
+            return false;
+        return filter ? filter({ method: request.method, url: request.url }) : true;
+    };
+};
+/** @internal */
+const resolveQueryTags = (tags, args) => (typeof tags === 'function' ? tags({ args: args ?? {} }) : tags);
+/** @internal */
+const invalidateOnSuccess = (options) => {
+    const { invalidates, state, deps } = options;
+    const subscription = state.events$.subscribe((event) => {
+        if (event.type !== HttpEventType.Response)
+            return;
+        const targets = typeof invalidates === 'function'
+            ? invalidates({
+                args: state.subtle.request()?.args ?? {},
+                response: state.response(),
+            })
+            : invalidates;
+        for (const target of targets)
+            deps.client.invalidateQueries(target);
+    });
+    deps.destroyRef.onDestroy(() => subscription.unsubscribe());
+};
+
 const parsers = [];
 /**
  * Adds a parser to the pipeline `createQueryErrorResponse` runs, ahead of the built-in ladder.
@@ -2019,7 +2364,11 @@ const createDefaultRetryFn = (options = {}) => {
     const jitter = clamp(options.jitter ?? DEFAULT_JITTER, 0, 1);
     const retryableStatusCodes = options.retryableStatusCodes;
     const retryNonIdempotent = options.retryNonIdempotent ?? false;
-    const isRetryableStatus = (status) => retryableStatusCodes ? retryableStatusCodes.includes(status) : isRetryableByDefault(status);
+    const isRetryableStatus = (status) => {
+        if (typeof retryableStatusCodes === 'function')
+            return retryableStatusCodes(status, isRetryableByDefault(status));
+        return retryableStatusCodes ? retryableStatusCodes.includes(status) : isRetryableByDefault(status);
+    };
     const backoff = (retryCount) => {
         const exponential = baseDelayMs * Math.pow(2, retryCount);
         const spread = jitter === 0 ? 1 : 1 + (Math.random() * 2 - 1) * jitter;
@@ -2069,6 +2418,7 @@ const isQueryErrorResponse = (error) => {
 /**
  * Every message carried by an error, flattened into a plain list - one entry for a single error,
  * one per violation for a list (a form response with several field violations), empty for `null`.
+ * Blank messages are dropped; an error left with none yields the raw response's message instead.
  *
  * The single/list split exists because that is how APIs answer; UI almost never wants to branch on
  * it. Reach for this when rendering, and keep {@link QueryErrorResponse} for anything that needs
@@ -2084,7 +2434,9 @@ const isQueryErrorResponse = (error) => {
 const queryErrorMessages = (error) => {
     if (!error)
         return [];
-    return error.isList ? error.errors.map((item) => item.message) : [error.error.message];
+    const items = error.isList ? error.errors : [error.error];
+    const messages = items.map((item) => item.message).filter((message) => message.trim());
+    return messages.length ? messages : [error.raw.message];
 };
 /**
  * The first message of an error, or `null` when there is none - the single-line counterpart to
@@ -2213,14 +2565,24 @@ const setupQueryState = (options) => {
     // set is overridden again the next time the source's dependencies change.
     const argsSource = signal(() => null, /* @ts-ignore */
     ...(ngDevMode ? [{ debugName: "argsSource" }] : /* istanbul ignore next */ []));
-    const args = linkedSignal(() => argsSource()(), /* @ts-ignore */
-    ...(ngDevMode ? [{ debugName: "args" }] : /* istanbul ignore next */ []));
+    let explicitArgs = null;
+    const args = linkedSignal({ ...(ngDevMode ? { debugName: "args" } : /* istanbul ignore next */ {}), source: () => argsSource()(),
+        computation: (next, previous) => {
+            if (next === null && explicitArgs !== null && previous)
+                return previous.value;
+            explicitArgs = null;
+            return next;
+        } });
     const hasArgsSource = signal(false, /* @ts-ignore */
     ...(ngDevMode ? [{ debugName: "hasArgsSource" }] : /* istanbul ignore next */ []));
     const setArgsSource = (source) => {
         argsSource.set(source);
         hasArgsSource.set(true);
     };
+    const setExplicitArgs = (value) => {
+        explicitArgs = value;
+        args.set(value);
+    };
     const lastTimeExecutedAt = signal(null, /* @ts-ignore */
     ...(ngDevMode ? [{ debugName: "lastTimeExecutedAt" }] : /* istanbul ignore next */ []));
     const lastTriggeredBy = signal(null, /* @ts-ignore */
@@ -2239,6 +2601,8 @@ const setupQueryState = (options) => {
     ...(ngDevMode ? [{ debugName: "defaultRunOptions" }] : /* istanbul ignore next */ []));
     const autoExecuteGuard = signal(null, /* @ts-ignore */
     ...(ngDevMode ? [{ debugName: "autoExecuteGuard" }] : /* istanbul ignore next */ []));
+    const beforeExecute = signal(null, /* @ts-ignore */
+    ...(ngDevMode ? [{ debugName: "beforeExecute" }] : /* istanbul ignore next */ []));
     options.destroyRef?.onDestroy(() => {
         requestEventsSubscription.unsubscribe();
         requestEvents$.complete();
@@ -2309,8 +2673,11 @@ const setupQueryState = (options) => {
             unbindRequestEvents,
             defaultRunOptions,
             autoExecuteGuard,
+            beforeExecute,
             setArgsSource,
             hasArgsSource: hasArgsSource.asReadonly(),
+            setExplicitArgs,
+            isExplicitArgs: (value) => value !== null && value === explicitArgs,
             devtoolsStats: options.devtoolsStats ?? null,
             devtoolsFormLinks: options.devtoolsFormLinks ?? null,
         },
@@ -2336,6 +2703,19 @@ const createDestroyedSnapshot = (state, execute) => {
         executionState: frozenObservableSignal({ type: 'failure', error, hasCachedResponse: false }),
     };
 };
+/** @internal */
+const createSkippedSnapshot = (query) => ({
+    args: frozenObservableSignal(query.args()),
+    response: frozenObservableSignal(null),
+    latestHttpEvent: frozenObservableSignal(CANCEL_EVENT),
+    loading: frozenObservableSignal(null),
+    error: frozenObservableSignal(null),
+    lastTimeExecutedAt: frozenObservableSignal(query.lastTimeExecutedAt()),
+    triggeredBy: frozenObservableSignal(query.triggeredBy()),
+    isAlive: frozenObservableSignal(false),
+    id: frozenObservableSignal(query.id()),
+    executionState: frozenObservableSignal(null),
+});
 const createQuerySnapshotFn = (options) => {
     const { state } = options;
     const context = injectQueryContext();
@@ -2409,17 +2789,18 @@ const createQuerySnapshotFn = (options) => {
         // snapshot has to settle itself - otherwise `executeUntilSettled` resolves with a snapshot still
         // reporting the execution as loading.
         unregisterScopeListener = context.deps.destroyRef.onDestroy(cancel);
+        const watcher = createObservableSignalWatcher(context.deps.injector);
         const snapshot = {
-            args: wrapAsObservableSignal(snapshotState.args.asReadonly(), context.deps.injector),
-            response: wrapAsObservableSignal(snapshotState.response, context.deps.injector),
-            latestHttpEvent: wrapAsObservableSignal(snapshotState.latestHttpEvent.asReadonly(), context.deps.injector),
-            loading: wrapAsObservableSignal(snapshotState.loading.asReadonly(), context.deps.injector),
-            error: wrapAsObservableSignal(snapshotState.error.asReadonly(), context.deps.injector),
-            lastTimeExecutedAt: wrapAsObservableSignal(snapshotState.lastTimeExecutedAt.asReadonly(), context.deps.injector),
-            triggeredBy: wrapAsObservableSignal(snapshotState.lastTriggeredBy.asReadonly(), context.deps.injector),
-            isAlive: wrapAsObservableSignal(isAlive.asReadonly(), context.deps.injector),
-            id: wrapAsObservableSignal(options.execute.currentRepositoryKey, context.deps.injector),
-            executionState: wrapAsObservableSignal(snapshotState.executionState, context.deps.injector),
+            args: watcher.wrap(snapshotState.args.asReadonly()),
+            response: watcher.wrap(snapshotState.response),
+            latestHttpEvent: watcher.wrap(snapshotState.latestHttpEvent.asReadonly()),
+            loading: watcher.wrap(snapshotState.loading.asReadonly()),
+            error: watcher.wrap(snapshotState.error.asReadonly()),
+            lastTimeExecutedAt: watcher.wrap(snapshotState.lastTimeExecutedAt.asReadonly()),
+            triggeredBy: watcher.wrap(snapshotState.lastTriggeredBy.asReadonly()),
+            isAlive: watcher.wrap(isAlive.asReadonly()),
+            id: watcher.wrap(options.execute.currentRepositoryKey),
+            executionState: watcher.wrap(snapshotState.executionState),
         };
         return snapshot;
     });
@@ -2507,16 +2888,18 @@ const createQueryObject = (options) => {
     const setError = (error) => state.error.set(error);
     const createSnapshot = createQuerySnapshotFn({ state, execute, deps });
     // Pre-wrap all public signals once so both `query` and `roQuery` share the same instances.
-    const wrappedArgs = wrapAsObservableSignal(state.args.asReadonly(), deps.injector);
-    const wrappedResponse = wrapAsObservableSignal(state.response, deps.injector);
-    const wrappedLatestHttpEvent = wrapAsObservableSignal(state.latestHttpEvent.asReadonly(), deps.injector);
-    const wrappedLoading = wrapAsObservableSignal(state.loading.asReadonly(), deps.injector);
-    const wrappedError = wrapAsObservableSignal(state.error.asReadonly(), deps.injector);
-    const wrappedLastTimeExecutedAt = wrapAsObservableSignal(state.lastTimeExecutedAt.asReadonly(), deps.injector);
-    const wrappedTriggeredBy = wrapAsObservableSignal(state.lastTriggeredBy.asReadonly(), deps.injector);
-    const wrappedId = wrapAsObservableSignal(execute.currentRepositoryKey, deps.injector);
-    const wrappedExecutionState = wrapAsObservableSignal(state.executionState, deps.injector);
-    const wrappedRequest = wrapAsObservableSignal(state.subtle.request.asReadonly(), deps.injector);
+    const watcher = createObservableSignalWatcher(deps.injector);
+    const wrappedArgs = watcher.wrap(state.args.asReadonly());
+    const wrappedResponse = watcher.wrap(state.response);
+    const wrappedLatestHttpEvent = watcher.wrap(state.latestHttpEvent.asReadonly());
+    const wrappedLoading = watcher.wrap(state.loading.asReadonly());
+    const wrappedError = watcher.wrap(state.error.asReadonly());
+    const wrappedLastTimeExecutedAt = watcher.wrap(state.lastTimeExecutedAt.asReadonly());
+    const wrappedTriggeredBy = watcher.wrap(state.lastTriggeredBy.asReadonly());
+    const wrappedId = watcher.wrap(execute.currentRepositoryKey);
+    const wrappedExecutionState = watcher.wrap(state.executionState);
+    const wrappedRequest = watcher.wrap(state.subtle.request.asReadonly());
+    const wrappedUrl = watcher.wrap(computed(() => state.subtle.request()?.url ?? null));
     const asReadonly = () => {
         const roQuery = {
             args: wrappedArgs,
@@ -2528,6 +2911,7 @@ const createQueryObject = (options) => {
             triggeredBy: wrappedTriggeredBy,
             id: wrappedId,
             createSnapshot,
+            url: wrappedUrl,
             executionState: wrappedExecutionState,
         };
         return roQuery;
@@ -2543,6 +2927,7 @@ const createQueryObject = (options) => {
         triggeredBy: wrappedTriggeredBy,
         id: wrappedId,
         createSnapshot,
+        url: wrappedUrl,
         reset: execute.reset,
         abort: execute.abort,
         asReadonly,
@@ -2593,6 +2978,12 @@ const createBaseQuery = (options) => {
             deps,
         };
         applyQueryFeatures(options.features, featureFnContext);
+        const invalidates = options.creator?.invalidates;
+        if (invalidates) {
+            if (flags.shouldAutoExecuteMethod)
+                throw invalidatesUsedOnRead(flags.method);
+            invalidateOnSuccess({ invalidates, state, deps });
+        }
         maybeExecute({ execute, flags, state });
         trackRefreshedExecutions({ state, deps });
         const query = createQueryObject({ state, execute, deps });
@@ -2704,7 +3095,7 @@ const extractExpiresInSeconds = (headers) => {
     if (cacheControl && /(?:^|,)\s*no-(?:cache|store)(?:\s|,|$)/i.test(cacheControl)) {
         return null;
     }
-    const maxAgeMatch = cacheControl?.match(/(?:^|,)\s*(?:s-maxage|max-age)=(\d+)/i);
+    const maxAgeMatch = cacheControl?.match(/(?:^|,)\s*max-age=(\d+)/i) ?? cacheControl?.match(/(?:^|,)\s*s-maxage=(\d+)/i);
     if (maxAgeMatch?.[1]) {
         maxAge = parseInt(maxAgeMatch[1]);
     }
@@ -2800,38 +3191,66 @@ const queryExecute = (options) => {
     }
     const defaultRunOptions = state.subtle.defaultRunOptions();
     const runQueryOptions = defaultRunOptions || options.options ? { ...defaultRunOptions, ...options.options } : undefined;
-    const { key, request, executed } = deps.client.repository.request({
-        route: creatorInternals.route,
-        method: creatorInternals.method,
-        args,
-        creatorOptions: creator,
-        retryFn: creator?.retryFn,
-        consumerDestroyRef: deps.destroyRef,
-        key: queryConfig.key,
-        previousKey: executeState.previousKey(),
-        runQueryOptions,
-        isSecure,
-        isRefreshable,
-        silenceUncacheableAllowCacheError: queryConfig.silenceUncacheableAllowCacheError,
-    });
+    const onRequest = state.subtle.beforeExecute()?.(args);
+    let requestResult;
+    try {
+        requestResult = deps.client.repository.request({
+            route: creatorInternals.route,
+            method: creatorInternals.method,
+            args,
+            creatorOptions: creator,
+            retryFn: creator?.retryFn,
+            consumerDestroyRef: deps.destroyRef,
+            key: queryConfig.key,
+            previousKey: executeState.previousKey(),
+            runQueryOptions,
+            isSecure,
+            isRefreshable,
+            silenceUncacheableAllowCacheError: queryConfig.silenceUncacheableAllowCacheError,
+            tags: creator?.tags ? resolveQueryTags(creator.tags, args) : undefined,
+        });
+    }
+    catch (error) {
+        onRequest?.(null);
+        throw error;
+    }
+    const { key, request, executed } = requestResult;
     executeState.previousKey.set(key);
     state.lastTimeExecutedAt.set(Date.now());
     state.lastTriggeredBy.set(runQueryOptions?.triggeredBy ?? null);
     state.subtle.request.set(request);
+    onRequest?.(request);
     state.subtle.bindRequestEvents(request);
     state.subtle.devtoolsStats?.recordExecution({ didRequest: executed, body: args?.body, url: request.url });
 };
+/**
+ * A query over a `withArgs` source that returns `null` is parked. Running it would send `null` args, so the
+ * call is dropped with a dev-mode warning.
+ */
+const skipParkedExecution = (state, args, route) => {
+    if ((args !== null && args !== undefined) || !state.subtle.hasArgsSource())
+        return false;
+    if (isDevMode())
+        console.warn(queryExecutedWhileParkedMessage(route));
+    return true;
+};
 /**
  * Writes the args an execution runs with to `state.args`, so a later bare `execute()` re-sends them.
- * A `withArgs` source owns `state.args`, and a `withLongPolling` round must not look like a new
- * args value, so neither is written.
+ * A `withLongPolling` round must not look like a new args value, so it is not written. Over a `withArgs`
+ * source only the caller's own non-null args are written, never what a feature re-sends.
  */
 const recordExecutionArgs = (state, args, options) => {
-    if (state.subtle.hasArgsSource() || options?.triggeredBy === LONG_POLLING_TRIGGER)
+    const triggeredBy = options?.triggeredBy;
+    if (triggeredBy === LONG_POLLING_TRIGGER)
+        return;
+    if (!state.subtle.hasArgsSource())
+        return state.args.set(args);
+    if (args === null || args === state.args() || (triggeredBy && FEATURE_TRIGGERS.includes(triggeredBy)))
         return;
-    state.args.set(args);
+    state.subtle.setExplicitArgs(args);
 };
 const LONG_POLLING_TRIGGER = 'long-polling';
+const FEATURE_TRIGGERS = ['polling', 'auto-refresh'];
 const CIRCULAR_DEPENDENCY_WINDOW_MS = 100;
 const CIRCULAR_DEPENDENCY_MAX_REPEATS = 5;
 /**
@@ -2841,259 +3260,115 @@ const CIRCULAR_DEPENDENCY_MAX_REPEATS = 5;
  */
 const circularQueryDependencyChecker = () => {
     const recent = new Map();
-    const check = (args) => {
-        const now = Date.now();
-        const signature = buildQueryCacheKey(JSON.stringify([args?.pathParams ?? null, args?.queryParams ?? null]), args ?? undefined);
-        for (const [key, entry] of recent) {
-            if (now - entry.lastTs >= CIRCULAR_DEPENDENCY_WINDOW_MS)
-                recent.delete(key);
-        }
-        const entry = recent.get(signature);
-        const repeats = entry ? entry.repeats + 1 : 1;
-        if (repeats > CIRCULAR_DEPENDENCY_MAX_REPEATS) {
-            recent.delete(signature);
-            throw circularQueryDependency();
-        }
-        recent.set(signature, { lastTs: now, repeats });
-    };
-    return {
-        check,
-    };
-};
-
-const createExecuteFn = (executeOptions) => {
-    const executeState = setupQueryExecuteState();
-    const circularChecker = circularQueryDependencyChecker();
-    const aborter = createQueryExecutionAborter(executeOptions.state);
-    const reset = () => untracked(() => resetExecuteState({ executeState, executeOptions }));
-    const exec = (executeArgs) => untracked(() => {
-        const { args = executeOptions.state.args(), options } = executeArgs ?? {};
-        circularChecker.check(args);
-        aborter.capture();
-        recordExecutionArgs(executeOptions.state, args, options);
-        queryExecute({ executeOptions, executeState, args, options });
-    });
-    exec['reset'] = reset;
-    exec['abort'] = () => aborter.abort();
-    exec['aborted$'] = aborter.aborted$;
-    exec['currentRepositoryKey'] = executeState.previousKey.asReadonly();
-    return exec;
-};
-
-/* eslint-disable @typescript-eslint/no-explicit-any */
-/**
- * The empty request-args object, typed to satisfy `RequestArgs<TArgs>` for a query that takes no
- * arguments - its `QueryArgs` is just `{ response: T }`, so `RequestArgs` resolves to `{}`.
- *
- * Only needed in generic code, where `TArgs` is still a type parameter and TS therefore cannot see
- * that `{}` is the whole of it. Against a concrete query, omit the argument instead: both
- * `query.execute()` and the auth registry's `execute()` already take none.
- *
- * @example
- * const runAnything = <TArgs extends QueryArgs>(query: Query<TArgs>) =>
- *   query.execute({ args: emptyQueryArgs<TArgs>() });
- */
-const emptyQueryArgs = () => ({});
-const createQuery = (options) => createBaseQuery({
-    creator: options.creator,
-    creatorInternals: options.creatorInternals,
-    features: options.features,
-    queryConfig: options.queryConfig,
-    executeFactory: createExecuteFn,
-});
-
-const splitQueryConfig = (args) => {
-    let queryConfig = {};
-    let features = [];
-    const first = args[0];
-    if (first) {
-        if ('type' in first) {
-            features = args;
-        }
-        else {
-            [queryConfig, ...features] = args;
-        }
-    }
-    return { features, queryConfig };
-};
-const createQueryCreator = (options, internals) => createBaseQueryCreator({
-    options,
-    internals,
-    queryFactory: createQuery,
-});
-
-const createBaseQueryCreator = (config) => {
-    function queryCreator(...args) {
-        if (getActiveConsumer() !== null)
-            throw queryCreatedInReactiveContext();
-        const { features, queryConfig } = splitQueryConfig(args);
-        return config.queryFactory({
-            creator: config.options,
-            creatorInternals: config.internals,
-            features,
-            queryConfig,
-        });
-    }
-    // Add clone method to create a new creator with merged options
-    // Cast to match QueryCreator's expected signature while preserving TOptions internally
-    queryCreator.clone = (additionalOptions) => {
-        return createBaseQueryCreator({
-            ...config,
-            options: { ...config.options, ...additionalOptions },
-        });
-    };
-    queryCreator.subtle = {
-        creatorInternals: config.internals,
-        creatorOptions: config.options,
-    };
-    return queryCreator;
-};
-
-/**
- * Route building, query-string serialization and the token clock - shared by the current generation and
- * the legacy V2 client, which re-exports them under their original names.
- */
-// codes 1-99 of the shared 0-999 `@ethlete/query` range - see `query-errors.ts` for the rest
-const RouteRuntimeErrorCode = {
-    INVALID_BASE_ROUTE: 1,
-    INVALID_ROUTE: 2,
-    PATH_PARAMS_MISSING_IN_ROUTE_FUNCTION: 3,
-};
-const invalidBaseRouteError$1 = (data) => new RuntimeError(RouteRuntimeErrorCode.INVALID_BASE_ROUTE, 'The baseRoute must not end with a slash', data);
-const invalidRouteError$1 = (data) => new RuntimeError(RouteRuntimeErrorCode.INVALID_ROUTE, 'The route must start with a slash', data);
-const pathParamsMissingInRouteFunctionError$1 = (data) => new RuntimeError(RouteRuntimeErrorCode.PATH_PARAMS_MISSING_IN_ROUTE_FUNCTION, 'The route is a function but pathParams are missing', data);
-const isNaN$2 = (value) => typeof value === 'number' && Number.isNaN(value);
-const isEmptyString$1 = (value) => typeof value === 'string' && value.trim() === '';
-const buildQueryString$1 = (params, config) => {
-    const objectNotation = config?.objectNotation ?? 'bracket';
-    const writeArrayIndexes = config?.writeArrayIndexes ?? false;
-    const ignoredValues = config?.ignoredValues ?? [undefined, null, Infinity, -Infinity];
-    const ignoredValuesFns = config?.ignoredValuesFns ?? [isNaN$2, isEmptyString$1];
-    const queryParams = [];
-    function processValue(key, rawValue) {
-        if (rawValue instanceof Date && Number.isNaN(rawValue.getTime()))
-            return false;
-        const value = rawValue instanceof Date ? rawValue.toISOString() : rawValue;
-        if (config?.objectNotation === 'json-stringify') {
-            if (value === undefined) {
-                return false;
-            }
-            if (ignoredValues.includes(value)) {
-                return false;
-            }
-            if (ignoredValuesFns.some((fn) => fn(value))) {
-                return false;
-            }
-            const encodedKey = encodeURIComponent(key);
-            const val = typeof value === 'object' ? JSON.stringify(value) : value;
-            const encodedValue = encodeURIComponent(val);
-            queryParams.push(`${encodedKey}=${encodedValue}`);
-            return true;
-        }
-        else if (Array.isArray(value)) {
-            let currentFilteredIndex = 0;
-            let didAddAnyValue = false;
-            for (const arrayValue of value) {
-                const nestedKey = writeArrayIndexes ? `${key}[${currentFilteredIndex}]` : `${key}[]`;
-                const didAddValue = processValue(nestedKey, arrayValue);
-                if (didAddValue) {
-                    currentFilteredIndex++;
-                    didAddAnyValue = true;
-                }
-            }
-            return didAddAnyValue;
-        }
-        else if (typeof value === 'object' && value !== null) {
-            let didAddAnyValue = false;
-            for (const [objKey, val] of Object.entries(value)) {
-                const nestedKey = objectNotation === 'dot' ? `${key}.${objKey}` : `${key}[${objKey}]`;
-                didAddAnyValue = processValue(nestedKey, val) || didAddAnyValue;
-            }
-            return didAddAnyValue;
-        }
-        else {
-            if (ignoredValues.includes(value)) {
-                return false;
-            }
-            if (ignoredValuesFns.some((fn) => fn(value))) {
-                return false;
-            }
-            const encodedKey = encodeURIComponent(key);
-            const encodedValue = encodeURIComponent(value);
-            queryParams.push(`${encodedKey}=${encodedValue}`);
-            return true;
-        }
-    }
-    for (const [key, val] of Object.entries(params)) {
-        processValue(key, val);
-    }
-    return queryParams.length ? queryParams.join('&') : null;
-};
-const isPlainObject = (value) => {
-    if (!value || typeof value !== 'object')
-        return false;
-    const proto = Object.getPrototypeOf(value);
-    return proto === Object.prototype || proto === null;
-};
-/** Copies query params with every plain object's keys sorted, so key order never reaches a cache key. */
-const sortQueryParamKeys = (value) => {
-    if (Array.isArray(value))
-        return value.map(sortQueryParamKeys);
-    if (!isPlainObject(value))
-        return value;
-    return Object.fromEntries(Object.keys(value)
-        .sort()
-        .map((key) => [key, sortQueryParamKeys(value[key])]));
-};
-const buildRoute$1 = (options) => {
-    if (options.base.endsWith('/')) {
-        throw invalidBaseRouteError$1(options.base);
-    }
-    let route;
-    if (typeof options.route === 'function') {
-        if (!options.pathParams) {
-            throw pathParamsMissingInRouteFunctionError$1(options.route({}));
+    const check = (args) => {
+        const now = Date.now();
+        const signature = buildQueryCacheKey(JSON.stringify([args?.pathParams ?? null, args?.queryParams ?? null]), args ?? undefined);
+        for (const [key, entry] of recent) {
+            if (now - entry.lastTs >= CIRCULAR_DEPENDENCY_WINDOW_MS)
+                recent.delete(key);
         }
-        route = options.route(options.pathParams);
-    }
-    else {
-        route = options.route ?? null;
-    }
-    if (route && !route.startsWith('/')) {
-        throw invalidRouteError$1(route);
-    }
-    if (options.queryParams) {
-        const queryString = buildQueryString$1(options.queryParams, options.queryParamConfig);
-        if (queryString) {
-            route = route ? `${route}?${queryString}` : `/?${queryString}`;
+        const entry = recent.get(signature);
+        const repeats = entry ? entry.repeats + 1 : 1;
+        if (repeats > CIRCULAR_DEPENDENCY_MAX_REPEATS) {
+            recent.delete(signature);
+            throw circularQueryDependency();
         }
-    }
-    return `${options.base}${route ?? ''}`;
+        recent.set(signature, { lastTs: now, repeats });
+    };
+    return {
+        check,
+    };
 };
-const buildTimestampFromSeconds$1 = (seconds) => {
-    if (seconds === null) {
-        return null;
-    }
-    return new Date(Date.now() + seconds * 1000).getTime();
+
+const createExecuteFn = (executeOptions) => {
+    const executeState = setupQueryExecuteState();
+    const circularChecker = circularQueryDependencyChecker();
+    const aborter = createQueryExecutionAborter(executeOptions.state);
+    const reset = () => untracked(() => resetExecuteState({ executeState, executeOptions }));
+    const exec = (executeArgs) => untracked(() => {
+        const { args = executeOptions.state.args(), options } = executeArgs ?? {};
+        if (skipParkedExecution(executeOptions.state, args, executeOptions.creatorInternals.route))
+            return false;
+        circularChecker.check(args);
+        aborter.capture();
+        recordExecutionArgs(executeOptions.state, args, options);
+        queryExecute({ executeOptions, executeState, args, options });
+        return true;
+    });
+    exec['reset'] = reset;
+    exec['abort'] = () => aborter.abort();
+    exec['aborted$'] = aborter.aborted$;
+    exec['currentRepositoryKey'] = executeState.previousKey.asReadonly();
+    return exec;
 };
-/** Reads a bearer token's payload. */
-const decryptBearer$1 = (token) => {
-    try {
-        const base64Url = token.split('.')[1];
-        if (!base64Url) {
-            return null;
+
+/* eslint-disable @typescript-eslint/no-explicit-any */
+/**
+ * The empty request-args object, typed to satisfy `RequestArgs<TArgs>` for a query that takes no
+ * arguments - its `QueryArgs` is just `{ response: T }`, so `RequestArgs` resolves to `{}`.
+ *
+ * Only needed in generic code, where `TArgs` is still a type parameter and TS therefore cannot see
+ * that `{}` is the whole of it. Against a concrete query, omit the argument instead: both
+ * `query.execute()` and the auth registry's `execute()` already take none.
+ *
+ * @example
+ * const runAnything = <TArgs extends QueryArgs>(query: Query<TArgs>) =>
+ *   query.execute({ args: emptyQueryArgs<TArgs>() });
+ */
+const emptyQueryArgs = () => ({});
+const createQuery = (options) => createBaseQuery({
+    creator: options.creator,
+    creatorInternals: options.creatorInternals,
+    features: options.features,
+    queryConfig: options.queryConfig,
+    executeFactory: createExecuteFn,
+});
+
+const splitQueryConfig = (args) => {
+    let queryConfig = {};
+    let features = [];
+    const first = args[0];
+    if (first) {
+        if ('type' in first) {
+            features = args;
+        }
+        else {
+            [queryConfig, ...features] = args;
         }
-        const base64 = base64Url.replace(/-/g, '+').replace(/_/g, '/');
-        const jsonPayload = decodeURIComponent(atob(base64)
-            .split('')
-            .map((c) => '%' + ('00' + c.charCodeAt(0).toString(16)).slice(-2))
-            .join(''));
-        return JSON.parse(jsonPayload);
     }
-    catch (error) {
-        console.error('Invalid bearer token', error);
-        return null;
+    return { features, queryConfig };
+};
+const createQueryCreator = (options, internals) => createBaseQueryCreator({
+    options,
+    internals,
+    queryFactory: createQuery,
+});
+
+const createBaseQueryCreator = (config) => {
+    function queryCreator(...args) {
+        if (getActiveConsumer() !== null)
+            throw queryCreatedInReactiveContext();
+        const { features, queryConfig } = splitQueryConfig(args);
+        return config.queryFactory({
+            creator: config.options,
+            creatorInternals: config.internals,
+            features,
+            queryConfig,
+        });
     }
+    // Add clone method to create a new creator with merged options
+    // Cast to match QueryCreator's expected signature while preserving TOptions internally
+    queryCreator.clone = (additionalOptions) => {
+        return createBaseQueryCreator({
+            ...config,
+            options: { ...config.options, ...additionalOptions },
+        });
+    };
+    queryCreator.subtle = {
+        creatorInternals: config.internals,
+        creatorOptions: config.options,
+    };
+    return queryCreator;
 };
 
 /**
@@ -3449,11 +3724,18 @@ const createHttpRequest = (options) => {
             retryState: retryState.asReadonly(),
             lastDurationMs: lastDurationMs.asReadonly(),
             abort,
+            markStale: () => {
+                if (!isStale())
+                    expiresIn.set(Date.now());
+            },
+            setResponse: (body) => response.set(body),
         },
     };
     return httpRequest;
 };
 
+const wrapAsObservableSignal = (source, defaultInjector) => createObservableSignalWatcher(defaultInjector).wrap(source);
+
 /* eslint-disable @typescript-eslint/no-explicit-any */
 /** Transforms an array of arrays into a single array and filters out `null` values. */
 const transformArrayResponse = (responses) => responses.filter((r) => !!r).flatMap((r) => r);
@@ -3465,7 +3747,7 @@ const createQueryStack = (options) => {
         const lastQuery = newQueries[newQueries.length - 1] ?? oldQueries[oldQueries.length - 1] ?? null;
         return { queries, lastQuery };
     }, transform, argsKeyFn, deduplicateArgs, maxQueries = Infinity, removeStrategy = 'oldest', } = options ?? {};
-    const injector = inject(Injector);
+    const injector = injectInQueryContext(Injector, 'query stack');
     const queries = signal([], /* @ts-ignore */
     ...(ngDevMode ? [{ debugName: "queries" }] : /* istanbul ignore next */ []));
     const lastQuery = signal(null, /* @ts-ignore */
@@ -3473,11 +3755,11 @@ const createQueryStack = (options) => {
     const firstQuery = computed(() => queries()[0] ?? null, /* @ts-ignore */
     ...(ngDevMode ? [{ debugName: "firstQuery" }] : /* istanbul ignore next */ []));
     const hasWithArgsFeature = features.some((f) => f.type === QueryFeatureType.WITH_ARGS);
-    const hasWithOptimisticUpdateFeature = features.some((f) => f.type === QueryFeatureType.WITH_RESPONSE_UPDATE);
+    const hasWithResponseUpdateFeature = features.some((f) => f.type === QueryFeatureType.WITH_RESPONSE_UPDATE);
     if (hasWithArgsFeature) {
         throw queryStackWithArgsUsed();
     }
-    if (hasWithOptimisticUpdateFeature) {
+    if (hasWithResponseUpdateFeature) {
         throw queryStackWithResponseUpdateUsed();
     }
     const runWithArgs = (args) => {
@@ -3730,6 +4012,7 @@ const createPagedQueryStack = (options) => {
         const args = options.args(initialPage(), []);
         untracked(() => {
             stack.clear();
+            pageDirection.set('next');
             currentPageArgs.set(args);
             loadedMinPage.set(initialPage());
             loadedMaxPage.set(initialPage());
@@ -4505,7 +4788,8 @@ const createIndexedDbQueryPersistenceAdapter = (options) => {
  */
 const createQueryBatch = (options) => {
     const { queryCreator, args: mapArgs, stopOnError, allowCache, onItemSettled, features = [] } = options;
-    const concurrency = Math.max(1, Math.floor(options.concurrency ?? 4));
+    const requestedConcurrency = options.concurrency ?? 4;
+    const concurrency = Number.isNaN(requestedConcurrency) ? 4 : Math.max(1, Math.floor(requestedConcurrency));
     if (features.some((f) => f.type === QueryFeatureType.WITH_ARGS)) {
         throw queryBatchWithArgsUsed();
     }
@@ -4786,41 +5070,6 @@ const isQueryDevtoolsRepositoryLive = (repository) => {
     return live$1.has(repository);
 };
 
-/**
- * Resolves an {@link QueryInvalidationOptions.url} to the absolute form request URLs are built in, so
- * the comparison - and the message the other tabs receive - never depends on who resolves it.
- */
-const resolveInvalidationUrl = (baseUrl, url) => {
-    const absolute = url.startsWith('/') ? `${baseUrl}${url}` : url;
-    // A trailing slash would put the boundary check below one character past where the URL actually
-    // ends, which is the one way `/players/` could fail to match `/players/1`.
-    return absolute.endsWith('/') ? absolute.slice(0, -1) : absolute;
-};
-/**
- * Whether a query URL is the invalidated one or sits below it. The check on what follows the prefix
- * is what keeps `/players` from matching `/players-archive`, which a `startsWith` alone would.
- */
-const isUnderInvalidatedUrl = (queryUrl, invalidatedUrl) => {
-    if (!queryUrl.startsWith(invalidatedUrl))
-        return false;
-    const rest = queryUrl.slice(invalidatedUrl.length);
-    return rest === '' || rest.startsWith('/') || rest.startsWith('?') || rest.startsWith('#');
-};
-/**
- * Turns an invalidation into the filter the repository refreshes by, or `undefined` when nothing
- * narrows it - "everything in use" is the repository's own cheapest path.
- */
-const createQueryInvalidationFilter = (options) => {
-    const { url, filter } = options;
-    if (!url && !filter)
-        return undefined;
-    return (request) => {
-        if (url && !isUnderInvalidatedUrl(request.url, url))
-            return false;
-        return filter ? filter({ method: request.method, url: request.url }) : true;
-    };
-};
-
 /**
  * An error body can be an HTML page instead of JSON: a proxy's 502, a load balancer's maintenance page, a
  * platform's "service temporarily unavailable". The markup is never worth showing, but the sentence inside it
@@ -5002,6 +5251,14 @@ const createQuerySyncEngine = (options) => {
     // response sharing would just make a tab stop updating. Enforced here rather than documented.
     const isPollingDedupeEnabled = (config.dedupePolling ?? true) && syncResponses && transport.isSupported && lockManager.isSupported;
     const mutationFilter = typeof refreshOnMutation === 'object' ? refreshOnMutation.filter : null;
+    let outgoingBatch = null;
+    const currentOutgoingBatch = () => {
+        if (outgoingBatch === null) {
+            outgoingBatch = randomId();
+            queueMicrotask(() => (outgoingBatch = null));
+        }
+        return outgoingBatch;
+    };
     const broadcast = (event) => {
         if (event.type !== 'request-success' || !event.isMultiTabSyncEnabled)
             return;
@@ -5023,7 +5280,12 @@ const createQuerySyncEngine = (options) => {
         // worth telling the other tabs about - and an uncacheable read has no shared key to send anyway.
         if (!refreshOnMutation || shouldCacheQuery(event.request.method))
             return;
-        transport.post({ type: 'mutation', method: event.request.method, url: event.request.url });
+        transport.post({
+            type: 'mutation',
+            method: event.request.method,
+            url: event.request.url,
+            batch: currentOutgoingBatch(),
+        });
     };
     const apply = (message) => {
         if (message.type === 'response') {
@@ -5035,23 +5297,20 @@ 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, tag: message.tag }), {
                 type: 'invalidation',
                 url: message.url,
                 otherTab: true,
-            });
+                ...(message.tag && { tag: message.tag }),
+            }, message.batch);
             return;
         }
         if (!refreshOnMutation)
             return;
         const mutation = { method: message.method, url: message.url };
-        repository.refreshInUse(mutationFilter ? (request) => mutationFilter(mutation, request) : undefined, {
-            type: 'mutation',
-            url: message.url,
-            otherTab: true,
-        });
+        repository.refreshInUse(mutationFilter ? (request) => mutationFilter(mutation, request) : undefined, { type: 'mutation', url: message.url, otherTab: true }, message.batch);
     };
-    const postInvalidation = (url) => transport.post({ type: 'invalidate', url });
+    const postInvalidation = (url, tag) => transport.post({ type: 'invalidate', url, ...(tag && { tag }), batch: currentOutgoingBatch() });
     const eventSubscription = repository.events$.subscribe(broadcast);
     const unlisten = transport.listen(apply);
     const destroy = () => {
@@ -5104,11 +5363,13 @@ const unwrapQuerySyncMessage = (data) => {
             expiresAt: typeof expiresAt === 'number' ? expiresAt : null,
         };
     }
+    const batch = typeof raw['batch'] === 'string' ? { batch: raw['batch'] } : {};
     if (type === 'mutation' && typeof method === 'string' && typeof url === 'string') {
-        return { type: 'mutation', method: method, url };
+        return { type: 'mutation', method: method, url, ...batch };
     }
     if (type === 'invalidate' && (typeof url === 'string' || url === null)) {
-        return { type: 'invalidate', url };
+        const tag = raw['tag'];
+        return { type: 'invalidate', url, tag: typeof tag === 'string' ? tag : null, ...batch };
     }
     return null;
 };
@@ -5370,6 +5631,16 @@ const withEthleteApiErrors = (options) => () => {
     };
 };
 
+const functionIds = /* @__PURE__ */ new WeakMap();
+let nextFunctionId = 1;
+const functionId = (fn) => {
+    let id = functionIds.get(fn);
+    if (id === undefined) {
+        id = nextFunctionId++;
+        functionIds.set(fn, id);
+    }
+    return id;
+};
 const generateUuid = () => randomId();
 /** @see CreateQueryClientConfigOptions.keepUnusedFor */
 const DEFAULT_KEEP_UNUSED_FOR = 300_000;
@@ -5379,6 +5650,7 @@ const DEFAULT_KEEP_UNUSED_FOR = 300_000;
  * `unbind`) must never grow unbounded - the least recently orphaned entries are dropped first.
  */
 const MAX_UNUSED_ENTRIES = 50;
+const MAX_TIMEOUT_DELAY = 2 ** 31 - 1;
 const createQueryRepository = (config) => {
     const cache = new Map();
     const eventsSubject = new Subject();
@@ -5421,8 +5693,17 @@ const createQueryRepository = (config) => {
                 queryParamConfig: config.queryString,
             })
             : route;
+        const wireKey = [
+            creatorOptions?.responseType && creatorOptions.responseType !== 'json' ? creatorOptions.responseType : '',
+            creatorOptions?.withCredentials ? 'credentials' : '',
+            creatorOptions?.reportErrors === false ? 'silent' : '',
+            creatorOptions?.reportProgress ? 'progress' : '',
+            options.retryFn ? `retry${functionId(options.retryFn)}` : '',
+        ]
+            .filter(Boolean)
+            .join('_');
         const cacheKey = shouldCache
-            ? buildQueryCacheKey(`${options.key ? options.key + '_' : ''}${keyRoute}`, {
+            ? buildQueryCacheKey(`${wireKey ? wireKey + '_' : ''}${options.key ? options.key + '_' : ''}${keyRoute}`, {
                 body: args?.body,
                 queryParams: args?.queryParams,
                 pathParams: args?.pathParams,
@@ -5433,6 +5714,7 @@ const createQueryRepository = (config) => {
         const keepUnusedFor = resolveKeepUnusedFor(creatorOptions, shouldCache, runQueryOptions?.keepUnusedFor);
         const isMultiTabSyncEnabled = creatorOptions?.multiTabSync !== false;
         const isSecure = options.isSecure ?? false;
+        const tags = options.tags ?? [];
         // A secure response needs an explicit `persistence: true` to reach the disk: leaving an
         // authenticated user's data there is a decision per endpoint, not a default. Everything else
         // persists unless it opted out.
@@ -5457,6 +5739,7 @@ const createQueryRepository = (config) => {
                     isMultiTabSyncEnabled,
                     isPersistEnabled,
                     keepUnusedFor,
+                    tags,
                 });
                 const executed = !runQueryOptions?.allowCache || cacheEntry.request.isStale()
                     ? cacheEntry.request.execute({ allowCache: runQueryOptions?.allowCache })
@@ -5489,6 +5772,7 @@ const createQueryRepository = (config) => {
             isMultiTabSyncEnabled,
             isPersistEnabled,
             keepUnusedFor,
+            tags,
         });
         // Announced after the entry is bound and its request is on its way, because the one thing that acts
         // on it - hydration from the persisted store - is only ever allowed to fill a gap this request has
@@ -5510,8 +5794,6 @@ const createQueryRepository = (config) => {
         eventsSubject.next({ type: 'entry-destroyed', key, isSecure: cacheEntry.isSecure, method, url, cause });
     };
     const cancelEviction = (cacheEntry) => {
-        if (cacheEntry.evictTimer === undefined)
-            return;
         clearTimeout(cacheEntry.evictTimer);
         cacheEntry.evictTimer = undefined;
         cacheEntry.unusedSince = undefined;
@@ -5529,7 +5811,9 @@ const createQueryRepository = (config) => {
     const retain = (key, cacheEntry) => {
         clearTimeout(cacheEntry.evictTimer);
         cacheEntry.unusedSince = Date.now();
-        cacheEntry.evictTimer = setTimeout(() => evict(key, 'expired'), cacheEntry.keepUnusedFor);
+        cacheEntry.evictTimer = Number.isFinite(cacheEntry.keepUnusedFor)
+            ? setTimeout(() => evict(key, 'expired'), Math.min(cacheEntry.keepUnusedFor, MAX_TIMEOUT_DELAY))
+            : undefined;
         enforceUnusedEntryLimit();
     };
     /**
@@ -5550,6 +5834,7 @@ const createQueryRepository = (config) => {
         cacheEntry.isPersistEnabled = bindings.some((binding) => binding.isPersistEnabled);
         cacheEntry.isMultiTabSyncEnabled = bindings.every((binding) => binding.isMultiTabSyncEnabled);
         cacheEntry.keepUnusedFor = Math.min(...bindings.map((binding) => binding.keepUnusedFor));
+        cacheEntry.tags = bindings.flatMap((binding) => binding.tags);
     };
     const unbind = (key, consumerDestroyRef) => {
         if (key === null)
@@ -5592,10 +5877,30 @@ const createQueryRepository = (config) => {
         bumpCacheVersion();
         eventsSubject.next({ type: 'unbind-all-secure' });
     };
-    const refreshInUse = (filter, cause) => {
+    let restartedBatch = null;
+    let turnBatchKey = null;
+    const currentTurnBatchKey = () => {
+        if (turnBatchKey === null) {
+            turnBatchKey = generateUuid();
+            queueMicrotask(() => (turnBatchKey = null));
+        }
+        return turnBatchKey;
+    };
+    const resolveRestartedBatch = (cause, batch) => {
+        if (!cause || cause.type === 'refresh')
+            return null;
+        const key = batch ?? currentTurnBatchKey();
+        if (restartedBatch?.key !== key)
+            restartedBatch = { key, requests: new WeakSet() };
+        return restartedBatch.requests;
+    };
+    const refreshInUse = (filter, cause, batch) => {
         const refreshed = [];
+        const marksUnusedStale = cause?.type === 'invalidation';
+        const restartedInBatch = resolveRestartedBatch(cause, batch);
         for (const cacheEntry of cache.values()) {
-            if (cacheEntry.consumers.size === 0)
+            const isUnused = cacheEntry.consumers.size === 0;
+            if (isUnused && !marksUnusedStale)
                 continue;
             // Re-firing a mutation would be a side effect nobody asked for, so only reads are refreshed:
             // a cacheable method, or a GQL query transported via POST. Opting into the cache alone does not
@@ -5603,8 +5908,15 @@ const createQueryRepository = (config) => {
             // end the session.
             if (!cacheEntry.isRefreshable)
                 continue;
-            if (filter && !filter(cacheEntry.request))
+            if (filter && !filter(cacheEntry.request, cacheEntry.tags))
                 continue;
+            if (isUnused) {
+                cacheEntry.request.subtle.markStale();
+                continue;
+            }
+            if (restartedInBatch?.has(cacheEntry.request))
+                continue;
+            restartedInBatch?.add(cacheEntry.request);
             refreshed.push(cacheEntry.request);
             cacheEntry.request.execute({ force: true });
         }
@@ -5635,7 +5947,7 @@ const createQueryRepository = (config) => {
         return true;
     };
     const bind = (options) => {
-        const { key, consumerDestroyRef, request, isSecure, isCached, isRefreshable, isMultiTabSyncEnabled, isPersistEnabled, keepUnusedFor, } = options;
+        const { key, consumerDestroyRef, request, isSecure, isCached, isRefreshable, isMultiTabSyncEnabled, isPersistEnabled, keepUnusedFor, tags, } = options;
         const cacheEntry = cache.get(key);
         if (cacheEntry && isCached) {
             const existingBinding = cacheEntry.consumers.get(consumerDestroyRef);
@@ -5645,6 +5957,7 @@ const createQueryRepository = (config) => {
                 existingBinding.isMultiTabSyncEnabled = isMultiTabSyncEnabled;
                 existingBinding.isPersistEnabled = isPersistEnabled;
                 existingBinding.keepUnusedFor = keepUnusedFor;
+                existingBinding.tags = tags;
             }
             else {
                 cacheEntry.consumers.set(consumerDestroyRef, {
@@ -5654,6 +5967,7 @@ const createQueryRepository = (config) => {
                     isMultiTabSyncEnabled,
                     isPersistEnabled,
                     keepUnusedFor,
+                    tags,
                 });
             }
             mergeConsumerPolicies(cacheEntry);
@@ -5669,6 +5983,7 @@ const createQueryRepository = (config) => {
                         isMultiTabSyncEnabled,
                         isPersistEnabled,
                         keepUnusedFor,
+                        tags,
                     },
                 ],
             ]);
@@ -5715,6 +6030,7 @@ const createQueryRepository = (config) => {
                 isRefreshable,
                 isMultiTabSyncEnabled,
                 isPersistEnabled,
+                tags,
             });
         }
         bumpCacheVersion();
@@ -5724,6 +6040,8 @@ const createQueryRepository = (config) => {
         isSecure: entry.isSecure,
         consumerCount: entry.consumers.size,
         isUnused: entry.consumers.size === 0,
+        isRefreshable: entry.isRefreshable,
+        tags: entry.tags,
         request: entry.request,
     }));
     const evict = (key, cause = 'manual') => {
@@ -5750,7 +6068,21 @@ const createQueryRepository = (config) => {
     return repository;
 };
 
+const clientNamesByInjector = /* @__PURE__ */ new WeakMap();
+const warnOnDuplicateClientName = (name, destroyRef) => {
+    const environmentInjector = inject(EnvironmentInjector);
+    const names = clientNamesByInjector.get(environmentInjector) ?? new Set();
+    clientNamesByInjector.set(environmentInjector, names);
+    if (names.has(name)) {
+        console.warn(`Two query clients are named "${name}". The name keys multi-tab sync, persistence and the devtools, so both clients share them. Give each createQueryClient() a unique name.`);
+        return;
+    }
+    names.add(name);
+    destroyRef.onDestroy(() => names.delete(name));
+};
 const createQueryClient = (options) => defineRootProvider(() => {
+    if (options.baseUrl.endsWith('/'))
+        throw invalidBaseRouteError$1(options.baseUrl);
     const httpClient = inject(HttpClient);
     const ngErrorHandler = inject(ErrorHandler);
     const injector = inject(Injector);
@@ -5768,6 +6100,8 @@ const createQueryClient = (options) => defineRootProvider(() => {
         dependencies: { httpClient, ngErrorHandler, injector },
     });
     const destroyRef = inject(DestroyRef);
+    if (isDevMode())
+        warnOnDuplicateClientName(options.name, destroyRef);
     destroyRef.onDestroy(() => {
         for (const entry of repository.subtle.cacheEntries()) {
             if (entry.isUnused)
@@ -5807,15 +6141,17 @@ 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 }), {
+            const tag = invalidation?.tag ?? null;
+            repository.refreshInUse(createQueryInvalidationFilter({ url, tag, filter: invalidation?.filter }), {
                 type: 'invalidation',
                 url,
                 otherTab: false,
+                ...(tag && { tag }),
             });
             // 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)
-                sync?.postInvalidation(url);
+                sync?.postInvalidation(url, tag);
         },
         clearPersistedQueries: () => persistenceEngine?.clear() ?? Promise.resolve(),
         whenPersistenceReady: persistenceEngine?.whenReady ?? Promise.resolve(),
@@ -6034,7 +6370,12 @@ const createSecureExecuteFactory = (options) => {
             throw invalidStateInsideSecureExecuteFactory();
         }
     };
-    const untrackedExec = (executeArgs) => untracked(() => exec(executeArgs));
+    const untrackedExec = (executeArgs) => untracked(() => {
+        if (skipParkedExecution(options.state, executeArgs?.args ?? options.state.args(), options.route))
+            return false;
+        exec(executeArgs);
+        return true;
+    });
     untrackedExec['reset'] = () => untracked(reset);
     untrackedExec['abort'] = () => aborter.abort(cancelPending);
     untrackedExec['aborted$'] = aborter.aborted$;
@@ -6048,6 +6389,7 @@ const createSecureExecuteFn = (executeOptions) => {
         authProvider,
         deps: executeOptions.deps,
         state: executeOptions.state,
+        route: executeOptions.creatorInternals.route,
         autoExecutes: shouldAutoExecuteQuery(executeOptions.creatorInternals.method) && !executeOptions.queryConfig.onlyManualExecution,
         transformAuthAndExec: (executeArgs, executeState) => {
             queryExecute({
@@ -6110,10 +6452,189 @@ const createPatchQuery = /* @__PURE__ */ createQueryTemplate('PATCH');
 /** A query creator that creates a secure PATCH query (requires authentication) */
 const createSecurePatchQuery = /* @__PURE__ */ createSecureQueryTemplate('PATCH');
 
+/**
+ * Groups a fixed set of queries of which the one executed last wins. The group fits `etQueryButton` and
+ * `et-query-error`'s `[query]`, which retries the member that ran last. Call it in an injection context.
+ *
+ * @example
+ * readonly actions = createQueryGroup({
+ *   accept: postAcceptInvitation(withArgs(() => ({ pathParams: { id: this.id() } }))),
+ *   decline: postDeclineInvitation(withArgs(() => ({ pathParams: { id: this.id() } }))),
+ * });
+ *
+ * accept() {
+ *   this.actions.members.accept.execute();
+ * }
+ */
+const createQueryGroup = (members) => {
+    const executions = new Subject();
+    const latestMember = signal(null, /* @ts-ignore */
+    ...(ngDevMode ? [{ debugName: "latestMember" }] : /* istanbul ignore next */ []));
+    injectInQueryContext(DestroyRef, 'query group').onDestroy(() => executions.complete());
+    const wrap = (key, query) => {
+        const member = {
+            key,
+            query,
+            execute: (executeArgs) => {
+                const ran = query.execute(executeArgs);
+                if (ran === false)
+                    return false;
+                latestMember.set(member);
+                executions.next(member);
+                return true;
+            },
+        };
+        return { ...query, execute: member.execute };
+    };
+    const wrappedMembers = Object.fromEntries(Object.entries(members).map(([key, query]) => [key, wrap(key, query)]));
+    const queries = Object.values(members);
+    const loading = computed(() => latestMember()?.query.loading() ??
+        queries.map((query) => query.loading()).find((state) => state !== null) ??
+        null, /* @ts-ignore */
+    ...(ngDevMode ? [{ debugName: "loading" }] : /* istanbul ignore next */ []));
+    const error = computed(() => latestMember()?.query.error() ?? null, /* @ts-ignore */
+    ...(ngDevMode ? [{ debugName: "error" }] : /* istanbul ignore next */ []));
+    const latest = computed(() => {
+        const member = latestMember();
+        return member ? { key: member.key, response: member.query.response() } : null;
+    }, /* @ts-ignore */
+    ...(ngDevMode ? [{ debugName: "latest" }] : /* istanbul ignore next */ []));
+    const execute = (executeArgs) => untracked(latestMember)?.execute(executeArgs);
+    const succeeded$ = executions.pipe(mergeMap(({ key, query }) => {
+        const snapshot = query.createSnapshot();
+        return snapshot.isAlive.asObservable().pipe(filter((isAlive) => !isAlive), take(1), map(() => untracked(() => snapshot.executionState())), filter((state) => state?.type === 'success'), map((state) => ({ key, response: state.response })));
+    }), share());
+    return { members: wrappedMembers, loading, error, latest, execute, succeeded$ };
+};
+
+const optimisticLayers = /* @__PURE__ */ new WeakMap();
+const liveLayer = (request) => {
+    const layer = optimisticLayers.get(request);
+    if (layer && layer.written === request.response())
+        return layer;
+    optimisticLayers.delete(request);
+    return null;
+};
+const rewrite = (request, layer) => {
+    layer.written = layer.ops.reduce((current, op) => op.apply(current) ?? current, layer.base);
+    request.subtle.setResponse(layer.written);
+    if (layer.ops.every((op) => op.settled))
+        optimisticLayers.delete(request);
+};
+const applyOp$1 = (request, op) => {
+    const current = request.response();
+    if (current === null)
+        return false;
+    const layer = liveLayer(request) ?? { base: current, written: current, ops: [] };
+    const next = op.apply(layer.written);
+    if (next === null)
+        return false;
+    layer.ops.push(op);
+    layer.written = next;
+    optimisticLayers.set(request, layer);
+    request.subtle.setResponse(next);
+    return true;
+};
+const settleOp = (request, op, confirmed) => {
+    const layer = liveLayer(request);
+    const index = layer?.ops.indexOf(op) ?? -1;
+    if (!layer || index === -1)
+        return;
+    if (confirmed) {
+        op.apply = confirmed;
+        op.settled = true;
+    }
+    else {
+        layer.ops.splice(index, 1);
+    }
+    rewrite(request, layer);
+};
+const findTargetRequests = (deps, targets) => {
+    const filters = targets.map((target) => createQueryInvalidationFilter('url' in target
+        ? { url: resolveInvalidationUrl(deps.client.baseUrl, target.url) }
+        : { url: null, tag: target.tag }));
+    return deps.client.repository.subtle
+        .cacheEntries()
+        .filter((entry) => entry.isRefreshable && filters.some((filter) => filter?.(entry.request, entry.tags)))
+        .map((entry) => entry.request);
+};
+/**
+ * Writes the expected result of a mutation into the cached responses of the reads `target` matches before
+ * the request leaves, and rolls those writes back if it fails or is cancelled. Pair it with the creator's
+ * `invalidates`, whose refetch corrects a wrong guess. The writes stay in this tab; the invalidation reaches
+ * the others.
+ *
+ * A rollback leaves an entry alone that a refetch or another tab wrote in the meantime; other optimistic
+ * updates of the entry still pending are re-applied on top of what it held before.
+ *
+ * @example
+ * patchOpportunityPerson(
+ *   withArgs(() => ({ pathParams: { uuid, peopleUuid }, body })),
+ *   withOptimisticUpdate({
+ *     read: getOpportunity,
+ *     target: ({ args }) => ({ tag: `opportunity:${args.pathParams.uuid}` }),
+ *     update: ({ current, args }) => ({ ...current, people: toggle(current.people, args.pathParams.peopleUuid) }),
+ *   }),
+ * );
+ *
+ * @throws If the query is a read (e.g. a GET request)
+ */
+const withOptimisticUpdate = (options) => {
+    const update = options.update;
+    return createQueryFeature({
+        type: QueryFeatureType.WITH_OPTIMISTIC_UPDATE,
+        devtools: () => queryDevtoolsFnDetail(options.update, 'update'),
+        fn: (context) => {
+            if (context.flags.shouldAutoExecuteMethod)
+                throw withOptimisticUpdateUsedOnRead(context.flags.method);
+            context.state.subtle.beforeExecute.set((executeArgs) => {
+                const args = executeArgs ?? {};
+                const target = options.target({ args });
+                const targets = Array.isArray(target) ? target : [target];
+                const optimistic = (current) => update({ current, args });
+                const applied = findTargetRequests(context.deps, targets)
+                    .map((request) => ({ request, op: { apply: optimistic, settled: false } }))
+                    .filter(({ request, op }) => applyOp$1(request, op));
+                if (!applied.length)
+                    return null;
+                const settle = (confirmed) => {
+                    for (const { request, op } of applied)
+                        settleOp(request, op, confirmed);
+                };
+                return (request) => {
+                    if (!request?.loading())
+                        return settle(null);
+                    let settled = false;
+                    const subscription = request.events$.subscribe({
+                        next: (event) => {
+                            if (event.type === HttpEventType.Response) {
+                                const response = context.state.subtle.request() === request ? context.state.response() : null;
+                                settled = true;
+                                settle((current) => update({ current, args, response }) ?? optimistic(current));
+                            }
+                            else if (event.type === 'error' || event.type === 'cancel') {
+                                settled = true;
+                                settle(null);
+                            }
+                            if (settled)
+                                subscription.unsubscribe();
+                        },
+                        complete: () => {
+                            if (!settled)
+                                settle(null);
+                        },
+                    });
+                };
+            });
+        },
+    });
+};
+
 const isAbortedSnapshot = (snapshot) => snapshot.latestHttpEvent()?.type === 'cancel' && snapshot.error() === null;
 const executeAndSettle$ = (query, executeArgs, emitAborted) => defer(() => {
-    query.execute(executeArgs);
-    const snapshot = query.createSnapshot();
+    const ran = query.execute(executeArgs);
+    // `false` means a parked query dropped the call: nothing runs, so a live snapshot would never settle.
+    const snapshot = ran === false ? createSkippedSnapshot(query) : query.createSnapshot();
     return snapshot.isAlive.asObservable().pipe(filter((isAlive) => !isAlive), take(1), 
     // The stream completes without emitting when the query's injector is torn down mid-execution.
     defaultIfEmpty(false), map(() => snapshot), filter((settled) => emitAborted || !untracked(() => isAbortedSnapshot(settled))), finalize(() => untracked(() => {
@@ -6128,7 +6649,7 @@ const executeAndSettle$ = (query, executeArgs, emitAborted) => defer(() => {
  *
  * Unsubscribing before it settles aborts the execution like `query.abort()`, the way unsubscribing
  * from `HttpClient` cancels its request. An execution stopped by `query.abort()` completes the stream
- * without a value.
+ * without a value, and so does a call a parked query (a `withArgs` source returning `null`) drops.
  *
  * A cancelled execution settles too - the entry was evicted, unbound by a logout, or the scope that
  * owns the query was destroyed. The snapshot then reports the execution as a failure whose error
@@ -6140,8 +6661,8 @@ const executeUntilSettled$ = (query, executeArgs) => executeAndSettle$(query, ex
  * signal-forms `submit()` action mapping server violations onto the form via
  * `mapViolationsToFormErrors`. Executes immediately. Prefer {@link executeUntilSettled$} in RxJS code.
  *
- * An execution stopped by `query.abort()` resolves with a snapshot that has no response, no error, a
- * `null` `executionState()` and `latestHttpEvent()` `{ type: 'cancel' }`.
+ * An execution stopped by `query.abort()`, or dropped by a parked query, resolves with a snapshot that
+ * has no response, no error, a `null` `executionState()` and `latestHttpEvent()` `{ type: 'cancel' }`.
  */
 const executeUntilSettled = (query, executeArgs) => firstValueFrom(executeAndSettle$(query, executeArgs, true));
 
@@ -6575,6 +7096,17 @@ const defaultExtractTokens = (response) => {
     }
     return { accessToken: response['accessToken'], refreshToken: response['refreshToken'] };
 };
+const subjectOf = (token) => {
+    const payload = decryptBearer$1(token);
+    return typeof payload?.sub === 'string' || typeof payload?.sub === 'number' ? payload.sub : null;
+};
+const isDifferentUser = (options) => {
+    const previous = subjectOf(options.previous);
+    const next = subjectOf(options.next);
+    if (previous !== null && next !== null)
+        return previous !== next;
+    return options.source === 'session';
+};
 const deriveExecutionStateType = (builder, triggeredBy) => {
     if (triggeredBy === 'persistent-auth')
         return 'autoLogin';
@@ -6623,7 +7155,7 @@ const setupBearerQueryRegistry = (builders, context) => {
                     const response = outcome.response;
                     try {
                         const tokens = extractTokens(response);
-                        applyTokens(tokens.accessToken, tokens.refreshToken);
+                        applyTokens(tokens.accessToken, tokens.refreshToken, type === 'tokenRefresh' ? 'rotation' : 'session');
                         executionState.set({ type, state: 'success', response });
                     }
                     catch (extractError) {
@@ -6749,16 +7281,18 @@ const createBearerAuthProviderImpl = (config) => {
     const refreshToken = signal(null, /* @ts-ignore */
     ...(ngDevMode ? [{ debugName: "refreshToken" }] : /* istanbul ignore next */ []));
     const afterTokenRefresh$ = new Subject();
+    const expiresInPropertyName = signal('exp', /* @ts-ignore */
+    ...(ngDevMode ? [{ debugName: "expiresInPropertyName" }] : /* istanbul ignore next */ []));
     const bearerData = computed(() => {
         const token = accessToken();
         if (!token)
             return null;
         try {
-            const decoded = config.bearerDecryptFn?.(token) ?? decryptBearer$1(token);
+            const decoded = config.bearerDecryptFn ? config.bearerDecryptFn(token) : decryptBearer$1(token);
             return patchQueryDevtoolsTokenPayload({
                 payload: decoded,
                 providerName: config.name,
-                expiresInPropertyName: 'exp',
+                expiresInPropertyName: expiresInPropertyName(),
             });
         }
         catch (error) {
@@ -6783,11 +7317,22 @@ const createBearerAuthProviderImpl = (config) => {
     ...(ngDevMode ? [{ debugName: "sessionEndCause" }] : /* istanbul ignore next */ []));
     const sessionEnd = signal(null, /* @ts-ignore */
     ...(ngDevMode ? [{ debugName: "sessionEnd" }] : /* istanbul ignore next */ []));
-    const applyTokens = (access, refresh) => {
+    const sessionId = signal(0, /* @ts-ignore */
+    ...(ngDevMode ? [{ debugName: "sessionId" }] : /* istanbul ignore next */ []));
+    const applyTokens = (access, refresh, source = 'rotation') => {
+        const previousAccess = untracked(accessToken);
+        const startsSession = previousAccess === null || isDifferentUser({ previous: previousAccess, next: access, source });
         accessToken.set(access);
         refreshToken.set(refresh);
         sessionStatus.set('authenticated');
         sessionEndCause.set(null);
+        if (startsSession)
+            sessionId.update((id) => id + 1);
+        // After the new tokens are in force: unbindAllSecure re-arms every auto-executing secure query, which
+        // would otherwise run again on the previous user's token.
+        if (previousAccess !== null && startsSession) {
+            untracked(() => queryClient.repository.unbindAllSecure());
+        }
         // Emit on the next microtask so that synchronous reactive work triggered by applying
         // the tokens (signals/effects) has a chance to settle before subscribers react.
         // This avoids rare races where a subscriber reacting to the emission would run
@@ -6802,7 +7347,7 @@ const createBearerAuthProviderImpl = (config) => {
         // auto-login or a refresh still out with an older token can only report a failure that no longer
         // means anything - or apply the pair it comes back with over this one.
         invalidateTokenIssuingExecutions();
-        applyTokens(access, refresh);
+        applyTokens(access, refresh, 'session');
         executionState.set({ type: 'tokenSeed', state: 'success' });
     };
     const { queries, hasTokenIssuingExecutionInFlight, invalidateTokenIssuingExecutions } = setupBearerQueryRegistry(config.queries, {
@@ -6891,6 +7436,7 @@ const createBearerAuthProviderImpl = (config) => {
         reportAccessTokenExpiry: (isExpired) => {
             readAccessTokenExpiry = isExpired;
         },
+        reportExpiresInPropertyName: (claim) => expiresInPropertyName.set(claim),
     };
     for (const builder of config.queries) {
         builder.setup?.(querySetupContext);
@@ -6949,6 +7495,7 @@ const createBearerAuthProviderImpl = (config) => {
         executionState: executionState.asReadonly(),
         sessionStatus: sessionStatus.asReadonly(),
         sessionEndCause: sessionEndCause.asReadonly(),
+        sessionId: sessionId.asReadonly(),
         session: computed(() => ({
             status: sessionStatus(),
             endCause: sessionEndCause(),
@@ -7081,6 +7628,7 @@ const withRefreshQuery = (key, config) => {
     const buildArgs = (refreshToken) => (config.buildArgs?.(refreshToken) ?? { body: { token: refreshToken } });
     const setup = (context) => {
         const expiresInPropertyName = config.expiresInPropertyName ?? 'exp';
+        context.reportExpiresInPropertyName(expiresInPropertyName);
         const minRefreshInterval = config.minRefreshInterval ?? 30000; // 30 seconds default
         const refreshIfExpired = config.refreshIfExpired ?? true;
         const destroyRef = inject(DestroyRef);
@@ -7265,48 +7813,51 @@ const withRefreshQuery = (key, config) => {
                 case 'notLeader':
                     return Math.min(Math.max(msUntilAccessTokenIsStale() ?? minRefreshInterval, rescheduleDelayMs), maxTimerDelayMs);
             }
-        };
-        const calculateRefreshBuffer = (tokenLifetimeMs) => {
-            if (typeof config.refreshStrategy === 'number') {
-                return config.refreshStrategy >= 0 && config.refreshStrategy <= 1
-                    ? tokenLifetimeMs * (1 - config.refreshStrategy)
-                    : Math.max(config.refreshStrategy, 0);
+        };
+        let expiryWarnedFor = null;
+        const tokenTimes = (token) => {
+            let decoded;
+            try {
+                decoded = context.bearerDecryptFn ? context.bearerDecryptFn(token) : decryptBearer$1(token);
+            }
+            catch {
+                decoded = null;
+            }
+            const times = readAccessTokenTimes({
+                token,
+                decoded,
+                claim: expiresInPropertyName,
+                providerName: context.name,
+            });
+            if (!times && isDevMode() && expiryWarnedFor !== token) {
+                expiryWarnedFor = token;
+                console.warn(authAccessTokenExpiryUnreadable(expiresInPropertyName).message);
             }
-            const percentage = config.refreshStrategy?.percentage ?? 0.75;
-            const minBufferMs = config.refreshStrategy?.minBufferMs ?? 60000; // 1 minute
-            const maxBufferMs = config.refreshStrategy?.maxBufferMs ?? 600000; // 10 minutes
-            const calculatedBuffer = tokenLifetimeMs * (1 - percentage);
-            return Math.max(minBufferMs, Math.min(maxBufferMs, calculatedBuffer));
+            return times;
         };
         /** When this token expires, as a timestamp, or `null` if the expiry cannot be read off it. */
-        const tokenExpiresAt = (token) => {
-            try {
-                const decoded = context.bearerDecryptFn ? context.bearerDecryptFn(token) : decryptBearer$1(token);
-                const bearerDataValue = patchQueryDevtoolsTokenPayload({
-                    payload: decoded,
-                    providerName: context.name,
-                    expiresInPropertyName,
-                });
-                const expiresIn = bearerDataValue?.[expiresInPropertyName];
-                if (typeof expiresIn !== 'number') {
-                    if (isDevMode()) {
-                        console.warn(`Token does not contain valid ${expiresInPropertyName} property for auto-refresh`);
-                    }
-                    return null;
-                }
-                return expiresIn * 1000;
+        const tokenExpiresAt = (token) => tokenTimes(token)?.expiresAtMs ?? null;
+        let measuredLifetime = null;
+        /**
+         * The whole lifetime of a token, not what is left of it: a schedule recomputed later (the tab came
+         * back to the foreground) must land at the same instant as the first one.
+         */
+        const tokenLifetimeMs = (token, times) => {
+            if (times.issuedAtMs !== null && times.expiresAtMs > times.issuedAtMs) {
+                return times.expiresAtMs - times.issuedAtMs;
             }
-            catch {
-                return null;
+            if (measuredLifetime?.token !== token) {
+                measuredLifetime = { token, lifetimeMs: times.expiresAtMs - Date.now() };
             }
+            return measuredLifetime.lifetimeMs;
         };
         /** When this access token is due to be refreshed, or `null` if it cannot be scheduled at all. */
         const scheduledRefreshDelay = (token) => {
-            const expiresAt = tokenExpiresAt(token);
-            if (expiresAt === null)
+            const times = tokenTimes(token);
+            if (times === null)
                 return null;
-            const tokenLifetimeMs = expiresAt - Date.now();
-            if (tokenLifetimeMs <= 0) {
+            const remainingMs = times.expiresAtMs - Date.now();
+            if (remainingMs <= 0) {
                 if (!refreshIfExpired)
                     return null;
                 if (isDevMode()) {
@@ -7314,7 +7865,7 @@ const withRefreshQuery = (key, config) => {
                 }
                 return 0;
             }
-            return Math.max(tokenLifetimeMs - calculateRefreshBuffer(tokenLifetimeMs), 0);
+            return Math.max(remainingMs - refreshBufferMs(config.refreshStrategy, tokenLifetimeMs(token, times)), 0);
         };
         /**
          * How long this tab can still work with the access token it holds, or `null` without a readable
@@ -7915,40 +8466,59 @@ const buildPersistentAuthFeature = (config, context) => {
  */
 const createPersistentAuthFeature = (config, context) => runInInjectionContext(context.injector, () => buildPersistentAuthFeature(config, context));
 
+const RENEWAL_GRACE_MS = 10_000;
 const withTokenExpirationWarning = (config = {}) => {
     return (context) => {
         const warningThreshold = config.warningThreshold ?? 5 * 60 * 1000;
         const checkInterval = config.checkInterval ?? 1000;
         const refreshBuilder = context.queryBuilders.find((builder) => builder._type === 'tokenRefreshQuery');
-        const expiresInPropertyName = config.expiresInPropertyName ??
-            (refreshBuilder?._type === 'tokenRefreshQuery' ? refreshBuilder.config.expiresInPropertyName : undefined) ??
-            'exp';
-        const expiresAt = computed(() => {
-            const decoded = context.bearerData();
-            if (!decoded)
+        const refreshConfig = refreshBuilder?._type === 'tokenRefreshQuery' ? refreshBuilder.config : null;
+        const expiresInPropertyName = config.expiresInPropertyName ?? refreshConfig?.expiresInPropertyName ?? 'exp';
+        let measuredLifetime = null;
+        const tokenTimes = computed(() => {
+            const token = context.accessToken();
+            if (!token)
                 return null;
-            const exp = decoded[expiresInPropertyName];
-            if (typeof exp !== 'number')
+            const times = readAccessTokenTimes({
+                token,
+                decoded: context.bearerData(),
+                claim: expiresInPropertyName,
+                providerName: context.name,
+            });
+            if (!times)
                 return null;
-            return new Date(exp * 1000);
+            if (times.issuedAtMs !== null && times.expiresAtMs > times.issuedAtMs) {
+                return { ...times, lifetimeMs: times.expiresAtMs - times.issuedAtMs };
+            }
+            if (measuredLifetime?.token !== token) {
+                measuredLifetime = { token, lifetimeMs: times.expiresAtMs - Date.now() };
+            }
+            return { ...times, lifetimeMs: measuredLifetime.lifetimeMs };
+        }, /* @ts-ignore */
+        ...(ngDevMode ? [{ debugName: "tokenTimes" }] : /* istanbul ignore next */ []));
+        const expiresAt = computed(() => {
+            const times = tokenTimes();
+            return times ? new Date(times.expiresAtMs) : null;
         }, /* @ts-ignore */
         ...(ngDevMode ? [{ debugName: "expiresAt" }] : /* istanbul ignore next */ []));
-        const expiresIn$ = toObservable(context.bearerData).pipe(switchMap((bearerData) => bearerData
+        const expiresIn = toSignal(toObservable(tokenTimes).pipe(switchMap((times) => times
             ? timer(0, checkInterval).pipe(map(() => {
-                const expiry = expiresAt();
-                if (!expiry)
-                    return null;
-                const msUntilExpiry = expiry.getTime() - Date.now();
+                const msUntilExpiry = times.expiresAtMs - Date.now();
                 return msUntilExpiry > 0 ? msUntilExpiry : null;
             }))
-            : of(null)));
-        const isExpiringSoon$ = expiresIn$.pipe(map((msUntilExpiry) => {
-            if (msUntilExpiry === null)
+            : of(null))), { initialValue: null });
+        const isExpiringSoon = computed(() => {
+            const msUntilExpiry = expiresIn();
+            const times = tokenTimes();
+            if (msUntilExpiry === null || !times || msUntilExpiry > warningThreshold)
                 return false;
-            return msUntilExpiry <= warningThreshold && msUntilExpiry > 0;
-        }));
-        const expiresIn = toSignal(expiresIn$, { initialValue: null });
-        const isExpiringSoon = toSignal(isExpiringSoon$, { initialValue: false });
+            if (!refreshConfig || !context.refreshToken())
+                return true;
+            const bufferMs = refreshBufferMs(refreshConfig.refreshStrategy, times.lifetimeMs);
+            const msOverdue = bufferMs - msUntilExpiry;
+            return msOverdue >= Math.min(RENEWAL_GRACE_MS, bufferMs / 2);
+        }, /* @ts-ignore */
+        ...(ngDevMode ? [{ debugName: "isExpiringSoon" }] : /* istanbul ignore next */ []));
         const instance = {
             expiresAt,
             expiresIn,
@@ -8001,10 +8571,11 @@ const withTokenRevocation = (config) => {
             ...(ngDevMode ? [{ debugName: "target" }] : /* istanbul ignore next */ []));
             const dropped = signal(false, /* @ts-ignore */
             ...(ngDevMode ? [{ debugName: "dropped" }] : /* istanbul ignore next */ []));
-            const follow = (read) => wrapAsObservableSignal(computed(() => {
+            const watcher = createObservableSignalWatcher(context.injector);
+            const follow = (read) => watcher.wrap(computed(() => {
                 const snapshot = target();
                 return snapshot ? read(snapshot) : null;
-            }), context.injector);
+            }));
             const snapshot = {
                 args: follow((s) => s.args()),
                 response: follow((s) => s.response()),
@@ -8015,7 +8586,7 @@ const withTokenRevocation = (config) => {
                 triggeredBy: follow((s) => s.triggeredBy()),
                 id: follow((s) => s.id()),
                 executionState: follow((s) => s.executionState()),
-                isAlive: wrapAsObservableSignal(computed(() => target()?.isAlive() ?? !(dropped() || queueDropped())), context.injector),
+                isAlive: watcher.wrap(computed(() => target()?.isAlive() ?? !(dropped() || queueDropped()))),
             };
             const queued = {
                 tokens,
@@ -8152,19 +8723,18 @@ const buildTrackingFeature = (context, config) => {
             }
         }
     };
-    const fireHandlers = (event, data) => {
-        const eventHandlers = handlers.get(event);
-        if (eventHandlers) {
-            eventHandlers.forEach((handler) => {
-                try {
-                    handler(data);
-                }
-                catch (error) {
-                    console.error(`Error in tracking event handler for "${event}":`, error);
-                }
-            });
-        }
-    };
+    // Handlers run outside the reactive context of the effects that fire them, so one that ends the
+    // session or creates a query does not throw NG0602.
+    const fireHandlers = (event, data) => untracked(() => {
+        handlers.get(event)?.forEach((handler) => {
+            try {
+                handler(data);
+            }
+            catch (error) {
+                console.error(`Error in tracking event handler for "${event}":`, error);
+            }
+        });
+    });
     const pendingForwardedMessages = [];
     const forwardingChannel = context.leaderElection && typeof BroadcastChannel !== 'undefined'
         ? new BroadcastChannel(`ethlete-auth-tracking:${context.name}`)
@@ -8298,6 +8868,10 @@ const buildTrackingFeature = (context, config) => {
  */
 const createTrackingFeature = (context, config) => runInInjectionContext(context.injector, () => buildTrackingFeature(context, config));
 
+// Generated from package.json by tools/scripts/generate-version.js - do not edit.
+/** The version of `@ethlete/query` this build was cut from. */
+const QUERY_VERSION = '6.0.0-next.56';
+
 const ethlete = {};
 let app = null;
 /** What `window.ethlete` exposes - the same object {@link queryDevtoolsAbout} returns. */
@@ -9321,12 +9895,23 @@ const sanitizeSession = (value) => {
         savedAt: typeof session.savedAt === 'number' ? session.savedAt : 0,
     };
 };
+const isLocalAccount = (value) => {
+    const account = value;
+    return (typeof account === 'object' &&
+        account !== null &&
+        typeof account.id === 'string' &&
+        typeof account.provider === 'string' &&
+        typeof account.label === 'string' &&
+        typeof account.loginQuery === 'string' &&
+        typeof account.scope === 'string' &&
+        (account.fields === undefined || Array.isArray(account.fields)));
+};
 const sanitize = (value) => ({
     sessions: Array.isArray(value?.sessions)
         ? value.sessions.map(sanitizeSession).filter((session) => session !== null)
         : [],
     credentials: typeof value?.credentials === 'object' && value.credentials !== null ? value.credentials : {},
-    accounts: Array.isArray(value?.accounts) ? value.accounts : [],
+    accounts: Array.isArray(value?.accounts) ? value.accounts.filter(isLocalAccount) : [],
 });
 /**
  * The vault is one key every tab writes, so a tab holding a stale copy of it would drop whatever another
@@ -9998,247 +10583,40 @@ const resolveQueryDevtoolsFaultForAttempt = (target) => {
  */
 const noteQueryFormReads = (formId, source) => {
     const memoized = computed(() => source(), /* @ts-ignore */
-    ...(ngDevMode ? [{ debugName: "memoized" }] : /* istanbul ignore next */ []));
-    // The read must be noted per read, not per recomputation of the value: the second query to build
-    // args reads a memoized value, and a note that only fires on a recomputation never reaches its
-    // collection window. Carrying the memo's signal node over keeps this function a real `Signal`.
-    const read = () => {
-        noteQueryFormRead(formId);
-        return memoized();
-    };
-    return Object.assign(read, { [SIGNAL]: memoized[SIGNAL] });
-};
-/**
- * Records which query forms feed one query's args, so the devtools can answer "which query does this
- * form drive?" from the reads themselves rather than from a naming convention.
- * @internal
- */
-const createQueryDevtoolsFormLinks = () => {
-    const ids = signal([], /* @ts-ignore */
-    ...(ngDevMode ? [{ debugName: "ids" }] : /* istanbul ignore next */ []));
-    return {
-        ids: ids.asReadonly(),
-        track: (build) => {
-            const collected = collectQueryFormLinks(build);
-            // Args are built inside a reactive computation, which may not write to a signal - `untracked`
-            // lifts that restriction, and skipping the write unless something is new keeps the panel from
-            // being notified on every evaluation.
-            untracked(() => {
-                const known = ids();
-                const added = collected.ids.filter((id) => !known.includes(id));
-                if (added.length)
-                    ids.set([...known, ...added]);
-            });
-            return collected.value;
-        },
-    };
-};
-
-/**
- * The designed library. Which of them is **armed** is a separate store under a separate scope - see
- * {@link queryDevtoolsArmedMocks}.
- */
-const STORAGE_KEY$1 = 'ethlete:query:devtools:mocks:v1';
-const ARMED_STORAGE_KEY = 'ethlete:query:devtools:mocks:armed:v1';
-const mocks = /* @__PURE__ */ signal([], /* @ts-ignore */
-...(ngDevMode ? [{ debugName: "mocks" }] : /* istanbul ignore next */ []));
-const armed = /* @__PURE__ */ signal(/* @__PURE__ */ new Set(), /* @ts-ignore */
-...(ngDevMode ? [{ debugName: "armed" }] : /* istanbul ignore next */ []));
-const armedRestored = /* @__PURE__ */ signal(false, /* @ts-ignore */
-...(ngDevMode ? [{ debugName: "armedRestored" }] : /* istanbul ignore next */ []));
-const scope$1 = () => queryDevtoolsSettings().mocks;
-const armedScope = () => queryDevtoolsSettings().armedMocks;
-/** The designed mocks, armed or not. Persisted, because losing an hour of authoring is unacceptable. */
-const queryDevtoolsMocks = /* @__PURE__ */ mocks.asReadonly();
-/**
- * The ids currently being served. Not kept across page loads unless the `armedMocks` setting asks for it -
- * an app that silently serves designed data tomorrow morning is worse than losing which mocks were armed.
- */
-const queryDevtoolsArmedMocks = /* @__PURE__ */ armed.asReadonly();
-/**
- * Whether what is armed right now came back from a previous page load rather than being armed by hand.
- * The panel's armed bar says so, because mocks nobody remembers arming look exactly like a broken API.
- */
-const queryDevtoolsArmedMocksRestored = /* @__PURE__ */ armedRestored.asReadonly();
-/**
- * The identity of a designed mock: one per client, method, route **and** declared query. The query is part
- * of it so `/posts?page=1` and `/posts?page=2` can hold different bodies.
- */
-const queryDevtoolsMockId = (parts) => `${parts.clientName}|${parts.method}|${parts.pattern}${parts.query ? `?${parts.query}` : ''}`;
-const write = () => {
-    if (scope$1() === 'none') {
-        clearQueryDevtoolsStore(STORAGE_KEY$1);
-        return;
-    }
-    writeQueryDevtoolsStore(scope$1(), STORAGE_KEY$1, mocks());
-};
-const writeArmed = () => {
-    if (armedScope() === 'none') {
-        clearQueryDevtoolsStore(ARMED_STORAGE_KEY);
-        return;
-    }
-    writeQueryDevtoolsStore(armedScope(), ARMED_STORAGE_KEY, [...armed()]);
-};
-/** Every change made by hand goes through here, so none of them can leave the store or the bar behind. */
-const setArmed = (next) => {
-    armed.set(next);
-    armedRestored.set(false);
-    writeArmed();
-};
-const isMock = (value) => {
-    const mock = value;
-    return (!!mock &&
-        typeof mock.id === 'string' &&
-        typeof mock.clientName === 'string' &&
-        typeof mock.method === 'string' &&
-        typeof mock.pattern === 'string' &&
-        typeof mock.status === 'number');
-};
-/**
- * Reads the designed library, so a mock can be armed without authoring it again. Called by
- * `provideQueryDevtools()` after the settings it takes its scope from; nothing else may call it.
- * @internal
- */
-const initQueryDevtoolsMocks = () => {
-    const stored = readQueryDevtoolsStore(scope$1(), STORAGE_KEY$1);
-    // `query` was added after the first version of the store, so an entry written before it still loads.
-    mocks.set(Array.isArray(stored) ? stored.filter(isMock).map((mock) => ({ ...mock, query: mock.query ?? '' })) : []);
-    const kept = readQueryDevtoolsStore(armedScope(), ARMED_STORAGE_KEY);
-    const library = new Set(mocks().map((mock) => mock.id));
-    // An id the library no longer holds would arm nothing, so it is dropped rather than kept waiting for a
-    // mock that may never be designed again.
-    const inherited = Array.isArray(kept)
-        ? kept.filter((id) => typeof id === 'string' && library.has(id))
-        : [];
-    armed.set(new Set(inherited));
-    armedRestored.set(inherited.length > 0);
-};
-/**
- * The path of a request URL relative to the client's `baseUrl` (base path included), without its query
- * string - what a pattern is matched against. A URL outside `baseUrl`, or no `baseUrl` at all, falls
- * back to the path without its origin.
- */
-const queryDevtoolsRequestPath = (url, baseUrl) => {
-    const withoutQuery = url.split('?')[0] ?? '';
-    const base = baseUrl?.replace(/\/+$/, '');
-    if (base && withoutQuery.startsWith(base)) {
-        const rest = withoutQuery.slice(base.length);
-        if (!rest)
-            return '/';
-        if (rest.startsWith('/'))
-            return rest;
-    }
-    const schemeEnd = withoutQuery.indexOf('://');
-    if (schemeEnd === -1)
-        return withoutQuery;
-    const pathStart = withoutQuery.indexOf('/', schemeEnd + 3);
-    return pathStart === -1 ? '/' : withoutQuery.slice(pathStart);
-};
-const segmentsOf$1 = (path) => path.split('/').filter(Boolean);
-/** The query string of a request URL, without the `?`. */
-const queryOf = (url) => url.split('?')[1] ?? '';
-/**
- * Whether a request carries every query parameter a mock declares. Extra parameters are ignored - a mock
- * says what the request must ask for, not everything it may.
- */
-const matchesQueryDevtoolsMockQuery = (declared, url) => {
-    if (!declared)
-        return true;
-    const asked = new URLSearchParams(queryOf(url));
-    return [...new URLSearchParams(declared)].every(([key, value]) => asked.get(key) === value);
-};
-/**
- * Whether a request path is the route a pattern describes. A `:param` segment matches any single
- * non-empty segment, which is the whole point: a mock is armed for a route, not for the one URL a query
- * happened to build.
- */
-const matchesQueryDevtoolsMockPattern = (pattern, path) => {
-    const patternSegments = segmentsOf$1(pattern);
-    const pathSegments = segmentsOf$1(path);
-    if (patternSegments.length !== pathSegments.length)
-        return false;
-    return patternSegments.every((segment, index) => segment.startsWith(':') || segment === pathSegments[index]);
-};
-/**
- * Adds a designed mock, or replaces the one already under its id. Arming is untouched: re-designing a
- * body while it is being served changes what the next request gets.
- */
-const saveQueryDevtoolsMock = (mock) => {
-    mocks.update((current) => {
-        const index = current.findIndex((entry) => entry.id === mock.id);
-        if (index === -1)
-            return [...current, mock];
-        return current.map((entry) => (entry.id === mock.id ? mock : entry));
-    });
-    write();
-};
-/** Removes a designed mock, disarming it on the way out. */
-const deleteQueryDevtoolsMock = (id) => {
-    mocks.update((current) => current.filter((entry) => entry.id !== id));
-    armQueryDevtoolsMock(id, false);
-    write();
-};
-/** Starts or stops serving one designed mock. Arming a mock that is not in the library does nothing. */
-const armQueryDevtoolsMock = (id, isArmed) => {
-    if (isArmed && !mocks().some((mock) => mock.id === id))
-        return;
-    const next = new Set(armed());
-    if (isArmed)
-        next.add(id);
-    else
-        next.delete(id);
-    setArmed(next);
-};
-/** Starts serving every mock in the library - the counterpart of {@link clearQueryDevtoolsArmedMocks}. */
-const armAllQueryDevtoolsMocks = () => setArmed(new Set(mocks().map((mock) => mock.id)));
-/** Stops serving every mock, leaving the library alone - the armed bar's one-click way out. */
-const clearQueryDevtoolsArmedMocks = () => setArmed(new Set());
-/**
- * Where the armed set is kept. Switching to a scope that keeps it stores whatever is armed right now, so
- * the choice reads as "keep these"; switching to `none` empties the store and leaves this page serving
- * exactly what it was already serving.
- */
-const setQueryDevtoolsArmedMocksScope = (next) => {
-    if (next === armedScope())
-        return;
-    // Off both stores first: whichever the previous scope was, its copy must not outlive the change.
-    clearQueryDevtoolsStore(ARMED_STORAGE_KEY);
-    setQueryDevtoolsSettings({ armedMocks: next });
-    writeArmed();
-};
-/** Empties the designed library and disarms everything - the panel's "Reset devtools". */
-const clearQueryDevtoolsMockStore = () => {
-    mocks.set([]);
-    armed.set(new Set());
-    armedRestored.set(false);
-    clearQueryDevtoolsStore(STORAGE_KEY$1);
-    clearQueryDevtoolsStore(ARMED_STORAGE_KEY);
+    ...(ngDevMode ? [{ debugName: "memoized" }] : /* istanbul ignore next */ []));
+    // The read must be noted per read, not per recomputation of the value: the second query to build
+    // args reads a memoized value, and a note that only fires on a recomputation never reaches its
+    // collection window. Carrying the memo's signal node over keeps this function a real `Signal`.
+    const read = () => {
+        noteQueryFormRead(formId);
+        return memoized();
+    };
+    return Object.assign(read, { [SIGNAL]: memoized[SIGNAL] });
 };
-const declaredParamCount = (mock) => (mock.query ? [...new URLSearchParams(mock.query)].length : 0);
 /**
- * The mock to serve one upcoming attempt, or `null` to let it reach the network. The armed mock declaring
- * the most query parameters wins, so a special case armed on top of a general one is what answers.
- *
- * Installed as the mock resolver by `provideQueryDevtools()`; nothing else may call it.
+ * 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 resolveQueryDevtoolsMockForAttempt = (target) => {
-    const ids = armed();
-    if (!ids.size)
-        return null;
-    const path = queryDevtoolsRequestPath(target.url, target.baseUrl);
-    const mock = mocks()
-        .filter((candidate) => ids.has(candidate.id) &&
-        candidate.clientName === target.clientName &&
-        candidate.method === target.method &&
-        matchesQueryDevtoolsMockPattern(candidate.pattern, path) &&
-        matchesQueryDevtoolsMockQuery(candidate.query, target.url))
-        // The most specific armed mock answers: one that names `page=2` beats one that takes any query, so
-        // arming a general mock does not shadow the special case someone armed on top of it.
-        .sort((a, b) => declaredParamCount(b) - declaredParamCount(a))[0];
-    if (!mock)
-        return null;
-    return { status: mock.status, body: mock.body, latencyMs: mock.latencyMs };
+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 isPathAtOrBelow = (path, root) => path.length >= root.length && root.every((step, index) => step === path[index]);
@@ -10475,19 +10853,19 @@ const resizePagination = (value, shape, mode, amount) => {
     }
     return result;
 };
-const STRING_PRESETS = {
+const STRING_PRESETS$1 = {
     short: 'Ab',
     long: /* @__PURE__ */ 'Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod tempor incididunt. '.repeat(4),
     longWord: 'Rindfleischetikettierungsüberwachungsaufgabenübertragungsgesetz',
     unicode: 'مرحبا بالعالم 👋 日本語テスト 🎉 Ñoño',
 };
-const stringPresetValue = (preset, custom) => custom ?? (preset === 'custom' ? '' : STRING_PRESETS[preset]);
-const NUMBER_PRESETS = {
+const stringPresetValue = (preset, custom) => custom ?? (preset === 'custom' ? '' : STRING_PRESETS$1[preset]);
+const NUMBER_PRESETS$1 = {
     zero: 0,
     negative: -1,
     huge: Number.MAX_SAFE_INTEGER,
 };
-const numberPresetValue = (preset, custom) => custom ?? (preset === 'custom' ? 0 : NUMBER_PRESETS[preset]);
+const numberPresetValue = (preset, custom) => custom ?? (preset === 'custom' ? 0 : NUMBER_PRESETS$1[preset]);
 const pickRandom = (values) => values[Math.floor(Math.random() * values.length)];
 const randomIntBetween = (min, max) => min + Math.floor(Math.random() * (max - min + 1));
 const randomHex = (length) => {
@@ -10703,6 +11081,30 @@ const OP_TYPES = /* @__PURE__ */ new Set([
     'reset',
 ]);
 const isJsonPath = (value) => Array.isArray(value) && value.every((step) => typeof step === 'string' || typeof step === 'number');
+const STRING_PRESETS = ['short', 'long', 'longWord', 'unicode', 'custom'];
+const NUMBER_PRESETS = ['zero', 'negative', 'huge', 'custom'];
+const DATE_PRESETS = ['now', 'plusDay', 'minusDay', 'farFuture', 'farPast', 'invalid'];
+const isIndex = (value) => Number.isInteger(value) && value >= 0;
+const hasReplayableFields = (op) => {
+    switch (op['type']) {
+        case 'set':
+            return 'value' in op;
+        case 'stringPreset':
+            return STRING_PRESETS.includes(op['preset']) && (op['custom'] === undefined || typeof op['custom'] === 'string');
+        case 'numberPreset':
+            return NUMBER_PRESETS.includes(op['preset']) && (op['custom'] === undefined || Number.isFinite(op['custom']));
+        case 'datePreset':
+            return DATE_PRESETS.includes(op['preset']);
+        case 'duplicateArrayItem':
+            return isIndex(op['index']);
+        case 'pasteArrayItem':
+            return 'value' in op && (op['index'] === undefined || isIndex(op['index']));
+        case 'paginationResize':
+            return (op['mode'] === 'shrink' || op['mode'] === 'extend') && isIndex(op['amount']);
+        default:
+            return true;
+    }
+};
 /**
  * Whether a value parsed from outside - a paste, a stored set - is an op this build can replay.
  * @internal
@@ -10711,7 +11113,7 @@ const isOverrideOp = (value) => {
     if (!value || typeof value !== 'object' || Array.isArray(value))
         return false;
     const op = value;
-    return typeof op.type === 'string' && OP_TYPES.has(op.type) && isJsonPath(op.path);
+    return (typeof op['type'] === 'string' && OP_TYPES.has(op['type']) && isJsonPath(op['path']) && hasReplayableFields(op));
 };
 /**
  * Serializes the ops armed on one query into clipboard text. `reset` never reaches a recorder's list, so
@@ -10777,12 +11179,12 @@ const armQueryDevtoolsOverrideTransfer = (recorder, ops) => {
  * debugging the wrong thing. `local` is offered in Settings for the dev who has a reason, and the
  * restored-overrides bar names the scope whatever it is.
  */
-const STORAGE_KEY = 'ethlete:query:devtools:overrides:v1';
+const STORAGE_KEY$1 = 'ethlete:query:devtools:overrides:v1';
 const restored = /* @__PURE__ */ signal([], /* @ts-ignore */
 ...(ngDevMode ? [{ debugName: "restored" }] : /* istanbul ignore next */ []));
 const restoredScope = /* @__PURE__ */ signal(null, /* @ts-ignore */
 ...(ngDevMode ? [{ debugName: "restoredScope" }] : /* istanbul ignore next */ []));
-const scope = () => queryDevtoolsSettings().overrides;
+const scope$1 = () => queryDevtoolsSettings().overrides;
 /** Where "Keep across reloads" puts them back when it is switched on again. */
 let lastPersistentScope = 'session';
 /** Every recorder that currently holds at least one op, so switching persistence on can capture them. */
@@ -10793,7 +11195,7 @@ const carriedOver = /* @__PURE__ */ new Map();
 const replayed = /* @__PURE__ */ new Set();
 let ops = {};
 const readStore = () => {
-    const parsed = readQueryDevtoolsStore(scope(), STORAGE_KEY);
+    const parsed = readQueryDevtoolsStore(scope$1(), STORAGE_KEY$1);
     const stored = parsed?.ops;
     const usable = !!stored && typeof stored === 'object' && !Array.isArray(stored);
     const valid = {};
@@ -10805,11 +11207,11 @@ const readStore = () => {
     return { enabled: parsed?.enabled === true, ops: valid };
 };
 const writeStore = () => {
-    if (scope() === 'none') {
-        clearQueryDevtoolsStore(STORAGE_KEY);
+    if (scope$1() === 'none') {
+        clearQueryDevtoolsStore(STORAGE_KEY$1);
         return;
     }
-    writeQueryDevtoolsStore(scope(), STORAGE_KEY, { enabled: true, ops });
+    writeQueryDevtoolsStore(scope$1(), STORAGE_KEY$1, { enabled: true, ops });
 };
 const publishRestored = () => restored.set([...carriedOver].map(([id, count]) => ({ id, count, armed: replayed.has(id) })));
 const forgetCarriedOver = () => {
@@ -10842,7 +11244,7 @@ const initQueryDevtoolsOverridePersistence = () => {
         if (list.length)
             carriedOver.set(id, list.length);
     }
-    const current = scope();
+    const current = scope$1();
     if (current !== 'none')
         lastPersistentScope = current;
     restoredScope.set(carriedOver.size ? current : null);
@@ -10852,7 +11254,7 @@ const initQueryDevtoolsOverridePersistence = () => {
  * Whether armed response overrides are stored and replayed on the next page load - that is, whether
  * their scope is anything other than `none`. Off by default.
  */
-const queryDevtoolsOverridePersistence = /* @__PURE__ */ computed(() => scope() !== 'none', /* @ts-ignore */
+const queryDevtoolsOverridePersistence = /* @__PURE__ */ computed(() => scope$1() !== 'none', /* @ts-ignore */
 ...(ngDevMode ? [{ debugName: "queryDevtoolsOverridePersistence" }] : /* istanbul ignore next */ []));
 /**
  * Where armed response overrides are kept. Switching to a scope that keeps them captures whatever is
@@ -10861,11 +11263,11 @@ const queryDevtoolsOverridePersistence = /* @__PURE__ */ computed(() => scope()
  * op exactly where it is for the rest of this page.
  */
 const setQueryDevtoolsOverridesScope = (next) => {
-    const previous = scope();
+    const previous = scope$1();
     if (next === previous)
         return;
     // Off both stores first: whichever the previous scope was, its copy must not outlive the change.
-    clearQueryDevtoolsStore(STORAGE_KEY);
+    clearQueryDevtoolsStore(STORAGE_KEY$1);
     setQueryDevtoolsSettings({ overrides: next });
     if (next === 'none') {
         ops = {};
@@ -10884,106 +11286,309 @@ const setQueryDevtoolsOverridesScope = (next) => {
     writeStore();
 };
 /**
- * Turns persistence on or off - the panel's "Keep across reloads" toggle. On restores the last scope
- * that kept them (`session` unless Settings picked `local`).
+ * Turns persistence on or off - the panel's "Keep across reloads" toggle. On restores the last scope
+ * that kept them (`session` unless Settings picked `local`).
+ */
+const setQueryDevtoolsOverridePersistence = (value) => {
+    setQueryDevtoolsOverridesScope(value ? lastPersistentScope : 'none');
+};
+/**
+ * Empties the override store in both browser stores and disarms everything a reload brought back,
+ * without changing where overrides are kept - the panel's "Reset devtools".
+ */
+const clearQueryDevtoolsOverrideStore = () => {
+    clearRestoredQueryDevtoolsOverrides();
+    ops = {};
+    clearQueryDevtoolsStore(STORAGE_KEY$1);
+};
+/**
+ * The ops this page load inherited from the previous one, and for each id whether a live query has taken
+ * it. Overrides that outlive the page that armed them have to announce themselves, because an app being
+ * lied to looks exactly like an app that is broken.
+ */
+const restoredQueryDevtoolsOverrides = 
+/* @__PURE__ */ restored.asReadonly();
+/**
+ * The scope those ops came back from, or `null` when this page inherited none. `local` is the one worth
+ * naming in the banner: it means they outlived closing the tab, not just a reload.
+ */
+const queryDevtoolsRestoredOverridesScope = 
+/* @__PURE__ */ restoredScope.asReadonly();
+/** Disarms every op this page load inherited and empties the store - the banner's one-click way out. */
+const clearRestoredQueryDevtoolsOverrides = () => {
+    for (const id of replayed) {
+        armedRecorders.get(id)?.clearAll();
+        armedRecorders.delete(id);
+    }
+    for (const id of carriedOver.keys())
+        writeOps(id, []);
+    forgetCarriedOver();
+};
+/**
+ * Forgets a destroyed query's recorder. Ops already persisted stay in the store on purpose - they are
+ * keyed by an id the next page load re-derives, which is what "Keep across reloads" replays them from.
+ * @internal
+ */
+const releaseQueryDevtoolsOverridePersistence = (id) => {
+    armedRecorders.delete(id);
+    if (scope$1() !== 'none')
+        return;
+    const { [id]: _dropped, ...rest } = ops;
+    ops = rest;
+};
+/**
+ * Wraps a query's overrides recorder so its armed ops are stored and replayed. Replay happens here, at
+ * registration, rather than in the panel - a query can run long before the panel is ever opened.
+ *
+ * Ids are reload-deterministic (descriptor + per-descriptor counter), so the same queries created in the
+ * same order re-arm correctly; an id the store holds that nobody claims is reported by
+ * {@link restoredQueryDevtoolsOverrides} rather than guessed at.
+ * @internal
+ */
+const withQueryDevtoolsOverridePersistence = (id, recorder) => {
+    const inherited = ops[id];
+    if (scope$1() !== 'none' && inherited?.length) {
+        for (const op of inherited)
+            recorder.arm(op);
+        armedRecorders.set(id, recorder);
+        replayed.add(id);
+        publishRestored();
+    }
+    const sync = () => {
+        const list = recorder.list().map((entry) => entry.op);
+        if (list.length)
+            armedRecorders.set(id, recorder);
+        else
+            armedRecorders.delete(id);
+        if (scope$1() !== 'none')
+            writeOps(id, list);
+    };
+    return {
+        ...recorder,
+        arm: (op) => {
+            recorder.arm(op);
+            sync();
+        },
+        clear: (opId) => {
+            recorder.clear(opId);
+            sync();
+        },
+        clearAll: () => {
+            recorder.clearAll();
+            if (replayed.delete(id))
+                publishRestored();
+            sync();
+        },
+    };
+};
+
+/**
+ * The designed library. Which of them is **armed** is a separate store under a separate scope - see
+ * {@link queryDevtoolsArmedMocks}.
+ */
+const STORAGE_KEY = 'ethlete:query:devtools:mocks:v1';
+const ARMED_STORAGE_KEY = 'ethlete:query:devtools:mocks:armed:v1';
+const mocks = /* @__PURE__ */ signal([], /* @ts-ignore */
+...(ngDevMode ? [{ debugName: "mocks" }] : /* istanbul ignore next */ []));
+const armed = /* @__PURE__ */ signal(/* @__PURE__ */ new Set(), /* @ts-ignore */
+...(ngDevMode ? [{ debugName: "armed" }] : /* istanbul ignore next */ []));
+const armedRestored = /* @__PURE__ */ signal(false, /* @ts-ignore */
+...(ngDevMode ? [{ debugName: "armedRestored" }] : /* istanbul ignore next */ []));
+const scope = () => queryDevtoolsSettings().mocks;
+const armedScope = () => queryDevtoolsSettings().armedMocks;
+/** The designed mocks, armed or not. Persisted, because losing an hour of authoring is unacceptable. */
+const queryDevtoolsMocks = /* @__PURE__ */ mocks.asReadonly();
+/**
+ * The ids currently being served. Not kept across page loads unless the `armedMocks` setting asks for it -
+ * an app that silently serves designed data tomorrow morning is worse than losing which mocks were armed.
+ */
+const queryDevtoolsArmedMocks = /* @__PURE__ */ armed.asReadonly();
+/**
+ * Whether what is armed right now came back from a previous page load rather than being armed by hand.
+ * The panel's armed bar says so, because mocks nobody remembers arming look exactly like a broken API.
+ */
+const queryDevtoolsArmedMocksRestored = /* @__PURE__ */ armedRestored.asReadonly();
+/**
+ * The identity of a designed mock: one per client, method, route **and** declared query. The query is part
+ * of it so `/posts?page=1` and `/posts?page=2` can hold different bodies.
+ */
+const queryDevtoolsMockId = (parts) => `${parts.clientName}|${parts.method}|${parts.pattern}${parts.query ? `?${parts.query}` : ''}`;
+const write = () => {
+    if (scope() === 'none') {
+        clearQueryDevtoolsStore(STORAGE_KEY);
+        return;
+    }
+    writeQueryDevtoolsStore(scope(), STORAGE_KEY, mocks());
+};
+const writeArmed = () => {
+    if (armedScope() === 'none') {
+        clearQueryDevtoolsStore(ARMED_STORAGE_KEY);
+        return;
+    }
+    writeQueryDevtoolsStore(armedScope(), ARMED_STORAGE_KEY, [...armed()]);
+};
+/** Every change made by hand goes through here, so none of them can leave the store or the bar behind. */
+const setArmed = (next) => {
+    armed.set(next);
+    armedRestored.set(false);
+    writeArmed();
+};
+const isMock = (value) => {
+    const mock = value;
+    return (!!mock &&
+        typeof mock.id === 'string' &&
+        typeof mock.clientName === 'string' &&
+        typeof mock.method === 'string' &&
+        typeof mock.pattern === 'string' &&
+        typeof mock.status === 'number');
+};
+/**
+ * Reads the designed library, so a mock can be armed without authoring it again. Called by
+ * `provideQueryDevtools()` after the settings it takes its scope from; nothing else may call it.
+ * @internal
+ */
+const initQueryDevtoolsMocks = () => {
+    const stored = readQueryDevtoolsStore(scope(), STORAGE_KEY);
+    // `query` was added after the first version of the store, so an entry written before it still loads.
+    mocks.set(Array.isArray(stored) ? stored.filter(isMock).map((mock) => ({ ...mock, query: mock.query ?? '' })) : []);
+    const kept = readQueryDevtoolsStore(armedScope(), ARMED_STORAGE_KEY);
+    const library = new Set(mocks().map((mock) => mock.id));
+    // An id the library no longer holds would arm nothing, so it is dropped rather than kept waiting for a
+    // mock that may never be designed again.
+    const inherited = Array.isArray(kept)
+        ? kept.filter((id) => typeof id === 'string' && library.has(id))
+        : [];
+    armed.set(new Set(inherited));
+    armedRestored.set(inherited.length > 0);
+};
+/**
+ * The path of a request URL relative to the client's `baseUrl` (base path included), without its query
+ * string - what a pattern is matched against. A URL outside `baseUrl`, or no `baseUrl` at all, falls
+ * back to the path without its origin.
+ */
+const queryDevtoolsRequestPath = (url, baseUrl) => {
+    const withoutQuery = url.split('?')[0] ?? '';
+    const base = baseUrl?.replace(/\/+$/, '');
+    if (base && withoutQuery.startsWith(base)) {
+        const rest = withoutQuery.slice(base.length);
+        if (!rest)
+            return '/';
+        if (rest.startsWith('/'))
+            return rest;
+    }
+    const schemeEnd = withoutQuery.indexOf('://');
+    if (schemeEnd === -1)
+        return withoutQuery;
+    const pathStart = withoutQuery.indexOf('/', schemeEnd + 3);
+    return pathStart === -1 ? '/' : withoutQuery.slice(pathStart);
+};
+const segmentsOf$1 = (path) => path.split('/').filter(Boolean);
+/** The query string of a request URL, without the `?`. */
+const queryOf = (url) => url.split('?')[1] ?? '';
+/**
+ * Whether a request carries every query parameter a mock declares. Extra parameters are ignored - a mock
+ * says what the request must ask for, not everything it may.
  */
-const setQueryDevtoolsOverridePersistence = (value) => {
-    setQueryDevtoolsOverridesScope(value ? lastPersistentScope : 'none');
+const matchesQueryDevtoolsMockQuery = (declared, url) => {
+    if (!declared)
+        return true;
+    const asked = new URLSearchParams(queryOf(url));
+    return [...new URLSearchParams(declared)].every(([key, value]) => asked.getAll(key).includes(value));
 };
 /**
- * Empties the override store in both browser stores and disarms everything a reload brought back,
- * without changing where overrides are kept - the panel's "Reset devtools".
+ * Whether a request path is the route a pattern describes. A `:param` segment matches any single
+ * non-empty segment, which is the whole point: a mock is armed for a route, not for the one URL a query
+ * happened to build.
  */
-const clearQueryDevtoolsOverrideStore = () => {
-    clearRestoredQueryDevtoolsOverrides();
-    ops = {};
-    clearQueryDevtoolsStore(STORAGE_KEY);
+const matchesQueryDevtoolsMockPattern = (pattern, path) => {
+    const patternSegments = segmentsOf$1(pattern);
+    const pathSegments = segmentsOf$1(path);
+    if (patternSegments.length !== pathSegments.length)
+        return false;
+    return patternSegments.every((segment, index) => segment.startsWith(':') || segment === pathSegments[index]);
 };
 /**
- * The ops this page load inherited from the previous one, and for each id whether a live query has taken
- * it. Overrides that outlive the page that armed them have to announce themselves, because an app being
- * lied to looks exactly like an app that is broken.
- */
-const restoredQueryDevtoolsOverrides = 
-/* @__PURE__ */ restored.asReadonly();
-/**
- * The scope those ops came back from, or `null` when this page inherited none. `local` is the one worth
- * naming in the banner: it means they outlived closing the tab, not just a reload.
+ * Adds a designed mock, or replaces the one already under its id. Arming is untouched: re-designing a
+ * body while it is being served changes what the next request gets.
  */
-const queryDevtoolsRestoredOverridesScope = 
-/* @__PURE__ */ restoredScope.asReadonly();
-/** Disarms every op this page load inherited and empties the store - the banner's one-click way out. */
-const clearRestoredQueryDevtoolsOverrides = () => {
-    for (const id of replayed) {
-        armedRecorders.get(id)?.clearAll();
-        armedRecorders.delete(id);
-    }
-    for (const id of carriedOver.keys())
-        writeOps(id, []);
-    forgetCarriedOver();
+const saveQueryDevtoolsMock = (mock) => {
+    mocks.update((current) => {
+        const index = current.findIndex((entry) => entry.id === mock.id);
+        if (index === -1)
+            return [...current, mock];
+        return current.map((entry) => (entry.id === mock.id ? mock : entry));
+    });
+    write();
+};
+/** Removes a designed mock, disarming it on the way out. */
+const deleteQueryDevtoolsMock = (id) => {
+    mocks.update((current) => current.filter((entry) => entry.id !== id));
+    armQueryDevtoolsMock(id, false);
+    write();
+};
+/** Starts or stops serving one designed mock. Arming a mock that is not in the library does nothing. */
+const armQueryDevtoolsMock = (id, isArmed) => {
+    if (isArmed && !mocks().some((mock) => mock.id === id))
+        return;
+    const next = new Set(armed());
+    if (isArmed)
+        next.add(id);
+    else
+        next.delete(id);
+    setArmed(next);
 };
+/** Starts serving every mock in the library - the counterpart of {@link clearQueryDevtoolsArmedMocks}. */
+const armAllQueryDevtoolsMocks = () => setArmed(new Set(mocks().map((mock) => mock.id)));
+/** Stops serving every mock, leaving the library alone - the armed bar's one-click way out. */
+const clearQueryDevtoolsArmedMocks = () => setArmed(new Set());
 /**
- * Forgets a destroyed query's recorder. Ops already persisted stay in the store on purpose - they are
- * keyed by an id the next page load re-derives, which is what "Keep across reloads" replays them from.
- * @internal
+ * Where the armed set is kept. Switching to a scope that keeps it stores whatever is armed right now, so
+ * the choice reads as "keep these"; switching to `none` empties the store and leaves this page serving
+ * exactly what it was already serving.
  */
-const releaseQueryDevtoolsOverridePersistence = (id) => {
-    armedRecorders.delete(id);
-    if (scope() !== 'none')
+const setQueryDevtoolsArmedMocksScope = (next) => {
+    if (next === armedScope())
         return;
-    const { [id]: _dropped, ...rest } = ops;
-    ops = rest;
+    // Off both stores first: whichever the previous scope was, its copy must not outlive the change.
+    clearQueryDevtoolsStore(ARMED_STORAGE_KEY);
+    setQueryDevtoolsSettings({ armedMocks: next });
+    writeArmed();
 };
+/** Empties the designed library and disarms everything - the panel's "Reset devtools". */
+const clearQueryDevtoolsMockStore = () => {
+    mocks.set([]);
+    armed.set(new Set());
+    armedRestored.set(false);
+    clearQueryDevtoolsStore(STORAGE_KEY);
+    clearQueryDevtoolsStore(ARMED_STORAGE_KEY);
+};
+const declaredParamCount = (mock) => (mock.query ? [...new URLSearchParams(mock.query)].length : 0);
 /**
- * Wraps a query's overrides recorder so its armed ops are stored and replayed. Replay happens here, at
- * registration, rather than in the panel - a query can run long before the panel is ever opened.
+ * The mock to serve one upcoming attempt, or `null` to let it reach the network. The armed mock declaring
+ * the most query parameters wins, so a special case armed on top of a general one is what answers.
  *
- * Ids are reload-deterministic (descriptor + per-descriptor counter), so the same queries created in the
- * same order re-arm correctly; an id the store holds that nobody claims is reported by
- * {@link restoredQueryDevtoolsOverrides} rather than guessed at.
+ * Installed as the mock resolver by `provideQueryDevtools()`; nothing else may call it.
  * @internal
  */
-const withQueryDevtoolsOverridePersistence = (id, recorder) => {
-    const inherited = ops[id];
-    if (scope() !== 'none' && inherited?.length) {
-        for (const op of inherited)
-            recorder.arm(op);
-        armedRecorders.set(id, recorder);
-        replayed.add(id);
-        publishRestored();
-    }
-    const sync = () => {
-        const list = recorder.list().map((entry) => entry.op);
-        if (list.length)
-            armedRecorders.set(id, recorder);
-        else
-            armedRecorders.delete(id);
-        if (scope() !== 'none')
-            writeOps(id, list);
-    };
-    return {
-        ...recorder,
-        arm: (op) => {
-            recorder.arm(op);
-            sync();
-        },
-        clear: (opId) => {
-            recorder.clear(opId);
-            sync();
-        },
-        clearAll: () => {
-            recorder.clearAll();
-            if (replayed.delete(id))
-                publishRestored();
-            sync();
-        },
-    };
+const resolveQueryDevtoolsMockForAttempt = (target) => {
+    const ids = armed();
+    if (!ids.size)
+        return null;
+    const path = queryDevtoolsRequestPath(target.url, target.baseUrl);
+    const mock = mocks()
+        .filter((candidate) => ids.has(candidate.id) &&
+        candidate.clientName === target.clientName &&
+        candidate.method === target.method &&
+        matchesQueryDevtoolsMockPattern(candidate.pattern, path) &&
+        matchesQueryDevtoolsMockQuery(candidate.query, target.url))
+        // The most specific armed mock answers: one that names `page=2` beats one that takes any query, so
+        // arming a general mock does not shadow the special case someone armed on top of it.
+        .sort((a, b) => declaredParamCount(b) - declaredParamCount(a))[0];
+    if (!mock)
+        return null;
+    return { status: mock.status, body: mock.body, latencyMs: mock.latencyMs };
 };
 
-// Generated from package.json by tools/scripts/generate-version.js - do not edit.
-/** The version of `@ethlete/query` this build was cut from. */
-const QUERY_VERSION = '6.0.0-next.54';
-
 /** How deep a schema is expanded before a nested branch is given up on. */
 const MAX_DEPTH = 12;
 /** How many elements are generated for an array, whatever its `minItems` says. */
@@ -11202,9 +11807,7 @@ const stringSample = (node, schema, ctx) => {
     if (ctx.style === 'stress')
         return fitLength(generateQueryDevtoolsStringPreset(pickStressStringPreset()), schema);
     const title = schema['title'];
-    if (typeof title === 'string' && title)
-        return title;
-    return node.key ?? 'string';
+    return fitLength(typeof title === 'string' && title ? title : (node.key ?? 'string'), schema);
 };
 const boundsOf = (schema) => {
     const exclusiveMin = finiteNumber(schema['exclusiveMinimum']);
@@ -11224,9 +11827,9 @@ const clampToBounds = (value, bounds) => {
 const numberSample = (schema, ctx) => {
     const bounds = boundsOf(schema);
     if (ctx.style === 'placeholder')
-        return bounds.min ?? 0;
+        return clampToBounds(bounds.min ?? 0, bounds);
     if (ctx.style === 'realistic') {
-        return generateQueryDevtoolsSampleNumber({ ...bounds, fractional: typeOf(schema) === 'number' });
+        return clampToBounds(generateQueryDevtoolsSampleNumber({ ...bounds, fractional: typeOf(schema) === 'number' }), bounds);
     }
     const allowsNegative = bounds.min === null || bounds.min < 0;
     return clampToBounds(generateQueryDevtoolsNumberPreset(allowsNegative && Math.random() < 0.5 ? 'negative' : 'huge'), bounds);
@@ -11667,7 +12270,8 @@ const queryDevtoolsResponseHistory = () => queryDevtoolsSettings().responseHisto
  * @internal
  */
 const setQueryDevtoolsResponseHistory = (count) => {
-    providedResponseHistory = count === undefined ? DEFAULT_RESPONSE_HISTORY : Math.max(1, Math.floor(count));
+    providedResponseHistory =
+        count === undefined || Number.isNaN(count) ? DEFAULT_RESPONSE_HISTORY : Math.max(1, Math.floor(count));
 };
 /** The index of the newest run still in flight, or -1 when none is. */
 const lastPendingRunIndex = (runs) => {
@@ -12301,6 +12905,14 @@ const warnAboutIgnoredOptions = (options) => {
         return;
     console.warn(`provideQueryDevtools() ran before on this page, so ${ignored.join(', ')} of this call ${ignored.length === 1 ? 'is' : 'are'} ignored. The devtools read these options once, from the first call. Declare them there.`);
 };
+/**
+ * Undoes the latch `provideQueryDevtools()` sets, so a later spec in the same worker sees the devtools
+ * disabled again. For specs only.
+ */
+const ɵresetQueryDevtoolsForTesting = () => {
+    queryDevtoolsInitialized = false;
+    setQueryDevtoolsRegistrar(null);
+};
 /**
  * Enables the `@ethlete/query` devtools. Add this to your application providers (e.g. in
  * `bootstrapApplication`) to make query clients, queries, stacks, sequences and auth providers
@@ -12353,7 +12965,7 @@ const provideQueryDevtools = (options) => {
     return makeEnvironmentProviders([settleThePillsOnFirstRender()]);
 };
 
-const getOpName = /\b(?:query|mutation)\s+([\w-]+)(?:\s*\([^)]*\))?\s*\{/;
+const getOpName = /\b(?:query|mutation)\s+([\w-]+)(?:\s*\([^)]*\))?(?:\s*@\w+(?:\s*\([^)]*\))?)*\s*\{/;
 const STRING_LITERAL = '"""[\\s\\S]*?"""|"(?:[^"\\\\\\n]|\\\\.)*"';
 const commentOutsideString = /* @__PURE__ */ new RegExp(`(${STRING_LITERAL})|#[^\\n\\r]*`, 'g');
 const whitespaceOutsideString = /* @__PURE__ */ new RegExp(`(${STRING_LITERAL})|\\s+`, 'g');
@@ -12361,6 +12973,19 @@ const minifyGql = (document) => document
     .replace(commentOutsideString, (_match, literal) => literal ?? '')
     .replace(whitespaceOutsideString, (_match, literal) => literal ?? ' ')
     .trim();
+/** Blanks everything inside braces, so a field named `query` or `mutation` cannot pass for an operation. */
+const topLevelOnly = (document) => {
+    let depth = 0;
+    let result = '';
+    for (const char of document) {
+        if (char === '}')
+            depth = Math.max(depth - 1, 0);
+        result += depth === 0 ? char : ' ';
+        if (char === '{')
+            depth++;
+    }
+    return result;
+};
 /**
  * Builds the GraphQL-over-HTTP payload of a document. `variables` comes back as a JSON string for
  * the `GET` transport (the default), where the payload travels as query parameters, and as the map
@@ -12368,12 +12993,12 @@ const minifyGql = (document) => document
  */
 const transformGql = (str) => {
     const normalizedStr = Array.isArray(str) ? str.join('') : str;
-    const operationName = getOpName.exec(normalizedStr.replace(commentOutsideString, (_match, literal) => (literal ? '""' : '')))?.[1];
+    const operationName = getOpName.exec(topLevelOnly(normalizedStr.replace(commentOutsideString, (_match, literal) => (literal ? '""' : ''))))?.[1];
     let minified;
     return (variables, transport = 'GET') => {
         const data = { query: isDevMode() ? normalizedStr : (minified ??= minifyGql(normalizedStr)) };
         if (variables) {
-            data['variables'] = transport === 'GET' ? JSON.stringify(variables) : variables;
+            data['variables'] = transport === 'GET' ? JSON.stringify(sortQueryParamKeys(variables)) : variables;
         }
         if (operationName) {
             data['operationName'] = operationName;
@@ -12399,7 +13024,8 @@ const gqlTransformerFor = (creatorInternals) => {
 };
 const gql = (strings, ...values) => {
     const str = strings.reduce((acc, cur, i) => {
-        return acc + cur + (values[i] ?? '');
+        const value = values[i];
+        return acc + cur + (value === false || value === null || value === undefined ? '' : value);
     }, '');
     return str;
 };
@@ -12409,9 +13035,11 @@ const createGqlExecuteFn = (executeOptions) => {
     const executeState = setupQueryExecuteState();
     const circularChecker = circularQueryDependencyChecker();
     const aborter = createQueryExecutionAborter(executeOptions.state);
-    const reset = () => resetExecuteState({ executeState, executeOptions });
-    const exec = (executeArgs) => {
+    const reset = () => untracked(() => resetExecuteState({ executeState, executeOptions }));
+    const exec = (executeArgs) => untracked(() => {
         const { args = executeOptions.state.args(), options } = executeArgs ?? {};
+        if (skipParkedExecution(executeOptions.state, args, executeOptions.creator?.route))
+            return false;
         circularChecker.check(args);
         let gqlParams = gqlTransformerFor(executeOptions.creatorInternals)(args?.variables, executeOptions.creatorInternals.transport);
         if (args?.queryParams && executeOptions.creatorInternals.transport === 'GET') {
@@ -12451,7 +13079,8 @@ const createGqlExecuteFn = (executeOptions) => {
             options,
             isRefreshable: executeOptions.creatorInternals.method === 'QUERY',
         });
-    };
+        return true;
+    });
     exec['reset'] = reset;
     exec['abort'] = () => aborter.abort();
     exec['aborted$'] = aborter.aborted$;
@@ -12501,6 +13130,7 @@ const createSecureGqlExecuteFn = (executeOptions) => {
         authProvider,
         deps: executeOptions.deps,
         state: executeOptions.state,
+        route: executeOptions.creator?.route,
         autoExecutes: shouldAutoExecuteGqlQuery(executeOptions.creatorInternals.method) &&
             !executeOptions.queryConfig.onlyManualExecution,
         transformAuthAndExec: (executeArgs, executeState) => {
@@ -12666,7 +13296,7 @@ const v2ExtractExpiresInSeconds = (headers) => {
     // In seconds
     let expiresIn = null;
     let maxAge = null;
-    if (cacheControl?.includes('no-cache')) {
+    if (cacheControl?.includes('no-cache') || cacheControl?.includes('no-store')) {
         return null;
     }
     if (cacheControl?.includes('max-age')) {
@@ -12681,11 +13311,11 @@ const v2ExtractExpiresInSeconds = (headers) => {
             maxAge = parseInt(m);
         }
     }
-    if (maxAge && age) {
+    if (maxAge !== null && age) {
         const ageSeconds = parseInt(age);
         expiresIn = maxAge - ageSeconds;
     }
-    else if (maxAge) {
+    else if (maxAge !== null) {
         expiresIn = maxAge / 2; // We assume the response is half way to its expiration
     }
     else if (expires) {
@@ -12711,6 +13341,9 @@ const serializeBody = (body) => {
     if (body === null || body === undefined) {
         return null;
     }
+    if (ArrayBuffer.isView(body)) {
+        return body;
+    }
     if (body instanceof ArrayBuffer ||
         body instanceof Blob ||
         body instanceof FormData ||
@@ -12754,9 +13387,12 @@ const detectContentTypeHeader = (body) => {
         return body.type || null;
     }
     // Array buffers have unknown contents and thus no type can be inferred.
-    if (body instanceof ArrayBuffer) {
+    if (body instanceof ArrayBuffer || ArrayBuffer.isView(body)) {
         return null;
     }
+    if (body instanceof URLSearchParams) {
+        return 'application/x-www-form-urlencoded;charset=UTF-8';
+    }
     // Technically, strings could be a form of JSON data, but it's safe enough
     // to assume they're plain strings.
     if (typeof body === 'string') {
@@ -12866,9 +13502,9 @@ const request = (config) => {
     const body = config.body ?? null;
     const url = config.urlWithParams.split('?')[0] || '';
     const retryFn = config.retryFn || v2ShouldRetryRequest;
-    let currentRetryCount = 0;
-    let retryTimeout = null;
     return new Observable((observer) => {
+        let currentRetryCount = 0;
+        let retryTimeout = null;
         const xhr = new XMLHttpRequest();
         const reqBody = serializeBody(body);
         const setupXhr = () => {
@@ -13932,6 +14568,10 @@ class LegacyQuery {
         // NG0205 ("Injector has already been destroyed") from inside the view's cleanup phase.
         this.newQuery.subtle.destroyRef.onDestroy(() => this.teardown());
     }
+    /** The full URL of the request the underlying query is bound to, `null` before the first execution. */
+    get url() {
+        return this.newQuery.url();
+    }
     get rawState() {
         return this.toQueryState(this.newQuery.executionState());
     }
@@ -14190,9 +14830,10 @@ const createInertQuery = () => {
         ...base,
         execute: noop,
         createSnapshot,
+        url: inertSignal(null),
         reset: noop,
         abort: () => false,
-        asReadonly: () => ({ ...base, createSnapshot }),
+        asReadonly: () => ({ ...base, createSnapshot, url: inertSignal(null) }),
         subtle: {
             destroy: noop,
             setResponse: noop,
@@ -15871,7 +16512,8 @@ class QueryDirective {
         this.queryState = queryStateSignal(this.query);
         inject(ViewContainerRef).createEmbeddedView(inject(TemplateRef), this.viewContext);
         effect(() => {
-            const query = extractQuery(this.query());
+            const rawQuery = this.query();
+            const query = extractQuery(rawQuery);
             untracked(() => {
                 if (!query) {
                     this.viewContext.$implicit = null;
@@ -15887,7 +16529,7 @@ class QueryDirective {
                 if (isQueryStatePrepared(query.rawState) || isQueryStateCancelled(query.rawState)) {
                     query.execute();
                 }
-                this.viewContext.scope = isQueryCollection(query) ? query.type : null;
+                this.viewContext.scope = isQueryCollection(rawQuery) ? rawQuery.type : null;
                 this.viewContext.query = query;
             });
         });
@@ -16957,13 +17599,13 @@ const transformToStringArray = (value) => {
 };
 const transformToNumber = (value) => {
     if (typeof value === 'number') {
-        return value;
+        return Number.isFinite(value) ? value : null;
     }
     if (typeof value === 'string') {
         if (!value.trim())
             return null;
         const number = Number(value);
-        return Number.isNaN(number) ? null : number;
+        return Number.isFinite(number) ? number : null;
     }
     return null;
 };
@@ -16999,7 +17641,7 @@ const transformToBooleanArray = (value) => {
 const DATE_ONLY_PATTERN = /^(\d{4})-(\d{2})-(\d{2})$/;
 const transformToDate = (value) => {
     if (value instanceof Date) {
-        return value;
+        return Number.isNaN(value.getTime()) ? null : value;
     }
     if (typeof value === 'string') {
         const date = new Date(value);
@@ -17026,7 +17668,9 @@ const transformToDateArray = (value) => {
 };
 const transformToSort = (value) => {
     if (typeof value === 'string') {
-        const [active, direction] = value.split(':');
+        const separator = value.lastIndexOf(':');
+        const active = separator === -1 ? value : value.slice(0, separator);
+        const direction = separator === -1 ? '' : value.slice(separator + 1);
         if (!active) {
             return null;
         }
@@ -17729,6 +18373,8 @@ const MAX_RESET_PASSES = 10;
 const changedKeysBetween = (previous, current) => Object.keys(current).filter((key) => !equal(previous?.[key], current[key]));
 /** Reads a URL string into the type of the field's default; `null` means the default's type cannot hold it. */
 const autoCoerce = (raw, defaultValue) => {
+    if (Array.isArray(raw))
+        return Array.isArray(defaultValue) ? raw : null;
     if (typeof raw !== 'string')
         return raw;
     if (Array.isArray(defaultValue))
@@ -17756,10 +18402,13 @@ const resolveDebounce = (fieldDefs, changedKeys, live) => {
     }
     return Math.min(...times);
 };
+const isUnserializable = (value) => value === undefined ||
+    (typeof value === 'number' && Number.isNaN(value)) ||
+    (value instanceof Date && Number.isNaN(value.getTime()));
 /**
  * A value that cannot be told apart from the default once serialized - a cleared text (`''`), an emptied list
- * (`[]`) or one whose `valueToQueryParam` yields nothing - commits as the default, so the URL reproduces the
- * committed state and the filter count does not report it.
+ * (`[]`), `undefined`, `NaN`, an invalid `Date` or one whose `valueToQueryParam` yields nothing - commits as the
+ * default, so the URL reproduces the committed state and the filter count does not report it.
  */
 const normalizeLive = (fieldDefs, rawLive, defaults) => {
     const live = { ...rawLive };
@@ -17770,7 +18419,7 @@ const normalizeLive = (fieldDefs, rawLive, defaults) => {
         const serialized = def.valueToQueryParam?.(value);
         const serializedToNothing = !!def.valueToQueryParam && (serialized === null || serialized === undefined);
         const clearedNullable = defaults[key] === null && (value === '' || (Array.isArray(value) && value.length === 0));
-        if (serializedToNothing || clearedNullable) {
+        if (serializedToNothing || clearedNullable || isUnserializable(value)) {
             live[key] = defaults[key];
         }
     }
@@ -17878,9 +18527,12 @@ const createBranch = (fields, initial, injector) => {
     ...(ngDevMode ? [{ debugName: "committed" }] : /* istanbul ignore next */ []));
     const tree = form(model, { injector });
     let pendingTimer = null;
+    const defaultsRevision = signal(0, /* @ts-ignore */
+    ...(ngDevMode ? [{ debugName: "defaultsRevision" }] : /* istanbul ignore next */ []));
     const defaultFor = (key) => {
         const value = resolveDefault(fields[key]);
         defaults[key] = value;
+        defaultsRevision.update((revision) => revision + 1);
         return value;
     };
     const normalizedLive = computed(() => normalizeLive(fields, model(), defaults), /* @ts-ignore */
@@ -17929,7 +18581,10 @@ const createBranch = (fields, initial, injector) => {
         fields: tree,
         value: committed.asReadonly(),
         liveValue: model.asReadonly(),
-        activeFilterCount: computed(() => computeFilterCount(fields, committed(), defaults)),
+        activeFilterCount: computed(() => {
+            defaultsRevision();
+            return computeFilterCount(fields, committed(), defaults);
+        }),
         setValue: (value, options) => write(clone(value), options),
         patchValue: (value, options) => write({ ...model(), ...value }, options),
         resetFieldToDefault: (key, options) => write({ ...model(), [key]: defaultFor(key) }, options),
@@ -17975,9 +18630,12 @@ const defineQueryForm = (config) => {
     const prefix = config.queryParamPrefix;
     const defaults = buildDefaults(fieldDefs);
     const defaultValue = clone(defaults);
+    const defaultsRevision = signal(0, /* @ts-ignore */
+    ...(ngDevMode ? [{ debugName: "defaultsRevision" }] : /* istanbul ignore next */ []));
     const defaultFor = (key) => {
         const value = resolveDefault(fieldDefs[key]);
         defaults[key] = value;
+        defaultsRevision.update((revision) => revision + 1);
         defaultValue[key] = clone(value);
         return value;
     };
@@ -18002,7 +18660,10 @@ const defineQueryForm = (config) => {
     const urlNavigationMarker = {};
     const pathOf = (tree) => router.serializeUrl(tree).split(/[?#]/)[0];
     const fields = form(model);
-    const activeFilterCount = computed(() => computeFilterCount(fieldDefs, committed(), defaults), /* @ts-ignore */
+    const activeFilterCount = computed(() => {
+        defaultsRevision();
+        return computeFilterCount(fieldDefs, committed(), defaults);
+    }, /* @ts-ignore */
     ...(ngDevMode ? [{ debugName: "activeFilterCount" }] : /* istanbul ignore next */ []));
     const paramKey = (key) => {
         if (!prefix)
@@ -18261,6 +18922,13 @@ const defineQueryForm = (config) => {
             }
             observeOptions = options;
             observing.set(true);
+            if (isDevMode()) {
+                for (const key of options?.persistence?.fields ?? []) {
+                    if (!(key in fieldDefs)) {
+                        console.warn(`defineQueryForm: persistence.fields references unknown field "${key}". Is it a typo?`);
+                    }
+                }
+            }
             changesSeenAtObserve = untracked(queryParamChanges);
             if (options?.persistence) {
                 restoreFromStorage(options.persistence, route.snapshot.queryParams);
@@ -18387,6 +19055,11 @@ const normalizeConfig = (config) => {
         isResetBy: isResetBy === undefined ? undefined : Array.isArray(isResetBy) ? isResetBy : [isResetBy],
     };
 };
+const dateToQueryParam = (value) => {
+    if (value === null)
+        return ET_NULL_VALUE;
+    return value instanceof Date && !Number.isNaN(value.getTime()) ? value.toISOString() : value;
+};
 function queryField(config) {
     return {
         defaultValue: null,
@@ -18463,6 +19136,7 @@ function dateQueryField(config) {
     return {
         defaultValue: null,
         queryParamToValue: transformToDate,
+        valueToQueryParam: dateToQueryParam,
         ...normalizeConfig(rest),
     };
 }
@@ -18470,6 +19144,11 @@ function dateQueryField(config) {
 const dateArrayQueryField = (config) => ({
     defaultValue: null,
     queryParamToValue: transformToDateArray,
+    valueToQueryParam: (value) => {
+        if (value === null)
+            return ET_NULL_VALUE;
+        return value.length ? value.map(dateToQueryParam) : ET_EMPTY_ARRAY_VALUE;
+    },
     ...normalizeConfig(config),
 });
 
@@ -18478,6 +19157,7 @@ const WebSocketRuntimeErrorCode = {
     // Web Socket Client
     ROOM_NOT_JOINED: 1000,
     MESSAGE_MALFORMED: 1001,
+    AUTH_AND_AUTH_PROVIDER: 1002,
 };
 const roomNotJoined = (room) => {
     return new RuntimeError(WebSocketRuntimeErrorCode.ROOM_NOT_JOINED, `Tried leaving the room "${room}" but it has not been joined.`);
@@ -18485,6 +19165,9 @@ const roomNotJoined = (room) => {
 const messageMalformed = () => {
     return new RuntimeError(WebSocketRuntimeErrorCode.MESSAGE_MALFORMED, 'A message has been received but it is malformed. Expected a JSON string shaped like { room: string; event: string; data: unknown }.');
 };
+const authAndAuthProvider = (name) => {
+    return new RuntimeError(WebSocketRuntimeErrorCode.AUTH_AND_AUTH_PROVIDER, `The web socket client "${name}" sets both \`auth\` and \`authProvider\`. \`authProvider\` sends the access token itself, so \`auth\` is ignored. Remove one of them.`);
+};
 
 const MAX_DEVTOOLS_MESSAGES = 100;
 const RECONNECT_BASE_DELAY = 1000;
@@ -18494,7 +19177,10 @@ const createWebSocketClient = (options) => {
     return defineRootProvider(() => {
         if (isPlatformServer(inject(PLATFORM_ID)))
             return createServerWebSocketClient();
-        const auth = options.auth;
+        if (options.auth && options.authProvider && isDevMode())
+            throw authAndAuthProvider(options.name);
+        const authProvider = options.authProvider?.inject();
+        const auth = authProvider ? () => ({ token: authProvider.accessToken() }) : options.auth;
         const socket = options.io(options.url, {
             withCredentials: options.withCredentials ?? true,
             autoConnect: false,
@@ -18502,6 +19188,7 @@ const createWebSocketClient = (options) => {
             auth: auth ? (cb) => cb(typeof auth === 'function' ? auth() : auth) : undefined,
         });
         const rooms = new Map();
+        const holds = new Set();
         const joinsDeliveredThisConnection = new Set();
         const joinsDeliveredToClosedConnection = new Set();
         const isConnected = signal(false, /* @ts-ignore */
@@ -18532,66 +19219,66 @@ const createWebSocketClient = (options) => {
                 direction: 'out',
             });
         };
-        const joinRoom = (room) => {
-            const roomFn = typeof room === 'function' ? room : () => room;
-            // Must stay above the effect below: `previousSignalValue` registers a `toObservable` effect that has to run
-            // first in the same flush. Registered later, it leaves `pre()` on the room from the flush before, and the
-            // effect joins the new room without ever leaving the old one.
-            const pre = previousSignalValue(computed(() => roomFn()));
-            const roomData = signal(null, /* @ts-ignore */
-            ...(ngDevMode ? [{ debugName: "roomData" }] : /* istanbul ignore next */ []));
-            let joinedRoomName = null;
-            const join = (name) => {
-                const existingRoom = rooms.get(name);
-                if (existingRoom) {
-                    existingRoom.joinCount++;
-                    return existingRoom;
-                }
-                emit({ event: 'join-room', data: name, room: name });
-                joinsDeliveredToClosedConnection.delete(name);
-                const messages = new Subject();
-                const newRoom = {
-                    latestMessage: signal(null),
-                    messages,
-                    messages$: messages.asObservable(),
-                    joinCount: 1,
-                };
-                rooms.set(name, newRoom);
-                syncDevtoolsRooms();
-                return newRoom;
+        const join = (name) => {
+            const existingRoom = rooms.get(name);
+            if (existingRoom) {
+                existingRoom.joinCount++;
+                return existingRoom;
+            }
+            emit({ event: 'join-room', data: name, room: name });
+            joinsDeliveredToClosedConnection.delete(name);
+            const messages = new Subject();
+            const newRoom = {
+                latestMessage: signal(null),
+                messages,
+                messages$: messages.asObservable(),
+                joinCount: 1,
             };
-            effect(() => {
-                const current = roomFn();
-                untracked(() => {
-                    const previous = pre();
-                    if (previous === current)
-                        return;
-                    if (previous) {
-                        leaveRoom(previous);
-                        joinedRoomName = null;
-                    }
-                    if (current) {
-                        const joinedRoom = join(current);
-                        if (joinedRoom) {
-                            joinedRoomName = current;
-                            roomData.set(joinedRoom);
-                        }
-                    }
-                    else {
-                        roomData.set(null);
-                    }
-                });
-            });
+            rooms.set(name, newRoom);
+            syncDevtoolsRooms();
+            return newRoom;
+        };
+        const holdRoom = (hold, name) => {
+            if (name === hold.name)
+                return;
+            if (hold.name !== null && !hold.parked)
+                leaveRoom(hold.name);
+            hold.name = name;
+            if (name === null)
+                hold.parked = false;
+            if (hold.parked)
+                return;
+            hold.room.set(name === null ? null : join(name));
+        };
+        const createHold = () => {
+            const hold = { name: null, parked: false, room: signal(null) };
+            holds.add(hold);
             inject(DestroyRef).onDestroy(() => {
-                if (joinedRoomName) {
-                    leaveRoom(joinedRoomName);
-                    joinedRoomName = null;
-                    roomData.set(null);
-                }
+                holdRoom(hold, null);
+                holds.delete(hold);
             });
-            return roomData.asReadonly();
+            return hold;
+        };
+        const joinRoom = (room) => {
+            const hold = createHold();
+            if (typeof room === 'string') {
+                holdRoom(hold, room);
+            }
+            else {
+                effect(() => {
+                    const current = room() || null;
+                    untracked(() => holdRoom(hold, current));
+                });
+            }
+            return hold.room.asReadonly();
         };
         const leaveRoom = (room) => {
+            const parkedHold = [...holds].find((hold) => hold.parked && hold.name === room);
+            if (parkedHold) {
+                parkedHold.name = null;
+                parkedHold.parked = false;
+                return;
+            }
             const joinedRoom = rooms.get(room);
             if (!joinedRoom) {
                 if (isDevMode())
@@ -18704,7 +19391,90 @@ const createWebSocketClient = (options) => {
         });
         setupWebSocketConnectionListener();
         setupWebSocketListener();
-        socket.connect();
+        const dropBufferedEmits = () => {
+            if (socket.sendBuffer)
+                socket.sendBuffer.length = 0;
+        };
+        const endSession = () => {
+            if (reconnectTimer !== null) {
+                clearTimeout(reconnectTimer);
+                reconnectTimer = null;
+            }
+            dropBufferedEmits();
+            socket.disconnect();
+            for (const hold of holds) {
+                if (hold.name === null || hold.parked)
+                    continue;
+                hold.parked = true;
+                hold.room.set(null);
+            }
+            for (const room of rooms.values())
+                room.messages.complete();
+            rooms.clear();
+            joinsDeliveredThisConnection.clear();
+            joinsDeliveredToClosedConnection.clear();
+            syncDevtoolsRooms();
+        };
+        const rejoinParkedRooms = () => {
+            for (const hold of holds) {
+                if (!hold.parked || hold.name === null)
+                    continue;
+                hold.parked = false;
+                hold.room.set(join(hold.name));
+            }
+        };
+        const startConnection = () => {
+            reconnectAttempt = 0;
+            socket.connect();
+        };
+        if (authProvider) {
+            let hasConnected = false;
+            let wasAuthenticated = false;
+            let handledLogin = null;
+            let handledSessionId = null;
+            effect(() => {
+                const status = authProvider.sessionStatus();
+                const execution = authProvider.executionState();
+                const sessionId = authProvider.sessionId();
+                untracked(() => {
+                    if (destroyed || status === 'unknown' || status === 'restoring')
+                        return;
+                    if (status === 'anonymous') {
+                        if (wasAuthenticated) {
+                            endSession();
+                            startConnection();
+                        }
+                        else if (!hasConnected) {
+                            startConnection();
+                        }
+                        wasAuthenticated = false;
+                        hasConnected = true;
+                        return;
+                    }
+                    const login = (execution?.type === 'login' || execution?.type === 'tokenSeed') && execution.state === 'success'
+                        ? execution
+                        : null;
+                    const startedSession = !wasAuthenticated || sessionId !== handledSessionId || (login !== null && login !== handledLogin);
+                    if (login)
+                        handledLogin = login;
+                    handledSessionId = sessionId;
+                    wasAuthenticated = true;
+                    if (!hasConnected) {
+                        startConnection();
+                    }
+                    else if (startedSession) {
+                        dropBufferedEmits();
+                        socket.disconnect();
+                        rejoinParkedRooms();
+                        startConnection();
+                    }
+                    hasConnected = true;
+                });
+            });
+        }
+        else {
+            socket.connect();
+        }
         const client = {
             joinRoom,
             isConnected: isConnected.asReadonly(),
@@ -18751,5 +19521,5 @@ const createServerWebSocketClient = () => {
  * Generated bundle index. Do not edit.
  */
 
-export { AuthBearerRefreshStrategy, BasicAuthProvider, BearerAuthFeatureType, BooleanArrayQueryField, CustomHeaderAuthProvider, DEFAULT_KEEP_UNUSED_FOR, DEFAULT_QUERY_PERSISTENCE_MAX_AGE, DEFAULT_QUERY_PERSISTENCE_MAX_ENTRIES, DEFAULT_QUERY_PERSISTENCE_VERSION, DEFAULT_QUERY_PERSISTENCE_WRITE_DELAY, DateArrayQueryField, DateQueryField, EMPTY_QUERY_DEVTOOLS_FAULT, EntityStore, IGNORED_FILTER_COUNT_FIELDS, INFINITY_QUERY_TOKEN, IS_QUERY_REQUEST, InfinityQuery, InfinityQueryDirective, InfinityQueryTriggerDirective, LegacyQuery, LegacyQueryCreator, MAX_QUERY_BATCH_TOMBSTONES, MAX_QUERY_BATCH_TOMBSTONE_BUCKETS, MAX_QUERY_DEVTOOLS_TOMBSTONES, MAX_UNUSED_ENTRIES, NumberArrayQueryField, ParseHttpErrorCodeToMessageDePipe, ParseHttpErrorCodeToMessageEnPipe, ParseHttpErrorCodeToTitleDePipe, ParseHttpErrorCodeToTitleEnPipe, QUERY_CLIENT_DEVTOOLS_TOKEN, QUERY_DEVTOOLS_FAULT_STATUSES, QUERY_DEVTOOLS_TOKEN_TTL_LIMIT, QUERY_PERSISTENCE_STORE_VERSION, QUERY_SYNC_PROTOCOL_VERSION, QUERY_VERSION, QueryClientFeatureType, QueryDevtoolsComponent, QueryDirective, QueryFeatureType, QueryField, QueryForm, QueryRuntimeErrorCode, QueryShortNamePipe, QueryStateType, QueryStore, SERVER_ERROR_KIND, SERVER_VIOLATION_ERROR_KIND, SPEED_BUFFER_TIME_IN_MS, SearchQueryField, SortQueryField, StringArrayQueryField, V2BearerAuthProvider, V2Query, V2QueryClient, V2QueryCreator, addQueryContainerHandling, addQueryDevtoolsAuthAccount, applyQueryDevtoolsOverrides, applyQueryDevtoolsTokenTtl, applyQueryFeatures, armAllQueryDevtoolsMocks, armQueryDevtoolsMock, armQueryDevtoolsOverrideTransfer, authExtractTokensResponseMissingAccessToken, authExtractTokensResponseMissingRefreshToken, authExtractTokensResponseNotObject, authProviderFeatureUsedMultipleTimes, booleanArrayQueryField, buildQueryCacheKey, buildQueryString, buildRoute, buildTimestampFromSeconds, canOverrideQueryDevtoolsTokenTtl, castQueryCreatorTypes, circularQueryDependency, circularQueryDependencyChecker, clearQueryDevtoolsArmedMocks, clearQueryDevtoolsAuthCredentials, clearQueryDevtoolsAuthSessions, clearQueryDevtoolsFaults, clearQueryDevtoolsMockStore, clearQueryDevtoolsOverrideStore, clearQueryDevtoolsStore, clearQueryDevtoolsTokenTtl, clearQueryDevtoolsTombstones, clearRestoredQueryDevtoolsOverrides, collectLeafPaths, collectQueryDevtoolsSchemaComponents, collectQueryFormLinks, computeQueryAuthHeader, computeQueryBody, computeQueryHeaders, computeQueryMethod, computeQueryQueryParams, consumeSuppressQueryStackDevtools, contentfulGqlLikePaginationAdapter, countUnresolvedQueryDevtoolsOverrides, createAuthGuard, createBaseQuery, createBaseQueryCreator, createBearerAuthProvider, createDefaultRetryFn, createDeleteQuery, createExecuteFn, createGetQuery, createGqlExecuteFn, createGqlMutationViaGet, createGqlMutationViaPost, createGqlQuery, createGqlQueryCreator, createGqlQueryViaGet, createGqlQueryViaPost, createHeadQuery, createHttpRequest, createIndexedDbQueryPersistenceAdapter, createInfinityQueryConfig, createLegacyQueryCreator, createNoopQueryPersistenceAdapter, createOptionsQuery, createPagedQueryStack, createPatchQuery, createPersistentAuthFeature, createPostQuery, createPutQuery, createQuery, createQueryBatch, createQueryClient, createQueryCollection, createQueryCollectionSignal, createQueryCollectionSubject, createQueryContext, createQueryCreator, createQueryDevtoolsFormLinks, createQueryDevtoolsFormLinksRecorder, createQueryDevtoolsOverrides, createQueryDevtoolsOverridesRecorder, createQueryDevtoolsStats, createQueryDevtoolsStatsRecorder, createQueryErrorResponse, createQueryFeature, createQueryInvalidationFilter, createQueryKeyLockManager, createQueryObject, createQueryPersistenceEngine, createQueryRepository, createQuerySnapshotFn, createQueryStack, createQuerySubmission, createQuerySyncEngine, createQuerySyncTransport, createSecureDeleteQuery, createSecureExecuteFactory, createSecureExecuteFn, createSecureGetQuery, createSecureGqlExecuteFn, createSecureGqlMutationViaGet, createSecureGqlMutationViaPost, createSecureGqlQuery, createSecureGqlQueryCreator, createSecureGqlQueryViaGet, createSecureGqlQueryViaPost, createSecureHeadQuery, createSecureOptionsQuery, createSecurePatchQuery, createSecurePostQuery, createSecurePutQuery, createSecureQuery, createSecureQueryCreator, createTrackingFeature, createWebSocketClient, currentQueryDevtoolsBatch, dateArrayQueryField, dateQueryField, decryptBearer, deepFreeze, def, defineQueryForm, deleteQueryDevtoolsMock, describeQueryDevtoolsFeatures, detectContentTypeHeader, detectPaginationShape, dynLikePaginationAdapter, effectComputed, emptyQueryArgs, ethletePaginationAdapter, executeUntilSettled, executeUntilSettled$, extractExpiresInSeconds, extractFormViolations, extractHtmlErrorMessage, extractQuery, fakePaginationAdapter, filterFailure, filterNull, filterQueryStates, filterSuccess, forEachHeader, forgetQueryDevtoolsAuthSession, forgetQueryDevtoolsAuthSessionsFor, formatQueryDevtoolsDuration, generateQueryDevtoolsNumberPreset, generateQueryDevtoolsSampleNumber, generateQueryDevtoolsStringPreset, getBearerAuthProviderName, getDefaultHeaders, getQueryClientName, getQueryFeatureUsage, getResponseUrl, ggLikePaginationAdapter, gql, gqlDataPropertyMissingInResponse, gqlErrorsInResponse, gqlTransformerFor, hasDefaultQueryRetry, hasHeader, hasQueryDevtoolsOverridesAtPath, htmlErrorPayload, htmlQueryErrorParser, ignoreAutoRefresh, initQueryDevtoolsAuthSessions, initQueryDevtoolsFaults, initQueryDevtoolsMocks, initQueryDevtoolsOverridePersistence, initQueryDevtoolsSettings, injectInfinityQueryResponseDelay, injectQueryContext, insertFrom, invalidBaseRouteError, invalidBodyError, invalidRouteError, invalidStateInsideSecureExecuteFactory, isAutoRefresh, isBasicAuthProvider, isBearerAuthProvider, isClassValidatorError, isCreateGqlQueryOptions, isCustomHeaderAuthProvider, isDateShapedLeaf, isEmptyString, isGqlQueryConfig, isHtmlErrorPayload, isIdempotentQueryMethod, isLegacyQuery, isNaN$1 as isNaN, isOverrideOp, isPageOutOfRangeError, isQuery, isQueryCollection, isQueryDevtoolsEnabled, isQueryDevtoolsFaultArmed, isQueryDevtoolsRepositoryLive, isQueryDevtoolsRequestInterceptionEnabled, isQueryErrorResponse, isQueryStateCancelled, isQueryStateFailure, isQueryStateLoading, isQueryStatePrepared, isQueryStateSuccess, isRequestError, isSymfonyError, isSymfonyFormViolationListError, isSymfonyListError, isSymfonyPagerfantaOutOfRangeError, isUnderInvalidatedUrl, legacyPrepareFallbackInjector, legacyPrepareWithoutInjectionContext, loadQueryDevtoolsSchema, loginQueryDevtoolsAuthAccount, logoutQueryDevtoolsAuthSession, mapToPaginated, mapViolationsToFormErrors, matchesQueryDevtoolsMockPattern, matchesQueryDevtoolsMockQuery, maybeExecute, measureQueryDevtoolsPayload, mergeHeaders, nestedEffect, noteQueryFormRead, noteQueryFormReads, numberArrayQueryField, pagedQueryStackNextPageCalledWithoutPreviousPage, pagedQueryStackPageBiggerThanTotalPages, pagedQueryStackPreviousPageCalledButAlreadyAtFirstPage, paginatedEntityValueUpdater, parseAllXhrResponseHeaders, parseHttpErrorCodeToMessageDe, parseHttpErrorCodeToMessageEn, parseHttpErrorCodeToTitleDe, parseHttpErrorCodeToTitleEn, parseQueryDevtoolsOverrideTransfer, parseQueryRoute, patchQueryDevtoolsTokenPayload, pathParamsMissingInRouteFunctionError, provideInfinityQueryResponseDelay, provideLegacyPrepareFallback, provideQueryClientForDevtools, provideQueryDevtools, queryArrayComputed, queryBatchAlreadyRunning, queryBatchWithArgsUsed, queryClientFeatureUsedMultipleTimes, queryComputed, queryComputedTillTruthy, queryCreatedInReactiveContext, queryDevtoolsAbout, queryDevtoolsAllowsLocalAuthSessions, queryDevtoolsApiEnvIds, queryDevtoolsApiEnvIsProduction, queryDevtoolsApiEnvScope, queryDevtoolsApiEnvValues, queryDevtoolsApiEnvs, queryDevtoolsArmedMocks, queryDevtoolsArmedMocksRestored, queryDevtoolsAuthAccountsFor, queryDevtoolsAuthActive, queryDevtoolsAuthFieldsFor, queryDevtoolsAuthOtherScopeCount, queryDevtoolsAuthProviders, queryDevtoolsAuthSessions, queryDevtoolsAuthSessionsFor, queryDevtoolsAuthTabLocal, queryDevtoolsEntries, queryDevtoolsFaults, queryDevtoolsFaultsRestored, queryDevtoolsFnDetail, queryDevtoolsMockId, queryDevtoolsMocks, queryDevtoolsOverridePersistence, queryDevtoolsRequestPath, queryDevtoolsResponseHistory, queryDevtoolsRestoredOverridesScope, queryDevtoolsSchemaNames, queryDevtoolsSchemaRoutes, queryDevtoolsSchemaState, queryDevtoolsSettings, queryDevtoolsStorage, queryDevtoolsTokenTtls, queryErrorMessage, queryErrorMessages, queryExecute, queryExecutedAfterDestroyMessage, queryFeatureUsedMultipleTimes, queryField, querySequence, querySequenceAlreadyRunning, queryStackWithArgsUsed, queryStackWithResponseUpdateUsed, queryStateAlreadyHasKeyError, queryStateCannotTransformError, queryStateDoesNotContainKeyError, queryStateErrorSignal, queryStateLoadingSignal, queryStateResponseSignal, queryStateSignal, readQueryDevtoolsAuthSeed, readQueryDevtoolsAuthSeedFor, readQueryDevtoolsStore, recordExecutionArgs, registerEthleteVersion, registerLiveQueryDevtoolsRepository, registerQueryDevtoolsAuthProvider, registerQueryDevtoolsEntry, registerQueryErrorParser, releaseQueryDevtoolsOverridePersistence, removeFrom, removeQueryDevtoolsAuthAccount, renameQueryDevtoolsAuthSession, request, resetExecuteState, resetPageOnError, resolveInvalidationUrl, resolveQueryDevtoolsFault, resolveQueryDevtoolsFaultForAttempt, resolveQueryDevtoolsMock, resolveQueryDevtoolsMockForAttempt, resolveQueryHeaders, restoredQueryDevtoolsOverrides, runDefaultQueryRetry, runInQueryDevtoolsBatch, runQueryErrorParsers, saveQueryDevtoolsMock, searchQueryField, seedQueryDevtoolsSchemaBody, seedQueryDevtoolsSchemaRoute, serializeBody, serializeQueryDevtoolsOverrideTransfer, setDefaultQueryRetryFn, setQueryDevtoolsApiEnv, setQueryDevtoolsApiEnvs, setQueryDevtoolsAppInfo, setQueryDevtoolsArmedMocksScope, setQueryDevtoolsAuthCredentials, setQueryDevtoolsAuthProviderRegistrar, setQueryDevtoolsAuthSeedReader, setQueryDevtoolsAuthTabLocal, setQueryDevtoolsFault, setQueryDevtoolsFaultResolver, setQueryDevtoolsFaultsScope, setQueryDevtoolsFormLinksFactory, setQueryDevtoolsMockResolver, setQueryDevtoolsOverridePersistence, setQueryDevtoolsOverridesFactory, setQueryDevtoolsOverridesScope, setQueryDevtoolsRegistrar, setQueryDevtoolsResponseHistory, setQueryDevtoolsSchemaLoader, setQueryDevtoolsSettings, setQueryDevtoolsStatsFactory, setQueryDevtoolsTokenPayloadPatcher, setQueryDevtoolsTokenTtl, setQueryDevtoolsUiMounted, setupQueryDependencies, setupQueryExecuteState, setupQueryState, shouldAutoExecuteGqlQuery, shouldAutoExecuteQuery, shouldCacheQuery, shouldRetryRequest, silenceMissingWithArgsFeatureErrorUsedButWithArgsPresent, skipPaginationPageParamCalculator, smartDuplicateArrayItem, snapshotQueryDevtoolsHandle, sortQueryField, splitQueryConfig, stringArrayQueryField, stringifyQueryRouteParts, sumQueryDevtoolsStats, suppressNextQueryStackDevtools, switchQueryCollectionState, switchQueryDevtoolsAuthSession, switchQueryState, symfonyQueryErrorParser, tableSortQueryField, takeUntilResponse, toQuerySignal, toQuerySubject, tokensNotAvailableInsideAuthAndExec, tombstoneOf, trackQueryDevtoolsAuthProvider, transformArrayResponse, transformExecStateToQueryState, transformGql, transformMethod, transformPaginatedResponse, transformToBoolean, transformToBooleanArray, transformToDate, transformToDateArray, transformToNumber, transformToNumberArray, transformToSort, transformToSortQueryParam, transformToString, transformToStringArray, transformToTableSort, transformToTableSortQueryParam, uncacheableRequestHasAllowCacheParam, uncacheableRequestHasCacheKeyParam, unwrapGqlResponseWithErrors, unwrapQuerySyncMessage, v2BuildQueryCacheKey, v2ExtractExpiresInSeconds, v2ShouldCacheQuery, v2ShouldRetryRequest, validateWithQuery, validateWithV2Query, withArgs, withArgsQueryFeatureMissingButRouteIsFunction, withAuthenticationQuery, withAutoRefresh, withAutoRefreshUsedInManualQuery, withAutoRefreshUsedOnUnsupportedHttpMethod, withBearerAuthMultiTabSync, withDefaultRetry, withErrorHandling, withEthleteApiErrors, withHtmlErrorParsing, withInactivityLogout, withLogging, withLongPolling, withLongPollingUsedOnUnsupportedHttpMethod, withLongPollingUsedWithPolling, withMultiTabSync, withPageResetOnError, withPersistentAuth, withPolling, withPollingUsedOnUnsupportedHttpMethod, withQueryDevtoolsOverridePersistence, withQueryPersistence, withRefreshQuery, withResponseUpdate, withSuccessHandling, withSymfonyErrors, withTokenExpirationWarning, withTokenRevocation, withTracking, wrapAsObservableSignal, wrapQuerySyncMessage, writeQueryDevtoolsStore };
+export { AuthBearerRefreshStrategy, BasicAuthProvider, BearerAuthFeatureType, BooleanArrayQueryField, CustomHeaderAuthProvider, DEFAULT_KEEP_UNUSED_FOR, DEFAULT_QUERY_PERSISTENCE_MAX_AGE, DEFAULT_QUERY_PERSISTENCE_MAX_ENTRIES, DEFAULT_QUERY_PERSISTENCE_VERSION, DEFAULT_QUERY_PERSISTENCE_WRITE_DELAY, DateArrayQueryField, DateQueryField, EntityStore, IGNORED_FILTER_COUNT_FIELDS, INFINITY_QUERY_TOKEN, IS_QUERY_REQUEST, 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, QUERY_VERSION, QueryClientFeatureType, QueryDevtoolsComponent, QueryDirective, QueryFeatureType, QueryField, QueryForm, QueryRuntimeErrorCode, QueryShortNamePipe, QueryStateType, QueryStore, SERVER_ERROR_KIND, SERVER_VIOLATION_ERROR_KIND, SPEED_BUFFER_TIME_IN_MS, SearchQueryField, SortQueryField, StringArrayQueryField, V2BearerAuthProvider, V2Query, V2QueryClient, V2QueryCreator, addQueryContainerHandling, applyQueryFeatures, authAccessTokenExpiryUnreadable, authExtractTokensResponseMissingAccessToken, authExtractTokensResponseMissingRefreshToken, authExtractTokensResponseNotObject, authProviderFeatureUsedMultipleTimes, booleanArrayQueryField, buildQueryCacheKey, buildQueryString, buildRoute, buildTimestampFromSeconds, castQueryCreatorTypes, circularQueryDependency, circularQueryDependencyChecker, clearQueryDevtoolsTokenTtl, computeQueryAuthHeader, computeQueryBody, computeQueryHeaders, computeQueryMethod, computeQueryQueryParams, contentfulGqlLikePaginationAdapter, createAuthGuard, createBaseQuery, createBaseQueryCreator, createBearerAuthProvider, createDefaultRetryFn, createDeleteQuery, createExecuteFn, createGetQuery, createGqlExecuteFn, createGqlMutationViaGet, createGqlMutationViaPost, createGqlQuery, createGqlQueryCreator, createGqlQueryViaGet, createGqlQueryViaPost, createHeadQuery, createHttpRequest, createIndexedDbQueryPersistenceAdapter, createInfinityQueryConfig, createLegacyQueryCreator, createNoopQueryPersistenceAdapter, createOptionsQuery, createPagedQueryStack, createPatchQuery, createPersistentAuthFeature, createPostQuery, createPutQuery, createQuery, createQueryBatch, createQueryClient, createQueryCollection, createQueryCollectionSignal, createQueryCollectionSubject, createQueryContext, createQueryCreator, createQueryErrorResponse, createQueryFeature, createQueryGroup, createQueryInvalidationFilter, createQueryKeyLockManager, createQueryObject, createQueryPersistenceEngine, createQueryRepository, createQuerySnapshotFn, createQueryStack, createQuerySubmission, createQuerySyncEngine, createQuerySyncTransport, createSecureDeleteQuery, createSecureExecuteFactory, createSecureExecuteFn, createSecureGetQuery, createSecureGqlExecuteFn, createSecureGqlMutationViaGet, createSecureGqlMutationViaPost, createSecureGqlQuery, createSecureGqlQueryCreator, createSecureGqlQueryViaGet, createSecureGqlQueryViaPost, createSecureHeadQuery, createSecureOptionsQuery, createSecurePatchQuery, createSecurePostQuery, createSecurePutQuery, createSecureQuery, createSecureQueryCreator, createSkippedSnapshot, createTrackingFeature, createWebSocketClient, dateArrayQueryField, dateQueryField, decryptBearer, deepFreeze, def, defineQueryForm, detectContentTypeHeader, dynLikePaginationAdapter, effectComputed, emptyQueryArgs, ethletePaginationAdapter, executeUntilSettled, executeUntilSettled$, extractExpiresInSeconds, extractFormViolations, extractHtmlErrorMessage, extractQuery, fakePaginationAdapter, filterFailure, filterNull, filterQueryStates, filterSuccess, forEachHeader, getDefaultHeaders, getQueryFeatureUsage, getResponseUrl, ggLikePaginationAdapter, gql, gqlDataPropertyMissingInResponse, gqlErrorsInResponse, gqlTransformerFor, hasDefaultQueryRetry, hasHeader, htmlErrorPayload, htmlQueryErrorParser, ignoreAutoRefresh, injectInfinityQueryResponseDelay, injectQueryContext, insertFrom, invalidBaseRouteError, invalidBodyError, invalidRouteError, invalidStateInsideSecureExecuteFactory, invalidateOnSuccess, invalidatesUsedOnRead, isAutoRefresh, isBasicAuthProvider, isBearerAuthProvider, isClassValidatorError, isCreateGqlQueryOptions, isCustomHeaderAuthProvider, isEmptyString, isGqlQueryConfig, isHtmlErrorPayload, isIdempotentQueryMethod, isLegacyQuery, isNaN$1 as isNaN, isPageOutOfRangeError, isQuery, isQueryCollection, isQueryErrorResponse, isQueryStateCancelled, isQueryStateFailure, isQueryStateLoading, isQueryStatePrepared, isQueryStateSuccess, isRequestError, isSymfonyError, isSymfonyFormViolationListError, isSymfonyListError, isSymfonyPagerfantaOutOfRangeError, isUnderInvalidatedUrl, legacyPrepareFallbackInjector, legacyPrepareWithoutInjectionContext, mapToPaginated, mapViolationsToFormErrors, maybeExecute, mergeHeaders, nestedEffect, numberArrayQueryField, pagedQueryStackNextPageCalledWithoutPreviousPage, pagedQueryStackPageBiggerThanTotalPages, pagedQueryStackPreviousPageCalledButAlreadyAtFirstPage, paginatedEntityValueUpdater, parseAllXhrResponseHeaders, parseHttpErrorCodeToMessageDe, parseHttpErrorCodeToMessageEn, parseHttpErrorCodeToTitleDe, parseHttpErrorCodeToTitleEn, pathParamsMissingInRouteFunctionError, provideInfinityQueryResponseDelay, provideLegacyPrepareFallback, provideQueryClientForDevtools, provideQueryDevtools, queryArrayComputed, queryBatchAlreadyRunning, queryBatchWithArgsUsed, queryClientFeatureUsedMultipleTimes, queryComputed, queryComputedTillTruthy, queryCreatedInReactiveContext, queryErrorMessage, queryErrorMessages, queryExecute, queryExecutedAfterDestroyMessage, queryExecutedWhileParkedMessage, queryFeatureUsedMultipleTimes, queryField, querySequence, querySequenceAlreadyRunning, queryStackWithArgsUsed, queryStackWithResponseUpdateUsed, queryStateAlreadyHasKeyError, queryStateCannotTransformError, queryStateDoesNotContainKeyError, queryStateErrorSignal, queryStateLoadingSignal, queryStateResponseSignal, queryStateSignal, recordExecutionArgs, registerQueryErrorParser, removeFrom, request, resetExecuteState, resetPageOnError, resolveInvalidationUrl, resolveQueryHeaders, resolveQueryTags, runDefaultQueryRetry, runQueryErrorParsers, searchQueryField, serializeBody, setDefaultQueryRetryFn, setQueryDevtoolsTokenTtl, setQueryDevtoolsUiMounted, setupQueryDependencies, setupQueryExecuteState, setupQueryState, shouldAutoExecuteGqlQuery, shouldAutoExecuteQuery, shouldCacheQuery, shouldRetryRequest, silenceMissingWithArgsFeatureErrorUsedButWithArgsPresent, skipPaginationPageParamCalculator, skipParkedExecution, sortQueryField, splitQueryConfig, stringArrayQueryField, switchQueryCollectionState, switchQueryState, symfonyQueryErrorParser, tableSortQueryField, takeUntilResponse, toQuerySignal, toQuerySubject, tokensNotAvailableInsideAuthAndExec, transformArrayResponse, transformExecStateToQueryState, transformGql, transformMethod, transformPaginatedResponse, transformToBoolean, transformToBooleanArray, transformToDate, transformToDateArray, transformToNumber, transformToNumberArray, transformToSort, transformToSortQueryParam, transformToString, transformToStringArray, transformToTableSort, transformToTableSortQueryParam, uncacheableRequestHasAllowCacheParam, uncacheableRequestHasCacheKeyParam, unwrapGqlResponseWithErrors, unwrapQuerySyncMessage, v2BuildQueryCacheKey, v2ExtractExpiresInSeconds, v2ShouldCacheQuery, v2ShouldRetryRequest, validateWithQuery, validateWithV2Query, withArgs, withArgsQueryFeatureMissingButRouteIsFunction, withAuthenticationQuery, withAutoRefresh, withAutoRefreshUsedInManualQuery, withAutoRefreshUsedOnUnsupportedHttpMethod, withBearerAuthMultiTabSync, withDefaultRetry, withErrorHandling, withEthleteApiErrors, withHtmlErrorParsing, withInactivityLogout, withLogging, withLongPolling, withLongPollingUsedOnUnsupportedHttpMethod, withLongPollingUsedWithPolling, withMultiTabSync, withOptimisticUpdate, withOptimisticUpdateUsedOnRead, withPageResetOnError, withPersistentAuth, withPolling, withPollingUsedOnUnsupportedHttpMethod, withQueryPersistence, withRefreshQuery, withResponseUpdate, withSuccessHandling, withSymfonyErrors, withTokenExpirationWarning, withTokenRevocation, withTracking, wrapAsObservableSignal, wrapQuerySyncMessage, EMPTY_QUERY_DEVTOOLS_FAULT as ɵEMPTY_QUERY_DEVTOOLS_FAULT, MAX_QUERY_BATCH_TOMBSTONES as ɵMAX_QUERY_BATCH_TOMBSTONES, MAX_QUERY_BATCH_TOMBSTONE_BUCKETS as ɵMAX_QUERY_BATCH_TOMBSTONE_BUCKETS, MAX_QUERY_DEVTOOLS_TOMBSTONES as ɵMAX_QUERY_DEVTOOLS_TOMBSTONES, QUERY_DEVTOOLS_FAULT_STATUSES as ɵQUERY_DEVTOOLS_FAULT_STATUSES, QUERY_DEVTOOLS_TOKEN_TTL_LIMIT as ɵQUERY_DEVTOOLS_TOKEN_TTL_LIMIT, addQueryDevtoolsAuthAccount as ɵaddQueryDevtoolsAuthAccount, applyQueryDevtoolsOverrides as ɵapplyQueryDevtoolsOverrides, applyQueryDevtoolsTokenTtl as ɵapplyQueryDevtoolsTokenTtl, armAllQueryDevtoolsMocks as ɵarmAllQueryDevtoolsMocks, armQueryDevtoolsMock as ɵarmQueryDevtoolsMock, armQueryDevtoolsOverrideTransfer as ɵarmQueryDevtoolsOverrideTransfer, canOverrideQueryDevtoolsTokenTtl as ɵcanOverrideQueryDevtoolsTokenTtl, clearQueryDevtoolsArmedMocks as ɵclearQueryDevtoolsArmedMocks, clearQueryDevtoolsAuthCredentials as ɵclearQueryDevtoolsAuthCredentials, clearQueryDevtoolsAuthSessions as ɵclearQueryDevtoolsAuthSessions, clearQueryDevtoolsFaults as ɵclearQueryDevtoolsFaults, clearQueryDevtoolsMockStore as ɵclearQueryDevtoolsMockStore, clearQueryDevtoolsOverrideStore as ɵclearQueryDevtoolsOverrideStore, clearQueryDevtoolsStore as ɵclearQueryDevtoolsStore, clearQueryDevtoolsTombstones as ɵclearQueryDevtoolsTombstones, clearRestoredQueryDevtoolsOverrides as ɵclearRestoredQueryDevtoolsOverrides, collectLeafPaths as ɵcollectLeafPaths, collectQueryDevtoolsSchemaComponents as ɵcollectQueryDevtoolsSchemaComponents, countUnresolvedQueryDevtoolsOverrides as ɵcountUnresolvedQueryDevtoolsOverrides, createQueryDevtoolsOverrides as ɵcreateQueryDevtoolsOverrides, deleteQueryDevtoolsMock as ɵdeleteQueryDevtoolsMock, detectPaginationShape as ɵdetectPaginationShape, forgetQueryDevtoolsAuthSession as ɵforgetQueryDevtoolsAuthSession, forgetQueryDevtoolsAuthSessionsFor as ɵforgetQueryDevtoolsAuthSessionsFor, generateQueryDevtoolsNumberPreset as ɵgenerateQueryDevtoolsNumberPreset, generateQueryDevtoolsSampleNumber as ɵgenerateQueryDevtoolsSampleNumber, generateQueryDevtoolsStringPreset as ɵgenerateQueryDevtoolsStringPreset, hasQueryDevtoolsOverridesAtPath as ɵhasQueryDevtoolsOverridesAtPath, isDateShapedLeaf as ɵisDateShapedLeaf, isQueryDevtoolsEnabled as ɵisQueryDevtoolsEnabled, isQueryDevtoolsFaultArmed as ɵisQueryDevtoolsFaultArmed, isQueryDevtoolsRepositoryLive as ɵisQueryDevtoolsRepositoryLive, loadQueryDevtoolsSchema as ɵloadQueryDevtoolsSchema, loginQueryDevtoolsAuthAccount as ɵloginQueryDevtoolsAuthAccount, logoutQueryDevtoolsAuthSession as ɵlogoutQueryDevtoolsAuthSession, matchesQueryDevtoolsMockPattern as ɵmatchesQueryDevtoolsMockPattern, matchesQueryDevtoolsMockQuery as ɵmatchesQueryDevtoolsMockQuery, measureQueryDevtoolsPayload as ɵmeasureQueryDevtoolsPayload, parseQueryDevtoolsOverrideTransfer as ɵparseQueryDevtoolsOverrideTransfer, queryDevtoolsAbout as ɵqueryDevtoolsAbout, queryDevtoolsAllowsLocalAuthSessions as ɵqueryDevtoolsAllowsLocalAuthSessions, queryDevtoolsApiEnvIds as ɵqueryDevtoolsApiEnvIds, queryDevtoolsApiEnvIsProduction as ɵqueryDevtoolsApiEnvIsProduction, queryDevtoolsApiEnvScope as ɵqueryDevtoolsApiEnvScope, queryDevtoolsApiEnvValues as ɵqueryDevtoolsApiEnvValues, queryDevtoolsApiEnvs as ɵqueryDevtoolsApiEnvs, queryDevtoolsArmedMocks as ɵqueryDevtoolsArmedMocks, queryDevtoolsArmedMocksRestored as ɵqueryDevtoolsArmedMocksRestored, queryDevtoolsAuthAccountsFor as ɵqueryDevtoolsAuthAccountsFor, queryDevtoolsAuthActive as ɵqueryDevtoolsAuthActive, queryDevtoolsAuthFieldsFor as ɵqueryDevtoolsAuthFieldsFor, queryDevtoolsAuthOtherScopeCount as ɵqueryDevtoolsAuthOtherScopeCount, queryDevtoolsAuthSessions as ɵqueryDevtoolsAuthSessions, queryDevtoolsAuthSessionsFor as ɵqueryDevtoolsAuthSessionsFor, queryDevtoolsAuthTabLocal as ɵqueryDevtoolsAuthTabLocal, queryDevtoolsEntries as ɵqueryDevtoolsEntries, queryDevtoolsFaults as ɵqueryDevtoolsFaults, queryDevtoolsFaultsRestored as ɵqueryDevtoolsFaultsRestored, queryDevtoolsMockId as ɵqueryDevtoolsMockId, queryDevtoolsMocks as ɵqueryDevtoolsMocks, queryDevtoolsOverridePersistence as ɵqueryDevtoolsOverridePersistence, queryDevtoolsRequestPath as ɵqueryDevtoolsRequestPath, queryDevtoolsResponseHistory as ɵqueryDevtoolsResponseHistory, queryDevtoolsRestoredOverridesScope as ɵqueryDevtoolsRestoredOverridesScope, queryDevtoolsSchemaNames as ɵqueryDevtoolsSchemaNames, queryDevtoolsSchemaRoutes as ɵqueryDevtoolsSchemaRoutes, queryDevtoolsSchemaState as ɵqueryDevtoolsSchemaState, queryDevtoolsSettings as ɵqueryDevtoolsSettings, queryDevtoolsStorage as ɵqueryDevtoolsStorage, queryDevtoolsTokenTtls as ɵqueryDevtoolsTokenTtls, readQueryDevtoolsStore as ɵreadQueryDevtoolsStore, registerEthleteVersion as ɵregisterEthleteVersion, removeQueryDevtoolsAuthAccount as ɵremoveQueryDevtoolsAuthAccount, renameQueryDevtoolsAuthSession as ɵrenameQueryDevtoolsAuthSession, ɵresetQueryDevtoolsForTesting, restoredQueryDevtoolsOverrides as ɵrestoredQueryDevtoolsOverrides, saveQueryDevtoolsMock as ɵsaveQueryDevtoolsMock, seedQueryDevtoolsSchemaBody as ɵseedQueryDevtoolsSchemaBody, seedQueryDevtoolsSchemaRoute as ɵseedQueryDevtoolsSchemaRoute, serializeQueryDevtoolsOverrideTransfer as ɵserializeQueryDevtoolsOverrideTransfer, setQueryDevtoolsApiEnv as ɵsetQueryDevtoolsApiEnv, setQueryDevtoolsAppInfo as ɵsetQueryDevtoolsAppInfo, setQueryDevtoolsArmedMocksScope as ɵsetQueryDevtoolsArmedMocksScope, setQueryDevtoolsAuthCredentials as ɵsetQueryDevtoolsAuthCredentials, setQueryDevtoolsAuthTabLocal as ɵsetQueryDevtoolsAuthTabLocal, setQueryDevtoolsFault as ɵsetQueryDevtoolsFault, setQueryDevtoolsFaultsScope as ɵsetQueryDevtoolsFaultsScope, setQueryDevtoolsOverridePersistence as ɵsetQueryDevtoolsOverridePersistence, setQueryDevtoolsOverridesScope as ɵsetQueryDevtoolsOverridesScope, setQueryDevtoolsSettings as ɵsetQueryDevtoolsSettings, smartDuplicateArrayItem as ɵsmartDuplicateArrayItem, snapshotQueryDevtoolsHandle as ɵsnapshotQueryDevtoolsHandle, stringifyQueryRouteParts as ɵstringifyQueryRouteParts, sumQueryDevtoolsStats as ɵsumQueryDevtoolsStats, switchQueryDevtoolsAuthSession as ɵswitchQueryDevtoolsAuthSession, tombstoneOf as ɵtombstoneOf, writeQueryDevtoolsStore as ɵwriteQueryDevtoolsStore };
 //# sourceMappingURL=ethlete-query.mjs.map