Use Char[] for Connection stdin (#19655)

lhecker · web-flow · commit f321c30cc14e · 2025-12-17T17:25:26.000Z
This makes it possible to pass through non-null-terminated strings.
This is needed for the tmux control mode which passes string slices.
diff --git a/src/cascadia/TerminalApp/DebugTapConnection.cpp b/src/cascadia/TerminalApp/DebugTapConnection.cpp
@@ -120,25 +120,25 @@ namespace winrt::Microsoft::TerminalApp::implementation
         return ConnectionState::Failed;
     }
 
-    void DebugTapConnection::_OutputHandler(const std::wstring_view str)
+    void DebugTapConnection::_OutputHandler(const winrt::array_view<const char16_t> str)
     {
-        auto output = til::visualize_control_codes(str);
+        auto output = til::visualize_control_codes(winrt_array_to_wstring_view(str));
         // To make the output easier to read, we introduce a line break whenever
         // an LF control is encountered. But at this point, the LF would have
         // been converted to U+240A (␊), so that's what we need to search for.
         for (size_t lfPos = 0; (lfPos = output.find(L'\u240A', lfPos)) != std::wstring::npos;)
         {
             output.insert(++lfPos, L"\r\n");
         }
-        TerminalOutput.raise(output);
+        TerminalOutput.raise(winrt_wstring_to_array_view(output));
     }
 
     // Called by the DebugInputTapConnection to print user input
     void DebugTapConnection::_PrintInput(const std::wstring_view str)
     {
         auto clean{ til::visualize_control_codes(str) };
         auto formatted{ wil::str_printf<std::wstring>(L"\x1b[91m%ls\x1b[m", clean.data()) };
-        TerminalOutput.raise(formatted);
+        TerminalOutput.raise(winrt_wstring_to_array_view(formatted));
     }
 
     // Wire us up so that we can forward input through
diff --git a/src/cascadia/TerminalApp/DebugTapConnection.h b/src/cascadia/TerminalApp/DebugTapConnection.h
@@ -31,7 +31,7 @@ namespace winrt::Microsoft::TerminalApp::implementation
 
     private:
         void _PrintInput(const std::wstring_view data);
-        void _OutputHandler(const std::wstring_view str);
+        void _OutputHandler(const winrt::array_view<const char16_t> str);
 
         winrt::Microsoft::Terminal::TerminalConnection::ITerminalConnection::TerminalOutput_revoker _outputRevoker;
         winrt::Microsoft::Terminal::TerminalConnection::ITerminalConnection::StateChanged_revoker _stateChangedRevoker;
diff --git a/src/cascadia/TerminalConnection/AzureConnection.cpp b/src/cascadia/TerminalConnection/AzureConnection.cpp
@@ -94,9 +94,15 @@ namespace winrt::Microsoft::Terminal::TerminalConnection::implementation
     // - helper that will write an unterminated string (generally, from a resource) to the output stream.
     // Arguments:
     // - str: the string to write.
+    void AzureConnection::_WriteStringWithNewline(std::wstring str)
+    {
+        str.append(L"\r\n");
+        TerminalOutput.raise(winrt_wstring_to_array_view(str));
+    }
+
     void AzureConnection::_WriteStringWithNewline(const std::wstring_view str)
     {
-        TerminalOutput.raise(str + L"\r\n");
+        TerminalOutput.raise(winrt_wstring_to_array_view(str + L"\r\n"));
     }
 
     // Method description:
