@ethlete/query-devtools 1.0.0-next.1 → 1.0.0-next.11

package/package.json

@@ -1,13 +1,13 @@
 {
   "name": "@ethlete/query-devtools",
-  "version": "1.0.0-next.1",
+  "version": "1.0.0-next.11",
   "license": "MIT",
   "sideEffects": false,
   "peerDependencies": {
     "@analogjs/vitest-angular": "2.6.3",
-    "@angular/common": "22.0.7",
-    "@angular/compiler": "22.0.7",
-    "@angular/core": "22.0.7",
+    "@angular/common": "22.1.6",
+    "@angular/compiler": "22.1.6",
+    "@angular/core": "22.1.6",
     "@ethlete/components": "^1.0.0-next.42",
     "@ethlete/core": "^5.0.0-beta.11",
     "@ethlete/query": "^6.0.0-beta.8",

package/types/ethlete-query-devtools-lazy.d.ts

@@ -5,6 +5,9 @@ import * as _angular_core from '@angular/core';
  * first asked for, then downloads `<et-query-devtools>` as its own chunk and hands over. Use it instead
  * of `<et-query-devtools>` to keep the panel out of the bundle an application ships to its users.
  *
+ * Without `provideQueryDevtools()` it renders nothing at all - no toggle, no shortcut, and the panel
+ * chunk is never requested - so it can be left mounted in a production build.
+ *
  * Everything else is identical - the same toggle, the same `Ctrl/Cmd + Alt + Q` shortcut, and a panel
  * that was open when the tab last stored its state comes back open without a click.
  *
@@ -16,10 +19,15 @@ import * as _angular_core from '@angular/core';
 declare class QueryDevtoolsLazyComponent {
     private document;
     /**
-     * Whether the panel was already open in this tab. It has to be answered before the panel exists, which
-     * is why the stored view state is read here rather than asked of the panel.
+     * Whether `provideQueryDevtools()` is in the application. Everything else here is gated on it - the
+     * stored view state read, the shortcut listener and the template - so a build that ships the shell
+     * without the provider renders nothing and can never load the panel.
+     */
+    protected enabled: boolean;
+    /**
+     * Whether the panel is wanted. Whether it was already open has to be answered before the panel exists,
+     * which is why the stored view state is read here rather than asked of the panel.
      */
-    private restoredOpen;
     protected load: _angular_core.WritableSignal<boolean>;
     /** A restored panel opens because it was open; one that was clicked open has to be told to. */
     protected openOnLoad: _angular_core.WritableSignal<boolean>;

package/types/ethlete-query-devtools-toggle.d.ts

@@ -12,6 +12,10 @@ declare const queryDevtoolsShortcutLabel: () => "⌘⌥Q" | "Ctrl+Alt+Q";
  * host application's global CSS (Tailwind resets, button styles, …) can never touch it and its own
  * styles can never leak out. Uses px (not rem) internally so it doesn't depend on the host's root
  * font-size; theme accent colour is read from an inherited custom property with a fallback.
+ *
+ * Mounted on its own - without `<et-query-devtools-lazy>` or `<et-query-devtools>` - it declares no
+ * devtools UI, so the floating API env and session pills take themselves off the page once the
+ * application settles. Call `setQueryDevtoolsUiMounted(true)` to keep them.
  */
 declare class QueryDevtoolsToggleComponent {
     tampered: _angular_core.InputSignal<boolean>;

package/types/ethlete-query-devtools.d.ts

@@ -1,7 +1,7 @@
 import * as _angular_core from '@angular/core';
 import { Signal, WritableSignal, OnInit } from '@angular/core';
 import * as _ethlete_query from '@ethlete/query';
-import { JsonPath, QueryDevtoolsOverridesRecorder, QueryRefreshCause, QueryRepositoryEntryDestroyedCause, Query, QueryRepositoryCacheEntry, HttpRequestRetryState, HttpRequestLoadingProgressState, QueryDevtoolsStats, QueryDevtoolsStatsHandle, QueryDevtoolsEntry, QueryRepository, QueryClient, QueryKeyLockState, QueryDevtoolsFeature, QueryDevtoolsFault, AnyQueryStack, AnyPagedQueryStack, QuerySequence, AnyBearerAuthProvider, WebSocketDevtoolsHandle, QueryDevtoolsFormHandle, QuerySequenceStatus, AnyQuerySnapshot, QueryDevtoolsRun, QueryDevtoolsRunError, WebSocketDevtoolsMessage, QueryDevtoolsStorageScope } from '@ethlete/query';
+import { JsonPath, QueryDevtoolsOverridesRecorder, QueryRefreshCause, QueryRepositoryEntryDestroyedCause, Query, QueryRepositoryCacheEntry, HttpRequestRetryState, HttpRequestLoadingProgressState, QueryDevtoolsStats, QueryDevtoolsStatsHandle, QueryDevtoolsEntry, AnyQueryBatchItemResult, QueryRepository, QueryClient, QueryKeyLockState, QueryDevtoolsFeature, QueryDevtoolsFault, AnyQueryStack, AnyPagedQueryStack, QuerySequence, AnyQueryBatch, AnyBearerAuthProvider, WebSocketDevtoolsHandle, QueryDevtoolsFormHandle, QuerySequenceStatus, AnyQuerySnapshot, QueryDevtoolsRun, QueryDevtoolsRunError, WebSocketDevtoolsMessage, QueryDevtoolsStorageScope, QueryDevtoolsApiEnvSwitch } from '@ethlete/query';
 import { ResizeEdge, DragMoveEvent, ResizeMoveEvent } from '@ethlete/core';
 
 type AboutRow = {
@@ -19,6 +19,8 @@ type AboutGroup = {
 declare class QueryDevtoolsAboutComponent {
     protected readonly groups: AboutGroup[];
     protected copied: _angular_core.WritableSignal<boolean>;
+    private copiedReset$;
+    constructor();
     protected copy(): void;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<QueryDevtoolsAboutComponent, never>;
     static ɵcmp: _angular_core.ɵɵComponentDeclaration<QueryDevtoolsAboutComponent, "et-query-devtools-about", never, {}, {}, never, never, true, never>;
@@ -82,7 +84,10 @@ declare class QueryDevtoolsJsonComponent {
     private shapePath;
     protected annotation: _angular_core.Signal<string | null>;
     protected annotationTitle: _angular_core.Signal<string>;
-    /** A `Date` or a `File` is object-typed but has nothing to expand into, so it renders as a leaf. */
+    /**
+     * A `Date` is object-typed but has nothing to expand into, so it renders as a leaf. A resolved
+     * header provider is the other way round: a function that does expand.
+     */
     protected isContainer: _angular_core.Signal<boolean>;
     /** The entries this node covers: the container's own, or just the window a chunk stands for. */
     ownEntries: _angular_core.Signal<JsonEntry[]>;
@@ -93,7 +98,7 @@ declare class QueryDevtoolsJsonComponent {
     private togglePath;
     private defaultExpanded;
     private localExpanded;
-    protected expanded: _angular_core.Signal<boolean>;
+    private expanded;
     /** Only slices that actually contain a match unfold while searching, so a filter stays cheap. */
     private chunkHasHit;
     protected effectiveExpanded: _angular_core.Signal<boolean>;
@@ -202,7 +207,7 @@ type QueryDevtoolsSelection = {
  * to count, so the badge/overflow logic would push it behind **More** - it is reached from the header's
  * gear instead.
  */
-type DevtoolsTab = 'queries' | 'stacks' | 'sequences' | 'forms' | 'auth' | 'ws' | 'cache' | 'locks' | 'timeline' | 'events' | 'faults' | 'mocks' | 'about' | 'settings';
+type DevtoolsTab = 'queries' | 'stacks' | 'sequences' | 'batches' | 'forms' | 'auth' | 'ws' | 'cache' | 'locks' | 'timeline' | 'events' | 'faults' | 'mocks' | 'about' | 'settings';
 /**
  * The sections of the query detail drawer. The head and its actions stay pinned above them - the detail
  * holds more than fits a column, and everything below the actions is reading material.
@@ -261,6 +266,20 @@ type QueryLink = {
     clientBaseUrl: string;
     stats?: QueryDevtoolsStatsHandle;
 };
+/** One settled item of a query batch, with the route the args it was sent with resolve to. */
+type BatchItemRow = {
+    result: AnyQueryBatchItemResult;
+    segments: RouteSegment[];
+};
+/**
+ * A batch's settled items as its card lists them. Capped, and `hidden` says by how much - a bulk run
+ * settles more items than a list can hold, and a truncated one must not read as the whole run.
+ */
+type BatchItemView = {
+    rows: BatchItemRow[];
+    total: number;
+    hidden: number;
+};
 /**
  * Query stats plus the numbers the panel derives from them rather than storing: an execution that never
  * reached the network was answered from the cache, and the averages come from the running totals.
@@ -391,6 +410,7 @@ type QueryDevtoolsHost = {
     queryEntries: Signal<QueryDevtoolsEntry[]>;
     stackEntries: Signal<QueryDevtoolsEntry[]>;
     sequenceEntries: Signal<QueryDevtoolsEntry[]>;
+    batchEntries: Signal<QueryDevtoolsEntry[]>;
     formEntries: Signal<QueryDevtoolsEntry[]>;
     authEntries: Signal<QueryDevtoolsEntry[]>;
     wsEntries: Signal<QueryDevtoolsEntry[]>;
@@ -450,6 +470,7 @@ type QueryDevtoolsHost = {
     asStack(entry: QueryDevtoolsEntry): AnyQueryStack;
     asPagedStack(entry: QueryDevtoolsEntry): AnyPagedQueryStack;
     asSequence(entry: QueryDevtoolsEntry): QuerySequence<unknown[]>;
+    asBatch(entry: QueryDevtoolsEntry): AnyQueryBatch;
     asAuth(entry: QueryDevtoolsEntry): AnyBearerAuthProvider;
     asWs(entry: QueryDevtoolsEntry): WebSocketDevtoolsHandle;
     asForm(entry: QueryDevtoolsEntry): QueryDevtoolsFormHandle;
@@ -475,6 +496,11 @@ type QueryDevtoolsHost = {
     requestUrl(query: AnyQuery): string | null;
     requestPath(url: string): string;
     queryArgs(query: AnyQuery): unknown;
+    /**
+     * The headers the query's last run sent, or - before it has run - the ones its args and its client
+     * resolve to now. `null` when there are none, or while a header provider cannot resolve yet.
+     */
+    requestHeaders(query: AnyQuery): Record<string, string> | null;
     routeSegments(entry: QueryDevtoolsEntry | undefined, query: AnyQuery): RouteSegment[];
     queryActivity(entry: QueryDevtoolsEntry): QueryActivity;
     linkActivity(link: QueryLink): QueryActivity;
@@ -492,6 +518,30 @@ type QueryDevtoolsHost = {
     /** Whether a sequence step's in/out detail (`<entryId>:<stepIndex>`) is expanded - persisted. */
     isStepExpanded(entryId: string, index: number): boolean;
     toggleStep(entryId: string, index: number): void;
+    /** A batch's route with its path params left as `:name` - a batch fills them in per item, not once. */
+    batchRouteSegments(entry: QueryDevtoolsEntry): RouteSegment[];
+    /**
+     * The batch entry that created a query, or `null` for a query no batch did. What lets the Queries list
+     * fold a bulk run's items under one row instead of listing whatever it has in flight.
+     */
+    batchOf(entry: QueryDevtoolsEntry): QueryDevtoolsEntry | null;
+    /**
+     * The item queries a batch has in flight. Only those: a batch destroys each item's query the moment
+     * that item settles, so a settled item is read from {@link batchItems} instead.
+     */
+    queriesForBatch(entry: QueryDevtoolsEntry): QueryLink[];
+    /** A batch's settled items, failures first and capped - see {@link BatchItemView}. */
+    batchItems(entry: QueryDevtoolsEntry): BatchItemView;
+    /**
+     * The registry entry of one of a batch's items, or `null` once it has fallen out of the batch's capped
+     * tombstone tail - which is what makes an item row openable only while its query is still kept.
+     */
+    batchItemQueryId(entry: QueryDevtoolsEntry, index: number): string | null;
+    /** An item's throughput line (`12.4 items/s · ~8s left`), or `null` before there is a rate to show. */
+    batchThroughput(batch: AnyQueryBatch): string | null;
+    /** Whether a batch item's args/response detail (`<entryId>:<itemIndex>`) is expanded - persisted. */
+    isBatchItemExpanded(entryId: string, index: number): boolean;
+    toggleBatchItem(entryId: string, index: number): void;
     /** Keys of the Queries-list groups of identical rows the user opened - persisted. */
     expandedQueryGroups: Signal<ReadonlySet<string>>;
     toggleQueryGroup(key: string): void;
@@ -632,6 +682,16 @@ type QueryDevtoolsHost = {
         entry: QueryDevtoolsEntry;
         query: AnyQuery;
     } | null>;
+    batchSelectedQueryId: WritableSignal<string | null>;
+    batchSelectedQuery: Signal<{
+        entry: QueryDevtoolsEntry;
+        query: AnyQuery;
+    } | null>;
+    eventSelectedQueryId: WritableSignal<string | null>;
+    eventSelectedQuery: Signal<{
+        entry: QueryDevtoolsEntry;
+        query: AnyQuery;
+    } | null>;
     formSelectedQueryId: WritableSignal<string | null>;
     formSelectedQuery: Signal<{
         entry: QueryDevtoolsEntry;
@@ -661,6 +721,12 @@ type QueryDevtoolsHost = {
         entry: QueryDevtoolsEntry;
         query: AnyQuery;
     } | null>;
+    /**
+     * The type annotations of each seeded mock body, by mock id. A mock only stores the *name* it was
+     * seeded from, and a body seeded from an inline schema has none, so this is the only thing that can
+     * label such a body - and it has to outlive the Mocks tab being switched away from.
+     */
+    seededTypes: WritableSignal<Record<string, ReadonlyMap<string, string>>>;
     paneAxis: Signal<PaneAxis>;
     listWidth: Signal<number | null>;
     drawerWidth: Signal<number | null>;
@@ -673,7 +739,7 @@ type QueryDevtoolsHost = {
     resetPaneSize(pane: PaneTarget): void;
 };
 
-type ScopeKey = 'viewState' | 'pins' | 'overrides' | 'mocks' | 'armedMocks' | 'armedFaults';
+type ScopeKey = 'viewState' | 'pins' | 'overrides' | 'mocks' | 'armedMocks' | 'armedFaults' | 'authSessions';
 type ScopeRow = {
     key: ScopeKey;
     label: string;
@@ -702,6 +768,7 @@ type LimitRow = {
  * otherwise hold as constants, and the toggles their own tabs also carry.
  */
 declare class QueryDevtoolsSettingsComponent {
+    private document;
     protected host: QueryDevtoolsHost;
     protected readonly SCOPE_ROWS: ScopeRow[];
     protected readonly SCOPES: {
@@ -716,14 +783,36 @@ declare class QueryDevtoolsSettingsComponent {
     /** What queries actually retain, which is the application's value unless this panel raised it. */
     protected responseHistory: _angular_core.Signal<number>;
     protected mockCount: _angular_core.Signal<number>;
+    protected sessionCount: _angular_core.Signal<number>;
     protected armedMockCount: _angular_core.Signal<number>;
     protected armedFaultCount: _angular_core.Signal<number>;
+    /** The same keys the Events tab's own picker offers - see {@link queryDevtoolsEventClients}. */
+    protected eventClients: _angular_core.Signal<string[]>;
     protected resetConfirming: _angular_core.WritableSignal<boolean>;
+    protected readonly FORGET_SESSIONS: () => void;
+    /** The backends the application declared, or an empty list - the card renders only for a declared one. */
+    protected apiEnvs: _angular_core.Signal<QueryDevtoolsApiEnvSwitch[]>;
+    /** The env id (or typed URL) a switch's key holds, or `null` while the application picks for itself. */
+    protected apiEnvValue(apiSwitch: QueryDevtoolsApiEnvSwitch): string | null;
+    /** The env a switch falls back to with nothing stored, described for the default button. */
+    protected apiEnvFallback(apiSwitch: QueryDevtoolsApiEnvSwitch): {
+        label: string;
+        production: boolean;
+    };
+    /** Whether the pick in force - the stored env, or the fallback behind an unwritten key - is production. */
+    protected apiEnvIsProduction(apiSwitch: QueryDevtoolsApiEnvSwitch): boolean;
+    /** A stored value no declared env carries, which is a URL somebody typed in below. */
+    protected apiEnvCustomUrl(apiSwitch: QueryDevtoolsApiEnvSwitch): string;
+    /** Writes the application's own key and reloads - it is read before Angular boots, so nothing else can. */
+    protected pickApiEnv(apiSwitch: QueryDevtoolsApiEnvSwitch, value: string | null): void;
+    protected setCustomApiUrl(apiSwitch: QueryDevtoolsApiEnvSwitch, value: string): void;
     protected settings(): _ethlete_query.QueryDevtoolsSettings;
     protected scopeOf(key: ScopeKey): QueryDevtoolsStorageScope;
     protected limitOf(key: LimitKey): number;
     /** What the picked scope means beyond where the state is kept, or `null` while it means nothing extra. */
     protected warningFor(row: ScopeRow, scope: QueryDevtoolsStorageScope): string | null;
+    /** Why one scope is not on offer for a row, for the button's title, or `null` while it is. */
+    protected unavailableReason(row: ScopeRow, scope: QueryDevtoolsStorageScope): "Unavailable outside a development build: live access and refresh tokens, and the credentials you typed in, must not outlive this tab on a deployed origin. Session keeps the vault for as long as the tab." | null;
     protected setScope(key: ScopeKey, scope: QueryDevtoolsStorageScope): void;
     protected setLimit(key: LimitKey, value: string): void;
     protected setResponseHistory(value: string): void;
@@ -761,21 +850,6 @@ type FloatRect = {
     width: number;
     height: number;
 };
-/**
- * A drag in progress: the panel's docked edge, the floating panel being moved or resized, or the
- * divider between a two-pane tab's panes.
- */
-type ResizeDrag = {
-    /** The document the pointer moves in - a popped-out panel lives in a window of its own. */
-    doc: Document;
-} & ({
-    kind: 'panel';
-} | {
-    kind: 'pane';
-    pane: PaneTarget;
-    axis: PaneAxis;
-    container: HTMLElement;
-});
 type PersistedState = {
     open?: boolean;
     height?: number;
@@ -785,12 +859,19 @@ type PersistedState = {
     listHeight?: number | null;
     drawerHeight?: number | null;
     dock?: DevtoolsDock;
+    reservesSpace?: boolean;
     floatRect?: FloatRect;
     floatParked?: boolean;
     activeTab?: DevtoolsTab;
     detailTab?: DetailTab;
     selectedClientName?: string | null;
     selectedQueryId?: string | null;
+    stackSelectedQueryId?: string | null;
+    sequenceSelectedQueryId?: string | null;
+    batchSelectedQueryId?: string | null;
+    eventSelectedQueryId?: string | null;
+    formSelectedQueryId?: string | null;
+    timelineSelectedQueryId?: string | null;
     selectedFormId?: string | null;
     inspectFilterIds?: string[] | null;
     queryFilter?: string;
@@ -803,6 +884,7 @@ type PersistedState = {
     socketFilter?: string;
     jsonSearch?: string;
     expandedSteps?: string[];
+    expandedBatchItems?: string[];
     expandedQueryGroups?: string[];
     jsonExpanded?: string[];
     jsonCollapsed?: string[];
@@ -875,6 +957,9 @@ declare class QueryDevtoolsComponent implements OnInit {
     } | {
         id: "sequences";
         label: string;
+    } | {
+        id: "batches";
+        label: string;
     } | {
         id: "forms";
         label: string;
@@ -956,7 +1041,7 @@ declare class QueryDevtoolsComponent implements OnInit {
     protected drawerWidth: WritableSignal<number | null>;
     protected listHeight: WritableSignal<number | null>;
     protected drawerHeight: WritableSignal<number | null>;
-    protected drag: WritableSignal<ResizeDrag | null>;
+    private drag;
     protected resizing: _angular_core.Signal<boolean>;
     /** Which edge the panel is docked to, or `float` for a window of its own inside the page. */
     protected dock: WritableSignal<DevtoolsDock>;
@@ -992,6 +1077,11 @@ declare class QueryDevtoolsComponent implements OnInit {
         readonly label: "Pop out";
         readonly hint: "Move the panel into a window of its own - the same live panel, on your other screen";
     }>;
+    /**
+     * Whether a docked panel takes its size out of the page instead of covering it - so the last rows of a
+     * long page can still be scrolled to. Only docks can: a float sits wherever it was dragged.
+     */
+    protected reservesSpace: WritableSignal<boolean>;
     /** Where the floating panel sits and how big it is. Kept while docked, so a return to float restores it. */
     private floatRect;
     /** The rect a resize gesture started from, or `null` outside one. */
@@ -1029,14 +1119,36 @@ declare class QueryDevtoolsComponent implements OnInit {
     /** The floating panel's offset from the viewport's top-left, or `null` while it is docked. */
     protected panelInsetBlock: _angular_core.Signal<number | null>;
     protected panelInsetInline: _angular_core.Signal<number | null>;
+    /**
+     * The panel's rendered size, not its dragged one - the stylesheet clamps a dock (`min-block-size`,
+     * `max-block-size: 90vh`) and it is the clamped size the page has to give up.
+     */
+    private panelSize;
+    /** Which padding a docked panel asks of the page and how much, or `null` when it asks for none. */
+    private pageReservation;
+    /**
+     * The viewport edge a docked panel covers, reserved for overlays whatever {@link reservesSpace} says:
+     * page content can be scrolled out from under the panel, a dialog or a menu cannot. A dock edge is
+     * logical, so which physical edge a side dock covers flips in RTL - read from the panel, since the
+     * writing direction cannot change under a dock switch.
+     */
+    private overlayReservation;
     /** Which section of the query detail is showing. Shared by the Queries tab and both drawers. */
     detailTab: WritableSignal<DetailTab>;
     selectedClientName: WritableSignal<string | null>;
     selectedQueryId: WritableSignal<string | null>;
     /** The form whose detail the Forms tab has expanded. */
     selectedFormId: WritableSignal<string | null>;
+    /**
+     * The type annotations of each seeded mock body, by mock id. It lives here rather than on the Mocks
+     * tab because a tab is destroyed the moment another one is selected, and a body seeded from an inline
+     * schema has no `schemaName` to recover its labels from.
+     */
+    seededTypes: WritableSignal<Record<string, ReadonlyMap<string, string>>>;
     stackSelectedQueryId: WritableSignal<string | null>;
     sequenceSelectedQueryId: WritableSignal<string | null>;
+    batchSelectedQueryId: WritableSignal<string | null>;
+    eventSelectedQueryId: WritableSignal<string | null>;
     formSelectedQueryId: WritableSignal<string | null>;
     timelineSelectedQueryId: WritableSignal<string | null>;
     /** Free-text narrowing of the Queries list. Every whitespace-separated term has to match. */
@@ -1082,6 +1194,8 @@ declare class QueryDevtoolsComponent implements OnInit {
     private socketEmitError;
     /** Keys (`<entryId>:<stepIndex>`) of the sequence steps whose in/out detail is expanded. */
     private expandedSteps;
+    /** Keys (`<entryId>:<itemIndex>`) of the batch items whose args/response detail is expanded. */
+    private expandedBatchItems;
     /** Keys of the Queries-list groups the user opened - the tab is rebuilt on every switch back. */
     expandedQueryGroups: WritableSignal<ReadonlySet<string>>;
     /** Shared value-explorer search term. */
@@ -1122,7 +1236,12 @@ declare class QueryDevtoolsComponent implements OnInit {
     copiedGql: WritableSignal<boolean>;
     copiedRoute: WritableSignal<boolean>;
     private copiedReset$;
-    /** 1-second tick driving the cache freshness countdowns. */
+    /**
+     * 1-second tick driving the cache freshness countdowns. Gated the way the locks poll is: an ungated
+     * `interval` is a periodic macrotask zone.js counts forever, so a mounted panel would tick the host
+     * application once a second and keep `ApplicationRef.whenStable()` from ever resolving. Every reader
+     * sits inside `@if (open())`, so there is nothing to drive while the panel is shut or the tab hidden.
+     */
     private clock;
     /**
      * The probe lock behind every Locks row's "this tab" answer, and the last snapshot read through it.
@@ -1135,7 +1254,8 @@ declare class QueryDevtoolsComponent implements OnInit {
     lockRows: _angular_core.Signal<DevtoolsLockRow[] | null>;
     /** "Inspect" mode: hover the live UI to find the query that a component created. */
     protected inspectActive: WritableSignal<boolean>;
-    protected inspectHover: WritableSignal<{
+    /** @internal */
+    inspectHover: WritableSignal<{
         rect: DOMRect;
         entries: QueryDevtoolsEntry[];
     } | null>;
@@ -1155,12 +1275,17 @@ declare class QueryDevtoolsComponent implements OnInit {
     protected panelTampered: _angular_core.Signal<boolean>;
     stackEntries: _angular_core.Signal<QueryDevtoolsEntry[]>;
     sequenceEntries: _angular_core.Signal<QueryDevtoolsEntry[]>;
+    batchEntries: _angular_core.Signal<QueryDevtoolsEntry[]>;
     formEntries: _angular_core.Signal<QueryDevtoolsEntry[]>;
     authEntries: _angular_core.Signal<QueryDevtoolsEntry[]>;
     wsEntries: _angular_core.Signal<QueryDevtoolsEntry[]>;
     /** Unique client names present across queries and auth providers, for the Queries-tab picker. */
     clientNames: _angular_core.Signal<string[]>;
-    /** Unique repositories (with their client name + base URL) used by the Cache and Events tabs. */
+    /**
+     * Unique repositories (with their client name + base URL) used by the Cache and Events tabs. A
+     * tombstone keeps its `meta.repository`, so a destroyed client would otherwise keep its Cache card
+     * and its **Evict all** long after its injector died.
+     */
     private repositories;
     /**
      * Every client the Faults tab can arm, with the fault it currently carries. Clients with nothing armed
@@ -1212,6 +1337,9 @@ declare class QueryDevtoolsComponent implements OnInit {
     } | {
         id: "sequences";
         label: string;
+    } | {
+        id: "batches";
+        label: string;
     } | {
         id: "forms";
         label: string;
@@ -1253,6 +1381,9 @@ declare class QueryDevtoolsComponent implements OnInit {
     } | {
         id: "sequences";
         label: string;
+    } | {
+        id: "batches";
+        label: string;
     } | {
         id: "forms";
         label: string;
@@ -1296,6 +1427,14 @@ declare class QueryDevtoolsComponent implements OnInit {
         entry: QueryDevtoolsEntry;
         query: AnyQuery;
     } | null>;
+    batchSelectedQuery: _angular_core.Signal<{
+        entry: QueryDevtoolsEntry;
+        query: AnyQuery;
+    } | null>;
+    eventSelectedQuery: _angular_core.Signal<{
+        entry: QueryDevtoolsEntry;
+        query: AnyQuery;
+    } | null>;
     formSelectedQuery: _angular_core.Signal<{
         entry: QueryDevtoolsEntry;
         query: AnyQuery;
@@ -1422,7 +1561,20 @@ declare class QueryDevtoolsComponent implements OnInit {
      * query) never writes them to its own `args` signal - only the `withArgs` feature does - so the args
      * its current request was built from stand in.
      */
-    queryArgs(query: AnyQuery): Omit<any, "response"> | null;
+    queryArgs(query: AnyQuery): Omit<any, "response" | "rawResponse"> | null;
+    /**
+     * The headers a query's request carries, as a plain `name: value` record, or `null` for a query that
+     * has none the panel can read. The set the last run sent, so it stays readable after the token it
+     * used was replaced; for a query that has not run, what its current args and its client resolve to
+     * now. `null` while a header provider throws - a secure query's needs an access token.
+     *
+     * The args tree cannot answer this on its own: a `withArgs` query reads its args from the feature's
+     * source, which the secure `Authorization` provider is never written back to, and client-level
+     * headers are merged in per execution rather than being part of the args at all.
+     */
+    requestHeaders(query: AnyQuery): {
+        [k: string]: string;
+    } | null;
     queryStatus(query: AnyQuery): QueryStatus;
     /**
      * A request in flight is already refreshing, so reporting it as stale on top of `loading` is noise -
@@ -1460,7 +1612,7 @@ declare class QueryDevtoolsComponent implements OnInit {
      * What a run's status dot and timeline bar colour by. `pending` reuses the panel's loading colour;
      * `aborted` matches no rule and so falls back to the neutral one.
      */
-    runStatus(run: QueryDevtoolsRun): "error" | "loading" | "success" | "aborted";
+    runStatus(run: QueryDevtoolsRun): "loading" | "success" | "error" | "aborted";
     /**
      * Whether a run can be an end of the diff: it still holds its body, and so does some other run of the
      * same query. Deliberately not "an *older* run" - a free pair means the oldest body held is pickable
@@ -1553,8 +1705,8 @@ declare class QueryDevtoolsComponent implements OnInit {
      * holds, the event log, the cache totals and anything armed in the Faults tab. Unlike **Copy report**
      * this is not scoped to one query - it is the attachment for a bug report about a screen.
      *
-     * Deliberately unfiltered: a report is read by someone who was not there, and a dump that silently
-     * left out the client you were not looking at is worse than no dump.
+     * Deliberately unfiltered apart from credentials: a report is read by someone who was not there, and a
+     * dump that silently left out the client you were not looking at is worse than no dump.
      */
     protected downloadSession(): void;
     openResponseEditor(query: AnyQuery): void;
@@ -1598,6 +1750,7 @@ declare class QueryDevtoolsComponent implements OnInit {
     asStack(entry: QueryDevtoolsEntry): AnyQueryStack;
     asPagedStack(entry: QueryDevtoolsEntry): AnyPagedQueryStack;
     asSequence(entry: QueryDevtoolsEntry): QuerySequence<unknown[]>;
+    asBatch(entry: QueryDevtoolsEntry): AnyQueryBatch;
     asAuth(entry: QueryDevtoolsEntry): AnyBearerAuthProvider;
     asWs(entry: QueryDevtoolsEntry): WebSocketDevtoolsHandle;
     /**
@@ -1662,6 +1815,19 @@ declare class QueryDevtoolsComponent implements OnInit {
     expandQueryGroup(key: string): void;
     isStepExpanded(entryId: string, index: number): boolean;
     toggleStep(entryId: string, index: number): void;
+    /** A batch's route with its path params left as `:name` - a batch fills them in per item, not once. */
+    batchRouteSegments(entry: QueryDevtoolsEntry): RouteSegment[];
+    batchOf(entry: QueryDevtoolsEntry): QueryDevtoolsEntry | null;
+    queriesForBatch(entry: QueryDevtoolsEntry): QueryLink[];
+    /**
+     * The registry entry of one of a batch's items, or `null` once it has fallen out of the batch's capped
+     * tombstone tail - which is what makes an item row openable only while its query is still kept.
+     */
+    batchItemQueryId(entry: QueryDevtoolsEntry, index: number): string | null;
+    batchItems(entry: QueryDevtoolsEntry): BatchItemView;
+    batchThroughput(batch: AnyQueryBatch): string | null;
+    isBatchItemExpanded(entryId: string, index: number): boolean;
+    toggleBatchItem(entryId: string, index: number): void;
     /** Dedents a GraphQL document (template-literal indentation) for readable display. */
     gqlDocument(doc: string): string;
     featureLabel(type: string): string;
@@ -1687,6 +1853,18 @@ declare class QueryDevtoolsComponent implements OnInit {
         content: string;
         type: string;
     }): void;
+    /**
+     * The headers an execution of this request would resolve to now: the client's with the per-request
+     * ones merged on top, providers called. `undefined` when a provider throws, which for a secure query
+     * means no access token is available yet.
+     */
+    private resolvedHeaders;
+    /**
+     * The same route rendered from a set of args rather than from a query, which is what a batch item leaves
+     * behind: the batch destroys its query the moment the item settles.
+     */
+    private argsRouteSegments;
+    private renderRoute;
     /**
      * Takes - or gives back - the lock whose name only this tab can have produced. Its `clientId` in the
      * snapshot is what tells this tab's rows from another tab's: `LockInfo` carries no tab identity, and
@@ -1774,11 +1952,18 @@ declare class QueryDevtoolsComponent implements OnInit {
      */
     private insomniaHeaders;
     private sessionClients;
+    /**
+     * A bearer auth provider's login and token-refresh queries are ordinary registered queries, so the
+     * export has to be told which ones they are before it can leave their bodies out. The provider's own
+     * entry lists them by client, method and route, which is what a query entry is matched on.
+     */
+    private sessionAuthQueryKeys;
     /** Every registered entry, described by whatever its kind carries. */
     private sessionEntries;
     private sessionQuery;
     private sessionActivity;
     private sessionSequence;
+    private sessionBatch;
     private sessionForm;
     /**
      * An auth provider without its tokens. A session report is a file that gets attached to a ticket, and
@@ -1830,7 +2015,7 @@ declare class QueryDevtoolsComponent implements OnInit {
 declare const QUERY_DEVTOOLS_IMPORTS: readonly [typeof QueryDevtoolsComponent];
 
 /** The version of `@ethlete/query-devtools` this build was cut from. */
-declare const QUERY_DEVTOOLS_VERSION = "1.0.0-next.1";
+declare const QUERY_DEVTOOLS_VERSION = "1.0.0-next.11";
 
 export { QUERY_DEVTOOLS_IMPORTS, QUERY_DEVTOOLS_VERSION, QueryDevtoolsAboutComponent, QueryDevtoolsComponent, QueryDevtoolsJsonComponent, QueryDevtoolsJsonStylesComponent, QueryDevtoolsSettingsComponent, QueryDevtoolsTimelineStylesComponent, clampFloatToPeek, kindOf, resizedFloatRect, settledFloatRect };
 export type { JsonKind };