@ethlete/query 6.0.0-next.37 → 6.0.0-next.38

package/CHANGELOG.md

@@ -1,5 +1,24 @@
 # @ethlete/query
 
+## 6.0.0-next.38
+
+### Minor Changes
+
+- [`9c64031`](https://github.com/ethlete-io/ethdk/commit/9c64031cb39f6ac9f5932cb32b31ab98742a9391) Thanks [@TomTomB](https://github.com/TomTomB)! - A query batch registers itself with the devtools, and each item's query is attributed to the run that
+  created it. Batch tombstones are capped per batch, so a bulk run cannot evict the others.
+
+- [`9c64031`](https://github.com/ethlete-io/ethdk/commit/9c64031cb39f6ac9f5932cb32b31ab98742a9391) Thanks [@TomTomB](https://github.com/TomTomB)! - A query batch reports `itemsPerSecond()` and `remainingTime()`, so a long bulk edit can show an ETA
+  next to its progress. Both are `null` until the run has settled enough items to measure.
+
+- [`9c64031`](https://github.com/ethlete-io/ethdk/commit/9c64031cb39f6ac9f5932cb32b31ab98742a9391) Thanks [@TomTomB](https://github.com/TomTomB)! - `createQueryBatch` runs one mutation over a list of items with bounded concurrency, a per-item
+  outcome and a `retryFailed()` that resends only what did not succeed.
+
+- [`3bc10d1`](https://github.com/ethlete-io/ethdk/commit/3bc10d12430def3315a17a3051b14624edc591cc) Thanks [@TomTomB](https://github.com/TomTomB)! - `createQuerySubmission` submits a signal form through a mutation, mapping a failed request's
+  violations back onto the fields that caused them.
+
+- [`5cb3e5e`](https://github.com/ethlete-io/ethdk/commit/5cb3e5e6ff61aea87dbca0481fbf48b8634183f6) Thanks [@TomTomB](https://github.com/TomTomB)! - `querySequence` now reports `completed()` and `progress()` (`0`-`100`), so a waterfall can drive a
+  progress bar or a determinate button spinner without deriving it from `currentStep()`.
+
 ## 6.0.0-next.37
 
 ### Minor Changes

package/fesm2022/ethlete-query.mjs

@@ -2,7 +2,7 @@ import * as i0 from '@angular/core';
 import { inject, computed, DestroyRef, InjectionToken, Injector, EnvironmentInjector, ElementRef, ErrorHandler, createEnvironmentInjector, effect, untracked, signal, linkedSignal, runInInjectionContext, isDevMode, PLATFORM_ID, resource, DOCUMENT, VERSION, makeEnvironmentProviders, assertInInjectionContext, provideEnvironmentInitializer, ChangeDetectorRef, ViewContainerRef, TemplateRef, Input, Directive, input, Pipe, ViewEncapsulation, Component, NgZone } from '@angular/core';
 import { toObservable, takeUntilDestroyed, toSignal } from '@angular/core/rxjs-interop';
 import { UrlTree, Router, RedirectCommand, ActivatedRoute } from '@angular/router';
-import { filter, take, map, defer, from, Subject, Subscription, throwError, of, timer, switchMap, tap, retry, catchError, merge, EMPTY, takeWhile, firstValueFrom, concatMap, fromEvent, throttleTime, interval, combineLatest, Observable, takeUntil, startWith, pairwise, BehaviorSubject, ReplaySubject, shareReplay, skip, withLatestFrom, debounceTime } from 'rxjs';
+import { filter, take, map, defer, from, Subject, Subscription, throwError, of, timer, switchMap, tap, retry, catchError, EMPTY, takeUntil, finalize, mergeMap, toArray, merge, takeWhile, firstValueFrom, concatMap, fromEvent, throttleTime, interval, combineLatest, Observable, startWith, pairwise, BehaviorSubject, ReplaySubject, shareReplay, skip, withLatestFrom, debounceTime } from 'rxjs';
 import { defineStaticProvider, RuntimeError, clamp, randomId, defineRootProvider, isObject, injectUnsavedChangesCoordinator, injectRoute, getCookie, getDomain, deleteCookie, setCookie, CORE_VERSION, createDestroy, computedTillTruthy, defineProvider, toProvideFn, toInjectFn, nextFrame, injectQueryParams, injectQueryParamChanges, clone, equal, ET_PROPERTY_REMOVED, previousSignalValue } from '@ethlete/core';
 import { HttpClient, HttpEventType, HttpErrorResponse, HttpResponse, HttpHeaders, HttpStatusCode } from '@angular/common/http';
 import { getActiveConsumer, setActiveConsumer } from '@angular/core/primitives/signals';
@@ -283,6 +283,26 @@ const setQueryDevtoolsTokenPayloadPatcher = (fn) => {
  * @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
@@ -409,6 +429,9 @@ const QueryRuntimeErrorCode = {
     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,
@@ -507,6 +530,12 @@ const legacyPrepareWithoutInjectionContext = (creatorName, method = 'prepare') =
 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 && 'statusCode' in error && 'message' in error && 'error' in error;
@@ -1204,6 +1233,7 @@ const createBaseQuery = (options) => {
         queryConfig: options.queryConfig,
     });
     return runInInjectionContext(deps.injector, () => {
+        const batchOwner = currentQueryDevtoolsBatch();
         const devtoolsStats = createQueryDevtoolsStatsRecorder();
         const devtoolsFormLinks = createQueryDevtoolsFormLinksRecorder();
         const devtoolsOverrides = createQueryDevtoolsOverridesRecorder();
@@ -1271,6 +1301,8 @@ const createBaseQuery = (options) => {
                     client: deps.client,
                     element: deps.hostElement,
                     gqlQuery: options.creatorInternals.query,
+                    batch: batchOwner?.batch,
+                    batchItemIndex: batchOwner?.index,
                 },
             });
             deps.destroyRef.onDestroy(unregister);
@@ -2924,6 +2956,259 @@ const createIndexedDbQueryPersistenceAdapter = (options) => {
     return { loadIndex, read, write, remove, clear, isSupported: true };
 };
 
+/* eslint-disable @typescript-eslint/no-explicit-any */
+/**
+ * Runs the same mutation over a list of items - the bulk edit / bulk delete shape - with a bounded
+ * number of requests in flight and a per-item outcome.
+ *
+ * Where a query stack fans a reactive read out over many arg sets and keeps every query alive, a
+ * batch is imperative and disposable: it is triggered by a button, it tolerates a partial failure,
+ * and it destroys each query as soon as that item settles.
+ *
+ * Call it from an injection context; the host's destruction stops an in-flight run.
+ *
+ * @example
+ * ```ts
+ * protected archivePosts = createQueryBatch({
+ *   queryCreator: patchPost,
+ *   args: (post: Post) => ({ pathParams: { id: post.id }, body: { archived: true } }),
+ *   concurrency: 6,
+ * });
+ *
+ * archiveSelected() {
+ *   this.archivePosts
+ *     .run(this.selection())
+ *     .pipe(tap((result) => result.ok || this.toast.error(`${result.failed.length} failed`)))
+ *     .subscribe();
+ * }
+ * ```
+ *
+ * ```html
+ * <button et-button [loading]="archivePosts.running()" [progress]="archivePosts.progress()">Archive</button>
+ * @if (archivePosts.failed()) {
+ *   <button (click)="retry()">Retry {{ archivePosts.failed() }} failed</button>
+ * }
+ * ```
+ */
+const createQueryBatch = (options) => {
+    const { queryCreator, args: mapArgs, stopOnError, allowCache, onItemSettled, features = [] } = options;
+    const concurrency = Math.max(1, Math.floor(options.concurrency ?? 4));
+    if (features.some((f) => f.type === QueryFeatureType.WITH_ARGS)) {
+        throw queryBatchWithArgsUsed();
+    }
+    const injector = inject(Injector);
+    const destroyRef = inject(DestroyRef);
+    const devtoolsHandle = isQueryDevtoolsEnabled()
+        ? { current: null }
+        : undefined;
+    const status = signal('idle', /* @ts-ignore */
+    ...(ngDevMode ? [{ debugName: "status" }] : /* istanbul ignore next */ []));
+    const running = signal(false, /* @ts-ignore */
+    ...(ngDevMode ? [{ debugName: "running" }] : /* istanbul ignore next */ []));
+    const total = signal(0, /* @ts-ignore */
+    ...(ngDevMode ? [{ debugName: "total" }] : /* istanbul ignore next */ []));
+    const inFlight = signal(0, /* @ts-ignore */
+    ...(ngDevMode ? [{ debugName: "inFlight" }] : /* istanbul ignore next */ []));
+    const results = signal([], /* @ts-ignore */
+    ...(ngDevMode ? [{ debugName: "results" }] : /* istanbul ignore next */ []));
+    const runStartedAt = signal(null, /* @ts-ignore */
+    ...(ngDevMode ? [{ debugName: "runStartedAt" }] : /* istanbul ignore next */ []));
+    const lastSettleAt = signal(null, /* @ts-ignore */
+    ...(ngDevMode ? [{ debugName: "lastSettleAt" }] : /* istanbul ignore next */ []));
+    const completedBeforeRun = signal(0, /* @ts-ignore */
+    ...(ngDevMode ? [{ debugName: "completedBeforeRun" }] : /* istanbul ignore next */ []));
+    let settled = [];
+    let cancelRequested = false;
+    let hostDestroyed = false;
+    const hostDestroyed$ = new Subject();
+    destroyRef.onDestroy(() => {
+        hostDestroyed = true;
+        cancelRequested = true;
+        hostDestroyed$.next();
+        hostDestroyed$.complete();
+    });
+    const publish = () => results.set(settled.filter((r) => !!r));
+    const record = (result) => {
+        settled[result.index] = result;
+        lastSettleAt.set(Date.now());
+        publish();
+        onItemSettled?.(result);
+    };
+    const countOf = (of) => computed(() => results().filter((r) => r.status === of).length);
+    const completed = computed(() => results().length, /* @ts-ignore */
+    ...(ngDevMode ? [{ debugName: "completed" }] : /* istanbul ignore next */ []));
+    const failedResults = computed(() => results().filter((r) => r.status === 'error'), /* @ts-ignore */
+    ...(ngDevMode ? [{ debugName: "failedResults" }] : /* istanbul ignore next */ []));
+    // Measured from the run's start rather than between the last two settles: items land in waves of
+    // `concurrency`, so an instantaneous rate swings between zero and a burst.
+    const itemsPerSecond = computed(() => {
+        const startedAt = runStartedAt();
+        const measuredAt = lastSettleAt();
+        if (startedAt === null || measuredAt === null)
+            return null;
+        const elapsedMs = measuredAt - startedAt;
+        const settledInRun = completed() - completedBeforeRun();
+        // One settled item says nothing about a run of `concurrency` parallel ones, and a run shorter
+        // than the buffer extrapolates a whole batch out of its own warm-up.
+        if (elapsedMs < SPEED_BUFFER_TIME_IN_MS || settledInRun < Math.min(concurrency, total()))
+            return null;
+        return (settledInRun / elapsedMs) * 1000;
+    }, /* @ts-ignore */
+    ...(ngDevMode ? [{ debugName: "itemsPerSecond" }] : /* istanbul ignore next */ []));
+    const remainingTime = computed(() => {
+        const rate = itemsPerSecond();
+        const outstanding = total() - completed();
+        if (rate === null || rate <= 0 || outstanding <= 0)
+            return null;
+        return Math.round((outstanding / rate) * 1000);
+    }, /* @ts-ignore */
+    ...(ngDevMode ? [{ debugName: "remainingTime" }] : /* istanbul ignore next */ []));
+    const runEntry = (entry) => defer(() => {
+        if (cancelRequested) {
+            record({ status: 'cancelled', index: entry.index, item: entry.item });
+            return EMPTY;
+        }
+        const args = mapArgs(entry.item, entry.index);
+        if (args === null) {
+            record({ status: 'skipped', index: entry.index, item: entry.item });
+            return EMPTY;
+        }
+        // The args reach the query through `execute()`, never `withArgs()`, so a function route has to
+        // be told the missing feature is intentional or creating the query throws ET100.
+        const create = () => queryCreator({ silenceMissingWithArgsFeatureError: true }, ...features);
+        const query = runInInjectionContext(injector, () => devtoolsHandle ? runInQueryDevtoolsBatch({ batch: devtoolsHandle, index: entry.index }, create) : create());
+        inFlight.update((count) => count + 1);
+        query.execute({ args, options: { allowCache } });
+        const snapshot = query.createSnapshot();
+        return snapshot.isAlive.asObservable().pipe(filter((isAlive) => !isAlive), take(1), 
+        // A destroyed host tears the query down without ever settling it, so the run would hang.
+        takeUntil(hostDestroyed$), tap(() => {
+            const error = snapshot.error();
+            if (error) {
+                record({ status: 'error', index: entry.index, item: entry.item, args, error });
+                if (stopOnError)
+                    cancelRequested = true;
+                return;
+            }
+            record({
+                status: 'success',
+                index: entry.index,
+                item: entry.item,
+                args,
+                response: snapshot.response(),
+            });
+        }), finalize(() => {
+            inFlight.update((count) => count - 1);
+            // The host's destruction already tore the query's injector down; destroying it again throws.
+            if (!hostDestroyed)
+                query.subtle.destroy();
+        }));
+    });
+    const settleRun = (entries) => {
+        const stoppedEarly = cancelRequested;
+        for (const entry of entries) {
+            settled[entry.index] ??= { status: 'cancelled', index: entry.index, item: entry.item };
+        }
+        publish();
+        running.set(false);
+        const all = results();
+        const succeeded = all.filter((r) => r.status === 'success');
+        const failed = all.filter((r) => r.status === 'error');
+        const skipped = all.filter((r) => r.status === 'skipped');
+        const notAttempted = all.filter((r) => r.status === 'cancelled');
+        if (failed.length === 0)
+            status.set(notAttempted.length === 0 ? 'success' : 'cancelled');
+        else
+            status.set(succeeded.length === 0 ? 'error' : 'partial');
+        return {
+            ok: failed.length === 0 && notAttempted.length === 0,
+            cancelled: stoppedEarly,
+            results: all,
+            succeeded,
+            failed,
+            skipped,
+            notAttempted,
+        };
+    };
+    const runEntries = (collect) => defer(() => {
+        if (running())
+            throw queryBatchAlreadyRunning();
+        const entries = collect();
+        cancelRequested = false;
+        running.set(true);
+        status.set('running');
+        publish();
+        // After `publish()`: a retry clears its entries first, so this reads the count the retried
+        // items are measured against, not the one from before they were dropped.
+        completedBeforeRun.set(completed());
+        runStartedAt.set(Date.now());
+        lastSettleAt.set(null);
+        return from(entries).pipe(mergeMap((entry) => runEntry(entry), concurrency), toArray(), map(() => settleRun(entries)));
+    });
+    const run = (items) => runEntries(() => {
+        settled = new Array(items.length);
+        total.set(items.length);
+        return items.map((item, index) => ({ item, index }));
+    });
+    const retryFailed = () => runEntries(() => {
+        const entries = results()
+            .filter((r) => r.status === 'error' || r.status === 'cancelled')
+            .map((r) => ({ item: r.item, index: r.index }));
+        for (const entry of entries) {
+            settled[entry.index] = undefined;
+        }
+        return entries;
+    });
+    const batch = {
+        status: status.asReadonly(),
+        running: running.asReadonly(),
+        total: total.asReadonly(),
+        completed,
+        inFlight: inFlight.asReadonly(),
+        succeeded: countOf('success'),
+        failed: countOf('error'),
+        skipped: countOf('skipped'),
+        progress: computed(() => {
+            const count = total();
+            return count === 0 ? 0 : (completed() / count) * 100;
+        }),
+        itemsPerSecond,
+        remainingTime,
+        results: results.asReadonly(),
+        errors: computed(() => failedResults().map((r) => r.error)),
+        failedItems: computed(() => failedResults().map((r) => r.item)),
+        run,
+        retryFailed,
+        cancel: () => {
+            cancelRequested = true;
+        },
+        reset: () => {
+            if (running())
+                return;
+            settled = [];
+            total.set(0);
+            results.set([]);
+            status.set('idle');
+            runStartedAt.set(null);
+            lastSettleAt.set(null);
+            completedBeforeRun.set(0);
+        },
+    };
+    if (devtoolsHandle) {
+        devtoolsHandle.current = batch;
+        const internals = queryCreator.subtle.creatorInternals;
+        const unregister = registerQueryDevtoolsEntry({
+            kind: 'query-batch',
+            handle: devtoolsHandle,
+            route: internals.route,
+            clientRef: internals.client,
+            meta: { method: internals.method, concurrency, stopOnError: !!stopOnError },
+        });
+        destroyRef.onDestroy(unregister);
+    }
+    return batch;
+};
+
 /**
  * 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.
@@ -4320,6 +4605,8 @@ const buildSequence = (steps, state, devtoolsHandle) => {
         state.running.set(false);
         return { ok: true, responses: responses, snapshots };
     };
+    const completed = computed(() => state.snapshots().length, /* @ts-ignore */
+    ...(ngDevMode ? [{ debugName: "completed" }] : /* istanbul ignore next */ []));
     const sequence = {
         then: (query, mapArgs) => buildSequence([
             ...steps,
@@ -4328,6 +4615,8 @@ const buildSequence = (steps, state, devtoolsHandle) => {
         status: state.status.asReadonly(),
         running: state.running.asReadonly(),
         currentStep: state.currentStep.asReadonly(),
+        completed,
+        progress: computed(() => (steps.length === 0 ? 0 : (completed() / steps.length) * 100)),
         total: steps.length,
         queries: steps.map((s) => s.query),
         error: state.error.asReadonly(),
@@ -4500,6 +4789,54 @@ const resolveFieldTreePath = (fieldTree, path) => {
     return typeof current === 'function' ? current : null;
 };
 
+/**
+ * Builds a signal form's `submission.action` around a mutation: submitting executes the query with
+ * args derived from the form's value, waits for it to settle, and maps a failed request's violations
+ * back onto the fields that caused them. `form().submitting()` therefore covers the whole round trip.
+ *
+ * This is the submit-time counterpart to {@link validateWithQuery}. The query's args come from the
+ * submitted value rather than a `withArgs()` feature, which also means the query no longer reads the
+ * form it belongs to - so it can be declared before it, and no derivation runs per keystroke.
+ *
+ * ```ts
+ * protected createPost = createQuerySubmission({
+ *   queryCreator: postPost,
+ *   args: (value) => ({ body: value }),
+ *   onSuccess: (post) => this.router.navigate(['/posts', post.id]),
+ * });
+ *
+ * protected form = form(this.model, postSchema, {
+ *   submission: { action: this.createPost.action },
+ * });
+ * ```
+ *
+ * ```html
+ * <form [etForm]="form">…</form>
+ * <et-query-error [error]="createPost.query.error()" [query]="createPost.query" />
+ * ```
+ *
+ * Call it from an injection context.
+ */
+const createQuerySubmission = (config) => {
+    // The args reach the query through `execute()`, never `withArgs()`, so a function route has to be
+    // told the missing feature is intentional or creating the query throws ET100.
+    const query = config.queryCreator({ silenceMissingWithArgsFeatureError: true });
+    const action = async (field) => {
+        const args = config.args?.(field().value(), field) ?? null;
+        if (config.args && args === null)
+            return undefined;
+        const snapshot = await executeUntilSettled(query, args === null ? undefined : { args });
+        const error = snapshot.error();
+        if (error) {
+            return (config.mapViolations?.(error, field) ??
+                mapViolationsToFormErrors({ fieldTree: field, error, rewritePath: config.rewritePath }));
+        }
+        config.onSuccess?.(snapshot.response(), field);
+        return undefined;
+    };
+    return { query, action };
+};
+
 // Shared core for the query-backed async validators (`validateWithQuery` /
 // `validateWithV2Query`). Everything except how the query is executed - the `factory` that turns
 // the debounced params into a `Resource` - is identical between the v2 and v3 variants, so it is
@@ -7466,7 +7803,7 @@ const armQueryDevtoolsOverrideTransfer = (recorder, ops) => {
 
 // Generated from package.json by tools/scripts/generate-version.js - do not edit.
 /** The version of `@ethlete/query` this build was cut from. */
-const QUERY_VERSION = '6.0.0-next.37';
+const QUERY_VERSION = '6.0.0-next.38';
 
 /** How deep a schema is expanded before a nested branch is given up on. */
 const MAX_DEPTH = 12;
@@ -8447,6 +8784,12 @@ const applyQueryDevtoolsTokenTtl = (options) => {
  * so the list is capped for the same reason the repository caps its unused entries.
  */
 const MAX_QUERY_DEVTOOLS_TOMBSTONES = 50;
+/**
+ * How many of its settled items' queries one batch keeps. Counted per batch rather than against
+ * {@link MAX_QUERY_DEVTOOLS_TOMBSTONES}, so a bulk run cannot evict the tombstones the panel is read
+ * for - and low, because the batch's own entry already holds every item's args, response and error.
+ */
+const MAX_QUERY_BATCH_TOMBSTONES = 20;
 const frozen = (value) => () => value;
 const noop = () => undefined;
 /**
@@ -8668,8 +9011,8 @@ const registerEntry = (registration) => {
         if (index === -1)
             return list;
         const next = list.slice();
-        // Only queries leave a tombstone. A stack, sequence, form or auth provider is a container whose
-        // interesting state is the queries it owns - each of which tombstones on its own.
+        // Only queries leave a tombstone. A stack, sequence, batch, form or auth provider is a container
+        // whose interesting state is the queries it owns - each of which tombstones on its own.
         if (fullEntry.kind !== 'query') {
             next.splice(index, 1);
             return next;
@@ -8678,16 +9021,39 @@ const registerEntry = (registration) => {
         return capTombstones(next);
     });
 };
-/** Drops the oldest tombstones once there are more than {@link MAX_QUERY_DEVTOOLS_TOMBSTONES} of them. */
+/** The oldest `count` entries of a bucket, which is what a cap drops when the bucket is over it. */
+const oldestOver = (bucket, cap) => bucket.length <= cap
+    ? []
+    : bucket.sort((a, b) => (a.destroyedAt ?? 0) - (b.destroyedAt ?? 0)).slice(0, bucket.length - cap);
+/**
+ * Caps the tombstones the registry holds. A batch's items are counted per batch rather than against the
+ * shared budget: a batch destroys one query per item as it settles, so a single 500-item run would
+ * otherwise fill the whole buffer and evict every tombstone the panel is actually read for - the `401`
+ * that took its component down with it. Each batch keeps its own recent tail instead.
+ */
 const capTombstones = (list) => {
-    const excess = list.filter((e) => e.destroyedAt).length - MAX_QUERY_DEVTOOLS_TOMBSTONES;
-    if (excess <= 0)
-        return list;
-    const doomed = new Set(list
-        .filter((e) => e.destroyedAt)
-        .sort((a, b) => (a.destroyedAt ?? 0) - (b.destroyedAt ?? 0))
-        .slice(0, excess));
-    return list.filter((e) => !doomed.has(e));
+    const shared = [];
+    const perBatch = new Map();
+    for (const entry of list) {
+        if (!entry.destroyedAt)
+            continue;
+        const batch = entry.meta.batch;
+        if (!batch) {
+            shared.push(entry);
+            continue;
+        }
+        const bucket = perBatch.get(batch);
+        if (bucket)
+            bucket.push(entry);
+        else
+            perBatch.set(batch, [entry]);
+    }
+    const doomed = new Set(oldestOver(shared, MAX_QUERY_DEVTOOLS_TOMBSTONES));
+    for (const bucket of perBatch.values()) {
+        for (const entry of oldestOver(bucket, MAX_QUERY_BATCH_TOMBSTONES))
+            doomed.add(entry);
+    }
+    return doomed.size ? list.filter((e) => !doomed.has(e)) : list;
 };
 /**
  * Forgets destroyed entries the registry is holding - the panel's "clear gone" action. Pass the ids to
@@ -14271,5 +14637,5 @@ const createWebSocketClient = (options) => {
  * Generated bundle index. Do not edit.
  */
 
-export { BasicAuthProvider, BearerAuthFeatureType, BooleanArrayQueryField, CustomHeaderAuthProvider, DEFAULT_KEEP_UNUSED_FOR, DEFAULT_QUERY_PERSISTENCE_MAX_AGE, DEFAULT_QUERY_PERSISTENCE_MAX_ENTRIES, DEFAULT_QUERY_PERSISTENCE_VERSION, DEFAULT_QUERY_PERSISTENCE_WRITE_DELAY, DateArrayQueryField, DateQueryField, EMPTY_QUERY_DEVTOOLS_FAULT, EntityStore, IGNORED_FILTER_COUNT_FIELDS, INFINITY_QUERY_TOKEN, InfinityQuery, InfinityQueryDirective, InfinityQueryTriggerDirective, LegacyQuery, LegacyQueryCreator, MAX_QUERY_DEVTOOLS_TOMBSTONES, MAX_UNUSED_ENTRIES, NumberArrayQueryField, ParseHttpErrorCodeToMessageDePipe, ParseHttpErrorCodeToMessageEnPipe, ParseHttpErrorCodeToTitleDePipe, ParseHttpErrorCodeToTitleEnPipe, QUERY_CLIENT_DEVTOOLS_TOKEN, QUERY_DEVTOOLS_FAULT_STATUSES, QUERY_DEVTOOLS_TOKEN_TTL_LIMIT, QUERY_PERSISTENCE_STORE_VERSION, QUERY_SYNC_PROTOCOL_VERSION, QUERY_VERSION, QueryClientFeatureType, QueryDevtoolsComponent, QueryDirective, QueryFeatureType, QueryField, QueryForm, QueryRuntimeErrorCode, QueryShortNamePipe, QueryStore, SERVER_ERROR_KIND, SERVER_VIOLATION_ERROR_KIND, SPEED_BUFFER_TIME_IN_MS, SearchQueryField, SortQueryField, StringArrayQueryField, V2BearerAuthProvider, V2Query, V2QueryClient, V2QueryCreator, addQueryContainerHandling, applyQueryDevtoolsOverrides, applyQueryDevtoolsTokenTtl, applyQueryFeatures, armAllQueryDevtoolsMocks, armQueryDevtoolsMock, armQueryDevtoolsOverrideTransfer, authExtractTokensResponseMissingAccessToken, authExtractTokensResponseMissingRefreshToken, authExtractTokensResponseNotObject, authProviderFeatureUsedMultipleTimes, booleanArrayQueryField, buildQueryCacheKey, buildQueryString, buildRoute, buildTimestampFromSeconds, canOverrideQueryDevtoolsTokenTtl, castQueryCreatorTypes, circularQueryDependency, circularQueryDependencyChecker, clearQueryDevtoolsArmedMocks, clearQueryDevtoolsFaults, clearQueryDevtoolsMockStore, clearQueryDevtoolsOverrideStore, clearQueryDevtoolsStore, clearQueryDevtoolsTokenTtl, clearQueryDevtoolsTombstones, clearRestoredQueryDevtoolsOverrides, collectLeafPaths, collectQueryDevtoolsSchemaComponents, collectQueryFormLinks, computeQueryAuthHeader, computeQueryBody, computeQueryHeaders, computeQueryMethod, computeQueryQueryParams, consumeSuppressQueryStackDevtools, contentfulGqlLikePaginationAdapter, countUnresolvedQueryDevtoolsOverrides, createAuthGuard, createBaseQuery, createBaseQueryCreator, createBearerAuthProvider, createDefaultRetryFn, createDeleteQuery, createExecuteFn, createGetQuery, createGqlExecuteFn, createGqlMutationViaGet, createGqlMutationViaPost, createGqlQuery, createGqlQueryCreator, createGqlQueryViaGet, createGqlQueryViaPost, createHttpRequest, createIndexedDbQueryPersistenceAdapter, createInfinityQueryConfig, createLegacyQueryCreator, createNoopQueryPersistenceAdapter, createPagedQueryStack, createPatchQuery, createPersistentAuthFeature, createPostQuery, createPutQuery, createQuery, createQueryClient, createQueryCollection, createQueryCollectionSignal, createQueryCollectionSubject, createQueryContext, createQueryCreator, createQueryDevtoolsFormLinks, createQueryDevtoolsFormLinksRecorder, createQueryDevtoolsOverrides, createQueryDevtoolsOverridesRecorder, createQueryDevtoolsStats, createQueryDevtoolsStatsRecorder, createQueryErrorResponse, createQueryFeature, createQueryInvalidationFilter, createQueryKeyLockManager, createQueryObject, createQueryPersistenceEngine, createQueryRepository, createQuerySnapshotFn, createQueryStack, createQuerySyncEngine, createQuerySyncTransport, createSecureDeleteQuery, createSecureExecuteFactory, createSecureExecuteFn, createSecureGetQuery, createSecureGqlExecuteFn, createSecureGqlMutationViaGet, createSecureGqlMutationViaPost, createSecureGqlQuery, createSecureGqlQueryCreator, createSecureGqlQueryViaGet, createSecureGqlQueryViaPost, createSecurePatchQuery, createSecurePostQuery, createSecurePutQuery, createSecureQuery, createSecureQueryCreator, createTrackingFeature, createWebSocketClient, dateArrayQueryField, dateQueryField, decryptBearer, deepFreeze, def, defineQueryForm, deleteQueryDevtoolsMock, describeQueryDevtoolsFeatures, detectContentTypeHeader, detectPaginationShape, dynLikePaginationAdapter, effectComputed, emptyQueryArgs, ethletePaginationAdapter, executeUntilSettled, extractExpiresInSeconds, extractFormViolations, extractHtmlErrorMessage, extractQuery, fakePaginationAdapter, filterFailure, filterNull, filterQueryStates, filterSuccess, forEachHeader, formatQueryDevtoolsDuration, generateQueryDevtoolsNumberPreset, generateQueryDevtoolsSampleNumber, generateQueryDevtoolsStringPreset, getBearerAuthProviderName, getDefaultHeaders, getQueryClientName, getQueryFeatureUsage, getResponseUrl, ggLikePaginationAdapter, gql, gqlDataPropertyMissingInResponse, hasHeader, hasQueryDevtoolsOverridesAtPath, htmlErrorPayload, htmlQueryErrorParser, ignoreAutoRefresh, initQueryDevtoolsFaults, initQueryDevtoolsMocks, initQueryDevtoolsOverridePersistence, initQueryDevtoolsSettings, injectInfinityQueryResponseDelay, injectQueryContext, insertFrom, invalidBaseRouteError, invalidBodyError, invalidRouteError, invalidStateInsideSecureExecuteFactory, isAutoRefresh, isBasicAuthProvider, isBearerAuthProvider, isClassValidatorError, isCreateGqlQueryOptions, isCustomHeaderAuthProvider, isDateShapedLeaf, isEmptyString, isGqlQueryConfig, isHtmlErrorPayload, isLegacyQuery, isNaN$1 as isNaN, isPageOutOfRangeError, isQuery, isQueryCollection, isQueryDevtoolsEnabled, isQueryDevtoolsFaultArmed, isQueryDevtoolsRequestInterceptionEnabled, isQueryErrorResponse, isQueryStateCancelled, isQueryStateFailure, isQueryStateLoading, isQueryStatePrepared, isQueryStateSuccess, isRequestError, isSymfonyError, isSymfonyFormViolationListError, isSymfonyListError, isSymfonyPagerfantaOutOfRangeError, isUnderInvalidatedUrl, legacyPrepareFallbackInjector, legacyPrepareWithoutInjectionContext, loadQueryDevtoolsSchema, mapToPaginated, mapViolationsToFormErrors, matchesQueryDevtoolsMockPattern, matchesQueryDevtoolsMockQuery, maybeExecute, measureQueryDevtoolsPayload, mergeHeaders, nestedEffect, noteQueryFormRead, numberArrayQueryField, pagedQueryStackNextPageCalledWithoutPreviousPage, pagedQueryStackPageBiggerThanTotalPages, pagedQueryStackPreviousPageCalledButAlreadyAtFirstPage, paginatedEntityValueUpdater, parseAllXhrResponseHeaders, parseHttpErrorCodeToMessageDe, parseHttpErrorCodeToMessageEn, parseHttpErrorCodeToTitleDe, parseHttpErrorCodeToTitleEn, parseQueryDevtoolsOverrideTransfer, parseQueryRoute, patchQueryDevtoolsTokenPayload, pathParamsMissingInRouteFunctionError, provideInfinityQueryResponseDelay, provideLegacyPrepareFallback, provideQueryClientForDevtools, provideQueryDevtools, queryArrayComputed, queryClientFeatureUsedMultipleTimes, queryComputed, queryComputedTillTruthy, queryDevtoolsAbout, queryDevtoolsArmedMocks, queryDevtoolsArmedMocksRestored, queryDevtoolsEntries, queryDevtoolsFaults, queryDevtoolsFaultsRestored, queryDevtoolsFnDetail, queryDevtoolsMockId, queryDevtoolsMocks, queryDevtoolsOverridePersistence, queryDevtoolsRequestPath, queryDevtoolsResponseHistory, queryDevtoolsRestoredOverridesScope, queryDevtoolsSchemaNames, queryDevtoolsSchemaRoutes, queryDevtoolsSchemaState, queryDevtoolsSettings, queryDevtoolsStorage, queryDevtoolsTokenTtls, queryErrorMessage, queryErrorMessages, queryExecute, queryFeatureUsedMultipleTimes, queryField, querySequence, querySequenceAlreadyRunning, queryStackTotalQueriesAndExpectedQueriesMismatch, queryStackWithArgsUsed, queryStackWithResponseUpdateUsed, queryStateAlreadyHasKeyError, queryStateCannotTransformError, queryStateDoesNotContainKeyError, queryStateErrorSignal, queryStateLoadingSignal, queryStateResponseSignal, queryStateSignal, readQueryDevtoolsStore, registerEthleteVersion, registerQueryDevtoolsEntry, registerQueryErrorParser, removeFrom, request, resetExecuteState, resetPageOnError, resolveInvalidationUrl, resolveQueryDevtoolsFault, resolveQueryDevtoolsFaultForAttempt, resolveQueryDevtoolsMock, resolveQueryDevtoolsMockForAttempt, restoredQueryDevtoolsOverrides, runDefaultQueryRetry, runQueryErrorParsers, saveQueryDevtoolsMock, searchQueryField, seedQueryDevtoolsSchemaBody, seedQueryDevtoolsSchemaRoute, serializeBody, serializeQueryDevtoolsOverrideTransfer, setDefaultQueryRetryFn, setQueryDevtoolsAppInfo, setQueryDevtoolsArmedMocksScope, setQueryDevtoolsFault, setQueryDevtoolsFaultResolver, setQueryDevtoolsFaultsScope, setQueryDevtoolsFormLinksFactory, setQueryDevtoolsMockResolver, setQueryDevtoolsOverridePersistence, setQueryDevtoolsOverridesFactory, setQueryDevtoolsOverridesScope, setQueryDevtoolsRegistrar, setQueryDevtoolsResponseHistory, setQueryDevtoolsSchemaLoader, setQueryDevtoolsSettings, setQueryDevtoolsStatsFactory, setQueryDevtoolsTokenPayloadPatcher, setQueryDevtoolsTokenTtl, setupQueryDependencies, setupQueryExecuteState, setupQueryState, shouldAutoExecuteGqlQuery, shouldAutoExecuteQuery, shouldCacheQuery, shouldRetryRequest, silenceMissingWithArgsFeatureErrorUsedButWithArgsPresent, skipPaginationPageParamCalculator, smartDuplicateArrayItem, snapshotQueryDevtoolsHandle, sortQueryField, splitQueryConfig, stringArrayQueryField, stringifyQueryRouteParts, sumQueryDevtoolsStats, suppressNextQueryStackDevtools, switchQueryCollectionState, switchQueryState, symfonyQueryErrorParser, takeUntilResponse, toQuerySignal, toQuerySubject, tokensNotAvailableInsideAuthAndExec, tombstoneOf, transformArrayResponse, transformExecStateToQueryState, transformGql, transformMethod, transformPaginatedResponse, transformToBoolean, transformToBooleanArray, transformToDate, transformToDateArray, transformToNumber, transformToNumberArray, transformToSort, transformToSortQueryParam, transformToString, transformToStringArray, uncacheableRequestHasAllowCacheParam, uncacheableRequestHasCacheKeyParam, unwrapQuerySyncMessage, v2BuildQueryCacheKey, v2ExtractExpiresInSeconds, v2ShouldCacheQuery, v2ShouldRetryRequest, validateWithQuery, validateWithV2Query, withArgs, withArgsQueryFeatureMissingButRouteIsFunction, withAuthenticationQuery, withAutoRefresh, withAutoRefreshUsedInManualQuery, withAutoRefreshUsedOnUnsupportedHttpMethod, withBearerAuthMultiTabSync, withDefaultRetry, withErrorHandling, withEthleteApiErrors, withHtmlErrorParsing, withInactivityLogout, withLogging, withLongPolling, withLongPollingUsedOnUnsupportedHttpMethod, withLongPollingUsedWithPolling, withMultiTabSync, withPageResetOnError, withPersistentAuth, withPolling, withPollingUsedOnUnsupportedHttpMethod, withQueryDevtoolsOverridePersistence, withQueryPersistence, withRefreshQuery, withResponseUpdate, withSuccessHandling, withSymfonyErrors, withTokenExpirationWarning, withTokenRevocation, withTracking, wrapAsObservableSignal, wrapQuerySyncMessage, writeQueryDevtoolsStore };
+export { BasicAuthProvider, BearerAuthFeatureType, BooleanArrayQueryField, CustomHeaderAuthProvider, DEFAULT_KEEP_UNUSED_FOR, DEFAULT_QUERY_PERSISTENCE_MAX_AGE, DEFAULT_QUERY_PERSISTENCE_MAX_ENTRIES, DEFAULT_QUERY_PERSISTENCE_VERSION, DEFAULT_QUERY_PERSISTENCE_WRITE_DELAY, DateArrayQueryField, DateQueryField, EMPTY_QUERY_DEVTOOLS_FAULT, EntityStore, IGNORED_FILTER_COUNT_FIELDS, INFINITY_QUERY_TOKEN, InfinityQuery, InfinityQueryDirective, InfinityQueryTriggerDirective, LegacyQuery, LegacyQueryCreator, MAX_QUERY_BATCH_TOMBSTONES, MAX_QUERY_DEVTOOLS_TOMBSTONES, MAX_UNUSED_ENTRIES, NumberArrayQueryField, ParseHttpErrorCodeToMessageDePipe, ParseHttpErrorCodeToMessageEnPipe, ParseHttpErrorCodeToTitleDePipe, ParseHttpErrorCodeToTitleEnPipe, QUERY_CLIENT_DEVTOOLS_TOKEN, QUERY_DEVTOOLS_FAULT_STATUSES, QUERY_DEVTOOLS_TOKEN_TTL_LIMIT, QUERY_PERSISTENCE_STORE_VERSION, QUERY_SYNC_PROTOCOL_VERSION, QUERY_VERSION, QueryClientFeatureType, QueryDevtoolsComponent, QueryDirective, QueryFeatureType, QueryField, QueryForm, QueryRuntimeErrorCode, QueryShortNamePipe, QueryStore, SERVER_ERROR_KIND, SERVER_VIOLATION_ERROR_KIND, SPEED_BUFFER_TIME_IN_MS, SearchQueryField, SortQueryField, StringArrayQueryField, V2BearerAuthProvider, V2Query, V2QueryClient, V2QueryCreator, addQueryContainerHandling, applyQueryDevtoolsOverrides, applyQueryDevtoolsTokenTtl, applyQueryFeatures, armAllQueryDevtoolsMocks, armQueryDevtoolsMock, armQueryDevtoolsOverrideTransfer, authExtractTokensResponseMissingAccessToken, authExtractTokensResponseMissingRefreshToken, authExtractTokensResponseNotObject, authProviderFeatureUsedMultipleTimes, booleanArrayQueryField, buildQueryCacheKey, buildQueryString, buildRoute, buildTimestampFromSeconds, canOverrideQueryDevtoolsTokenTtl, castQueryCreatorTypes, circularQueryDependency, circularQueryDependencyChecker, clearQueryDevtoolsArmedMocks, clearQueryDevtoolsFaults, clearQueryDevtoolsMockStore, clearQueryDevtoolsOverrideStore, clearQueryDevtoolsStore, clearQueryDevtoolsTokenTtl, clearQueryDevtoolsTombstones, clearRestoredQueryDevtoolsOverrides, collectLeafPaths, collectQueryDevtoolsSchemaComponents, collectQueryFormLinks, computeQueryAuthHeader, computeQueryBody, computeQueryHeaders, computeQueryMethod, computeQueryQueryParams, consumeSuppressQueryStackDevtools, contentfulGqlLikePaginationAdapter, countUnresolvedQueryDevtoolsOverrides, createAuthGuard, createBaseQuery, createBaseQueryCreator, createBearerAuthProvider, createDefaultRetryFn, createDeleteQuery, createExecuteFn, createGetQuery, createGqlExecuteFn, createGqlMutationViaGet, createGqlMutationViaPost, createGqlQuery, createGqlQueryCreator, createGqlQueryViaGet, createGqlQueryViaPost, createHttpRequest, createIndexedDbQueryPersistenceAdapter, createInfinityQueryConfig, createLegacyQueryCreator, createNoopQueryPersistenceAdapter, createPagedQueryStack, createPatchQuery, createPersistentAuthFeature, createPostQuery, createPutQuery, createQuery, createQueryBatch, createQueryClient, createQueryCollection, createQueryCollectionSignal, createQueryCollectionSubject, createQueryContext, createQueryCreator, createQueryDevtoolsFormLinks, createQueryDevtoolsFormLinksRecorder, createQueryDevtoolsOverrides, createQueryDevtoolsOverridesRecorder, createQueryDevtoolsStats, createQueryDevtoolsStatsRecorder, createQueryErrorResponse, createQueryFeature, createQueryInvalidationFilter, createQueryKeyLockManager, createQueryObject, createQueryPersistenceEngine, createQueryRepository, createQuerySnapshotFn, createQueryStack, createQuerySubmission, createQuerySyncEngine, createQuerySyncTransport, createSecureDeleteQuery, createSecureExecuteFactory, createSecureExecuteFn, createSecureGetQuery, createSecureGqlExecuteFn, createSecureGqlMutationViaGet, createSecureGqlMutationViaPost, createSecureGqlQuery, createSecureGqlQueryCreator, createSecureGqlQueryViaGet, createSecureGqlQueryViaPost, createSecurePatchQuery, createSecurePostQuery, createSecurePutQuery, createSecureQuery, createSecureQueryCreator, createTrackingFeature, createWebSocketClient, currentQueryDevtoolsBatch, dateArrayQueryField, dateQueryField, decryptBearer, deepFreeze, def, defineQueryForm, deleteQueryDevtoolsMock, describeQueryDevtoolsFeatures, detectContentTypeHeader, detectPaginationShape, dynLikePaginationAdapter, effectComputed, emptyQueryArgs, ethletePaginationAdapter, executeUntilSettled, extractExpiresInSeconds, extractFormViolations, extractHtmlErrorMessage, extractQuery, fakePaginationAdapter, filterFailure, filterNull, filterQueryStates, filterSuccess, forEachHeader, formatQueryDevtoolsDuration, generateQueryDevtoolsNumberPreset, generateQueryDevtoolsSampleNumber, generateQueryDevtoolsStringPreset, getBearerAuthProviderName, getDefaultHeaders, getQueryClientName, getQueryFeatureUsage, getResponseUrl, ggLikePaginationAdapter, gql, gqlDataPropertyMissingInResponse, hasHeader, hasQueryDevtoolsOverridesAtPath, htmlErrorPayload, htmlQueryErrorParser, ignoreAutoRefresh, initQueryDevtoolsFaults, initQueryDevtoolsMocks, initQueryDevtoolsOverridePersistence, initQueryDevtoolsSettings, injectInfinityQueryResponseDelay, injectQueryContext, insertFrom, invalidBaseRouteError, invalidBodyError, invalidRouteError, invalidStateInsideSecureExecuteFactory, isAutoRefresh, isBasicAuthProvider, isBearerAuthProvider, isClassValidatorError, isCreateGqlQueryOptions, isCustomHeaderAuthProvider, isDateShapedLeaf, isEmptyString, isGqlQueryConfig, isHtmlErrorPayload, isLegacyQuery, isNaN$1 as isNaN, isPageOutOfRangeError, isQuery, isQueryCollection, isQueryDevtoolsEnabled, isQueryDevtoolsFaultArmed, isQueryDevtoolsRequestInterceptionEnabled, isQueryErrorResponse, isQueryStateCancelled, isQueryStateFailure, isQueryStateLoading, isQueryStatePrepared, isQueryStateSuccess, isRequestError, isSymfonyError, isSymfonyFormViolationListError, isSymfonyListError, isSymfonyPagerfantaOutOfRangeError, isUnderInvalidatedUrl, legacyPrepareFallbackInjector, legacyPrepareWithoutInjectionContext, loadQueryDevtoolsSchema, mapToPaginated, mapViolationsToFormErrors, matchesQueryDevtoolsMockPattern, matchesQueryDevtoolsMockQuery, maybeExecute, measureQueryDevtoolsPayload, mergeHeaders, nestedEffect, noteQueryFormRead, numberArrayQueryField, pagedQueryStackNextPageCalledWithoutPreviousPage, pagedQueryStackPageBiggerThanTotalPages, pagedQueryStackPreviousPageCalledButAlreadyAtFirstPage, paginatedEntityValueUpdater, parseAllXhrResponseHeaders, parseHttpErrorCodeToMessageDe, parseHttpErrorCodeToMessageEn, parseHttpErrorCodeToTitleDe, parseHttpErrorCodeToTitleEn, parseQueryDevtoolsOverrideTransfer, parseQueryRoute, patchQueryDevtoolsTokenPayload, pathParamsMissingInRouteFunctionError, provideInfinityQueryResponseDelay, provideLegacyPrepareFallback, provideQueryClientForDevtools, provideQueryDevtools, queryArrayComputed, queryBatchAlreadyRunning, queryBatchWithArgsUsed, queryClientFeatureUsedMultipleTimes, queryComputed, queryComputedTillTruthy, queryDevtoolsAbout, queryDevtoolsArmedMocks, queryDevtoolsArmedMocksRestored, queryDevtoolsEntries, queryDevtoolsFaults, queryDevtoolsFaultsRestored, queryDevtoolsFnDetail, queryDevtoolsMockId, queryDevtoolsMocks, queryDevtoolsOverridePersistence, queryDevtoolsRequestPath, queryDevtoolsResponseHistory, queryDevtoolsRestoredOverridesScope, queryDevtoolsSchemaNames, queryDevtoolsSchemaRoutes, queryDevtoolsSchemaState, queryDevtoolsSettings, queryDevtoolsStorage, queryDevtoolsTokenTtls, queryErrorMessage, queryErrorMessages, queryExecute, queryFeatureUsedMultipleTimes, queryField, querySequence, querySequenceAlreadyRunning, queryStackTotalQueriesAndExpectedQueriesMismatch, queryStackWithArgsUsed, queryStackWithResponseUpdateUsed, queryStateAlreadyHasKeyError, queryStateCannotTransformError, queryStateDoesNotContainKeyError, queryStateErrorSignal, queryStateLoadingSignal, queryStateResponseSignal, queryStateSignal, readQueryDevtoolsStore, registerEthleteVersion, registerQueryDevtoolsEntry, registerQueryErrorParser, removeFrom, request, resetExecuteState, resetPageOnError, resolveInvalidationUrl, resolveQueryDevtoolsFault, resolveQueryDevtoolsFaultForAttempt, resolveQueryDevtoolsMock, resolveQueryDevtoolsMockForAttempt, restoredQueryDevtoolsOverrides, runDefaultQueryRetry, runInQueryDevtoolsBatch, runQueryErrorParsers, saveQueryDevtoolsMock, searchQueryField, seedQueryDevtoolsSchemaBody, seedQueryDevtoolsSchemaRoute, serializeBody, serializeQueryDevtoolsOverrideTransfer, setDefaultQueryRetryFn, setQueryDevtoolsAppInfo, setQueryDevtoolsArmedMocksScope, setQueryDevtoolsFault, setQueryDevtoolsFaultResolver, setQueryDevtoolsFaultsScope, setQueryDevtoolsFormLinksFactory, setQueryDevtoolsMockResolver, setQueryDevtoolsOverridePersistence, setQueryDevtoolsOverridesFactory, setQueryDevtoolsOverridesScope, setQueryDevtoolsRegistrar, setQueryDevtoolsResponseHistory, setQueryDevtoolsSchemaLoader, setQueryDevtoolsSettings, setQueryDevtoolsStatsFactory, setQueryDevtoolsTokenPayloadPatcher, setQueryDevtoolsTokenTtl, setupQueryDependencies, setupQueryExecuteState, setupQueryState, shouldAutoExecuteGqlQuery, shouldAutoExecuteQuery, shouldCacheQuery, shouldRetryRequest, silenceMissingWithArgsFeatureErrorUsedButWithArgsPresent, skipPaginationPageParamCalculator, smartDuplicateArrayItem, snapshotQueryDevtoolsHandle, sortQueryField, splitQueryConfig, stringArrayQueryField, stringifyQueryRouteParts, sumQueryDevtoolsStats, suppressNextQueryStackDevtools, switchQueryCollectionState, switchQueryState, symfonyQueryErrorParser, takeUntilResponse, toQuerySignal, toQuerySubject, tokensNotAvailableInsideAuthAndExec, tombstoneOf, transformArrayResponse, transformExecStateToQueryState, transformGql, transformMethod, transformPaginatedResponse, transformToBoolean, transformToBooleanArray, transformToDate, transformToDateArray, transformToNumber, transformToNumberArray, transformToSort, transformToSortQueryParam, transformToString, transformToStringArray, uncacheableRequestHasAllowCacheParam, uncacheableRequestHasCacheKeyParam, unwrapQuerySyncMessage, v2BuildQueryCacheKey, v2ExtractExpiresInSeconds, v2ShouldCacheQuery, v2ShouldRetryRequest, validateWithQuery, validateWithV2Query, withArgs, withArgsQueryFeatureMissingButRouteIsFunction, withAuthenticationQuery, withAutoRefresh, withAutoRefreshUsedInManualQuery, withAutoRefreshUsedOnUnsupportedHttpMethod, withBearerAuthMultiTabSync, withDefaultRetry, withErrorHandling, withEthleteApiErrors, withHtmlErrorParsing, withInactivityLogout, withLogging, withLongPolling, withLongPollingUsedOnUnsupportedHttpMethod, withLongPollingUsedWithPolling, withMultiTabSync, withPageResetOnError, withPersistentAuth, withPolling, withPollingUsedOnUnsupportedHttpMethod, withQueryDevtoolsOverridePersistence, withQueryPersistence, withRefreshQuery, withResponseUpdate, withSuccessHandling, withSymfonyErrors, withTokenExpirationWarning, withTokenRevocation, withTracking, wrapAsObservableSignal, wrapQuerySyncMessage, writeQueryDevtoolsStore };
 //# sourceMappingURL=ethlete-query.mjs.map