@@ -112,7 +118,7 @@ namespace winrt::Microsoft::Terminal::TerminalConnection::implementation
         catch (const std::exception& runtimeException)
         {
             // This also catches the AzureException, which has a .what()
-            TerminalOutput.raise(_colorize(91, til::u8u16(std::string{ runtimeException.what() })));
+            TerminalOutput.raise(winrt_wstring_to_array_view(_colorize(91, til::u8u16(std::string{ runtimeException.what() }))));
         }
         catch (...)
         {
@@ -162,13 +168,13 @@ namespace winrt::Microsoft::Terminal::TerminalConnection::implementation
 
         _currentInputMode = mode;
 
-        TerminalOutput.raise(L"> \x1b[92m"); // Make prompted user input green
+        TerminalOutput.raise(winrt_wstring_to_array_view(L"> \x1b[92m")); // Make prompted user input green
 
         _inputEvent.wait(inputLock, [this, mode]() {
             return _currentInputMode != mode || _isStateAtOrBeyond(ConnectionState::Closing);
         });
 
-        TerminalOutput.raise(L"\x1b[m");
+        TerminalOutput.raise(winrt_wstring_to_array_view(L"\x1b[m"));
 
         if (_isStateAtOrBeyond(ConnectionState::Closing))
         {
@@ -211,19 +217,19 @@ namespace winrt::Microsoft::Terminal::TerminalConnection::implementation
             if (_userInput.size() > 0)
             {
                 _userInput.pop_back();
-                TerminalOutput.raise(L"\x08 \x08"); // overstrike the character with a space
+                TerminalOutput.raise(winrt_wstring_to_array_view(L"\x08 \x08")); // overstrike the character with a space
             }
         }
         else
         {
-            TerminalOutput.raise(data); // echo back
+            TerminalOutput.raise(winrt_wstring_to_array_view(data)); // echo back
 
             switch (_currentInputMode)
             {
             case InputMode::Line:
                 if (data.size() > 0 && gsl::at(data, 0) == UNICODE_CARRIAGERETURN)
                 {
-                    TerminalOutput.raise(L"\r\n"); // we probably got a \r, so we need to advance to the next line.
+                    TerminalOutput.raise(winrt_wstring_to_array_view(L"\r\n")); // we probably got a \r, so we need to advance to the next line.
                     _currentInputMode = InputMode::None; // toggling the mode indicates completion
                     _inputEvent.notify_one();
                     break;
@@ -429,7 +435,7 @@ namespace winrt::Microsoft::Terminal::TerminalConnection::implementation
                             }
 
                             // Pass the output to our registered event handlers
-                            TerminalOutput.raise(_u16Str);
+                            TerminalOutput.raise(winrt_wstring_to_array_view(_u16Str));
                             break;
                         }
                         case WINHTTP_WEB_SOCKET_CLOSE_BUFFER_TYPE:
@@ -772,7 +778,7 @@ namespace winrt::Microsoft::Terminal::TerminalConnection::implementation
         const auto shellType = _ParsePreferredShellType(settingsResponse);
         _WriteStringWithNewline(RS_(L"AzureRequestingTerminal"));
         const auto socketUri = _GetTerminal(shellType);
-        TerminalOutput.raise(L"\r\n");
+        TerminalOutput.raise(winrt_wstring_to_array_view(L"\r\n"));
 
         //// Step 8: connecting to said terminal
         {
diff --git a/src/cascadia/TerminalConnection/AzureConnection.h b/src/cascadia/TerminalConnection/AzureConnection.h
@@ -67,6 +67,7 @@ namespace winrt::Microsoft::Terminal::TerminalConnection::implementation
         std::optional<::Microsoft::Terminal::Azure::Tenant> _currentTenant;
 
         void _writeInput(const std::wstring_view str);
+        void _WriteStringWithNewline(std::wstring str);
         void _WriteStringWithNewline(const std::wstring_view str);
         void _WriteCaughtExceptionRecord();
         winrt::Windows::Data::Json::JsonObject _SendRequestReturningJson(std::wstring_view uri, const winrt::Windows::Web::Http::IHttpContent& content = nullptr, winrt::Windows::Web::Http::HttpMethod method = nullptr, const winrt::Windows::Foundation::Uri referer = nullptr);
diff --git a/src/cascadia/TerminalConnection/ConptyConnection.cpp b/src/cascadia/TerminalConnection/ConptyConnection.cpp
@@ -477,31 +477,28 @@ namespace winrt::Microsoft::Terminal::TerminalConnection::implementation
         const auto hr = wil::ResultFromCaughtException();
 
         // GH#11556 - make sure to format the error code to this string as an UNSIGNED int
-        const auto failureText = RS_fmt(L"ProcessFailedToLaunch", _formatStatus(hr), _commandline);
-        TerminalOutput.raise(failureText);
+        auto failureText = RS_fmt(L"ProcessFailedToLaunch", _formatStatus(hr), _commandline);
 
         // If the path was invalid, let's present an informative message to the user
         if (hr == HRESULT_FROM_WIN32(ERROR_DIRECTORY))
         {
-            const auto badPathText = RS_fmt(L"BadPathText", _startingDirectory);
-            TerminalOutput.raise(L"\r\n");
-            TerminalOutput.raise(badPathText);
+            failureText.append(L"\r\n");
+            failureText.append(RS_fmt(L"BadPathText", _startingDirectory));
         }
         // If the requested action requires elevation, display appropriate message
         else if (hr == HRESULT_FROM_WIN32(ERROR_ELEVATION_REQUIRED))
         {
-            const auto elevationText = RS_(L"ElevationRequired");
-            TerminalOutput.raise(L"\r\n");
-            TerminalOutput.raise(elevationText);
+            failureText.append(L"\r\n");
+            failureText.append(RS_(L"ElevationRequired"));
         }
         // If the requested executable was not found, display appropriate message
         else if (hr == HRESULT_FROM_WIN32(ERROR_FILE_NOT_FOUND))
         {
-            const auto fileNotFoundText = RS_(L"FileNotFound");
-            TerminalOutput.raise(L"\r\n");
-            TerminalOutput.raise(fileNotFoundText);
+            failureText.append(L"\r\n");
+            failureText.append(RS_(L"FileNotFound"));
         }
 
+        TerminalOutput.raise(winrt_wstring_to_array_view(failureText));
         _transitionToState(ConnectionState::Failed);
 
         // Tear down any state we may have accumulated.
@@ -520,7 +517,7 @@ namespace winrt::Microsoft::Terminal::TerminalConnection::implementation
             const auto msg1 = RS_fmt(L"ProcessExited", _formatStatus(status));
             const auto msg2 = RS_(L"CtrlDToClose");
             const auto msg = fmt::format(FMT_COMPILE(L"\r\n{}\r\n{}\r\n"), msg1, msg2);
-            TerminalOutput.raise(msg);
+            TerminalOutput.raise(winrt_wstring_to_array_view(msg));
         }
         CATCH_LOG();
     }
@@ -792,7 +789,7 @@ namespace winrt::Microsoft::Terminal::TerminalConnection::implementation
 
                 try
                 {
-                    TerminalOutput.raise(wstr);
+                    TerminalOutput.raise(winrt_wstring_to_array_view(wstr));
                 }
                 CATCH_LOG();
             }
