Pangular Inspector
On this page ▾
Your NgRx state as it changes. Signal stores and the classic Store, with entity collections, dispatched events, a log of every change, a diff per entry, restore and dispatch.

NgRx Store

The Store tab shows your NgRx state live. It covers @ngrx/signals stores (signalStore and signalState) and the classic @ngrx/store. NGXS, Elf and MiniRx stores show up in the same list through their Redux DevTools integration (see Other stores). With the hub mounted, it lives in the NgRx dock.

The tab has two sections. Live stores reads the running page. Source declarations lists what your files declare.

The Store tab with three live stores listed and the PackingStore signal store selected, showing its scope, its source file, the state as a tree of packing items, its methods with call counts, and the start of its change log

What it shows

Store list

Each store shows its label, its kind (signalStore, signalState or @ngrx/store), its scope and its change count. The scope is where the store lives:

  • root, platform or another environment injector that provides it.
  • Owner (component) for a store a component provides.
  • Owner (field) for a store found only in a component field.

The tab labels a signal store with the matching declaration name from your source. Without a match, it uses the first component field that holds it, then its class name. The classic Store shows with the label Store. Use the filter box to narrow stores, changes and declarations. When more than one page reports, a picker chooses the page.

Store detail

Select a store to see:

  • Its kind, scope and declaring file. The file appears when the store's state keys match a signalStore or signalState in your source.
  • Store DevTools on or Store DevTools off, for the classic Store.
  • Referenced by: the component fields that hold it.
  • State, Computed and Methods, with a call count per method. Copy next to State copies the state as shown in the panel, with secrets already redacted. The copy is the panel's formatted text, not strict JSON. The tab tags signalMethod and rxMethod members. Once a method has been called, its chip also shows the average and last call duration, in milliseconds.
  • withDevtools: watched only, for a signal store that uses withDevtools(). See Stores that use withDevtools().
  • Entities, for a signalStore that calls withEntities(). One group per collection, with the entity count and the ids as chips. A group past 30 ids shows the first 30 and a count of the rest.

State tree

State shows the state as a tree. Objects at the top level start open. Select an object or array to open or close it. Type in the search box above the tree to keep only the rows whose key or value matches, with their parents, all open, and a match count. Escape clears the search. Past 400 rows, the tree says how many more it holds; search to narrow it.

Copy path on a row copies its path in the form the diff uses, such as cart.items[0].name. Pass that path to the ngrx-explain-change agent tool to ask why it changed. The paths the newest change of the store wrote are marked changed, and the objects that hold them open on their own. A closed object that holds one says holds a change.

Store the state as a global

Store as global next to State stores a copy of the selected store's state in the page console as temp1, then the first free tempN, and shows the name it used. For the classic Store, the copy is the whole state. For a signal store, it holds the state fields. Secret-looking keys, JWTs and Bearer values are replaced by [redacted] in the copy, and the button then says Stored a copy as temp1, with secret fields masked. Changing the copy doesn't change the store. Only the tab you are looking at gets the global. See Console handles.

Change log

Signal stores get a Change log. The classic Store gets an Action log. Each entry shows its number, its type, the number of changes and the time. A method-call entry also shows how long the call itself took, and an entry whose change came from a dispatched event carries a tag with the event's type. An action also shows a badge for where it came from:

Badge Sent by
dispatch A store.dispatch(action) call, usually from a component or a service.
effect An NgRx effect. Effects send their actions through Store.next.
reactive store.dispatch(() => action), which dispatches again when a signal changes.

Open an entry to see its time, Origin and Duration, and three tabs. Action shows the action, or the method's arguments and the event that caused it. Diff shows the State diff with the value before and after each change. State reads the whole state of the store right after the entry, or right before it, from the page; see Read any past state. The diff lists up to 50 changes. When there were more, a line under it says how many are not shown, for example 12 more changes not shown, and the entry's change count includes them. The overlay counts up to 1000 more, so a larger change reads 1000+ more changes not shown. A method-call entry also shows its Duration, in milliseconds. An entry caused by a dispatched event shows the event under Caused by event. An action entry also has Dispatch again. Copy next to State diff copies that entry's diff in the same format as State, one object per change with its path, op, before and after. An entry that changed nothing has no diff to copy.

