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

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

@@ -1,158 +1,9 @@
-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, AnyQueryBatchItemResult, QueryRepository, QueryClient, QueryKeyLockState, QueryDevtoolsFeature, QueryDevtoolsFault, AnyQueryStack, AnyPagedQueryStack, QuerySequence, AnyQueryBatch, AnyBearerAuthProvider, WebSocketDevtoolsHandle, QueryDevtoolsFormHandle, QuerySequenceStatus, AnyQuerySnapshot, QueryDevtoolsRun, QueryDevtoolsRunError, WebSocketDevtoolsMessage, QueryDevtoolsStorageScope, QueryDevtoolsApiEnvSwitch } from '@ethlete/query';
+import { QueryRefreshCause, QueryRepositoryEntryDestroyedCause, Query, QueryRepositoryCacheEntry, HttpRequestRetryState, HttpRequestLoadingProgressState, AnyQueryBatchItemResult, QueryRepository, QueryKeyLockState, QueryClient, AnyQueryStack, AnyPagedQueryStack, QuerySequence, AnyQueryBatch, AnyBearerAuthProvider, WebSocketDevtoolsHandle, WebSocketDevtoolsMessage, QuerySequenceStatus, AnyQuerySnapshot } from '@ethlete/query';
+import * as _angular_core from '@angular/core';
+import { OnInit } from '@angular/core';
 import { ResizeEdge, DragMoveEvent, ResizeMoveEvent } from '@ethlete/core';