diff --git a/src/cascadia/TerminalConnection/EchoConnection.cpp b/src/cascadia/TerminalConnection/EchoConnection.cpp
@@ -34,7 +34,7 @@ namespace winrt::Microsoft::Terminal::TerminalConnection::implementation
                 prettyPrint << wch;
             }
         }
-        TerminalOutput.raise(prettyPrint.str());
+        TerminalOutput.raise(winrt_wstring_to_array_view(prettyPrint.str()));
     }
 
     void EchoConnection::Resize(uint32_t /*rows*/, uint32_t /*columns*/) noexcept
diff --git a/src/cascadia/TerminalConnection/ITerminalConnection.idl b/src/cascadia/TerminalConnection/ITerminalConnection.idl
@@ -13,7 +13,7 @@ namespace Microsoft.Terminal.TerminalConnection
         Failed
     };
 
-    delegate void TerminalOutputHandler(String output);
+    delegate void TerminalOutputHandler(Char[] output);
 
     interface ITerminalConnection
     {
diff --git a/src/cascadia/TerminalControl/ControlCore.cpp b/src/cascadia/TerminalControl/ControlCore.cpp
@@ -10,8 +10,6 @@
 
 #include <DefaultSettings.h>
 #include <unicode.hpp>
-#include <utils.hpp>
-#include <WinUser.h>
 
 #include "EventArgs.h"
 #include "../../renderer/atlas/AtlasEngine.h"
@@ -2238,13 +2236,13 @@ namespace winrt::Microsoft::Terminal::Control::implementation
         auto noticeArgs = winrt::make<NoticeEventArgs>(NoticeLevel::Info, RS_(L"TermControlReadOnly"));
         RaiseNotice.raise(*this, std::move(noticeArgs));
     }