With ngrx.trace on, an entry also lists Called from: the app frames of the dispatch, method call or patchState that made it, the closest call first. With the server connected, each frame opens its file in your editor.

Pause above the log holds it as it is while the app keeps changing the store. A pill counts the entries that arrived since, such as 4 new. Press Pause again to show them. A pause lasts across a switch to another store. With Follow newest checked, the log scrolls back to the newest entry each time one arrives. The panel remembers Follow newest in localStorage.

Entry numbers start at 1 again when the app reloads. So when the app reloads, or the selected page closes and the tab shows another one, the open entry closes and a pending Restore confirmation is cancelled.

Action frequency

Action frequency under the log counts how often each action, method call or write of the selected store ran since the page loaded, including entries the log no longer keeps.

Column What it shows
Count Entries of that type since load.
Avg, Longest The duration of signal store method calls. n/a for actions, which carry none.
Peak per second The most entries of that type within any one second.

An action an NgRx effect dispatched 20 or more times within one second is flagged Possible effect loop. Check that effect for a missing filter, or for a dispatch of the action that triggers it. The page counts up to 100 types, keeping the most recent.

Store DevTools history

With provideStoreDevtools(), the classic Store gets a Store DevTools history section.

Control What it does
Pause recording Store DevTools stops recording new actions. They still change the state, but cannot be restored. Resume recording starts recording again.
Jump to committed state Shows the state Store DevTools starts from. The store is then paused on it, like a restore; Back to latest resumes.
Commit Makes the current state the new starting point. Earlier entries can no longer be restored.
Reset… After Reset history to confirm, puts the store back on its initial state and empties the history. Earlier entries can no longer be restored.
Skip this action On an open action entry: Store DevTools computes the state again without it, and the entry gets a skipped tag. Include this action undoes it.

Each operation but Pause recording and Resume recording adds a Store DevTools: … entry to the log, so the diff shows where the state moved. Pausing and resuming leave the state as it is.

Read any past state

The State tab of an entry asks the page for the state of the store around that entry and shows it with After #N and Before #N, with Copy. The page keeps the states of every entry still in the log. NgRx state is immutable, so consecutive states share everything an entry did not change, and keeping them costs what changed. Values are redacted like the rest of the tab. When the log entry lists only 50 changes, Show all changes on the Diff tab reads up to 500 of them.

Reading a state changes nothing in the app, so it works with actions.ngrx off.

Session

Under the log, Session works on a range of the selected NgRx store's entries, picked with From and To:

Control What it does
Export session Saves the range as a JSON file: the state before the first entry, then each action or method call with the changes it made.
Import session Reads an exported file back. Its entries show under Imported with the same Action, Diff and State tabs, and Generate test works on the whole session. The app does not change.
Generate test Writes a Vitest spec that starts from the state before the range, replays its actions or method calls, and expects the state after it. Copy and Download save it. Notes above the code say what to adjust.

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() from @ngrx/signals/testing, calls the recorded methods and checks getState(). A patchState write outside a method is replayed as a patchState call with what it changed. Point the import at your reducer or store, since the devtools cannot tell its file.

The server checks an imported file before it reads it: the format and version, at most 1000 entries and 4,000,000 characters, and change paths that cannot reach a prototype. It keeps at most 5 imported sessions, each for an hour after its last use.

Events

When a page dispatches at least one @ngrx/signals/events event, an Events section lists them: the event type, its payload and the time. This section covers every store on the page, not only the selected one. Open an event to see its full payload in the same detail panel as the change log.

Dispatch an action

The classic Store gets a Dispatch an action form under the action log. Type suggests the action types from your source and the log. Payload takes the action props as a JSON object, like {"id": 7}, and cannot have a type key. Dispatch sends the action through store.dispatch, so the log gets a dispatch entry and the tab selects it.

Source declarations

The server scans your files for:

  • signalStore with its withState, withComputed, withMethods, withProps, withHooks, withEntities and rxMethod members.
  • signalState and signalMethod.
  • createAction, createActionGroup, createReducer, createEffect, createSelector, createFeatureSelector and createFeature. An action shows its type strings, like [Cart] Add Item, when they are string literals.
  • Store setup: provideStore, provideState, provideEffects, and the StoreModule and EffectsModule calls.

Filter by kind with the chips.

Where the data comes from

