@ethlete/query-devtools 1.0.0-next.13 → 1.0.0-next.14

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

@@ -17,10 +17,13 @@ type AboutGroup = {
  * `provideQueryDevtools({ about })`. A section rather than a tab body, so it can be shown anywhere.
  */
 declare class QueryDevtoolsAboutComponent {
+    private hostEl;
     protected readonly groups: AboutGroup[];
-    protected copied: _angular_core.WritableSignal<boolean>;
-    private copiedReset$;
-    constructor();
+    protected copied: {
+        value: _angular_core.Signal<boolean>;
+        mark: (next: boolean) => void;
+        clear: () => void;
+    };
     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>;
@@ -49,10 +52,11 @@ declare const kindOf: (value: unknown) => JsonKind;
  * re-enter as the same component with a `chunk` window over the same value.
  */
 declare class QueryDevtoolsJsonComponent {
+    private hostEl;
     value: _angular_core.InputSignal<unknown>;
     nodeKey: _angular_core.InputSignal<string | null>;
     depth: _angular_core.InputSignalWithTransform<number, unknown>;
-    /** Lowercased search term; when set, the tree auto-expands and matches are highlighted. */
+    /** Lowercased search term; when set, the containers holding a match auto-expand and matches are highlighted. */
     search: _angular_core.InputSignal<string>;
     /**
      * When set, this node is not the value itself but a folded window over its entries. It shares the
@@ -78,6 +82,8 @@ declare class QueryDevtoolsJsonComponent {
      * {@link QueryDevtoolsSchemaSeed} produces it. A node with an entry labels itself with it.
      */
     annotations: _angular_core.InputSignal<ReadonlyMap<string, string> | null>;
+    /** The containers above this node, so a search does not unfold a value that holds itself again. */
+    ancestors: _angular_core.InputSignal<readonly unknown[]>;
     protected kind: _angular_core.Signal<JsonKind>;
     private exotic;
     /** One annotation covers every element of an array, so the lookup path forgets which index this is. */
@@ -99,12 +105,15 @@ declare class QueryDevtoolsJsonComponent {
     private defaultExpanded;
     private localExpanded;
     private expanded;
-    /** Only slices that actually contain a match unfold while searching, so a filter stays cheap. */
-    private chunkHasHit;
+    protected childAncestors: _angular_core.Signal<unknown[]>;
+    private hasHit;
     protected effectiveExpanded: _angular_core.Signal<boolean>;
     /** What the last copy put on the clipboard, or `null` once the tick has expired. */
-    protected copied: _angular_core.WritableSignal<QueryDevtoolsCopyPayload | null>;
-    private copiedReset$;
+    protected copied: {
+        value: _angular_core.Signal<QueryDevtoolsCopyPayload | null>;
+        mark: (next: QueryDevtoolsCopyPayload | null) => void;
+        clear: () => void;
+    };
     /**
      * Whether this node has an address of its own to copy. An explorer root has no key, and a folded
      * slice stands for a range of entries rather than one path - neither can name itself.
@@ -138,9 +147,8 @@ declare class QueryDevtoolsJsonComponent {
     /** An exotic container copies the entries the tree shows, not the private fields `JSON.stringify` finds. */
     private copyableValue;
     private chunkValue;
-    private flagCopied;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<QueryDevtoolsJsonComponent, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<QueryDevtoolsJsonComponent, "et-query-devtools-json", never, { "value": { "alias": "value"; "required": false; "isSignal": true; }; "nodeKey": { "alias": "nodeKey"; "required": false; "isSignal": true; }; "depth": { "alias": "depth"; "required": false; "isSignal": true; }; "search": { "alias": "search"; "required": false; "isSignal": true; }; "chunk": { "alias": "chunk"; "required": false; "isSignal": true; }; "path": { "alias": "path"; "required": false; "isSignal": true; }; "expandedPaths": { "alias": "expandedPaths"; "required": false; "isSignal": true; }; "collapsedPaths": { "alias": "collapsedPaths"; "required": false; "isSignal": true; }; "toggleFn": { "alias": "toggleFn"; "required": false; "isSignal": true; }; "jsonPath": { "alias": "jsonPath"; "required": false; "isSignal": true; }; "parentKind": { "alias": "parentKind"; "required": false; "isSignal": true; }; "overrides": { "alias": "overrides"; "required": false; "isSignal": true; }; "annotations": { "alias": "annotations"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<QueryDevtoolsJsonComponent, "et-query-devtools-json", never, { "value": { "alias": "value"; "required": false; "isSignal": true; }; "nodeKey": { "alias": "nodeKey"; "required": false; "isSignal": true; }; "depth": { "alias": "depth"; "required": false; "isSignal": true; }; "search": { "alias": "search"; "required": false; "isSignal": true; }; "chunk": { "alias": "chunk"; "required": false; "isSignal": true; }; "path": { "alias": "path"; "required": false; "isSignal": true; }; "expandedPaths": { "alias": "expandedPaths"; "required": false; "isSignal": true; }; "collapsedPaths": { "alias": "collapsedPaths"; "required": false; "isSignal": true; }; "toggleFn": { "alias": "toggleFn"; "required": false; "isSignal": true; }; "jsonPath": { "alias": "jsonPath"; "required": false; "isSignal": true; }; "parentKind": { "alias": "parentKind"; "required": false; "isSignal": true; }; "overrides": { "alias": "overrides"; "required": false; "isSignal": true; }; "annotations": { "alias": "annotations"; "required": false; "isSignal": true; }; "ancestors": { "alias": "ancestors"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
 }
 
 /**
@@ -154,6 +162,17 @@ declare class QueryDevtoolsJsonStylesComponent {
     static ɵcmp: _angular_core.ɵɵComponentDeclaration<QueryDevtoolsJsonStylesComponent, "et-query-devtools-json-styles", never, {}, {}, never, never, true, never>;
 }
 
+/**
+ * A copy confirmation that falls back to `idle` once {@link QUERY_DEVTOOLS_COPIED_RESET_MS} pass; each
+ * `mark` restarts the countdown. Create it in an injection context.
+ */
+declare const createQueryDevtoolsCopiedTick: <T>(idle: T) => {
+    value: _angular_core.Signal<T>;
+    mark: (next: T) => void;
+    clear: () => void;
+};
+type QueryDevtoolsCopiedTick<T> = ReturnType<typeof createQueryDevtoolsCopiedTick<T>>;
+
 /** Whether a path exists only in the newer value, only in the older one, or in both with a new value. */
 type QueryDevtoolsDiffKind = 'added' | 'removed' | 'changed';
 /** One difference between two values, located by the path it sits at. */
@@ -324,11 +343,8 @@ type EventLogItem = {
     url: string | null;
     isSecure: boolean;
     status: number | null;
-    /**
-     * The registered query the request belonged to when the event fired, so the row can open it. Resolved
-     * here rather than at click time so the log holds an id instead of a reference to the request itself.
-     */
-    queryId: string | null;
+    /** Weak, so the log never keeps a destroyed request alive. `null` for an event that is not one request. */
+    request: WeakRef<object> | null;
     /** What asked for a refresh, for a `queries-refreshed` row. `null` for every other type. */
     cause: QueryRefreshCause | null;
     /** Why a cache entry was torn down, for an `entry-destroyed` row. `null` for every other type. */
@@ -466,6 +482,7 @@ type QueryDevtoolsHost = {
     /** 1-second tick driving every countdown/freshness readout across tabs. */
     clock: Signal<number>;
     findQuery(id: string | null): QueryDevtoolsSelection | null;
+    eventQueryId(event: EventLogItem): string | null;
     queryLinkFor(entry: QueryDevtoolsEntry | undefined, query?: AnyQuery): QueryLink;
     asStack(entry: QueryDevtoolsEntry): AnyQueryStack;
     asPagedStack(entry: QueryDevtoolsEntry): AnyPagedQueryStack;
@@ -612,11 +629,11 @@ type QueryDevtoolsHost = {
         run: QueryDevtoolsRun;
         error: QueryDevtoolsRunError;
     } | null;
-    copiedReport: Signal<boolean>;
-    copiedInsomnia: Signal<boolean>;
-    copiedCurl: Signal<boolean>;
-    copiedGql: Signal<boolean>;
-    copiedRoute: Signal<boolean>;
+    copiedReport: QueryDevtoolsCopiedTick<boolean>;
+    copiedInsomnia: QueryDevtoolsCopiedTick<boolean>;
+    copiedCurl: QueryDevtoolsCopiedTick<boolean>;
+    copiedGql: QueryDevtoolsCopiedTick<boolean>;
+    copiedRoute: QueryDevtoolsCopiedTick<boolean>;
     copyReport(entry: QueryDevtoolsEntry, query: AnyQuery): void;
     copyInsomniaRequest(entry: QueryDevtoolsEntry, query: AnyQuery): void;
     copyCurlRequest(entry: QueryDevtoolsEntry, query: AnyQuery): void;
@@ -836,14 +853,8 @@ declare class QueryDevtoolsTimelineStylesComponent {
     static ɵcmp: _angular_core.ɵɵComponentDeclaration<QueryDevtoolsTimelineStylesComponent, "et-query-devtools-timeline-styles", never, {}, {}, never, never, true, never>;
 }
 
-/**
- * Where the panel sits: attached to an edge, or floating over the page as a window of its own. A
- * pop-out is not one of these - that is a real browser window, not a position in this document.
- */
 type DevtoolsDock = 'bottom' | 'top' | 'left' | 'right' | 'float';
-/** What the layout menu offers, in the order it lists them. `popout` is a window, not a position. */
 type DevtoolsLayout = DevtoolsDock | 'popout';
-/** The floating panel's position and size, in CSS px from the viewport's top-left. */
 type FloatRect = {
     x: number;
     y: number;
@@ -899,21 +910,10 @@ type ViewportSize = {
  * thing that drags the panel back, so it may never be the part that leaves.
  */
 declare const clampFloatToPeek: (rect: FloatRect, viewport: ViewportSize) => FloatRect;
-/**
- * Where a float settles when the pointer is released. Dragged more than halfway off an edge, it stays
- * parked there with {@link FLOAT_PEEK} showing - the panel gets out of the way of the thing you are
- * debugging without being closed. Anything short of halfway is pulled back in, so a slightly clumsy
- * drag does not park it.
- */
 declare const settledFloatRect: (rect: FloatRect, viewport: ViewportSize) => {
     rect: FloatRect;
     collapsed: boolean;
 };
-/**
- * The rect a resize gesture from `edge` produces, given where the panel was when the gesture started.
- * A west or north drag grows away from the edge that stays pinned, so the origin follows whatever
- * size the drag settled on - including when the size hit its floor and the origin must stop with it.
- */
 declare const resizedFloatRect: (base: FloatRect, { move, viewport }: {
     move: ResizeMoveEvent;
     viewport: ViewportSize;
@@ -941,11 +941,9 @@ declare class QueryDevtoolsComponent implements OnInit {
      * `<et-query-devtools-lazy>`, which downloads the panel on the click that was meant to open it.
      */
     startOpen: _angular_core.InputSignalWithTransform<boolean, unknown>;
-    /** The panel itself, so a pop-out can move it into another window's document. */
     private panelEl;
     private eventIdCounter;
     private lastSelectionKey;
-    /** Where the gear goes back to, so opening Settings does not lose the tab it was opened over. */
     private tabBeforeSettings;
     readonly persisted: PersistedState;
     protected readonly tabs: ({
@@ -991,10 +989,6 @@ declare class QueryDevtoolsComponent implements OnInit {
         id: "about";
         label: string;
     })[];
-    /**
-     * Tabs the bar keeps whether they hold anything or not: the one the panel opens on, and the one that
-     * arms faults - which has entries to arm rather than to count.
-     */
     private readonly PINNED_TABS;
     protected readonly shortcut: "⌘⌥Q" | "Ctrl+Alt+Q";
     protected readonly LAYOUTS: readonly [{
@@ -1028,24 +1022,18 @@ 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";
     }];
-    protected open: WritableSignal<boolean>;
+    protected open: _angular_core.WritableSignal<boolean>;
     private panelHeight;
     private panelWidth;
-    protected activeTab: WritableSignal<DevtoolsTab>;
-    /**
-     * The dragged sizes of the two-pane tabs, in px, one pair per axis - a side dock stacks the panes, so
-     * the same divider sizes them along the block axis there and a dock switch has to keep both. `null`
-     * keeps the stylesheet's proportional default, which is also what a double-click on a divider restores.
-     */
-    protected listWidth: WritableSignal<number | null>;
-    protected drawerWidth: WritableSignal<number | null>;
-    protected listHeight: WritableSignal<number | null>;
-    protected drawerHeight: WritableSignal<number | null>;
+    protected activeTab: _angular_core.WritableSignal<DevtoolsTab>;
+    protected listWidth: _angular_core.WritableSignal<number | null>;
+    protected drawerWidth: _angular_core.WritableSignal<number | null>;
+    protected listHeight: _angular_core.WritableSignal<number | null>;
+    protected drawerHeight: _angular_core.WritableSignal<number | null>;
     private drag;
+    private floatGesture;
     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>;
-    /** The entry the layout button shows, so it names where the panel is rather than where it could go. */
+    protected dock: _angular_core.WritableSignal<DevtoolsDock>;
     protected currentLayout: _angular_core.Signal<{
         readonly id: "bottom";
         readonly glyph: "⬓";
@@ -1077,46 +1065,32 @@ 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. */
+    protected reservesSpace: _angular_core.WritableSignal<boolean>;
     private floatRect;
-    /** The rect a resize gesture started from, or `null` outside one. */
     private floatResizeBase;
     /**
      * Whether the float is shoved off an edge with only its peek showing. Persisted with the rect, since
      * restoring the rect without it would either strand the panel off screen or silently un-park it.
      */
-    protected floatParked: WritableSignal<boolean>;
-    /**
-     * The browser refused the last pop-out. `window.open` returns `null` with no error to catch, so
-     * without this the button simply did nothing - and floating is the fallback it should have offered.
-     */
-    protected popOutBlocked: WritableSignal<boolean>;
+    protected floatParked: _angular_core.WritableSignal<boolean>;
+    protected popOutBlocked: _angular_core.WritableSignal<boolean>;
     /**
      * Whether the panel currently lives in a window of its own. Deliberately not persisted: a reload
      * cannot re-adopt a window the previous document opened, so it always starts docked.
      */
-    protected poppedOut: WritableSignal<boolean>;
+    protected poppedOut: _angular_core.WritableSignal<boolean>;
     protected floating: _angular_core.Signal<boolean>;
-    /**
-     * Below `md` a side-by-side split cannot fit: the list alone asks for `22rem` and the drawer for
-     * `26rem`, which is wider than a phone. Narrow gets the same stacked layout a right dock does.
-     */
     private narrowViewport;
-    /** Whether the panel is docked to a side edge, which is what sizes it along the inline axis. */
     private sideDocked;
-    /** Which axis the two-pane tabs split along. The stylesheet keys the stacked layout off the same value. */
     protected paneAxis: _angular_core.Signal<PaneAxis>;
     private popup;
-    /** Stops mirroring the host document's stylesheets into the pop-up. @see syncStylesInto */
+    /** Ends everything tied to one pop-out window: a pending `load`, its `pagehide`, shortcut and visibility. */
+    private popOutEnded$;
+    private popupVisible;
+    private isPanelVisible;
     private popOutStyleSync;
     protected panelBlockSize: _angular_core.Signal<number | null>;
     protected panelInlineSize: _angular_core.Signal<number | null>;
-    /** 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>;
     /**
@@ -1124,7 +1098,6 @@ declare class QueryDevtoolsComponent implements OnInit {
      * `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:
@@ -1133,109 +1106,84 @@ declare class QueryDevtoolsComponent implements OnInit {
      * 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>;
+    detailTab: _angular_core.WritableSignal<DetailTab>;
+    selectedClientName: _angular_core.WritableSignal<string | null>;
+    selectedQueryId: _angular_core.WritableSignal<string | null>;
+    selectedFormId: _angular_core.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. */
-    queryFilter: WritableSignal<string>;
-    /** The status facets the Queries list is narrowed to. Empty means no status narrowing. */
-    queryFacets: WritableSignal<ReadonlySet<QueryListFacet>>;
-    /**
-     * Which way the Queries list sorts by last-executed time. Only the direction is switchable - the field
-     * is not, because "which one just ran" is the question the column exists to answer.
-     */
-    queryRecentFirst: WritableSignal<boolean>;
-    /**
-     * Whether the Queries list is arranged as a tree of route paths. Off by default: the flat list is
-     * still the right shape for "what ran just now", which is what the tab is opened for most of the time.
-     */
-    queryTreeView: WritableSignal<boolean>;
-    /**
-     * The path folders the user closed. Collapsed rather than expanded, because a tree that opens closed
-     * shows nothing but the top segment of every route - which answers no question the flat list didn't.
-     */
-    collapsedQueryPaths: WritableSignal<ReadonlySet<string>>;
-    /**
-     * The entry ids sorted to the top of the Queries list. Ids are derived from a stable descriptor plus a
-     * per-descriptor sequence number, so a pin survives a reload as long as queries are created in the same
-     * order - the same property the restored selection already relies on.
-     */
-    pinnedQueryIds: WritableSignal<ReadonlySet<string>>;
-    eventLog: WritableSignal<EventLogItem[]>;
-    /**
-     * The cache entries that are gone, newest first. Kept here rather than in the repository, which stays
-     * lean in production - it emits the teardown and forgets it.
-     */
-    droppedCacheEntries: WritableSignal<DroppedCacheEntry[]>;
-    /** The client (by base URL) the event log is scoped to, or `null` for all of them. */
-    eventClient: WritableSignal<string | null>;
-    /** Whether the event log is narrowed to failures - the rows a bug report is about. */
-    eventErrorsOnly: WritableSignal<boolean>;
-    /** Free-text narrowing of every socket's message log. Matches the event, the room and the direction. */
-    socketFilter: WritableSignal<string>;
-    /** The cache entry whose response is expanded, as `<client>|<key>`, or `null` while none is. */
+    seededTypes: _angular_core.WritableSignal<Record<string, ReadonlyMap<string, string>>>;
+    stackSelectedQueryId: _angular_core.WritableSignal<string | null>;
+    sequenceSelectedQueryId: _angular_core.WritableSignal<string | null>;
+    batchSelectedQueryId: _angular_core.WritableSignal<string | null>;
+    eventSelectedQueryId: _angular_core.WritableSignal<string | null>;
+    formSelectedQueryId: _angular_core.WritableSignal<string | null>;
+    timelineSelectedQueryId: _angular_core.WritableSignal<string | null>;
+    queryFilter: _angular_core.WritableSignal<string>;
+    queryFacets: _angular_core.WritableSignal<ReadonlySet<QueryListFacet>>;
+    queryRecentFirst: _angular_core.WritableSignal<boolean>;
+    queryTreeView: _angular_core.WritableSignal<boolean>;
+    collapsedQueryPaths: _angular_core.WritableSignal<ReadonlySet<string>>;
+    pinnedQueryIds: _angular_core.WritableSignal<ReadonlySet<string>>;
+    eventLog: _angular_core.WritableSignal<EventLogItem[]>;
+    private eventOwners;
+    droppedCacheEntries: _angular_core.WritableSignal<DroppedCacheEntry[]>;
+    eventClient: _angular_core.WritableSignal<string | null>;
+    eventErrorsOnly: _angular_core.WritableSignal<boolean>;
+    socketFilter: _angular_core.WritableSignal<string>;
     private expandedCacheKey;
-    /** The socket whose emit box last failed, so the message shows on that card and no other. */
     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. */
-    jsonSearch: WritableSignal<string>;
+    expandedQueryGroups: _angular_core.WritableSignal<ReadonlySet<string>>;
+    jsonSearch: _angular_core.WritableSignal<string>;
     jsonSearchTerm: _angular_core.Signal<string>;
-    /** Path-keyed value-explorer expansion overrides (persisted so open trees survive a reload). */
-    jsonExpandedPaths: WritableSignal<ReadonlySet<string>>;
-    jsonCollapsedPaths: WritableSignal<ReadonlySet<string>>;
-    /** Bound callback passed into the value explorer to persist per-path expansion. Assigned in the constructor. */
+    jsonExpandedPaths: _angular_core.WritableSignal<ReadonlySet<string>>;
+    jsonCollapsedPaths: _angular_core.WritableSignal<ReadonlySet<string>>;
     toggleJsonPath: (path: string, expand: boolean) => void;
-    /** The run whose response the diff is comparing, by run index, or `null` while no diff is open. */
-    diffRunIndex: WritableSignal<number | null>;
-    /**
-     * The run the diff compares it *against*, or `null` to derive that side - the newest older run that
-     * still holds a body, which is what one click on **Diff** gives you.
-     */
-    diffBaseRunIndex: WritableSignal<number | null>;
-    errorRunIndex: WritableSignal<number | null>;
-    /** How many bodies a query retains, which is what bounds how far back a diff can reach. */
+    diffRunIndex: _angular_core.WritableSignal<number | null>;
+    diffBaseRunIndex: _angular_core.WritableSignal<number | null>;
+    errorRunIndex: _angular_core.WritableSignal<number | null>;
     retainedResponseCount: _angular_core.Signal<number>;
-    /** JIT editor state (response / args editing on the selected query). */
-    editorMode: WritableSignal<"none" | "response" | "args">;
-    responseDraft: WritableSignal<string>;
-    argsDraft: WritableSignal<string>;
+    editorMode: _angular_core.WritableSignal<"none" | "response" | "args">;
+    responseDraft: _angular_core.WritableSignal<string>;
+    argsDraft: _angular_core.WritableSignal<string>;
     /**
      * The text the currently open editor was seeded with. The textareas bind `value` to this and not to
      * the live draft: a `value` binding fed by the draft is written back on every keystroke, and writing
      * a textarea's `value` puts the caret at the end.
      */
     editorSeed: string;
-    editError: WritableSignal<string | null>;
-    /** The args the open editor was seeded from, so applying can put back what the draft cannot carry. */
+    editError: _angular_core.WritableSignal<string | null>;
     private editedArgsSource;
-    /** Transient "Copied!" feedback for the copy-report, copy-as-Insomnia / cURL and copy-document actions. */
-    copiedReport: WritableSignal<boolean>;
-    copiedInsomnia: WritableSignal<boolean>;
-    copiedCurl: WritableSignal<boolean>;
-    copiedGql: WritableSignal<boolean>;
-    copiedRoute: WritableSignal<boolean>;
-    private copiedReset$;
+    copiedReport: {
+        value: _angular_core.Signal<boolean>;
+        mark: (next: boolean) => void;
+        clear: () => void;
+    };
+    copiedInsomnia: {
+        value: _angular_core.Signal<boolean>;
+        mark: (next: boolean) => void;
+        clear: () => void;
+    };
+    copiedCurl: {
+        value: _angular_core.Signal<boolean>;
+        mark: (next: boolean) => void;
+        clear: () => void;
+    };
+    copiedGql: {
+        value: _angular_core.Signal<boolean>;
+        mark: (next: boolean) => void;
+        clear: () => void;
+    };
+    copiedRoute: {
+        value: _angular_core.Signal<boolean>;
+        mark: (next: boolean) => void;
+        clear: () => void;
+    };
     /**
      * 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
@@ -1243,32 +1191,25 @@ declare class QueryDevtoolsComponent implements OnInit {
      * 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.
-     * 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 inspectActive: _angular_core.WritableSignal<boolean>;
     /** @internal */
-    inspectHover: WritableSignal<{
+    inspectHover: _angular_core.WritableSignal<{
         rect: DOMRect;
         entries: QueryDevtoolsEntry[];
     } | null>;
-    /** Inspect run backwards: the box drawn over the element the selected query was created in. */
-    protected locatedRect: WritableSignal<DOMRect | null>;
-    locateState: WritableSignal<"idle" | "located" | "offscreen">;
+    protected locatedRect: _angular_core.WritableSignal<DOMRect | null>;
+    locateState: _angular_core.WritableSignal<"idle" | "located" | "offscreen">;
     private locate$;
-    /** When set (via inspect), the Queries list is filtered to exactly these entry ids. */
-    inspectFilterIds: WritableSignal<string[] | null>;
+    inspectFilterIds: _angular_core.WritableSignal<string[] | null>;
     private queryEntries;
     /**
      * The queries that still exist. Everything that measures what the application is doing right now -
-     * the tab bar's error flags, the tamper dot, the timeline, the identity match behind an event row -
+     * the tab bar's error flags, the tamper dot, the timeline -
      * reads this rather than {@link queryEntries}, so a tombstone never inflates a live number.
      */
     private liveQueryEntries;
@@ -1279,7 +1220,6 @@ declare class QueryDevtoolsComponent implements OnInit {
     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. A
@@ -1287,47 +1227,18 @@ declare class QueryDevtoolsComponent implements OnInit {
      * 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
-     * read as {@link EMPTY_QUERY_DEVTOOLS_FAULT} so the inputs always have a value to show.
-     */
     faultClients: _angular_core.Signal<{
         name: string;
         baseUrl: string;
         fault: _ethlete_query.QueryDevtoolsFault;
         armed: boolean;
     }[]>;
-    /**
-     * The names of the clients currently carrying a fault, or `null` when none do - so a template can `@if`
-     * on it. Armed faults are the one state where the panel is lying to the app on purpose, and a badge on a
-     * tab that isn't open cannot say that: whichever tab you are reading, a red response has to be
-     * attributable to the injection rather than to the API.
-     */
     protected armedFaultClients: _angular_core.Signal<string[] | null>;
-    /**
-     * The routes currently answered by a designed mock, for the shell's banner. A mocked response is a
-     * stronger lie than an override - nothing was sent at all - so it is named above every tab, not just
-     * badged on the one that armed it.
-     */
     protected armedMockRoutes: _angular_core.Signal<string[] | null>;
-    /**
-     * The queries the list is scoped to before the search box and the status chips narrow them further:
-     * either the picked client's, or exactly the inspected element's.
-     */
     scopedQueries: _angular_core.Signal<QueryDevtoolsEntry[]>;
-    /** How many runs every query has recorded, for the Timeline tab's badge. */
     private runTotals;
-    /** Cache entries across every client, for the Cache tab's badge. */
     private cacheEntryCount;
-    /**
-     * What each tab holds, so a failing query in a tab that is not open is still visible. Reading it
-     * subscribes the tab bar to every entry's live state - which is the point of the badges.
-     */
     protected tabBadges: _angular_core.Signal<Record<DevtoolsTab, TabBadge>>;
-    /**
-     * The tabs the bar shows: the pinned ones, the one that is open, and every tab that currently holds
-     * something.
-     */
     protected visibleTabs: _angular_core.Signal<({
         id: "queries";
         label: string;
@@ -1371,7 +1282,6 @@ declare class QueryDevtoolsComponent implements OnInit {
         id: "about";
         label: string;
     })[]>;
-    /** The empty tabs, which the bar offers behind "More" instead. */
     protected overflowTabs: _angular_core.Signal<({
         id: "queries";
         label: string;
@@ -1460,19 +1370,11 @@ declare class QueryDevtoolsComponent implements OnInit {
         client: QueryClient | null;
         dropped: DroppedCacheEntry[];
     }[]>;
-    /** Map of a component's host element to the query entries it created (for the inspect tool). */
     private elementQueryMap;
-    /** Disarms every client's fault - the shell's "Faults armed" banner offers this above every tab. */
     protected readonly CLEAR_FAULTS: (clientName?: string) => void;
-    /** Whether what is armed came back from a previous page load, which is what the bars have to say. */
     protected faultsRestored: _angular_core.Signal<boolean>;
     protected mocksRestored: _angular_core.Signal<boolean>;
-    /** Stops serving every designed mock - the shell's "Mocks armed" banner offers the same way out. */
     protected readonly DISARM_MOCKS: () => void;
-    /**
-     * What the previous page load left armed: how many ops came back, how many queries took them, and the
-     * ids nothing claimed. `null` when this page inherited nothing, so a template can `@if` on it.
-     */
     protected restoredOverrides: _angular_core.Signal<{
         queries: number;
         ops: number;
@@ -1480,32 +1382,19 @@ declare class QueryDevtoolsComponent implements OnInit {
         orphaned: string[];
         fromLocalStorage: boolean;
     } | null>;
-    /** Drops everything the reload re-armed, and empties the store it came from. */
     protected readonly DROP_RESTORED_OVERRIDES: () => void;
-    /** Every edge, so a float resizes the way a window does rather than only from one corner. */
     protected readonly FLOAT_RESIZE_EDGES: ResizeEdge[];
     constructor();
     ngOnInit(): void;
-    /** @see queryDevtoolsOverridePersistence */
     overridesPersist(): boolean;
     toggleOverridesPersist(): void;
-    /** Where armed overrides are kept, as the drawer's toggle and the Settings picker both name it. */
     overridesScopeLabel(): string;
     /**
-     * Puts the panel back the way it ships: layout, filters, selections, pins and the stored overrides.
-     * The settings themselves stay - a panel behaving oddly is a reason to reset its state, not to lose the
-     * scopes and limits that were chosen deliberately.
-     *
-     * Resetting the live state is the point, not just clearing the keys: the persistence effects would
-     * write the current state straight back into whatever store the scopes name.
+     * Puts layout, filters, selections, pins and stored overrides back the way they ship; the settings stay.
+     * Resets the live state too, or the persistence effects write it straight back.
      */
     resetDevtools(): void;
-    /**
-     * Opens Settings over whatever tab is showing, and the same click closes it again. Settings is not in
-     * the tab bar - see {@link DevtoolsTab}.
-     */
     protected toggleSettings(): void;
-    /** Opens the first query the reload re-armed, so the banner leads somewhere rather than just warning. */
     protected reviewRestoredOverrides(id: string): void;
     /**
      * Closing while popped out docks back instead: the panel a pop-out shows is the very element the
@@ -1515,17 +1404,13 @@ declare class QueryDevtoolsComponent implements OnInit {
     protected floatPanel(): void;
     protected selectLayout(layout: DevtoolsLayout): void;
     /**
-     * Moves the panel into a window of its own - the same element, adopted by the pop-up's document, so
-     * every signal binding in it keeps updating from the app it is inspecting.
-     *
-     * The panel's styles are global `<style>` tags in the host document, and the theming tokens it reads
-     * hang off the root element, so both are copied over; without them the pop-out renders unstyled.
+     * Moves the panel element into a pop-up window. The host document's `<style>` tags and root theming
+     * tokens must be copied over with it, or the pop-out renders unstyled.
      */
     popOut(): void;
     selectClient(name: string | null): void;
     clearInspectFilter(): void;
     toggleFacet(facet: QueryListFacet): void;
-    /** Drops the search term and the status chips, keeping the client / inspection scope. */
     clearQueryFilters(): void;
     isQueryPinned(entry: QueryDevtoolsEntry): boolean;
     toggleQueryPath(key: string): void;
@@ -1533,11 +1418,8 @@ declare class QueryDevtoolsComponent implements OnInit {
     protected toggleInspect(): void;
     protected startResize(event: PointerEvent): void;
     protected moveFloat(move: DragMoveEvent): void;
-    /** Parks the panel where a drag left it, or pulls it back in if the drag stopped short of an edge. */
     protected endFloatMove(): void;
-    /** A click on the title bar of a parked panel brings it back - the gesture that parked it, reversed. */
     protected restoreFloat(): void;
-    /** A resize reports a delta from where the pointer went down, so the rect it started from is kept. */
     protected startFloatResize(): void;
     protected resizeFloat(move: ResizeMoveEvent): void;
     protected endFloatResize(): void;
@@ -1545,16 +1427,9 @@ declare class QueryDevtoolsComponent implements OnInit {
         pane: PaneTarget;
         container: HTMLElement;
     }): void;
-    /** Hands a pane back to the stylesheet's proportional default, on the axis it is being sized along. */
     resetPaneSize(pane: PaneTarget): void;
     protected inspectLabel(entries: QueryDevtoolsEntry[]): string;
-    /**
-     * A query's route, split so the template can tell its static path from its path params (each carrying
-     * the value the query used, or `:<name>` while it has none yet) and from the query string of the
-     * request that ran - which is what tells two requests to the same endpoint apart.
-     */
     routeSegments(entry: QueryDevtoolsEntry | undefined, query: AnyQuery): RouteSegment[];
-    /** The full URL of the request a query last made, or `null` while it has not executed. */
     requestUrl(query: AnyQuery): string | null;
     /**
      * The args of a query. A query executed imperatively (`execute({ args })`, a sequence step, an auth
@@ -1563,80 +1438,37 @@ declare class QueryDevtoolsComponent implements OnInit {
      */
     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.
+     * The headers the last run sent, or what the args and client resolve to now for a query that has not
+     * run; `null` while a header provider throws. Client headers and the secure `Authorization` never
+     * reach the args, so the args alone cannot answer this.
      */
     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 -
-     * the same precedence the cache tab's freshness column applies.
-     */
     isStale(query: AnyQuery): boolean;
-    /**
-     * Whether an entry is showing something other than what the server actually sent - an armed response
-     * override, or a devtools fault that decided its last completed run. Deliberately not "a fault is
-     * armed nearby": an armed-but-idle fault (a `failRate` under 100, say) mostly lets requests through
-     * untouched, so that would over-claim for the vast majority of queries on that client.
-     */
     isTampered(entry: QueryDevtoolsEntry): boolean;
-    /** Whether a designed mock is armed for this query's own route, so nothing it shows came off the wire. */
     isMocked(entry: QueryDevtoolsEntry): boolean;
-    /**
-     * What a query's current request is doing beyond being loading, or `null` when there is nothing beyond
-     * the status dot to say - so the readout only takes up room while it carries something.
-     */
     requestProgress(query: AnyQuery): RequestProgress | null;
-    /** Why a retry was scheduled, as the panel spells it out. A status of 0 never reached the server. */
     retryCause(status: number): string;
     formatPercent(percentage: number): string;
-    /** A countdown in whole seconds, spelled out the way the cache freshness column does. */
     formatCountdown(ms: number | null): string;
     queryActivity(entry: QueryDevtoolsEntry): QueryActivity;
     linkActivity(link: QueryLink): QueryActivity;
     stackActivity(stack: AnyQueryStack | AnyPagedQueryStack): QueryActivity;
     sequenceActivity(sequence: QuerySequence<unknown[]>): QueryActivity;
-    /** Clears an entry's counters and run history, so the next interaction can be measured on its own. */
     resetStats(entry: QueryDevtoolsEntry): void;
-    /** A query's runs, newest first - the order a history is read in. */
     queryRuns(entry: QueryDevtoolsEntry): QueryDevtoolsRun[];
-    /**
-     * 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): "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
-     * too, as the base of a comparison against something newer.
-     */
     canDiffRun(entry: QueryDevtoolsEntry, run: QueryDevtoolsRun): boolean;
-    /**
-     * Arms a run as one end of the diff, or - with one end already armed - as the other. Clicking either
-     * end clears both.
-     */
     toggleRunDiff(entry: QueryDevtoolsEntry, run: QueryDevtoolsRun): void;
-    /** Which end of the comparison a run is, so a row says so and the two ends read differently. */
     diffRunRole(entry: QueryDevtoolsEntry, run: QueryDevtoolsRun): 'base' | 'compare' | null;
     responseDiff(entry: QueryDevtoolsEntry): {
         before: QueryDevtoolsRun;
         after: QueryDevtoolsRun;
         diff: QueryDevtoolsDiff;
     } | null;
-    /** Whether the diff header's older/newer control has a pair to move to. */
     canStepRunDiff(entry: QueryDevtoolsEntry, older: boolean): boolean;
-    /**
-     * Moves the whole comparison one run older or newer, so re-picking a pair does not mean scrolling back
-     * up to the runs table. Within the handful of retained bodies there are only a few pairs to walk.
-     */
     stepRunDiff(entry: QueryDevtoolsEntry, older: boolean): void;
     toggleRunError(run: QueryDevtoolsRun): void;
     /**
@@ -1648,17 +1480,10 @@ declare class QueryDevtoolsComponent implements OnInit {
         run: QueryDevtoolsRun;
         error: _ethlete_query.QueryDevtoolsRunError;
     } | null;
-    /** Opens a query in the Queries tab - the Events tab is a way in, not a dead end. */
     selectQuery(id: string): void;
-    /** A value on one line, for a diff row or a form field. The full tree would bury the row it sits in. */
     inlineValue(value: unknown): string;
     formatBytes(bytes: number): string;
-    /**
-     * A transferred size, marked `≈` when any part of it was measured from a decoded body instead of read
-     * from a `content-length` header - such a size ignores transport compression.
-     */
     formatTransferred(bytes: number, isEstimated: boolean): string;
-    /** A transfer rate, given in bytes per second the way `HttpRequestLoadingProgressState.speed` reports it. */
     formatSpeed(bytesPerSecond: number): string;
     formatDuration(ms: number | null): string;
     /**
@@ -1668,46 +1493,17 @@ declare class QueryDevtoolsComponent implements OnInit {
      */
     executeQuery(selection: QueryDevtoolsSelection, allowCache: boolean): void;
     resetQuery(query: AnyQuery): void;
-    /**
-     * Copies a shareable report (path, args, status, slimmed response) for handing to an API dev.
-     * Writes both rich `text/html` (Slack applies formatting on paste - it does not parse markdown) and
-     * a plain-text fallback.
-     */
     copyReport(entry: QueryDevtoolsEntry, query: AnyQuery): void;
-    /** Copies one query as an Insomnia collection, for `Import > From Clipboard`. */
     copyInsomniaRequest(entry: QueryDevtoolsEntry, query: AnyQuery): void;
-    /**
-     * Copies one query as a `curl` command - what goes into a terminal, a ticket or a chat message, where
-     * an Insomnia collection is too heavy to be read at all.
-     */
     copyCurlRequest(entry: QueryDevtoolsEntry, query: AnyQuery): void;
-    /** Copies the GraphQL document as displayed — dedented, so it pastes straight into a playground. */
     copyGqlDocument(doc: string): void;
-    /**
-     * The endpoint of a query as one string: the absolute URL its last request used, or - for a query
-     * that has not run - the rendered route on screen.
-     */
     copyableRoute(entry: QueryDevtoolsEntry, query: AnyQuery): string;
-    /** Names which of the two strings {@link copyableRoute} is offering, so the button says what it copies. */
     copyableRouteTitle(entry: QueryDevtoolsEntry, query: AnyQuery): string;
-    /** Copies {@link copyableRoute} - the endpoint on its own, where the exports are a whole document. */
     copyRoute(entry: QueryDevtoolsEntry, query: AnyQuery): void;
-    /**
-     * Downloads the given queries (already scoped/filtered by the caller) as one Insomnia collection,
-     * filed into a folder per query client.
-     */
     downloadInsomniaCollection(items: {
         entry: QueryDevtoolsEntry;
         query: AnyQuery;
     }[], clientLabel: string | null): void;
-    /**
-     * Downloads the whole panel as one JSON file: every registered entry with what it ran and what it
-     * 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 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;
     openArgsEditor({ entry, query }: QueryDevtoolsSelection): void;
@@ -1720,32 +1516,14 @@ declare class QueryDevtoolsComponent implements OnInit {
     clearForced(query: AnyQuery): void;
     refetchCacheEntry(entry: QueryRepositoryCacheEntry): void;
     evictCacheEntry(repository: QueryRepository, key: string): void;
-    /**
-     * Drops every entry of one client, consumers included - the cold-start check that does not need a
-     * reload. A query still bound to an evicted entry requests again on its next execution.
-     */
     evictAllCacheEntries(repository: QueryRepository): void;
-    /**
-     * Expands the response held under a cache key, which is the only way to read an entry no live query is
-     * bound to any more - the Queries tab has nothing to select for it.
-     */
     toggleCacheValue(clientName: string, key: string): void;
     isCacheValueExpanded(clientName: string, key: string): boolean;
     cacheFreshness(entry: QueryRepositoryCacheEntry): string;
-    /**
-     * What multi-tab sync is doing for a cache entry: whether this tab is the one polling the key, and
-     * how long ago it last took a response from another tab. Empty when the client has no sync.
-     */
     cacheSync(entry: QueryRepositoryCacheEntry, pollStates: Record<string, QueryKeyLockState>): string;
-    /**
-     * Whether a cache entry is showing data that came off the disk rather than the network - the answer
-     * to "why is this here already?" on a cold start. Empty when the client does not persist responses.
-     */
     cachePersistence(entry: QueryRepositoryCacheEntry): string;
-    /** How many responses this client has on disk, which is usually more than it has in memory. */
     persistedCount(client: QueryClient): number;
     clearPersistedQueries(client: QueryClient): void;
-    /** The path + query of a request URL (origin stripped), for readable cache/event identifiers. */
     requestPath(url: string): string;
     asStack(entry: QueryDevtoolsEntry): AnyQueryStack;
     asPagedStack(entry: QueryDevtoolsEntry): AnyPagedQueryStack;
@@ -1753,17 +1531,8 @@ declare class QueryDevtoolsComponent implements OnInit {
     asBatch(entry: QueryDevtoolsEntry): AnyQueryBatch;
     asAuth(entry: QueryDevtoolsEntry): AnyBearerAuthProvider;
     asWs(entry: QueryDevtoolsEntry): WebSocketDevtoolsHandle;
-    /**
-     * A socket's messages, narrowed by the filter box. Every whitespace-separated term has to match the
-     * event, the room or the direction, so `out join` finds the room joins the client sent.
-     */
     socketMessages(ws: WebSocketDevtoolsHandle): WebSocketDevtoolsMessage[];
-    /** How the message log labels a direction: what the client sent, versus what the server pushed. */
     socketDirectionLabel(message: WebSocketDevtoolsMessage): "↑ sent" | "↓ received";
-    /**
-     * Sends a message as the app would, so a server that only answers a client that asked can be provoked
-     * from the panel. An empty payload sends nothing rather than `""` - a plain event is a valid message.
-     */
     emitSocketMessage(options: {
         entry: QueryDevtoolsEntry;
         event: string;
@@ -1771,98 +1540,50 @@ declare class QueryDevtoolsComponent implements OnInit {
     }): void;
     socketEmitErrorFor(entryId: string): string | null;
     asForm(entry: QueryDevtoolsEntry): QueryDevtoolsFormHandle;
-    /**
-     * The queries a form feeds, discovered from the reads its `value()` recorded while their args were
-     * built - so a form that nothing consumes yet reads as exactly that.
-     */
     queriesDrivenByForm(entry: QueryDevtoolsEntry): QueryLink[];
-    /** The reverse: the forms whose value a query's args read. */
     formsDrivingQuery(entry: QueryDevtoolsEntry): QueryDevtoolsEntry[];
     selectForm(id: string): void;
-    /**
-     * The refreshes that re-executed a query, newest first - the answer to "why did this refetch?". Read
-     * off the event log, so it goes back exactly as far as the log does.
-     */
     refreshesFor(entryId: string): {
         id: number;
         timestamp: number;
         label: string;
     }[];
-    /** What asked for a refresh, on one line. */
     causeLabel(cause: QueryRefreshCause): string;
-    /** Derives the per-step status of a sequence step from its live progress signals. */
     sequenceStepStatus(sequence: QuerySequence<unknown[]>, index: number): QuerySequenceStatus;
     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): 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
-     * a refresh is due at a time the API would disagree with.
-     */
     authTokenLifetime(entry: QueryDevtoolsEntry): QueryDevtoolsTokenLifetime;
     queriesForSequence(sequence: QuerySequence<unknown[]>): QueryLink[];
-    /** The snapshot of a sequence step, once it has run (holds the args in and the response/error out). */
     stepSnapshot(sequence: QuerySequence<unknown[]>, index: number): AnyQuerySnapshot | null;
     toggleQueryGroup(key: string): void;
     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;
-    /** A feature and its options on one line, for a report or a chip's tooltip. */
     featureSummary(feature: QueryDevtoolsFeature): string;
-    /** The features of the client behind a cache tab card, or `null` for a client without any. */
     clientFeatures(client: QueryClient | null | undefined): QueryDevtoolsFeature[] | null;
     formatTime(timestamp: number | null): string;
-    /**
-     * The element a query was created in, which is what {@link locateQuery} can point at. `null` for a
-     * query created outside a component or directive injector - a root service, a resolver, a guard.
-     */
     locatableElement(entry: QueryDevtoolsEntry): HTMLElement | null;
-    /**
-     * Scrolls the element the selected query was created in into view and draws the inspect box over it -
-     * inspect run backwards. Where a query was *created* is not necessarily where its data is rendered,
-     * which is what the button's "created here" wording is for.
-     */
     locateQuery(entry: QueryDevtoolsEntry): void;
-    /** Downloads a file a tab generated. @see QueryDevtoolsHost.downloadTextFile */
     downloadTextFile(file: {
         name: string;
         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.
-     */
+    eventQueryId(event: EventLogItem): string | null;
     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;
     /**
@@ -1871,40 +1592,16 @@ declare class QueryDevtoolsComponent implements OnInit {
      * 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.
-     *
-     * `null` unless a run is picked, so a closed diff costs nothing to walk.
-     */
-    /**
-     * The two runs the comparison spans, 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. With only one end
-     * armed, `after` is absent unless an older body-holding run can stand in for the base.
-     *
-     * `null` unless a run is armed, so a closed diff costs nothing to walk.
-     */
-    /**
-     * The pair one step older or newer than the current comparison, keeping whatever gap it has, or `null`
-     * at either end of the retained bodies.
-     */
     private steppedDiffPair;
     private diffEnds;
     private isTabPrimary;
-    /** Moves the panel into a pop-up whose document has finished loading. @see popOut */
     private mountPopOut;
     /**
-     * The panel's chrome tokens as the app currently resolves them, so a pop-out keeps the surface it was
-     * docked in. Its own CSS resolves them from the host app's theme, and that theme is set on an ancestor
-     * the pop-out does not have - inherited afresh over there, the panel would take the document's theme
-     * (usually the light one) rather than the one it was just being read against.
-     *
-     * Empty on a browser that does not enumerate custom properties, which leaves the tokens to be
-     * inherited as before.
+     * The chrome tokens as the app resolves them now: the pop-out has no ancestor carrying the host theme.
+     * Empty on a browser that does not enumerate custom properties.
      */
     private chromeTokens;
     private inlineStyleOf;
-    /** Whether a `<head>` child carries CSS the pop-out needs a copy of. */
     private isStyleNode;
     /**
      * Copies the host document's stylesheets into the pop-up and keeps mirroring them while it is
@@ -1913,53 +1610,19 @@ declare class QueryDevtoolsComponent implements OnInit {
      * over there - so a one-time copy would leave everything first used after the pop-out unstyled.
      */
     private syncStylesInto;
-    /** Brings the panel back into the host element and closes the window it was living in. */
     private dockBack;
-    /** A registered query as a row that opens the detail drawer. */
     private queryLinkFor;
-    /** The activity of one entry, or the total of a group of them (a stack's queries, a whole tab). */
     private activityOf;
-    /** An activity summary on one line, for a report. `null` for a query that has not run. */
     private activitySummary;
-    /** {@link routeSegments} as a plain string, for the places that cannot render markup. */
     private queryRoute;
-    /**
-     * Describes a query the way a replay outside the app needs it: the URL, headers and body of the
-     * request it last made, or - for a query that has not run - what its current args would send.
-     */
     private exportedRequest;
-    /**
-     * The token refreshes the given requests authenticate with - one per auth provider they name, and
-     * only for a provider that is logged in, since a refresh request without a refresh token has
-     * nothing to send.
-     */
     private insomniaTokenRefreshes;
     private insomniaTokenRefresh;
-    /**
-     * Where the access token sits in the refresh response. A provider's `extractTokens` can pull it out
-     * of any shape, so the path is recovered by finding the live token in the last auth response - with
-     * the default extractor's `$.accessToken` as the fallback.
-     */
     private accessTokenPath;
-    /**
-     * How long Insomnia may reuse a stored refresh response: the access token's own lifetime with a
-     * margin, so the chain refreshes shortly before the token it hands out would expire. Capped at an
-     * hour - a long-lived (or bogus) `exp` should still hand out a token minted this session.
-     */
     private accessTokenMaxAge;
-    /**
-     * The headers a replay needs, including the ones the query client adds. Header providers can throw
-     * (a secure query's needs an access token), in which case the request is exported without them.
-     */
     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;
@@ -1975,37 +1638,20 @@ declare class QueryDevtoolsComponent implements OnInit {
     private sessionSocket;
     private sessionEvents;
     private sessionFaults;
-    /** Only the armed ones: a capture taken while the panel was answering requests has to say which. */
     private sessionMocks;
     private downloadFile;
     private stepKey;
     private paneSize;
-    /** The panel's size is the distance from the pointer to the edge it is docked to. */
     private applyResize;
-    /** A pane's size is the distance from the pointer to the container edge that pane sits against. */
     private applyPaneResize;
     private closePopup;
     private updateInspectHover;
     private selectInspectedQuery;
     private selectionKey;
-    /** Writes to the clipboard and ticks `copied` on success. `html` is omitted for plain-text payloads. */
     private writeToClipboard;
     private responseStatus;
     private findQuery;
     private pushEvent;
-    /**
-     * The registered query an event's request belongs to. A request is shared by every query on the same
-     * cache key, so the first owner is as good as any - they all show the same response.
-     *
-     * The url fallback is what makes a row clickable when the query is already gone: an error that fires
-     * as the component holding it is being destroyed (a `401` that redirects to login) has no live owner
-     * left to match on identity, and its tombstone holds a copy of the request rather than the request.
-     */
-    private resolveEventQueryId;
-    /**
-     * The size of a settled request's response, taken from its `content-length` when the response carried
-     * one and measured from the decoded body otherwise.
-     */
     private measureResponse;
     private refreshedRequestOf;
     private pushEventItem;
@@ -2016,7 +1662,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.13";
+declare const QUERY_DEVTOOLS_VERSION = "1.0.0-next.14";
 
 export { QUERY_DEVTOOLS_IMPORTS, QUERY_DEVTOOLS_VERSION, QueryDevtoolsAboutComponent, QueryDevtoolsComponent, QueryDevtoolsJsonComponent, QueryDevtoolsJsonStylesComponent, QueryDevtoolsSettingsComponent, QueryDevtoolsTimelineStylesComponent, clampFloatToPeek, kindOf, resizedFloatRect, settledFloatRect };
 export type { JsonKind };