-    void ControlCore::_connectionOutputHandler(const hstring& hstr)
+    void ControlCore::_connectionOutputHandler(const winrt::array_view<const char16_t> str)
     {
         try
         {
             {
                 const auto lock = _terminal->LockForWriting();
-                _terminal->Write(hstr);
+                _terminal->Write(winrt_array_to_wstring_view(str));
             }
 
             if (!_pendingResponses.empty())
diff --git a/src/cascadia/TerminalControl/ControlCore.h b/src/cascadia/TerminalControl/ControlCore.h
@@ -349,7 +349,7 @@ namespace winrt::Microsoft::Terminal::Control::implementation
 
         void _raiseReadOnlyWarning();
         void _updateAntiAliasingMode();
-        void _connectionOutputHandler(const hstring& hstr);
+        void _connectionOutputHandler(winrt::array_view<const char16_t> str);
         void _connectionStateChangedHandler(const TerminalConnection::ITerminalConnection&, const Windows::Foundation::IInspectable&);
         void _updateHoveredCell(const std::optional<til::point> terminalPosition);
         void _setOpacity(const float opacity, const bool focused = true);
diff --git a/src/cascadia/TerminalSettingsEditor/PreviewConnection.cpp b/src/cascadia/TerminalSettingsEditor/PreviewConnection.cpp
@@ -28,10 +28,11 @@ namespace winrt::Microsoft::Terminal::Settings::Editor::implementation
 {
     PreviewConnection::PreviewConnection() noexcept = default;
 
-    void PreviewConnection::Start() noexcept
+    void PreviewConnection::Start()
     {
-        // Send the preview text
-        TerminalOutput.raise(fmt::format(PreviewText, _displayPowerlineGlyphs ? PromptTextPowerline : PromptTextPlain));
+        const auto prompt = _displayPowerlineGlyphs ? PromptTextPowerline : PromptTextPlain;
+        const auto text = fmt::format(FMT_COMPILE(PreviewText), prompt);
+        TerminalOutput.raise(winrt_wstring_to_array_view(text));
     }
 
     void PreviewConnection::Initialize(const Windows::Foundation::Collections::ValueSet& /*settings*/) noexcept
@@ -50,7 +51,7 @@ namespace winrt::Microsoft::Terminal::Settings::Editor::implementation
     {
     }
 
-    void PreviewConnection::DisplayPowerlineGlyphs(bool d) noexcept
+    void PreviewConnection::DisplayPowerlineGlyphs(bool d)
     {
         if (_displayPowerlineGlyphs != d)
         {
diff --git a/src/cascadia/TerminalSettingsEditor/PreviewConnection.h b/src/cascadia/TerminalSettingsEditor/PreviewConnection.h
@@ -22,12 +22,12 @@ namespace winrt::Microsoft::Terminal::Settings::Editor::implementation
         PreviewConnection() noexcept;
 
         void Initialize(const Windows::Foundation::Collections::ValueSet& settings) noexcept;
-        void Start() noexcept;
+        void Start();
         void WriteInput(const winrt::array_view<const char16_t> buffer);
         void Resize(uint32_t rows, uint32_t columns) noexcept;
         void Close() noexcept;
 
-        void DisplayPowerlineGlyphs(bool d) noexcept;
+        void DisplayPowerlineGlyphs(bool d);
 
         winrt::guid SessionId() const noexcept { return {}; }
         winrt::Microsoft::Terminal::TerminalConnection::ConnectionState State() const noexcept { return winrt::Microsoft::Terminal::TerminalConnection::ConnectionState::Connected; }
diff --git a/src/cascadia/UnitTests_Control/ControlInteractivityTests.cpp b/src/cascadia/UnitTests_Control/ControlInteractivityTests.cpp
@@ -104,13 +104,14 @@ namespace ControlUnitTests
         auto _addInputCallback(const winrt::com_ptr<MockConnection>& conn,
                                std::deque<std::wstring>& expectedOutput)
         {
-            conn->TerminalOutput([&](const hstring& hstr) {
+            conn->TerminalOutput([&](const winrt::array_view<const char16_t> str) {
                 VERIFY_IS_GREATER_THAN(expectedOutput.size(), 0u);
+                const auto actual = winrt_array_to_wstring_view(str);
                 const auto expected = expectedOutput.front();
                 expectedOutput.pop_front();
-                Log::Comment(fmt::format(L"Received: \"{}\"", TerminalCoreUnitTests::TestUtils::ReplaceEscapes(hstr.c_str())).c_str());
-                Log::Comment(fmt::format(L"Expected: \"{}\"", TerminalCoreUnitTests::TestUtils::ReplaceEscapes(expected)).c_str());
-                VERIFY_ARE_EQUAL(expected, hstr);
+                Log::Comment(fmt::format(L"Received: \"{}\"", til::visualize_nonspace_control_codes(std::wstring{ actual })).c_str());
+                Log::Comment(fmt::format(L"Expected: \"{}\"", til::visualize_nonspace_control_codes(expected)).c_str());
+                VERIFY_ARE_EQUAL(expected, actual);
             });
 
             return std::move(wil::scope_exit([&]() {
diff --git a/src/cascadia/UnitTests_Control/MockConnection.h b/src/cascadia/UnitTests_Control/MockConnection.h
@@ -18,7 +18,7 @@ namespace ControlUnitTests
         void Start() noexcept {};
         void WriteInput(const winrt::array_view<const char16_t> data)
         {
-            TerminalOutput.raise(winrt_array_to_wstring_view(data));
+            TerminalOutput.raise(data);
         }
         void Resize(uint32_t /*rows*/, uint32_t /*columns*/) noexcept {}
         void Close() noexcept {}
diff --git a/src/inc/TestUtils.h b/src/inc/TestUtils.h
@@ -109,50 +109,6 @@ class TerminalCoreUnitTests::TestUtils
         return iter;
     };
 
-    // Function Description:
-    // - Replaces all escapes with the printable symbol for that escape
-    //   character. This makes log parsing easier for debugging, as the literal
-    //   escapes won't be written to the console output.
-    // Arguments:
-    // - str: the string to escape.
-    // Return Value:
-    // - A modified version of that string with non-printable characters replaced.
-    static std::string ReplaceEscapes(const std::string& str)
-    {
-        std::string escaped = str;
-        auto replaceFn = [&escaped](const std::string& search, const std::string& replace) {
-            size_t pos = escaped.find(search, 0);
-            while (pos != std::string::npos)
-            {
-                escaped.replace(pos, search.length(), replace);
-                pos = escaped.find(search, pos + replace.length());
-            }
-        };
-        replaceFn("\x1b", "^\x5b"); // ESC
-        replaceFn("\x08", "^\x48"); // BS
-        replaceFn("\x0A", "^\x4A"); // LF
-        replaceFn("\x0D", "^\x4D"); // CR
-        return escaped;
-    }
-
-    // Function Description:
-    // - Replaces all escapes with the printable symbol for that escape
-    //   character. This makes log parsing easier for debugging, as the literal
-    //   escapes won't be written to the console output.
-    // Arguments:
-    // - wstr: the string to escape.
-    // Return Value:
-    // - A modified version of that string with non-printable characters replaced.
-    static std::wstring ReplaceEscapes(const std::wstring& wstr)
-    {
-        std::wstring escaped = wstr;
-        std::replace(escaped.begin(), escaped.end(), L'\x1b', L'\x241b'); // ESC
-        std::replace(escaped.begin(), escaped.end(), L'\x08', L'\x2408'); // BS
-        std::replace(escaped.begin(), escaped.end(), L'\x0A', L'\x240A'); // LF
-        std::replace(escaped.begin(), escaped.end(), L'\x0D', L'\x240D'); // CR
-        return escaped;
-    }
-
     template<class... T>
     static bool VerifyLineContains(TextBufferCellIterator& actual, T&&... expectedContent)
     {

Original file line number	Diff line number	Diff line change
`@@ -120,25 +120,25 @@ namespace winrt::Microsoft::TerminalApp::implementation`
`120`	`120`	`return ConnectionState::Failed;`
`121`	`121`	`}`
`122`	`122`
`123`		`- void DebugTapConnection::_OutputHandler(const std::wstring_view str)`
	`123`	`+ void DebugTapConnection::_OutputHandler(const winrt::array_view<const char16_t> str)`
`124`	`124`	`{`
`125`		`- auto output = til::visualize_control_codes(str);`
	`125`	`+ auto output = til::visualize_control_codes(winrt_array_to_wstring_view(str));`
`126`	`126`	`// To make the output easier to read, we introduce a line break whenever`
`127`	`127`	`// an LF control is encountered. But at this point, the LF would have`
`128`	`128`	`// been converted to U+240A (␊), so that's what we need to search for.`
`129`	`129`	`for (size_t lfPos = 0; (lfPos = output.find(L'\u240A', lfPos)) != std::wstring::npos;)`
`130`	`130`	`{`
`131`	`131`	`output.insert(++lfPos, L"\r\n");`
`132`	`132`	`}`
`133`		`- TerminalOutput.raise(output);`
	`133`	`+ TerminalOutput.raise(winrt_wstring_to_array_view(output));`
`134`	`134`	`}`
`135`	`135`
`136`	`136`	`// Called by the DebugInputTapConnection to print user input`
`137`	`137`	`void DebugTapConnection::_PrintInput(const std::wstring_view str)`
`138`	`138`	`{`
`139`	`139`	`auto clean{ til::visualize_control_codes(str) };`
`140`	`140`	`auto formatted{ wil::str_printf<std::wstring>(L"\x1b[91m%ls\x1b[m", clean.data()) };`
`141`		`- TerminalOutput.raise(formatted);`
	`141`	`+ TerminalOutput.raise(winrt_wstring_to_array_view(formatted));`
`142`	`142`	`}`
`143`	`143`
`144`	`144`	`// Wire us up so that we can forward input through`
Original file line number	Diff line number	Diff line change
`@@ -94,9 +94,15 @@ namespace winrt::Microsoft::Terminal::TerminalConnection::implementation`
`94`	`94`	`// - helper that will write an unterminated string (generally, from a resource) to the output stream.`
`95`	`95`	`// Arguments:`
`96`	`96`	`// - str: the string to write.`
	`97`	`+ void AzureConnection::_WriteStringWithNewline(std::wstring str)`
	`98`	`+ {`
	`99`	`+ str.append(L"\r\n");`
	`100`	`+ TerminalOutput.raise(winrt_wstring_to_array_view(str));`
	`101`	`+ }`
	`102`	`+`
`97`	`103`	`void AzureConnection::_WriteStringWithNewline(const std::wstring_view str)`
`98`	`104`	`{`
`99`		`- TerminalOutput.raise(str + L"\r\n");`
	`105`	`+ TerminalOutput.raise(winrt_wstring_to_array_view(str + L"\r\n"));`
`100`	`106`	`}`
`101`	`107`
`102`	`108`	`// Method description:`
`@@ -112,7 +118,7 @@ namespace winrt::Microsoft::Terminal::TerminalConnection::implementation`
`112`	`118`	`catch (const std::exception& runtimeException)`
`113`	`119`	`{`
`114`	`120`	`// This also catches the AzureException, which has a .what()`
`115`		`- TerminalOutput.raise(_colorize(91, til::u8u16(std::string{ runtimeException.what() })));`
	`121`	`+ TerminalOutput.raise(winrt_wstring_to_array_view(_colorize(91, til::u8u16(std::string{ runtimeException.what() }))));`
`116`	`122`	`}`
`117`	`123`	`catch (...)`
`118`	`124`	`{`
`@@ -162,13 +168,13 @@ namespace winrt::Microsoft::Terminal::TerminalConnection::implementation`
`162`	`168`
`163`	`169`	`_currentInputMode = mode;`
`164`	`170`
`165`		`- TerminalOutput.raise(L"> \x1b[92m"); // Make prompted user input green`
	`171`	`+ TerminalOutput.raise(winrt_wstring_to_array_view(L"> \x1b[92m")); // Make prompted user input green`
`166`	`172`
`167`	`173`	`_inputEvent.wait(inputLock, [this, mode]() {`
`168`	`174`	`return _currentInputMode != mode \|\| _isStateAtOrBeyond(ConnectionState::Closing);`
`169`	`175`	`});`
`170`	`176`
`171`		`- TerminalOutput.raise(L"\x1b[m");`
	`177`	`+ TerminalOutput.raise(winrt_wstring_to_array_view(L"\x1b[m"));`
`172`	`178`
`173`	`179`	`if (_isStateAtOrBeyond(ConnectionState::Closing))`
`174`	`180`	`{`
`@@ -211,19 +217,19 @@ namespace winrt::Microsoft::Terminal::TerminalConnection::implementation`
`211`	`217`	`if (_userInput.size() > 0)`
`212`	`218`	`{`
`213`	`219`	`_userInput.pop_back();`
`214`		`- TerminalOutput.raise(L"\x08 \x08"); // overstrike the character with a space`
	`220`	`+ TerminalOutput.raise(winrt_wstring_to_array_view(L"\x08 \x08")); // overstrike the character with a space`
`215`	`221`	`}`
`216`	`222`	`}`
`217`	`223`	`else`
`218`	`224`	`{`
`219`		`- TerminalOutput.raise(data); // echo back`
	`225`	`+ TerminalOutput.raise(winrt_wstring_to_array_view(data)); // echo back`
`220`	`226`
`221`	`227`	`switch (_currentInputMode)`
`222`	`228`	`{`
`223`	`229`	`case InputMode::Line:`
`224`	`230`	`if (data.size() > 0 && gsl::at(data, 0) == UNICODE_CARRIAGERETURN)`
`225`	`231`	`{`
`226`		`- TerminalOutput.raise(L"\r\n"); // we probably got a \r, so we need to advance to the next line.`
	`232`	`+ TerminalOutput.raise(winrt_wstring_to_array_view(L"\r\n")); // we probably got a \r, so we need to advance to the next line.`
`227`	`233`	`_currentInputMode = InputMode::None; // toggling the mode indicates completion`
`228`	`234`	`_inputEvent.notify_one();`
`229`	`235`	`break;`
`@@ -429,7 +435,7 @@ namespace winrt::Microsoft::Terminal::TerminalConnection::implementation`
`429`	`435`	`}`
`430`	`436`
`431`	`437`	`// Pass the output to our registered event handlers`
`432`		`- TerminalOutput.raise(_u16Str);`
	`438`	`+ TerminalOutput.raise(winrt_wstring_to_array_view(_u16Str));`
`433`	`439`	`break;`
`434`	`440`	`}`
`435`	`441`	`case WINHTTP_WEB_SOCKET_CLOSE_BUFFER_TYPE:`
`@@ -772,7 +778,7 @@ namespace winrt::Microsoft::Terminal::TerminalConnection::implementation`
`772`	`778`	`const auto shellType = _ParsePreferredShellType(settingsResponse);`
`773`	`779`	`_WriteStringWithNewline(RS_(L"AzureRequestingTerminal"));`
`774`	`780`	`const auto socketUri = _GetTerminal(shellType);`
`775`		`- TerminalOutput.raise(L"\r\n");`
	`781`	`+ TerminalOutput.raise(winrt_wstring_to_array_view(L"\r\n"));`
`776`	`782`
`777`	`783`	`//// Step 8: connecting to said terminal`
`778`	`784`	`{`
Original file line number	Diff line number	Diff line change
`@@ -477,31 +477,28 @@ namespace winrt::Microsoft::Terminal::TerminalConnection::implementation`
`477`	`477`	`const auto hr = wil::ResultFromCaughtException();`
`478`	`478`
`479`	`479`	`// GH#11556 - make sure to format the error code to this string as an UNSIGNED int`
`480`		`- const auto failureText = RS_fmt(L"ProcessFailedToLaunch", _formatStatus(hr), _commandline);`
`481`		`- TerminalOutput.raise(failureText);`
	`480`	`+ auto failureText = RS_fmt(L"ProcessFailedToLaunch", _formatStatus(hr), _commandline);`
`482`	`481`
`483`	`482`	`// If the path was invalid, let's present an informative message to the user`
`484`	`483`	`if (hr == HRESULT_FROM_WIN32(ERROR_DIRECTORY))`
`485`	`484`	`{`
`486`		`- const auto badPathText = RS_fmt(L"BadPathText", _startingDirectory);`
`487`		`- TerminalOutput.raise(L"\r\n");`
`488`		`- TerminalOutput.raise(badPathText);`
	`485`	`+ failureText.append(L"\r\n");`
	`486`	`+ failureText.append(RS_fmt(L"BadPathText", _startingDirectory));`
`489`	`487`	`}`
`490`	`488`	`// If the requested action requires elevation, display appropriate message`
`491`	`489`	`else if (hr == HRESULT_FROM_WIN32(ERROR_ELEVATION_REQUIRED))`
`492`	`490`	`{`
`493`		`- const auto elevationText = RS_(L"ElevationRequired");`
`494`		`- TerminalOutput.raise(L"\r\n");`
`495`		`- TerminalOutput.raise(elevationText);`
	`491`	`+ failureText.append(L"\r\n");`
	`492`	`+ failureText.append(RS_(L"ElevationRequired"));`
`496`	`493`	`}`
`497`	`494`	`// If the requested executable was not found, display appropriate message`
`498`	`495`	`else if (hr == HRESULT_FROM_WIN32(ERROR_FILE_NOT_FOUND))`
`499`	`496`	`{`
`500`		`- const auto fileNotFoundText = RS_(L"FileNotFound");`
`501`		`- TerminalOutput.raise(L"\r\n");`
`502`		`- TerminalOutput.raise(fileNotFoundText);`
	`497`	`+ failureText.append(L"\r\n");`
	`498`	`+ failureText.append(RS_(L"FileNotFound"));`
`503`	`499`	`}`
`504`	`500`
	`501`	`+ TerminalOutput.raise(winrt_wstring_to_array_view(failureText));`
`505`	`502`	`_transitionToState(ConnectionState::Failed);`
`506`	`503`
`507`	`504`	`// Tear down any state we may have accumulated.`
`@@ -520,7 +517,7 @@ namespace winrt::Microsoft::Terminal::TerminalConnection::implementation`
`520`	`517`	`const auto msg1 = RS_fmt(L"ProcessExited", _formatStatus(status));`
`521`	`518`	`const auto msg2 = RS_(L"CtrlDToClose");`
`522`	`519`	`const auto msg = fmt::format(FMT_COMPILE(L"\r\n{}\r\n{}\r\n"), msg1, msg2);`
`523`		`- TerminalOutput.raise(msg);`
	`520`	`+ TerminalOutput.raise(winrt_wstring_to_array_view(msg));`
`524`	`521`	`}`
`525`	`522`	`CATCH_LOG();`
`526`	`523`	`}`
`@@ -792,7 +789,7 @@ namespace winrt::Microsoft::Terminal::TerminalConnection::implementation`
`792`	`789`
`793`	`790`	`try`
`794`	`791`	`{`
`795`		`- TerminalOutput.raise(wstr);`
	`792`	`+ TerminalOutput.raise(winrt_wstring_to_array_view(wstr));`
`796`	`793`	`}`
`797`	`794`	`CATCH_LOG();`
`798`	`795`	`}`
Original file line number	Diff line number	Diff line change
`@@ -34,7 +34,7 @@ namespace winrt::Microsoft::Terminal::TerminalConnection::implementation`
`34`	`34`	`prettyPrint << wch;`
`35`	`35`	`}`
`36`	`36`	`}`
`37`		`- TerminalOutput.raise(prettyPrint.str());`
	`37`	`+ TerminalOutput.raise(winrt_wstring_to_array_view(prettyPrint.str()));`
`38`	`38`	`}`
`39`	`39`
`40`	`40`	`void EchoConnection::Resize(uint32_t /rows/, uint32_t /columns/) noexcept`
Original file line number	Diff line number	Diff line change
`@@ -13,7 +13,7 @@ namespace Microsoft.Terminal.TerminalConnection`
`13`	`13`	`Failed`
`14`	`14`	`};`
`15`	`15`
`16`		`- delegate void TerminalOutputHandler(String output);`
	`16`	`+ delegate void TerminalOutputHandler(Char[] output);`
`17`	`17`
`18`	`18`	`interface ITerminalConnection`
`19`	`19`	`{`
Original file line number	Diff line number	Diff line change
`@@ -10,8 +10,6 @@`
`10`	`10`
`11`	`11`	`#include <DefaultSettings.h>`
`12`	`12`	`#include <unicode.hpp>`
`13`		`-#include <utils.hpp>`
`14`		`-#include <WinUser.h>`
`15`	`13`
`16`	`14`	`#include "EventArgs.h"`
`17`	`15`	`#include "../../renderer/atlas/AtlasEngine.h"`
`@@ -2238,13 +2236,13 @@ namespace winrt::Microsoft::Terminal::Control::implementation`
`2238`	`2236`	`auto noticeArgs = winrt::make<NoticeEventArgs>(NoticeLevel::Info, RS_(L"TermControlReadOnly"));`
`2239`	`2237`	`RaiseNotice.raise(*this, std::move(noticeArgs));`
`2240`	`2238`	`}`
`2241`		`- void ControlCore::_connectionOutputHandler(const hstring& hstr)`
	`2239`	`+ void ControlCore::_connectionOutputHandler(const winrt::array_view<const char16_t> str)`
`2242`	`2240`	`{`
`2243`	`2241`	`try`
`2244`	`2242`	`{`
`2245`	`2243`	`{`
`2246`	`2244`	`const auto lock = _terminal->LockForWriting();`
`2247`		`- _terminal->Write(hstr);`
	`2245`	`+ _terminal->Write(winrt_array_to_wstring_view(str));`
`2248`	`2246`	`}`
`2249`	`2247`
`2250`	`2248`	`if (!_pendingResponses.empty())`
Original file line number	Diff line number	Diff line change
`@@ -28,10 +28,11 @@ namespace winrt::Microsoft::Terminal::Settings::Editor::implementation`
`28`	`28`	`{`
`29`	`29`	`PreviewConnection::PreviewConnection() noexcept = default;`
`30`	`30`
`31`		`- void PreviewConnection::Start() noexcept`
	`31`	`+ void PreviewConnection::Start()`
`32`	`32`	`{`
`33`		`- // Send the preview text`
`34`		`- TerminalOutput.raise(fmt::format(PreviewText, _displayPowerlineGlyphs ? PromptTextPowerline : PromptTextPlain));`
	`33`	`+ const auto prompt = _displayPowerlineGlyphs ? PromptTextPowerline : PromptTextPlain;`
	`34`	`+ const auto text = fmt::format(FMT_COMPILE(PreviewText), prompt);`
	`35`	`+ TerminalOutput.raise(winrt_wstring_to_array_view(text));`
`35`	`36`	`}`
`36`	`37`
`37`	`38`	`void PreviewConnection::Initialize(const Windows::Foundation::Collections::ValueSet& /settings/) noexcept`
`@@ -50,7 +51,7 @@ namespace winrt::Microsoft::Terminal::Settings::Editor::implementation`
`50`	`51`	`{`
`51`	`52`	`}`
`52`	`53`
`53`		`- void PreviewConnection::DisplayPowerlineGlyphs(bool d) noexcept`
	`54`	`+ void PreviewConnection::DisplayPowerlineGlyphs(bool d)`
`54`	`55`	`{`
`55`	`56`	`if (_displayPowerlineGlyphs != d)`
`56`	`57`	`{`