UI Stale After In-Place State Mutation in Redux Reducer

Answer

No. A reducer that mutates in place and returns the same root reference does not always prevent a useSelector re-render in React Redux v7 or v8. Re-render is decided by the equality check on the selector result, not by the root state reference alone.

• A reducer that mutates nested state and returns the same reference does NOT always prevent a useSelector re-render in v7 and v8.
• A custom equality function can force a re-render when the state reference is unchanged, if the comparator returns false for the selected values.
• Redux DevTools "trace" does not change the outcome. It records stack traces for debugging only.

Confirmed facts

React Redux notifies subscribers on every dispatch. useSelector runs the selector on each store update and re-renders only if the selected value differs from the previous value per the equality function. The check is on the selector result, not on root state reference alone.

With default === equality, a selector that returns a mutated nested object reference will not cause a re-render because the reference is unchanged. A selector that returns a primitive derived from mutated nested data will re-render because the primitive value changes, even though the root reference is unchanged.

React Redux v7 and v8 use the same selector equality semantics. v8 adds automatic batching and concurrent features, not a change to reference equality or selector comparison logic.

Redux DevTools trace option records action stack traces for debugging. It does not alter subscription, selector execution, or equality checks and does not force shallow comparison.

Likely explanation for your case

Mutation violates Redux immutability. The UI is stale because your selector returns the same object reference that was mutated in place. The default === check sees no change, so React Redux skips the render.

If your selector returns a primitive like state.user.name, you would see a re-render despite the mutation, which masks the bug and will break when the selector shape changes.

Steps needed for this case

1. Stop mutating. Return new references for changed branches in the reducer. This is the only stable fix.
2. Verify selector shape now. Log previous and current selected value with Object.is and reference identity across dispatches.
3. If you must keep the mutation temporarily, do not rely on a custom equality to "rescue" renders. A comparator that always returns false forces a re-render on every dispatch and removes the render guard.
4. Remove any expectation that DevTools trace changes rendering behavior.

One missing diagnostic detail that changes the recommendation: does your useSelector return the nested object reference itself, or a primitive/derived value from it? If it returns the object reference, the default equality will always block updates with in-place mutation. If it returns a primitive, you will see intermittent updates that will break on refactor.