Can the cursor reach the bottom? In a matrix of characters, a cursor is a movable position between two adjacent characters, before the first character or after the last character in a line, like that &quot;I&quot;-shaped indicator which moves while you type.
In this challenge, a cursor position is considered valid if at least one of its two sides touches a space. The cursor travels through valid positions in a matrix, by moving up, down, left or right by one position each time. It could also move left or right though the line separator, to the end of the previous line, or the beginning of the next line respectively.
Given a character matrix as input, and a cursor initially at the top left corner, your task is to determine whether it can reach the bottom line.
This is a code-golf and decision-problem problem; the rules of this question is the same as what these two tags specified.
Rules

You can assume that the input consists only of .,  , and newlines. (Only these three characters and no more characters; otherwise its behavior is undefined.)
You may require there must or must not be a trailing newline in the input, if you want to.
Your code should output either a truthy value (if the condition is true), or a falsy value (if the condition is false).

Examples
Example input(where ░ is the space character):
░.....░
░......
.░.░.░.
.░░░░░░
......░

The cursor can reach the bottom in this case. This process of moving the cursor will work: down, right(touches spaces on the left), down(touches spaces on the right), down, right(touches spaces on both sides) 6 times, and down(touching spaces on the left).
This will also work(░ still represent spaces):
░░
.░
.░

The cursor starts at the up-left corner. After moving right two times, it can move down twice, which touches the bottom of the lines.
This example will not work(░ represent spaces again):
░...
...░

The cursor cannot move down, as there is no sufficient whitespace to be touched. There are only newline characters on the right of the input, and there are no newline characters on the left(otherwise a line would have spanned two lines.)
The cursor can also move up and left, in order to solve a maze-like input as in this one:
░....
░░░░.
...░.
.░░░.
░....
░░░░░

In this case, the cursor has to move left in order to get through spaces and get to the bottom line.
Here is another important test case: the cursor can move left or right to another line.
░░░░
...░
░...

In this case, the cursor can reach the last line, as the cursor can move left or right in order to get to the next line. Moving the cursor down is blocked on the right position of row 2, column 4; however, the cursor can still get to the last line if it moves right (touching spaces).
This is a fairly interesting test input:
░░..░
░...░
....░

In this case, the cursor can reach the last line, by moving down and left to the end of the first line, then down twice to reach the end of the bottom line.
APL (Dyalog Unicode), 60 bytesSBCS



Full program. Prompts for character matrix from stdin. Prints 1 or 0 to stdout. Requires zero-indexing (⎕IO←0) which is default on many systems.

P←{' '0∊⍨s←(×⍨≢⍺)⊃,⍵:1∊⍵⋄s}
1∊⊢⌿{P⌺3 3⊢(⍴⍵)⍴1@0P⌺3,⍵}⍣≡3/3⌿⎕


Try it online! (space characters replaced by ░ for clarity)

The method here is basically to seed fill from the top left corner, but alternating between 1D and 2D seed fill to account for line wrapping and vertical/diagonal motion. Diagonal motion is simple horizontal motion followed by vertical motion, since the cursor sits in between adjacent characters.

The first line defines a helper function P(rocess) which will be called on each neighbourhood.

P←{…} "dfn"; ⍵ is the neighborhood, ⍺ is the number of padded elements for each dimension:

 ,⍵ ravel (flatten) the neighbourhood into a list

 (…)⊃ pick the following element from that:

  ⍺ the paddings per dimension (so a 1 or 2 element list, depending on ⍵ being 1D or 2D)

  ≢ the tally of that (1 or 2)

  ×⍨ the square of that (lit. multiplication selfie; 1 or 4)

 s← assign to s(elf; i.e. the centre of the neighbourhood)

' '0∊⍨ is that a member of [" ",0]?

 : if so:

  1∊⍵ return whether the neighbourhood has a one

 ⋄ else:

  s return s(elf unmodified, i.e. leave as-is for now)

The second line is the main part of the program:

⎕ prompt for evaluated input via the console (stdin)

3⌿ triplicate each row (ensures we have at least 3 — makes no difference to connectivity)

3/ triplicate each column (ensures we have at least 3 — makes no difference to connectivity)

{…}⍣≡ apply this function repeatedly until two successive results are identical (i.e. until stable):

 ,⍵ ravel (flatten) the matrix into a list

 P⌺3 apply P to each neighbourhood of 3 elements

 1@0 replace the current value at position 0 with a 1 (this seeds the top left corner)

 (…)⍴ reshape that into the following shape:

  ⍴⍵ the original shape of the matrix

⊢⌿ get the bottom row (lit. vertical right-reduction)

1∊ is there any 1 there?