Prevent flickering in nushell due to FTCS marks

src/host/screenInfo.cpp

@@ -2349,7 +2349,10 @@ void SCREEN_INFORMATION::SetTerminalConnection(_In_ VtEngine* const pTtyConnecti
     if (pTtyConnection)
     {
         engine.SetTerminalConnection(pTtyConnection,
-                                     std::bind(&StateMachine::FlushToTerminal, _stateMachine.get()));
+                                     [&stateMachine = *_stateMachine]() -> bool {
+                                         ServiceLocator::LocateGlobals().pRender->NotifyPaintFrame();
+                                         return stateMachine.FlushToTerminal();
+                                     });
     }
     else
     {

src/renderer/vt/XtermEngine.cpp

@@ -534,10 +534,16 @@ CATCH_RETURN();
     // decided to pass through would have gotten buffered here until the next
     // actual frame is triggered.
     //
-    // To fix this, flush here, so this string is sent to the connected terminal
-    // application.
+    // Originally, we would _Flush()  here, so this string (and anything buffered) is sent to the connected
+    // terminal application. As of GH#13710, we won't. We'll just buffer the string.
+    //
+    // Now, we've added a NotifyPaintFrame to the state machine's
+    // FlushToTerminal callback. That callback will allow us to add this wstr to
+    // the buffer now, without pushing the entire buffer out to the pipe right
+    // now. The NotifyPaintFrame in that callback will ensure that a Flush
+    // definitely _does_ happen (after this whole string is processed).
 
-    return _Flush();
+    return S_OK;
 }
 
 // Method Description:

src/renderer/vt/invalidate.cpp

@@ -120,6 +120,12 @@ CATCH_RETURN();
         _circled = circled;
     }
 
+    // If we flushed for any reason other than circling, we don't need to push
+    // the buffer out on EndPaint. We're doing this because we encountered some
+    // VT sequence that required we sync the state of the buffers before passing
+    // it through.
+    _noFlushOnEnd = !circled;
+
     _trace.TraceTriggerCircling(*pForcePaint);
 
     return S_OK;

src/renderer/vt/paint.cpp

@@ -94,7 +94,22 @@ using namespace Microsoft::Console::Types;
         RETURN_IF_FAILED(_MoveCursor(_deferredCursorPos));
     }
 
-    RETURN_IF_FAILED(_Flush());
+    // If this frame was triggered because we encountered a VT sequence which
+    // required the buffered state to get printed, we don't want to flush this
+    // frame to the pipe. That might result in us rendering half the output of a
+    // particular frame (as emitted by the client).
+    //
+    // Instead, we'll leave this frame in _buffer, and just keep appending to
+    // it as needed.
+    if (_noFlushOnEnd)
+        [[unlikely]]
+    {
+        _noFlushOnEnd = false;
+    }
+    else
+    {
+        RETURN_IF_FAILED(_Flush());
+    }
 
     return S_OK;
 }
@@ -538,7 +553,8 @@ using namespace Microsoft::Console::Types;
     // Write the actual text string. If we're using a soft font, the character
     // set should have already been selected, so we just need to map our internal
     // representation back to ASCII (handled by the _WriteTerminalDrcs method).
-    if (_usingSoftFont) [[unlikely]]
+    if (_usingSoftFont)
+        [[unlikely]]
     {
         RETURN_IF_FAILED(VtEngine::_WriteTerminalDrcs({ _bufferLine.data(), cchActual }));
     }

src/renderer/vt/vtrenderer.hpp

@@ -139,6 +139,7 @@ namespace Microsoft::Console::Render
 
         bool _resizeQuirk{ false };
         bool _passthrough{ false };
+        bool _noFlushOnEnd{ false };
         std::optional<TextColor> _newBottomLineBG{ std::nullopt };
 
         [[nodiscard]] HRESULT _WriteFill(const size_t n, const char c) noexcept;

src/terminal/parser/OutputStateMachineEngine.cpp

@@ -168,6 +168,7 @@ bool OutputStateMachineEngine::ActionPassThroughString(const std::wstring_view s
     if (_pTtyConnection != nullptr)
     {
         const auto hr = _pTtyConnection->WriteTerminalW(string);
+
         LOG_IF_FAILED(hr);
         success = SUCCEEDED(hr);
     }