@ethlete/query-devtools 1.0.0-next.0 → 1.0.0-next.10

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ethlete/query-devtools",
-  "version": "1.0.0-next.0",
+  "version": "1.0.0-next.10",
   "license": "MIT",
   "sideEffects": false,
   "peerDependencies": {

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 = {
@@ -82,7 +82,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 +96,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>;
@@ -167,6 +170,30 @@ type QueryDevtoolsDiff = {
     truncated: boolean;
 };
 
+/** Which SDK feature a lock name belongs to, or `other` for one the panel did not put there. */
+type DevtoolsLockKind = 'auth' | 'poll' | 'other';
+/** Where the tab the panel is open in stands on one lock. */
+type DevtoolsLockStanding = 'holder' | 'queued' | 'absent' | 'unknown';
+/** One lock name, with every client that holds or waits for it folded into a single row. */
+type DevtoolsLockRow = {
+    /** The raw name, so a lock the panel cannot decode is still greppable from the row. */
+    name: string;
+    /** What the name means: the provider for an auth lock, the cache key for a poll lock. */
+    label: string;
+    kind: DevtoolsLockKind;
+    /** The sync channel a poll lock belongs to, or `null` for a name that carries no such part. */
+    channel: string | null;
+    /**
+     * Held plus queued on this name. Every participant requests the same lock and exactly one gets it, so
+     * this is the number of tabs, workers and service workers taking part - the same arithmetic the auth
+     * provider's own `instanceCount` does.
+     */
+    tabs: number;
+    standing: DevtoolsLockStanding;
+    /** This tab's 1-based place in the queue, or `null` unless {@link standing} is `queued`. */
+    queuePlace: number | null;
+};
+
 type AnyQuery = Query<any>;
 /** The query a detail pane is showing, together with the registry entry it was registered as. */
 type QueryDevtoolsSelection = {
@@ -178,7 +205,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' | '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.
@@ -208,11 +235,11 @@ type RouteSegment = {
     name?: string;
 };
 /**
- * Which tab refreshes an auth provider's tokens, as the auth tab's chip renders it. `title` carries
- * the caveats the label has no room for - why every tab reads as the leader, or how approximate the
- * tab count is.
+ * A one-line verdict the panel renders as a chip - which tab refreshes an auth provider's tokens, where
+ * this tab stands on a lock. `title` carries the caveats the label has no room for: why every tab reads
+ * as the leader, or how approximate a tab count is.
  */
-type QueryDevtoolsLeadership = {
+type QueryDevtoolsChip = {
     label: string;
     tone: 'success' | 'muted';
     title: string;
@@ -237,6 +264,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.
@@ -367,6 +408,7 @@ type QueryDevtoolsHost = {
     queryEntries: Signal<QueryDevtoolsEntry[]>;
     stackEntries: Signal<QueryDevtoolsEntry[]>;
     sequenceEntries: Signal<QueryDevtoolsEntry[]>;
+    batchEntries: Signal<QueryDevtoolsEntry[]>;
     formEntries: Signal<QueryDevtoolsEntry[]>;
     authEntries: Signal<QueryDevtoolsEntry[]>;
     wsEntries: Signal<QueryDevtoolsEntry[]>;
@@ -391,6 +433,14 @@ type QueryDevtoolsHost = {
     clearPersistedQueries(client: QueryClient): void;
     /** The features of the client behind a cache tab card, or `null` for a client without any. */
     clientFeatures(client: QueryClient | null | undefined): QueryDevtoolsFeature[] | null;
+    /**
+     * Every Web Lock held or queued across this origin, decoded, or `null` in a browser without the Web
+     * Locks API. Empty while the Locks tab has not read its first snapshot - it polls, because Web Locks
+     * has no change event to listen to.
+     */
+    lockRows: Signal<DevtoolsLockRow[] | null>;
+    /** Where this tab stands on one lock, as a chip: whether it holds it, waits for it, or is not in it. */
+    lockStanding(row: DevtoolsLockRow): QueryDevtoolsChip;
     /** Unique client names present across queries and auth providers, for the Queries/Timeline pickers. */
     clientNames: Signal<string[]>;
     /** What each tab holds - also drives the tab bar's own badges, so it lives here rather than per-tab. */
@@ -418,6 +468,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;
@@ -426,7 +477,7 @@ type QueryDevtoolsHost = {
     /** The access-token expiry the app acts on, plus the lifetime the panel has armed over it. */
     authTokenLifetime(entry: QueryDevtoolsEntry): QueryDevtoolsTokenLifetime;
     /** The multi-tab leadership chip, or `null` for a provider without `withBearerAuthMultiTabSync`. */
-    authLeadership(auth: AnyBearerAuthProvider): QueryDevtoolsLeadership | null;
+    authLeadership(auth: AnyBearerAuthProvider): QueryDevtoolsChip | null;
     queryStatus(query: AnyQuery): 'idle' | 'loading' | 'success' | 'error';
     isStale(query: AnyQuery): boolean;
     /** Whether an entry is showing an armed response override or a devtools-faulted outcome. */
@@ -443,6 +494,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;
@@ -460,6 +516,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;
@@ -600,6 +680,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;
@@ -641,7 +731,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;
@@ -670,6 +760,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: {
@@ -684,9 +775,27 @@ 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>;
     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;
@@ -729,21 +838,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;
@@ -753,12 +847,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;
@@ -771,6 +872,7 @@ type PersistedState = {
     socketFilter?: string;
     jsonSearch?: string;
     expandedSteps?: string[];
+    expandedBatchItems?: string[];
     expandedQueryGroups?: string[];
     jsonExpanded?: string[];
     jsonCollapsed?: string[];
@@ -821,6 +923,7 @@ declare class QueryDevtoolsComponent implements OnInit {
     private destroyRef;
     private document;
     private viewport;
+    private isDocumentVisible;
     /**
      * Opens the panel as soon as it is created, whatever the stored view state says. Set by
      * `<et-query-devtools-lazy>`, which downloads the panel on the click that was meant to open it.
@@ -842,6 +945,9 @@ declare class QueryDevtoolsComponent implements OnInit {
     } | {
         id: "sequences";
         label: string;
+    } | {
+        id: "batches";
+        label: string;
     } | {
         id: "forms";
         label: string;
@@ -854,6 +960,9 @@ declare class QueryDevtoolsComponent implements OnInit {
     } | {
         id: "cache";
         label: string;
+    } | {
+        id: "locks";
+        label: string;
     } | {
         id: "timeline";
         label: string;
@@ -920,7 +1029,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>;
@@ -956,6 +1065,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. */
@@ -993,6 +1107,20 @@ 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>;
@@ -1001,6 +1129,8 @@ declare class QueryDevtoolsComponent implements OnInit {
     selectedFormId: WritableSignal<string | null>;
     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. */
@@ -1046,6 +1176,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. */
@@ -1088,9 +1220,19 @@ declare class QueryDevtoolsComponent implements OnInit {
     private copiedReset$;
     /** 1-second tick driving the cache freshness countdowns. */
     private clock;
+    /**
+     * The probe lock behind every Locks row's "this tab" answer, and the last snapshot read through it.
+     * Both only exist while the Locks tab is on screen - see the polling stream in the constructor.
+     */
+    private probeLocks;
+    private probeId;
+    private probeHold;
+    private lockSnapshot;
+    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>;
@@ -1110,6 +1252,7 @@ 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[]>;
@@ -1167,6 +1310,9 @@ declare class QueryDevtoolsComponent implements OnInit {
     } | {
         id: "sequences";
         label: string;
+    } | {
+        id: "batches";
+        label: string;
     } | {
         id: "forms";
         label: string;
@@ -1179,6 +1325,9 @@ declare class QueryDevtoolsComponent implements OnInit {
     } | {
         id: "cache";
         label: string;
+    } | {
+        id: "locks";
+        label: string;
     } | {
         id: "timeline";
         label: string;
@@ -1205,6 +1354,9 @@ declare class QueryDevtoolsComponent implements OnInit {
     } | {
         id: "sequences";
         label: string;
+    } | {
+        id: "batches";
+        label: string;
     } | {
         id: "forms";
         label: string;
@@ -1217,6 +1369,9 @@ declare class QueryDevtoolsComponent implements OnInit {
     } | {
         id: "cache";
         label: string;
+    } | {
+        id: "locks";
+        label: string;
     } | {
         id: "timeline";
         label: string;
@@ -1245,6 +1400,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;
@@ -1371,7 +1534,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 -
@@ -1547,6 +1723,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;
     /**
@@ -1591,11 +1768,13 @@ declare class QueryDevtoolsComponent implements OnInit {
     authTokenPayload(auth: AnyBearerAuthProvider): Record<string, unknown> | null;
     queriesForStack(stack: AnyQueryStack | AnyPagedQueryStack): QueryLink[];
     authQueryKeys(auth: AnyBearerAuthProvider): string[];
+    /** Where this tab stands on one lock, as a chip. @see lockRows */
+    lockStanding(row: DevtoolsLockRow): QueryDevtoolsChip;
     /**
      * Which tab refreshes this provider's tokens, as a chip: whether it is this one, how many tabs are
      * in the election, and - when there is no election - why every tab reads as the leader.
      */
-    authLeadership(auth: AnyBearerAuthProvider): QueryDevtoolsLeadership | null;
+    authLeadership(auth: AnyBearerAuthProvider): QueryDevtoolsChip | null;
     /**
      * The access token's expiry as the app sees it, plus whatever the panel is doing to it: an armed
      * lifetime replaces the countdown, and the token's own is reported next to it so the card never claims
@@ -1609,6 +1788,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;
@@ -1634,6 +1826,24 @@ 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
+     * the platform offers no way to ask for one's own client id.
+     */
+    private holdProbeLock;
     /**
      * The two runs the diff compares, oldest first - normalised by run index, so picking a pair in either
      * order reads the same way round as the `#before → #after` header prints it.
@@ -1720,6 +1930,7 @@ declare class QueryDevtoolsComponent implements OnInit {
     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
@@ -1771,7 +1982,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.0";
+declare const QUERY_DEVTOOLS_VERSION = "1.0.0-next.10";
 
 export { QUERY_DEVTOOLS_IMPORTS, QUERY_DEVTOOLS_VERSION, QueryDevtoolsAboutComponent, QueryDevtoolsComponent, QueryDevtoolsJsonComponent, QueryDevtoolsJsonStylesComponent, QueryDevtoolsSettingsComponent, QueryDevtoolsTimelineStylesComponent, clampFloatToPeek, kindOf, resizedFloatRect, settledFloatRect };
 export type { JsonKind };