yea sure this works I guess

src/cascadia/WindowsTerminal/AppHost.cpp

@@ -31,7 +31,8 @@ static constexpr short KeyPressed{ gsl::narrow_cast<short>(0x8000) };
 AppHost::AppHost(const winrt::TerminalApp::AppLogic& logic,
                  winrt::Microsoft::Terminal::Remoting::WindowRequestedArgs args,
                  const Remoting::WindowManager& manager,
-                 const Remoting::Peasant& peasant) noexcept :
+                 const Remoting::Peasant& peasant,
+                 std::unique_ptr<IslandWindow> window) noexcept :
     _appLogic{ logic },
     _windowLogic{ nullptr }, // don't make one, we're going to take a ref on app's
     _windowManager{ manager },
@@ -44,13 +45,21 @@ AppHost::AppHost(const winrt::TerminalApp::AppLogic& logic,
 
     // _HandleCommandlineArgs will create a _windowLogic
     _useNonClientArea = _windowLogic.GetShowTabsInTitlebar();
-    if (_useNonClientArea)
+
+    if (window)
     {
-        _window = std::make_unique<NonClientIslandWindow>(_windowLogic.GetRequestedTheme());
+        _window = std::move(window);
     }
     else
     {
-        _window = std::make_unique<IslandWindow>();
+        if (_useNonClientArea)
+        {
+            _window = std::make_unique<NonClientIslandWindow>(_windowLogic.GetRequestedTheme());
+        }
+        else
+        {
+            _window = std::make_unique<IslandWindow>();
+        }
     }
 
     // Update our own internal state tracking if we're in quake mode or not.
@@ -65,16 +74,38 @@ AppHost::AppHost(const winrt::TerminalApp::AppLogic& logic,
                          std::placeholders::_2);
     _window->SetCreateCallback(pfn);
 
-    _window->MouseScrolled({ this, &AppHost::_WindowMouseWheeled });
-    _window->WindowActivated({ this, &AppHost::_WindowActivated });
-    _window->WindowMoved({ this, &AppHost::_WindowMoved });
+    _windowCallbacks.MouseScrolled = _window->MouseScrolled({ this, &AppHost::_WindowMouseWheeled });
+    _windowCallbacks.WindowActivated = _window->WindowActivated({ this, &AppHost::_WindowActivated });
+    _windowCallbacks.WindowMoved = _window->WindowMoved({ this, &AppHost::_WindowMoved });
+    _windowCallbacks.ShouldExitFullscreen = _window->ShouldExitFullscreen({ &_windowLogic, &winrt::TerminalApp::TerminalWindow::RequestExitFullscreen });
 
-    _window->ShouldExitFullscreen({ &_windowLogic, &winrt::TerminalApp::TerminalWindow::RequestExitFullscreen });
+    // TODO! These call APIs that are re-entrant on the window message loop.
+    // If you call them in the ctor, then if we're being instantiated for a reheated thread, we'll deadlock.
+    // _window->SetAlwaysOnTop(_windowLogic.GetInitialAlwaysOnTop());
+    // _window->SetAutoHideWindow(_windowLogic.AutoHideWindow());
 
-    _window->SetAlwaysOnTop(_windowLogic.GetInitialAlwaysOnTop());
-    _window->SetAutoHideWindow(_windowLogic.AutoHideWindow());
-
-    _window->MakeWindow();
+    if (_window->GetHandle() == nullptr)
+    {
+        _window->MakeWindow();
+    }
+    else
+    {
+        // _window->Microwave();
+
+        //auto dispatcher = winrt::Windows::System::DispatcherQueue::GetForCurrentThread();
+        //dispatcher.TryEnqueue([this]() {
+        //    // TODO! obv these bounds are wrong
+        //    _HandleCreateWindow(_window->GetHandle(), til::rect{ 0, 0, 256, 256 });
+        //});
+
+        CREATESTRUCTW dumb{
+            .cy = 256,
+            .cx = 256,
+            .y = 0,
+            .x = 0,
+        };
+        PostMessageW(_window->GetHandle(), WM_CREATE, 0, (LPARAM)&dumb);
+    }
 }
 
 bool AppHost::OnDirectKeyEvent(const uint32_t vkey, const uint8_t scanCode, const bool down)
@@ -297,7 +328,7 @@ void AppHost::Initialize()
 
     // Register the 'X' button of the window for a warning experience of multiple
     // tabs opened, this is consistent with Alt+F4 closing