The overlay finds stores in the page's injectors and component fields, and records every change. The server reads your .ts files for NgRx declarations, skipping specs.

How changes are recorded

The overlay wraps the state signals of each signal store and the store's methods. Every method call, nested or not, adds its duration to that method's average and last figures in Methods. The duration covers the synchronous call only, not any async work an rxMethod or an effect starts from it.

How the log groups changes depends on whether watchState is registered (see Restore NgRx signal state):

Setup Change log entries
With watchState One entry per patchState call, including several in the same tick, labeled with the method that is running. Each entry carries a duration: the time from the start of that method to that patch, so an earlier patch in a method shows a shorter duration than a later one.
Without watchState One entry per outermost method call that changes state, with the duration of the whole call. Writes outside a method are grouped per microtask into one patchState entry.

A patchState outside a method and a Restore #N entry carry no duration. A method call that changes nothing still gets an entry, at most once per second.

For the classic Store, the overlay listens to the dispatched actions. It also wraps dispatch and next on the Store to tag each action with its origin, and puts them back when the page disconnects.

The overlay diffs a copy of the state that keeps the first 100 items of each array or object. When a change is past that limit, it compares the live state instead, so the entry still lists the change.

Stores that use withDevtools()

A signal store that uses withDevtools() from @angular-architects/ngrx-toolkit already reports its changes through watchState, so the overlay leaves it as it is: it does not wrap the store's methods or state signals. With watchState registered, each patchState gets its own entry. Without it, the overlay compares the state each time it collects and logs the writes since the last time as one patchState entry. Either way, entries are not labeled with a method, and Methods lists the methods without call counts.

For @ngrx/signals/events, the overlay finds the platform Dispatcher and every component-scoped one from provideDispatcher(), and records each event once, from the dispatcher that handles it. When a store's state changes while an event is being dispatched, that change's log entry is tagged with the event.

Development builds

The overlay finds stores through Angular's debug API, so the live section needs a development build.

How to use it

Find the change that broke the state

Pick it in the list. Filter by name if there are many. Open entries from newest to oldest. Each State diff shows the keys that changed. The entry that set the wrong value shows the method and the arguments it got.

Restore an earlier state

Pick the change you want to go back to. Click Restore this state, then Restore to confirm. Focus moves to Cancel. Press Escape or Cancel to back out. Components that read the store update at once. The log gets a Restore #N entry.

Restore modes

Restore sets every state key that differs back to its value right after that change. Every state signal must be writable. Restore uses Store DevTools to jump to the state right after that action, and the log gets a Restore #N entry. Unless you restored the newest action, the store is then paused on that state: a Viewing a past state banner appears, and new actions are logged but do not change the state. Select Back to latest to resume. It needs provideStoreDevtools(). Without it, entries cannot be restored, but you can still dispatch actions.

Turn a bug into a test

Use the app until the state goes wrong, with the store selected. In Session, set From to the last good entry and To to the one that broke the state. Check them on the State tab of each entry. Click Generate test, then Download. Save the spec next to your reducer or store, point its import there, and fix the expected state to what it should be.

To share the bug instead, Export session and send the file. Anyone can Import session it to read the same entries and states.

Replay an action

Pick an entry in the Action log. Click Dispatch again. The Store gets a copy of the same action, and the log gets a new entry with its diff.

To try another payload, type the action in Dispatch an action instead.

Other stores

NGXS, Elf and MiniRx each ship an integration for the Redux DevTools browser extension. The overlay stands in for that extension, so these stores report to the Store tab too: their name, their state and every action they send, with a state diff per action.

Library Its devtools integration
NGXS withNgxsReduxDevtoolsPlugin() from @ngxs/devtools-plugin (or NgxsReduxDevtoolsPluginModule.forRoot())
Elf devTools() from @ngneat/elf-devtools
MiniRx new ReduxDevtoolsExtension() in the store's extensions

Any other library that calls window.__REDUX_DEVTOOLS_EXTENSION__.connect() reports the same way, with the library shown as Redux DevTools.

Set it up

These libraries look for the extension once, when the app starts, and the overlay usually connects later. Load @pangular-inspector/devtools/store-hook before your app, from the polyfills of your development configuration. A configuration's polyfills replace the list in the build's options, so copy that list and add the hook to it. In angular.json (excerpt):

