Simulate my keyboard wave light! (The word frame in the following text does not mean an actual frame, it is used as a placeholder for an undefined time unit)
The task
Imagine you have a keyboard layout with only letters like so:
q w e r t y u i o p
 a s d f g h j k l
  z x c v b n m

Whenever you press a key, for example f, the keyboard lights up the keys around it each frame like this (unordered, each line is a separate frame):
F
RTGVCD
YHBXSE
UJNWAZ
IKMQ
OL
P

As you can see, each frame lights up the keys around the ones that were lit previously, but not the ones that have already been lit up before.
After you have determined which keys need to be pressed each frame, you need to visualise them. For each frame, you print out the default keyboard layout (with all of the whitespace), but with the lit up keys uppercased. In our example:
q w e r t y u i o p
 a s d F g h j k l
  z x c v b n m

q w e R T y u i o p
 a s D f G h j k l
  z x C V b n m

q w E r t Y u i o p
 a S d f g H j k l
  z X c v B n m

q W e r t y U i o p
 A s d f g h J k l
  Z x c v b N m

Q w e r t y u I o p
 a s d f g h j K l
  z x c v b n M

q w e r t y u i O p
 a s d f g h j k L
  z x c v b n m

q w e r t y u i o P
 a s d f g h j k l
  z x c v b n m

Rules

Input will be a single letter, you can choose whether it will be capitalised or not.

Output can be either:
a. An array of multiline strings representing each second of the visualised keyboard
b. A single multiline string with each frame of the visualised keyboard separated by at least one newline

You can output a trailing newline or/and the final keyboard visualisation when no keys are lit anymore


Test cases
Input: F
Output:
q w e r t y u i o p
 a s d F g h j k l
  z x c v b n m

q w e R T y u i o p
 a s D f G h j k l
  z x C V b n m

q w E r t Y u i o p
 a S d f g H j k l
  z X c v B n m

q W e r t y U i o p
 A s d f g h J k l
  Z x c v b N m

Q w e r t y u I o p
 a s d f g h j K l
  z x c v b n M

q w e r t y u i O p
 a s d f g h j k L
  z x c v b n m

q w e r t y u i o P
 a s d f g h j k l
  z x c v b n m


Input: Q
Output:

Q w e r t y u i o p
 a s d f g h j k l
  z x c v b n m

q W e r t y u i o p
 A s d f g h j k l
  z x c v b n m

q w E r t y u i o p
 a S d f g h j k l
  Z x c v b n m

q w e R t y u i o p
 a s D f g h j k l
  z X c v b n m

q w e r T y u i o p
 a s d F g h j k l
  z x C v b n m

q w e r t Y u i o p
 a s d f G h j k l
  z x c V b n m

q w e r t y U i o p
 a s d f g H j k l
  z x c v B n m

q w e r t y u I o p
 a s d f g h J k l
  z x c v b N m

q w e r t y u i O p
 a s d f g h j K l
  z x c v b n M

q w e r t y u i o P
 a s d f g h j k L
  z x c v b n m


Input: Z
Output:
q w e r t y u i o p
 a s d f g h j k l
  Z x c v b n m

q w e r t y u i o p
 A S d f g h j k l
  z X c v b n m

Q W E r t y u i o p
 a s D f g h j k l
  z x C v b n m

q w e R t y u i o p
 a s d F g h j k l
  z x c V b n m

q w e r T y u i o p
 a s d f G h j k l
  z x c v B n m

q w e r t Y u i o p
 a s d f g H j k l
  z x c v b N m

q w e r t y U i o p
 a s d f g h J k l
  z x c v b n M

q w e r t y u I o p
 a s d f g h j K l
  z x c v b n m

q w e r t y u i O p
 a s d f g h j k L
  z x c v b n m

q w e r t y u i o P
 a s d f g h j k l
  z x c v b n m
Haskell, 229 bytes

e=zip[0..]
x!y=abs$x-y
k=e[&quot;Q W E R T Y U I O P&quot;,&quot; A S D F G H J K L&quot;,&quot;  Z X C V B N M&quot;]
f c=filter(any(&lt;&quot;a&quot;).words)[unlines[[[z..]!!sum[32|z&gt;'@',max(2*y!i)(y!i+x!j)/=d*2]|(x,z)&lt;-e m]|(y,m)&lt;-k]|(i,l)&lt;-k,(j,h)&lt;-e l,c==h,d&lt;-[0..9]]

Try it online!
f takes an uppercase char argument and returns a list of multiline strings.
It loops over the keyboard layout looking for (i,j), the position of the given character. When it finds it, for each d&lt;-[0..9] it generates a string (unlines[…]) of the keyboard with all letters not d hex-steps away lowercased. It never takes longer than 10 steps for the wave to leave the keyboard, so this is OK. Finally, strings that don't contain any uppercase letters are filtered away from the result.
I calculate the hex distance between two points on the keyboard as: \$ \max\left(2|y_1-y_2|, |x_1-x_2|+|y_1-y_2|\right)\$. Here are some distances around a point under this metric:
   6666666                                 6 6 6 6
  654444456                               6 4 4 4 6
 65432223456                             6 4 2 2 4 6
6543210123456  --&gt; on staggered grid:   6 4 2 0 2 4 6
 65432223456                             6 4 2 2 4 6
  654444456                               6 4 4 4 6
   6666666                                 6 6 6 6