---
title: Tools
description: Every agent tool the devtools expose, grouped by inspector, with what it answers and its arguments.
---
One hundred and two tools, grouped by inspector. Each one answers a question you would otherwise answer by clicking through the panel.
# Tools
This page lists every tool the [MCP server](./mcp-server.md) exposes. Each group matches an inspector in the panel.
The server's [prompts](./mcp-server.md#prompts) chain these tools into ready workflows, such as `debug-error` and `fix-form`.
## Before you call a tool
### Names
Tool ids use a colon, as `pangular:scan-routes`. MCP clients see them with an underscore, as `pangular_scan-routes`. The tables below drop the `pangular:` prefix. The `read` tools are also registered on the page under the same names, for [browser agents](./browser-agents.md).
Each tool has a short title that clients show in their tool lists. Every tool answers with one plain text block: markdown, or compact JSON for a source scan. See [Titles and answers](./mcp-server.md#titles-and-answers).
### Source and live tools
Each tool reads from one of three places. The stdio server registers only the tools that read your source, because no page reaches it.
Reads your files. Works over stdio and HTTP, with or without a browser.
Reads what a connected page reported. Needs the HTTP endpoint and the app open in a browser.
Reads what the Vite dev server recorded. Needs the Vite plugin.
### Analog, Capacitor and TanStack Query tools
The `analog-` tools, `capacitor-list-calls`, `capacitor-list-plugins`, `tanstack-list-queries`, `tanstack-inspect-query` and `tanstack-run-query` are listed only when the app uses the library: the project's `package.json` lists `@capacitor/core` or an `@tanstack/angular-query` package, the project is an Analog app, or a page reports the library's data. In the last case the server adds the tools and sends `notifications/tools/list_changed`. A client that doesn't follow it sees them when it reconnects. Setting `inspectors.` or `agent.tools.` in the [configuration](../getting-started/configuration.md#inspectors-and-agent-tools) turns them on or off for good. If the server can't read a `package.json`, it lists them all.
### A wrong project folder
If the server scans a folder with no Angular project in it (no `angular.json`, and no `package.json` that depends on `@angular/core`), every source tool refuses with `isError: true` and names the folder, instead of answering an empty list. Restart the server with `--root` or `PANGULAR_ROOT` set to the project folder. See [Connect over stdio](./mcp-server.md#connect-over-stdio).
### The page argument
Most page tools take an optional `page` argument to pick a browser tab. Without it, every tool reads the same default page: among the tabs that report the tool's data, a tab in the foreground before one in the background, then the tab that connected last. `list-pages` lists pages in that order, so its first row is the default page. The answer names the page it read on its first line (`Page .`), unless its text or JSON already names it.
Some calls name their page another way:
| Call | Page |
| -------------------------------------------------------- | ----------------------------------------------------------------------- |
| `run-form-action`, `fill-form`, a form tool given `form` | The tab in the form id (the part after `@`, as in `Checkout.form@ab12`) |
| `set-signal`, `set-component-property` | The one tab that has the instance `component` names |
| `ngrx-inspect-store`, `ngrx-history` given `store` | The tab of that store |
| `highlight`, `inspect-component` given `component` | Every tab is searched for the instance, default page first |
| `defer-blocks`, `for-blocks`, `hydration` | Every tab is listed |
Tools that change app state never pick one of several tabs on their own: `navigate`, `probe-route`, `record-guards`, `ngrx-dispatch`, `ngrx-restore`, `ngrx-store-devtools`, `tanstack-run-query`, `set-signal` and `set-component-property` refuse and list the tabs when more than one could take the call. The tables below leave `page` out.
If `page` names a tab that doesn't report that data, the tool answers `No page is reporting ...` and lists the tabs that do. It never falls back to another tab. A `page` that is not a string, such as a number, is refused the same way, and an empty string counts as left out. `page` is the only page argument: a call that sends `pageId` is refused.
### Arguments and refusals
The server checks each call's arguments against the tool's input schema before the tool runs: types, required arguments, allowed values and ranges. A wrong argument is answered with `Invalid arguments:` and a line for each argument that names what it takes, as in `` `limit` must be at most 50, not 1000000. ``. A `null` for an optional argument counts as left out.
The argument names are the same in every tool:
| Argument | What it names |
| ----------- | ----------------------------------------------------------------------------------- |
| `page` | A page id from `list-pages` |
| `component` | A component instance: an instance id, a class name or a host tag |
| `selector` | A CSS selector, and nothing else |
| `injector` | An injector: an environment injector name such as `Root`, a tag, a class or an id |
| `node` | A signal graph node, by id or label |
| `property` | A field on a component: an input, a property or a signal |
| `store` | A store, by id or name |
| `after` | A point in a log: a forms marker or an NgRx `seq`. Only entries after it are listed |
| `since` | A point in time: a duration back from now such as `30s`, a date, or epoch ms |
A call that sends an argument name a tool no longer takes, such as `selector` for `inspect-component` or `storeId` for `ngrx-history`, is refused with the name to use instead.
An argument that moved to another tool is refused with the tool to use: `record`, `flash`, `track` and `angularProfiling` on `change-detection` (use `record-change-detection`), `overlay` on `hydration` (use `highlight` with `hydration`), and `routeId` and `on` on `navigate` (use `list-routes` with `resolveLazy`, and `record-guards` with `on`).
A tool that refuses a call answers with `isError: true`. That covers a wrong or missing argument, a `page` that reports no such data, an action turned off in the config or under `agent.readOnly`, a form or action the page refuses, and a write that would have to guess the tab. The text starts with `Refused:` or `Invalid arguments:` and says what to change.
An action or destructive tool that does nothing also answers `isError: true`: no page to send it to, a target that matches nothing, a navigation the app cancelled or that failed, or a recording no page confirmed. An empty result of a read, such as no HTTP calls yet, is an ordinary answer.
Tools that start or stop a recording (`record-change-detection`, `record-pipes`, `track-subscriptions`) wait up to 3 seconds for each page to confirm, and name the pages that did.
### Older Angular versions
When the page's Angular lacks the debug API a tool needs, the tool answers **Unsupported on this Angular version** with the version the feature needs and the version the page runs, instead of an empty list. `inspect-signals`, `watch-signal`, `defer-blocks`, `for-blocks`, `change-detection` and `diagnose-change-detection` answer this way. `inspect-providers` puts the same note before a reduced tree. See [Supported Angular versions](../getting-started/installation.md#supported-angular-versions).
### list-pages
Lists the tabs, [Angular Native](../getting-started/angular-native.md) apps, [NativeScript](../getting-started/nativescript.md) apps and [Capacitor](../guides/capacitor.md) apps that report to the server, default page first (see [The page argument](#the-page-argument)): page id, URL, title, platform (`browser`, `Angular Native`, `NativeScript`, or `Capacitor (android)` and `Capacitor (ios)` for an app in a native WebView, followed by the page's Angular version when it reported one, as in `browser, Angular 15.2`), seconds since the last report or heartbeat, and which inspectors report. Takes no arguments. Reads: page. Use it to find the id to pass as `page`.
The URL comes from the HTTP or router report. A page that sends neither (no router, and no [HTTP setup](../getting-started/express.md)) still shows the URL its component tree reports, which also stands in when the other reports are more than 30 seconds older. A tab in the background stops reporting until it is shown again, so its last report is marked `(background)`: an old time there means the data is the last known state, not that the page is gone. A tab that closes leaves the list at once. A tab that crashes or is killed without closing leaves it, with all its data, 30 seconds after its last report or heartbeat.
### snapshot
Gives one page's full picture in one bounded markdown answer, for an agent that wants everything at once or a bug report. Reads: page. Each section comes from the tool named under its heading, with the same masking, so call that tool for the rest.
| Section | What it holds | Full answer |
| ------------- | ---------------------------------------------------------- | ----------------------- |
| `page` | Page id, URL, title, platform, Angular version, inspectors | `list-pages` |
| `components` | The component outline | `list-components` |
| `route` | The URL and the active route tree | `inspect-route` |
| `navigations` | Recent navigations, one line each, newest first | `explain-navigation` |
| `http` | HttpClient calls, newest first | `list-http-calls` |
| `errors` | Error groups, most recent first | `list-errors` |
| `console` | Console calls, newest first | `list-console` |
| `forms` | Each form with its status and error count | `inspect-forms` |
| `signals` | The signal graph, without Angular's own nodes and history | `inspect-signals` |
| `stores` | NgRx stores and Redux DevTools stores | `ngrx-inspect-store` |
| `queries` | TanStack Query queries and mutations | `tanstack-list-queries` |
| Argument | Required | What it is |
| ---------- | -------- | ---------------------------------------------------------------------- |
| `sections` | No | The sections to include, in the order above. Every section without it. |
| `limit` | No | Most items per section, 1 to 50 (default 10). |
| `maxChars` | No | Longest answer, 2,000 to 50,000 characters (default 20,000). |
Each section is also cut at 4,000 characters. When the answer reaches `maxChars`, it ends with a `Truncated` note that names the sections left out. A section whose inspector is off in `inspectors`, or whose tools are off in `agent.tools`, is listed under `Skipped`, and a section the page reported nothing for is listed as empty. The answer starts with the untrusted-data notice once, for every section.
### open-in-panel
Gives the user a link that opens the panel on one tab with one item selected, and switches the panels that are open to it. Reads: page. Use it to point the user at what you found.
| Argument | Required | What it is |
| -------- | -------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `tab` | Yes | The tab: `dashboard`, `timeline`, `audit`, `components`, `routes`, `signals`, `injectors`, `store`, `queries`, `forms`, `pipes`, `network` (SSR & HTTP), `errors`, `analog`, `capacitor` or `plugins`. Only tabs that are on count. |
| `id` | No | The item to select: a component id on `components`, the id of the component whose element injector to show on `injectors`, a form id on `forms`. Other tabs ignore it. |
| `page` | No | The page the item belongs to, from `list-pages`. |
The answer is a full URL, such as `http://localhost:4200/__devframes/pangular/#tab=components&id=12&page=k3x9`, when the hub serves the panel and a page has reported its address. Otherwise it is the hash to add to the panel's address. Each panel that is open and not in a background tab opens the link at once. The tool is `read`: it changes what the panel shows, not the app. See [Deep links](../getting-started/popup-and-hub.md#deep-links).
### wait-for
Waits until a condition holds on a page, then answers. Use it after a click, a navigation or an action instead of calling another tool in a loop. Reads: page. It reads what the collectors already reported and never changes the page. It answers as soon as the condition holds, or after `timeoutMs` with `Timed out after ms` and the last state it saw.
| Condition | Holds when | Argument | Inspector |
| ---------------- | ----------------------------------------------------------------------------------------- | ------------------------ | ---------- |
| `component` | A component matching `component` is rendered. | `component` (required) | Components |
| `component-gone` | No component matches `component` any more. | `component` (required) | Components |
| `navigation` | The router has no navigation in progress, and its URL matches `url` when given. | `url` | Router |
| `http-call` | An HttpClient call finished after the wait started, and its URL matches `url` when given. | `url` | SSR & HTTP |
| `error` | A new error was captured after the wait started, with the Angular code `code` when given. | `code`, such as `NG0100` | Errors |
| `form` | A form is `settled` (default), `valid`, `not-pending`, or `submitted` after a marker. | `form`, `until`, `after` | Forms |
| Argument | Required | What it is |
| ----------- | -------- | ------------------------------------------------------------------------------------------------------------------------------------- |
| `condition` | Yes | One of the conditions above. |
| `component` | No | An instance id, class name or host tag, as in `highlight`. |
| `url` | No | Text the URL contains. `*` matches anything and a leading `^` anchors it at the start of the path, as in [fault rules](#fault-rules). |
| `code` | No | An Angular error code. |
| `form` | No | A form id or label from `inspect-forms`. Every form without it. |
| `until` | No | For `form`: `settled` (no pending async validation, debounce or submit in flight), `valid`, `not-pending` or `submitted`. |
| `after` | No | For `form` with `until: "submitted"`: a marker from a forms answer. |
| `timeoutMs` | No | How long to wait. Default 5000, at most 30000. |
| `page` | No | The page id. Without it, every page counts, and `navigation` uses the most recent page. |
Without `url`, `navigation` holds as soon as no navigation is in progress, which can be before a navigation you just started reaches the page. Pass `url` to wait for the destination. A condition is offered only while its inspector is on for agents, and the tool is dropped when all five are off.
### Action tools
Every tool has one of three safety tiers. The server sends the tier to your client as the tool's read-only and destructive hints.
| Tier | What the tool can do | Tools |
| ------------- | ------------------------------------------------------------------------------------------------------------------------------------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
| `read` | Reads your source, the page or the server. `highlight` only shows and selects a component. | Every other tool, and every resource |
| `action` | Changes the running page, the server's fault rules and SSR overrides, or what the page records. A reload or the next call undoes it. | `navigate`, `probe-route`, `record-guards`, `ngrx-dispatch`, `ngrx-restore`, `ngrx-store-devtools`, `tanstack-run-query`, `run-form-action`, `fill-form`, `set-http-rule`, `remove-http-rule`, `set-ssr-override`, `remove-ssr-override`, `set-component-property`, `set-signal`, `watch-signal`, `record-pipes`, `track-subscriptions`, `record-change-detection` and `audit` |
| `destructive` | Can lose data: it erases recordings, or sends writes to your own API routes. | `clear-recordings` and `analog-run-api` |
The twenty-two action and destructive tools act on the app. Your client can ask you before it runs them.
When the hub is mounted, each finished call of an `action` or `destructive` tool posts an `Agent ran ` message to the hub, so you can see what the agent changed. `record-change-detection` posts only when it starts, stops or clears a recording, or turns a live view on or off, and `audit` only when it runs axe. See [Messages and badges](../getting-started/popup-and-hub.md#messages-and-badges).
### Turn tools off
The server decides which tools exist. Set `agent.readOnly` to keep only the `read` tools. `change-detection` reads a recording the panel started, and its hints, like those of `diagnose-change-detection` and `audit`, name only **Record** in the panel. `audit` stays without its `axe` argument, so it reads the last axe pass the panel ran. Set `agent.tools.` to `false` to hide one inspector's tools and resources, and keep its tab. Turning an inspector off with `inspectors`, or blocking an action with `actions`, drops the matching tools too. `wait-for` stays while any of the Components, Router, SSR & HTTP, Errors and Forms inspectors is on, with only the conditions of the inspectors that are. A [plugin's own tools](#plugins) follow the same switches, with the tier the plugin declares. `actions.router` drops `navigate` and `probe-route` and keeps `record-guards` and `list-routes` with `resolveLazy`. See [Inspectors and agent tools](../getting-started/configuration.md#inspectors-and-agent-tools).
## Source scan
These seven tools read your source and answer compact JSON. Every tool that reads only your files starts with `scan-` (after its library prefix, as in `ngrx-scan` and `analog-scan-routes`).
| Tool | What it answers | Arguments |
| ----------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | --------------------------- |
| `scan-routes` | Angular routes from your route files, with full URL path (parents and `loadChildren` prefixes included), kind (page, group, redirect or wildcard), guards, resolvers, and file and line. | None |
| `scan-components` | Components and directives from `@Component` and `@Directive` classes, with class name, selector, kind, inputs, outputs, change detection (components only), and file and line. | `filter`, `offset`, `limit` |
| `scan-signals` | `signal()`, `computed()`, `linkedSignal()`, `effect()`, `toSignal()` and resource declarations (`resource`, `httpResource`, `rxResource`), plus signal inputs, models and queries. | `filter`, `offset`, `limit` |
| `scan-providers` | DI providers: `@Injectable` services, `inject()` calls, constructor parameters and `providers` arrays, with token, file and where each one is provided. | None |
| `ngrx-scan` | NgRx declarations: `@ngrx/store` actions (with their type strings in `types`), reducers, effects, selectors, features and store setup, and `@ngrx/signals` `signalStore` (with its members), `signalState` and `signalMethod`. | None |
| `scan-pipes` | Custom `@Pipe` classes, and built-in pipes from `@angular/common` in use in templates, with purity, standalone status, and where each is declared or used. | None |
| `scan-build` | The project name, the Angular and TypeScript versions, SSR status, the Analog version in Analog apps, and a `builtAt` timestamp. | None |
`scan-components` and `scan-signals` answer at most `limit` items (default 200, at most 1,000) and at most 20,000 characters. A list that fits is the JSON array alone. A cut list is followed by a note with the items shown, the total and the `offset` of the next part, such as `Showing signals 1-200 of 450; 250 more not shown. Pass offset: 200 for the next part`. An item longer than 20,000 characters on its own is cut, so that answer is not valid JSON. Its note gives the `offset` of the next item. `filter` keeps the items whose fields contain the text, in any case: class name, selector, kind and file for components, and name, kind, file and component for signals.
## Components, signals and DI
### highlight
Highlights a component in the page, scrolls it into view, selects it and makes it the target of `inspect-signals`. The `component-tree` resource then carries its live `detail`, and the Components tab selects it too. Reads: page.
| Argument | Required | Value |
| ----------- | -------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `component` | one of | An instance id from the `component-tree` resource (like `c12`), a class name or a host tag. |
| `selector` | one of | A CSS selector. |
| `hydration` | one of | `true` outlines the hydrated, skipped, mismatched and dehydrated regions of a page rendered on the server, with a label on each and a legend. `false` removes the outline. |
Pass exactly one of the three. An instance id targets that exact instance, for example the second card of a list. A class name or tag that matches several instances picks the first and lists the ids of all of them. A `component` that matches no instance is refused, not sent on as a CSS selector. A CSS selector highlights but doesn't change the selection. With `page`, a CSS selector or the hydration outline goes to that tab only. The hydration outline draws in its own layer over the page, ignores the pointer and changes nothing in the app. It is the **Outline on page** button of the [Hydration](../inspectors/components.md#hydration) section.
### inspect-component
The live detail of one component instance: inputs, outputs and whether a parent listens, other own properties (signals and resources unwrapped), DOM listeners, host directives, change detection, encapsulation, host path and injected services. It selects the instance on its page and waits up to 3 seconds for the page to report it. Reads: page.
| Argument | Required | Value |
| ----------- | -------- | ---------------------------------------------------------------------------- |
| `component` | yes | An instance id from the `component-tree` resource, a class name or host tag. |
| `path` | no | One value to read instead of the whole detail, such as `user.address`. |
| `depth` | no | With `path`: levels to read below it, 1 to 5. Defaults to 1. |
| `limit` | no | With `path`: most entries per object or list, 1 to 1000. Defaults to 30. |
A class name or tag that matches several instances answers for the first and lists the ids of all of them. A class name or tag only finds components. The id of a directive host from `list-components` answers with the directives on that element, since it has no component detail. When nothing matches and the page's tree stopped at a [limit](../inspectors/components.md#selection), `inspect-component` and `highlight` say which one, since the instance can be past it. Secret-looking values are redacted.
Each value in the detail shows its first level. A nested object, array, `Map` or `Set` reads `{"$collapsed": type, "size": n}`, and a list cut at 30 entries ends with a `$more` count. Pass `path` to read that value: an input or property name, then keys and indexes, as in `user.address` or `items[0]`. An index into a `Map` or `Set` counts its entries. With `path`, the tool reads the value without changing the selection. It reads own data properties only, so getters never run, and it refuses a path through a redacted name. Each input and property carries `editInside` when a path inside it can be written with `set-component-property` or `set-signal`.
The answer stops at 20,000 characters. Past that, each value longer than 1,000 characters shows only the start of its JSON, then each list (inputs, outputs, properties, listeners, directives, injected services, and the inputs and outputs of each directive) keeps fewer entries. A note names the cut values and says how many entries are not shown. The `detail` of the `component-tree` resource has every value in full.
### list-components
The live component tree of one page as an indented outline, one line per instance: class name, host tag and instance id, as in `ProductCard c12`. An element that hosts directives but no component gets a line too, as in ` [routerLink] c14 [directive host: RouterLink]`. Reads: page.
| Argument | Required | Value |
| ---------------- | -------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `filter` | no | A search, as in the [Components](../inspectors/components.md#search-syntax) filter: plain text, `` and `[directive]`, such as ` [matTooltip]`. The outline keeps the matches and their ancestors. |
| `depth` | no | The most levels to list, `1` for the roots only. Unlimited by default. |
| `directiveHosts` | no | `false` leaves out the elements that host directives but no component. They are listed by default. |
Markers follow the id:
| Marker | Meaning |
| ------------------------------------- | ----------------------------------------------------------------------------------------------------------- |
| `[routed route /products]` | A router outlet shows this instance. A named outlet adds `outlet `. It needs the Router inspector on. |
| `[directives: RouterLinkActive, ...]` | The other directives on the host. |
| `[directive host: RouterLink]` | The element hosts these directives and no component. |
| `[hydration: skipped]` | In a page rendered on the server, the host was `skipped`, `mismatched` or created on the `client`. |
| `(+3 below)` | `depth` hides 3 instances under this one. |
Without `page`, it lists the default page among the tabs that have a component tree and names the other tabs that have one. The outline carries no input or property values. Pass an id to `inspect-component` for those, or to `highlight` to show the instance. The answer stops at 20,000 characters and says how to narrow it, and it says when the page's tree stopped at a [limit](../inspectors/components.md#selection).
### defer-blocks
The `@defer` blocks of each page: the component that holds each one, its state, its incremental hydration state, its triggers and whether it has `@loading`, `@placeholder` and `@error` blocks. A **Needs attention** list names blocks that failed to load and blocks still on their placeholder after 10 seconds. A block whose triggers only wait for the user (`on viewport`, `on interaction` or `on hover`) is not listed there: its row notes that it is waiting for its trigger. Times are counted on the page's clock, which the page sends with each report, so a page whose clock differs from the server's still gets the right age. Reads: page.
It takes only `page`.
Without a development build, the page has no util to read defer blocks, and the answer says so.
Each page lists at most 50 blocks in the table and 50 under **Needs attention**, with a note on how many more are not shown. The whole answer stops at 20,000 characters. If several tabs report, pass `page` to read one. The **Defer blocks** list on the [Components](../inspectors/components.md#defer-blocks) page has every block the page reported. A page reports its first 500 blocks. When it has more, the answer says so.
### for-blocks
The `@for` blocks of each page: the component that holds each one, its item count, what its `track` expression tracks by and whether it has an `@empty` block and shows it. A block with no items and no `@empty` block gets a note that it renders nothing. Reads: page.
It takes only `page`.
Angular reports the `track` expression as one of three kinds, not as its source text:
| Tracks by | Template |
| --------------- | --------------------------------------------- |
| `$index` | `track $index` |
| the item itself | `track item`, where `item` is the loop item |
| an expression | Any other expression, such as `track trip.id` |
The page reads the blocks with `ng.ɵgetControlFlowBlocks`, which Angular 22.0 added for development builds. On an older Angular or a production build, the answer says the page cannot list them. The page sends the item count only, never the items.
Each page lists at most 50 blocks, with a note on how many more are not shown, and says when the page has more than the 500 blocks it reports. The whole answer stops at 20,000 characters. If several tabs report, pass `page` to read one. The **@for blocks** list on the [Components](../inspectors/components.md#for-blocks) page has every block.
### scan-templates
Checks the component templates in your source, inline `template` and `templateUrl` files, with the compiler bundled with Pangular Inspector. The scan does not load compiler code from the project. Reads: source.
| Argument | Required | Value |
| ---------- | -------- | ---------------------------------------------------------------------- |
| `rule` | no | Only findings of this rule, one of the ids below. |
| `file` | no | Only findings in files whose path contains this text, such as `cart/`. |
| `severity` | no | Only findings of this severity: `error`, `warning` or `info`. |
| `limit` | no | How many findings to list, 1 to 200. Defaults to 50. |
| Rule | Severity | Finds |
| ---------------------- | --------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `template-parse-error` | `error` | An error the template parser reports, such as an unclosed element, a broken expression or `@for` without `track`. |
| `track-by-index` | `warning` | `@for` that tracks by `$index` (or an alias of it) while its body reads fields of the item, so the items are objects. Rows that bind a form directive, such as `[formControlName]="$index"` or `[formField]`, are skipped. |
| `img-missing-alt` | `warning` | ` ` without `alt`, `[alt]` or `[attr.alt]`, unless it has `role="presentation"`, `role="none"` or `aria-hidden="true"`. |
| `click-without-key` | `warning` | `(click)` on a plain element such as `` or `
` with no `keydown`, `keyup` or `keypress` handler. Buttons, links, form controls and components are skipped. |
| `legacy-control-flow` | `info` | `*ngIf`, `*ngFor`, `*ngSwitchCase` or `*ngSwitchDefault` where `@if`, `@for` or `@switch` would do. Skipped before Angular 17. |
| `ngclass-ngstyle` | `info` | `ngClass` or `ngStyle` where `[class]` or `[style]` bindings would do. |
Each finding gives its severity, rule, `file:line` and a fix. Errors come first. A template whose text has not changed since the last call is not parsed again. A backtick template built with `${}` is skipped.
### hydration
Hydration of each page that was rendered on the server: how many component hosts were hydrated, skipped with `ngSkipHydration`, mismatched or created on the client, and how many `@defer` blocks are still dehydrated. It names the skipped and client-created hosts and the dehydrated blocks, at most 30 of each, and each mismatch with a line diff of the server HTML Angular expected (`-`) and the client DOM it found (`+`). Reads: page.
It takes only `page`. Without it, it lists every page.
A page that was not rendered on the server gets an answer that says so. A page with server HTML but no hydrated host gets a note that client hydration is off or the build is a production build. To outline the regions on the page, call [`highlight`](#highlight) with `hydration: true`. The whole answer stops at 20,000 characters.
### change-detection
Change detection cycles recorded with Angular's profiler: the slowest components by self time, the most often checked components, lifecycle hook time per class and hook, output listener time, `afterRender` callback time, and the latest cycles with their duration, component checks, sync passes, hook and afterRender time and the output that ran before each one. Reads: page. Needs Angular 20 or later. It only reads; [`record-change-detection`](#record-change-detection) starts a recording.
| Argument | Required | Value |
| -------- | -------- | --------------------------------------------------------------------------------------------------------------------------------- |
| `limit` | no | Rows per list. Default 10, at most 50. |
| `export` | no | `json` returns the recording as the file the panel's **Import** reads. `trace` returns it in the Trace Event Format for Perfetto. |
Without `page`, it reads the default page among the pages that are recording. A `page` that names no connected tab gets the list of connected tabs. A connected tab that has not recorded yet gets a hint to start a recording there. The answer starts with the change detection mode of the page it reports on: zoneless, zone.js, or zoneless with zone.js still loaded. Recording is off until the panel or `record-change-detection` starts it. When older cycles were dropped at [`limits.cdCycles`](../getting-started/configuration.md#limits), the answer says how many. A recording lists at most 100 component classes and counts checks for up to 2000 instances. When it checked more, the answer says how many were left out. Once a page reports its live views, the answer ends with a line that says which views are on.
The `export` file is masked like other answers (JWTs, bearer tokens and secret names), has no instance check counts, and comes in a `json` code block to save as a `.json` file. An export over 100,000 characters is not returned, because cut JSON doesn't parse. The answer gives its size and the counts of cycles, timed spans, component classes, hook rows and output rows instead. Export it from the panel then, or clear the recording and record a shorter session. See [Export and import a recording](../inspectors/components.md#export-and-import-a-recording).
Each cycle line also names what started the cycle and how many of its refreshed checks changed nothing, when the page reports them. See [diagnose-change-detection](#diagnose-change-detection).
### record-change-detection Action
Starts, stops or clears a change detection recording, and turns the live views on or off. Read the result with [`change-detection`](#change-detection). Reads: page. Needs Angular 20 or later.
| Argument | Required | Value |
| ------------------ | -------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `record` | no | `start` starts a fresh recording on a page that is not recording and leaves a running one as it is, `stop` stops it and keeps the cycles, `clear` empties it. |
| `flash` | no | `true` turns the flash overlay on: a fading box with the class name and check count over each component Angular checks. `false` turns it off. |
| `track` | no | `true` writes each component check, lifecycle hook and output listener to a **Pangular** track in the Chrome Performance panel. `false` turns it off. |
| `angularProfiling` | no | `true` calls `ng.enableProfiling()` for Angular's own Performance panel track. It stays on until the page reloads, so `false` is refused. |
Pass `record`, a view or both. Without `page`, `record` goes to every connected page (`stop` only to the pages that record). `record` waits up to 3 seconds for each page to confirm and names the pages that did; when none does, or no page is connected, it refuses with `isError`. Call it with `record: "start"`, use the app, then call `change-detection`.
`flash`, `track` and `angularProfiling` go to the page in `page`, or to every connected page. An [Angular Native](../getting-started/angular-native.md) or [NativeScript](../getting-started/nativescript.md) app has no live views. The tool says there is no DOM when `page` names such an app, or when `page` is left out and every page that reports is one. `record` works on these apps as on a browser page. They are the **Live views** toggles of the panel; see [Watch checks live](../inspectors/components.md#watch-checks-live). With `agent.readOnly` the tool is not registered, so start the recording from the panel.
### diagnose-change-detection
Why change detection ran and what it wasted, from the recording that `record-change-detection` or the panel started. Reads: page. Needs Angular 20 or later.
| Argument | Required | Value |
| -------- | -------- | -------------------------------------- |
| `limit` | no | Rows per list. Default 10, at most 50. |
Without `page`, it reads the same page as `change-detection`. The answer starts with the page's change detection mode, then has these parts:
| Part | What it lists |
| ------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| **What started the cycles** | Cycles per cause, then the latest causes: a DOM event with its type, target and listener component, a signal write with the signal's `debugName`, an HTTP response, a timer, `markForCheck`, `setInput`, an effect, a view change, `ApplicationRef.tick()` from app code, or a zone.js tick that nothing in Angular asked for. Causes from app code carry its first app frames. |
| **Components that depend on zone.js** | Components that changed in ticks only zone.js started, with the zone.js tasks behind them, such as `setTimeout`. Without zone.js these components would not update. |
| **Wasted checks** | Per component class, the refreshed checks where nothing it renders changed, and its change detection strategy. |
| **Inputs that break OnPush** | Inputs mutated in place (same reference, other contents) and inputs given a new reference with the same contents, with the component that set them. |
| **Hints** | OnPush for a class refreshed at least 10 times that changed something in under 20% of them, or a note that it is already OnPush, plus a line per input and per zone.js dependent above. |
It only reads, so it stays with `agent.readOnly`. With no recording yet, it says to start one with `record-change-detection`. See [Why it ran and what it wasted](../inspectors/components.md#why-it-ran-and-what-it-wasted) for how the page finds causes and wasted checks.
### Edit a component Action
`set-component-property` and `set-signal` write a JSON value to one live component instance, in development only, and answer with the value it now holds, redacted like the component detail. Reads: page.
| Tool | Writes | How |
| ------------------------ | ----------------------------------------------------------------------------------------------- | --------------------------------------------------------------------- |
| `set-component-property` | An input or another property. Signals are refused; use `set-signal`. | Assigns the value, then runs change detection with `ng.applyChanges`. |
| `set-signal` | A writable signal the component holds as a property: `signal()`, `linkedSignal()` or `model()`. | Calls `.set()`. |
| Argument | Tool | Value |
| ----------- | ------------------------ | ------------------------------------------------------------------------------------------------------------------------------- |
| `component` | both | An instance id from the `component-tree` resource, or a class name or host tag that matches one instance. |
| `property` | `set-component-property` | The class property or public input name, or a path inside its value, like `user.name` or `items[0].title`. |
| `property` | `set-signal` | The signal property, or a path inside its value, like `filters.query`. The signal is set to a copy with that one value changed. |
| `value` | both | The new value as JSON. |
Both tools refuse, and write nothing, when:
- the target is a signal input (`input()` or `input.required()`), a `computed()` or an `asReadonly()` signal, a getter without a setter, a method or an output
- the value is not JSON, or the target holds a class instance, `Map`, `Date` or function
- a name on the path is redacted, or the target holds a redacted value (see [What is redacted](../security.md#what-is-redacted))
- a class name or tag matches several instances, or more than one tab reports components and `page` is missing
A parent binding sets a bound input again the next time its own value changes. Only signals held as component properties can be set; the signals that `inspect-signals` lists elsewhere cannot. Set [`actions.components`](../getting-started/configuration.md#actions) to `false` to drop both tools.
### find-leaks
Leak hints for one page, in three parts. Reads: page.
| Part | What it lists |
| ------------------------------------ | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| **Still retained** | Component instances destroyed but still in memory after at least 2 navigations and 10 seconds: class, instance id, the route they lived on, age, navigations since and open subscriptions. When the page has `ng.ɵgetInjectorProviders` (a development build of Angular 16.2 or later), Angular's DI debug data keeps every destroyed component in memory, so this part lists no instances and says so, pointing to the Chrome Memory panel. Detached views are named apart. |
| **Open subscriptions after destroy** | Subscriptions still open after the component that made them went away, grouped by class, instance and call site, with why each is flagged. Only while subscription tracking is on. |
| **Live effects and subscriptions** | Components with live effects (from `ng.ɵgetSignalGraph`, Angular 20.1 and later) or tracked open subscriptions, with instance ids for `inspect-component`. |
| Argument | Required | Value |
| ----------- | -------- | -------------------------------------------------------- |
| `component` | no | Only classes whose name contains this text, in any case. |
| `limit` | no | Rows per table, 1 to 200. Defaults to 20. |
Garbage collection runs when the browser decides, so the answer says "still retained" and points to the retainers in the Chrome Memory panel rather than calling it a leak. It also says what the page can't report: no `WeakRef` or debug API, no signal graph, or tracking off. Routes and call sites are masked like other live values. See [Leaks](../inspectors/components.md#leaks).
### Track subscriptions Action
`track-subscriptions` starts or stops subscription tracking on a page, the same switch as **Track subscriptions** in the Components panel. Reads: page.
| Argument | Required | Value |
| -------- | -------- | -------------------------------------------------------------------------------------------------- |
| `action` | yes | `start` or `stop`. |
| `page` | no | The tab to track. Defaults to the default page for `start`, and every page that tracks for `stop`. |
While on, the overlay wraps `Observable.prototype.subscribe` and records which component made each subscription. `stop` puts `subscribe` back. Subscriptions made before tracking started are not seen, so reload the tab or go to the screen again after `start`, then call `find-leaks`. Tracking patches the page, so `track-subscriptions` is an `action` tool and `agent.readOnly` drops it. No action covers it, so `actions` leaves it in place. `agent.tools.components: false` hides both tools.
### screenshot-component
An image of one component's host element as the page renders it now. The answer is an MCP image content block (PNG, or JPEG when the PNG is large) with a short note: the size in CSS pixels, what was masked and what could not be drawn. Reads: page.
| Argument | Required | Value |
| ----------- | -------- | -------------------------------------------------------------------------------------------------------------------------------------------------- |
| `component` | one of | An instance id from the `component-tree` resource (like `c12`), a class name or a host tag. |
| `selector` | one of | A CSS selector. |
| `page` | no | The page id, from `list-pages`. Without it, a `component` is searched on every page, default page first, and a CSS selector uses the default page. |
The page draws a copy of the element, not the screen: it copies the element's DOM with every computed style written inline into an SVG, and draws that on a canvas that is never added to the page. Nothing in the app changes, no app code runs, and a component scrolled out of view or behind a dialog is drawn all the same. Pass one of `component` and `selector`. A class name or tag that matches several instances captures the first and lists the ids of all of them, and one that matches none is refused. A CSS selector captures the first element it matches on the default page, or on `page`.
The copy masks what the [redaction](../security.md) masks in form values: password fields, fields where any of `formControlName`, `ng-reflect-name`, `name` or `id` looks secret (plus `redaction.secretNames`), and fields with a secret `autocomplete`. Any other element named that way, such as a custom form control ``, becomes a grey block with everything inside it, its inputs included. Elements marked `data-private`, `.sentry-mask`, `.rr-mask` or `data-pangular="mask"` become grey blocks, and `data-pangular="unmask"` keeps a field. JWTs, bearer tokens and secret `key=value` pairs in text are masked too.
What the copy can't show:
- Images, canvases and videos the page can't read, such as an image from another origin without CORS, are grey boxes. Background images from another origin are left out.
- Iframes are grey boxes with their tag.
- Web fonts don't load inside the copy, so text uses a fallback font and can wrap differently.
- Scroll positions inside the component, `::before` and `::after` content other than plain text, and elements past the first 3000 are left out.
- A component larger than 2000 pixels on its longest side is scaled down to fit.
The image needs an MCP client that shows image content, and devframe 1.2.6 or later to pass it on. With an older devframe, the tool answers with the note and no image. `agent.tools.components: false` hides the tool.
An [Angular Native](../getting-started/angular-native.md) or [NativeScript](../getting-started/nativescript.md) app has no DOM to copy. With its `page`, the tool says so without asking the app. Without `page`, the search skips those apps, and when only a device app reports, the answer says so.
### inspect-signals
The signal graph the page reported: nodes (`signal`, `computed`, `linkedSignal`, `effect`), dependency edges (`{ consumer, producer }`, where `consumer` reads `producer`, both node ids), the component or injector they belong to, and recent value history per node. Reads: page.
| Argument | Required | Value |
| ----------- | -------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------ |
| `component` | one of | Host tag, class name or instance id of the component, like `app-root`. Or `root`, or a route path like `/admin` or `Route: admin`. |
| `selector` | one of | A CSS selector for a component host, like `app-card.featured`. The first match is read. At most 500 characters. |
| `node` | no | A node id or label. The answer holds only that node, or every node with that label, with its direct producers and consumers and their resources and history. |
| `history` | no | `false` leaves out the value history. Defaults to `true`. |
| `framework` | no | `false` leaves out the nodes Angular itself created (`framework: true`). Defaults to `true`. |
Pass `component` or `selector`, not both. When the graph the page last reported belongs to another component or injector, the tool asks the page for the one you named, once, and the Signals page keeps showing what it showed. A `component` the component tree knows is read by its first instance. A `component` it doesn't know answers with the graph the page reported and says what that graph covers. A `selector` that matches no component host is refused.
The answer also holds:
| Field | Value |
| ---------------- | ---------------------------------------------------------------------------------------------------------------------------------------- |
| `resources` | One entry per `resource()`, `httpResource()` or `rxResource()`: `status`, `isLoading`, `params`, `value`, `error`, `nodeIds`. |
| `environments` | The root and route injectors the page can report, with `id` and `name`. |
| `changes` | On a node or resource, every change since the page first saw it. The history keeps the last 50. |
| `nodeCount` | Set when Angular reported more than the 400 nodes the page keeps. |
| `unnamedSignals` | Set when signals, computeds or linkedSignals in the graph have no `debugName`. Their history holds sampled values only. |
| `framework` | `true` on a node that Angular's router, forms or HTTP code created. See [Framework signals](../inspectors/signals.md#framework-signals). |
| `watch` | The node ids the page watches (`ids`) and whether write stacks are on (`stacks`). Set only while one of them is on. |
| `stack` | On a `write` history entry while write stacks are on: the first 3 app frames of the code that set the signal. |
The answer is cut at 20,000 characters. A graph that is too long first keeps fewer history entries per node, then keeps the first nodes that fit. A note under the JSON says how many history entries and nodes it left out. Pass `node` or `history: false` to see the rest.
With `root` or a route path, the tool asks the page for the effects of that injector and waits up to 1.5 seconds for the answer. It reads that graph once and leaves the Signals page on the target it shows. If no injector matches, the answer lists the ones the page knows. On Angular 20.0, the answer says the live graph needs Angular 20.1 or later.
The page reports one graph: the component picked on the Signals page or with highlight, otherwise the deepest component in the primary router outlet. Call highlight first to switch the graph to another component. Only signals a template or an effect has read appear.
### watch-signal Action
Watches a signal on the page, and turns write stacks on or off, the same switches as **Watch** and **Record write stacks** on the Signals page. Acts on: page.
| Argument | Required | Value |
| -------- | -------- | ---------------------------------------------------------------------------------------- |
| `node` | no | A node id or label from `inspect-signals`. A label watches every node with it, up to 20. |
| `watch` | no | `false` stops watching `node`. Defaults to `true`. |
| `stacks` | no | `true` records write stacks on the page, `false` stops. |
Pass `node`, `stacks` or both. A watched signal logs each change to the page console and shows under **Watched** on the Signals page. With write stacks on, each `write` entry in the `inspect-signals` history carries `stack`: the first 3 app frames of the code that set the signal, without Angular, packages, zone.js and the overlay. Taking a stack slows every signal write, so turn it off when you are done. Both reset when the page reloads.
Watching changes what the page records, so `watch-signal` is an `action` tool and `agent.readOnly` drops it. No action covers signals, so `actions` leaves it in place. `agent.tools.signals: false` hides it.
### inspect-providers
The injectors a page reported. Element injectors list what each component injected and which injector supplied it. Environment injectors run from the platform down to the root and route injectors, and list what the services they already created inject. Reads: page.
| Argument | Required | Value |
| ---------- | -------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `injector` | no | A tag name, a component or directive class name, an environment injector name like `Root`, `Platform` or `Route: admin`, an injector id, or a component instance id like `c12`. Returns only the matching injectors. |
| `token` | no | A token name, like `HttpClient`. Returns the injectors that provide it and the components or services that inject it. |
| `tokenId` | no | The id of one token, like `tok-3`, from `tokenId` in the tree. Keeps only that token when several share a name. |
An `injector` that names an element injector returns it with its lookup path resolved to names and provided tokens. One that names an environment injector, in any case, returns that injector's providers, what the services it already created inject, and its parent injectors. When nothing matches, the answer lists the tags and environment injector names on the page to retry with.
An element injector that belongs to a component carries `componentId`, the instance id that `inspect-component`, `list-components` and the `component-tree` resource use. `framework: true` marks the injectors and providers that come from the installed `@angular/*` packages; see [Framework injectors](../inspectors/injectors.md#framework-injectors).
Without `injector` or `token`, the answer is the whole tree and says which change detection mode the page runs. The answer stays within 20,000 characters and its JSON always parses. A larger tree shows element injectors as an outline (id, name, type, component, and provider and dependency counts), and when that is still too long it leaves out the deepest injectors and says how many. The environment injectors are always there, as an outline when they are large, and without their deepest injectors when even that outline is too long. An `injector` or `token` answer that is too long cuts each injector's `providers` and `dependencies` lists, with `providersTotal` and `dependenciesTotal` giving the full counts, so a large injector such as `Root` still shows. An `@ngrx/signals` store that an environment injector created carries the name the NgRx tools use, such as `TravelStore`, in `token`, and its class name `SignalStore` in `tokenClass`; `token` finds it by either name, and so do `read-provider-value` and `explain-injection`. `injector` and `token` take at most 500 characters each.
Each provider and dependency carries `tokenId`, the page's id for the token object, so two tokens with the same name, such as two `new InjectionToken('config')`, stay apart. A `token` that several tokens share lists every match with its `tokenId`, and `tokenId` keeps one of them. `read-provider-value` and `explain-injection` answer such a name with the candidates instead, and take `tokenId` to pick one. `read-provider-value` needs no `tokenId` when its `injector` leaves only one token with the name. Ids last until the page reloads. A tree from an older overlay has no ids, and the tools match by name.
When the page reported only part of its injector tree (it keeps at most 2000 element injectors and 2500 in all, and leaves out injectors nested more than 1000 levels deep), the answer says so.
### read-provider-value
The current value of a service or other provider that an injector on the page already created: its own fields, with signals and resources unwrapped and marked `signal` or `resource`, and methods left out. Each value shows its first level, and a nested object, array, Map or Set reads `{"$collapsed": type, "size": n}`. Nothing is created: an environment injector answers only for a value it already holds, and an element injector only for a token a component or directive on the page injected. Otherwise the answer says it was not created yet. Getters never run, and secret-looking names are redacted. Reads: page.
| Argument | Required | Value |
| ---------- | -------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `token` | yes | A class name like `CartStore` or an `InjectionToken` description like `API_URL`. |
| `tokenId` | no | The id of one token, like `tok-3`. Needed when several tokens share the name and `injector` doesn't narrow them to one; the answer then lists them. |
| `injector` | no | An injector id, `Root`, `Platform`, `Route: admin`, a tag or a component class name. Defaults to the first injector that provides the token, environment injectors first. |
| `path` | no | A member, then keys or indexes, like `items` or `cart.items[0]`. Without it, the answer lists the members. |
| `depth` | no | With `path`, the levels to read below it, 1 to 5. |
| `limit` | no | The most entries per object or list, 1 to 1000. Defaults to 30. |
A value without members, such as a string or an array from `useValue`, is shown whole. See [Peek at a provider value](../inspectors/injectors.md#peek-at-a-provider-value).
### explain-injection
How Angular resolves one token for one component, element or environment injector: each injector on the lookup path in order, whether it provides the token and why the lookup stops. It reads the injector tree the page reported, so nothing is created or injected. See [Explain a lookup with flags](../inspectors/injectors.md#explain-a-lookup-with-flags). Reads: page.
| Argument | Required | Value |
| ---------- | -------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `injector` | yes | Where the injection happens: a component or directive class name, a tag, a component instance id like `c12` (an error's owner id works), an injector id, or an environment injector name like `Root`. |
| `token` | yes | The token as the Injectors tab names it: a class name like `HttpClient` or an `InjectionToken` description like `API_URL`. |
| `tokenId` | no | The id of one token, like `tok-3`. Needed when several tokens share the name; the answer then lists them. |
| `self` | no | `true` asks only the first injector. |
| `skipSelf` | no | `true` starts at the parent injector. |
| `host` | no | `true` stops at the host element of the component that declares the start, where only its `viewProviders` and the component count. |
| `optional` | no | `true` ends in `null` instead of NG0201. |
The answer is a table of steps: **provides it**, **not provided**, **hidden** (a `viewProviders` entry the lookup can't see), **skipped**, **not asked** or **unknown**. A `providedIn: 'root'` service counts as provided once something on the page got it. When `injector` matches several injectors, the answer uses the first and lists the others. Before Angular 16.2 the path is rebuilt from the rendered tree and providers are unknown, and the answer says so. `injector` and `token` take at most 500 characters each.
### startup-timing
How the running app started, from navigation start: DOM content loaded, first contentful paint, when Angular started, when the root component was created, when the app was first stable, and the slowest providers to construct. Reads: page. See [Startup timing](../inspectors/injectors.md#startup-timing).
| Argument | Required | Value |
| -------- | -------- | --------------------------------------- |
| `limit` | no | Providers to list, 1 to 50. Default 10. |
When the overlay or the startup hook saw the app become stable, the time is exact. Otherwise the answer says the app was stable at or before the time the overlay looked. Provider times need the `startup-hook` entry on Angular 20 or later in a development build; without it the answer says how to add it.
## NgRx
These tools read the live `@ngrx/signals` and `@ngrx/store` state a page reported, and the sessions you export and import. `redux-inspect-stores` reads the other stores. Reads: page, or an imported session.
### ngrx-inspect-store
With `store`, the full state of one store: state, computed values, `withEntities()` collections (a summary of state and computed already there), methods with call counts, scope, where it is provided, and which components or injectors reference it. Without it, every store discovered so far, and the classic `@ngrx/store` state if present.
| Argument | Required | Value |
| -------- | -------- | ---------------------------------------------------------------------------------------------------------------------------------- |
| `page` | no | The tab to read. Defaults to every connected page. |
| `store` | no | A store id from a previous call or the [NgRx Store](../inspectors/ngrx-store.md) page, or the store's name, such as `TravelStore`. |
### ngrx-history
The change log for a page's stores, oldest first: `@ngrx/signals` state diffs (method calls and `patchState` writes, each with a per-key diff), classic `@ngrx/store` actions, and `@ngrx/signals/events` dispatched events. A method-call entry carries a duration in milliseconds. With `watchState` registered, it is the time from the start of the method to that patch; without it, the time the whole call took. A signal-store entry carries the event that caused it when the change happened while that event was being dispatched. Each entry lists up to 50 changes; when there were more, it ends with how many were left out, such as `12 more changes not shown`. With [`ngrx.trace`](../getting-started/configuration.md#ngrx) on, an entry names the closest app frame it came from.
| Argument | Required | Value |
| -------- | -------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `page` | no | The tab to read. Defaults to every connected page. |
| `store` | no | Only that store's entries, by id or name. Without it, every store, action and event. |
| `after` | no | A `seq` from a previous call. Returns only entries after it. Requires `page` when more than one page is connected, since each page has its own sequence numbers. |
### ngrx-inspect-entry
The State, Diff and Action of one past entry: the full redacted state of its store right after it, every change from the state before it (up to 500), and the action, method arguments, origin and causing event. The page keeps the raw states of the entries in its log, so any entry still in the log can be read. Events have no state of their own.
| Argument | Required | Value |
| --------- | -------- | --------------------------------------------------------------------------- |
| `seq` | yes | The entry number, from `ngrx-history` or the NgRx Store page. |
| `page` | no | The tab to read. Defaults to the default page among those that report NgRx. |
| `session` | no | The id `ngrx-import-session` returned, to read an imported session instead. |
### ngrx-export-session
A session of one store as JSON: the redacted state before the first entry, then each action or method call with the state changes it made. Save it as a `.json` file to import it later, here or on the NgRx Store page. The answer carries the JSON when it fits in 60,000 characters; otherwise it says to export a shorter range.
| Argument | Required | Value |
| -------- | -------- | ------------------------------------------------------------------------------------------------------------------------------------ |
| `store` | no | `store` for `@ngrx/store`, or a signal store id like `ngrx-1` or its name. Defaults to `@ngrx/store`, or the one store with entries. |
| `from` | no | The first entry number to include. |
| `to` | no | The last entry number to include. |
| `page` | no | The tab to read. |
### ngrx-import-session
Reads back a session that `ngrx-export-session` or the NgRx Store page exported, and answers with its id and entries. The server checks it first: the format and version, at most 1000 entries and 4,000,000 characters, and change paths that cannot reach a prototype. Nothing in the app changes. The server keeps at most 5 sessions, each for an hour after its last use.
| Argument | Required | Value |
| --------- | -------- | ----------------------------------- |
| `session` | yes | The exported session, as JSON text. |
### ngrx-generate-test
A Vitest spec that replays a range of entries: the state before the range, the recorded actions or method calls in order, and the state after the range as the expectation. An `@ngrx/store` range becomes a reducer spec, for one feature reducer when only one top-level key changed, or through `combineReducers` otherwise. A signal store range becomes a spec that injects the store with `TestBed`, sets the start state with `unprotected()` and checks `getState()`. The answer says which imports to point and which recorded values were cut or redacted. Jest runs the spec too once you drop the `vitest` import.
| Argument | Required | Value |
| --------- | -------- | ---------------------------------------------------- |
| `store` | no | The store, as for `ngrx-export-session`. |
| `from` | no | The first entry number to replay. |
| `to` | no | The last entry number to replay. |
| `page` | no | The tab to read. |
| `session` | no | An imported session id, to generate from it instead. |
### ngrx-explain-change
Why a state value changed. With `path`, the newest entries in the kept log (up to 5) whose diff wrote that path, a path inside it or one around it, newest first. Each lists what ran (the action, the method, a `patchState` outside a method, or an event), its arguments or action, its origin, the event that caused it, its duration, the changes to that path, and, with [`ngrx.trace`](../getting-started/configuration.md#ngrx) on, the app frames it was called from. With `seq`, that one entry with its whole diff. Without call sites, the answer says how to turn `ngrx.trace` on. It reads the newest page that matches; a change older than the kept log ([`limits.changeLog`](../getting-started/configuration.md#limits)) is not found.
| Argument | Required | Value |
| -------- | ------------ | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `path` | without seq | A state path as the diff writes it, from the state root (`cart.items`, `items[0].done`) or a signal store field (`filter`). **Copy path** in the state tree copies one. |
| `seq` | without path | An entry number, to explain that entry instead. |
| `store` | no | Only entries of that store, by id or name. `store` is the `@ngrx/store` Store. |
| `page` | no | The tab to read. Defaults to the newest page that reports NgRx. |
### redux-inspect-stores
Stores that report through the Redux DevTools extension API, such as NGXS, Elf and MiniRx (see [Other stores](../inspectors/ngrx-store.md#other-stores)). Without `store`, a table of the page's stores with their id, library and action count. With `store`, or when the page has one store, its last state and its latest actions, newest first, each with the action and a state diff of up to 50 changes. It never restores a state.
| Argument | Required | Value |
| -------- | -------- | ----------------------------------------------- |
| `store` | no | A store id, such as `r1`, or its name. |
| `limit` | no | How many actions to list, 1 to 200. Default 20. |
## Router
All router tools read the page, except `scan-render-mode`, which also reads your `*.routes.server.ts` files.
### Read the current route
| Tool | What it answers | Arguments |
| -------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------- |
| `inspect-route` | The current route: URL, query params, fragment, title, the navigation in flight, the active route tree (component, params, data, guards, resolvers) and the outlet tree with each outlet's `routerOutletData`. With `component`, the route a component was rendered for, or whether a link is active. | `component`: component class, element tag or link text |
| `explain-navigation` | Recent navigations, newest first: who started each one, redirects and loops with the cause of each hop, per-phase timing, guard and resolver verdicts, lazy loads, and the cancel or error reason in plain language. | `url`, `id`, `limit` (1 to `limits.navigations`, default 5), `perf`, `format` |
Use `explain-navigation` for "why was I redirected". Pass `perf: true` for "why is navigation slow": it lists the slowest navigations and preloads. Pass `format: "repro"` for a markdown repro of one navigation (`id`, or by default the latest one that did not succeed), with router options, any loop it is part of and the relevant slice of the route config. `format` is `explain` by default, and `repro` can't be combined with `perf`.
### Read the route config
| Tool | What it answers | Arguments |
| ------------------ | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ----------------------------------------- |
| `list-routes` | The live route config: every route with its full path, component or redirect, lazy state, guards, resolvers, title, source file and an example URL. | `match`, `audit`, `filter`, `resolveLazy` |
| `lint-routes` | Route config mistakes, such as routes after `**`, redirect cycles, redirect loops seen at runtime, deprecated class guards, missing titles and param typos. Each finding says how Angular reacts and how to fix it. Says how many links past the first 100 were not checked, as "at least" when the page stopped checking elements early. | none |
| `router-config` | How the router is set up (`provideRouter`, `forRoot or other` or `unknown`), effective options, enabled features, strategies, base href and hydration. | none |
| `scan-render-mode` | The `ServerRoute` and render mode (Server, Client, Prerender) a URL gets, plus server entries that match no client route. | `url`, defaults to the page URL |
`list-routes` takes four optional arguments:
| Argument | Value |
| ------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `match` | A URL such as `/users/42`. The tool predicts which route it hits, or the nearest routes when it hits none. |
| `audit` | Set to `true` to list the guards that protect each page. |
| `filter` | Only routes whose path or component contains this text. |
| `resolveLazy` | The route id of an unloaded lazy route, from this list. The page reads its routes without registering them, and the answer starts with the result, then lists the routes. |
`resolveLazy` only reads, so it stays with `agent.readOnly` and `actions.router: false`.
### Act on the router Action
Three tools act on the running app's router, in development only. Reads: page.
| Tool | What it does | Arguments |
| --------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------- |
| `navigate` | `action: "go"` goes to `url`, or to `pattern` with `params`, and waits for the outcome. `abort` stops the navigation in flight. `replay` runs navigation `id` again and compares the outcome. | `action` (required: `go`, `abort` or `replay`), `url` or `pattern` + `params`, `replaceUrl`, `skipLocationChange`, `waitFor`, `id` |
| `probe-route` | Runs the real matcher for `url` without navigating. It runs `canMatch` guards and may load lazy chunks. | `url` (required) |
| `record-guards` | Turns per-guard and per-resolver recording on (`on: true`, the default) or off, so `explain-navigation` shows each verdict and its time. | `on` |
The page's result comes back as a JSON block cut at 15,000 characters. A cut result ends with a note saying so. The result names the tab it ran on in `page`. After a guard or resolver redirect, `outcome` is `redirected`, `finalUrl` is where the app ended up, `redirect` holds the id and outcome of the navigation that followed, and `decidedBy` names the guard when guard recording (`record-guards`) is on.
Without `page`, each tool uses the one tab that reports a router. When several do, it does nothing and lists them, so call it again with `page`. A refused URL, a navigation the app cancelled or that failed, and an `abort` with nothing in flight answer with `isError: true`.
Only same-origin URLs that start with `/` are accepted. With `actions.router` set to `false`, `navigate` and `probe-route` are not registered; `record-guards` stays, since it only changes what the page records. All three are `action` tools, so `agent.readOnly` drops them.
`waitFor` sets when `navigate` with `go` answers:
| Value | When the tool answers |
| ------------ | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `navigation` | When the navigation ends. The default. |
| `stable` | When the navigation ends and the app has no pending tasks, such as HTTP requests or `httpResource` loads (the signal behind `ApplicationRef.whenStable()`). The result has `stable: true`, or `stable: false` with a note when 10 seconds pass first. |
If a `canMatch` guard or the navigation error handler redirects a probe, `probe-route` stops the redirected navigation before it matches or renders anything, and the result names the target in `redirectedTo`.
## NgRx actions
### Dispatch an action Action
`ngrx-dispatch` dispatches an action to the `@ngrx/store` Store of the running app, in development only, and returns the new log entry: the action, its origin and the state diff. Reads: page.
| Argument | Value |
| --------- | -------------------------------------------------------------------------------------------- |
| `type` | The action type, like `[Cart] Add Item`. `ngrx-scan` lists the types it finds in source. |
| `payload` | The action props as a JSON object, like `{"id": 7}`. It cannot have a `type` key. |
| `seq` | The number of an action in the log, to dispatch that action again. Use it instead of `type`. |
Without `page`, the tool uses the one page that has an `@ngrx/store` Store. If more than one page has a Store, it dispatches nothing and lists those pages with their URLs, so you can call it again with `page`. While a restore holds Store DevTools on a past state, the action is logged but does not change the state, and the answer says so. Set [`actions.ngrx`](../getting-started/configuration.md#actions) to `false` to drop the tool. Read the live state and log with the [`ngrx-store` resource](./resources.md#ngrx-store).
### Restore a state Action
`ngrx-restore` restores a past state in the running app, in development only, the way **Restore this state** does on the [NgRx Store](../inspectors/ngrx-store.md#restore-an-earlier-state) page. A signal store gets every state key set back to its value right after the entry. `@ngrx/store` jumps Store DevTools to the state after that action, which needs `provideStoreDevtools()`, and stays paused there until you go back. The log gets a `Restore #N` entry. Reads: page.
| Argument | Value |
| -------- | ------------------------------------------------------------------------------ |
| `seq` | The number of a restorable entry in the log. |
| `latest` | `true` sends Store DevTools back to the latest state. Use it instead of `seq`. |
Without `page`, the tool uses the one page that reports NgRx state. With several, it restores nothing and lists them. Set [`actions.ngrx`](../getting-started/configuration.md#actions) to `false` to drop the tool.
### Change the Store DevTools history Action
`ngrx-store-devtools` runs an operation on the `@ngrx/store` Store DevTools history of the running app, in development only, like the **Store DevTools history** controls on the [NgRx Store](../inspectors/ngrx-store.md#store-devtools-history) page. It needs `provideStoreDevtools()`. Every operation but `pause` adds a `Store DevTools: …` entry to the log. Reads: page.
| `op` | What it does | Other arguments |
| -------- | ------------------------------------------------------------------------------------------------------------------------------------- | --------------------------------------------------------------- |
| `toggle` | Skips the action of an entry, so the state is computed without it, or includes a skipped one again. | `seq`: the entry of an `@ngrx/store` action. |
| `jump` | Shows the state after an entry, like `ngrx-restore`, or a Store DevTools state by its index. The store stays on it until you go back. | `seq`, or `index`: 0 is the committed state. |
| `commit` | Makes the current state the new starting point. Earlier entries can no longer be restored. | none |
| `reset` | Puts the store back on its initial state and empties the history. Earlier entries can no longer be restored. | none |
| `pause` | Stops recording new actions, which still change the state but cannot be restored, or starts recording again. | `paused`: `true` stops, `false` starts. Without it, it toggles. |
Without `page`, the tool uses the one page that has an `@ngrx/store` Store. With several, it changes nothing and lists them. Set [`actions.ngrx`](../getting-started/configuration.md#actions) to `false` to drop the tool.
## TanStack Query
These tools read the `QueryClient` the app provides, through the page. See [TanStack Query](../inspectors/tanstack-query.md). Reads: page.
| Tool | What it answers | Arguments |
| ------------------------ | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | --------------------------- |
| `tanstack-list-queries` | The clients, then the queries and mutations: id, key, status, fetch status, freshness (`fresh`, `stale` or `invalidated`), when the data was last updated, observers and the error. | `status`, `search`, `limit` |
| `tanstack-inspect-query` | One query or mutation by `id`, or the query whose key contains `key`: its status, freshness, `staleTime`, `gcTime`, observers and failures, then its data (and a mutation's variables), read from the page now. | `id`, `key` |
`status` is one of `pending`, `error`, `success`, `idle`, `fetching` or `paused`, and matches a status or a fetch status. `search` keeps keys that contain the text, ignoring case. `limit` sets the rows per table, 1 to 300 (default 50). Keys, errors and data are masked like other live values.
### Invalidate or refetch a query Action
`tanstack-run-query` calls the app's own `QueryClient` for one query. `invalidate` marks it stale through `invalidateQueries()`, and a query with an active observer refetches at once. `refetch` fetches it again through `refetchQueries()`. Both run the query function, so the app sends its request again.
| Argument | Required | Value |
| -------- | -------- | ------------------------------------------------------ |
| `action` | yes | `invalidate` or `refetch`. |
| `id` | no | A query id from `tanstack-list-queries`, such as `q3`. |
| `key` | no | Text the query key contains, when there is no `id`. |
Without `page`, the tool refuses when more than one tab reports TanStack Query. Set [`actions.tanstackQuery`](../getting-started/configuration.md#actions) to `false` to drop the tool.
## Forms
All forms tools read the page. They cover Signal Forms, reactive forms and template-driven forms.
Two arguments come up in almost every tool:
| Argument | Value |
| -------- | ------------------------------------------------------------------------------------- |
| `form` | A form id (like `Checkout.form@ab12`) or part of its label (`Component.property`). |
| `path` | A dotted field path, like `address.city` or `items.0.qty`. Empty for the form itself. |
### Read form state
| Tool | What it answers | Arguments |
| ------------------------ | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ---------------------------------------------- |
| `inspect-forms` | Without arguments, each form with its status and error count, plus WebMCP tool state for Signal Forms that set `experimentalWebMcpTool`. With `form`, its field tree: value, status, touched, dirty and errors, and a `webMcp` entry with the tool name, inputs, registration status, blocking fields and recent calls. | `form`, `path`, `onlyInvalid`, `includeValues` |
| `explain-invalid-forms` | Which fields make a form invalid, and why: the failing validator, its message, the value and whether it was touched. Without `form`, every invalid or pending form. | `form`, `path` |
| `explain-field` | One field: where each error comes from, why validation is skipped, the binding and DOM facts like the label and visible error text. | `form`, `path`, or `selector` (a CSS selector) |
| `explain-submit` | What submit does, and why it might do nothing. Its recent submits say which fields and validators blocked or rejected them. | `form` |
| `inspect-form-payload` | What the form sends: `value` against `getRawValue()`, fields that are sent without validation, and which fields the user changed. | `form`, `path` |
| `explain-custom-control` | How a field is bound to its element, and what is wrong with the binding, such as value drift or a missing `setDisabledState`. | `form`, `path` |
For "why is this form invalid", call `explain-invalid-forms` first. The tools redact passwords and other secret-looking values.
Answers about large forms are cut to keep an agent's context small. Each cut ends with a note on what was left out and how to narrow the answer:
| Tool | Cap | Narrow with |
| ----------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ----------------------------------------------------- |
| `inspect-forms` | As many fields per form as fit in 20,000 characters, at most 200, taken level by level from the start of the tree. A group that lost fields carries `notShown` with the count. Values, error messages and metadata over 300 characters are cut. If not even one field fits, each form shows only its status and `notShown`. | `path`, `form` or `onlyInvalid` |
| `explain-invalid-forms` | 100 problems per form, then `… and N more not shown`. | `path` |
| `inspect-form-payload` | 8,000 characters per value. | `path` |
| `export-form` | The same field cap as `inspect-forms` for a snapshot. A fixture, header included, fits in 20,000 characters, and its header lists at most 20 failing fields. | `inspect-forms` or `inspect-form-payload` with `path` |
| `lint-forms` | 100 findings. | `form` |
| `explain-form-changes` | 100 changed fields. | `form` or a later `after` marker |
With `path`, `inspect-forms`, `explain-invalid-forms` and `inspect-form-payload` start at that group or field, so a cut part of the form can be read one group at a time.
The page itself reads at most 100 fields per group or array, and 8 levels deep. A group cut there carries `truncated` (the fields left out) and `truncatedInvalid` (up to 20 paths of invalid fields left out). The tools then say which group was cut, as in `keeps the first 100 of 150 fields (50 more not read)`, and `path` can't reach those fields. `explain-invalid-forms` and `explain-submit` name each invalid field past the cap, with its error when a Signal Form's `errorSummary` has it. If the form is invalid and no field the page read has an error, `explain-invalid-forms` says the failing field may be past the cap.
### Track changes
| Tool | What it answers | Arguments |
| ---------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------- |
| `list-form-changes` | A timeline of changes, each tagged with its origin (`user`, `code`, `devtools`, `binding`, `agent`). Writes from these MCP tools and the panel are `devtools`; `agent` marks a write through a WebMCP form tool. Returns the current marker. | `form`, `path`, `type`, `origin`, `after`, `limit` (default 50, at most 200) |
| `explain-form-changes` | The net change since a marker: each field whose value or status ended up different. | `form`, `after` |
| `export-form` | A JSON snapshot, or a test fixture with the expected status. Secret values stay redacted. | `form`, `format` (`snapshot` or `fixture`) |
| `lint-forms` | Form bugs, NG01xxx setup errors and model-aware accessibility checks, like a missing label or error text that is not linked. | `form` |
A `submit` event has an outcome: `ran`, `blocked` (the Signal Forms action did not run), `rejected` (the action returned errors) or `threw`. Its detail names the fields and the validator kinds that blocked it, or the fields and messages the action rejected. See [Submit view](../inspectors/forms.md#submit-view).
To wait until a form is settled, valid, not pending or submitted after a marker, call [`wait-for`](#wait-for) with `condition: "form"`.
Markers let an agent check its own work: read the marker, act, then call `explain-form-changes` with `after` set to it. A marker counts events across every open page and keeps counting after a page reloads, so it stays valid when the agent works in another tab.
### Act on a form
Both tools are action tools and need a development build. They don't write secret fields unless you unmask them. See [Opt fields in or out](../security.md#opt-fields-in-or-out). For Signal Forms, they don't write hidden, readonly or disabled fields either.
| Tool | What it does | Arguments |
| ----------------- | -------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------- |
| `run-form-action` | One action on a form or field. | `action` (required), `form` (required, the full id), `path`, `value`, `mode` (`code` or `user`), `confirm`, `force`, `snapshot` |
| `fill-form` | Fills several fields by path, through the inputs like a user would. Optionally submits afterwards. | `form` (required), `values` (required, a map of path to value), `mode`, `submit`, `confirm` |
When a write goes through a native `` (`mode: user`, the default for `fill-form`, or any write to a template-driven form), the value must equal the value of one of its options (`[ngValue]` or `value`). A multiple select takes an array. If no option matches, the field is not written and the result says `has no option with the value ...`. A `mode: code` write to a reactive form or Signal Form sets the model directly and does not check the options.
`run-form-action` accepts these actions: `set-value`, `mark-touched`, `mark-untouched`, `mark-dirty`, `mark-pristine`, `touch-all`, `revalidate`, `reset`, `enable`, `disable`, `submit`, `focus`, `focus-first-invalid`, `store-as-global`, `snapshot`, `restore` and `instrument`.
`run-form-action` and `fill-form` always act on the form `form` names. `store-as-global` does not overwrite a `$form` or `$control` that the page defined itself, unless you pass `force`.
`snapshot` keeps a copy of the form value, so it refuses a form whose value cannot be cloned, such as a control that holds a function. `inspect-forms` with `includeValues: false` also leaves out uncommitted input, model drift and metadata.
reset, submit and restore need confirm: true, and so does fill-form with submit. Disabled reactive fields need force.
## Pipes
### scan-pipe-usage
`scan-pipe-usage` checks the pipes in your source. Reads: source. No arguments.
It finds impure pipes used inside `@for`, `| json` left in templates, pure pipes whose `transform()` reads a signal, and method calls piped to `| async`. See [Lint](../inspectors/pipes.md#lint).
### Explain a pipe
`explain-pipe` explains one pipe: where it is declared or used, whether it is pure, live instance and call counts, the time spent in `transform` and the errors it threw, the last input and output, a stale-value warning, a churn warning, `| async` usages that resubscribe on every check or subscribe to the same source as another usage, and lint findings. Reads: source, plus the page for live counts.
| Argument | Required | Value |
| -------- | -------- | ----------------------------------------------- |
| `name` | yes | The pipe name as used after `\|` in a template. |
| `page` | no | The tab to read. Defaults to the default page. |
Live data comes from one tab: the one `page` names, or the default page. When more than one tab reports pipes, the answer starts with the tab it read. Live counts, times, errors, input and output appear while recording is on. Start it with [`record-pipes`](#record-pipe-calls) or with **Record calls** in the [Pipes inspector](../inspectors/pipes.md).
The **Live** line tells these cases apart:
| Case | What the tool says |
| ----------------------------------- | ------------------------------------------------------------------ |
| No page is connected | There is no live data. The stdio server always reports this. |
| A page is connected, pipe not used | No rendered component on the page uses the pipe. |
| Pipe in use, recording off | Instance count and components, plus a hint to start recording. |
| Pipe in use, recording on, no calls | Instance count and components, and that no calls are recorded yet. |
A pipe is churning when one of its instances returned an equal result 20 calls in a row while recording: a pure pipe whose input changes reference on every check while its contents stay the same, or an impure pipe that returns an equal object or array as a new reference. An impure pipe that returns the same reference or primitive is how impure pipes run, so it never counts.
### Suggest pipe migrations
`suggest-pipe-migrations` suggests how to move pipes to signals, with the file, line and template text of each use. Reads: source, plus the page for churn and stale findings. It changes no file: apply the suggestions by hand.
| Argument | Required | Value |
| -------- | -------- | ----------------------------------------------------------------- |
| `name` | no | Only this pipe, by the name used after `\|`. |
| `page` | no | The tab to read live findings from. Defaults to the default page. |
| Suggestion | When |
| ----------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------ |
| `\| async` to `toSignal()` | A template uses `\| async`. If a use pipes a method call, the answer names it and tells you to move the Observable to a field first. |
| Impure pipe to `computed()` | A custom pipe is `pure: false`. |
| Signal-reading pipe to `computed()` | The `signal-read-in-pure-pipe` lint rule fires for a pure pipe. |
| Churning pipe | While recording, the pipe churned (see [Explain a pipe](#explain-a-pipe)). |
| Stale pipe | While recording, the experimental stale check fired. |
Built-in formatting pipes such as `date` and `currency` are pure and cheap, so it suggests nothing for them. A lint rule set to `false` in `lint.rules` drops its suggestion too.
### Record pipe calls Action
`record-pipes` starts or stops call recording on a page, the same switch as **Record calls** in the panel. Reads: page.
| Argument | Required | Value |
| -------- | -------- | ------------------------------------------------------------------------------------------------------- |
| `action` | yes | `start` or `stop`. |
| `page` | no | The tab to record on. Defaults to the default page for `start`, and every page that records for `stop`. |
`start` records on the tab `page` names, or on the default page. Other tabs stay unpatched. `stop` stops that tab, or every tab that records without `page`; with none recording it refuses. The answer names the tabs that confirmed within 3 seconds. Each recording starts from zero, and the calls recorded so far stay after a stop. Call `record-pipes` with `action: "start"`, use the app, then call `explain-pipe`. Recording patches the page, so `record-pipes` is an `action` tool and `agent.readOnly` drops it. No action covers pipes, so `actions` leaves it in place. `agent.tools.pipes: false` hides it.
## SSR & HTTP
These tools read the HttpClient calls that `withPangular()` recorded and the SSR requests that `ssrMiddleware` or `withPangularSsr()` traced in your server. See [SSR & HTTP](../inspectors/ssr-http.md). Reads: page.
| Tool | What it answers | Arguments |
| --------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------ |
| `list-ssr-requests` | Recent traced SSR requests: id, URL, status, render mode, render time, server calls, and whether a connected page loaded the response. | `limit` |
| `explain-ssr-request` | One request end to end: timings, kept response headers, the router's guard and resolver times, each server call with its transfer cache outcome, then the browser page with its hydration result and the calls the browser made again. | `id`, `url` |
| `list-http-calls` | The HttpClient calls of one tab and the server render that served it, newest first: side (SSR or client), method, URL, status, duration, and flags for mocked, faulted, cancelled, redirected, transfer cache hit, the matched rule and the Angular API that likely started it (`likely httpResource()`, `likely resource()`, `likely @defer`). With `preview`, the masked response body, for failed calls too. With `view: "waterfall"`, the tab's client calls as a waterfall instead. | `url`, `failed`, `limit`, `preview`, `headers`, `view` |
| `lint-http` | Checks one tab's recorded client calls for duplicate GETs, waterfalls (calls that ran one after another and could start together) and server calls the browser made again. Each finding lists the call ids and what to try. | `page` |
`explain-ssr-request` picks the request by `id`, else the newest one for `url`, else the newest one.
`list-http-calls` lists one tab and the server calls of the SSR request that served it: the tab `page` names, or the default page. With no tab connected, it lists the server calls. `url` keeps calls whose URL contains the text. `failed` keeps calls with a status of 400 or more, no response, an error, or a cancel. `limit` defaults to 30 (at most 200). `preview` adds each call's response preview, including the body a failed call got back, such as a validation message or `problem+json`. `headers` adds each call's request and response headers. Secrets in URLs, errors, previews and headers are masked, and `url` matches the masked URL.
`lint-http` reads the tab `page` names, or the default page, and the server calls of the SSR request that served it. It leaves out transfer cache hits, mocked and cancelled calls, and reports three kinds of findings: a GET to the same URL again within 2000 ms on the same page URL, 3 or more calls where each started within 50 ms after the previous one ended, and a server call whose method, path and query the browser requested again. Each finding names the calls by the ids `list-http-calls` uses, the time it costs where that can be told, and a fix. URLs are masked.
`list-http-calls` with `view: "waterfall"` reads the tab `page` names, or the default page, and groups its client calls by navigation, newest first: each call's start offset in its navigation, duration, status and a text bar. A new navigation starts each time the page URL a call was made on changes. `limit` then sets how many navigations it shows, 5 by default (at most 50). `url`, `failed` and `preview` apply to the list only, and are refused with `view: "waterfall"`. `headers` adds each call's headers. `Authorization`, `Proxy-Authorization`, `Cookie` and `Set-Cookie` are always masked, as are names that look secret or match `redaction.secretNames`, and JWTs and bearer tokens in any value.
### Fault rules Action
These tools read and change the rules of [Fault injection](../inspectors/ssr-http.md#fault-injection), the same rules the panel shows. Rules live on the devtools server and apply to every connected tab, so the tools take no `page`. Reads: page.
| Tool | What it does | Arguments |
| ------------------ | ----------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------ |
| `list-http-rules` | Lists the rules in match order: id, on or off, method, URL pattern, where it applies (client, SSR or both) and its effect (status, delay, mock body). | none |
| `set-http-rule` | Adds a rule, or replaces the rule with `id`, and returns the saved rules. | `pattern` (required), `id`, `method`, `target`, `status`, `delayMs`, `body`, `chance`, `enabled` |
| `remove-http-rule` | Removes the rule with `id` and returns the rules left. | `id` (required) |
`set-http-rule` checks its input the way the panel's form does. `pattern` is a substring or a glob where `*` matches anything, up to 500 characters. A leading `^` anchors it at the start of the URL path. `target` is `client`, `server` or `both` (the default). `status` is one of the statuses the panel lists, or `0` to fail the request as a network error. `delayMs` runs from 0 to 10000. `chance` is a whole percent from 1 to 99: the rule then applies to that share of matching requests, rolled per request, and the others go on to the next rule. `body` is JSON text or a JSON value, up to 100,000 characters. A rule needs a `status`, a `delayMs` or a `body`, and there can be at most 50 rules. A rule that breaks one of these is refused with the reason, and nothing changes. A rule that applies to SSR takes effect on the next page load. Patterns and bodies in the answers are masked like recorded calls. The panel's presets are plain rules, so an agent sets the same ones: Offline is `pattern: "*", target: "client", status: 0`, Slow 3G is `delayMs: 2000` and Flaky is `status: 503, chance: 30`.
With [`actions.http`](../getting-started/configuration.md#actions) set to `false`, `set-http-rule` and `remove-http-rule` are dropped, and `list-http-rules` says that no rule applies.
### TransferState and SSR overrides Action
These tools read the [TransferState payload](../inspectors/ssr-http.md#transferstate-payload) a page was served with, and read and change the [SSR overrides](../inspectors/ssr-http.md#ssr-overrides), the same overrides the panel shows. Overrides live on the devtools server and apply to every page load that matches, so the override tools take no `page`. Reads: page.
| Tool | What it does | Arguments |
| ------------------------ | --------------------------------------------------------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------- |
| `inspect-transfer-state` | Lists the TransferState keys of a page with their kind (HTTP transfer cache, app state, hydration data, Analog) and size, or shows one key's value. | `page`, `key`, `search`, `limit` |
| `list-ssr-overrides` | Lists the overrides: id, on or off, kind, page pattern and effect. | none |
| `set-ssr-override` | Adds an override, or replaces the one with `id`, and returns the saved overrides. | `kind` (required), `pattern` (required), `id`, `message`, `key`, `value`, `enabled` |
| `remove-ssr-override` | Removes the override with `id` and returns the overrides left. | `id` (required) |
`kind` is one of these:
| `kind` | What it does | Arguments it takes |
| --------------- | --------------------------------------------------------------------------------------------- | ------------------ |
| `render-error` | Throws `message` (default `Simulated render error`) while the server renders a matching page. | `message` |
| `client-render` | Serves `index.csr.html` instead of rendering. | none |
| `state-edit` | Sets the TransferState entry `key` to `value`, or removes the entry when `value` is left out. | `key`, `value` |
`set-ssr-override` checks its input the way the panel's form does. `pattern` matches the page path and query like a fault rule's, up to 500 characters. `message` is up to 300 characters. `key` is up to 200 characters, with no spaces at either end, and a key with a masked part is refused because it can never match. `value` is JSON text or a JSON value, up to 100,000 characters. There can be at most 20 overrides. An override applies from the next full page load. Patterns, messages and values in the answers are masked like recorded calls.
`inspect-transfer-state` reads the default page among those that reported a payload unless `page` names another. `search` keeps keys and cached URLs that contain the text, and `limit` defaults to 50 (at most 500). The values are the masked and clipped copy the panel shows, so read them to find a key, and type the full value for `state-edit`. An HttpClient entry holds `b` (body), `s` (status), `st` (status text), `u` (URL) and `rt` (response type). Above the key list, it warns when the payload is over 100 KB, with its three largest entries, and names any URL the transfer cache stored under more than one key.
With [`actions.http`](../getting-started/configuration.md#actions) set to `false`, `set-ssr-override` and `remove-ssr-override` are dropped, and `list-ssr-overrides` says that no override applies.
### Clear recordings Destructive
Resets recorded data between reproduction runs: recorded HTTP calls, router navigations, and Analog server calls. Reads: page.
| Tool | What it does | Arguments |
| ------------------ | -------------------------------------------------------------------------------------------------------------- | --------------------------- |
| `clear-recordings` | Clears recorded HTTP calls, router navigations, or Analog server calls, and broadcasts the reset to the panel. | `target` (required), `page` |
`target` is one of `http`, `router`, `analog`, or `all`. With `router`, `page` clears navigations for that browser tab only; when left out, it clears navigations for every reporting page. A `page` that sends no router data gets an answer that lists the pages that do, and nothing is cleared.
Each target needs three settings turned on: its write action ([`actions.http`](../getting-started/configuration.md#actions), `actions.router` or `actions.analog`), its agent tools (`agent.tools.`) and its inspector (`inspectors.`). `target` lists only the targets that pass, plus `all`, and any other value is refused. With `all`, the targets that pass are cleared and the others are reported as skipped. When no target passes, the tool is not listed.
## Capacitor
These tools read what a Capacitor app reported: its platform, its plugins and the plugin calls it made. See [Capacitor](../inspectors/capacitor.md). Reads: page.
| Tool | What it answers | Arguments |
| ------------------------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | ------------------------------------- |
| `capacitor-list-calls` | Plugin calls, newest first: plugin and method, `native` or `web`, arguments, the result or the error with its code, and the duration. Marks **not implemented** calls and streams, and ends with the active listeners, their event counts and the masked payload of each one's last event. | `plugin`, `failed`, `slowMs`, `limit` |
| `capacitor-list-plugins` | The platform, the server URL, whether CapacitorHttp and native logging are on, the WebView user agent, and each plugin: available, imported, installed natively, its native methods, and a hint when they disagree. | none |
`plugin` keeps calls to one plugin, ignoring case. `failed` keeps calls that failed. `slowMs` keeps calls that took at least that many milliseconds, counting a pending call's time so far. `limit` defaults to 30 (at most 200). Without `page`, both tools answer for the default page among those with a native bridge, so a desktop tab of the same app doesn't hide the device, and they name the other pages that report. A long answer is cut at about 20,000 characters with a note on how to narrow it, and a plugin lists its first 20 methods. Native calls are logged on iOS and Android. Calls a web implementation answers are logged only when the app loads `@pangular-inspector/devtools/capacitor-hook` before `@capacitor/core`, and the answer says so when it doesn't. Arguments, results and errors are masked with the server's redaction too.
## Errors
These tools read what a page captured: errors from Angular's `ErrorHandler`, uncaught errors, unhandled promise rejections and console calls. See [Errors](../inspectors/errors.md). Reads: page.
| Tool | What it answers | Arguments |
| --------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ----------------------------------- |
| `list-errors` | Error groups, most recent first: id, count, when last seen, the Angular error code linked to its reference page, the message, the owning component with its instance id, and the source (`handler`, `window` or `promise`). | `code`, `limit` |
| `explain-error` | One error by `id`: message, count, sources, the owning component, the stack of the first occurrence, and for an Angular code its reference page and a short known cause. With `code` instead, the reference entry and the errors that carry it. An NG0100, a hydration mismatch or a missing provider adds its explainer. | `id`, `code` |
| `list-console` | Console calls, newest first: when, level, the text of the arguments and the Angular code it mentions. Calls repeated in a row show once with a count. | `level`, `search`, `since`, `limit` |
The explainers are the ones the [Errors](../inspectors/errors.md#explainers) tab shows. For NG0100: the binding, the template function, the previous and current value, the component fields that hold the new value, and the named signals written with it just before the check, with the code that wrote them when write stacks are on. For NG0500 to NG0503: a diff of the server HTML Angular expected and the client DOM it found. For NG0201 and `NullInjectorError`: the token and Angular's dependency path, to pass to `explain-injection`.
`code` accepts `NG0100`, `ng100` or `NG01203`. `explain-error` says so when Angular's error reference has no page for a code, and gives no known cause then. Pass the owner's instance id to `inspect-component` for its inputs and state. `list-errors` takes `limit` up to 100 (default 30), and `list-console` up to 200 (default 50). `since` keeps the console calls made since a duration back from now (`30s`, `5m`, `1h`), an ISO date or epoch milliseconds, so you can read what one reproduction logged. A call repeated in a row counts from its last repeat. The page keeps its last 200 calls and sends them while a panel or an agent watches, so an agent call to an idle page gets what it logged meanwhile. Messages, stacks and console text are masked like other live values.
## Audit
### audit Action
One ranked list of what is wrong on the page, gathered from the other inspectors, with an axe pass over the app on request. See [Audit](../inspectors/audit.md). Reads: page.
Each finding has a severity, an area, the component, route or URL it is about, one line on why, and the tool to call for detail, with its arguments. The answer also lists key numbers (mean and slowest change detection cycle, wasted checks, retained components, open subscriptions after destroy, errors, axe violations and failed HTTP calls) and the areas it could not read, under **Coverage**.
| Argument | Required | Value |
| ---------- | -------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `axe` | no | `true` runs axe-core over the app first. Without it, the audit uses the last axe pass on the page. |
| `session` | no | `before` saves this audit as the page's baseline. `after` audits again and compares with the baseline. `clear` drops the baseline. |
| `area` | no | `accessibility`, `errors`, `hydration`, `change-detection`, `leaks`, `router`, `forms`, `http` or `pipes`. `accessibility` also lists the elements that break each axe rule. |
| `severity` | no | `error`, `warning` or `info`: only findings at that severity or above. |
| `limit` | no | Rows to list, 1 to 200. Default 30. |
The audit reuses each inspector's own checks: `diagnose-change-detection` hints and checks slower than 16 ms, `find-leaks`, `explain-error`, `hydration`, `lint-routes`, `lint-forms`, `list-http-calls` and `scan-pipe-usage`. Change detection numbers need a recording from `change-detection`. Retention is not judged on a page whose Angular keeps DI debug data, the same as `find-leaks`. An area whose inspector is off, or whose agent tools are hidden with `agent.tools.: false`, is left out, and **Coverage** says which. With the Components agent tools hidden, axe findings name no component or instance id.
The axe pass loads axe-core into the page on demand and changes nothing in the app. It leaves out the overlay's own elements and frames, masks selectors, attributes and summaries, and leaves out text content. With `agent.readOnly`, the tool has no `axe` argument and is marked read-only. It refuses `axe: true` sent anyway, and `session: "clear"` and a `session: "before"` that would replace a baseline, so it never drops one the user took. Two audits that used the same axe pass don't compare accessibility, and a note says so. A reload of the tab drops its axe pass. A session is kept per page for 30 minutes after its last use, so it survives a reload of the tab. Comparing only works within one page id. See [Inspect, fix and verify](../guides/inspect-fix-verify.md) for the loop.
On an [Angular Native](../getting-started/angular-native.md) or [NativeScript](../getting-started/nativescript.md) app, the audit reads its change detection, leaks and errors, and sessions work as on a browser page. The app has no DOM, so `axe: true` answers that the pass did not run and why, and **Coverage** lists accessibility as off.
## Analog
These tools cover *Analog apps. Most read your source. Some also read what the Vite plugin recorded.
### Routes and files
| Tool | What it answers | Arguments |
| ------------------------------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ---------------- |
| `analog-scan-routes` | File routes in match order: URL pattern, page or layout file, route groups, params, the sibling `.server.ts`, and route meta. | `filter` |
| `analog-scan-url` | Which files render a URL (layouts, page, `.server.ts` load), the params, or why nothing matches. | `url` (required) |
| `analog-scan-api-routes` | Server routes under `src/server/routes` with method, URL and file, plus server middleware. | none |
| `analog-scan-server-functions` | Server functions (`serverFn` exports in any `.server.ts` under `src`) with name, method, file and id, how often each ran over HTTP and during server rendering, and reads called again right after hydration. | none |
| `analog-scan-content` | Markdown content files with slug, frontmatter, the route that serves them and parse errors. | `filter` |
### The running page
| Tool | What it answers | Reads | Arguments |
| -------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | ----------- | ------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `analog-inspect-page` | The open page: its files (layouts first, then pages in named outlets with the outlet name), the `load()` data it received, server rendering and hydration state, and hydration errors. | page | none |
| `analog-list-server-calls` | Recent page renders, `load()` fetches, form actions (with their outcome), server functions by name and API calls, with status, time and size. Flags a `load()` fetched twice and a seeded server function read called again. Each call names its tab when the dev server could tell. | Vite plugin | `kind` (`page`, `load`, `action`, `fn` or `api`), `route`, `limit`, `page` (only that tab's calls; leave it out for every call, untagged ones included) |
### Rendering
| Tool | What it answers | Arguments |
| ----------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | --------- |
| `analog-explain-render-modes` | For each page: server rendered, prerendered, cached, redirected or client only, the route rule or config that decides it, and what the last request actually did. Says when `vite.config` could not be read in full. | none |
| `analog-scan-prerender` | `prerender.routes` and `routeRules` with `prerender: true`, compared with the page files and the build output. Says when `vite.config` could not be read in full. | none |
### Call a server route Destructive
`analog-run-api` sends a request to a route on the running dev server, like `GET /api/v1/hello`, and returns the status, time and body. `path` is a path on the dev server that starts with a single `/`, not a full URL. `POST`, `PUT`, `PATCH` and `DELETE` need `confirm: true`. Secret keys, tokens and `Bearer` values in the body are masked. Reads: Vite plugin.
`path` must be an API route (under the API prefix, or any route in `src/server/routes`), an `/_analog` URL or a page of the app. The tool refuses Vite internals such as `/@fs/` and `/@id/`, Vite query flags such as `?raw`, `?url` and `?import`, `.` and `..` segments, and any path that names a file or folder in the project, so it can't read your source or files outside the app.
| Argument | Required | Value |
| --------- | -------- | ------------------------------------------------------------- |
| `path` | yes | An API route, an `/_analog` URL or a page path. |
| `method` | no | `GET`, `POST`, `PUT`, `PATCH`, `DELETE`, `HEAD` or `OPTIONS`. |
| `body` | no | A JSON body. |
| `confirm` | no | Required for methods other than `GET`, `HEAD` and `OPTIONS`. |
### Lint
`analog-lint` finds Analog mistakes: two files for one URL, a missing default export, a layout without `router-outlet`, bad API method suffixes, prerender entries that match nothing, frontmatter errors, and a `vite.config` it could not read in full (`config-partial`). It also reports live problems, like a `load()` fetched twice, a server function read that runs again after hydration, or a restart needed. Hydration errors and restart hints come from one page: pass `page` to pick it, or leave it out for the default page. If no page with that id sends Analog data, the answer says so and lists the pages that do.
analog-list-server-calls and analog-run-api need the Vite plugin . The plugin records the calls and knows the dev server address.
## Plugins
These tools read the views that [Pangular plugins](../guides/write-a-plugin.md) report from the page. Both read the page.
| Tool | What it answers |
| ---------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
| `list-plugins` | The page plugins each page runs, with version, status and pages, and the server plugins with their tools and tiers. Takes no arguments. |
| `inspect-plugin` | One plugin's view of a page as markdown: its tables, lists, stats and trees, its status, page actions and tools. Takes `plugin` (required, the plugin id) and `limit` (rows, 1-200). |
### A plugin's own tools
A server plugin adds tools named `plugin::`, which your client calls as `pangular_plugin__`. Built-in tools never start with `plugin`, so a plugin can't replace one. Each tool is `read` unless the plugin declares `action` or `destructive`, and its answer starts with a note that it comes from the plugin and the page. `agent.readOnly` and `actions.plugins: false` drop the tools that are not `read`. `plugins..tools: false` drops all of one plugin's tools and leaves the plugin out of `list-plugins` and `inspect-plugin`. MCP clients take tool names of up to 64 characters, so the server skips a plugin whose `pangular_plugin__` name is longer.
## Shared state
`devframe_state_read` reads the devtools' live shared state, for data no other tool covers. Call it without arguments to list the keys with their size and the tool that reads each one, then with `key` to read a value as compact JSON. It answers at most `maxChars` characters (default 20,000, at most 50,000) from `offset` and says where the next part starts. It leaves out the keys a [resource](./resources.md#shared-state) serves and the keys of an inspector whose agent tools are hidden (`agent.tools.: false`).
Use it for data that has no dedicated tool, such as hydration data and TransferState payloads (`pangular:http`, `pangular:http-payloads`) or live pipe usage (`pangular:pipe-usage`). See [Resources](./resources.md) for every key.
## Renamed tools
Tools and arguments were renamed in 1.0.0 so that each name follows one pattern: an optional library prefix (`ngrx-`, `redux-`, `tanstack-`, `capacitor-`, `analog-`), then a verb that says whether the tool reads source (`scan`), reads the page (`list`, `inspect`, `explain`, `lint`) or writes (`run`, `set`, `record`). The old names are not accepted.
| Before | Now |
| ---------------------------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------- |
| `get-routes`, `get-components`, `get-pipes`, `get-signals`, `get-providers` | `scan-routes`, `scan-components`, `scan-pipes`, `scan-signals`, `scan-providers` |
| `get-ngrx-store`, `build-meta` | `ngrx-scan`, `scan-build` |
| `lint-templates`, `lint-pipes`, `explain-render-mode` | `scan-templates`, `scan-pipe-usage`, `scan-render-mode` |
| `inspect-signal-store`, `signal-store-history` | `ngrx-inspect-store`, `ngrx-history` |
| `dispatch-ngrx-action`, `restore-ngrx-state` | `ngrx-dispatch`, `ngrx-restore` |
| `inspect-ngrx-entry`, `export-ngrx-session`, `import-ngrx-session`, `generate-ngrx-test` | `ngrx-inspect-entry`, `ngrx-export-session`, `ngrx-import-session`, `ngrx-generate-test` |
| `inspect-redux-stores` | `redux-inspect-stores` |
| `list-queries`, `inspect-query`, `query-action` | `tanstack-list-queries`, `tanstack-inspect-query`, `tanstack-run-query` |
| `list-capacitor-calls`, `list-capacitor-plugins` | `capacitor-list-calls`, `capacitor-list-plugins` |
| `analog-routes`, `analog-explain-url`, `analog-api-routes` | `analog-scan-routes`, `analog-scan-url`, `analog-scan-api-routes` |
| `analog-server-functions`, `analog-content`, `analog-prerender-plan` | `analog-scan-server-functions`, `analog-scan-content`, `analog-scan-prerender` |
| `analog-current-page`, `analog-server-calls`, `analog-call-api`, `analog-render-modes` | `analog-inspect-page`, `analog-list-server-calls`, `analog-run-api`, `analog-explain-render-modes` |
| `form-payload`, `form-history`, `form-diff`, `form-action`, `explain-form-invalid` | `inspect-form-payload`, `list-form-changes`, `explain-form-changes`, `run-form-action`, `explain-invalid-forms` |
| `wait-for-form` | `wait-for` with `condition: "form"` |
| `navigate` with `action: "navigate"`, `"probe"`, `"instrument"`, `"resolve-lazy"` | `navigate` with `action: "go"`, `probe-route`, `record-guards`, `list-routes` with `resolveLazy` |
| `export-navigation` | `explain-navigation` with `format: "repro"` |
| `http-waterfall` | `list-http-calls` with `view: "waterfall"` |
| `change-detection` with `record`, `flash`, `track` or `angularProfiling` | `record-change-detection` |
| `hydration` with `overlay` | `highlight` with `hydration` |
| `pageId` | `page` |
| `selector` naming a component | `component` |
| `selector` naming an injector | `injector` |
| `signal` in `set-signal` | `property` |
| `storeId` | `store`, which also takes a store name |
| `since` as a forms marker or an NgRx `seq` | `after` |
## Where to next