{
  "projects": {
    "my-app": {
      "architect": {
        "build": {
          "configurations": {
            "development": {
              "polyfills": ["zone.js", "@pangular-inspector/devtools/store-hook"]
            }
          }
        }
      }
    }
  }
}

This sample assumes the base list is ["zone.js"]. Leave zone.js out if your app doesn't use it. The hook starts on import, and does nothing when ngDevMode is off. Without it, the overlay installs the stand-in when it connects, so only stores that connect after that report.

On a device, see Other stores on a device for Angular Native. The NativeScript overlay installs the stand-in itself before the app starts.

In the Store tab

Each store shows its name (the name option it passed, or the library), Redux DevTools as its kind, the library, such as NGXS, and how many actions its log holds, @@INIT included. Select it for its State and its Action log. Each entry shows the action and a State diff against the state before it, with up to 50 changes, without the Action, Diff and State tabs of the NgRx log. The first entry of NGXS is @@INIT, with the initial state.

The tab only reads these stores. It has no Restore, Dispatch again, Store as global or Session for them, since the page keeps only their latest state.

With the Redux DevTools extension installed

The extension keeps working. The overlay passes every call on to it, and returns the extension's answers to the store, so jumps and imports in the extension still reach the app. The overlay itself never sends anything back to the store.

@ngrx/store-devtools connects through the same API. The overlay passes it on to the extension when one is installed and does not list it again, since the classic Store already shows in the tab.

Turn it off

The stand-in is part of the NgRx inspector. With inspectors.ngrx set to false, the overlay removes it again when it connects and puts back the extension, if there was one. The log keeps the last limits.changeLog actions per page.

Agent tools

Tool or resource Kind What it does
pangular:ngrx-scan tool NgRx declarations from source, with the members of each signalStore and the type strings of each action.
pangular:ngrx-dispatch tool Dispatches an action to the classic Store, or an action from the log again, and returns the new log entry.
pangular:ngrx-store resource The live stores per page, with state, computeds, methods, references and the change log. Classic Store actions carry an origin.
pangular:ngrx-inspect-store tool The live state of one store, or a summary of every store discovered so far.
pangular:ngrx-history tool The live change log, oldest first: state diffs, classic @ngrx/store actions and @ngrx/signals/events events.
pangular:ngrx-inspect-entry tool The State, Diff and Action of one past entry, from the page or an imported session.
pangular:ngrx-export-session tool A range of one store's log as session JSON.
pangular:ngrx-import-session tool Reads an exported session back, for the two tools above and below.
pangular:ngrx-generate-test tool A Vitest spec from a range of entries, live or imported.
pangular:ngrx-restore tool Restores the state after an entry, or sends Store DevTools back to the latest state. An action tool.
pangular:ngrx-store-devtools tool Skips or includes an action, jumps, commits, resets, or pauses recording in the Store DevTools history. A destructive tool: commit and reset erase history.
pangular:ngrx-explain-change tool Which log entries wrote a state path, with the action or method, its arguments, origin, causing event and call site.
pangular:redux-inspect-stores tool The NGXS, Elf, MiniRx and other Redux DevTools stores of a page, or one of them with its state and latest actions.

See NgRx tools, Restore a state and Resources.

Limits and gotchas

On older Angular

The overlay finds the @ngrx/store Store, and signal stores that components provide, through ng.ɵgetInjectorProviders, which Angular 16.2 added. On an older page the tab finds no such store and shows a note with the page's version. See Supported Angular versions.

watchState needs registerNgrxSignals

Without it, restore writes the state signals directly. Components update, but watchState listeners do not run, and the log entry says so. Call registerNgrxSignals({ patchState, watchState }) from @pangular-inspector/devtools/overlay once, and restore goes through patchState. This applies to signalStore only. A signalState restore always writes directly. See Restore NgRx signal state.

Stores appear when they are created

Angular creates a signalStore the first time something injects it. Open a page that uses it, and it appears.

The classic Store must be in an environment injector

Use provideStore() or StoreModule.forRoot(). The overlay stops looking after a few tries, so if you provide the Store late, reload the page.

State changed in place

The tab can miss a change made in place to a nested object, without patchState or a reducer. It may show the old values until something else rebuilds the report, such as the next real change or a recorded action. Use patchState, or a reducer that returns new objects.

