Stop the terminal's Enter key dismissing the keyboard it was typed on

The first device run of ADR 0015 found the premise held and the field misconfigured
in a second way: the suggestion strip, autocorrect and predictive text were all
gone, and every Enter closed the keyboard. On a terminal that is every command, so
the phone asked for a tap between each one.

TerminalInputSurface had been left with Avalonia's default ReturnKeyType, and the
same OnCreateInputConnection that carries the inputType fix maps that default, on a
field that is not Multiline, to IME_ACTION_DONE:

    _ => options.Multiline ? 1073741824 : 6,   // 6 is IME_ACTION_DONE

Done means done. The keyboard performs the action and dismisses itself, which is
right for the text box the default was written for and wrong for a surface where
Enter is punctuation rather than submission.

TextInputReturnKeyType.Return is the member that maps to IME_ACTION_NONE — value 1,
so `returnKeyType - 1 => 0 => 1073741824` — leaving Enter a plain newline with no
action attached and no reason for the IME to hide.

◆ THE TRAP, WHICH IS THE ONE 11.10b ALREADY WARNED ABOUT FROM THE OTHER SIDE.

Multiline=true also reaches IME_ACTION_NONE, through that same default arm, and is
the obvious fix and the wrong one. It ORs TYPE_TEXT_FLAG_MULTI_LINE into InputType,
which moves it off 1 and silently fails the ShowSuggestions guard the whole ADR
turns on. Taking the obvious route to a working Enter would have handed the
suggestion strip back and looked like the premise had failed rather than like the
fix had. ReturnKeyType touches imeOptions only, which is why it is what is set.

Enter's byte was never the problem and is not what changed: IME_ACTION_DONE was
already synthesising KEYCODE_ENTER through AvaloniaInputConnection.PerformEditorAction,
so commands did run — the keyboard just left afterwards.

OnTextInput now also normalises line endings to CR. Belt and braces for the case
this change makes newly possible: a keyboard with no editor action attached may
commit "\n" as ordinary text rather than sending KEYCODE_ENTER, and a shell handed
LF for Enter looks like a shell that ignored the key. Normalising rather than
special-casing also stops a pasted "\r\n" running its line twice.

Check 11.10e is the regression test, and says in as many words not to fix a
recurrence with Multiline.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>

src/DodoSSH.Client.Android/Views/TerminalInputSurface.cs

@@ -31,10 +31,17 @@ namespace DodoSSH.Client.Android.Views;
 /// </code>
 /// <c>0x80080</c> is <c>TYPE_TEXT_VARIATION_VISIBLE_PASSWORD | TYPE_TEXT_FLAG_NO_SUGGESTIONS</c> — the exact
 /// pair Termux's own <c>TerminalView</c> sets, and the reason typing in Termux feels like a terminal. The
-/// guard is why the constructor sets <em>only</em> <see cref="TextInputOptions.ShowSuggestionsProperty"/>
-/// and leaves <c>ContentType</c>, <c>Multiline</c> and <c>AutoCapitalization</c> alone: any of those would
-/// move <c>InputType</c> off <c>1</c> and the branch would never be taken. <c>ShowSuggestions</c> is a
-/// <c>bool?</c> defaulting to <c>null</c>, so it must be set to <c>false</c> rather than merely left.
+/// guard is why the constructor leaves <c>ContentType</c>, <c>Multiline</c> and <c>AutoCapitalization</c>
+/// alone: any of those would move <c>InputType</c> off <c>1</c> and the branch would never be taken.
+/// <c>ShowSuggestions</c> is a <c>bool?</c> defaulting to <c>null</c>, so it must be set to <c>false</c>
+/// rather than merely left.
+/// </para>
+/// <para>
+/// <b>Two options are set, and the second one is not optional either.</b> The default
+/// <c>ReturnKeyType</c> maps to <c>IME_ACTION_DONE</c> on a non-multiline field, which closed the keyboard
+/// on every Enter — that is, on every command. <c>ReturnKeyType.Return</c> is <c>IME_ACTION_NONE</c> and
+/// touches nothing else. The constructor carries the full argument, including why the obvious alternative
+/// of <c>Multiline</c> cannot be used without giving the suggestion strip back.
 /// </para>
 /// <para>
 /// <b>One pixel, and never drawn.</b> Focus in Avalonia has nothing to do with hit-testing, so the input
@@ -105,9 +112,26 @@ internal sealed class TerminalInputSurface : Control
         VerticalAlignment = Avalonia.Layout.VerticalAlignment.Top;
         IsHitTestVisible = false;
 
-        // The one line that fixes the keyboard. See the remarks for why it is the only option set.
+        // The one line that fixes the keyboard. See the remarks for why almost nothing else is set.
         TextInputOptions.SetShowSuggestions(this, false);
 
+        // ◆ AND THE ONE THAT KEEPS THE KEYBOARD UP WHEN A COMMAND IS RUN.
+        //
+        // Avalonia maps ReturnKeyType.Default, on a field that is not Multiline, to IME_ACTION_DONE — and
+        // Done means done: the keyboard performs the action and dismisses itself. Every Enter therefore
+        // closed the keyboard, which on a terminal is every command.
+        //
+        // Return is the member that maps to IME_ACTION_NONE, leaving the key as a plain newline with no
+        // action attached and no reason for the IME to hide. Its whole switch arm is
+        // `returnKeyType - 1 => 0 => 1073741824`, which is 0x40000000, IME_ACTION_NONE.
+        //
+        // Multiline=true reaches the same IME_ACTION_NONE through the default arm and is the wrong way to
+        // get there: it also ORs TYPE_TEXT_FLAG_MULTI_LINE into InputType, which moves InputType off 1 and
+        // silently fails the ShowSuggestions guard above. The two options cannot both be had that way — one
+        // trades the suggestion strip back for a working Enter. ReturnKeyType costs nothing and is the
+        // reason this file sets it rather than Multiline.
+        TextInputOptions.SetReturnKeyType(this, TextInputReturnKeyType.Return);
+
         AddHandler(TextInputMethodClientRequestedEvent, OnTextInputMethodClientRequested);
     }
 
@@ -156,7 +180,14 @@ internal sealed class TerminalInputSurface : Control
             return;
         }
 
-        Input?.Invoke(this, new TerminalInputEventArgs(Encoding.UTF8.GetBytes(e.Text)));
+        // Newlines arrive as carriage returns, whichever way they came. A keyboard with no editor action
+        // attached may commit "\n" as ordinary text rather than sending KEYCODE_ENTER, and a paste carries
+        // whatever the clipboard held — but a terminal's line terminator from a keyboard is CR, and a shell
+        // handed LF for Enter is a shell that looks like it ignored the key. Normalised rather than special
+        // -cased so that a pasted "\r\n" does not run the line twice.
+        var text = e.Text.ReplaceLineEndings("\r");
+
+        Input?.Invoke(this, new TerminalInputEventArgs(Encoding.UTF8.GetBytes(text)));
         e.Handled = true;
 
         base.OnTextInput(e);