-
-type AboutRow = {
-    label: string;
-    value: string;
-};
-type AboutGroup = {
-    title: string;
-    rows: AboutRow[];
-};
-/**
- * What is running: the loaded `@ethlete/*` versions, the Angular version and whatever the app handed to
- * `provideQueryDevtools({ about })`. A section rather than a tab body, so it can be shown anywhere.
- */
-declare class QueryDevtoolsAboutComponent {
-    protected readonly groups: AboutGroup[];
-    protected copied: _angular_core.WritableSignal<boolean>;
-    private copiedReset$;
-    constructor();
-    protected copy(): void;
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<QueryDevtoolsAboutComponent, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<QueryDevtoolsAboutComponent, "et-query-devtools-about", never, {}, {}, never, never, true, never>;
-}
-
-/** Which of a node's four pasteable forms a copy action asks for. */
-type QueryDevtoolsCopyPayload = 'value' | 'key' | 'path' | 'entry';
-
-/** A JSON value's kind as the value explorer (and its per-node override menu) categorizes it. */
-type JsonKind = 'string' | 'number' | 'boolean' | 'null' | 'undefined' | 'array' | 'object';
-type JsonEntry = {
-    k: string;
-    v: unknown;
-};
-/** A folded slice of a container's entries, rendered as its own collapsible row. */
-type JsonChunk = {
-    start: number;
-    end: number;
-    label: string;
-};
-declare const kindOf: (value: unknown) => JsonKind;
-/**
- * A recursive, collapsible, searchable JSON tree used by the query devtools value explorer. Renders
- * the *transformed* value the app actually sees (post `transformResponse`). Self-recurses via its
- * own selector - both for child entries and for the folded slices of an oversized container, which
- * re-enter as the same component with a `chunk` window over the same value.
- */
-declare class QueryDevtoolsJsonComponent {
-    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. */
-    search: _angular_core.InputSignal<string>;
-    /**
-     * When set, this node is not the value itself but a folded window over its entries. It shares the
-     * container's `path` so a child's persisted expansion does not depend on where the slice borders land.
-     */
-    chunk: _angular_core.InputSignal<JsonChunk | null>;
-    /** Full path of this node from the explorer root, used as the key for persisted expansion. */
-    path: _angular_core.InputSignal<string>;
-    /** Persisted paths explicitly expanded (overrides the depth default). */
-    expandedPaths: _angular_core.InputSignal<ReadonlySet<string> | null>;
-    /** Persisted paths explicitly collapsed (overrides the depth default). */
-    collapsedPaths: _angular_core.InputSignal<ReadonlySet<string> | null>;
-    /** When provided, expansion is externally persisted via this callback instead of local state. */
-    toggleFn: _angular_core.InputSignal<((path: string, expand: boolean) => void) | null>;
-    /** Same node as {@link path}, but as the array-of-steps an override op targets rather than a display key. */
-    jsonPath: _angular_core.InputSignal<JsonPath>;
-    /** The kind of the container holding this node, so its override menu can offer "duplicate this item". */
-    parentKind: _angular_core.InputSignal<JsonKind | null>;
-    /** When provided, every node renders an override menu that arms/clears ops through it. */
-    overrides: _angular_core.InputSignal<QueryDevtoolsOverridesRecorder | null>;
-    /**
-     * The declared type of each field, keyed by its path with array indices as `*` (`items.*.id`) - as
-     * {@link QueryDevtoolsSchemaSeed} produces it. A node with an entry labels itself with it.
-     */
-    annotations: _angular_core.InputSignal<ReadonlyMap<string, string> | null>;
-    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. */
-    private shapePath;
-    protected annotation: _angular_core.Signal<string | null>;
-    protected annotationTitle: _angular_core.Signal<string>;
-    /**
-     * 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[]>;
-    protected childChunks: _angular_core.Signal<JsonChunk[]>;
-    /** Entries rendered as rows - empty while they are folded into slices instead. */
-    protected visibleEntries: _angular_core.Signal<JsonEntry[]>;
-    /** Slices carry their window in the key so siblings persist independently of the container. */
-    private togglePath;
-    private defaultExpanded;
-    private localExpanded;
-    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>;
-    /** What the last copy put on the clipboard, or `null` once the tick has expired. */
-    protected copied: _angular_core.WritableSignal<QueryDevtoolsCopyPayload | null>;
-    private copiedReset$;
-    /**
-     * 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.
-     */
-    protected addressable: _angular_core.Signal<boolean>;
-    private valueLabel;
-    /**
-     * Doubles as the button's `title` and its `aria-label`, and names what landed while the tick is up -
-     * a bare `✓` stopped being unambiguous once the menu put four payloads behind one control.
-     */
-    protected copyLabel: _angular_core.Signal<string>;
-    protected preview: _angular_core.Signal<string>;
-    protected display: _angular_core.Signal<string>;
-    protected keyHit: _angular_core.Signal<boolean>;
-    protected valueHit: _angular_core.Signal<boolean>;
-    constructor();
-    protected childPath(key: string): string;
-    protected childJsonPath(key: string): JsonPath;
-    protected toggle(): void;
-    /**
-     * Writes one of the node's four pasteable forms. All of them go through here so the tick stays a
-     * single readout of what actually landed.
-     */
-    protected copy(payload: QueryDevtoolsCopyPayload): void;
-    /**
-     * Containers copy their whole subtree as JSON, slices only the entries they cover; leaves copy
-     * something pasteable - a raw string without the display quotes, so an id or url can go straight
-     * into a search box. `null` for a subtree that cannot be serialized at all.
-     */
-    private copyTextFor;
-    /** 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>;
-}
-
-/**
- * The value explorer's tree chrome, as a styles-only component the tree mounts itself - a session that
- * never opens a JSON view does not inject it.
- *
- * @internal
- */
-declare class QueryDevtoolsJsonStylesComponent {
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<QueryDevtoolsJsonStylesComponent, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<QueryDevtoolsJsonStylesComponent, "et-query-devtools-json-styles", never, {}, {}, never, never, true, never>;
-}
+import { QueryDevtoolsStats, QueryDevtoolsStatsHandle, QueryDevtoolsEntry, QueryDevtoolsRun, QueryDevtoolsFormHandle, QueryDevtoolsFeature } from '@ethlete/query/devtools-contract';
 
 /** 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';
@@ -324,11 +175,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. */
@@ -363,27 +211,6 @@ type CacheRow = {
     bytes: number;
     isEstimatedBytes: boolean;
 };
-/** A repository the panel found, together with the client name/base URL it was registered under. */
-type RepositoryInfo = {
-    repository: QueryRepository;
-    name: string;
-    baseUrl: string;
-    client: QueryClient | null;
-};
-/** One client's cache, as the Cache tab lists it - every entry measured, with the client's poll states. */
-type CacheView = {
-    name: string;
-    baseUrl: string;
-    repository: QueryRepository;
-    rows: CacheRow[];
-    bytes: number;
-    isEstimatedBytes: boolean;
-    unused: number;
-    pollStates: Record<string, QueryKeyLockState>;
-    client: QueryClient | null;
-    /** The entries this client has lost since the panel was loaded, newest first. */
-    dropped: DroppedCacheEntry[];
-};
 /** What each tab holds, as its badge reports it: how many entries, and how many of them are failing. */
 type TabBadge = {
     count: number;
@@ -391,459 +218,8 @@ type TabBadge = {
     errorNoun?: string;
 };
 
-/**
- * Everything a tab or the shared detail drawer reads from - or writes back into - the always-mounted
- * `<et-query-devtools>` panel: cross-tab registries, the JIT editor, copy/export actions, the value
- * explorer and pane sizing. A tab component only ever exists while it is the active one, so anything a
- * tab needs to survive being switched away from (a drawer's own selection, the persisted panel chrome)
- * has to live here instead of on the tab itself. Every member below is named and shaped exactly like the
- * panel's own field/method it stands in for.
- *
- * @see injectQueryDevtoolsHost
- */
-type QueryDevtoolsHost = {
-    selectTab(tab: DevtoolsTab): void;
-    /** Jumps to the Queries tab with this query selected - the Events tab is a way in, not a dead end. */
-    selectQuery(id: string): void;
-    /** Jumps to the Forms tab with this form selected. */
-    selectForm(id: string): void;
-    queryEntries: Signal<QueryDevtoolsEntry[]>;
-    stackEntries: Signal<QueryDevtoolsEntry[]>;
-    sequenceEntries: Signal<QueryDevtoolsEntry[]>;
-    batchEntries: Signal<QueryDevtoolsEntry[]>;
-    formEntries: Signal<QueryDevtoolsEntry[]>;
-    authEntries: Signal<QueryDevtoolsEntry[]>;
-    wsEntries: Signal<QueryDevtoolsEntry[]>;
-    repositories: Signal<RepositoryInfo[]>;
-    /**
-     * The cache per client, with every entry's size measured. Reading each response inside the computed is
-     * what keeps the totals current: a cache mutation bumps `cacheVersion`, but a response landing in an
-     * entry that is already there does not.
-     */
-    cacheView: Signal<CacheView[]>;
-    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. */
-    evictAllCacheEntries(repository: QueryRepository): void;
-    toggleCacheValue(clientName: string, key: string): void;
-    isCacheValueExpanded(clientName: string, key: string): boolean;
-    cacheFreshness(entry: QueryRepositoryCacheEntry): string;
-    cacheSync(entry: QueryRepositoryCacheEntry, pollStates: Record<string, unknown>): string;
-    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 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. */
-    tabBadges: Signal<Record<DevtoolsTab, TabBadge>>;
-    /**
-     * Every client the Faults tab can arm, with the fault it currently carries. Also feeds the
-     * cross-tab "Faults armed" banner and the session export, so it lives here rather than on the tab.
-     */
-    faultClients: Signal<{
-        name: string;
-        baseUrl: string;
-        fault: QueryDevtoolsFault;
-        armed: boolean;
-    }[]>;
-    /**
-     * The queries in scope before the Queries tab's own search box and status chips narrow them further:
-     * either the picked client's, or exactly the inspected element's. Also what the Timeline tab scopes
-     * its runs to, which is why this lives here rather than on the Queries tab alone.
-     */
-    scopedQueries: Signal<QueryDevtoolsEntry[]>;
-    /** 1-second tick driving every countdown/freshness readout across tabs. */
-    clock: Signal<number>;
-    findQuery(id: string | null): QueryDevtoolsSelection | null;
-    queryLinkFor(entry: QueryDevtoolsEntry | undefined, query?: AnyQuery): QueryLink;
-    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;
-    authTokenPayload(auth: AnyBearerAuthProvider): Record<string, unknown> | null;
-    authQueryKeys(auth: AnyBearerAuthProvider): string[];
-    /** 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): 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. */
-    isTampered(entry: QueryDevtoolsEntry): boolean;
-    /** Whether armed response overrides are stored and replayed on the next load. */
-    overridesPersist(): boolean;
-    toggleOverridesPersist(): void;
-    /** Where they are kept, named for a title or a hint (`sessionStorage`, `localStorage`, `not kept`). */
-    overridesScopeLabel(): string;
-    /** Puts the panel's layout, filters, pins and stored overrides back to defaults, keeping the settings. */
-    resetDevtools(): void;
-    requestProgress(query: AnyQuery): RequestProgress | null;
-    retryCause(status: number): string;
-    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;
-    stackActivity(stack: AnyQueryStack | AnyPagedQueryStack): QueryActivity;
-    sequenceActivity(sequence: QuerySequence<unknown[]>): QueryActivity;
-    queriesForStack(stack: AnyQueryStack | AnyPagedQueryStack): QueryLink[];
-    queriesForSequence(sequence: QuerySequence<unknown[]>): QueryLink[];
-    /**
-     * 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[];
-    sequenceStepStatus(sequence: QuerySequence<unknown[]>, index: number): QuerySequenceStatus;
-    stepSnapshot(sequence: QuerySequence<unknown[]>, index: number): AnyQuerySnapshot | null;
-    /** 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;
-    expandQueryGroup(key: string): void;
-    /** Which way the Queries list sorts by last-executed time - persisted. */
-    queryRecentFirst: WritableSignal<boolean>;
-    /** Whether the Queries list is arranged as a tree of route paths instead of a flat list - persisted. */
-    queryTreeView: WritableSignal<boolean>;
-    /** The path folders the user closed. Collapsed, not expanded - a tree opens open. */
-    collapsedQueryPaths: Signal<ReadonlySet<string>>;
-    toggleQueryPath(key: string): void;
-    /** The element a query was created in, or `null` for one created outside a component/directive. */
-    locatableElement(entry: QueryDevtoolsEntry): HTMLElement | null;
-    locateQuery(entry: QueryDevtoolsEntry): void;
-    locateState: Signal<'idle' | 'located' | 'offscreen'>;
-    resetStats(entry: QueryDevtoolsEntry): void;
-    executeQuery(selection: QueryDevtoolsSelection, allowCache: boolean): void;
-    resetQuery(query: AnyQuery): void;
-    formatDuration(ms: number | null): string;
-    formatBytes(bytes: number): string;
-    formatTransferred(bytes: number, isEstimated: boolean): string;
-    formatSpeed(bytesPerSecond: number): string;
-    formatPercent(percentage: number): string;
-    formatCountdown(ms: number | null): string;
-    formatTime(timestamp: number | null): string;
-    gqlDocument(doc: string): string;
-    inlineValue(value: unknown): string;
-    featureLabel(type: string): string;
-    featureSummary(feature: QueryDevtoolsFeature): string;
-    detailTab: WritableSignal<DetailTab>;
-    editorMode: WritableSignal<'none' | 'response' | 'args'>;
-    responseDraft: WritableSignal<string>;
-    argsDraft: WritableSignal<string>;
-    /** The text the currently open editor was seeded with - not a signal, see the field's own doc. */
-    editorSeed: string;
-    editError: Signal<string | null>;
-    openResponseEditor(query: AnyQuery): void;
-    openArgsEditor(selection: QueryDevtoolsSelection): void;
-    applyResponse(query: AnyQuery): void;
-    applyArgs(query: AnyQuery): void;
-    cancelEditor(): void;
-    forceLoading(query: AnyQuery): void;
-    forceError(query: AnyQuery): void;
-    forceEmpty(query: AnyQuery): void;
-    clearForced(query: AnyQuery): void;
-    diffRunIndex: WritableSignal<number | null>;
-    /** The run the diff compares against, or `null` to derive it - see the panel's own field. */
-    diffBaseRunIndex: WritableSignal<number | null>;
-    toggleRunDiff(entry: QueryDevtoolsEntry, run: QueryDevtoolsRun): void;
-    /** Which end of the open diff a run is, or `null` if it is not one of the two. */
-    diffRunRole(entry: QueryDevtoolsEntry, run: QueryDevtoolsRun): 'base' | 'compare' | null;
-    responseDiff(entry: QueryDevtoolsEntry): {
-        before: QueryDevtoolsRun;
-        after: QueryDevtoolsRun;
-        diff: QueryDevtoolsDiff;
-    } | null;
-    canDiffRun(entry: QueryDevtoolsEntry, run: QueryDevtoolsRun): boolean;
-    queryRuns(entry: QueryDevtoolsEntry): QueryDevtoolsRun[];
-    runStatus(run: QueryDevtoolsRun): string;
-    /** How many bodies a query retains, which is what bounds how far back a diff can reach. */
-    retainedResponseCount: Signal<number>;
-    /** Moves the whole response diff one run older or newer, from the diff header. */
-    canStepRunDiff(entry: QueryDevtoolsEntry, older: boolean): boolean;
-    stepRunDiff(entry: QueryDevtoolsEntry, older: boolean): void;
-    errorRunIndex: WritableSignal<number | null>;
-    toggleRunError(run: QueryDevtoolsRun): void;
-    pickedRunError(entry: QueryDevtoolsEntry): {
-        run: QueryDevtoolsRun;
-        error: QueryDevtoolsRunError;
-    } | null;
-    copiedReport: Signal<boolean>;
-    copiedInsomnia: Signal<boolean>;
-    copiedCurl: Signal<boolean>;
-    copiedGql: Signal<boolean>;
-    copiedRoute: Signal<boolean>;
-    copyReport(entry: QueryDevtoolsEntry, query: AnyQuery): void;
-    copyInsomniaRequest(entry: QueryDevtoolsEntry, query: AnyQuery): void;
-    copyCurlRequest(entry: QueryDevtoolsEntry, query: AnyQuery): void;
-    copyGqlDocument(doc: string): void;
-    /** The absolute URL of the last request, or the rendered route for a query that has not run. */
-    copyableRoute(entry: QueryDevtoolsEntry, query: AnyQuery): string;
-    copyableRouteTitle(entry: QueryDevtoolsEntry, query: AnyQuery): string;
-    copyRoute(entry: QueryDevtoolsEntry, query: AnyQuery): void;
-    refreshesFor(entryId: string): {
-        id: number;
-        timestamp: number;
-        label: string;
-    }[];
-    /** What asked for a refresh, on one line - shared by the drawer's "Refetched by" and the Events tab. */
-    causeLabel(cause: QueryRefreshCause): string;
-    formsDrivingQuery(entry: QueryDevtoolsEntry): QueryDevtoolsEntry[];
-    /** Shared value-explorer search term, read (and set) from every drawer's Data sub-tab. */
-    jsonSearch: WritableSignal<string>;
-    jsonSearchTerm: Signal<string>;
-    jsonExpandedPaths: Signal<ReadonlySet<string>>;
-    jsonCollapsedPaths: Signal<ReadonlySet<string>>;
-    toggleJsonPath(path: string, expand: boolean): void;
-    selectedClientName: WritableSignal<string | null>;
-    selectedQueryId: WritableSignal<string | null>;
-    selectedQuery: Signal<{
-        entry: QueryDevtoolsEntry;
-        query: AnyQuery;
-    } | null>;
-    queryFilter: WritableSignal<string>;
-    queryFacets: WritableSignal<ReadonlySet<QueryListFacet>>;
-    /** The entry ids sorted to the top of the Queries list. Persisted apart from the rest - see the panel. */
-    pinnedQueryIds: Signal<ReadonlySet<string>>;
-    isQueryPinned(entry: QueryDevtoolsEntry): boolean;
-    toggleQueryPin(entry: QueryDevtoolsEntry): void;
-    /** When set (via inspect), the Queries list is filtered to exactly these entry ids. */
-    inspectFilterIds: WritableSignal<string[] | null>;
-    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;
-    /**
-     * 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 a file a tab generated. The panel does it because the panel owns the download injector. */
-    downloadTextFile(file: {
-        name: string;
-        content: string;
-        type: string;
-    }): void;
-    stackSelectedQueryId: WritableSignal<string | null>;
-    stackSelectedQuery: Signal<{
-        entry: QueryDevtoolsEntry;
-        query: AnyQuery;
-    } | null>;
-    sequenceSelectedQueryId: WritableSignal<string | null>;
-    sequenceSelectedQuery: Signal<{
-        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;
-        query: AnyQuery;
-    } | null>;
-    /** The form whose detail the Forms tab has expanded - persisted. */
-    selectedFormId: WritableSignal<string | null>;
-    /** The rolling event log - persisted only in the sense that it survives a tab switch, not a reload. */
-    eventLog: WritableSignal<EventLogItem[]>;
-    /** The client (by base URL) the event log is scoped to, or `null` for all of them - persisted. */
-    eventClient: WritableSignal<string | null>;
-    /** Whether the event log is narrowed to failures - persisted. */
-    eventErrorsOnly: WritableSignal<boolean>;
-    /** Free-text narrowing of every socket's message log - persisted. */
-    socketFilter: WritableSignal<string>;
-    socketMessages(ws: WebSocketDevtoolsHandle): WebSocketDevtoolsMessage[];
-    socketDirectionLabel(message: WebSocketDevtoolsMessage): string;
-    emitSocketMessage(options: {
-        entry: QueryDevtoolsEntry;
-        event: string;
-        data: string;
-    }): void;
-    /** The message an emit box last failed with, if this is the socket it failed on. */
-    socketEmitErrorFor(entryId: string): string | null;
-    timelineSelectedQueryId: WritableSignal<string | null>;
-    timelineSelectedQuery: Signal<{
-        entry: QueryDevtoolsEntry;
-        query: AnyQuery;
-    } | null>;
-    /**
-     * The type annotations of each seeded mock body, by mock id. A mock only stores the *name* it was
-     * seeded from, and a body seeded from an inline schema has none, so this is the only thing that can
-     * label such a body - and it has to outlive the Mocks tab being switched away from.
-     */
-    seededTypes: WritableSignal<Record<string, ReadonlyMap<string, string>>>;
-    paneAxis: Signal<PaneAxis>;
-    listWidth: Signal<number | null>;
-    drawerWidth: Signal<number | null>;
-    listHeight: Signal<number | null>;
-    drawerHeight: Signal<number | null>;
-    startPaneResize(event: PointerEvent, target: {
-        pane: PaneTarget;
-        container: HTMLElement;
-    }): void;
-    resetPaneSize(pane: PaneTarget): void;
-};
-
-type ScopeKey = 'viewState' | 'pins' | 'overrides' | 'mocks' | 'armedMocks' | 'armedFaults' | 'authSessions';
-type ScopeRow = {
-    key: ScopeKey;
-    label: string;
-    /** What is kept, and what `none` costs - the one thing a scope picker cannot show on its own. */
-    hint: string;
-    /**
-     * What to say on the scopes that let this state outlive the page that armed it - a picker cannot show
-     * that an app is about to start lying to itself before anyone opens the panel.
-     */
-    warn?: {
-        scopes: QueryDevtoolsStorageScope[];
-        text: string;
-    };
-};
-type LimitKey = 'maxEvents' | 'maxDroppedCacheEntries';
-type LimitRow = {
-    key: LimitKey;
-    label: string;
-    min: number;
-    max: number;
-    step: number;
-    hint: string;
-};
-/**
- * Every panel-wide switch in one place - the storage each kind of state uses, the limits the panel would
- * 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: {
-        value: QueryDevtoolsStorageScope;
-        label: string;
-    }[];
-    protected readonly INDEXED_DB_TITLE = "Unavailable: these are read synchronously - view state before the first render, overrides before the first fetch - and IndexedDB cannot answer in time. Only the mock library could tolerate an async store, and it is not wired to one yet.";
-    protected readonly LIMIT_ROWS: LimitRow[];
-    protected readonly ARM_ALL_MOCKS: () => void;
-    protected readonly DISARM_ALL_MOCKS: () => void;
-    protected readonly DISARM_ALL_FAULTS: (clientName?: string) => void;
-    /** What queries actually retain, which is the application's value unless this panel raised it. */
-    protected responseHistory: _angular_core.Signal<number>;
-    protected mockCount: _angular_core.Signal<number>;
-    protected sessionCount: _angular_core.Signal<number>;
-    protected armedMockCount: _angular_core.Signal<number>;
-    protected armedFaultCount: _angular_core.Signal<number>;
-    /** The same keys the Events tab's own picker offers - see {@link queryDevtoolsEventClients}. */
-    protected eventClients: _angular_core.Signal<string[]>;
-    protected resetConfirming: _angular_core.WritableSignal<boolean>;
-    protected readonly FORGET_SESSIONS: () => void;
-    /** The backends the application declared, or an empty list - the card renders only for a declared one. */
-    protected apiEnvs: _angular_core.Signal<QueryDevtoolsApiEnvSwitch[]>;
-    /** The env id (or typed URL) a switch's key holds, or `null` while the application picks for itself. */
-    protected apiEnvValue(apiSwitch: QueryDevtoolsApiEnvSwitch): string | null;
-    /** The env a switch falls back to with nothing stored, described for the default button. */
-    protected apiEnvFallback(apiSwitch: QueryDevtoolsApiEnvSwitch): {
-        label: string;
-        production: boolean;
-    };
-    /** Whether the pick in force - the stored env, or the fallback behind an unwritten key - is production. */
-    protected apiEnvIsProduction(apiSwitch: QueryDevtoolsApiEnvSwitch): boolean;
-    /** A stored value no declared env carries, which is a URL somebody typed in below. */
-    protected apiEnvCustomUrl(apiSwitch: QueryDevtoolsApiEnvSwitch): string;
-    /** Writes the application's own key and reloads - it is read before Angular boots, so nothing else can. */
-    protected pickApiEnv(apiSwitch: QueryDevtoolsApiEnvSwitch, value: string | null): void;
-    protected setCustomApiUrl(apiSwitch: QueryDevtoolsApiEnvSwitch, value: string): void;
-    protected settings(): _ethlete_query.QueryDevtoolsSettings;
-    protected scopeOf(key: ScopeKey): QueryDevtoolsStorageScope;
-    protected limitOf(key: LimitKey): number;
-    /** What the picked scope means beyond where the state is kept, or `null` while it means nothing extra. */
-    protected warningFor(row: ScopeRow, scope: QueryDevtoolsStorageScope): string | null;
-    /** Why one scope is not on offer for a row, for the button's title, or `null` while it is. */
-    protected unavailableReason(row: ScopeRow, scope: QueryDevtoolsStorageScope): "Unavailable outside a development build: live access and refresh tokens, and the credentials you typed in, must not outlive this tab on a deployed origin. The vault keeps nothing here unless you pick Session, which keeps it for as long as the tab." | null;
-    protected setScope(key: ScopeKey, scope: QueryDevtoolsStorageScope): void;
-    protected setLimit(key: LimitKey, value: string): void;
-    protected setResponseHistory(value: string): void;
-    /** Hands retention back to `provideQueryDevtools({ responseHistory })`. */
-    protected clearResponseHistory(): void;
-    protected reset(): void;
-    protected toggleGoneQueries(): void;
-    protected showsGoneQueries(): boolean;
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<QueryDevtoolsSettingsComponent, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<QueryDevtoolsSettingsComponent, "et-query-devtools-settings", never, {}, {}, never, never, true, never>;
-}
-
-/**
- * The waterfall's grid, axis and bars, as a styles-only component the panel mounts when the Timeline tab
- * is first opened.
- *
- * @internal
- */
-declare class QueryDevtoolsTimelineStylesComponent {
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<QueryDevtoolsTimelineStylesComponent, never>;
-    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;
@@ -889,35 +265,6 @@ type PersistedState = {
     jsonExpanded?: string[];
     jsonCollapsed?: string[];
 };
-type ViewportSize = {
-    width: number;
-    height: number;
-};
-/**
- * The loosest a float may sit: shoved off an edge with only {@link FLOAT_PEEK} left, which is what a
- * drag and a parked panel are held to. **North is never a parking edge** - the title bar is the only
- * 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;
-}) => FloatRect;
 /**
  * A floating, dockable panel that inspects the live state of the signals-first `@ethlete/query`
  * system: queries, stacks, sequences, bearer auth providers, the repository cache and a rolling
@@ -941,11 +288,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 +336,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 +369,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 +412,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 +445,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 +453,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 +538,20 @@ 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>;
-    /** @internal */
-    inspectHover: 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 inspectActive: _angular_core.WritableSignal<boolean>;
+    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 +562,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 +569,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;
+        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 +624,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 +712,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 +724,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 +746,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 +760,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 +769,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 +780,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;
     /**
@@ -1646,19 +820,12 @@ declare class QueryDevtoolsComponent implements OnInit {
      */
     pickedRunError(entry: QueryDevtoolsEntry): {
         run: QueryDevtoolsRun;
-        error: _ethlete_query.QueryDevtoolsRunError;
+        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 +835,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 +858,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 +873,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 +882,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 +934,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 +952,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 +980,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 +1004,6 @@ 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.15";
 
-export { QUERY_DEVTOOLS_IMPORTS, QUERY_DEVTOOLS_VERSION, QueryDevtoolsAboutComponent, QueryDevtoolsComponent, QueryDevtoolsJsonComponent, QueryDevtoolsJsonStylesComponent, QueryDevtoolsSettingsComponent, QueryDevtoolsTimelineStylesComponent, clampFloatToPeek, kindOf, resizedFloatRect, settledFloatRect };
-export type { JsonKind };
+export { QUERY_DEVTOOLS_IMPORTS, QUERY_DEVTOOLS_VERSION, QueryDevtoolsComponent };