-    _window->WindowCloseButtonClicked([this]() {
+    _windowCallbacks.WindowCloseButtonClicked = _window->WindowCloseButtonClicked([this]() {
         _CloseRequested(nullptr, nullptr);
     });
     // If the user requests a close in another way handle the same as if the 'X'
@@ -306,11 +337,11 @@ void AppHost::Initialize()
 
     // Add an event handler to plumb clicks in the titlebar area down to the
     // application layer.
-    _window->DragRegionClicked([this]() { _windowLogic.TitlebarClicked(); });
+    _windowCallbacks.DragRegionClicked = _window->DragRegionClicked([this]() { _windowLogic.TitlebarClicked(); });
 
-    _window->WindowVisibilityChanged([this](bool showOrHide) { _windowLogic.WindowVisibilityChanged(showOrHide); });
+    _windowCallbacks.WindowVisibilityChanged = _window->WindowVisibilityChanged([this](bool showOrHide) { _windowLogic.WindowVisibilityChanged(showOrHide); });
 
-    _window->UpdateSettingsRequested({ this, &AppHost::_requestUpdateSettings });
+    _windowCallbacks.UpdateSettingsRequested = _window->UpdateSettingsRequested({ this, &AppHost::_requestUpdateSettings });
 
     _revokers.Initialized = _windowLogic.Initialized(winrt::auto_revoke, { this, &AppHost::_WindowInitializedHandler });
     _revokers.RequestedThemeChanged = _windowLogic.RequestedThemeChanged(winrt::auto_revoke, { this, &AppHost::_UpdateTheme });
@@ -321,14 +352,14 @@ void AppHost::Initialize()
     _revokers.SystemMenuChangeRequested = _windowLogic.SystemMenuChangeRequested(winrt::auto_revoke, { this, &AppHost::_SystemMenuChangeRequested });
     _revokers.ChangeMaximizeRequested = _windowLogic.ChangeMaximizeRequested(winrt::auto_revoke, { this, &AppHost::_ChangeMaximizeRequested });
 
-    _window->MaximizeChanged([this](bool newMaximize) {
+    _windowCallbacks.MaximizeChanged = _window->MaximizeChanged([this](bool newMaximize) {
         if (_windowLogic)
         {
             _windowLogic.Maximized(newMaximize);
         }
     });
 
-    _window->AutomaticShutdownRequested([this]() {
+    _windowCallbacks.AutomaticShutdownRequested = _window->AutomaticShutdownRequested([this]() {
         // Raised when the OS is beginning an update of the app. We will quit,
         // to save our state, before the OS manually kills us.
         Remoting::WindowManager::RequestQuitAll(_peasant);
@@ -429,6 +460,36 @@ void AppHost::Close()
     }
 }
 
+[[nodiscard]] std::unique_ptr<IslandWindow> AppHost::Refrigerate()
+{
+    // After calling _window->Close() we should avoid creating more WinUI related actions.
+    // I suspect WinUI wouldn't like that very much. As such unregister all event handlers first.
+    _revokers = {};
+    _showHideWindowThrottler.reset();
+
+    // DO NOT CLOSE THE WINDOW
+    _window->Refrigerate();
+
+    _window->MouseScrolled(_windowCallbacks.MouseScrolled);
+    _window->WindowActivated(_windowCallbacks.WindowActivated);
+    _window->WindowMoved(_windowCallbacks.WindowMoved);
+    _window->ShouldExitFullscreen(_windowCallbacks.ShouldExitFullscreen);
+    _window->WindowCloseButtonClicked(_windowCallbacks.WindowCloseButtonClicked);
+    _window->DragRegionClicked(_windowCallbacks.DragRegionClicked);
+    _window->WindowVisibilityChanged(_windowCallbacks.WindowVisibilityChanged);
+    _window->UpdateSettingsRequested(_windowCallbacks.UpdateSettingsRequested);
+    _window->MaximizeChanged(_windowCallbacks.MaximizeChanged);
+    _window->AutomaticShutdownRequested(_windowCallbacks.AutomaticShutdownRequested);
+
+    if (_windowLogic)
+    {
+        _windowLogic.DismissDialog();
+        _windowLogic = nullptr;
+    }
+
+    return std::move(_window);
+}
+
 // Method Description:
 // - Called every time when the active tab's title changes. We'll also fire off
 //   a window message so we can update the window's title on the main thread,

src/cascadia/WindowsTerminal/AppHost.h

@@ -12,12 +12,16 @@ class AppHost
     AppHost(const winrt::TerminalApp::AppLogic& logic,
             winrt::Microsoft::Terminal::Remoting::WindowRequestedArgs args,
             const winrt::Microsoft::Terminal::Remoting::WindowManager& manager,
-            const winrt::Microsoft::Terminal::Remoting::Peasant& peasant) noexcept;
+            const winrt::Microsoft::Terminal::Remoting::Peasant& peasant,
+            std::unique_ptr<IslandWindow> window = nullptr) noexcept;
 
     void AppTitleChanged(const winrt::Windows::Foundation::IInspectable& sender, winrt::hstring newTitle);
     void LastTabClosed(const winrt::Windows::Foundation::IInspectable& sender, const winrt::TerminalApp::LastTabClosedEventArgs& args);
     void Initialize();
     void Close();
+
+    [[nodiscard]] std::unique_ptr<IslandWindow> Refrigerate();
+
     bool OnDirectKeyEvent(const uint32_t vkey, const uint8_t scanCode, const bool down);
     void SetTaskbarProgress(const winrt::Windows::Foundation::IInspectable& sender, const winrt::Windows::Foundation::IInspectable& args);
 
@@ -194,4 +198,24 @@ class AppHost
         winrt::Microsoft::Terminal::Remoting::WindowManager::QuitAllRequested_revoker QuitAllRequested;
         winrt::Microsoft::Terminal::Remoting::Peasant::SendContentRequested_revoker SendContentRequested;
     } _revokers{};
+
+    // our IslandWindow is not a WinRT type. It can't make auto_revokers like
+    // the above. We also need to make sure to unregister ourself from the
+    // window when we refrigerate the window thread so that the window can later
+    // be re-used.
+    struct WindowRevokers
+    {
+        winrt::event_token MouseScrolled;
+        winrt::event_token WindowActivated;
+        winrt::event_token WindowMoved;
+        winrt::event_token ShouldExitFullscreen;
+        winrt::event_token WindowCloseButtonClicked;
+        winrt::event_token DragRegionClicked;
+        winrt::event_token WindowVisibilityChanged;
+        winrt::event_token UpdateSettingsRequested;
+        winrt::event_token MaximizeChanged;
+        winrt::event_token AutomaticShutdownRequested;
+        // LOAD BEARING!!
+        //If you add events here, make sure they're revokec in AppHost::Refrigerate
+    } _windowCallbacks{};
 };

src/cascadia/WindowsTerminal/IslandWindow.cpp

@@ -42,13 +42,24 @@ IslandWindow::~IslandWindow()
 
 void IslandWindow::Close()
 {
+    // auto a{ _source };
+    // winrt::detach_abi(_source);
     if (_source)
     {
         _source.Close();
         _source = nullptr;
     }
 }
 
+void IslandWindow::Refrigerate() noexcept
+{
+    _pfnCreateCallback = nullptr;
+    _pfnSnapDimensionCallback = nullptr;
+
+    _rootGrid.Children().Clear();
+    ShowWindow(_window.get(), SW_HIDE);
+}
+
 HWND IslandWindow::GetInteropHandle() const
 {
     return _interopWindowHandle;
@@ -295,38 +306,45 @@ LRESULT IslandWindow::_OnMoving(const WPARAM /*wParam*/, const LPARAM lParam)
     return false;
 }
 
-void IslandWindow::Initialize()
+// return true if this was a "cold" initialize, that didn't start XAML before.
+bool IslandWindow::Initialize()
 {
-    _source = DesktopWindowXamlSource{};
+    if (!_source)
+    {
+        _source = DesktopWindowXamlSource{};
 
-    auto interop = _source.as<IDesktopWindowXamlSourceNative>();
-    winrt::check_hresult(interop->AttachToWindow(_window.get()));
+        auto interop = _source.as<IDesktopWindowXamlSourceNative>();
+        winrt::check_hresult(interop->AttachToWindow(_window.get()));
 
-    // stash the child interop handle so we can resize it when the main hwnd is resized
-    interop->get_WindowHandle(&_interopWindowHandle);
+        // stash the child interop handle so we can resize it when the main hwnd is resized
+        interop->get_WindowHandle(&_interopWindowHandle);
 
-    // Immediately hide our XAML island hwnd. On earlier versions of Windows,
-    // this HWND could sometimes appear as an actual window in the taskbar
-    // without this!
-    ShowWindow(_interopWindowHandle, SW_HIDE);
+        // Immediately hide our XAML island hwnd. On earlier versions of Windows,
+        // this HWND could sometimes appear as an actual window in the taskbar
+        // without this!
+        ShowWindow(_interopWindowHandle, SW_HIDE);
 
-    _rootGrid = winrt::Windows::UI::Xaml::Controls::Grid();
-    _source.Content(_rootGrid);
+        _rootGrid = winrt::Windows::UI::Xaml::Controls::Grid();
+        _source.Content(_rootGrid);
 
-    // initialize the taskbar object
-    if (auto taskbar = wil::CoCreateInstanceNoThrow<ITaskbarList3>(CLSID_TaskbarList))
-    {
-        if (SUCCEEDED(taskbar->HrInit()))
+        // initialize the taskbar object
+        if (auto taskbar = wil::CoCreateInstanceNoThrow<ITaskbarList3>(CLSID_TaskbarList))
         {
-            _taskbar = std::move(taskbar);
+            if (SUCCEEDED(taskbar->HrInit()))
+            {
+                _taskbar = std::move(taskbar);
+            }
         }
-    }
 
-    _systemMenuNextItemId = IDM_SYSTEM_MENU_BEGIN;
+        _systemMenuNextItemId = IDM_SYSTEM_MENU_BEGIN;
+
+        // Enable vintage opacity by removing the XAML emergency backstop, GH#603.
+        // We don't really care if this failed or not.
+        TerminalTrySetTransparentBackground(true);
 
-    // Enable vintage opacity by removing the XAML emergency backstop, GH#603.
-    // We don't really care if this failed or not.
-    TerminalTrySetTransparentBackground(true);
+        return true;
+    }
+    return false;
 }
 
 void IslandWindow::OnSize(const UINT width, const UINT height)

src/cascadia/WindowsTerminal/IslandWindow.h

@@ -3,6 +3,7 @@
 
 #include "pch.h"
 #include "BaseWindow.h"
+#include <til/winrt.h>
 
 void SetWindowLongWHelper(const HWND hWnd, const int nIndex, const LONG dwNewLong) noexcept;
 
@@ -21,6 +22,9 @@ class IslandWindow :
 
     virtual void MakeWindow() noexcept;
     virtual void Close();
+
+    void Refrigerate() noexcept;
+
     virtual void OnSize(const UINT width, const UINT height);
     HWND GetInteropHandle() const;
 
@@ -37,7 +41,7 @@ class IslandWindow :
     virtual til::rect GetNonClientFrame(const UINT dpi) const noexcept;
     virtual til::size GetTotalNonClientExclusiveSize(const UINT dpi) const noexcept;
 
-    virtual void Initialize();
+    virtual bool Initialize();
 
     void SetCreateCallback(std::function<void(const HWND, const til::rect&)> pfn) noexcept;
 

src/cascadia/WindowsTerminal/NonClientIslandWindow.cpp

@@ -335,9 +335,9 @@ void NonClientIslandWindow::OnAppInitialized()
     IslandWindow::OnAppInitialized();
 }
 
-void NonClientIslandWindow::Initialize()
+bool NonClientIslandWindow::Initialize()
 {
-    IslandWindow::Initialize();
+    const bool coldInit = IslandWindow::Initialize();
 
     _UpdateFrameMargins();
 
@@ -367,6 +367,8 @@ void NonClientIslandWindow::Initialize()
     // then make sure to update its visual state to reflect if we're in the
     // maximized state on launch.
     _titlebar.Loaded([this](auto&&, auto&&) { _OnMaximizeChange(); });
+
+    return coldInit;
 }
 
 // Method Description:
@@ -519,8 +521,8 @@ void NonClientIslandWindow::_OnMaximizeChange() noexcept
         const auto isIconified = WI_IsFlagSet(windowStyle, WS_ICONIC);
 
         const auto state = _isMaximized ? winrt::TerminalApp::WindowVisualState::WindowVisualStateMaximized :
-                           isIconified  ? winrt::TerminalApp::WindowVisualState::WindowVisualStateIconified :
-                                          winrt::TerminalApp::WindowVisualState::WindowVisualStateNormal;
+                                          isIconified ? winrt::TerminalApp::WindowVisualState::WindowVisualStateIconified :
+                                                        winrt::TerminalApp::WindowVisualState::WindowVisualStateNormal;
 
         try
         {

src/cascadia/WindowsTerminal/NonClientIslandWindow.h

@@ -40,7 +40,7 @@ class NonClientIslandWindow : public IslandWindow
     virtual til::rect GetNonClientFrame(UINT dpi) const noexcept override;
     virtual til::size GetTotalNonClientExclusiveSize(UINT dpi) const noexcept override;
 
-    void Initialize() override;
+    bool Initialize() override;
 
     void OnAppInitialized() override;
     void SetContent(winrt::Windows::UI::Xaml::UIElement content) override;