Redaction

The devtools replace state keys with secret-looking names with [redacted], at any depth. A signal store method call that writes such a key shows every argument as [redacted] in the change log, and so do later calls of that method. An argument whose parameter name looks secret, such as password in login(email, password), is masked too. See what the devtools redact.

Action origin

The origin comes from the Store calls made while the page is connected. A store.dispatch(() => action) that started before the overlay connected shows as dispatch. An action sent straight to ActionsSubject has no origin.

Copy needs clipboard access

The copy buttons use the browser clipboard. If the panel cannot write to it, for example in a page without clipboard permission, the tab says The clipboard is not available here. instead of Copied.

Write actions

Restore, Back to latest, Dispatch, Dispatch again and the Store DevTools history controls need actions.ngrx. With it off, the panel disables them, the server refuses them, and the ngrx-dispatch, ngrx-restore and ngrx-store-devtools tools are dropped. The State tab, Session and their tools only read, so they keep working.

Log size

The log keeps the last 200 entries, and the page keeps the states of the same entries for the State tab and Export session. Set the count with limits.changeLog. Once older entries are dropped, the log says how many. The overlay logs a method call that changes nothing at most once per second.

State size

The server keeps at most 256 KB of JSON for each store's state: the classic Store's state, and the state and computed fields of each signal store. Past that, the largest top-level slices or fields show [too large: N KB] instead of their value, until the rest fits. The smaller slices stay readable. If the state still doesn't fit, such as one with thousands of small fields, the whole state shows the marker, under a [state] field for a signal store. A slice that JSON can't write, such as a BigInt or a cycle, shows [not serializable]. The Store tab, the pangular:ngrx-inspect-store tool and the pangular:ngrx-store resource all read the capped state.

Past states assume immutable state

The page keeps a reference to each state an entry produced. NgRx reducers and patchState return new objects, so those references stay as they were. An app that mutates its state objects in place changes the kept states too, and the State tab then shows the newer values. Exported states are serialized like the rest of the tab, so very deep or large values are cut and marked, and a generated test notes them.

The selected entity is a convention, not an API

@ngrx/signals has no built-in concept of a selected entity. The tab looks for a selectedId state key (or <collection>SelectedId for a named collection) next to a withEntities() collection, and shows it as Selected when it holds a value. A null or missing key shows no Selected row.

Events come from every Dispatcher, and only synchronous changes are tagged

The overlay listens to the platform Dispatcher from @ngrx/signals/events. It also listens to a Dispatcher that a component provides with provideDispatcher(), and stops when that component is destroyed. An event sent with scope: 'parent' or scope: 'global' is logged once, by the dispatcher that handles it.

A change gets a Caused by event tag only when it happens during the dispatch() call, like a withReducer() case or an event handler that patches state right away. A change made later, after an HTTP call or a timer, shows as a plain state change. The tag names the event, not which case reducer handled it.

signalMethod vs rxMethod

Both wrap the returned callable with a .destroy function, so the overlay cannot tell them apart from the live store alone. The tab reads the source scan to decide which label to show. A store with no matching declaration file (because its state keys do not line up with any signalStore in the scanned source) labels every reactive method as rxMethod by default.

FAQ

Store DevTools is not set up, so entries cannot be restored. The store detail shows Store DevTools off. Add provideStoreDevtools() to the app config. Store DevTools no longer holds it. The entry says Store DevTools no longer holds this action. With maxAge set, Store DevTools keeps only the last maxAge actions, while the log keeps 200 entries. Raise maxAge in provideStoreDevtools() to restore further back. Committing, resetting or importing the history in the Redux DevTools extension also removes the older actions, and no setting brings them back. Store DevTools skipped it. An actionsBlocklist, actionsSafelist or predicate option filtered it out, or recording was paused in the Redux DevTools extension. The entry says Store DevTools never recorded this action. Change the filter so Store DevTools records the action next time. The entry fell out of the 200-entry log in the page. Pick a newer entry. The tab matches the file by state keys. A store whose keys match no signalStore or signalState in the scanned source has none.

Where to next

Register patchState and watchState so restore notifies listeners and each patch gets its own entry. The signal graph of the components that read the store. Where each store is provided. Every tool a coding agent can call.
© 2026 Pangular Inspector contributors. Released under the MIT License.