Migrate spelling-0.0.21 changes from main

(cherry picked from commit d2d462fc48)

.clang-format

@@ -1,17 +1,19 @@
 
 AccessModifierOffset: -4
 AlignAfterOpenBracket: Align
-#AllowAllArgumentsOnNextLine: false
+AllowAllArgumentsOnNextLine: true
+AlignConsecutiveMacros: false
 AlignConsecutiveAssignments: false
 AlignConsecutiveDeclarations: false
-#AllowAllConstructorInitializersOnNextLine: false
+AllowAllConstructorInitializersOnNextLine: true
 AlignEscapedNewlines: Left
 AlignOperands: true
 AlignTrailingComments: false
 AllowAllParametersOfDeclarationOnNextLine: false
+AllowShortBlocksOnASingleLine: Never
 AllowShortFunctionsOnASingleLine: Inline
 AllowShortCaseLabelsOnASingleLine: false
-AllowShortIfStatementsOnASingleLine: false
+AllowShortIfStatementsOnASingleLine: Never
 #AllowShortLambdasOnASingleLine: Inline
 AllowShortLoopsOnASingleLine: false
 AlwaysBreakAfterReturnType: None
@@ -20,6 +22,7 @@ AlwaysBreakTemplateDeclarations: Yes
 BinPackArguments: false
 BinPackParameters: false
 BraceWrapping:
+  AfterCaseLabel: true
   AfterClass: true
   AfterControlStatement: true
   AfterEnum: true
@@ -47,6 +50,7 @@ ConstructorInitializerAllOnOneLineOrOnePerLine: true
 ConstructorInitializerIndentWidth: 4
 ContinuationIndentWidth: 4
 Cpp11BracedListStyle: false
+DeriveLineEnding: true
 DerivePointerAlignment: false
 FixNamespaceComments: false
 IncludeBlocks: Regroup
@@ -73,7 +77,7 @@ ReflowComments: false
 SortIncludes: false
 SortUsingDeclarations: true
 SpaceAfterCStyleCast: false
-#SpaceAfterLogicalNot: false
+SpaceAfterLogicalNot: false
 SpaceAfterTemplateKeyword: false
 SpaceBeforeAssignmentOperators: true
 SpaceBeforeCpp11BracedList: false
@@ -88,6 +92,6 @@ SpacesInCStyleCastParentheses: false
 SpacesInContainerLiterals: false
 SpacesInParentheses: false
 SpacesInSquareBrackets: false
-Standard: Cpp11
+Standard: Latest
 TabWidth: 4
 UseTab: Never

NuGet.Config

@@ -9,6 +9,11 @@
         
         <!-- Use our own NuGet Feed -->
         <add key="TerminalDependencies" value="https://pkgs.dev.azure.com/ms/terminal/_packaging/TerminalDependencies/nuget/v3/index.json" />
+		
+		<!-- Temporarily? use the feeds from our friends in MUX for Helix test stuff -->
+		<add key="dotnetfeed" value="https://dotnetfeed.blob.core.windows.net/dotnet-core/index.json" />
+        <add key="dnceng" value="https://pkgs.dev.azure.com/dnceng/public/_packaging/dotnet-eng/nuget/v3/index.json" />
+        <add key="MUX-Dependencies" value="https://pkgs.dev.azure.com/ms/microsoft-ui-xaml/_packaging/MUX-Dependencies/nuget/v3/index.json" />
         
         <!-- Internal NuGet feeds that may not be accessible outside Microsoft corporate network -->
         <!--<add key="TAEF - internal" value="https://microsoft.pkgs.visualstudio.com/DefaultCollection/_packaging/Taef/nuget/v3/index.json" />

OpenConsole.sln

@@ -160,15 +160,11 @@ EndProject
 Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "TerminalConnection", "src\cascadia\TerminalConnection\TerminalConnection.vcxproj", "{CA5CAD1A-C46D-4588-B1C0-40F31AE9100B}"
 EndProject
 Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "TerminalCore", "src\cascadia\TerminalCore\lib\TerminalCore-lib.vcxproj", "{CA5CAD1A-ABCD-429C-B551-8562EC954746}"
-	ProjectSection(ProjectDependencies) = postProject
-		{CA5CAD1A-D7EC-4107-B7C6-79CB77AE2907} = {CA5CAD1A-D7EC-4107-B7C6-79CB77AE2907}
-	EndProjectSection
 EndProject
 Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "TerminalControl", "src\cascadia\TerminalControl\TerminalControl.vcxproj", "{CA5CAD1A-44BD-4AC7-AC72-6CA5B3AB89ED}"
 	ProjectSection(ProjectDependencies) = postProject
 		{CA5CAD1A-C46D-4588-B1C0-40F31AE9100B} = {CA5CAD1A-C46D-4588-B1C0-40F31AE9100B}
 		{CA5CAD1A-ABCD-429C-B551-8562EC954746} = {CA5CAD1A-ABCD-429C-B551-8562EC954746}
-		{CA5CAD1A-D7EC-4107-B7C6-79CB77AE2907} = {CA5CAD1A-D7EC-4107-B7C6-79CB77AE2907}
 		{1CF55140-EF6A-4736-A403-957E4F7430BB} = {1CF55140-EF6A-4736-A403-957E4F7430BB}
 		{48D21369-3D7B-4431-9967-24E81292CF63} = {48D21369-3D7B-4431-9967-24E81292CF63}
 	EndProjectSection
@@ -178,20 +174,16 @@ Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "WindowsTerminal", "src\casc
 		{CA5CAD1A-44BD-4AC7-AC72-6CA5B3AB89ED} = {CA5CAD1A-44BD-4AC7-AC72-6CA5B3AB89ED}
 		{CA5CAD1A-44BD-4AC7-AC72-F16E576FDD12} = {CA5CAD1A-44BD-4AC7-AC72-F16E576FDD12}
 		{CA5CAD1A-ABCD-429C-B551-8562EC954746} = {CA5CAD1A-ABCD-429C-B551-8562EC954746}
-		{CA5CAD1A-D7EC-4107-B7C6-79CB77AE2907} = {CA5CAD1A-D7EC-4107-B7C6-79CB77AE2907}
 		{9CBD7DFA-1754-4A9D-93D7-857A9D17CB1B} = {9CBD7DFA-1754-4A9D-93D7-857A9D17CB1B}
 	EndProjectSection
 EndProject
-Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "TerminalApp", "src\cascadia\TerminalApp\TerminalApp.vcxproj", "{CA5CAD1A-44BD-4AC7-AC72-F16E576FDD12}"
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "TerminalApp", "src\cascadia\TerminalApp\dll\TerminalApp.vcxproj", "{CA5CAD1A-44BD-4AC7-AC72-F16E576FDD12}"
 	ProjectSection(ProjectDependencies) = postProject
 		{CA5CAD1A-9A12-429C-B551-8562EC954746} = {CA5CAD1A-9A12-429C-B551-8562EC954746}
 		{CA5CAD1A-C46D-4588-B1C0-40F31AE9100B} = {CA5CAD1A-C46D-4588-B1C0-40F31AE9100B}
 		{CA5CAD1A-44BD-4AC7-AC72-6CA5B3AB89ED} = {CA5CAD1A-44BD-4AC7-AC72-6CA5B3AB89ED}
-		{CA5CAD1A-D7EC-4107-B7C6-79CB77AE2907} = {CA5CAD1A-D7EC-4107-B7C6-79CB77AE2907}
 	EndProjectSection
 EndProject
-Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "TerminalSettings", "src\cascadia\TerminalSettings\TerminalSettings.vcxproj", "{CA5CAD1A-D7EC-4107-B7C6-79CB77AE2907}"
-EndProject
 Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "WindowsTerminalShellExt", "src\cascadia\ShellExtension\WindowsTerminalShellExt.vcxproj", "{F2ED628A-DB22-446F-A081-4CC845B51A2B}"
 EndProject
 Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "UnitTests_TerminalCore", "src\cascadia\UnitTests_TerminalCore\UnitTests.vcxproj", "{2C2BEEF4-9333-4D05-B12A-1905CBF112F9}"
@@ -235,10 +227,9 @@ Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "UnitTests_TerminalApp", "sr
 		{CA5CAD1A-9A12-429C-B551-8562EC954746} = {CA5CAD1A-9A12-429C-B551-8562EC954746}
 	EndProjectSection
 EndProject
-Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "TerminalAppLib", "src\cascadia\TerminalApp\lib\TerminalAppLib.vcxproj", "{CA5CAD1A-9A12-429C-B551-8562EC954746}"
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "TerminalAppLib", "src\cascadia\TerminalApp\TerminalAppLib.vcxproj", "{CA5CAD1A-9A12-429C-B551-8562EC954746}"
 	ProjectSection(ProjectDependencies) = postProject
 		{CA5CAD1A-44BD-4AC7-AC72-6CA5B3AB89ED} = {CA5CAD1A-44BD-4AC7-AC72-6CA5B3AB89ED}
-		{CA5CAD1A-D7EC-4107-B7C6-79CB77AE2907} = {CA5CAD1A-D7EC-4107-B7C6-79CB77AE2907}
 	EndProjectSection
 EndProject
 Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "LocalTests_TerminalApp", "src\cascadia\LocalTests_TerminalApp\TerminalApp.LocalTests.vcxproj", "{CA5CAD1A-B11C-4DDB-A4FE-C3AFAE9B5506}"
@@ -1389,35 +1380,6 @@ Global
 		{CA5CAD1A-44BD-4AC7-AC72-F16E576FDD12}.Release|x64.Build.0 = Release|x64
 		{CA5CAD1A-44BD-4AC7-AC72-F16E576FDD12}.Release|x86.ActiveCfg = Release|Win32
 		{CA5CAD1A-44BD-4AC7-AC72-F16E576FDD12}.Release|x86.Build.0 = Release|Win32
-		{CA5CAD1A-D7EC-4107-B7C6-79CB77AE2907}.AuditMode|Any CPU.ActiveCfg = Debug|Win32
-		{CA5CAD1A-D7EC-4107-B7C6-79CB77AE2907}.AuditMode|ARM64.ActiveCfg = Release|ARM64
-		{CA5CAD1A-D7EC-4107-B7C6-79CB77AE2907}.AuditMode|DotNet_x64Test.ActiveCfg = Debug|Win32
-		{CA5CAD1A-D7EC-4107-B7C6-79CB77AE2907}.AuditMode|DotNet_x86Test.ActiveCfg = Debug|Win32
-		{CA5CAD1A-D7EC-4107-B7C6-79CB77AE2907}.AuditMode|x64.ActiveCfg = AuditMode|x64
-		{CA5CAD1A-D7EC-4107-B7C6-79CB77AE2907}.AuditMode|x64.Build.0 = AuditMode|x64
-		{CA5CAD1A-D7EC-4107-B7C6-79CB77AE2907}.AuditMode|x86.ActiveCfg = Release|Win32
-		{CA5CAD1A-D7EC-4107-B7C6-79CB77AE2907}.Debug|Any CPU.ActiveCfg = Debug|Win32
-		{CA5CAD1A-D7EC-4107-B7C6-79CB77AE2907}.Debug|ARM64.ActiveCfg = Debug|ARM64
-		{CA5CAD1A-D7EC-4107-B7C6-79CB77AE2907}.Debug|ARM64.Build.0 = Debug|ARM64
-		{CA5CAD1A-D7EC-4107-B7C6-79CB77AE2907}.Debug|DotNet_x64Test.ActiveCfg = Debug|x64
-		{CA5CAD1A-D7EC-4107-B7C6-79CB77AE2907}.Debug|DotNet_x64Test.Build.0 = Debug|x64
-		{CA5CAD1A-D7EC-4107-B7C6-79CB77AE2907}.Debug|DotNet_x86Test.ActiveCfg = Debug|Win32
-		{CA5CAD1A-D7EC-4107-B7C6-79CB77AE2907}.Debug|DotNet_x86Test.Build.0 = Debug|Win32
-		{CA5CAD1A-D7EC-4107-B7C6-79CB77AE2907}.Debug|x64.ActiveCfg = Debug|x64
-		{CA5CAD1A-D7EC-4107-B7C6-79CB77AE2907}.Debug|x64.Build.0 = Debug|x64
-		{CA5CAD1A-D7EC-4107-B7C6-79CB77AE2907}.Debug|x86.ActiveCfg = Debug|Win32
-		{CA5CAD1A-D7EC-4107-B7C6-79CB77AE2907}.Debug|x86.Build.0 = Debug|Win32
-		{CA5CAD1A-D7EC-4107-B7C6-79CB77AE2907}.Release|Any CPU.ActiveCfg = Release|Win32
-		{CA5CAD1A-D7EC-4107-B7C6-79CB77AE2907}.Release|ARM64.ActiveCfg = Release|ARM64
-		{CA5CAD1A-D7EC-4107-B7C6-79CB77AE2907}.Release|ARM64.Build.0 = Release|ARM64
-		{CA5CAD1A-D7EC-4107-B7C6-79CB77AE2907}.Release|DotNet_x64Test.ActiveCfg = Release|x64
-		{CA5CAD1A-D7EC-4107-B7C6-79CB77AE2907}.Release|DotNet_x64Test.Build.0 = Release|x64
-		{CA5CAD1A-D7EC-4107-B7C6-79CB77AE2907}.Release|DotNet_x86Test.ActiveCfg = Release|Win32
-		{CA5CAD1A-D7EC-4107-B7C6-79CB77AE2907}.Release|DotNet_x86Test.Build.0 = Release|Win32
-		{CA5CAD1A-D7EC-4107-B7C6-79CB77AE2907}.Release|x64.ActiveCfg = Release|x64
-		{CA5CAD1A-D7EC-4107-B7C6-79CB77AE2907}.Release|x64.Build.0 = Release|x64
-		{CA5CAD1A-D7EC-4107-B7C6-79CB77AE2907}.Release|x86.ActiveCfg = Release|Win32
-		{CA5CAD1A-D7EC-4107-B7C6-79CB77AE2907}.Release|x86.Build.0 = Release|Win32
 		{F2ED628A-DB22-446F-A081-4CC845B51A2B}.AuditMode|Any CPU.ActiveCfg = Release|Win32
 		{F2ED628A-DB22-446F-A081-4CC845B51A2B}.AuditMode|ARM64.ActiveCfg = Release|ARM64
 		{F2ED628A-DB22-446F-A081-4CC845B51A2B}.AuditMode|DotNet_x64Test.ActiveCfg = AuditMode|Win32
@@ -2073,7 +2035,6 @@ Global
 		{CA5CAD1A-44BD-4AC7-AC72-6CA5B3AB89ED} = {59840756-302F-44DF-AA47-441A9D673202}
 		{CA5CAD1A-1754-4A9D-93D7-857A9D17CB1B} = {59840756-302F-44DF-AA47-441A9D673202}
 		{CA5CAD1A-44BD-4AC7-AC72-F16E576FDD12} = {59840756-302F-44DF-AA47-441A9D673202}
-		{CA5CAD1A-D7EC-4107-B7C6-79CB77AE2907} = {59840756-302F-44DF-AA47-441A9D673202}
 		{F2ED628A-DB22-446F-A081-4CC845B51A2B} = {59840756-302F-44DF-AA47-441A9D673202}
 		{2C2BEEF4-9333-4D05-B12A-1905CBF112F9} = {BDB237B6-1D1D-400F-84CC-40A58FA59C8E}
 		{EF3E32A7-5FF6-42B4-B6E2-96CD7D033F00} = {E8F24881-5E37-4362-B191-A3BA0ED7F4EB}

README.md

@@ -60,6 +60,22 @@ choco upgrade microsoft-windows-terminal
 
 If you have any issues when installing/upgrading the package please go to the [Windows Terminal package page](https://chocolatey.org/packages/microsoft-windows-terminal) and follow the [Chocolatey triage process](https://chocolatey.org/docs/package-triage-process)
 
+#### Via Scoop (unofficial)
+
+[Scoop](https://scoop.sh) users can download and install the latest Terminal release by installing the `windows-terminal` package:
+
+```powershell
+scoop install windows-terminal
+```
+
+To update Windows Terminal using Scoop, run the following:
+
+```powershell
+scoop update windows-terminal
+```
+
+If you have any issues when installing/updating the package, please search for or report the same on the [issues page](https://github.com/lukesampson/scoop-extras/issues) of Scoop Extras bucket repository.  
+
 ---
 
 ## Windows Terminal 2.0 Roadmap
@@ -163,6 +179,7 @@ If you would like to ask a question that you feel doesn't warrant an issue (yet)
 * Mike Griese, Developer: [@zadjii](https://twitter.com/zadjii)
 * Carlos Zamora, Developer: [@cazamor_msft](https://twitter.com/cazamor_msft)
 * Leon Liang, Developer: [@leonmsft](https://twitter.com/leonmsft)
+* Pankaj Bhojwani, Developer
 
 ## Developer Guidance
 

build/Helix/AzurePipelinesHelperScripts.ps1

@@ -0,0 +1,32 @@
+function GetAzureDevOpsBaseUri
+{
+    Param(
+        [string]$CollectionUri,
+        [string]$TeamProject
+    )
+
+    return $CollectionUri + $TeamProject
+}
+
+function GetQueryTestRunsUri
+{
+    Param(
+        [string]$CollectionUri,
+        [string]$TeamProject,
+        [string]$BuildUri,
+        [switch]$IncludeRunDetails
+    )
+
+    if ($IncludeRunDetails)
+    {
+        $includeRunDetailsParameter = "&includeRunDetails=true"
+    }
+    else
+    {
+        $includeRunDetailsParameter = ""
+    }
+
+    $baseUri = GetAzureDevOpsBaseUri -CollectionUri $CollectionUri -TeamProject $TeamProject
+    $queryUri = "$baseUri/_apis/test/runs?buildUri=$BuildUri$includeRunDetailsParameter&api-version=5.0"
+    return $queryUri
+}

build/Helix/ConvertWttLogToXUnit.ps1

@@ -0,0 +1,28 @@
+Param(
+    [Parameter(Mandatory = $true)] 
+    [string]$WttInputPath,
+
+    [Parameter(Mandatory = $true)] 
+    [string]$WttSingleRerunInputPath,
+
+    [Parameter(Mandatory = $true)] 
+    [string]$WttMultipleRerunInputPath,
+
+    [Parameter(Mandatory = $true)] 
+    [string]$XUnitOutputPath,
+
+    [Parameter(Mandatory = $true)] 
+    [string]$TestNamePrefix
+)
+
+# Ideally these would be passed as parameters to the script. However ps makes it difficult to deal with string literals containing '&', so we just 
+# read the values directly from the environment variables
+$helixResultsContainerUri = $Env:HELIX_RESULTS_CONTAINER_URI
+$helixResultsContainerRsas = $Env:HELIX_RESULTS_CONTAINER_RSAS
+
+$rerunPassesRequiredToAvoidFailure = $env:rerunPassesRequiredToAvoidFailure
+
+Add-Type -Language CSharp -ReferencedAssemblies System.Xml,System.Xml.Linq,System.Runtime.Serialization,System.Runtime.Serialization.Json (Get-Content $PSScriptRoot\HelixTestHelpers.cs -Raw)
+
+$testResultParser = [HelixTestHelpers.TestResultParser]::new($TestNamePrefix, $helixResultsContainerUri, $helixResultsContainerRsas)
+$testResultParser.ConvertWttLogToXUnitLog($WttInputPath, $WttSingleRerunInputPath, $WttMultipleRerunInputPath, $XUnitOutputPath, $rerunPassesRequiredToAvoidFailure)

build/Helix/EnsureMachineState.ps1

@@ -0,0 +1,112 @@
+$scriptDirectory = $script:MyInvocation.MyCommand.Path | Split-Path -Parent
+
+# List all processes to aid debugging:
+Write-Host "All processes running:"
+Get-Process
+
+tasklist /svc
+
+# Add this test directory as an exclusion for Windows Defender
+Write-Host "Add $scriptDirectory as Exclusion Path"
+Add-MpPreference -ExclusionPath $scriptDirectory
+Write-Host "Add $($env:HELIX_CORRELATION_PAYLOAD) as Exclusion Path"
+Add-MpPreference -ExclusionPath $env:HELIX_CORRELATION_PAYLOAD
+Get-MpPreference
+Get-MpComputerStatus
+
+
+# Minimize all windows:
+$shell = New-Object -ComObject "Shell.Application"
+$shell.minimizeall()
+
+# Kill any instances of Windows Security Alert:
+$windowTitleToMatch = "*Windows Security Alert*"
+$procs = Get-Process | Where {$_.MainWindowTitle -like "*Windows Security Alert*"}
+foreach ($proc in $procs)
+{
+    Write-Host "Found process with '$windowTitleToMatch' title: $proc"
+    $proc.Kill();
+}
+
+# Kill processes by name that are known to interfere with our tests:
+$processNamesToStop = @("Microsoft.Photos", "WinStore.App", "SkypeApp", "SkypeBackgroundHost", "OneDriveSetup", "OneDrive")
+foreach($procName in $processNamesToStop)
+{
+    Write-Host "Attempting to kill $procName if it is running"
+    Stop-Process -ProcessName $procName -Verbose -ErrorAction Ignore   
+}
+Write-Host "All processes running after attempting to kill unwanted processes:"
+Get-Process
+
+tasklist /svc
+
+$platform = $env:testbuildplatform
+if(!$platform)
+{
+    $platform = "x86"
+}
+
+function UninstallApps {
+    Param([string[]]$appsToUninstall)
+
+    foreach($pkgName in $appsToUninstall)
+    {
+        foreach($pkg in (Get-AppxPackage $pkgName).PackageFullName) 
+        {
+            Write-Output "Removing: $pkg" 
+            Remove-AppxPackage $pkg
+        } 
+    }
+}
+
+function UninstallTestApps {
+    Param([string[]]$appsToUninstall)
+
+    foreach($pkgName in $appsToUninstall)
+    {
+        foreach($pkg in (Get-AppxPackage $pkgName).PackageFullName) 
+        {
+            Write-Output "Removing: $pkg" 
+            Remove-AppxPackage $pkg
+        }
+
+        # Sometimes an app can get into a state where it is no longer returned by Get-AppxPackage, but it is still present
+        # which prevents other versions of the app from being installed.
+        # To handle this, we can directly call Remove-AppxPackage against the full name of the package. However, without
+        # Get-AppxPackage to find the PackageFullName, we just have to manually construct the name.
+        $packageFullName = "$($pkgName)_1.0.0.0_$($platform)__8wekyb3d8bbwe" 
+        Write-Host "Removing $packageFullName if installed"
+        Remove-AppPackage $packageFullName -ErrorVariable appxerror -ErrorAction SilentlyContinue 
+        if($appxerror)
+        {
+            foreach($error in $appxerror)
+            {
+                # In most cases, Remove-AppPackage will fail due to the package not being found. Don't treat this as an error.
+                if(!($error.Exception.Message -match "0x80073CF1"))
+                {
+                    Write-Error $error
+                }
+            }
+        }
+        else
+        {
+            Write-Host "Successfully removed $packageFullName"
+        }
+    }
+}
+
+Write-Host "Uninstall AppX packages that are known to cause issues with our tests"
+UninstallApps("*Skype*", "*Windows.Photos*")
+
+Write-Host "Uninstall any of our test apps that may have been left over from previous test runs"
+UninstallTestApps("NugetPackageTestApp", "NugetPackageTestAppCX", "IXMPTestApp", "MUXControlsTestApp")
+
+Write-Host "Uninstall MUX Framework package that may have been left over from previous test runs"
+# We don't want to uninstall all versions of the MUX Framework package, as there may be other apps preinstalled on the system 
+# that depend on it. We only uninstall the Framework package that corresponds to the version of MUX that we are testing.
+[xml]$versionData = (Get-Content "version.props")
+$versionMajor = $versionData.GetElementsByTagName("MUXVersionMajor").'#text'
+$versionMinor = $versionData.GetElementsByTagName("MUXVersionMinor").'#text'
+UninstallApps("Microsoft.UI.Xaml.$versionMajor.$versionMinor")
+
+Get-Process

build/Helix/GenerateTestProjFile.ps1

@@ -0,0 +1,336 @@
+[CmdLetBinding()]
+Param(
+    [Parameter(Mandatory = $true)] 
+    [string]$TestFile,
+
+    [Parameter(Mandatory = $true)] 
+    [string]$OutputProjFile,
+
+    [Parameter(Mandatory = $true)] 
+    [string]$JobTestSuiteName,
+
+    [Parameter(Mandatory = $true)] 
+    [string]$TaefPath,
+
+    [string]$TaefQuery
+)
+
+Class TestCollection
+{
+    [string]$Name
+    [string]$SetupMethodName
+    [string]$TeardownMethodName
+    [System.Collections.Generic.Dictionary[string, string]]$Properties
+
+    TestCollection()
+    {
+        if ($this.GetType() -eq [TestCollection])
+        {
+            throw "This class should never be instantiated directly; it should only be derived from."
+        }
+    }
+
+    TestCollection([string]$name)
+    {
+        $this.Init($name)
+    }
+
+    hidden Init([string]$name)
+    {
+        $this.Name = $name
+        $this.Properties = @{}
+    }
+}
+
+Class Test : TestCollection 
+{
+    Test([string]$name)
+    {
+        $this.Init($name)
+    }
+}
+
+Class TestClass : TestCollection
+{
+    [System.Collections.Generic.List[Test]]$Tests
+
+    TestClass([string]$name)
+    {
+        $this.Init($name)
+        $this.Tests = @{}
+    }
+}
+
+Class TestModule : TestCollection
+{
+    [System.Collections.Generic.List[TestClass]]$TestClasses
+
+    TestModule([string]$name)
+    {
+        $this.Init($name)
+        $this.TestClasses = @{}
+    }
+}
+
+function Parse-TestInfo([string]$taefOutput)
+{
+    enum LineType
+    {
+        None
+        TestModule
+        TestClass
+        Test
+        Setup
+        Teardown
+        Property
+    }
+        
+    [string]$testModuleIndentation = "        "
+    [string]$testClassIndentation = "            "
+    [string]$testIndentation = "                "
+    [string]$setupBeginning = "Setup: "
+    [string]$teardownBeginning = "Teardown: "
+    [string]$propertyBeginning = "Property["
+
+    function Get-LineType([string]$line)
+    {
+        if ($line.Contains($setupBeginning))
+        {
+            return [LineType]::Setup;
+        }
+        elseif ($line.Contains($teardownBeginning))
+        {
+            return [LineType]::Teardown;
+        }
+        elseif ($line.Contains($propertyBeginning))
+        {
+            return [LineType]::Property;
+        }
+        elseif ($line.StartsWith($testModuleIndentation) -and -not $line.StartsWith("$testModuleIndentation "))
+        {
+            return [LineType]::TestModule;
+        }
+        elseif ($line.StartsWith($testClassIndentation) -and -not $line.StartsWith("$testClassIndentation "))
+        {
+            return [LineType]::TestClass;
+        }
+        elseif ($line.StartsWith($testIndentation) -and -not $line.StartsWith("$testIndentation "))
+        {
+            return [LineType]::Test;
+        }
+        else
+        {
+            return [LineType]::None;
+        }
+    }
+
+    [string[]]$lines = $taefOutput.Split(@([Environment]::NewLine, "`n"), [StringSplitOptions]::RemoveEmptyEntries)
+    [System.Collections.Generic.List[TestModule]]$testModules = @()
+
+    [TestModule]$currentTestModule = $null
+    [TestClass]$currentTestClass = $null
+    [Test]$currentTest = $null
+
+    [TestCollection]$lastTestCollection = $null
+
+    foreach ($rawLine in $lines)
+    {
+        [LineType]$lineType = (Get-LineType $rawLine)
+
+        # We don't need the whitespace around the line anymore, so we'll discard it to make things easier.
+        [string]$line = $rawLine.Trim()
+
+        if ($lineType -eq [LineType]::TestModule)
+        {
+            if ($currentTest -ne $null -and $currentTestClass -ne $null)
+            {
+                $currentTestClass.Tests.Add($currentTest)
+            }
+
+            if ($currentTestClass -ne $null -and $currentTestModule -ne $null)
+            {
+                $currentTestModule.TestClasses.Add($currentTestClass)
+            }
+
+            if ($currentTestModule -ne $null)
+            {
+                $testModules.Add($currentTestModule)
+            }
+
+            $currentTestModule = [TestModule]::new($line)
+            $currentTestClass = $null
+            $currentTest = $null
+            $lastTestCollection = $currentTestModule
+        }
+        elseif ($lineType -eq [LineType]::TestClass)
+        {
+            if ($currentTest -ne $null -and $currentTestClass -ne $null)
+            {
+                $currentTestClass.Tests.Add($currentTest)
+            }
+
+            if ($currentTestClass -ne $null -and $currentTestModule -ne $null)
+            {
+                $currentTestModule.TestClasses.Add($currentTestClass)
+            }
+
+            $currentTestClass = [TestClass]::new($line)
+            $currentTest = $null
+            $lastTestCollection = $currentTestClass
+        }
+        elseif ($lineType -eq [LineType]::Test)
+        {
+            if ($currentTest -ne $null -and $currentTestClass -ne $null)
+            {
+                $currentTestClass.Tests.Add($currentTest)
+            }
+
+            $currentTest = [Test]::new($line)
+            $lastTestCollection = $currentTest
+        }
+        elseif ($lineType -eq [LineType]::Setup)
+        {
+            if ($lastTestCollection -ne $null)
+            {
+                $lastTestCollection.SetupMethodName = $line.Replace($setupBeginning, "")
+            }
+        }
+        elseif ($lineType -eq [LineType]::Teardown)
+        {
+            if ($lastTestCollection -ne $null)
+            {
+                $lastTestCollection.TeardownMethodName = $line.Replace($teardownBeginning, "")
+            }
+        }
+        elseif ($lineType -eq [LineType]::Property)
+        {
+            if ($lastTestCollection -ne $null)
+            {
+                foreach ($match in [Regex]::Matches($line, "Property\[(.*)\]\s+=\s+(.*)"))
+                {
+                    [string]$propertyKey = $match.Groups[1].Value;
+                    [string]$propertyValue = $match.Groups[2].Value;
+                    $lastTestCollection.Properties.Add($propertyKey, $propertyValue);
+                }
+            }
+        }
+    }
+
+    if ($currentTest -ne $null -and $currentTestClass -ne $null)
+    {
+        $currentTestClass.Tests.Add($currentTest)
+    }
+
+    if ($currentTestClass -ne $null -and $currentTestModule -ne $null)
+    {
+        $currentTestModule.TestClasses.Add($currentTestClass)
+    }
+
+    if ($currentTestModule -ne $null)
+    {
+        $testModules.Add($currentTestModule)
+    }
+
+    return $testModules
+}
+
+Write-Verbose "TaefQuery = $TaefQuery"
+
+$TaefSelectQuery = ""
+$TaefQueryToAppend = ""
+if($TaefQuery)
+{
+    $TaefSelectQuery = "/select:`"$TaefQuery`""
+    $TaefQueryToAppend = " and $TaefQuery"
+}
+Write-Verbose "TaefSelectQuery = $TaefSelectQuery"
+
+
+$taefExe = "$TaefPath\te.exe"
+[string]$taefOutput = & "$taefExe" /listproperties $TaefSelectQuery $TestFile | Out-String
+
+[System.Collections.Generic.List[TestModule]]$testModules = (Parse-TestInfo $taefOutput)
+
+$projFileContent = @"
+<Project>
+  <ItemGroup>
+"@
+
+foreach ($testModule in $testModules)
+{
+    foreach ($testClass in $testModules.TestClasses)
+    {
+        Write-Host "Generating Helix work item for test class $($testClass.Name)..."
+        [System.Collections.Generic.List[string]]$testSuiteNames = @()
+        
+        $testSuiteExists = $false
+        $suitelessTestExists = $false
+
+        foreach ($test in $testClass.Tests)
+        {
+            # A test method inherits its 'TestSuite' property from its TestClass
+            if (!$test.Properties.ContainsKey("TestSuite") -and $testClass.Properties.ContainsKey("TestSuite"))
+            {
+                $test.Properties["TestSuite"] = $testClass.Properties["TestSuite"]
+            }
+
+            if ($test.Properties.ContainsKey("TestSuite"))
+            {
+                [string]$testSuite = $test.Properties["TestSuite"]
+
+                if (-not $testSuiteNames.Contains($testSuite))
+                {
+                    Write-Host "    Found test suite $testSuite. Generating Helix work item for it as well."
+                    $testSuiteNames.Add($testSuite)
+                }
+
+                $testSuiteExists = $true
+            }
+            else
+            {
+                $suitelessTestExists = $true
+            }
+        }
+        
+        $testClassSelectPattern = "$($testClass.Name).*"
+        if($testClass.Name.Contains("::"))
+        {
+            $testClassSelectPattern = "$($testClass.Name)::*"
+        }
+        $testNameQuery= "(@Name='$testClassSelectPattern')"
+
+        $workItemName = $testClass.Name
+        # Native tests use '::' as a separator, which is not valid for workItem names.
+        $workItemName = $workItemName -replace "::", "-"
+        
+        if ($suitelessTestExists)
+        {
+            $projFileContent += @"
+
+    <HelixWorkItem Include="$($workItemName)" Condition="'`$(TestSuite)'=='$($JobTestSuiteName)'">
+      <Timeout>00:30:00</Timeout>
+      <Command>call %HELIX_CORRELATION_PAYLOAD%\runtests.cmd /select:"(@Name='$($testClass.Name)*'$(if ($testSuiteExists) { "and not @TestSuite='*'" }))$($TaefQueryToAppend)"</Command>
+    </HelixWorkItem>
+"@
+        }
+        
+        foreach ($testSuiteName in $testSuiteNames)
+        {
+            $projFileContent += @"
+
+    <HelixWorkItem Include="$($workItemName)-$testSuiteName" Condition="'`$(TestSuite)'=='$($JobTestSuiteName)'">
+      <Timeout>00:30:00</Timeout>
+      <Command>call %HELIX_CORRELATION_PAYLOAD%\runtests.cmd /select:"(@Name='$($testClass.Name)*' and @TestSuite='$testSuiteName')$($TaefQueryToAppend)"</Command>
+    </HelixWorkItem>
+"@
+        }
+    }
+}
+
+$projFileContent += @"
+
+  </ItemGroup>
+</Project>
+"@
+
+Set-Content $OutputProjFile $projFileContent -NoNewline -Encoding UTF8

build/Helix/HelixTestHelpers.cs

@@ -0,0 +1,669 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Runtime.Serialization;
+using System.Runtime.Serialization.Json;
+using System.Text;
+using System.Xml.Linq;
+
+namespace HelixTestHelpers
+{
+    public class TestResult
+    {
+        public TestResult()
+        {
+            Screenshots = new List<string>();
+            RerunResults = new List<TestResult>();
+        }
+
+        public string Name { get; set; }
+        public string SourceWttFile { get; set; }
+        public bool Passed { get; set; }
+        public bool CleanupPassed { get; set; }
+        public TimeSpan ExecutionTime { get; set; }
+        public string Details { get; set; }
+
+        public List<string> Screenshots { get; private set; }
+        public List<TestResult> RerunResults { get; private set; }
+
+        // Returns true if the test pass rate is sufficient to avoid being counted as a failure.
+        public bool PassedOrUnreliable(int requiredNumberOfPasses)
+        {
+            if(Passed)
+            {
+                return true;
+            }
+            else
+            {
+                if(RerunResults.Count == 1)
+                {
+                    return RerunResults[0].Passed;
+                }
+                else
+                {
+                    return RerunResults.Where(r => r.Passed).Count() >= requiredNumberOfPasses;
+                }
+            }
+        }
+    }
+    
+    //
+    // Azure DevOps doesn't currently provide a way to directly report sub-results for tests that failed at least once
+    // that were run multiple times.  To get around that limitation, we'll mark the test as "Skip" since
+    // that's the only non-pass/fail result we can return, and will then report the information about the
+    // runs in the "reason" category for the skipped test.  In order to save space, we'll make the following
+    // optimizations for size:
+    //
+    //   1. Serialize as JSON, which is more compact than XML;
+    //   2. Don't serialize values that we don't need;
+    //   3. Store the URL prefix and suffix for the blob storage URL only once instead of
+    //      storing every log and screenshot URL in its entirety; and
+    //   4. Store a list of unique error messages and then index into that instead of
+    //      storing every error message in its entirety.
+    //
+    // #4 is motivated by the fact that if a test fails multiple times, it probably failed for the same reason
+    // each time, in which case we'd just be repeating ourselves if we stored every error message each time.
+    //
+    // TODO (https://github.com/dotnet/arcade/issues/2773): Once we're able to directly report things in a
+    // more granular fashion than just a binary pass/fail result, we should do that.
+    //
+    [DataContract]  
+    internal class JsonSerializableTestResults
+    {  
+        [DataMember]
+        internal string blobPrefix;
+        
+        [DataMember]
+        internal string blobSuffix;
+        
+        [DataMember]
+        internal string[] errors;
+        
+        [DataMember]
+        internal JsonSerializableTestResult[] results;
+    }
+    
+    [DataContract]  
+    internal class JsonSerializableTestResult  
+    {
+        [DataMember]
+        internal string outcome;
+
+        [DataMember]
+        internal int duration;
+        
+        [DataMember(EmitDefaultValue = false)]
+        internal string log;
+        
+        [DataMember(EmitDefaultValue = false)]
+        internal string[] screenshots;
+        
+        [DataMember(EmitDefaultValue = false)]
+        internal int errorIndex;
+    }
+    
+    public class TestPass
+    {
+        public TimeSpan TestPassExecutionTime { get; set; }
+        public List<TestResult> TestResults { get; set; }
+        
+        public static TestPass ParseTestWttFile(string fileName, bool cleanupFailuresAreRegressions, bool truncateTestNames)
+        {
+            using (var stream = File.OpenRead(fileName))
+            {
+                var doc = XDocument.Load(stream);
+                var testResults = new List<TestResult>();
+                var testExecutionTimeMap = new Dictionary<string, List<double>>();
+
+                TestResult currentResult = null;
+                long frequency = 0;
+                long startTime = 0;
+                long stopTime = 0;
+                bool inTestCleanup = false;
+
+                bool shouldLogToTestDetails = false;
+
+                long testPassStartTime = 0;
+                long testPassStopTime = 0;
+
+                Func<XElement, bool> isScopeData = (elt) =>
+                {
+                    return
+                        elt.Element("Data") != null &&
+                        elt.Element("Data").Element("WexContext") != null &&
+                        (
+                            elt.Element("Data").Element("WexContext").Value == "Cleanup" ||
+                            elt.Element("Data").Element("WexContext").Value == "TestScope" ||
+                            elt.Element("Data").Element("WexContext").Value == "TestScope" ||
+                            elt.Element("Data").Element("WexContext").Value == "ClassScope" ||
+                            elt.Element("Data").Element("WexContext").Value == "ModuleScope"
+                        );
+                };
+
+                Func<XElement, bool> isModuleOrClassScopeStart = (elt) =>
+                {
+                    return
+                        elt.Name == "Msg" &&
+                        elt.Element("Data") != null &&
+                        elt.Element("Data").Element("StartGroup") != null &&
+                        elt.Element("Data").Element("WexContext") != null &&
+                            (elt.Element("Data").Element("WexContext").Value == "ClassScope" ||
+                            elt.Element("Data").Element("WexContext").Value == "ModuleScope");
+                };
+
+                Func<XElement, bool> isModuleScopeEnd = (elt) =>
+                {
+                    return
+                        elt.Name == "Msg" &&
+                        elt.Element("Data") != null &&
+                        elt.Element("Data").Element("EndGroup") != null &&
+                        elt.Element("Data").Element("WexContext") != null &&
+                        elt.Element("Data").Element("WexContext").Value == "ModuleScope";
+                };
+
+                Func<XElement, bool> isClassScopeEnd = (elt) =>
+                {
+                    return
+                        elt.Name == "Msg" &&
+                        elt.Element("Data") != null &&
+                        elt.Element("Data").Element("EndGroup") != null &&
+                        elt.Element("Data").Element("WexContext") != null &&
+                        elt.Element("Data").Element("WexContext").Value == "ClassScope";
+                };
+
+                int testsExecuting = 0;
+                foreach (XElement element in doc.Root.Elements())
+                {
+                    // Capturing the frequency data to record accurate
+                    // timing data.
+                    if (element.Name == "RTI")
+                    {
+                        frequency = Int64.Parse(element.Attribute("Frequency").Value);
+                    }
+
+                    // It's possible for a test to launch another test. If that happens, we won't modify the
+                    // current result. Instead, we'll continue operating like normal and expect that we get two
+                    // EndTests nodes before our next StartTests. We'll check that we've actually got a stop time
+                    // before creating a new result. This will result in the two results being squashed
+                    // into one result of the outer test that ran the inner one.
+                    if (element.Name == "StartTest")
+                    {
+                        testsExecuting++;
+                        if (testsExecuting == 1)
+                        {
+                            string testName = element.Attribute("Title").Value;
+                            
+                            if (truncateTestNames)
+                            {
+                                const string xamlNativePrefix = "Windows::UI::Xaml::Tests::";
+                                const string xamlManagedPrefix = "Windows.UI.Xaml.Tests.";
+                                if (testName.StartsWith(xamlNativePrefix))
+                                {
+                                    testName = testName.Substring(xamlNativePrefix.Length);
+                                }
+                                else if (testName.StartsWith(xamlManagedPrefix))
+                                {
+                                    testName = testName.Substring(xamlManagedPrefix.Length);
+                                }
+                            }
+
+                            currentResult = new TestResult() { Name = testName, SourceWttFile = fileName, Passed = true, CleanupPassed = true };
+                            testResults.Add(currentResult);
+                            startTime = Int64.Parse(element.Descendants("WexTraceInfo").First().Attribute("TimeStamp").Value);
+                            inTestCleanup = false;
+                            shouldLogToTestDetails = true;
+                            stopTime = 0;
+                        }
+                    }
+                    else if (currentResult != null && element.Name == "EndTest")
+                    {
+                        testsExecuting--;
+
+                        // If any inner test fails, we'll still fail the outer
+                        currentResult.Passed &= element.Attribute("Result").Value == "Pass";
+
+                        // Only gather execution data if this is the outer test we ran initially
+                        if (testsExecuting == 0)
+                        {
+                            stopTime = Int64.Parse(element.Descendants("WexTraceInfo").First().Attribute("TimeStamp").Value);
+                            if (!testExecutionTimeMap.Keys.Contains(currentResult.Name))
+                                testExecutionTimeMap[currentResult.Name] = new List<double>();
+                            testExecutionTimeMap[currentResult.Name].Add((double)(stopTime - startTime) / frequency);
+                            currentResult.ExecutionTime = TimeSpan.FromSeconds(testExecutionTimeMap[currentResult.Name].Average());
+
+                            startTime = 0;
+                            inTestCleanup = true;
+                        }
+                    }
+                    else if (currentResult != null &&
+                            (isModuleOrClassScopeStart(element) || isModuleScopeEnd(element) || isClassScopeEnd(element)))
+                    {
+                        shouldLogToTestDetails = false;
+                        inTestCleanup = false;
+                    }
+
+                    // Log-appending methods.
+                    if (currentResult != null && element.Name == "Error")
+                    {
+                        if (shouldLogToTestDetails)
+                        {
+                            currentResult.Details += "\r\n[Error]: " + element.Attribute("UserText").Value;
+                            if (element.Attribute("File") != null && element.Attribute("File").Value != "")
+                            {
+                                currentResult.Details += (" [File " + element.Attribute("File").Value);
+                                if (element.Attribute("Line") != null)
+                                    currentResult.Details += " Line: " + element.Attribute("Line").Value;
+                                currentResult.Details += "]";
+                            }
+                        }
+
+
+                        // The test cleanup errors will often come after the test claimed to have
+                        // 'passed'. We treat them as errors as well. 
+                        if (inTestCleanup)
+                        {
+                            currentResult.CleanupPassed = false;
+                            currentResult.Passed = false;
+                            // In stress mode runs, this test will run n times before cleanup is run. If the cleanup
+                            // fails, we want to fail every test.
+                            if (cleanupFailuresAreRegressions)
+                            {
+                                foreach (var result in testResults.Where(res => res.Name == currentResult.Name))
+                                {
+                                    result.Passed = false;
+                                    result.CleanupPassed = false;
+                                }
+                            }
+                        }
+                    }
+
+                    if (currentResult != null && element.Name == "Warn")
+                    {
+                        if (shouldLogToTestDetails)
+                        {
+                            currentResult.Details += "\r\n[Warn]: " + element.Attribute("UserText").Value;
+                        }
+
+                        if (element.Attribute("File") != null && element.Attribute("File").Value != "")
+                        {
+                            currentResult.Details += (" [File " + element.Attribute("File").Value);
+                            if (element.Attribute("Line") != null)
+                                currentResult.Details += " Line: " + element.Attribute("Line").Value;
+                            currentResult.Details += "]";
+                        }
+                    }
+
+                    if (currentResult != null && element.Name == "Msg")
+                    {
+                        var dataElement = element.Element("Data");
+                        if (dataElement != null)
+                        {
+                            var supportingInfo = dataElement.Element("SupportingInfo");
+                            if (supportingInfo != null)
+                            {
+                                var screenshots = supportingInfo.Elements("Item")
+                                    .Where(item => GetAttributeValue(item, "Name") == "Screenshot")
+                                    .Select(item => GetAttributeValue(item, "Value"));
+
+                                foreach(var screenshot in screenshots)
+                                {
+                                    string fileNameSuffix = string.Empty;
+                                    
+                                    if (fileName.Contains("_rerun_multiple"))
+                                    {
+                                        fileNameSuffix = "_rerun_multiple";
+                                    }
+                                    else if (fileName.Contains("_rerun"))
+                                    {
+                                        fileNameSuffix = "_rerun";
+                                    }
+                                    
+                                    currentResult.Screenshots.Add(screenshot.Replace(".jpg", fileNameSuffix + ".jpg"));
+                                }
+                            }
+                        }
+                    }
+                }
+
+                testPassStartTime = Int64.Parse(doc.Root.Descendants("WexTraceInfo").First().Attribute("TimeStamp").Value);
+                testPassStopTime = Int64.Parse(doc.Root.Descendants("WexTraceInfo").Last().Attribute("TimeStamp").Value);
+
+                var testPassTime = TimeSpan.FromSeconds((double)(testPassStopTime - testPassStartTime) / frequency);
+                
+                foreach (TestResult testResult in testResults)
+                {
+                    if (testResult.Details != null)
+                    {
+                        testResult.Details = testResult.Details.Trim();
+                    }
+                }
+
+                var testpass = new TestPass
+                {
+                    TestPassExecutionTime = testPassTime,
+                    TestResults = testResults
+                };
+
+                return testpass;
+            }
+        }
+        
+        public static TestPass ParseTestWttFileWithReruns(string fileName, string singleRerunFileName, string multipleRerunFileName, bool cleanupFailuresAreRegressions, bool truncateTestNames)
+        {
+            TestPass testPass = ParseTestWttFile(fileName, cleanupFailuresAreRegressions, truncateTestNames);
+            TestPass singleRerunTestPass = File.Exists(singleRerunFileName) ? ParseTestWttFile(singleRerunFileName, cleanupFailuresAreRegressions, truncateTestNames) : null;
+            TestPass multipleRerunTestPass = File.Exists(multipleRerunFileName) ? ParseTestWttFile(multipleRerunFileName, cleanupFailuresAreRegressions, truncateTestNames) : null;
+            
+            List<TestResult> rerunTestResults = new List<TestResult>();
+
+            if (singleRerunTestPass != null)
+            {
+                rerunTestResults.AddRange(singleRerunTestPass.TestResults);
+            }
+
+            if (multipleRerunTestPass != null)
+            {
+                rerunTestResults.AddRange(multipleRerunTestPass.TestResults);
+            }
+
+            // For each failed test result, we'll check to see whether the test passed at least once upon rerun.
+            // If so, we'll set PassedOnRerun to true to flag the fact that this is an unreliable test
+            // rather than a genuine test failure.
+            foreach (TestResult failedTestResult in testPass.TestResults.Where(r => !r.Passed))
+            {
+                failedTestResult.RerunResults.AddRange(rerunTestResults.Where(r => r.Name == failedTestResult.Name));
+            }
+
+            return testPass;
+        }
+
+        private static string GetAttributeValue(XElement element, string attributeName)
+        {
+            if(element.Attribute(attributeName) != null)
+            {
+                return element.Attribute(attributeName).Value;
+            }
+
+            return null;
+        }
+    }
+
+    public static class FailedTestDetector
+    {
+        public static void OutputFailedTestQuery(string wttInputPath)
+        {
+            var testPass = TestPass.ParseTestWttFile(wttInputPath, cleanupFailuresAreRegressions: true, truncateTestNames: false);
+            
+            List<string> failedTestNames = new List<string>();
+            
+            foreach (var result in testPass.TestResults)
+            {
+                if (!result.Passed)
+                {
+                    failedTestNames.Add(result.Name);
+                }
+            }
+            
+            if (failedTestNames.Count > 0)
+            {
+                string failedTestSelectQuery = "(@Name='";
+                
+                for (int i = 0; i < failedTestNames.Count; i++)
+                {
+                    failedTestSelectQuery += failedTestNames[i];
+                    
+                    if (i < failedTestNames.Count - 1)
+                    {
+                        failedTestSelectQuery += "' or @Name='";
+                    }
+                }
+                
+                failedTestSelectQuery += "')";
+            
+                Console.WriteLine(failedTestSelectQuery);
+            }
+            else
+            {
+                Console.WriteLine("");
+            }
+        }
+    }
+
+    public class TestResultParser
+    {
+        private string testNamePrefix;
+        private string helixResultsContainerUri;
+        private string helixResultsContainerRsas;
+    
+        public TestResultParser(string testNamePrefix, string helixResultsContainerUri, string helixResultsContainerRsas)
+        {
+            this.testNamePrefix = testNamePrefix;
+            this.helixResultsContainerUri = helixResultsContainerUri;
+            this.helixResultsContainerRsas = helixResultsContainerRsas;
+        }
+
+        public Dictionary<string, string> GetSubResultsJsonByMethodName(string wttInputPath, string wttSingleRerunInputPath, string wttMultipleRerunInputPath)
+        {
+            Dictionary<string, string> subResultsJsonByMethod = new Dictionary<string, string>();
+            TestPass testPass = TestPass.ParseTestWttFileWithReruns(wttInputPath, wttSingleRerunInputPath, wttMultipleRerunInputPath, cleanupFailuresAreRegressions: true, truncateTestNames: false);
+            
+            foreach (var result in testPass.TestResults)
+            {
+                var methodName = result.Name.Substring(result.Name.LastIndexOf('.') + 1);
+
+                if (!result.Passed)
+                {
+                    // If a test failed, we'll have rerun it multiple times.  We'll record the results of each run
+                    // formatted as JSON.
+                    JsonSerializableTestResults serializableResults = new JsonSerializableTestResults();
+                    serializableResults.blobPrefix = helixResultsContainerUri;
+                    serializableResults.blobSuffix = helixResultsContainerRsas;
+
+                    List<string> errorList = new List<string>();
+                    errorList.Add(result.Details);
+
+                    foreach (TestResult rerunResult in result.RerunResults)
+                    {
+                        errorList.Add(rerunResult.Details);
+                    }
+
+                    serializableResults.errors = errorList.Distinct().Where(s => s != null).ToArray();
+
+                    var reason = new XElement("reason");
+                    List<JsonSerializableTestResult> serializableResultList = new List<JsonSerializableTestResult>();
+                    serializableResultList.Add(ConvertToSerializableResult(result, serializableResults.errors));
+
+                    foreach (TestResult rerunResult in result.RerunResults)
+                    {
+                        serializableResultList.Add(ConvertToSerializableResult(rerunResult, serializableResults.errors));
+                    }
+
+                    serializableResults.results = serializableResultList.ToArray();
+
+                    using (MemoryStream stream = new MemoryStream())
+                    {
+                        DataContractJsonSerializer serializer = new DataContractJsonSerializer(typeof(JsonSerializableTestResults));
+                        serializer.WriteObject(stream, serializableResults);
+                        stream.Position = 0;
+
+                        using (StreamReader streamReader = new StreamReader(stream))
+                        {
+                            subResultsJsonByMethod.Add(methodName, streamReader.ReadToEnd());
+                        }
+                    }
+                }
+            }
+
+            return subResultsJsonByMethod;
+        }
+
+        public void ConvertWttLogToXUnitLog(string wttInputPath, string wttSingleRerunInputPath, string wttMultipleRerunInputPath, string xunitOutputPath, int requiredPassRateThreshold)
+        {
+            TestPass testPass = TestPass.ParseTestWttFileWithReruns(wttInputPath, wttSingleRerunInputPath, wttMultipleRerunInputPath, cleanupFailuresAreRegressions: true, truncateTestNames: false);
+            var results = testPass.TestResults;
+
+            int resultCount = results.Count;
+            int passedCount = results.Where(r => r.Passed).Count();
+            
+            // Since we re-run tests on failure, we'll mark every test that failed at least once as "skipped" rather than "failed".
+            // If the test failed sufficiently often enough for it to count as a failed test (determined by a property on the
+            // Azure DevOps job), we'll later mark it as failed during test results processing.
+
+            int failedCount = results.Where(r => !r.PassedOrUnreliable(requiredPassRateThreshold)).Count();
+            int skippedCount = results.Where(r => !r.Passed && r.PassedOrUnreliable(requiredPassRateThreshold)).Count();
+
+            var root = new XElement("assemblies");
+
+            var assembly = new XElement("assembly");
+            assembly.SetAttributeValue("name", "MUXControls.Test.dll");
+            assembly.SetAttributeValue("test-framework", "TAEF");
+            assembly.SetAttributeValue("run-date", DateTime.Now.ToString("yyyy-MM-dd"));
+
+            // This doesn't need to be completely accurate since it's not exposed anywhere.
+            // If we need accurate an start time we can probably calculate it from the te.wtl file, but for
+            // now this is fine.
+            assembly.SetAttributeValue("run-time", (DateTime.Now - testPass.TestPassExecutionTime).ToString("hh:mm:ss"));
+            
+            assembly.SetAttributeValue("total", resultCount);
+            assembly.SetAttributeValue("passed", passedCount);
+            assembly.SetAttributeValue("failed", failedCount);
+            assembly.SetAttributeValue("skipped", skippedCount);
+            
+            assembly.SetAttributeValue("time", (int)testPass.TestPassExecutionTime.TotalSeconds);
+            assembly.SetAttributeValue("errors", 0);
+            root.Add(assembly);
+
+            var collection = new XElement("collection");
+            collection.SetAttributeValue("total", resultCount);
+            collection.SetAttributeValue("passed", passedCount);
+            collection.SetAttributeValue("failed", failedCount);
+            collection.SetAttributeValue("skipped", skippedCount);
+            collection.SetAttributeValue("name", "Test collection");
+            collection.SetAttributeValue("time", (int)testPass.TestPassExecutionTime.TotalSeconds);
+            assembly.Add(collection);
+
+            foreach (var result in results)
+            {
+                var test = new XElement("test");
+                test.SetAttributeValue("name", testNamePrefix + "." + result.Name);
+
+                var className = GetTestClassName(result.Name);
+                var methodName = GetTestMethodName(result.Name);
+                test.SetAttributeValue("type", className);
+                test.SetAttributeValue("method", methodName);
+
+                test.SetAttributeValue("time", result.ExecutionTime.TotalSeconds);
+                
+                string resultString = string.Empty;
+                
+                if (result.Passed)
+                {
+                    resultString = "Pass";
+                }
+                else if(result.PassedOrUnreliable(requiredPassRateThreshold))
+                {
+                    resultString = "Skip";
+                }
+                else
+                {
+                    resultString = "Fail";
+                }
+
+                
+                test.SetAttributeValue("result", resultString);
+
+                if (!result.Passed)
+                {
+                    // If a test failed, we'll have rerun it multiple times.
+                    // We'll save the subresults to a JSON text file that we'll upload to the helix results container -
+                    // this allows it to be as long as we want, whereas the reason field in Azure DevOps has a 4000 character limit.
+                    string subResultsFileName = methodName + "_subresults.json";
+                    string subResultsFilePath = Path.Combine(Path.GetDirectoryName(wttInputPath), subResultsFileName);
+					
+                    if (result.PassedOrUnreliable(requiredPassRateThreshold))
+                    {
+                        var reason = new XElement("reason");
+                        reason.Add(new XCData(GetUploadedFileUrl(subResultsFileName, helixResultsContainerUri, helixResultsContainerRsas)));
+                        test.Add(reason);
+                    }
+                    else
+                    {
+                        var failure = new XElement("failure");
+                        var message = new XElement("message");
+						message.Add(new XCData(GetUploadedFileUrl(subResultsFileName, helixResultsContainerUri, helixResultsContainerRsas)));
+                        failure.Add(message);
+                        test.Add(failure);
+                    }
+                }
+                collection.Add(test);
+            }
+
+            File.WriteAllText(xunitOutputPath, root.ToString());
+        }
+        
+        private JsonSerializableTestResult ConvertToSerializableResult(TestResult rerunResult, string[] uniqueErrors)
+        {
+            var serializableResult = new JsonSerializableTestResult();
+            
+            serializableResult.outcome = rerunResult.Passed ? "Passed" : "Failed";
+            serializableResult.duration = (int)Math.Round(rerunResult.ExecutionTime.TotalMilliseconds);
+            
+            if (!rerunResult.Passed)
+            {
+                serializableResult.log = Path.GetFileName(rerunResult.SourceWttFile);
+                
+                if (rerunResult.Screenshots.Any())
+                {
+                    List<string> screenshots = new List<string>();
+                    
+                    foreach (var screenshot in rerunResult.Screenshots)
+                    {
+                        screenshots.Add(Path.GetFileName(screenshot));
+                    }
+                    
+                    serializableResult.screenshots = screenshots.ToArray();
+                }
+                
+                // To conserve space, we'll log the index of the error to index in a list of unique errors rather than
+                // jotting down every single error in its entirety. We'll add one to the result so we can avoid
+                // serializing this property when it has the default value of 0.
+                serializableResult.errorIndex = Array.IndexOf(uniqueErrors, rerunResult.Details) + 1;
+            }
+            
+            return serializableResult;
+        }
+
+        private string GetUploadedFileUrl(string filePath, string helixResultsContainerUri, string helixResultsContainerRsas)
+        {
+            var filename = Path.GetFileName(filePath);
+            return string.Format("{0}/{1}{2}", helixResultsContainerUri, filename, helixResultsContainerRsas);
+        }
+		
+		private string GetTestNameSeparator(string testname)
+        {
+            var separatorString = ".";
+            if (!testname.Contains(separatorString))
+            {
+                separatorString = "::";
+            }
+            return separatorString;
+        }
+
+        private string GetTestMethodName(string fullyQualifiedName)
+        {
+            var separatorString = GetTestNameSeparator(fullyQualifiedName);
+            var methodName = fullyQualifiedName.Substring(fullyQualifiedName.LastIndexOf(separatorString) + separatorString.Length);
+
+            return methodName;
+        }
+
+        private string GetTestClassName(string fullyQualifiedName)
+        {
+            var separatorString = GetTestNameSeparator(fullyQualifiedName);
+            var className = fullyQualifiedName.Substring(0, fullyQualifiedName.LastIndexOf(separatorString));
+
+            return className;
+        }
+    }
+}

build/Helix/InstallTestAppDependencies.ps1

@@ -0,0 +1,12 @@
+# Displaying progress is unnecessary and is just distracting.
+$ProgressPreference = "SilentlyContinue"
+
+$dependencyFiles = Get-ChildItem -Filter "*Microsoft.VCLibs.*.appx"
+
+foreach ($file in $dependencyFiles)
+{
+    Write-Host "Adding dependency $($file)..."
+
+    Add-AppxPackage $file
+    
+}

build/Helix/OutputFailedTestQuery.ps1

@@ -0,0 +1,8 @@
+Param(
+    [Parameter(Mandatory = $true)] 
+    [string]$WttInputPath
+)
+
+Add-Type -Language CSharp -ReferencedAssemblies System.Xml,System.Xml.Linq,System.Runtime.Serialization,System.Runtime.Serialization.Json (Get-Content $PSScriptRoot\HelixTestHelpers.cs -Raw)
+
+[HelixTestHelpers.FailedTestDetector]::OutputFailedTestQuery($WttInputPath)

build/Helix/OutputSubResultsJsonFiles.ps1

@@ -0,0 +1,32 @@
+Param(
+    [Parameter(Mandatory = $true)] 
+    [string]$WttInputPath,
+
+    [Parameter(Mandatory = $true)] 
+    [string]$WttSingleRerunInputPath,
+
+    [Parameter(Mandatory = $true)] 
+    [string]$WttMultipleRerunInputPath,
+
+    [Parameter(Mandatory = $true)] 
+    [string]$TestNamePrefix
+)
+
+# Ideally these would be passed as parameters to the script. However ps makes it difficult to deal with string literals containing '&', so we just 
+# read the values directly from the environment variables
+$helixResultsContainerUri = $Env:HELIX_RESULTS_CONTAINER_URI
+$helixResultsContainerRsas = $Env:HELIX_RESULTS_CONTAINER_RSAS
+
+Add-Type -Language CSharp -ReferencedAssemblies System.Xml,System.Xml.Linq,System.Runtime.Serialization,System.Runtime.Serialization.Json (Get-Content $PSScriptRoot\HelixTestHelpers.cs -Raw)
+
+$testResultParser = [HelixTestHelpers.TestResultParser]::new($TestNamePrefix, $helixResultsContainerUri, $helixResultsContainerRsas)
+[System.Collections.Generic.Dictionary[string, string]]$subResultsJsonByMethodName = $testResultParser.GetSubResultsJsonByMethodName($WttInputPath, $WttSingleRerunInputPath, $WttMultipleRerunInputPath)
+
+$subResultsJsonDirectory = [System.IO.Path]::GetDirectoryName($WttInputPath)
+
+foreach ($methodName in $subResultsJsonByMethodName.Keys)
+{
+    $subResultsJson = $subResultsJsonByMethodName[$methodName]
+    $subResultsJsonPath = [System.IO.Path]::Combine($subResultsJsonDirectory, $methodName + "_subresults.json")
+    Out-File $subResultsJsonPath -Encoding utf8 -InputObject $subResultsJson
+}

build/Helix/OutputTestResults.ps1

@@ -0,0 +1,131 @@
+Param(
+    [Parameter(Mandatory = $true)] 
+    [int]$MinimumExpectedTestsExecutedCount,
+
+    [string]$AccessToken = $env:SYSTEM_ACCESSTOKEN,
+    [string]$CollectionUri = $env:SYSTEM_COLLECTIONURI,
+    [string]$TeamProject = $env:SYSTEM_TEAMPROJECT,
+    [string]$BuildUri = $env:BUILD_BUILDURI,
+    [bool]$CheckJobAttempt
+)
+
+$azureDevOpsRestApiHeaders = @{
+    "Accept"="application/json"
+    "Authorization"="Basic $([System.Convert]::ToBase64String([System.Text.ASCIIEncoding]::ASCII.GetBytes(":$AccessToken")))"
+}
+
+. "$PSScriptRoot/AzurePipelinesHelperScripts.ps1"
+
+Write-Host "Checking test results..."
+
+$queryUri = GetQueryTestRunsUri -CollectionUri $CollectionUri -TeamProject $TeamProject -BuildUri $BuildUri -IncludeRunDetails
+Write-Host "queryUri = $queryUri"
+
+$testRuns = Invoke-RestMethod -Uri $queryUri -Method Get -Headers $azureDevOpsRestApiHeaders
+[System.Collections.Generic.List[string]]$failingTests = @()
+[System.Collections.Generic.List[string]]$unreliableTests = @()
+[System.Collections.Generic.List[string]]$unexpectedResultTest = @()
+
+[System.Collections.Generic.List[string]]$namesOfProcessedTestRuns = @()
+$totalTestsExecutedCount = 0
+
+# We assume that we only have one testRun with a given name that we care about
+# We only process the last testRun with a given name (based on completedDate)
+# The name of a testRun is set to the Helix queue that it was run on (e.g. windows.10.amd64.client19h1.xaml)
+# If we have multiple test runs on the same queue that we care about, we will need to re-visit this logic
+foreach ($testRun in ($testRuns.value | Sort-Object -Property "completedDate" -Descending))
+{
+    if ($CheckJobAttempt)
+    {
+        if ($namesOfProcessedTestRuns -contains $testRun.name)
+        {
+            Write-Host "Skipping test run '$($testRun.name)', since we have already processed a test run of that name."
+            continue
+        }
+    }
+    
+    Write-Host "Processing results from test run '$($testRun.name)'"
+    $namesOfProcessedTestRuns.Add($testRun.name)
+
+    $totalTestsExecutedCount += $testRun.totalTests
+
+    $testRunResultsUri = "$($testRun.url)/results?api-version=5.0"
+    $testResults = Invoke-RestMethod -Uri "$($testRun.url)/results?api-version=5.0" -Method Get -Headers $azureDevOpsRestApiHeaders
+        
+    foreach ($testResult in $testResults.value)
+    {
+        $shortTestCaseTitle = $testResult.testCaseTitle -replace "[a-zA-Z0-9]+.[a-zA-Z0-9]+.Windows.UI.Xaml.Tests.MUXControls.",""
+
+        if ($testResult.outcome -eq "Failed")
+        {
+            if (-not $failingTests.Contains($shortTestCaseTitle))
+            {
+                $failingTests.Add($shortTestCaseTitle)
+            }
+        }
+        elseif ($testResult.outcome -eq "Warning")
+        {
+            if (-not $unreliableTests.Contains($shortTestCaseTitle))
+            {
+                $unreliableTests.Add($shortTestCaseTitle)
+            }
+        }
+        elseif ($testResult.outcome -ne "Passed")
+        {
+            # We should only see tests with result "Passed", "Failed" or "Warning"
+            if (-not $unexpectedResultTest.Contains($shortTestCaseTitle))
+            {
+                $unexpectedResultTest.Add($shortTestCaseTitle)
+            }
+        }
+    }
+}
+
+if ($unreliableTests.Count -gt 0)
+{
+    Write-Host @"
+##vso[task.logissue type=warning;]Unreliable tests:
+##vso[task.logissue type=warning;]$($unreliableTests -join "$([Environment]::NewLine)##vso[task.logissue type=warning;]")
+
+"@
+}
+
+if ($failingTests.Count -gt 0)
+{
+    Write-Host @"
+##vso[task.logissue type=error;]Failing tests:
+##vso[task.logissue type=error;]$($failingTests -join "$([Environment]::NewLine)##vso[task.logissue type=error;]")
+
+"@
+}
+
+if ($unexpectedResultTest.Count -gt 0)
+{
+    Write-Host @"
+##vso[task.logissue type=error;]Tests with unexpected results:
+##vso[task.logissue type=error;]$($unexpectedResultTest -join "$([Environment]::NewLine)##vso[task.logissue type=error;]")
+
+"@
+}
+
+if($totalTestsExecutedCount -lt $MinimumExpectedTestsExecutedCount)
+{
+    Write-Host "Expected at least $MinimumExpectedTestsExecutedCount tests to be executed."
+    Write-Host "Actual executed test count is: $totalTestsExecutedCount"
+    Write-Host "##vso[task.complete result=Failed;]"
+}
+elseif ($failingTests.Count -gt 0)
+{
+    Write-Host "At least one test failed."
+    Write-Host "##vso[task.complete result=Failed;]"
+}
+elseif ($unreliableTests.Count -gt 0)
+{
+    Write-Host "All tests eventually passed, but some initially failed."
+    Write-Host "##vso[task.complete result=Succeeded;]"
+}
+else
+{
+    Write-Host "All tests passed."
+    Write-Host "##vso[task.complete result=Succeeded;]"
+}

build/Helix/PrepareHelixPayload.ps1

@@ -0,0 +1,54 @@
+[CmdLetBinding()]
+Param(
+    [string]$Platform,
+    [string]$Configuration,
+    [string]$ArtifactName='drop'
+)
+
+$payloadDir = "HelixPayload\$Configuration\$Platform"
+
+$repoDirectory = Join-Path (Split-Path -Parent $script:MyInvocation.MyCommand.Path) "..\..\"
+$nugetPackagesDir = Join-Path (Split-Path -Parent $script:MyInvocation.MyCommand.Path) "packages"
+ 
+# Create the payload directory. Remove it if it already exists.
+If(test-path $payloadDir)
+{
+    Remove-Item $payloadDir -Recurse
+}
+New-Item -ItemType Directory -Force -Path $payloadDir
+
+# Copy files from nuget packages
+Copy-Item "$nugetPackagesDir\microsoft.windows.apps.test.1.0.181203002\lib\netcoreapp2.1\*.dll" $payloadDir
+Copy-Item "$nugetPackagesDir\taef.redist.wlk.10.57.200731005-develop\build\Binaries\$Platform\*" $payloadDir
+Copy-Item "$nugetPackagesDir\taef.redist.wlk.10.57.200731005-develop\build\Binaries\$Platform\CoreClr\*" $payloadDir
+New-Item -ItemType Directory -Force -Path "$payloadDir\.NETCoreApp2.1\"
+Copy-Item "$nugetPackagesDir\runtime.win-$Platform.microsoft.netcore.app.2.1.0\runtimes\win-$Platform\lib\netcoreapp2.1\*" "$payloadDir\.NETCoreApp2.1\"
+Copy-Item "$nugetPackagesDir\runtime.win-$Platform.microsoft.netcore.app.2.1.0\runtimes\win-$Platform\native\*" "$payloadDir\.NETCoreApp2.1\"
+
+function Copy-If-Exists
+{
+    Param($source, $destinationDir)
+
+    if (Test-Path $source)
+    {
+        Write-Host "Copy from '$source' to '$destinationDir'"
+        Copy-Item -Force $source $destinationDir
+    }
+    else
+    {
+        Write-Host "'$source' does not exist."
+    }
+}
+
+# Copy files from the 'drop' artifact dir
+Copy-Item "$repoDirectory\Artifacts\$ArtifactName\$Configuration\$Platform\Test\*" $payloadDir -Recurse
+
+# Copy files from the repo
+New-Item -ItemType Directory -Force -Path "$payloadDir"
+Copy-Item "build\helix\ConvertWttLogToXUnit.ps1" "$payloadDir"
+Copy-Item "build\helix\OutputFailedTestQuery.ps1" "$payloadDir"
+Copy-Item "build\helix\OutputSubResultsJsonFiles.ps1" "$payloadDir"
+Copy-Item "build\helix\HelixTestHelpers.cs" "$payloadDir"
+Copy-Item "build\helix\runtests.cmd" $payloadDir
+Copy-Item "build\helix\InstallTestAppDependencies.ps1" "$payloadDir"
+Copy-Item "build\Helix\EnsureMachineState.ps1" "$payloadDir"

build/Helix/ProcessHelixFiles.ps1

@@ -0,0 +1,112 @@
+Param(
+    [string]$AccessToken = $env:SYSTEM_ACCESSTOKEN,
+    [string]$HelixAccessToken = $env:HelixAccessToken,
+    [string]$CollectionUri = $env:SYSTEM_COLLECTIONURI,
+    [string]$TeamProject = $env:SYSTEM_TEAMPROJECT,
+    [string]$BuildUri = $env:BUILD_BUILDURI,
+    [string]$OutputFolder = "HelixOutput"
+)
+
+$helixLinkFile = "$OutputFolder\LinksToHelixTestFiles.html"
+
+$accessTokenParam = ""
+if($HelixAccessToken)
+{
+    $accessTokenParam = "?access_token=$HelixAccessToken"
+}
+
+function Generate-File-Links
+{
+    Param ([Array[]]$files,[string]$sectionName)
+    if($files.Count -gt 0)
+    {
+        Out-File -FilePath $helixLinkFile -Append -InputObject "<div class=$sectionName>"
+        Out-File -FilePath $helixLinkFile -Append -InputObject "<h4>$sectionName</h4>"
+        Out-File -FilePath $helixLinkFile -Append -InputObject "<ul>"
+        foreach($file in $files)
+        {
+            Out-File -FilePath $helixLinkFile -Append -InputObject "<li><a href=$($file.Link)>$($file.Name)</a></li>"
+        }
+        Out-File -FilePath $helixLinkFile -Append -InputObject "</ul>"
+        Out-File -FilePath $helixLinkFile -Append -InputObject "</div>"
+    }
+}
+
+#Create output directory
+New-Item $OutputFolder -ItemType Directory
+
+$azureDevOpsRestApiHeaders = @{
+    "Accept"="application/json"
+    "Authorization"="Basic $([System.Convert]::ToBase64String([System.Text.ASCIIEncoding]::ASCII.GetBytes(":$AccessToken")))"
+}
+
+. "$PSScriptRoot/AzurePipelinesHelperScripts.ps1"
+
+$queryUri = GetQueryTestRunsUri -CollectionUri $CollectionUri -TeamProject $TeamProject -BuildUri $BuildUri -IncludeRunDetails
+Write-Host "queryUri = $queryUri"
+
+$testRuns = Invoke-RestMethod -Uri $queryUri -Method Get -Headers $azureDevOpsRestApiHeaders
+$webClient = New-Object System.Net.WebClient
+[System.Collections.Generic.List[string]]$workItems = @()
+
+foreach ($testRun in $testRuns.value)
+{
+    $testResults = Invoke-RestMethod -Uri "$($testRun.url)/results?api-version=5.0" -Method Get -Headers $azureDevOpsRestApiHeaders
+    $isTestRunNameShown = $false
+
+    foreach ($testResult in $testResults.value)
+    {
+        if ("comment" -in $testResult)
+        {
+            $info = ConvertFrom-Json $testResult.comment
+            $helixJobId = $info.HelixJobId
+            $helixWorkItemName = $info.HelixWorkItemName
+
+            $workItem = "$helixJobId-$helixWorkItemName"
+
+            if (-not $workItems.Contains($workItem))
+            {
+                $workItems.Add($workItem)
+                $filesQueryUri = "https://helix.dot.net/api/2019-06-17/jobs/$helixJobId/workitems/$helixWorkItemName/files$accessTokenParam"
+                $files = Invoke-RestMethod -Uri $filesQueryUri -Method Get
+
+                $screenShots = $files | where { $_.Name.EndsWith(".jpg") }
+                $dumps = $files | where { $_.Name.EndsWith(".dmp") }
+                $pgcFiles = $files | where { $_.Name.EndsWith(".pgc") }
+                if ($screenShots.Count + $dumps.Count + $pgcFiles.Count -gt 0)
+                {
+                    if(-Not $isTestRunNameShown)
+                    {
+                        Out-File -FilePath $helixLinkFile -Append -InputObject "<h2>$($testRun.name)</h2>"
+                        $isTestRunNameShown = $true
+                    }
+                    Out-File -FilePath $helixLinkFile -Append -InputObject "<h3>$helixWorkItemName</h3>"
+                    Generate-File-Links $screenShots "Screenshots"
+                    Generate-File-Links $dumps "CrashDumps"
+                    Generate-File-Links $pgcFiles "PGC files"
+                    $misc = $files | where { ($screenShots -NotContains $_) -And ($dumps -NotContains $_) -And ($visualTreeVerificationFiles -NotContains $_) -And ($pgcFiles -NotContains $_) }
+                    Generate-File-Links $misc "Misc"
+
+                    foreach($pgcFile in $pgcFiles)
+                    {
+                        $flavorPath = $pgcFile.Name.Split('.')[0]
+                        $archPath = $pgcFile.Name.Split('.')[1]
+                        $fileName = $pgcFile.Name.Remove(0, $flavorPath.length + $archPath.length + 2)
+                        $fullPath = "$OutputFolder\PGO\$flavorPath\$archPath"
+                        $destination = "$fullPath\$fileName"
+
+                        Write-Host "Copying $($pgcFile.Name) to $destination"
+
+                        if (-Not (Test-Path $fullPath))
+                        {
+                            New-Item $fullPath -ItemType Directory
+                        }
+
+                        $link = "$($pgcFile.Link)$accessTokenParam"
+                        $webClient.DownloadFile($link, $destination)
+                    }
+                }
+            }
+        }
+    }
+}

build/Helix/RunTestsInHelix.proj

@@ -0,0 +1,18 @@
+<Project Sdk="Microsoft.DotNet.Helix.Sdk" DefaultTargets="Test">
+  <PropertyGroup>
+    <HelixSource>pr/terminal/$(BUILD_SOURCEBRANCH)/</HelixSource>
+    <EnableXUnitReporter>true</EnableXUnitReporter>
+    <EnableAzurePipelinesReporter>true</EnableAzurePipelinesReporter>
+    <FailOnMissionControlTestFailure>true</FailOnMissionControlTestFailure>
+    <HelixPreCommands>$(HelixPreCommands);set testnameprefix=$(Configuration).$(Platform);set testbuildplatform=$(Platform);set rerunPassesRequiredToAvoidFailure=$(rerunPassesRequiredToAvoidFailure)</HelixPreCommands>
+    <OutputPath>..\..\bin\$(Platform)\$(Configuration)\</OutputPath>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <HelixCorrelationPayload Include="..\..\HelixPayload\$(Configuration)\$(Platform)" />
+  </ItemGroup>
+  
+  <!-- These .proj files are generated by the build machine prior to running tests via GenerateTestProjFile.ps1. -->
+  <Import Project="$(ProjFilesPath)\RunTestsInHelix-TerminalAppLocalTests.proj" Condition=" '$(TestSuite)'=='DevTestSuite' " />
+  <Import Project="$(ProjFilesPath)\RunTestsInHelix-HostTestsUIA.proj" Condition=" '$(TestSuite)'=='DevTestSuite' " />
+</Project>

build/Helix/UpdateUnreliableTests.ps1

@@ -0,0 +1,135 @@
+[CmdLetBinding()]
+Param(
+    [Parameter(Mandatory = $true)] 
+    [int]$RerunPassesRequiredToAvoidFailure,
+
+    [string]$AccessToken = $env:SYSTEM_ACCESSTOKEN,
+    [string]$CollectionUri = $env:SYSTEM_COLLECTIONURI,
+    [string]$TeamProject = $env:SYSTEM_TEAMPROJECT,
+    [string]$BuildUri = $env:BUILD_BUILDURI
+)
+
+. "$PSScriptRoot/AzurePipelinesHelperScripts.ps1"
+
+
+$azureDevOpsRestApiHeaders = @{
+    "Accept"="application/json"
+    "Authorization"="Basic $([System.Convert]::ToBase64String([System.Text.ASCIIEncoding]::ASCII.GetBytes(":$AccessToken")))"
+}
+
+$queryUri = GetQueryTestRunsUri -CollectionUri $CollectionUri -TeamProject $TeamProject -BuildUri $BuildUri
+Write-Host "queryUri = $queryUri"
+
+# To account for unreliable tests, we'll iterate through all of the tests associated with this build, check to see any tests that were unreliable
+# (denoted by being marked as "skipped"), and if so, we'll instead mark those tests with a warning and enumerate all of the attempted runs
+# with their pass/fail states as well as any relevant error messages for failed attempts.
+$testRuns = Invoke-RestMethod -Uri $queryUri -Method Get -Headers $azureDevOpsRestApiHeaders
+
+$timesSeenByRunName = @{}
+      
+foreach ($testRun in $testRuns.value)
+{
+    $testRunResultsUri = "$($testRun.url)/results?api-version=5.0"
+        
+    Write-Host "Marking test run `"$($testRun.name)`" as in progress so we can change its results to account for unreliable tests."
+    Invoke-RestMethod -Uri "$($testRun.url)?api-version=5.0" -Method Patch -Body (ConvertTo-Json @{ "state" = "InProgress" }) -Headers $azureDevOpsRestApiHeaders -ContentType "application/json" | Out-Null
+
+    Write-Host "Retrieving test results..."
+    $testResults = Invoke-RestMethod -Uri $testRunResultsUri -Method Get -Headers $azureDevOpsRestApiHeaders
+        
+    foreach ($testResult in $testResults.value)
+    {
+        $testNeedsSubResultProcessing = $false
+        if ($testResult.outcome -eq "NotExecuted")
+        {
+            $testNeedsSubResultProcessing = $true
+        }
+        elseif($testResult.outcome -eq "Failed")
+        {
+            $testNeedsSubResultProcessing = $testResult.errorMessage -like "*_subresults.json*"
+        }
+
+        if ($testNeedsSubResultProcessing)
+        {
+            Write-Host "  Test $($testResult.testCaseTitle) was detected as unreliable. Updating..."
+            
+            # The errorMessage field contains a link to the JSON-encoded rerun result data.
+            $rerunResults = ConvertFrom-Json (New-Object System.Net.WebClient).DownloadString($testResult.errorMessage)
+            [System.Collections.Generic.List[System.Collections.Hashtable]]$rerunDataList = @()
+            $attemptCount = 0
+            $passCount = 0
+            $totalDuration = 0
+            
+            foreach ($rerun in $rerunResults.results)
+            {
+                $rerunData = @{
+                    "displayName" = "Attempt #$($attemptCount + 1) - $($testResult.testCaseTitle)";
+                    "durationInMs" = $rerun.duration;
+                    "outcome" = $rerun.outcome;
+                }
+
+                if ($rerun.outcome -eq "Passed")
+                {
+                    $passCount++
+                }
+                
+                if ($attemptCount -gt 0)
+                {
+                    $rerunData["sequenceId"] = $attemptCount
+                }
+
+                Write-Host "    Attempt #$($attemptCount + 1): $($rerun.outcome)"
+                
+                if ($rerun.outcome -ne "Passed")
+                {
+                    $screenshots = "$($rerunResults.blobPrefix)/$($rerun.screenshots -join @"
+$($rerunResults.blobSuffix)
+$($rerunResults.blobPrefix)
+"@)$($rerunResults.blobSuffix)"
+
+                    # We subtract 1 from the error index because we added 1 so we could use 0
+                    # as a default value not injected into the JSON in order to keep its size down.
+                    # We did this because there's a maximum size enforced for the errorMessage parameter
+                    # in the Azure DevOps REST API.
+                    $fullErrorMessage = @"
+Log: $($rerunResults.blobPrefix)/$($rerun.log)$($rerunResults.blobSuffix)
+
+Screenshots:
+$screenshots
+
+Error log:
+$($rerunResults.errors[$rerun.errorIndex - 1])
+"@
+
+                    $rerunData["errorMessage"] = $fullErrorMessage
+                }
+                
+                $attemptCount++
+                $totalDuration += $rerun.duration
+                $rerunDataList.Add($rerunData)
+            }
+
+            $overallOutcome = "Warning"
+            
+            if ($attemptCount -eq 2)
+            {
+                Write-Host "  Test $($testResult.testCaseTitle) passed on the immediate rerun, so we'll mark it as unreliable."
+            }
+            elseif ($passCount -gt $RerunPassesRequiredToAvoidFailure)
+            {
+                Write-Host "  Test $($testResult.testCaseTitle) passed on $passCount of $attemptCount attempts, which is greater than or equal to the $RerunPassesRequiredToAvoidFailure passes required to avoid being marked as failed. Marking as unreliable."
+            }
+            else
+            {
+                Write-Host "  Test $($testResult.testCaseTitle) passed on only $passCount of $attemptCount attempts, which is less than the $RerunPassesRequiredToAvoidFailure passes required to avoid being marked as failed. Marking as failed."
+                $overallOutcome = "Failed"
+            }
+            
+            $updateBody = ConvertTo-Json @(@{ "id" = $testResult.id; "outcome" = $overallOutcome; "errorMessage" = " "; "durationInMs" = $totalDuration; "subResults" = $rerunDataList; "resultGroupType" = "rerun" }) -Depth 5
+            Invoke-RestMethod -Uri $testRunResultsUri -Method Patch -Headers $azureDevOpsRestApiHeaders -Body $updateBody -ContentType "application/json" | Out-Null
+        }
+    }
+        
+    Write-Host "Finished updates. Re-marking test run `"$($testRun.name)`" as completed."
+    Invoke-RestMethod -Uri "$($testRun.url)?api-version=5.0" -Method Patch -Body (ConvertTo-Json @{ "state" = "Completed" }) -Headers $azureDevOpsRestApiHeaders -ContentType "application/json" | Out-Null
+}

build/Helix/global.json

@@ -0,0 +1,5 @@
+{
+  "msbuild-sdks": {
+    "Microsoft.DotNet.Helix.Sdk": "5.0.0-beta.20277.5"
+  }
+}

build/Helix/packages.config

@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="utf-8"?>
+<packages>
+  <package id="MUXCustomBuildTasks" version="1.0.48" targetFramework="native" />
+  <package id="TAEF.Redist.Wlk" version="10.57.200731005-develop" targetFramework="native" />
+  <package id="microsoft.windows.apps.test" version="1.0.181203002" targetFramework="native" />
+  <package id="runtime.win-x86.microsoft.netcore.app" version="2.1.0" targetFramework="native" />
+  <package id="runtime.win-x64.microsoft.netcore.app" version="2.1.0" targetFramework="native" />
+</packages>

build/Helix/readme.md

@@ -0,0 +1,32 @@
+This directory contains code and configuration files to run WinUI tests in Helix.
+
+Helix is a cloud hosted test execution environment which is accessed via the Arcade SDK.
+More details:
+* [Arcade](https://github.com/dotnet/arcade)
+* [Helix](https://github.com/dotnet/arcade/tree/master/src/Microsoft.DotNet.Helix/Sdk)
+
+WinUI tests are scheduled in Helix by the Azure DevOps Pipeline: [RunHelixTests.yml](../RunHelixTests.yml).
+
+The workflow is as follows:
+1. NuGet Restore is called on the packages.config in this directory. This downloads any runtime dependencies 
+that are needed to run tests.
+2. PrepareHelixPayload.ps1 is called. This copies the necessary files from various locations into a Helix 
+payload directory. This directory is what will get sent to the Helix machines.
+3. RunTestsInHelix.proj is executed. This proj has a dependency on 
+[Microsoft.DotNet.Helix.Sdk](https://github.com/dotnet/arcade/tree/master/src/Microsoft.DotNet.Helix/Sdk) 
+which it uses to publish the Helix payload directory and to schedule the Helix Work Items. The WinUI tests 
+are parallelized into multiple Helix Work Items.
+4. Each Helix Work Item calls [runtests.cmd](runtests.cmd) with a specific query to pass to 
+[TAEF](https://docs.microsoft.com/en-us/windows-hardware/drivers/taef/) which runs the tests.
+5. If a test is detected to have failed, we run it again, first once, then eight more times if it fails again.
+If it fails all ten times, we report the test as failed; otherwise, we report it as unreliable,
+which will show up as a warning, but which will not fail the build.  When a test is reported as unreliable,
+we include the results for each individual run via a JSON string in the original test's errorMessage field.
+6. TAEF produces logs in WTT format. Helix is able to process logs in XUnit format. We run 
+[ConvertWttLogToXUnit.ps1](ConvertWttLogToXUnit.ps1) to convert the logs into the necessary format.
+7. RunTestsInHelix.proj has EnableAzurePipelinesReporter set to true. This allows the XUnit formatted test 
+results to be reported back to the Azure DevOps Pipeline.
+8. We process unreliable tests once all tests have been reported by reading the JSON string from the
+errorMessage field and calling the Azure DevOps REST API to modify the unreliable tests to have sub-results
+added to the test and to mark the test as "warning", which will enable people to see exactly how the test
+failed in runs where it did.

build/Helix/runtests.cmd

@@ -0,0 +1,106 @@
+setlocal ENABLEDELAYEDEXPANSION
+
+echo %TIME%
+
+robocopy %HELIX_CORRELATION_PAYLOAD% . /s /NP > NUL
+
+echo %TIME%
+
+reg add HKLM\Software\Policies\Microsoft\Windows\Appx /v AllowAllTrustedApps /t REG_DWORD /d 1 /f
+
+rem enable dump collection for our test apps:
+rem note, this script is run from a 32-bit cmd, but we need to set the native reg-key
+FOR %%A IN (TestHostApp.exe,te.exe,te.processhost.exe,conhost.exe,OpenConsole.exe,WindowsTerminal.exe) DO (
+  %systemroot%\sysnative\cmd.exe /c reg add "HKLM\Software\Microsoft\Windows\Windows Error Reporting\LocalDumps\%%A" /v DumpFolder /t REG_EXPAND_SZ /d %HELIX_DUMP_FOLDER% /f
+  %systemroot%\sysnative\cmd.exe /c reg add "HKLM\Software\Microsoft\Windows\Windows Error Reporting\LocalDumps\%%A" /v DumpType /t REG_DWORD /d 2 /f
+  %systemroot%\sysnative\cmd.exe /c reg add "HKLM\Software\Microsoft\Windows\Windows Error Reporting\LocalDumps\%%A" /v DumpCount /t REG_DWORD /d 10 /f
+)
+
+echo %TIME%
+
+:: kill dhandler, which is a tool designed to handle unexpected windows appearing. But since our tests are 
+:: expected to show UI we don't want it running.
+taskkill -f -im dhandler.exe
+
+echo %TIME%
+powershell -ExecutionPolicy Bypass .\EnsureMachineState.ps1
+echo %TIME%
+powershell -ExecutionPolicy Bypass .\InstallTestAppDependencies.ps1
+echo %TIME%
+
+set testBinaryCandidates=TerminalApp.LocalTests.dll Conhost.UIA.Tests.dll
+set testBinaries=
+for %%B in (%testBinaryCandidates%) do (
+    if exist %%B (
+        set "testBinaries=!testBinaries! %%B"
+    )
+)
+
+echo %TIME%
+te.exe %testBinaries% /enablewttlogging /unicodeOutput:false /sessionTimeout:0:15 /testtimeout:0:10 /screenCaptureOnError %*
+echo %TIME%
+
+powershell -ExecutionPolicy Bypass Get-Process
+
+move te.wtl te_original.wtl
+
+copy /y te_original.wtl %HELIX_WORKITEM_UPLOAD_ROOT%
+copy /y WexLogFileOutput\*.jpg %HELIX_WORKITEM_UPLOAD_ROOT%
+for /f "tokens=* delims=" %%a in ('dir /b *.pgc') do ren "%%a" "%testnameprefix%.%%~na.pgc"
+copy /y *.pgc %HELIX_WORKITEM_UPLOAD_ROOT%
+
+set FailedTestQuery=
+for /F "tokens=* usebackq" %%I IN (`powershell -ExecutionPolicy Bypass .\OutputFailedTestQuery.ps1 te_original.wtl`) DO (
+  set FailedTestQuery=%%I
+)
+
+rem The first time, we'll just re-run failed tests once.  In many cases, tests fail very rarely, such that
+rem a single re-run will be sufficient to detect many unreliable tests.
+if "%FailedTestQuery%" == "" goto :SkipReruns
+
+echo %TIME%
+te.exe %testBinaries% /enablewttlogging /unicodeOutput:false /sessionTimeout:0:15 /testtimeout:0:10 /screenCaptureOnError /select:"%FailedTestQuery%"
+echo %TIME%
+
+move te.wtl te_rerun.wtl
+
+copy /y te_rerun.wtl %HELIX_WORKITEM_UPLOAD_ROOT%
+copy /y WexLogFileOutput\*.jpg %HELIX_WORKITEM_UPLOAD_ROOT%
+
+rem If there are still failing tests remaining, we'll run them eight more times, so they'll have been run a total of ten times.
+rem If any tests fail all ten times, we can be pretty confident that these are actual test failures rather than unreliable tests.
+if not exist te_rerun.wtl goto :SkipReruns
+
+set FailedTestQuery=
+for /F "tokens=* usebackq" %%I IN (`powershell -ExecutionPolicy Bypass .\OutputFailedTestQuery.ps1 te_rerun.wtl`) DO (
+  set FailedTestQuery=%%I
+)
+
+if "%FailedTestQuery%" == "" goto :SkipReruns
+
+echo %TIME%
+te.exe %testBinaries% /enablewttlogging /unicodeOutput:false /sessionTimeout:0:15 /testtimeout:0:10 /screenCaptureOnError /testmode:Loop /LoopTest:8 /select:"%FailedTestQuery%"
+echo %TIME%
+
+powershell -ExecutionPolicy Bypass Get-Process
+
+move te.wtl te_rerun_multiple.wtl
+
+copy /y te_rerun_multiple.wtl %HELIX_WORKITEM_UPLOAD_ROOT%
+copy /y WexLogFileOutput\*.jpg %HELIX_WORKITEM_UPLOAD_ROOT%
+powershell -ExecutionPolicy Bypass .\CopyVisualTreeVerificationFiles.ps1
+
+:SkipReruns
+
+powershell -ExecutionPolicy Bypass Get-Process
+
+echo %TIME%
+powershell -ExecutionPolicy Bypass .\OutputSubResultsJsonFiles.ps1 te_original.wtl te_rerun.wtl te_rerun_multiple.wtl %testnameprefix%
+powershell -ExecutionPolicy Bypass .\ConvertWttLogToXUnit.ps1 te_original.wtl te_rerun.wtl te_rerun_multiple.wtl testResults.xml %testnameprefix%
+echo %TIME%
+
+copy /y *_subresults.json %HELIX_WORKITEM_UPLOAD_ROOT%
+
+type testResults.xml
+
+echo %TIME%

build/packages.config

@@ -0,0 +1,5 @@
+<?xml version="1.0" encoding="utf-8"?>
+<packages>
+  <package id="MUXCustomBuildTasks" version="1.0.48" targetFramework="native" />
+  <package id="TAEF.Redist.Wlk" version="10.57.200731005-develop" targetFramework="native" />
+</packages>

build/pipelines/templates/build-console-ci.yml

@@ -2,6 +2,8 @@ parameters:
   configuration: 'Release'
   platform: ''
   additionalBuildArguments: ''
+  minimumExpectedTestsExecutedCount: 10  # Sanity check for minimum expected tests to be reported
+  rerunPassesRequiredToAvoidFailure: 5
 
 jobs:
 - job: Build${{ parameters.platform }}${{ parameters.configuration }}
@@ -15,3 +17,19 @@ jobs:
   - template: build-console-steps.yml
     parameters:
       additionalBuildArguments: ${{ parameters.additionalBuildArguments }}
+
+- template: helix-runtests-job.yml
+  parameters:
+    name: 'RunTestsInHelix'
+    dependsOn: Build${{ parameters.platform }}${{ parameters.configuration }}
+    condition: and(succeeded(), and(eq('${{ parameters.platform }}', 'x64'), not(eq(variables['Build.Reason'], 'PullRequest')))) 
+    testSuite: 'DevTestSuite'
+    rerunPassesRequiredToAvoidFailure: ${{ parameters.rerunPassesRequiredToAvoidFailure }}
+    
+- template: helix-processtestresults-job.yml
+  parameters:
+    dependsOn:
+    - RunTestsInHelix
+    condition: and(succeededOrFailed(), and(eq('${{ parameters.platform }}', 'x64'), not(eq(variables['Build.Reason'], 'PullRequest')))) 
+    rerunPassesRequiredToAvoidFailure: ${{ parameters.rerunPassesRequiredToAvoidFailure }}
+    minimumExpectedTestsExecutedCount: ${{ parameters.minimumExpectedTestsExecutedCount }}

build/pipelines/templates/build-console-steps.yml

@@ -1,5 +1,6 @@
 parameters:
   additionalBuildArguments: ''
+  testLogPath: '$(Build.BinariesDirectory)\$(BuildPlatform)\$(BuildConfiguration)\testsOnBuildMachine.wtl'
 
 steps:
 - checkout: self
@@ -7,23 +8,29 @@ steps:
   clean: true
 
 - task: NuGetToolInstaller@0
-  displayName: Ensure NuGet 4.8.1
+  displayName: 'Use NuGet 5.2.0'
   inputs:
-    versionSpec: 4.8.1
-
-- task: VisualStudioTestPlatformInstaller@1
-  displayName: Ensure VSTest Platform
+    versionSpec: 5.2.0
 
 # In the Microsoft Azure DevOps tenant, NuGetCommand is ambiguous.
 # This should be `task: NuGetCommand@2`
 - task: 333b11bd-d341-40d9-afcf-b32d5ce6f23b@2
-  displayName: Restore NuGet packages
+  displayName: Restore NuGet packages for solution
   inputs:
     command: restore
     feedsToUse: config
     configPath: NuGet.config
     restoreSolution: OpenConsole.sln
     restoreDirectory: '$(Build.SourcesDirectory)\packages'
+    
+- task: 333b11bd-d341-40d9-afcf-b32d5ce6f23b@2
+  displayName: Restore NuGet packages for extraneous build actions
+  inputs:
+    command: restore
+    feedsToUse: config
+    configPath: NuGet.config
+    restoreSolution: build/packages.config
+    restoreDirectory: '$(Build.SourcesDirectory)\packages'
 
 - task: VSBuild@1
   displayName: 'Build solution **\OpenConsole.sln'
@@ -66,7 +73,7 @@ steps:
   inputs:
     targetType: filePath
     filePath: build\scripts\Run-Tests.ps1
-    arguments: -MatchPattern '*unit.test*.dll' -Platform '$(RationalizedBuildPlatform)' -Configuration '$(BuildConfiguration)'
+    arguments: -MatchPattern '*unit.test*.dll' -Platform '$(RationalizedBuildPlatform)' -Configuration '$(BuildConfiguration)' -LogPath '${{ parameters.testLogPath }}'
   condition: and(succeeded(), or(eq(variables['BuildPlatform'], 'x64'), eq(variables['BuildPlatform'], 'x86')))
 
 - task: PowerShell@2
@@ -74,9 +81,41 @@ steps:
   inputs:
     targetType: filePath
     filePath: build\scripts\Run-Tests.ps1
-    arguments: -MatchPattern '*feature.test*.dll' -Platform '$(RationalizedBuildPlatform)' -Configuration '$(BuildConfiguration)'
+    arguments: -MatchPattern '*feature.test*.dll' -Platform '$(RationalizedBuildPlatform)' -Configuration '$(BuildConfiguration)' -LogPath '${{ parameters.testLogPath }}'
   condition: and(succeeded(), eq(variables['BuildPlatform'], 'x64'))
 
+- task: PowerShell@2
+  displayName: 'Convert Test Logs from WTL to xUnit format'
+  inputs:
+    targetType: filePath
+    filePath: build\Helix\ConvertWttLogToXUnit.ps1
+    arguments: -WttInputPath '${{ parameters.testLogPath }}' -WttSingleRerunInputPath 'unused.wtl' -WttMultipleRerunInputPath 'unused2.wtl' -XUnitOutputPath 'onBuildMachineResults.xml' -TestNamePrefix '$(BuildConfiguration).$(BuildPlatform)'
+  condition: or(eq(variables['BuildPlatform'], 'x64'), eq(variables['BuildPlatform'], 'x86'))
+
+- task: PublishTestResults@2
+  displayName: 'Upload converted test logs'
+  inputs:
+    testResultsFormat: 'xUnit' # Options: JUnit, NUnit, VSTest, xUnit, cTest
+    testResultsFiles: '**/onBuildMachineResults.xml' 
+    #searchFolder: '$(System.DefaultWorkingDirectory)' # Optional
+    #mergeTestResults: false # Optional
+    #failTaskOnFailedTests: false # Optional
+    testRunTitle: 'On Build Machine Tests' # Optional
+    buildPlatform: $(BuildPlatform) # Optional
+    buildConfiguration: $(BuildConfiguration) # Optional
+    #publishRunAttachments: true # Optional
+
+- task: CopyFiles@2
+  displayName: 'Copy result logs to Artifacts'
+  inputs:
+    Contents: |
+     **/*.wtl
+     **/*onBuildMachineResults.xml
+     ${{ parameters.testLogPath }}
+    TargetFolder: '$(Build.ArtifactStagingDirectory)/$(BuildConfiguration)/$(BuildPlatform)/test'
+    OverWrite: true
+    flattenFolders: true
+
 - task: CopyFiles@2
   displayName: 'Copy *.appx/*.msix to Artifacts (Non-PR builds only)'
   inputs:
@@ -90,9 +129,22 @@ steps:
     flattenFolders: true
   condition: and(succeeded(), ne(variables['Build.Reason'], 'PullRequest'))
 
-- task: PublishBuildArtifacts@1
-  displayName: 'Publish Artifact (appx) (Non-PR builds only)'
+- task: CopyFiles@2
+  displayName: 'Copy outputs needed for test runs to Artifacts'
   inputs:
-    PathtoPublish: '$(Build.ArtifactStagingDirectory)/appx'
-    ArtifactName: 'appx-$(BuildConfiguration)'
-  condition: and(succeeded(), ne(variables['Build.Reason'], 'PullRequest'))
+    Contents: |
+     $(Build.SourcesDirectory)/bin/$(BuildPlatform)/$(BuildConfiguration)/*.exe
+     $(Build.SourcesDirectory)/bin/$(BuildPlatform)/$(BuildConfiguration)/*.dll
+     $(Build.SourcesDirectory)/bin/$(BuildPlatform)/$(BuildConfiguration)/*.xml
+     **/Microsoft.VCLibs.*.appx
+     **/TestHostApp/*
+    TargetFolder: '$(Build.ArtifactStagingDirectory)/$(BuildConfiguration)/$(BuildPlatform)/test'
+    OverWrite: true
+    flattenFolders: true
+  condition: and(and(succeeded(), eq(variables['BuildPlatform'], 'x64')), ne(variables['Build.Reason'], 'PullRequest'))
+
+- task: PublishBuildArtifacts@1
+  displayName: 'Publish All Build Artifacts'
+  inputs:
+    PathtoPublish: '$(Build.ArtifactStagingDirectory)'
+    ArtifactName: 'drop'

build/pipelines/templates/helix-createprojfile-steps.yml

@@ -0,0 +1,15 @@
+parameters:
+  condition: ''
+  testFilePath: ''
+  outputProjFileName: ''
+  testSuite: ''
+  taefQuery: ''
+
+steps:
+  - task: powershell@2
+    displayName: 'Create ${{ parameters.outputProjFileName }}'
+    condition: ${{ parameters.condition }}
+    inputs:
+      targetType: filePath
+      filePath: build\Helix\GenerateTestProjFile.ps1
+      arguments: -TestFile '${{ parameters.testFilePath }}' -OutputProjFile '$(Build.ArtifactStagingDirectory)\${{ parameters.outputProjFileName }}' -JobTestSuiteName '${{ parameters.testSuite }}' -TaefPath '$(Build.SourcesDirectory)\build\Helix\packages\taef.redist.wlk.10.57.200731005-develop\build\Binaries\x86' -TaefQuery '${{ parameters.taefQuery }}'

build/pipelines/templates/helix-processtestresults-job.yml

@@ -0,0 +1,68 @@
+parameters:
+  condition: 'succeededOrFailed()'
+  dependsOn: ''
+  rerunPassesRequiredToAvoidFailure: 5
+  minimumExpectedTestsExecutedCount: 10
+  checkJobAttempt: false
+  pgoArtifact: ''
+
+jobs:
+- job: ProcessTestResults
+  condition: ${{ parameters.condition }}
+  dependsOn: ${{ parameters.dependsOn }}
+  pool:
+    vmImage: 'windows-2019'
+  timeoutInMinutes: 120
+  variables:
+    helixOutputFolder: $(Build.SourcesDirectory)\HelixOutput
+
+  steps:
+  - task: powershell@2
+    displayName: 'UpdateUnreliableTests.ps1'
+    condition: succeededOrFailed()
+    env:
+      SYSTEM_ACCESSTOKEN: $(System.AccessToken)
+    inputs:
+      targetType: filePath
+      filePath: build\Helix\UpdateUnreliableTests.ps1
+      arguments: -RerunPassesRequiredToAvoidFailure '${{ parameters.rerunPassesRequiredToAvoidFailure }}'
+
+  - task: powershell@2
+    displayName: 'OutputTestResults.ps1'
+    condition: succeededOrFailed()
+    env:
+      SYSTEM_ACCESSTOKEN: $(System.AccessToken)
+    inputs:
+      targetType: filePath
+      filePath: build\Helix\OutputTestResults.ps1
+      arguments: -MinimumExpectedTestsExecutedCount '${{ parameters.minimumExpectedTestsExecutedCount }}' -CheckJobAttempt $${{ parameters.checkJobAttempt }}
+
+  - task: powershell@2
+    displayName: 'ProcessHelixFiles.ps1'
+    condition: succeededOrFailed()
+    env:
+      SYSTEM_ACCESSTOKEN: $(System.AccessToken)
+      HelixAccessToken: $(HelixApiAccessToken)
+    inputs:
+      targetType: filePath
+      filePath: build\Helix\ProcessHelixFiles.ps1
+      arguments: -OutputFolder '$(helixOutputFolder)'
+
+  - ${{if ne(parameters.pgoArtifact, '') }}:
+    - script: move /y $(helixOutputFolder)\PGO $(Build.ArtifactStagingDirectory)
+      displayName: 'Move pgc files to PGO artifact'
+
+  - task: PublishBuildArtifacts@1
+    displayName: 'Publish Helix files'
+    condition: succeededOrFailed()
+    inputs:
+      PathtoPublish: $(helixOutputFolder)
+      artifactName: drop
+
+  - ${{if ne(parameters.pgoArtifact, '') }}:
+    - task: PublishBuildArtifacts@1
+      displayName: 'Publish pgc files'
+      condition: succeededOrFailed()
+      inputs:
+        PathtoPublish: $(Build.ArtifactStagingDirectory)\PGO\Release
+        artifactName: ${{ parameters.pgoArtifact }}

build/pipelines/templates/helix-runtests-job.yml

@@ -0,0 +1,131 @@
+parameters:
+  name: 'RunTestsInHelix'
+  dependsOn: ''
+  condition: ''
+  testSuite: ''
+  # If a Pipeline runs this template more than once, this parameter should be unique per build flavor to differentiate the
+  # the different test runs:
+  helixType: 'test/devtest' 
+  artifactName: 'drop'
+  maxParallel: 4
+  rerunPassesRequiredToAvoidFailure: 5
+  taefQuery: ''
+  # if 'useBuildOutputFromBuildId' is set, we will default to using a build from this pipeline:
+  useBuildOutputFromPipeline: $(System.DefinitionId)
+  matrix: 
+    # Release_x86:
+    #   buildPlatform: 'x86'
+    #   buildConfiguration: 'release'
+    #   openHelixTargetQueues: 'windows.10.amd64.client19h1.open.xaml'
+    #   closedHelixTargetQueues: 'windows.10.amd64.client19h1.xaml'
+    Release_x64:
+      buildPlatform: 'x64'
+      buildConfiguration: 'release'
+      openHelixTargetQueues: 'windows.10.amd64.client19h1.open.xaml'
+      closedHelixTargetQueues: 'windows.10.amd64.client19h1.xaml'
+
+jobs:
+- job: ${{ parameters.name }}
+  dependsOn: ${{ parameters.dependsOn }}
+  condition: ${{ parameters.condition }}
+  pool:
+    vmImage: 'windows-2019'
+  timeoutInMinutes: 120
+  strategy:
+    maxParallel: ${{ parameters.maxParallel }}
+    matrix: ${{ parameters.matrix }}
+  variables:
+    artifactsDir: $(Build.SourcesDirectory)\Artifacts
+    taefPath: $(Build.SourcesDirectory)\build\Helix\packages\taef.redist.wlk.10.57.200731005-develop\build\Binaries\$(buildPlatform)
+    helixCommonArgs: '/binaryLogger:$(Build.SourcesDirectory)/${{parameters.name}}.$(buildPlatform).$(buildConfiguration).binlog /p:HelixBuild=$(Build.BuildId).$(buildPlatform).$(buildConfiguration) /p:Platform=$(buildPlatform) /p:Configuration=$(buildConfiguration) /p:HelixType=${{parameters.helixType}} /p:TestSuite=${{parameters.testSuite}} /p:ProjFilesPath=$(Build.ArtifactStagingDirectory) /p:rerunPassesRequiredToAvoidFailure=${{parameters.rerunPassesRequiredToAvoidFailure}}'
+
+      
+  steps:
+  - task: CmdLine@1
+    displayName: 'Display build machine environment variables'
+    inputs:
+      filename: 'set'
+      
+  - task: NuGetToolInstaller@0
+    displayName: 'Use NuGet 5.2.0'
+    inputs:
+      versionSpec: 5.2.0
+
+  - task: 333b11bd-d341-40d9-afcf-b32d5ce6f23b@2
+    displayName: 'NuGet restore build/Helix/packages.config'
+    inputs:
+      restoreSolution: build/Helix/packages.config
+      feedsToUse: config
+      nugetConfigPath: nuget.config
+      restoreDirectory: packages
+
+  - task: DownloadBuildArtifacts@0 
+    condition:
+      and(succeeded(),eq(variables['useBuildOutputFromBuildId'],''))
+    inputs: 
+      artifactName: ${{ parameters.artifactName }} 
+      downloadPath: '$(artifactsDir)'
+
+  - task: DownloadBuildArtifacts@0 
+    condition:
+      and(succeeded(),ne(variables['useBuildOutputFromBuildId'],''))
+    inputs: 
+      buildType: specific
+      buildVersionToDownload: specific
+      project: $(System.TeamProjectId)
+      pipeline: ${{ parameters.useBuildOutputFromPipeline }}
+      buildId: $(useBuildOutputFromBuildId)
+      artifactName: ${{ parameters.artifactName }} 
+      downloadPath: '$(artifactsDir)'
+
+  - task: CmdLine@1
+    displayName: 'Display Artifact Directory payload contents'
+    inputs:
+      filename: 'dir'
+      arguments: '/s $(artifactsDir)'
+
+  - task: powershell@2
+    displayName: 'PrepareHelixPayload.ps1'
+    inputs:
+      targetType: filePath
+      filePath: build\Helix\PrepareHelixPayload.ps1
+      arguments: -Platform '$(buildPlatform)' -Configuration '$(buildConfiguration)' -ArtifactName '${{ parameters.artifactName }}'
+      
+  - task: CmdLine@1
+    displayName: 'Display Helix payload contents'
+    inputs:
+      filename: 'dir'
+      arguments: '/s $(Build.SourcesDirectory)\HelixPayload'
+
+  - template: helix-createprojfile-steps.yml
+    parameters:
+      condition: and(succeeded(),ne('${{ parameters.testSuite }}','NugetTestSuite'))
+      testFilePath: '$(artifactsDir)\${{ parameters.artifactName }}\$(buildConfiguration)\$(buildPlatform)\Test\TerminalApp.LocalTests.dll'
+      outputProjFileName: 'RunTestsInHelix-TerminalAppLocalTests.proj'
+      testSuite: '${{ parameters.testSuite }}'
+      taefQuery: ${{ parameters.taefQuery }}
+      
+  - template: helix-createprojfile-steps.yml
+    parameters:
+      condition: and(succeeded(),ne('${{ parameters.testSuite }}','NugetTestSuite'))
+      testFilePath: '$(artifactsDir)\${{ parameters.artifactName }}\$(buildConfiguration)\$(buildPlatform)\Test\Conhost.UIA.Tests.dll'
+      outputProjFileName: 'RunTestsInHelix-HostTestsUIA.proj'
+      testSuite: '${{ parameters.testSuite }}'
+      taefQuery: ${{ parameters.taefQuery }}
+
+  - task: PublishBuildArtifacts@1
+    displayName: 'Publish generated .proj files'
+    inputs:
+      PathtoPublish: $(Build.ArtifactStagingDirectory)
+      artifactName: ${{ parameters.artifactName }}
+      
+  - task: DotNetCoreCLI@2
+    displayName: 'Run tests in Helix (open queues)'
+    env:
+      SYSTEM_ACCESSTOKEN: $(System.AccessToken)
+    inputs:
+      command: custom
+      projects: build\Helix\RunTestsInHelix.proj
+      custom: msbuild
+      arguments: '$(helixCommonArgs) /p:IsExternal=true /p:Creator=Terminal /p:HelixTargetQueues=$(openHelixTargetQueues)'
+

build/scripts/Get-WttLog.ps1

@@ -0,0 +1,15 @@
+[CmdLetBinding()]
+Param(
+    [Parameter(Mandatory=$true, Position=0)][string]$BuildPlatform,
+    [Parameter(Mandatory=$true, Position=1)][string]$RationalizedPlatform,
+    [Parameter(Mandatory=$true, Position=2)][string]$Configuration
+)
+
+
+$i = Get-Item .\packages\MuxCustomBuild*
+$wtt = Join-Path -Path $i[0].FullName -ChildPath (Join-Path -Path 'tools' -ChildPath (Join-Path -Path $BuildPlatform -ChildPath 'wttlog.dll'))
+$dest = Join-Path -Path .\bin -ChildPath (Join-Path -Path $RationalizedPlatform -ChildPath ($Configuration))
+copy $wtt $dest
+
+
+Exit 0

build/scripts/Run-Tests.ps1

@@ -2,12 +2,24 @@
 Param(
     [Parameter(Mandatory=$true, Position=0)][string]$MatchPattern,
     [Parameter(Mandatory=$true, Position=1)][string]$Platform,
-    [Parameter(Mandatory=$true, Position=2)][string]$Configuration
+    [Parameter(Mandatory=$true, Position=2)][string]$Configuration,
+    [Parameter(Mandatory=$false, Position=3)][string]$LogPath
 )
 
 $testdlls = Get-ChildItem -Path ".\bin\$Platform\$Configuration" -Recurse -Filter $MatchPattern
 
-&".\bin\$Platform\$Configuration\te.exe" $testdlls.FullName
+
+$args = @();
+
+if ($LogPath)
+{
+    $args += '/enablewttlogging';
+    $args += '/appendwttlogging';
+    $args += "/logFile:$LogPath";
+    Write-Host "Wtt Logging Enabled";
+}
+
+&".\bin\$Platform\$Configuration\te.exe" $args $testdlls.FullName
 
 if ($lastexitcode -Ne 0) { Exit $lastexitcode }
 

custom.props

@@ -5,7 +5,7 @@
     <XesUseOneStoreVersioning>true</XesUseOneStoreVersioning>
     <XesBaseYearForStoreVersion>2020</XesBaseYearForStoreVersion>
     <VersionMajor>1</VersionMajor>
-    <VersionMinor>2</VersionMinor>
+    <VersionMinor>3</VersionMinor>
     <VersionInfoProductName>Windows Terminal</VersionInfoProductName>
   </PropertyGroup>
 </Project>

doc/Niksa.md

@@ -9,6 +9,8 @@ This document serves as a storage point for those posts.
 - [Output Processing between "Far East" and "Western"](#fesb)
 - [Why do we not backport things?](#backport)
 - [Why can't we have mixed elevated and non-elevated tabs in the Terminal?](#elevation)
+- [What's the difference between a shell and a terminal?](#shell-vs-terminal)
+
 
 ## <a name="cmd"></a>Why do we avoid changing CMD.exe?
 `setlocal` doesn't behave the same way as an environment variable. It's a thing that would have to be put in at the top of the batch script that is `somefile.cmd` as one of its first commands to adjust the way that one specific batch file is processed by the `cmd.exe` engine. That's probably not suitable for your needs, but that's the way we have to go.
@@ -179,3 +181,20 @@ Other platforms have accepted that risk in preference for user convenience. They
 
 Original Source: https://github.com/microsoft/terminal/issues/632#issuecomment-519375707
 
+## <a name="shell-vs-terminal"></a>What's the difference between a shell and a terminal?
+
+_guest speaker @zadjii-msft_
+
+I think there might be a bit of a misunderstanding here - there are two different kinds of applications we're talking about here:
+* shell applications, like `cmd.exe`, `powershell`, `zsh`, etc. These are text-only applications that emit streams of characters. They don't care at all about how they're eventually rendered to the user. These are also sometimes referred to as "commandline client" applications.
+* terminal applications, like the Windows Terminal, gnome-terminal, xterm, iterm2, hyper. These are graphical applications that can be used to render the output of commandline clients. 
+
+On Windows, if you just run `cmd.exe` directly, the OS will create an instance of `conhost.exe` as the _terminal_ for `cmd.exe`. The same thing happens for `powershell.exe`, the system will creates a new conhost window for any client that's not already connected to a terminal of some sort. This has lead to an enormous amount of confusion for people thinking that a conhost window is actually a "`cmd` window". `cmd` can't have a window, it's just a commandline application. Its window is always some other terminal.
+
+Any terminal can run any commandline client application. So you can use the Windows Terminal to run whatever shell you want. I use mine for both `cmd` and `powershell`, and also WSL:
+
+![image](https://user-images.githubusercontent.com/18356694/89556758-79d27e80-d7d7-11ea-84e2-10710e09ef4a.png)
+
+It's not the Terminal's responsibility to remember the commands executed by a commandline client. That's the responsibility of the _shell_. How would the terminal remember commands executed by something like `emacs` or `vim`? Those are both applications where the user is typing input and hitting enter, like they would at a cmd prompt, but without something that resembles a command history.
+
+Original Source: https://github.com/microsoft/terminal/issues/6500#issuecomment-670035468

doc/cascadia/SettingsSchema.md

@@ -8,7 +8,7 @@ Properties listed below affect the entire window, regardless of the profile sett
 | -------- | --------- | ---- | ------- | ----------- |
 | `alwaysShowTabs` | _Required_ | Boolean | `true` | When set to `true`, tabs are always displayed. When set to `false` and `showTabsInTitlebar` is set to `false`, tabs only appear after typing <kbd>Ctrl</kbd> + <kbd>T</kbd>. |
 | `copyOnSelect` | Optional | Boolean | `false` | When set to `true`, a selection is immediately copied to your clipboard upon creation. When set to `false`, the selection persists and awaits further action. |
-| `copyFormatting` | Optional | Boolean | `false` | When set to `true`, the color and font formatting of selected text is also copied to your clipboard. When set to `false`, only plain text is copied to your clipboard. |
+| `copyFormatting` | Optional | Boolean, Array | `true` | When set to `true`, the color and font formatting of selected text is also copied to your clipboard. When set to `false`, only plain text is copied to your clipboard. An array of specific formats can also be used. Supported array values include `html` and `rtf`. Plain text is always copied. |
 | `largePasteWarning` | Optional | Boolean | `true` | When set to `true`, trying to paste text with more than 5 KiB of characters will display a warning asking you whether to continue or not with the paste. |
 | `multiLinePasteWarning` | Optional | Boolean | `true` | When set to `true`, trying to paste text with a _new line_ character will display a warning asking you whether to continue or not with the paste. |
 | `defaultProfile` | _Required_ | String | PowerShell guid | Sets the default profile. Opens by typing <kbd>Ctrl</kbd> + <kbd>T</kbd> or by clicking the '+' icon. The guid of the desired default profile is used as the value. |
@@ -126,7 +126,7 @@ For commands with arguments:
 | `closePane` | Close the active pane. | | | |
 | `closeTab` | Close the current tab. | | | |
 | `closeWindow` | Close the current window and all tabs within it. | | | |
-| `copy` | Copy the selected terminal content to your Windows Clipboard. | `singleLine` | boolean | When `true`, the copied content will be copied as a single line. When `false`, newlines persist from the selected text. |
+| `copy` | Copy the selected terminal content to your Windows Clipboard. | 1. `singleLine`<br>2. `copyFormatting` | 1. boolean<br>2. boolean, array | 1. When `true`, the copied content will be copied as a single line. When `false`, newlines persist from the selected text.<br>2. When set to `true`, the color and font formatting of selected text is also copied to your clipboard. When set to `false`, only plain text is copied to your clipboard. An array of specific formats can also be used. Supported array values include `html` and `rtf`. Plain text is always copied. Not setting this value inherits the behavior of the `copyFormatting` global setting. |
 | `duplicateTab` | Make a copy and open the current tab. | | | |
 | `find` | Open the search dialog box. | | | |
 | `moveFocus` | Focus on a different pane depending on direction. | `direction`* | `left`, `right`, `up`, `down` | Direction in which the focus will move. |
@@ -142,6 +142,7 @@ For commands with arguments:
 | `scrollUp` | Move the screen up. | | | |
 | `scrollUpPage` | Move the screen up a whole page. | | | |
 | `scrollDownPage` | Move the screen down a whole page. | | | |
+| `sendInput` | Sends some text input to the shell. | `input` | string | The text input to feed into the shell.<br>ANSI escape sequences may be used. Escape codes like `\x1b` must be written as `\u001b`.<br>For instance the input `"text\n"` will write "text" followed by a newline. `"\u001b[D"` will behave as if the left arrow button had been pressed. |
 | `splitPane` | Halve the size of the active pane and open another. Without any arguments, this will open the default profile in the new pane. | 1. `split`*<br>2. `commandLine`<br>3. `startingDirectory`<br>4. `tabTitle`<br>5. `index`<br>6. `profile`<br>7. `splitMode` | 1. `vertical`, `horizontal`, `auto`<br>2. string<br>3. string<br>4. string<br>5. integer<br>6. string<br>7. string | 1. How the pane will split. `auto` will split in the direction that provides the most surface area.<br>2. Executable run within the pane.<br>3. Directory in which the pane will open.<br>4. Title of the tab when the new pane is focused.<br>5. Profile that will open based on its position in the dropdown (starting at 0).<br>6. Profile that will open based on its GUID or name.<br>7. Controls how the pane splits. Only accepts `duplicate` which will duplicate the focused pane's profile into a new pane. |
 | `switchToTab` | Open a specific tab depending on index. | `index`* | integer | Tab that will open based on its position in the tab bar (starting at 0). |
 | `toggleFullscreen` | Switch between fullscreen and default window sizes. | | | |

doc/cascadia/profiles.schema.json

@@ -34,35 +34,41 @@
     "ShortcutActionName": {
       "enum": [
         "adjustFontSize",
+        "closeOtherTabs",
         "closePane",
         "closeTab",
+        "closeTabsAfter",
         "closeWindow",
+        "commandPalette",
         "copy",
         "duplicateTab",
+        "find",
         "moveFocus",
         "newTab",
         "nextTab",
         "openNewTabDropdown",
         "openSettings",
+        "openTabColorPicker",
         "paste",
         "prevTab",
+        "renameTab",
         "resetFontSize",
         "resizePane",
         "scrollDown",
         "scrollDownPage",
         "scrollUp",
         "scrollUpPage",
+        "sendInput",
+        "setColorScheme",
+        "setTabColor",
         "splitPane",
         "switchToTab",
+        "tabSearch",
+        "toggleAlwaysOnTop",
         "toggleFocusMode",
         "toggleFullscreen",
-        "toggleAlwaysOnTop",
         "toggleRetroEffect",
-        "find",
-        "setTabColor",
-        "openTabColorPicker",
-        "renameTab",
-        "commandPalette",
+        "wt",
         "unbound"
       ],
       "type": "string"
@@ -84,6 +90,40 @@
       ],
       "type": "string"
     },
+    "CopyFormat": {
+      "oneOf": [
+        {
+          "type": "boolean"
+        },
+        {
+          "type": "array",
+          "items": {
+            "type": "string",
+            "enum": [
+              "html",
+              "rtf"
+            ]
+          }
+        },
+        {
+          "type": "string",
+          "enum": [
+            "html",
+            "rtf",
+            "all",
+            "none"
+          ]
+        }
+      ]
+    },
+    "AnchorKey": {
+      "enum": [
+        "ctrl",
+        "alt",
+        "shift"
+      ],
+      "type": "string"
+    },
     "NewTerminalArgs": {
       "properties": {
         "commandline": {
@@ -149,6 +189,18 @@
               "type": "boolean",
               "default": false,
               "description": "If true, the copied content will be copied as a single line (even if there are hard line breaks present in the text). If false, newlines persist from the selected text."
+            },
+            "copyFormatting": {
+              "default": null,
+              "description": "When set to `true`, the color and font formatting of selected text is also copied to your clipboard. When set to `false`, only plain text is copied to your clipboard. An array of specific formats can also be used. Supported array values include `html` and `rtf`. Plain text is always copied. Not setting this value inherits the behavior of the `copyFormatting` global setting.",
+              "oneOf": [
+                {
+                  "$ref": "#/definitions/CopyFormat"
+                },
+                {
+                  "type": "null"
+                }
+              ]
             }
           }
         }
@@ -217,6 +269,28 @@
       ],
       "required": [ "direction" ]
     },
+    "SendInputAction": {
+      "description": "Arguments corresponding to a Send Input Action",
+      "allOf": [
+        {
+          "$ref": "#/definitions/ShortcutAction"
+        },
+        {
+          "properties": {
+            "action": {
+              "type": "string",
+              "pattern": "sendInput"
+            },
+            "input": {
+              "type": "string",
+              "default": "",
+              "description": "The text input to feed into the shell. ANSI escape sequences may be used. Escape codes like \\x1b must be written as \\u001b."
+            }
+          }
+        }
+      ],
+      "required": [ "input" ]
+    },
     "SplitPaneAction": {
       "description": "Arguments corresponding to a Split Pane Action",
       "allOf": [
@@ -280,6 +354,78 @@
         }
       ]
     },
+    "SetColorSchemeAction": {
+      "description": "Arguments corresponding to a Set Color Scheme Action",
+      "allOf": [
+        { "$ref": "#/definitions/ShortcutAction" },
+        {
+          "properties": {
+            "action": { "type": "string", "pattern": "setColorScheme" },
+            "colorScheme": {
+              "type": "string",
+              "default": "",
+              "description": "the name of the scheme to apply to the active pane"
+            }
+          }
+        }
+      ],
+      "required": [ "colorScheme" ]
+    },
+    "WtAction": {
+      "description": "Arguments corresponding to a wt Action",
+      "allOf": [
+        { "$ref": "#/definitions/ShortcutAction" },
+        {
+          "properties": {
+            "action": { "type": "string", "pattern": "wt" },
+            "commandline": {
+              "type": "string",
+              "default": "",
+              "description": "a `wt` commandline to run in the current window"
+            }
+          }
+        }
+      ],
+      "required": [ "commandline" ]
+    },
+    "CloseOtherTabsAction": {
+      "description": "Arguments for a closeOtherTabs action",
+      "allOf": [
+        { "$ref": "#/definitions/ShortcutAction" },
+        {
+          "properties": {
+            "action": { "type": "string", "pattern": "closeOtherTabs" },
+            "index": {
+              "oneOf": [
+                { "type": "integer" },
+                { "type": null }
+              ],
+              "default": "",
+              "description": "Close the tabs other than the one at this index. If no index is provided, use the focused tab's index."
+            }
+          }
+        }
+      ]
+    },
+    "CloseTabsAfterAction": {
+      "description": "Arguments for a closeTabsAfter action",
+      "allOf": [
+        { "$ref": "#/definitions/ShortcutAction" },
+        {
+          "properties": {
+            "action": { "type": "string", "pattern": "closeTabsAfter" },
+            "index": {
+              "oneOf": [
+                { "type": "integer" },
+                { "type": null }
+              ],
+              "default": "",
+              "description": "Close the tabs following the tab at this index. If no index is provided, use the focused tab's index."
+            }
+          }
+        }
+      ]
+    },
     "Keybinding": {
       "additionalProperties": false,
       "properties": {
@@ -293,9 +439,14 @@
               { "$ref": "#/definitions/SwitchToTabAction" },
               { "$ref": "#/definitions/MoveFocusAction" },
               { "$ref": "#/definitions/ResizePaneAction" },
+              { "$ref": "#/definitions/SendInputAction" },
               { "$ref": "#/definitions/SplitPaneAction" },
               { "$ref": "#/definitions/OpenSettingsAction" },
               { "$ref": "#/definitions/SetTabColorAction" },
+              { "$ref": "#/definitions/SetColorSchemeAction" },
+              { "$ref": "#/definitions/WtAction" },
+              { "$ref": "#/definitions/CloseOtherTabsAction" },
+              { "$ref": "#/definitions/CloseTabsAfterAction" },
               { "type": "null" }
             ]
         },
@@ -342,8 +493,8 @@
         },
         "copyFormatting": {
           "default": true,
-          "description": "When set to `true`, the color and font formatting of selected text is also copied to your clipboard. When set to `false`, only plain text is copied to your clipboard.",
-          "type": "boolean"
+          "description": "When set to `true`, the color and font formatting of selected text is also copied to your clipboard. When set to `false`, only plain text is copied to your clipboard. An array of specific formats can also be used. Supported array values include `html` and `rtf`. Plain text is always copied.",
+          "$ref": "#/definitions/CopyFormat"
         },
         "largePasteWarning": {
           "default": true,
@@ -466,6 +617,11 @@
           "default": true,
           "description": "When set to \"true\" closing a window with multiple tabs open will require confirmation.  When set to \"false\", the confirmation dialog will not appear.",
           "type": "boolean"
+        },
+        "useTabSwitcher": {
+          "default": true,
+          "description": "When set to \"true\", the \"nextTab\" and \"prevTab\" commands will use the tab switcher UI.",
+          "type": "boolean"
         }
       },
       "required": [
@@ -665,8 +821,15 @@
         "padding": {
           "default": "8, 8, 8, 8",
           "description": "Sets the padding around the text within the window. Can have three different formats:\n -\"#\" sets the same padding for all sides \n -\"#, #\" sets the same padding for left-right and top-bottom\n -\"#, #, #, #\" sets the padding individually for left, top, right, and bottom.",
-          "pattern": "^-?[0-9]+(\\.[0-9]+)?( *, *-?[0-9]+(\\.[0-9]+)?|( *, *-?[0-9]+(\\.[0-9]+)?){3})?$",
-          "type": "string"
+          "oneOf": [
+            {
+              "pattern": "^-?[0-9]+(\\.[0-9]+)?( *, *-?[0-9]+(\\.[0-9]+)?|( *, *-?[0-9]+(\\.[0-9]+)?){3})?$",
+              "type": "string"
+            },
+            {
+              "type": "integer"
+            }
+          ]
         },
         "scrollbarState": {
           "default": "visible",

doc/specs/#1337 - Per-Profile Tab Colors/#1337 - Per-Profile Tab Colors.md

@@ -0,0 +1,146 @@
+---
+author: Mike Griese @zadjii-msft
+created on: 2020-07-31
+last updated: 2020-08-03
+issue id: #1337
+---
+# Per-Profile Tab Colors
+
+## Abstract
+
+This spec describes a way to specify tab colors in a profile in a way that will
+be forward compatible with theming the Terminal. This spec will be largely
+dedicated to the design of a single setting, but within the context of theming.
+
+## Inspiration
+
+Following the addition of the Tab Color Picker in [#3789], we've had numerous
+requests for the ability to set the color of a tab directly within a profile.
+While largely we're tracking theming in [#3327], including the specification of
+a tab color, the theming spec ([#5772] )is very large and will take a while to
+revise and approve. This spec is intended to pull a single point out from that
+spec to make it more easily reviewable, and implement it in a way that will
+continue working when we add support for themes in the future.
+
+## Solution Design
+
+To enable per-profile tab colors, we'll add a single setting: `tabColor`. For
+now<sup>[[1](#user-content-footnote-1)]</sup>, this setting will accept any
+`#rrggbb` color string.
+
+Since each profile creates a `Pane` with a `TermControl`, we'll need to store
+this color not in the `Tab`, but somewhere below `Pane`, so that when you switch
+between Panes in a tab with different `tabColor`s, the color will update
+automatically. When a new `TermControl` is created, we'll store this color in the
+`TermControl`'s `Terminal` core. This is to support the future possibility of
+setting the tab color via VT sequences.
+
+A Tab's color will be the result of layering a variety of sources, from the bottom up:
+
+Color | | Set by
+-- | -- | --
+Runtime Color | _optional_ |Color Picker / `setTabColor` action
+Control Tab Color | _optional_ | Profile's `tabColor`, or a color set by VT
+Theme Tab Background | _optional_ | `tab.backgroundColor` in the theme
+Tab Default Color | **default** | TabView in XAML
+
+Some examples:
+* **Scenario 1**: The user has set `"tabColor": "#ff0000"` in their profile.
+  When they create tabs with that profile, instead of appearing in the default
+  color for the TabView, they'll be `#ff0000`.
+* **Scenario 2**: The user has set `"tabColor": "#ff0000"` in their profile.
+  When they try to set the color for that tab (with the color picker) to
+  `#0000ff`, the tab's color is updated to reflect this new blue color. When
+  they clear the runtime color (with the color picker), the tab will return to
+  `#ff0000`.
+* **Scenario 3**: The user has two profiles with colors set, one to `"tabColor":
+  "#ff0000"`, and the other with `"tabColor": "#00ff00"`. If they open these
+  profiles in two panes side-by side, the tab's color will update to reflect the
+  color from the currently-focused control.
+* **Scenario 4**: The user has two profiles with colors set, one to `"tabColor":
+  "#ff0000"`, and the other with `"tabColor": "#00ff00"`. If they open these
+  profiles in two panes side-by side, and try to set the color for that tab
+  (with the color picker) to `#0000ff`, the tab's color is updated to reflect
+  this new blue color. Regardless of which pane is focused, the tab will be
+  blue.
+* **Scenario 5**: The user has set `"tabColor": "#ff0000"` in their profile
+  ("Profile A"), and `"tab.backgroundColor": "#00ff00"`in their theme. When they
+  create tabs with "Profile A", the tabs will appear red. Other tabs (for
+  profiles without `tabColor` set) will appear green, using the color from the
+  theme.
+
+
+## UI/UX Design
+
+In general, this is going to look exactly like the colored tabs look now.
+
+![preview](profile-tabColor-000.gif)
+
+## Capabilities
+
+<table>
+<tr>
+<td><strong>Accessibility</strong></td>
+<td>
+N/A
+</td>
+</tr>
+<tr>
+<td><strong>Security</strong></td>
+<td>
+N/A
+</td>
+</tr>
+<tr>
+<td><strong>Reliability</strong></td>
+<td>
+No expected change
+</td>
+</tr>
+<tr>
+<td><strong>Compatibility</strong></td>
+<td>
+This entire spec outlines how this feature is designed with a emphasis on future
+compatibility. As such, there are no expected regressions in the future when we
+do add support for themes.
+</td>
+</tr>
+<tr>
+<td><strong>Performance, Power, and Efficiency</strong></td>
+<td>
+No expected change
+</td>
+</tr>
+</table>
+
+## Potential Issues
+
+None expected.
+
+## Footnotes
+
+<a id="footnote-1"><a>[1]: When full theming support is added, themes will
+provide support for setting colors as one of a variety of values:
+
+  * An `#rrggbb` string
+  * The system accent color
+  * The current background color of the Terminal
+  * A value from a given resource key from XAML
+
+When support for these other types of "smart" colors is added, then the profile
+`tabColor` setting will also gracefully accept these values.
+
+## Future considerations
+
+* It's not out of the realm of possibility that someone might want to color each
+  _pane_'s color at runtime. In that case, the runtime color would be stored in
+  the `Pane`, not the `Tab`.
+
+
+
+<!-- Footnotes -->
+
+[#1337]: https://github.com/microsoft/terminal/issues/1337
+[#3789]: https://github.com/microsoft/terminal/issues/3789
+[#3327]: https://github.com/microsoft/terminal/issues/3327
+[#5772]: https://github.com/microsoft/terminal/pull/5772

doc/specs/#1571 - New Tab Menu Customization/#1571 - New Tab Menu Customization.md

@@ -0,0 +1,300 @@
+---
+author: Mike Griese @zadjii-msft
+created on: 2020-5-13
+last updated: 2020-08-04
+issue id: 1571
+---
+
+# New Tab Menu Customization
+
+## Abstract
+
+Many users have lots and _lots_ of profiles that they use. Some of these
+profiles the user might not use that frequently. When that happens, the new tab
+dropdown can become quite cluttered.
+
+A common ask is for the ability to reorder and reorganize this dropdown. This
+spec provides a design for how the user might be able to specify the
+customization in their settings.
+
+## Inspiration
+
+Largely, this spec was inspired by discussion in
+[#1571](https://github.com/microsoft/terminal/issues/1571#issuecomment-519504048)
+and the _many_ linked threads.
+
+## Solution Design
+
+This design proposes adding a new setting `"newTabMenu"`. When unset, (the
+default), the new tab menu is populated with all the profiles, in the order they
+appear in the users settings file. When set, this enables the user to control
+the appearance of the new tab dropdown. Let's take a look at an example:
+
+```json
+{
+    "profiles":{ ... },
+    "newTabMenu": [
+        { "type":"profile", "profile": "cmd" },
+        { "type":"profile", "profile": "Windows PowerShell" },
+        { "type":"separator" },
+        {
+            "type":"folder",
+            "name": "ssh",
+            "icon": "C:\\path\\to\\icon.png",
+            "entries":[
+                { "type":"profile", "profile": "Host 1" },
+                { "type":"profile", "profile": "8.8.8.8" },
+                { "type":"profile", "profile": "Host 2" }
+            ]
+        },
+        { "type":"separator" },
+        { "type":"profile", "profile": "Ubuntu-18.04" },
+        { "type":"profile", "profile": "Fedora" }
+    ]
+}
+```
+
+If a user were to use this as their new tab menu, that they would get is a menu
+that looks like this:
+
+![fig 1](Menu-Customization-000.png)
+
+_fig 1_: A _very rough_ mockup of what this feature might look like
+
+There are five `type`s of objects in this menu:
+* `"type":"profile"`: This is a profile. Clicking on this entry will open a new
+  tab, with that profile. The profile is identified with the `"profile"`
+  parameter, which accepts either a profile `name` or GUID. The icon for this
+  entry will be the profile's icon, and the text on the entry will be the
+  profile's name.
+* `"type":"separator"`: This represents a XAML `MenuFlyoutSeparator`, enabling
+  the user to visually space out entries.
+* `"type":"folder"`: This represents a nested menu of entries.
+  - The `"name"` property provides a string of text to display for the group.
+  - The `"icon"` property provides a path to a image to use as the icon. This
+    property is optional.
+  - The `"entries"` property specifies a list of menu entries that will appear
+    nested under this entry. This can contain other `"type":"folder"` groups as
+    well!
+* `"type":"action"`: This represents a menu entry that should execute a specific
+  `ShortcutAction`.
+  - the `id` property will specify the global action ID (see [#6899], [#7175])
+    to identify the action to perform when the user selects the entry. Actions
+    with invalid IDs will be ignored and omitted from the list.
+  - The text for this entry will be the action's label (which is
+    either provided as the `"name"` in the global list of actions, or the
+    generated name if no `name` was provided)
+  - The icon for this entry will similarly re-use the action's `icon`.
+* `"type":"remainingProfiles"`: This is a special type of entry that will be
+  expanded to contain one `"type":"profile"` entry for every profile that was
+  not already listed in the menu. This will allow users to add one entry for
+  just "all the profiles they haven't manually added to the menu".
+  - This type of entry can only be specified once - trying to add it to the menu
+    twice will raise a warning, and ignore all but the first `remainingProfiles`
+    entry.
+  - This type of entry can also be set inside a `folder` entry, allowing users
+    to highlight only a couple profiles in the top-level of the menu, but
+    enabling all other profiles to also be accessible.
+  - The "name" of these entries will simply be the name of the profile
+  - The "icon" of these entries will simply be the profile's icon
+
+The "default" new tab menu could be imagined as the following blob of json:
+
+```json
+{
+    "newTabMenu": [
+        { "type":"remainingProfiles" }
+    ]
+}
+```
+
+### Other considerations
+
+Also considered during the investigation for this feature was re-using the list
+of profiles to expose the structure of the new tab menu. For example, doing
+something like:
+
+```json
+"profiles": {
+  "defaults": {},
+  "list":
+  [
+    { "name": "cmd" },
+    { "name": "powershell" },
+    { "type": "separator" },
+    {
+      "type": "folder" ,
+      "profiles": [
+        { "name": "ubuntu" }
+      ]
+    }
+  ]
+}
+```
+
+This option was not pursued because we felt that it needlessly complicated the
+contents of the list of profiles objects. We'd rather have the `profiles` list
+exclusively contain `Profile` objects, and have other elements of the json
+_refer_ to those profiles. What if someone would like to have an action that
+opened a new tab with profile index 4, and then they set that action as entry 4
+in the profile's list? That would certainly be some sort of unexpected behavior.
+
+Additionally, what if someone wants to have an entry that opens a tab with one
+pane with one profile in it, and another pane with different profile in it? Or
+what if they want the same profile to appear twice in the menu?
+
+By overloading the structure of the `profiles` list, we're forcing all other
+consumers of the list of profiles to care about the structure of the elements of
+the list. These other consumers should only really care about the list of
+profiles, and not necessarily how they're structured in the new tab dropdown.
+Furthermore, it complicates the list of profiles, by adding actions intermixed
+with the profiles.
+
+The design chosen in this spec more cleanly separates the responsibilities of
+the list of profiles and the contents of the new tab menu. This way, each object
+can be defined independent of the structure of the other.
+
+## UI/UX Design
+
+See the above _figure 1_.
+
+The profile's `icon` will also appear as the icon on `profile` entries. If
+there's a keybinding bound to open a new tab with that profile, then that will
+also be added to the `MenuFlyoutItem` as the accelerator text, similar to the
+text we have nowadays.
+
+Beneath the list of profiles will _always_ be the same "Settings", "Feedback"
+and "About" entries, separated by a `MenuFlyoutSeparator`. This is consistent
+with the UI as it exists with no customization. These entries cannot be removed
+with this feature, only the list of profiles customized.
+
+## Capabilities
+
+### Accessibility
+
+This menu will be added to the XAML tree in the same fashion as the current new
+tab flyout, so there should be no dramatic change here.
+
+### Security
+
+_(no change expected)_
+
+### Reliability
+
+_(no change expected)_
+
+### Compatibility
+
+_(no change expected)_
+
+### Performance, Power, and Efficiency
+
+_(no change expected)_
+
+## Potential Issues
+
+Currently, the `openTab` and `splitPane` keybindings will accept a `index`
+parameter to say either:
+* "Create a new tab/pane with the N'th profile"
+* "Create a new tab/pane with the profile at index N in the new
+tab dropdown".
+
+These two were previously synonymous, as the N'th profile was always the N'th in
+the dropdown. However, with this change, we'll be changing the meaning of that
+argument to mean explicitly the first option - "Open a tab/pane with the N'th
+profile".
+
+A previous version of this spec considered changing the meaning of that
+parameter to mean "open the entry at index N", the second option. However, in
+[Command Palette, Addendum 1], we found that naming that command would become
+unnecessarily complex.
+
+To cover that above scenario, we could consider adding an `index` parameter to
+the `openNewTabDropdown` action. If specified, that would open either the N'th
+action in the dropdown (ignoring separators), or open the dropdown with the n'th
+item selected.
+
+The N'th entry in the menu won't always be a profile: it might be a folder with
+more options, or it might be an action (that might not be opening a new tab/pane
+at all).
+
+Given all the above scenarios, `openNewTabDropdown` with an `"index":N`
+parameter will behave in the following ways. If the Nth top-level entry in the
+new tab menu is a:
+* `"type":"profile"`: perform the `newTab` or `splitPane` action with that profile.
+* `"type":"folder"`: Focus the first element in the sub menu, so the user could
+  navigate it with the keyboard.
+* `"type":"separator"`: Ignore these when counting top-level entries.
+* `"type":"action"`: Perform the action.
+
+So for example:
+
+```
+New Tab Button ▽
+├─ Folder 1
+│  └─ Profile A
+│  └─ Action B
+├─ Separator
+├─ Folder 2
+│  └─ Profile C
+│  └─ Profile D
+├─ Action E
+└─ Profile F
+```
+
+And assuming the user has bound:
+```json
+{
+  "bindings":
+  [
+    { "command": { "action": "openNewTabDropdown", "index": 0 }, "keys": "ctrl+shift+1" },
+    { "command": { "action": "openNewTabDropdown", "index": 1 }, "keys": "ctrl+shift+2" },
+    { "command": { "action": "openNewTabDropdown", "index": 2 }, "keys": "ctrl+shift+3" },
+    { "command": { "action": "openNewTabDropdown", "index": 3 }, "keys": "ctrl+shift+4" },
+  ]
+}
+```
+
+* <kbd>ctrl+shift+1</kbd> focuses "Profile A", but the user needs to press
+  enter/space to creates a new tab/split
+* <kbd>ctrl+shift+2</kbd> focuses "Profile C", but the user needs to press
+  enter/space to creates a new tab/split
+* <kbd>ctrl+shift+3</kbd> performs Action E
+* <kbd>ctrl+shift+4</kbd> Creates a new tab/split with Profile F
+
+## Future considerations
+
+* The user could set a `"name"`/`"text"`, or `"icon"` property to these menu
+  items manually, to override the value from the profile or action. These
+  settings would be totally optional, but it's not unreasonable that someone
+  might want this.
+* We may want to consider adding a default icon for all folders or actions in
+  the menu. For example, a folder (like 📁) for `folder` entries, or something
+  like ⚡ for actions. We'll leave these unset by default, and evaluate setting
+  these icons by default in the future.
+* Something considered during review was a way to specify "All my WSL profiles".
+  Maybe the user wants to have all their profiles generated by the WSL Distro
+  Generator appear in a "WSL" folder. This would likely require a more elaborate
+  filtering syntax, to be able to select only profiles where a certain property
+  has a specific value. Consider the user who has multiple "SSH
+  me@\<some host\>.com" profiles, and they want all their "SSH\*" profiles to
+  appear in an "SSH" folder. This feels out-of-scope for this spec.
+* A similar structure could potentially also be used for customizing the context
+  menu within a control, or the context menu for the tab. (see [#3337])
+  - In both of those cases, it might be important to somehow refer to the
+    context of the current tab or control in the json. Think for example about
+    "Close tab" or "Close other tabs" - currently, those work by _knowing_ which
+    tab the "action" is specified for, not by actually using a `closeTab` action.
+    In the future, they might need to be implemented as something like
+    - Close Tab: `{ "action": "closeTab", "index": "${selectedTab.index}" }`
+    - Close Other Tabs: `{ "action": "closeTabs", "otherThan": "${selectedTab.index}" }`
+    - Close Tabs to the Right: `{ "action": "closeTabs", "after": "${selectedTab.index}" }`
+
+
+<!-- Footnotes -->
+[#2046]: https://github.com/microsoft/terminal/issues/2046
+[Command Palette, Addendum 1]: https://github.com/microsoft/terminal/blob/master/doc/specs/%232046%20-%20Unified%20keybindings%20and%20commands%2C%20and%20synthesized%20action%20names.md
+
+[#3337]: https://github.com/microsoft/terminal/issues/3337
+[#6899]: https://github.com/microsoft/terminal/issues/6899
+[#7175]: https://github.com/microsoft/terminal/issues/7175

doc/specs/#6899 - Action IDs/#6899 - Action IDs.md

@@ -0,0 +1,228 @@
+---
+author: Mike Griese @zadjii-msft
+created on: 2020-07-13
+last updated: 2020-07-22
+issue id: 6899
+---
+
+# Action IDs
+
+## Abstract
+
+This document is intended to serve as an addition to the [Command Palette Spec],
+as well as the [New Tab Menu Customization Spec].
+
+As we come to rely more on actions being a mechanism by which the user defines
+"do something in the Terminal", we'll want to make it even easier for users to
+re-use the actions that they've already defined, as to reduce duplicated json as
+much as possible. This spec proposes a mechanism by which actions could be
+uniquely identifiable, so that the user could refer to bindings in other
+contexts without needing to replicate an entire json blob.
+
+## Solution Design
+
+This spec was largely inspired by the following diagram from @DHowett:
+
+![figure 1](data-mockup.png)
+
+The goal is to introduce an `id` parameter by which actions could be uniquely
+refered to. If we'd ever like to use an action outside the list of `actions`, we
+can simply refer to the action's ID, allowing the user to only define the action
+_once_.
+
+We'll start by renaming `bindings` to `actions`. `bindings` was suggested as a
+rename for `keybindings` in [#6532], as a way to make the name more generic.
+Discussion with the team lead to the understanding that the name `actions` would
+be even better, as a way of making the meaning of the "list of actions" more
+obvious.
+
+When we're parsing `actions`, we'll make three passes:
+* The first pass will scan the list for objects with an `id` property. We'll
+  attempt to parse those entries into `ActionAndArgs` which we'll store in the
+  global `id->ActionAndArgs` map. If any entry doesn't have an `id` set, we'll
+  skip it in this phase. If an entry doesn't have a `command` set, we'll ignore
+  it in this pass.
+* The second pass will scan for _keybindings_. Any entries with `keys` set will
+  create a `KeyChord->ActionAndArgs` entry in the keybindings map. If the entry
+  has an `id` set, then we'll simply re-use the action we've already parsed for
+  the `id`, from the action map. If there isn't an `id`, then we'll parse the
+  action manually at this time. Entries without a `keys` set will be ignored in
+  this pass.
+* The final pass will be to generate _commands_. Similar to the keybindings
+  pass, we'll attempt to lookup actions for entries with an `id` set. If there
+  isn't an `id`, then we'll parse the action manually at this time. We'll then
+  get the name for the entry, either from the `name` property if it's set, or
+  the action's `GenerateName` method.
+
+For a visual representation, let's assume the user has the following in their
+`actions`:
+
+![figure 2](data-mockup-actions.png)
+
+We'll first parse the `actions` to generate the mapping of `id`->`Actions`:
+
+![figure 3](data-mockup-actions-and-ids.png)
+
+Then, we'll parse the `actions` to generate the mapping of keys to actions, with
+some actions already being defined in the map of `id`->`Actions`:
+
+![figure 4](data-mockup-actions-and-ids-and-keys.png)
+
+
+When layering `actions`, if a later settings file contains an action with the
+same `id`, it will replace the current value. In this way, users can redefine
+actions, or remove default ones (with something like `{ "id":
+"Terminal.OpenTab", "command":null }`
+
+We'd maintain a large list of default actions, each with unique `id`s set. These
+are all given `id`'s with a `Terminal.` prefix, to easily identify them as
+built-in, default actions. Not all of these actions will be given keys, but they
+will all be given `id`s.
+
+> 👉 NOTE: The IDs for the default actions will need to be manually created, not
+> autogenerated. These `id`s are not strings displayed in the user interface, so
+> localization is not a concern.
+
+As we add additional menus to the Terminal, like the customization for the new
+tab dropdown, or the tab context menu, or the `TermControl` context menu, they
+could all refer to these actions by `id`, rather than duplicating the same json.
+
+
+### Existing Scenarios
+
+Keybindings will still be stored as a `keys->Action` mapping, so the user will
+still be able to override default keybindings exactly the same as before.
+
+Similarly, commands in the Command Palette will continue using their existing
+`name->Action` mapping they're currently using. For a binding like
+
+```json
+{ "keys": "ctrl+alt+x", "id": "Terminal.OpenDefaultSettings" },
+```
+* We'll bind whatever action is defined as `Terminal.OpenDefaultSettings` to
+  <kbd>ctrl+alt+x</kbd>.
+* We'll use whatever action is defined as `Terminal.OpenDefaultSettings` to
+  generate a name for the command palette.
+
+### Future Context Menus
+
+In [New Tab Menu Customization Spec], we discuss allowing the user to bind
+actions to the new tab menu. In that spec, they can do so with something like
+the following:
+
+```json
+{
+    "newTabMenu": [
+        { "type":"action", "command": { "action": "adjustFontSize", "delta": 1 }, }
+        { "type":"action", "command": { "action": "adjustFontSize", "delta": -1 }, }
+        { "type":"action", "command": "resetFontSize", }
+        { "type":"profile", "profile": "cmd" },
+        { "type":"profile", "profile": "Windows PowerShell" },
+        { "type":"separator" },
+        {
+            "type":"folder",
+            "name": "Settings...",
+            "icon": "C:\\path\\to\\icon.png",
+            "entries":[
+                { "type":"action", "command": "openSettings" },
+                { "type":"action", "command": { "action": "openSettings", "target": "defaultsFile" } },
+            ]
+        }
+    ]
+}
+```
+
+In this example, the user has also exposed the "Increase font size", "Decrease
+font size", and "Reset font size" actions, as well as the settings files in a
+submenu. With this proposal, the above could instead be re-written as:
+
+```json
+{
+    "newTabMenu": [
+        { "type":"action", "id": "Terminal.IncreaseFontSize" },
+        { "type":"action", "id": "Terminal.DecreaseFontSize" },
+        { "type":"action", "id": "Terminal.ResetFontSize" },
+        { "type":"profile", "profile": "cmd" },
+        { "type":"profile", "profile": "Windows PowerShell" },
+        { "type":"separator" },
+        {
+            "type":"folder",
+            "name": "Settings...",
+            "icon": "C:\\path\\to\\icon.png",
+            "entries":[
+                { "type":"action", "id": "Terminal.OpenDefaultSettings" },
+                { "type":"action", "id": "Terminal.OpenSettings" },
+            ]
+        }
+    ]
+}
+```
+
+In this example, the actions are looked up from the global map using the `id`
+provided, enabling the user to re-use their existing definitions. If the user
+re-defined the `Terminal.IncreaseFontSize` action to mean something else, then
+the action in the new tab menu will also be automatically updated.
+
+Furthermore, when additional menus are added (such as the tab context menu, or
+the `TermControl` context menu), these could also leverage a similar syntax to
+the above to allow re-use of the `id` parameter.
+
+Discussion with the team also suggested that users shouldn't be able to define
+actions in these menus _at all_. The actions should exclusively be defined in
+`actions`, and other menus should only be able to refer to these actions by
+`id`.
+
+## UI/UX Design
+
+There's not a whole lot of UI for this feature specifically. This is largely
+behind-the-scenes refactoring of how actions can be defined.
+
+## Capabilities
+
+### Accessibility
+
+_(not applicable)_
+
+### Security
+
+_(no change expected)_
+
+### Reliability
+
+_(no change expected)_
+
+### Compatibility
+
+_(no change expected)_
+
+### Performance, Power, and Efficiency
+
+_(no change expected)_
+
+## Potential Issues
+
+This won't necessarily play well with iterable commands in the Command Palette,
+but that's okay. For iterable commands, users will still need to define the
+actions manually.
+
+## Future considerations
+
+* See the following issues for other places where this might be useful:
+  - [#1912] - Context Menu for Tabs
+    * See also [#5524], [#5025], [#5633]
+  - [#3337] - Right-click menu inside TerminalControl (w/ Copy & Paste?)
+    * See also [#5633] and [#5025], both those actions seem reasonable in either
+      the tab context menu or the control context menu.
+
+<!-- Footnotes -->
+[Command Palette Spec]: https://github.com/microsoft/terminal/blob/master/doc/specs/%232046%20-%20Command%20Palette.md
+[New Tab Menu Customization Spec]: https://github.com/microsoft/terminal/blob/master/doc/specs/%231571%20-%20New%20Tab%20Menu%20Customization.md
+
+[#1571]: https://github.com/microsoft/terminal/issues/1571
+[#1912]: https://github.com/microsoft/terminal/issues/1912
+[#3337]: https://github.com/microsoft/terminal/issues/3337
+[#5025]: https://github.com/microsoft/terminal/issues/5025
+[#5524]: https://github.com/microsoft/terminal/issues/5524
+[#5633]: https://github.com/microsoft/terminal/issues/5633
+[#6532]: https://github.com/microsoft/terminal/issues/6532
+[#6899]: https://github.com/microsoft/terminal/issues/6899

res/README.md

@@ -17,5 +17,5 @@ Please consult the [license](https://raw.githubusercontent.com/microsoft/cascadi
 
 ### Fonts Included
 
-* Cascadia Code, Cascadia Mono (2008.25)
-   * from microsoft/cascadia-code@678eea921b0c8b921b9fb009bb16d3d2ca5b8112
+* Cascadia Code, Cascadia Mono (2009.21)
+   * from microsoft/cascadia-code@32f84124db1970fa5d032f0fe9019e6922961beb

src/buffer/out/Row.cpp

@@ -160,66 +160,98 @@ OutputCellIterator ROW::WriteCells(OutputCellIterator it, const size_t index, co
     // If we're given a right-side column limit, use it. Otherwise, the write limit is the final column index available in the char row.
     const auto finalColumnInRow = limitRight.value_or(_charRow.size() - 1);
 
-    while (it && currentIndex <= finalColumnInRow)
+    if (it)
     {
-        // Fill the color if the behavior isn't set to keeping the current color.
-        if (it->TextAttrBehavior() != TextAttributeBehavior::Current)
+        // Accumulate usages of the same color so we can spend less time in InsertAttrRuns rewriting it.
+        auto currentColor = it->TextAttr();
+        size_t colorUses = 0;
+        size_t colorStarts = index;
+
+        while (it && currentIndex <= finalColumnInRow)
         {
-            const TextAttributeRun attrRun{ 1, it->TextAttr() };
-            LOG_IF_FAILED(_attrRow.InsertAttrRuns({ &attrRun, 1 },
-                                                  currentIndex,
-                                                  currentIndex,
-                                                  _charRow.size()));
-        }
-
-        // Fill the text if the behavior isn't set to saying there's only a color stored in this iterator.
-        if (it->TextAttrBehavior() != TextAttributeBehavior::StoredOnly)
-        {
-            const bool fillingLastColumn = currentIndex == finalColumnInRow;
-
-            // TODO: MSFT: 19452170 - We need to ensure when writing any trailing byte that the one to the left
-            // is a matching leading byte. Likewise, if we're writing a leading byte, we need to make sure we still have space in this loop
-            // for the trailing byte coming up before writing it.
-
-            // If we're trying to fill the first cell with a trailing byte, pad it out instead by clearing it.
-            // Don't increment iterator. We'll advance the index and try again with this value on the next round through the loop.
-            if (currentIndex == 0 && it->DbcsAttr().IsTrailing())
+            // Fill the color if the behavior isn't set to keeping the current color.
+            if (it->TextAttrBehavior() != TextAttributeBehavior::Current)
             {
-                _charRow.ClearCell(currentIndex);
+                // If the color of this cell is the same as the run we're currently on,
+                // just increment the counter.
+                if (currentColor == it->TextAttr())
+                {
+                    ++colorUses;
+                }
+                else
+                {
+                    // Otherwise, commit this color into the run and save off the new one.
+                    const TextAttributeRun run{ colorUses, currentColor };
+                    // Now commit the new color runs into the attr row.
+                    LOG_IF_FAILED(_attrRow.InsertAttrRuns({ &run, 1 },
+                                                          colorStarts,
+                                                          currentIndex - 1,
+                                                          _charRow.size()));
+                    currentColor = it->TextAttr();
+                    colorUses = 1;
+                    colorStarts = currentIndex;
+                }
             }
-            // If we're trying to fill the last cell with a leading byte, pad it out instead by clearing it.
-            // Don't increment iterator. We'll exit because we couldn't write a lead at the end of a line.
-            else if (fillingLastColumn && it->DbcsAttr().IsLeading())
+
+            // Fill the text if the behavior isn't set to saying there's only a color stored in this iterator.
+            if (it->TextAttrBehavior() != TextAttributeBehavior::StoredOnly)
             {
-                _charRow.ClearCell(currentIndex);
-                _charRow.SetDoubleBytePadded(true);
+                const bool fillingLastColumn = currentIndex == finalColumnInRow;
+
+                // TODO: MSFT: 19452170 - We need to ensure when writing any trailing byte that the one to the left
+                // is a matching leading byte. Likewise, if we're writing a leading byte, we need to make sure we still have space in this loop
+                // for the trailing byte coming up before writing it.
+
+                // If we're trying to fill the first cell with a trailing byte, pad it out instead by clearing it.
+                // Don't increment iterator. We'll advance the index and try again with this value on the next round through the loop.
+                if (currentIndex == 0 && it->DbcsAttr().IsTrailing())
+                {
+                    _charRow.ClearCell(currentIndex);
+                }
+                // If we're trying to fill the last cell with a leading byte, pad it out instead by clearing it.
+                // Don't increment iterator. We'll exit because we couldn't write a lead at the end of a line.
+                else if (fillingLastColumn && it->DbcsAttr().IsLeading())
+                {
+                    _charRow.ClearCell(currentIndex);
+                    _charRow.SetDoubleBytePadded(true);
+                }
+                // Otherwise, copy the data given and increment the iterator.
+                else
+                {
+                    _charRow.DbcsAttrAt(currentIndex) = it->DbcsAttr();
+                    _charRow.GlyphAt(currentIndex) = it->Chars();
+                    ++it;
+                }
+
+                // If we're asked to (un)set the wrap status and we just filled the last column with some text...
+                // NOTE:
+                //  - wrap = std::nullopt    --> don't change the wrap value
+                //  - wrap = true            --> we're filling cells as a steam, consider this a wrap
+                //  - wrap = false           --> we're filling cells as a block, unwrap
+                if (wrap.has_value() && fillingLastColumn)
+                {
+                    // set wrap status on the row to parameter's value.
+                    _charRow.SetWrapForced(wrap.value());
+                }
             }
-            // Otherwise, copy the data given and increment the iterator.
             else
             {
-                _charRow.DbcsAttrAt(currentIndex) = it->DbcsAttr();
-                _charRow.GlyphAt(currentIndex) = it->Chars();
                 ++it;
             }
 
-            // If we're asked to (un)set the wrap status and we just filled the last column with some text...
-            // NOTE:
-            //  - wrap = std::nullopt    --> don't change the wrap value
-            //  - wrap = true            --> we're filling cells as a steam, consider this a wrap
-            //  - wrap = false           --> we're filling cells as a block, unwrap
-            if (wrap.has_value() && fillingLastColumn)
-            {
-                // set wrap status on the row to parameter's value.
-                _charRow.SetWrapForced(wrap.value());
-            }
-        }
-        else
-        {
-            ++it;
+            // Move to the next cell for the next time through the loop.
+            ++currentIndex;
         }
 
-        // Move to the next cell for the next time through the loop.
-        ++currentIndex;
+        // Now commit the final color into the attr row
+        if (colorUses)
+        {
+            const TextAttributeRun run{ colorUses, currentColor };
+            LOG_IF_FAILED(_attrRow.InsertAttrRuns({ &run, 1 },
+                                                  colorStarts,
+                                                  currentIndex - 1,
+                                                  _charRow.size()));
+        }
     }
 
     return it;

src/buffer/out/TextAttribute.cpp

@@ -246,8 +246,12 @@ bool TextAttribute::IsCrossedOut() const noexcept
 
 bool TextAttribute::IsUnderlined() const noexcept
 {
-    // TODO:GH#2915 Treat underline separately from LVB_UNDERSCORE
-    return WI_IsFlagSet(_wAttrLegacy, COMMON_LVB_UNDERSCORE);
+    return WI_IsFlagSet(_extendedAttrs, ExtendedAttributes::Underlined);
+}
+
+bool TextAttribute::IsDoublyUnderlined() const noexcept
+{
+    return WI_IsFlagSet(_extendedAttrs, ExtendedAttributes::DoublyUnderlined);
 }
 
 bool TextAttribute::IsOverlined() const noexcept
@@ -270,7 +274,7 @@ void TextAttribute::SetFaint(bool isFaint) noexcept
     WI_UpdateFlag(_extendedAttrs, ExtendedAttributes::Faint, isFaint);
 }
 
-void TextAttribute::SetItalics(bool isItalic) noexcept
+void TextAttribute::SetItalic(bool isItalic) noexcept
 {
     WI_UpdateFlag(_extendedAttrs, ExtendedAttributes::Italics, isItalic);
 }
@@ -290,13 +294,17 @@ void TextAttribute::SetCrossedOut(bool isCrossedOut) noexcept
     WI_UpdateFlag(_extendedAttrs, ExtendedAttributes::CrossedOut, isCrossedOut);
 }
 
-void TextAttribute::SetUnderline(bool isUnderlined) noexcept
+void TextAttribute::SetUnderlined(bool isUnderlined) noexcept
 {
-    // TODO:GH#2915 Treat underline separately from LVB_UNDERSCORE
-    WI_UpdateFlag(_wAttrLegacy, COMMON_LVB_UNDERSCORE, isUnderlined);
+    WI_UpdateFlag(_extendedAttrs, ExtendedAttributes::Underlined, isUnderlined);
 }
 
-void TextAttribute::SetOverline(bool isOverlined) noexcept
+void TextAttribute::SetDoublyUnderlined(bool isDoublyUnderlined) noexcept
+{
+    WI_UpdateFlag(_extendedAttrs, ExtendedAttributes::DoublyUnderlined, isDoublyUnderlined);
+}
+
+void TextAttribute::SetOverlined(bool isOverlined) noexcept
 {
     WI_UpdateFlag(_wAttrLegacy, COMMON_LVB_GRID_HORIZONTAL, isOverlined);
 }

src/buffer/out/TextAttribute.hpp

@@ -95,17 +95,19 @@ public:
     bool IsInvisible() const noexcept;
     bool IsCrossedOut() const noexcept;
     bool IsUnderlined() const noexcept;
+    bool IsDoublyUnderlined() const noexcept;
     bool IsOverlined() const noexcept;
     bool IsReverseVideo() const noexcept;
 
     void SetBold(bool isBold) noexcept;
     void SetFaint(bool isFaint) noexcept;
-    void SetItalics(bool isItalic) noexcept;
+    void SetItalic(bool isItalic) noexcept;
     void SetBlinking(bool isBlinking) noexcept;
     void SetInvisible(bool isInvisible) noexcept;
     void SetCrossedOut(bool isCrossedOut) noexcept;
-    void SetUnderline(bool isUnderlined) noexcept;
-    void SetOverline(bool isOverlined) noexcept;
+    void SetUnderlined(bool isUnderlined) noexcept;
+    void SetDoublyUnderlined(bool isDoublyUnderlined) noexcept;
+    void SetOverlined(bool isOverlined) noexcept;
     void SetReverseVideo(bool isReversed) noexcept;
 
     ExtendedAttributes GetExtendedAttributes() const noexcept;
@@ -218,11 +220,12 @@ namespace WEX
             static WEX::Common::NoThrowString ToString(const TextAttribute& attr)
             {
                 return WEX::Common::NoThrowString().Format(
-                    L"{FG:%s,BG:%s,bold:%d,wLegacy:(0x%04x)}",
+                    L"{FG:%s,BG:%s,bold:%d,wLegacy:(0x%04x),ext:(0x%02x)}",
                     VerifyOutputTraits<TextColor>::ToString(attr._foreground).GetBuffer(),
                     VerifyOutputTraits<TextColor>::ToString(attr._background).GetBuffer(),
                     attr.IsBold(),
-                    attr._wAttrLegacy);
+                    attr._wAttrLegacy,
+                    static_cast<DWORD>(attr._extendedAttrs));
             }
         };
     }

src/buffer/out/UnicodeStorage.cpp

@@ -35,12 +35,7 @@ void UnicodeStorage::StoreGlyph(const key_type key, const mapped_type& glyph)
 // - erases key and its associated data from the storage
 // Arguments:
 // - key - the key to remove
-// ~~~~~~~~~~~~~~
-// NOTE: VS 16.7 changes std::map::erase to noexcept, but the build agents are still 16.6.5.
-// Ignore this audit warning on your dev box until the build starts failing. Then fix it
-// and remove this comment.
-// ~~~~~~~~~~~~~
-void UnicodeStorage::Erase(const key_type key)
+void UnicodeStorage::Erase(const key_type key) noexcept
 {
     _map.erase(key);
 }

src/buffer/out/UnicodeStorage.hpp

@@ -53,7 +53,7 @@ public:
 
     void StoreGlyph(const key_type key, const mapped_type& glyph);
 
-    void Erase(const key_type key);
+    void Erase(const key_type key) noexcept;
 
     void Remap(const std::unordered_map<SHORT, SHORT>& rowMap, const std::optional<SHORT> width);
 

src/buffer/out/textBuffer.cpp

@@ -787,7 +787,7 @@ const Cursor& TextBuffer::GetCursor() const noexcept
     return _currentAttributes;
 }
 
-void TextBuffer::SetCurrentAttributes(const TextAttribute currentAttributes) noexcept
+void TextBuffer::SetCurrentAttributes(const TextAttribute& currentAttributes) noexcept
 {
     _currentAttributes = currentAttributes;
 }

src/buffer/out/textBuffer.hpp

@@ -118,7 +118,7 @@ public:
 
     [[nodiscard]] TextAttribute GetCurrentAttributes() const noexcept;
 
-    void SetCurrentAttributes(const TextAttribute currentAttributes) noexcept;
+    void SetCurrentAttributes(const TextAttribute& currentAttributes) noexcept;
 
     void Reset();
 

src/cascadia/LocalTests_TerminalApp/ColorSchemeTests.cpp

@@ -9,6 +9,7 @@
 
 using namespace Microsoft::Console;
 using namespace TerminalApp;
+using namespace winrt::TerminalApp::implementation;
 using namespace WEX::Logging;
 using namespace WEX::TestExecution;
 using namespace WEX::Common;
@@ -73,24 +74,24 @@ namespace TerminalAppLocalTests
 
         const auto scheme0 = ColorScheme::FromJson(scheme0Json);
 
-        VERIFY_IS_TRUE(scheme0.ShouldBeLayered(scheme0Json));
-        VERIFY_IS_FALSE(scheme0.ShouldBeLayered(scheme1Json));
-        VERIFY_IS_TRUE(scheme0.ShouldBeLayered(scheme2Json));
-        VERIFY_IS_FALSE(scheme0.ShouldBeLayered(scheme3Json));
+        VERIFY_IS_TRUE(scheme0->ShouldBeLayered(scheme0Json));
+        VERIFY_IS_FALSE(scheme0->ShouldBeLayered(scheme1Json));
+        VERIFY_IS_TRUE(scheme0->ShouldBeLayered(scheme2Json));
+        VERIFY_IS_FALSE(scheme0->ShouldBeLayered(scheme3Json));
 
         const auto scheme1 = ColorScheme::FromJson(scheme1Json);
 
-        VERIFY_IS_FALSE(scheme1.ShouldBeLayered(scheme0Json));
-        VERIFY_IS_TRUE(scheme1.ShouldBeLayered(scheme1Json));
-        VERIFY_IS_FALSE(scheme1.ShouldBeLayered(scheme2Json));
-        VERIFY_IS_FALSE(scheme1.ShouldBeLayered(scheme3Json));
+        VERIFY_IS_FALSE(scheme1->ShouldBeLayered(scheme0Json));
+        VERIFY_IS_TRUE(scheme1->ShouldBeLayered(scheme1Json));
+        VERIFY_IS_FALSE(scheme1->ShouldBeLayered(scheme2Json));
+        VERIFY_IS_FALSE(scheme1->ShouldBeLayered(scheme3Json));
 
         const auto scheme3 = ColorScheme::FromJson(scheme3Json);
 
-        VERIFY_IS_FALSE(scheme3.ShouldBeLayered(scheme0Json));
-        VERIFY_IS_FALSE(scheme3.ShouldBeLayered(scheme1Json));
-        VERIFY_IS_FALSE(scheme3.ShouldBeLayered(scheme2Json));
-        VERIFY_IS_FALSE(scheme3.ShouldBeLayered(scheme3Json));
+        VERIFY_IS_FALSE(scheme3->ShouldBeLayered(scheme0Json));
+        VERIFY_IS_FALSE(scheme3->ShouldBeLayered(scheme1Json));
+        VERIFY_IS_FALSE(scheme3->ShouldBeLayered(scheme2Json));
+        VERIFY_IS_FALSE(scheme3->ShouldBeLayered(scheme3Json));
     }
 
     void ColorSchemeTests::LayerColorSchemeProperties()
@@ -130,38 +131,38 @@ namespace TerminalAppLocalTests
         const auto scheme2Json = VerifyParseSucceeded(scheme2String);
 
         auto scheme0 = ColorScheme::FromJson(scheme0Json);
-        VERIFY_ARE_EQUAL(L"scheme0", scheme0._schemeName);
-        VERIFY_ARE_EQUAL(ARGB(0, 0, 0, 0), scheme0._defaultForeground);
-        VERIFY_ARE_EQUAL(ARGB(0, 1, 1, 1), scheme0._defaultBackground);
-        VERIFY_ARE_EQUAL(ARGB(0, 1, 1, 0), scheme0._selectionBackground);
-        VERIFY_ARE_EQUAL(ARGB(0, 1, 0, 1), scheme0._cursorColor);
-        VERIFY_ARE_EQUAL(ARGB(0, 1, 0, 0), scheme0._table[XTERM_RED_ATTR]);
-        VERIFY_ARE_EQUAL(ARGB(0, 0, 1, 0), scheme0._table[XTERM_GREEN_ATTR]);
-        VERIFY_ARE_EQUAL(ARGB(0, 0, 0, 1), scheme0._table[XTERM_BLUE_ATTR]);
+        VERIFY_ARE_EQUAL(L"scheme0", scheme0->_schemeName);
+        VERIFY_ARE_EQUAL(ARGB(0, 0, 0, 0), scheme0->_defaultForeground);
+        VERIFY_ARE_EQUAL(ARGB(0, 1, 1, 1), scheme0->_defaultBackground);
+        VERIFY_ARE_EQUAL(ARGB(0, 1, 1, 0), scheme0->_selectionBackground);
+        VERIFY_ARE_EQUAL(ARGB(0, 1, 0, 1), scheme0->_cursorColor);
+        VERIFY_ARE_EQUAL(ARGB(0, 1, 0, 0), scheme0->_table[XTERM_RED_ATTR]);
+        VERIFY_ARE_EQUAL(ARGB(0, 0, 1, 0), scheme0->_table[XTERM_GREEN_ATTR]);
+        VERIFY_ARE_EQUAL(ARGB(0, 0, 0, 1), scheme0->_table[XTERM_BLUE_ATTR]);
 
         Log::Comment(NoThrowString().Format(
             L"Layering scheme1 on top of scheme0"));
-        scheme0.LayerJson(scheme1Json);
+        scheme0->LayerJson(scheme1Json);
 
-        VERIFY_ARE_EQUAL(ARGB(0, 2, 2, 2), scheme0._defaultForeground);
-        VERIFY_ARE_EQUAL(ARGB(0, 3, 3, 3), scheme0._defaultBackground);
-        VERIFY_ARE_EQUAL(ARGB(0, 2, 2, 0), scheme0._selectionBackground);
-        VERIFY_ARE_EQUAL(ARGB(0, 4, 0, 4), scheme0._cursorColor);
-        VERIFY_ARE_EQUAL(ARGB(0, 2, 0, 0), scheme0._table[XTERM_RED_ATTR]);
-        VERIFY_ARE_EQUAL(ARGB(0, 0, 1, 0), scheme0._table[XTERM_GREEN_ATTR]);
-        VERIFY_ARE_EQUAL(ARGB(0, 0, 0, 2), scheme0._table[XTERM_BLUE_ATTR]);
+        VERIFY_ARE_EQUAL(ARGB(0, 2, 2, 2), scheme0->_defaultForeground);
+        VERIFY_ARE_EQUAL(ARGB(0, 3, 3, 3), scheme0->_defaultBackground);
+        VERIFY_ARE_EQUAL(ARGB(0, 2, 2, 0), scheme0->_selectionBackground);
+        VERIFY_ARE_EQUAL(ARGB(0, 4, 0, 4), scheme0->_cursorColor);
+        VERIFY_ARE_EQUAL(ARGB(0, 2, 0, 0), scheme0->_table[XTERM_RED_ATTR]);
+        VERIFY_ARE_EQUAL(ARGB(0, 0, 1, 0), scheme0->_table[XTERM_GREEN_ATTR]);
+        VERIFY_ARE_EQUAL(ARGB(0, 0, 0, 2), scheme0->_table[XTERM_BLUE_ATTR]);
 
         Log::Comment(NoThrowString().Format(
             L"Layering scheme2Json on top of (scheme0+scheme1)"));
-        scheme0.LayerJson(scheme2Json);
+        scheme0->LayerJson(scheme2Json);
 
-        VERIFY_ARE_EQUAL(ARGB(0, 4, 4, 4), scheme0._defaultForeground);
-        VERIFY_ARE_EQUAL(ARGB(0, 5, 5, 5), scheme0._defaultBackground);
-        VERIFY_ARE_EQUAL(ARGB(0, 3, 3, 0), scheme0._selectionBackground);
-        VERIFY_ARE_EQUAL(ARGB(0, 6, 0, 6), scheme0._cursorColor);
-        VERIFY_ARE_EQUAL(ARGB(0, 3, 0, 0), scheme0._table[XTERM_RED_ATTR]);
-        VERIFY_ARE_EQUAL(ARGB(0, 0, 3, 0), scheme0._table[XTERM_GREEN_ATTR]);
-        VERIFY_ARE_EQUAL(ARGB(0, 0, 0, 2), scheme0._table[XTERM_BLUE_ATTR]);
+        VERIFY_ARE_EQUAL(ARGB(0, 4, 4, 4), scheme0->_defaultForeground);
+        VERIFY_ARE_EQUAL(ARGB(0, 5, 5, 5), scheme0->_defaultBackground);
+        VERIFY_ARE_EQUAL(ARGB(0, 3, 3, 0), scheme0->_selectionBackground);
+        VERIFY_ARE_EQUAL(ARGB(0, 6, 0, 6), scheme0->_cursorColor);
+        VERIFY_ARE_EQUAL(ARGB(0, 3, 0, 0), scheme0->_table[XTERM_RED_ATTR]);
+        VERIFY_ARE_EQUAL(ARGB(0, 0, 3, 0), scheme0->_table[XTERM_GREEN_ATTR]);
+        VERIFY_ARE_EQUAL(ARGB(0, 0, 0, 2), scheme0->_table[XTERM_BLUE_ATTR]);
     }
 
     void ColorSchemeTests::LayerColorSchemesOnArray()
@@ -205,19 +206,20 @@ namespace TerminalAppLocalTests
             for (auto& kv : settings._globals._colorSchemes)
             {
                 Log::Comment(NoThrowString().Format(
-                    L"kv:%s->%s", kv.first.data(), kv.second.GetName().data()));
+                    L"kv:%s->%s", kv.first.data(), kv.second.Name().data()));
             }
             VERIFY_ARE_EQUAL(1u, settings._globals.GetColorSchemes().size());
 
             VERIFY_IS_TRUE(settings._globals._colorSchemes.find(L"scheme0") != settings._globals._colorSchemes.end());
-            auto scheme0 = settings._globals._colorSchemes.find(L"scheme0")->second;
+            auto scheme0Proj = settings._globals._colorSchemes.find(L"scheme0")->second;
+            auto scheme0 = winrt::get_self<ColorScheme>(scheme0Proj);
 
             VERIFY_IS_NOT_NULL(settings._FindMatchingColorScheme(scheme0Json));
             VERIFY_IS_NULL(settings._FindMatchingColorScheme(scheme1Json));
             VERIFY_IS_NOT_NULL(settings._FindMatchingColorScheme(scheme2Json));
             VERIFY_IS_NULL(settings._FindMatchingColorScheme(scheme3Json));
-            VERIFY_ARE_EQUAL(ARGB(0, 0, 0, 0), scheme0._defaultForeground);
-            VERIFY_ARE_EQUAL(ARGB(0, 1, 1, 1), scheme0._defaultBackground);
+            VERIFY_ARE_EQUAL(ARGB(0, 0, 0, 0), scheme0->_defaultForeground);
+            VERIFY_ARE_EQUAL(ARGB(0, 1, 1, 1), scheme0->_defaultBackground);
         }
 
         settings._LayerOrCreateColorScheme(scheme1Json);
@@ -226,18 +228,20 @@ namespace TerminalAppLocalTests
             VERIFY_ARE_EQUAL(2u, settings._globals.GetColorSchemes().size());
 
             VERIFY_IS_TRUE(settings._globals._colorSchemes.find(L"scheme0") != settings._globals._colorSchemes.end());
-            auto scheme0 = settings._globals._colorSchemes.find(L"scheme0")->second;
+            auto scheme0Proj = settings._globals._colorSchemes.find(L"scheme0")->second;
+            auto scheme0 = winrt::get_self<ColorScheme>(scheme0Proj);
             VERIFY_IS_TRUE(settings._globals._colorSchemes.find(L"scheme1") != settings._globals._colorSchemes.end());
-            auto scheme1 = settings._globals._colorSchemes.find(L"scheme1")->second;
+            auto scheme1Proj = settings._globals._colorSchemes.find(L"scheme1")->second;
+            auto scheme1 = winrt::get_self<ColorScheme>(scheme1Proj);
 
             VERIFY_IS_NOT_NULL(settings._FindMatchingColorScheme(scheme0Json));
             VERIFY_IS_NOT_NULL(settings._FindMatchingColorScheme(scheme1Json));
             VERIFY_IS_NOT_NULL(settings._FindMatchingColorScheme(scheme2Json));
             VERIFY_IS_NULL(settings._FindMatchingColorScheme(scheme3Json));
-            VERIFY_ARE_EQUAL(ARGB(0, 0, 0, 0), scheme0._defaultForeground);
-            VERIFY_ARE_EQUAL(ARGB(0, 1, 1, 1), scheme0._defaultBackground);
-            VERIFY_ARE_EQUAL(ARGB(0, 2, 2, 2), scheme1._defaultForeground);
-            VERIFY_ARE_EQUAL(ARGB(0, 3, 3, 3), scheme1._defaultBackground);
+            VERIFY_ARE_EQUAL(ARGB(0, 0, 0, 0), scheme0->_defaultForeground);
+            VERIFY_ARE_EQUAL(ARGB(0, 1, 1, 1), scheme0->_defaultBackground);
+            VERIFY_ARE_EQUAL(ARGB(0, 2, 2, 2), scheme1->_defaultForeground);
+            VERIFY_ARE_EQUAL(ARGB(0, 3, 3, 3), scheme1->_defaultBackground);
         }
         settings._LayerOrCreateColorScheme(scheme2Json);
 
@@ -245,18 +249,20 @@ namespace TerminalAppLocalTests
             VERIFY_ARE_EQUAL(2u, settings._globals.GetColorSchemes().size());
 
             VERIFY_IS_TRUE(settings._globals._colorSchemes.find(L"scheme0") != settings._globals._colorSchemes.end());
-            auto scheme0 = settings._globals._colorSchemes.find(L"scheme0")->second;
+            auto scheme0Proj = settings._globals._colorSchemes.find(L"scheme0")->second;
+            auto scheme0 = winrt::get_self<ColorScheme>(scheme0Proj);
             VERIFY_IS_TRUE(settings._globals._colorSchemes.find(L"scheme1") != settings._globals._colorSchemes.end());
-            auto scheme1 = settings._globals._colorSchemes.find(L"scheme1")->second;
+            auto scheme1Proj = settings._globals._colorSchemes.find(L"scheme1")->second;
+            auto scheme1 = winrt::get_self<ColorScheme>(scheme1Proj);
 
             VERIFY_IS_NOT_NULL(settings._FindMatchingColorScheme(scheme0Json));
             VERIFY_IS_NOT_NULL(settings._FindMatchingColorScheme(scheme1Json));
             VERIFY_IS_NOT_NULL(settings._FindMatchingColorScheme(scheme2Json));
             VERIFY_IS_NULL(settings._FindMatchingColorScheme(scheme3Json));
-            VERIFY_ARE_EQUAL(ARGB(0, 4, 4, 4), scheme0._defaultForeground);
-            VERIFY_ARE_EQUAL(ARGB(0, 5, 5, 5), scheme0._defaultBackground);
-            VERIFY_ARE_EQUAL(ARGB(0, 2, 2, 2), scheme1._defaultForeground);
-            VERIFY_ARE_EQUAL(ARGB(0, 3, 3, 3), scheme1._defaultBackground);
+            VERIFY_ARE_EQUAL(ARGB(0, 4, 4, 4), scheme0->_defaultForeground);
+            VERIFY_ARE_EQUAL(ARGB(0, 5, 5, 5), scheme0->_defaultBackground);
+            VERIFY_ARE_EQUAL(ARGB(0, 2, 2, 2), scheme1->_defaultForeground);
+            VERIFY_ARE_EQUAL(ARGB(0, 3, 3, 3), scheme1->_defaultBackground);
         }
         settings._LayerOrCreateColorScheme(scheme3Json);
 
@@ -264,22 +270,25 @@ namespace TerminalAppLocalTests
             VERIFY_ARE_EQUAL(3u, settings._globals.GetColorSchemes().size());
 
             VERIFY_IS_TRUE(settings._globals._colorSchemes.find(L"scheme0") != settings._globals._colorSchemes.end());
-            auto scheme0 = settings._globals._colorSchemes.find(L"scheme0")->second;
+            auto scheme0Proj = settings._globals._colorSchemes.find(L"scheme0")->second;
+            auto scheme0 = winrt::get_self<ColorScheme>(scheme0Proj);
             VERIFY_IS_TRUE(settings._globals._colorSchemes.find(L"scheme1") != settings._globals._colorSchemes.end());
-            auto scheme1 = settings._globals._colorSchemes.find(L"scheme1")->second;
+            auto scheme1Proj = settings._globals._colorSchemes.find(L"scheme1")->second;
+            auto scheme1 = winrt::get_self<ColorScheme>(scheme1Proj);
             VERIFY_IS_TRUE(settings._globals._colorSchemes.find(L"") != settings._globals._colorSchemes.end());
-            auto scheme2 = settings._globals._colorSchemes.find(L"")->second;
+            auto scheme2Proj = settings._globals._colorSchemes.find(L"")->second;
+            auto scheme2 = winrt::get_self<ColorScheme>(scheme2Proj);
 
             VERIFY_IS_NOT_NULL(settings._FindMatchingColorScheme(scheme0Json));
             VERIFY_IS_NOT_NULL(settings._FindMatchingColorScheme(scheme1Json));
             VERIFY_IS_NOT_NULL(settings._FindMatchingColorScheme(scheme2Json));
             VERIFY_IS_NULL(settings._FindMatchingColorScheme(scheme3Json));
-            VERIFY_ARE_EQUAL(ARGB(0, 4, 4, 4), scheme0._defaultForeground);
-            VERIFY_ARE_EQUAL(ARGB(0, 5, 5, 5), scheme0._defaultBackground);
-            VERIFY_ARE_EQUAL(ARGB(0, 2, 2, 2), scheme1._defaultForeground);
-            VERIFY_ARE_EQUAL(ARGB(0, 3, 3, 3), scheme1._defaultBackground);
-            VERIFY_ARE_EQUAL(ARGB(0, 6, 6, 6), scheme2._defaultForeground);
-            VERIFY_ARE_EQUAL(ARGB(0, 7, 7, 7), scheme2._defaultBackground);
+            VERIFY_ARE_EQUAL(ARGB(0, 4, 4, 4), scheme0->_defaultForeground);
+            VERIFY_ARE_EQUAL(ARGB(0, 5, 5, 5), scheme0->_defaultBackground);
+            VERIFY_ARE_EQUAL(ARGB(0, 2, 2, 2), scheme1->_defaultForeground);
+            VERIFY_ARE_EQUAL(ARGB(0, 3, 3, 3), scheme1->_defaultBackground);
+            VERIFY_ARE_EQUAL(ARGB(0, 6, 6, 6), scheme2->_defaultForeground);
+            VERIFY_ARE_EQUAL(ARGB(0, 7, 7, 7), scheme2->_defaultBackground);
         }
     }
 }

src/cascadia/LocalTests_TerminalApp/CommandTests.cpp

@@ -10,7 +10,8 @@
 using namespace Microsoft::Console;
 using namespace TerminalApp;
 using namespace winrt::TerminalApp;
-using namespace winrt::Microsoft::Terminal::Settings;
+using namespace winrt::Microsoft::Terminal::TerminalControl;
+using namespace winrt::Windows::Foundation::Collections;
 using namespace WEX::Logging;
 using namespace WEX::TestExecution;
 using namespace WEX::Common;
@@ -61,25 +62,25 @@ namespace TerminalAppLocalTests
         const auto commands1Json = VerifyParseSucceeded(commands1String);
         const auto commands2Json = VerifyParseSucceeded(commands2String);
 
-        std::unordered_map<winrt::hstring, Command> commands;
-        VERIFY_ARE_EQUAL(0u, commands.size());
+        IMap<winrt::hstring, winrt::TerminalApp::Command> commands = winrt::single_threaded_map<winrt::hstring, winrt::TerminalApp::Command>();
+        VERIFY_ARE_EQUAL(0u, commands.Size());
         {
             auto warnings = implementation::Command::LayerJson(commands, commands0Json);
             VERIFY_ARE_EQUAL(0u, warnings.size());
         }
-        VERIFY_ARE_EQUAL(1u, commands.size());
+        VERIFY_ARE_EQUAL(1u, commands.Size());
 
         {
             auto warnings = implementation::Command::LayerJson(commands, commands1Json);
             VERIFY_ARE_EQUAL(0u, warnings.size());
         }
-        VERIFY_ARE_EQUAL(2u, commands.size());
+        VERIFY_ARE_EQUAL(2u, commands.Size());
 
         {
             auto warnings = implementation::Command::LayerJson(commands, commands2Json);
             VERIFY_ARE_EQUAL(0u, warnings.size());
         }
-        VERIFY_ARE_EQUAL(4u, commands.size());
+        VERIFY_ARE_EQUAL(4u, commands.Size());
     }
 
     void CommandTests::LayerCommand()
@@ -95,13 +96,13 @@ namespace TerminalAppLocalTests
         const auto commands2Json = VerifyParseSucceeded(commands2String);
         const auto commands3Json = VerifyParseSucceeded(commands3String);
 
-        std::unordered_map<winrt::hstring, Command> commands;
-        VERIFY_ARE_EQUAL(0u, commands.size());
+        IMap<winrt::hstring, winrt::TerminalApp::Command> commands = winrt::single_threaded_map<winrt::hstring, winrt::TerminalApp::Command>();
+        VERIFY_ARE_EQUAL(0u, commands.Size());
         {
             auto warnings = implementation::Command::LayerJson(commands, commands0Json);
             VERIFY_ARE_EQUAL(0u, warnings.size());
-            VERIFY_ARE_EQUAL(1u, commands.size());
-            auto command = commands.at(L"action0");
+            VERIFY_ARE_EQUAL(1u, commands.Size());
+            auto command = commands.Lookup(L"action0");
             VERIFY_IS_NOT_NULL(command);
             VERIFY_IS_NOT_NULL(command.Action());
             VERIFY_ARE_EQUAL(ShortcutAction::CopyText, command.Action().Action());
@@ -111,8 +112,8 @@ namespace TerminalAppLocalTests
         {
             auto warnings = implementation::Command::LayerJson(commands, commands1Json);
             VERIFY_ARE_EQUAL(0u, warnings.size());
-            VERIFY_ARE_EQUAL(1u, commands.size());
-            auto command = commands.at(L"action0");
+            VERIFY_ARE_EQUAL(1u, commands.Size());
+            auto command = commands.Lookup(L"action0");
             VERIFY_IS_NOT_NULL(command);
             VERIFY_IS_NOT_NULL(command.Action());
             VERIFY_ARE_EQUAL(ShortcutAction::PasteText, command.Action().Action());
@@ -121,8 +122,8 @@ namespace TerminalAppLocalTests
         {
             auto warnings = implementation::Command::LayerJson(commands, commands2Json);
             VERIFY_ARE_EQUAL(0u, warnings.size());
-            VERIFY_ARE_EQUAL(1u, commands.size());
-            auto command = commands.at(L"action0");
+            VERIFY_ARE_EQUAL(1u, commands.Size());
+            auto command = commands.Lookup(L"action0");
             VERIFY_IS_NOT_NULL(command);
             VERIFY_IS_NOT_NULL(command.Action());
             VERIFY_ARE_EQUAL(ShortcutAction::NewTab, command.Action().Action());
@@ -133,7 +134,7 @@ namespace TerminalAppLocalTests
             // This last command should "unbind" the action.
             auto warnings = implementation::Command::LayerJson(commands, commands3Json);
             VERIFY_ARE_EQUAL(0u, warnings.size());
-            VERIFY_ARE_EQUAL(0u, commands.size());
+            VERIFY_ARE_EQUAL(0u, commands.Size());
         }
     }
 
@@ -147,22 +148,20 @@ namespace TerminalAppLocalTests
             { "name": "command0", "command": { "action": "splitPane", "split": null } },
             { "name": "command1", "command": { "action": "splitPane", "split": "vertical" } },
             { "name": "command2", "command": { "action": "splitPane", "split": "horizontal" } },
-            { "name": "command3", "command": { "action": "splitPane", "split": "none" } },
             { "name": "command4", "command": { "action": "splitPane" } },
-            { "name": "command5", "command": { "action": "splitPane", "split": "auto" } },
-            { "name": "command6", "command": { "action": "splitPane", "split": "foo" } }
+            { "name": "command5", "command": { "action": "splitPane", "split": "auto" } }
         ])" };
 
         const auto commands0Json = VerifyParseSucceeded(commands0String);
 
-        std::unordered_map<winrt::hstring, Command> commands;
-        VERIFY_ARE_EQUAL(0u, commands.size());
+        IMap<winrt::hstring, winrt::TerminalApp::Command> commands = winrt::single_threaded_map<winrt::hstring, winrt::TerminalApp::Command>();
+        VERIFY_ARE_EQUAL(0u, commands.Size());
         auto warnings = implementation::Command::LayerJson(commands, commands0Json);
         VERIFY_ARE_EQUAL(0u, warnings.size());
-        VERIFY_ARE_EQUAL(7u, commands.size());
+        VERIFY_ARE_EQUAL(5u, commands.Size());
 
         {
-            auto command = commands.at(L"command0");
+            auto command = commands.Lookup(L"command0");
             VERIFY_IS_NOT_NULL(command);
             VERIFY_IS_NOT_NULL(command.Action());
             VERIFY_ARE_EQUAL(ShortcutAction::SplitPane, command.Action().Action());
@@ -172,7 +171,7 @@ namespace TerminalAppLocalTests
             VERIFY_ARE_EQUAL(winrt::TerminalApp::SplitState::Automatic, realArgs.SplitStyle());
         }
         {
-            auto command = commands.at(L"command1");
+            auto command = commands.Lookup(L"command1");
             VERIFY_IS_NOT_NULL(command);
             VERIFY_IS_NOT_NULL(command.Action());
             VERIFY_ARE_EQUAL(ShortcutAction::SplitPane, command.Action().Action());
@@ -182,7 +181,7 @@ namespace TerminalAppLocalTests
             VERIFY_ARE_EQUAL(winrt::TerminalApp::SplitState::Vertical, realArgs.SplitStyle());
         }
         {
-            auto command = commands.at(L"command2");
+            auto command = commands.Lookup(L"command2");
             VERIFY_IS_NOT_NULL(command);
             VERIFY_IS_NOT_NULL(command.Action());
             VERIFY_ARE_EQUAL(ShortcutAction::SplitPane, command.Action().Action());
@@ -192,7 +191,7 @@ namespace TerminalAppLocalTests
             VERIFY_ARE_EQUAL(winrt::TerminalApp::SplitState::Horizontal, realArgs.SplitStyle());
         }
         {
-            auto command = commands.at(L"command3");
+            auto command = commands.Lookup(L"command4");
             VERIFY_IS_NOT_NULL(command);
             VERIFY_IS_NOT_NULL(command.Action());
             VERIFY_ARE_EQUAL(ShortcutAction::SplitPane, command.Action().Action());
@@ -202,27 +201,7 @@ namespace TerminalAppLocalTests
             VERIFY_ARE_EQUAL(winrt::TerminalApp::SplitState::Automatic, realArgs.SplitStyle());
         }
         {
-            auto command = commands.at(L"command4");
-            VERIFY_IS_NOT_NULL(command);
-            VERIFY_IS_NOT_NULL(command.Action());
-            VERIFY_ARE_EQUAL(ShortcutAction::SplitPane, command.Action().Action());
-            const auto& realArgs = command.Action().Args().try_as<SplitPaneArgs>();
-            VERIFY_IS_NOT_NULL(realArgs);
-            // Verify the args have the expected value
-            VERIFY_ARE_EQUAL(winrt::TerminalApp::SplitState::Automatic, realArgs.SplitStyle());
-        }
-        {
-            auto command = commands.at(L"command5");
-            VERIFY_IS_NOT_NULL(command);
-            VERIFY_IS_NOT_NULL(command.Action());
-            VERIFY_ARE_EQUAL(ShortcutAction::SplitPane, command.Action().Action());
-            const auto& realArgs = command.Action().Args().try_as<SplitPaneArgs>();
-            VERIFY_IS_NOT_NULL(realArgs);
-            // Verify the args have the expected value
-            VERIFY_ARE_EQUAL(winrt::TerminalApp::SplitState::Automatic, realArgs.SplitStyle());
-        }
-        {
-            auto command = commands.at(L"command6");
+            auto command = commands.Lookup(L"command5");
             VERIFY_IS_NOT_NULL(command);
             VERIFY_IS_NOT_NULL(command.Action());
             VERIFY_ARE_EQUAL(ShortcutAction::SplitPane, command.Action().Action());
@@ -239,17 +218,17 @@ namespace TerminalAppLocalTests
         const std::string commands0String{ R"([ { "name": { "key": "DuplicateTabCommandKey"}, "command": "copy" } ])" };
         const auto commands0Json = VerifyParseSucceeded(commands0String);
 
-        std::unordered_map<winrt::hstring, Command> commands;
-        VERIFY_ARE_EQUAL(0u, commands.size());
+        IMap<winrt::hstring, winrt::TerminalApp::Command> commands = winrt::single_threaded_map<winrt::hstring, winrt::TerminalApp::Command>();
+        VERIFY_ARE_EQUAL(0u, commands.Size());
         {
             auto warnings = implementation::Command::LayerJson(commands, commands0Json);
             VERIFY_ARE_EQUAL(0u, warnings.size());
-            VERIFY_ARE_EQUAL(1u, commands.size());
+            VERIFY_ARE_EQUAL(1u, commands.Size());
 
             // NOTE: We're relying on DuplicateTabCommandKey being defined as
             // "Duplicate Tab" here. If that string changes in our resources,
             // this test will break.
-            auto command = commands.at(L"Duplicate tab");
+            auto command = commands.Lookup(L"Duplicate tab");
             VERIFY_IS_NOT_NULL(command);
             VERIFY_IS_NOT_NULL(command.Action());
             VERIFY_ARE_EQUAL(ShortcutAction::CopyText, command.Action().Action());
@@ -260,6 +239,14 @@ namespace TerminalAppLocalTests
 
     void CommandTests::TestAutogeneratedName()
     {
+        // Tests run in Helix can't report Skipped until GH#7286 is resolved.
+        // Set ignore flag to make Helix run completely overlook it.
+        BEGIN_TEST_METHOD_PROPERTIES()
+            TEST_METHOD_PROPERTY(L"Ignore", L"True")
+        END_TEST_METHOD_PROPERTIES()
+
+        // This test to be corrected as a part of GH#7281
+
         // This test ensures that we'll correctly create commands for actions
         // that don't have given names, pursuant to the spec in GH#6532.
 
@@ -279,18 +266,18 @@ namespace TerminalAppLocalTests
 
         const auto commands0Json = VerifyParseSucceeded(commands0String);
 
-        std::unordered_map<winrt::hstring, Command> commands;
-        VERIFY_ARE_EQUAL(0u, commands.size());
+        IMap<winrt::hstring, winrt::TerminalApp::Command> commands = winrt::single_threaded_map<winrt::hstring, winrt::TerminalApp::Command>();
+        VERIFY_ARE_EQUAL(0u, commands.Size());
         auto warnings = implementation::Command::LayerJson(commands, commands0Json);
         VERIFY_ARE_EQUAL(0u, warnings.size());
 
         // There are only 3 commands here: all of the `"none"`, `"auto"`,
         // `"foo"`, `null`, and <no args> bindings all generate the same action,
         // which will generate just a single name for all of them.
-        VERIFY_ARE_EQUAL(3u, commands.size());
+        VERIFY_ARE_EQUAL(3u, commands.Size());
 
         {
-            auto command = commands.at(L"Split pane");
+            auto command = commands.Lookup(L"Split pane");
             VERIFY_IS_NOT_NULL(command);
             VERIFY_IS_NOT_NULL(command.Action());
             VERIFY_ARE_EQUAL(ShortcutAction::SplitPane, command.Action().Action());
@@ -300,7 +287,7 @@ namespace TerminalAppLocalTests
             VERIFY_ARE_EQUAL(winrt::TerminalApp::SplitState::Automatic, realArgs.SplitStyle());
         }
         {
-            auto command = commands.at(L"Split pane, direction: vertical");
+            auto command = commands.Lookup(L"Split pane, split: vertical");
             VERIFY_IS_NOT_NULL(command);
             VERIFY_IS_NOT_NULL(command.Action());
             VERIFY_ARE_EQUAL(ShortcutAction::SplitPane, command.Action().Action());
@@ -310,7 +297,7 @@ namespace TerminalAppLocalTests
             VERIFY_ARE_EQUAL(winrt::TerminalApp::SplitState::Vertical, realArgs.SplitStyle());
         }
         {
-            auto command = commands.at(L"Split pane, direction: horizontal");
+            auto command = commands.Lookup(L"Split pane, split: horizontal");
             VERIFY_IS_NOT_NULL(command);
             VERIFY_IS_NOT_NULL(command.Action());
             VERIFY_ARE_EQUAL(ShortcutAction::SplitPane, command.Action().Action());
@@ -329,14 +316,14 @@ namespace TerminalAppLocalTests
 
         const auto commands0Json = VerifyParseSucceeded(commands0String);
 
-        std::unordered_map<winrt::hstring, Command> commands;
-        VERIFY_ARE_EQUAL(0u, commands.size());
+        IMap<winrt::hstring, winrt::TerminalApp::Command> commands = winrt::single_threaded_map<winrt::hstring, winrt::TerminalApp::Command>();
+        VERIFY_ARE_EQUAL(0u, commands.Size());
         auto warnings = implementation::Command::LayerJson(commands, commands0Json);
         VERIFY_ARE_EQUAL(0u, warnings.size());
-        VERIFY_ARE_EQUAL(1u, commands.size());
+        VERIFY_ARE_EQUAL(1u, commands.Size());
 
         {
-            auto command = commands.at(L"Split pane");
+            auto command = commands.Lookup(L"Split pane");
             VERIFY_IS_NOT_NULL(command);
             VERIFY_IS_NOT_NULL(command.Action());
             VERIFY_ARE_EQUAL(ShortcutAction::SplitPane, command.Action().Action());

src/cascadia/LocalTests_TerminalApp/CommandlineTest.cpp

@@ -4,7 +4,9 @@
 #include "pch.h"
 #include <WexTestClass.h>
 
+#include "../TerminalApp/TerminalPage.h"
 #include "../TerminalApp/AppCommandlineArgs.h"
+#include "../TerminalApp/ActionArgs.h"
 
 using namespace WEX::Logging;
 using namespace WEX::Common;
@@ -52,6 +54,10 @@ namespace TerminalAppLocalTests
 
         TEST_METHOD(CheckTypos);
 
+        TEST_METHOD(TestSimpleExecuteCommandlineAction);
+        TEST_METHOD(TestMultipleCommandExecuteCommandlineAction);
+        TEST_METHOD(TestInvalidExecuteCommandlineAction);
+
     private:
         void _buildCommandlinesHelper(AppCommandlineArgs& appArgs,
                                       const size_t expectedSubcommands,
@@ -1067,4 +1073,66 @@ namespace TerminalAppLocalTests
             VERIFY_ARE_EQUAL(L"C:\\", myArgs.TerminalArgs().StartingDirectory());
         }
     }
+
+    void CommandlineTest::TestSimpleExecuteCommandlineAction()
+    {
+        auto args = winrt::make_self<implementation::ExecuteCommandlineArgs>();
+        args->Commandline(L"new-tab");
+        auto actions = implementation::TerminalPage::ConvertExecuteCommandlineToActions(*args);
+        VERIFY_ARE_EQUAL(1u, actions.size());
+        auto actionAndArgs = actions.at(0);
+        VERIFY_ARE_EQUAL(ShortcutAction::NewTab, actionAndArgs.Action());
+        VERIFY_IS_NOT_NULL(actionAndArgs.Args());
+        auto myArgs = actionAndArgs.Args().try_as<NewTabArgs>();
+        VERIFY_IS_NOT_NULL(myArgs);
+        VERIFY_IS_NOT_NULL(myArgs.TerminalArgs());
+        VERIFY_IS_TRUE(myArgs.TerminalArgs().Commandline().empty());
+        VERIFY_IS_TRUE(myArgs.TerminalArgs().StartingDirectory().empty());
+        VERIFY_IS_TRUE(myArgs.TerminalArgs().TabTitle().empty());
+        VERIFY_IS_TRUE(myArgs.TerminalArgs().ProfileIndex() == nullptr);
+        VERIFY_IS_TRUE(myArgs.TerminalArgs().Profile().empty());
+    }
+
+    void CommandlineTest::TestMultipleCommandExecuteCommandlineAction()
+    {
+        auto args = winrt::make_self<implementation::ExecuteCommandlineArgs>();
+        args->Commandline(L"new-tab ; split-pane");
+        auto actions = implementation::TerminalPage::ConvertExecuteCommandlineToActions(*args);
+        VERIFY_ARE_EQUAL(2u, actions.size());
+        {
+            auto actionAndArgs = actions.at(0);
+            VERIFY_ARE_EQUAL(ShortcutAction::NewTab, actionAndArgs.Action());
+            VERIFY_IS_NOT_NULL(actionAndArgs.Args());
+            auto myArgs = actionAndArgs.Args().try_as<NewTabArgs>();
+            VERIFY_IS_NOT_NULL(myArgs);
+            VERIFY_IS_NOT_NULL(myArgs.TerminalArgs());
+            VERIFY_IS_TRUE(myArgs.TerminalArgs().Commandline().empty());
+            VERIFY_IS_TRUE(myArgs.TerminalArgs().StartingDirectory().empty());
+            VERIFY_IS_TRUE(myArgs.TerminalArgs().TabTitle().empty());
+            VERIFY_IS_TRUE(myArgs.TerminalArgs().ProfileIndex() == nullptr);
+            VERIFY_IS_TRUE(myArgs.TerminalArgs().Profile().empty());
+        }
+        {
+            auto actionAndArgs = actions.at(1);
+            VERIFY_ARE_EQUAL(ShortcutAction::SplitPane, actionAndArgs.Action());
+            VERIFY_IS_NOT_NULL(actionAndArgs.Args());
+            auto myArgs = actionAndArgs.Args().try_as<SplitPaneArgs>();
+            VERIFY_IS_NOT_NULL(myArgs);
+            VERIFY_IS_NOT_NULL(myArgs.TerminalArgs());
+            VERIFY_IS_TRUE(myArgs.TerminalArgs().Commandline().empty());
+            VERIFY_IS_TRUE(myArgs.TerminalArgs().StartingDirectory().empty());
+            VERIFY_IS_TRUE(myArgs.TerminalArgs().TabTitle().empty());
+            VERIFY_IS_TRUE(myArgs.TerminalArgs().ProfileIndex() == nullptr);
+            VERIFY_IS_TRUE(myArgs.TerminalArgs().Profile().empty());
+        }
+    }
+
+    void CommandlineTest::TestInvalidExecuteCommandlineAction()
+    {
+        auto args = winrt::make_self<implementation::ExecuteCommandlineArgs>();
+        // -H and -V cannot be combined.
+        args->Commandline(L"split-pane -H -V");
+        auto actions = implementation::TerminalPage::ConvertExecuteCommandlineToActions(*args);
+        VERIFY_ARE_EQUAL(0u, actions.size());
+    }
 }

src/cascadia/LocalTests_TerminalApp/KeyBindingsTests.cpp

@@ -11,7 +11,7 @@
 using namespace Microsoft::Console;
 using namespace TerminalApp;
 using namespace winrt::TerminalApp;
-using namespace winrt::Microsoft::Terminal::Settings;
+using namespace winrt::Microsoft::Terminal::TerminalControl;
 using namespace WEX::Logging;
 using namespace WEX::TestExecution;
 using namespace WEX::Common;
@@ -323,10 +323,8 @@ namespace TerminalAppLocalTests
             { "keys": ["ctrl+c"], "command": { "action": "splitPane", "split": null } },
             { "keys": ["ctrl+d"], "command": { "action": "splitPane", "split": "vertical" } },
             { "keys": ["ctrl+e"], "command": { "action": "splitPane", "split": "horizontal" } },
-            { "keys": ["ctrl+f"], "command": { "action": "splitPane", "split": "none" } },
             { "keys": ["ctrl+g"], "command": { "action": "splitPane" } },
-            { "keys": ["ctrl+h"], "command": { "action": "splitPane", "split": "auto" } },
-            { "keys": ["ctrl+i"], "command": { "action": "splitPane", "split": "foo" } }
+            { "keys": ["ctrl+h"], "command": { "action": "splitPane", "split": "auto" } }
         ])" };
 
         const auto bindings0Json = VerifyParseSucceeded(bindings0String);
@@ -335,7 +333,7 @@ namespace TerminalAppLocalTests
         VERIFY_IS_NOT_NULL(appKeyBindings);
         VERIFY_ARE_EQUAL(0u, appKeyBindings->_keyShortcuts.size());
         appKeyBindings->LayerJson(bindings0Json);
-        VERIFY_ARE_EQUAL(7u, appKeyBindings->_keyShortcuts.size());
+        VERIFY_ARE_EQUAL(5u, appKeyBindings->_keyShortcuts.size());
 
         {
             KeyChord kc{ true, false, false, static_cast<int32_t>('C') };
@@ -364,15 +362,6 @@ namespace TerminalAppLocalTests
             // Verify the args have the expected value
             VERIFY_ARE_EQUAL(winrt::TerminalApp::SplitState::Horizontal, realArgs.SplitStyle());
         }
-        {
-            KeyChord kc{ true, false, false, static_cast<int32_t>('F') };
-            auto actionAndArgs = TestUtils::GetActionAndArgs(*appKeyBindings, kc);
-            VERIFY_ARE_EQUAL(ShortcutAction::SplitPane, actionAndArgs.Action());
-            const auto& realArgs = actionAndArgs.Args().try_as<SplitPaneArgs>();
-            VERIFY_IS_NOT_NULL(realArgs);
-            // Verify the args have the expected value
-            VERIFY_ARE_EQUAL(winrt::TerminalApp::SplitState::Automatic, realArgs.SplitStyle());
-        }
         {
             KeyChord kc{ true, false, false, static_cast<int32_t>('G') };
             auto actionAndArgs = TestUtils::GetActionAndArgs(*appKeyBindings, kc);
@@ -391,15 +380,6 @@ namespace TerminalAppLocalTests
             // Verify the args have the expected value
             VERIFY_ARE_EQUAL(winrt::TerminalApp::SplitState::Automatic, realArgs.SplitStyle());
         }
-        {
-            KeyChord kc{ true, false, false, static_cast<int32_t>('I') };
-            auto actionAndArgs = TestUtils::GetActionAndArgs(*appKeyBindings, kc);
-            VERIFY_ARE_EQUAL(ShortcutAction::SplitPane, actionAndArgs.Action());
-            const auto& realArgs = actionAndArgs.Args().try_as<SplitPaneArgs>();
-            VERIFY_IS_NOT_NULL(realArgs);
-            // Verify the args have the expected value
-            VERIFY_ARE_EQUAL(winrt::TerminalApp::SplitState::Automatic, realArgs.SplitStyle());
-        }
     }
 
     void KeyBindingsTests::TestSetTabColorArgs()
@@ -407,7 +387,6 @@ namespace TerminalAppLocalTests
         const std::string bindings0String{ R"([
             { "keys": ["ctrl+c"], "command": { "action": "setTabColor", "color": null } },
             { "keys": ["ctrl+d"], "command": { "action": "setTabColor", "color": "#123456" } },
-            { "keys": ["ctrl+e"], "command": { "action": "setTabColor", "color": "thisStringObviouslyWontWork" } },
             { "keys": ["ctrl+f"], "command": "setTabColor" },
         ])" };
 
@@ -417,7 +396,7 @@ namespace TerminalAppLocalTests
         VERIFY_IS_NOT_NULL(appKeyBindings);
         VERIFY_ARE_EQUAL(0u, appKeyBindings->_keyShortcuts.size());
         appKeyBindings->LayerJson(bindings0Json);
-        VERIFY_ARE_EQUAL(4u, appKeyBindings->_keyShortcuts.size());
+        VERIFY_ARE_EQUAL(3u, appKeyBindings->_keyShortcuts.size());
 
         {
             KeyChord kc{ true, false, false, static_cast<int32_t>('C') };
@@ -439,15 +418,6 @@ namespace TerminalAppLocalTests
             // Remember that COLORREFs are actually BBGGRR order, while the string is in #RRGGBB order
             VERIFY_ARE_EQUAL(static_cast<uint32_t>(til::color(0x563412)), realArgs.TabColor().Value());
         }
-        {
-            KeyChord kc{ true, false, false, static_cast<int32_t>('E') };
-            auto actionAndArgs = TestUtils::GetActionAndArgs(*appKeyBindings, kc);
-            VERIFY_ARE_EQUAL(ShortcutAction::SetTabColor, actionAndArgs.Action());
-            const auto& realArgs = actionAndArgs.Args().try_as<SetTabColorArgs>();
-            VERIFY_IS_NOT_NULL(realArgs);
-            // Verify the args have the expected value
-            VERIFY_IS_NULL(realArgs.TabColor());
-        }
         {
             KeyChord kc{ true, false, false, static_cast<int32_t>('F') };
             auto actionAndArgs = TestUtils::GetActionAndArgs(*appKeyBindings, kc);

src/cascadia/LocalTests_TerminalApp/TabTests.cpp

@@ -51,7 +51,8 @@ namespace TerminalAppLocalTests
         TEST_METHOD(TryCreateSettingsType);
         TEST_METHOD(TryCreateConnectionType);
         TEST_METHOD(TryCreateXamlObjects);
-        TEST_METHOD(TryCreateTab);
+
+        TEST_METHOD(TryInitializePage);
 
         TEST_METHOD(CreateSimpleTerminalXamlType);
         TEST_METHOD(CreateTerminalMuxXamlType);
@@ -67,6 +68,11 @@ namespace TerminalAppLocalTests
             return true;
         }
 
+        TEST_METHOD_CLEANUP(MethodCleanup)
+        {
+            return true;
+        }
+
     private:
         void _initializeTerminalPage(winrt::com_ptr<winrt::TerminalApp::implementation::TerminalPage>& page,
                                      std::shared_ptr<CascadiaSettings> initialSettings);
@@ -84,7 +90,7 @@ namespace TerminalAppLocalTests
     {
         // Verify we can create a WinRT type we authored
         // Just creating it is enough to know that everything is working.
-        winrt::Microsoft::Terminal::Settings::TerminalSettings settings;
+        TerminalSettings settings;
         VERIFY_IS_NOT_NULL(settings);
         auto oldFontSize = settings.FontSize();
         settings.FontSize(oldFontSize + 5);
@@ -125,35 +131,6 @@ namespace TerminalAppLocalTests
         VERIFY_SUCCEEDED(result);
     }
 
-    void TabTests::TryCreateTab()
-    {
-        // If you leave the Tab ptr owned by the RunOnUIThread lambda, it
-        // will crash when the test tears down. Not totally clear why, but make
-        // sure it's owned outside the lambda
-        winrt::com_ptr<winrt::TerminalApp::implementation::Tab> newTab{ nullptr };
-
-        auto result = RunOnUIThread([&newTab]() {
-            // Try creating all of:
-            // 1. one of our pure c++ types (Profile)
-            // 2. one of our c++winrt types (TerminalSettings, EchoConnection)
-            // 3. one of our types that uses MUX/Xaml (TermControl).
-            // 4. one of our types that uses MUX/Xaml in this dll (Tab).
-            // Just creating all of them is enough to know that everything is working.
-            const auto profileGuid{ Utils::CreateGuid() };
-            winrt::Microsoft::Terminal::Settings::TerminalSettings settings{};
-            VERIFY_IS_NOT_NULL(settings);
-            winrt::Microsoft::Terminal::TerminalConnection::EchoConnection conn{};
-            VERIFY_IS_NOT_NULL(conn);
-            winrt::Microsoft::Terminal::TerminalControl::TermControl term{ settings, conn };
-            VERIFY_IS_NOT_NULL(term);
-
-            newTab = winrt::make_self<winrt::TerminalApp::implementation::Tab>(profileGuid, term);
-            VERIFY_IS_NOT_NULL(newTab);
-        });
-
-        VERIFY_SUCCEEDED(result);
-    }
-
     void TabTests::CreateSimpleTerminalXamlType()
     {
         winrt::com_ptr<winrt::TerminalApp::implementation::MinMaxCloseControl> mmcc{ nullptr };
@@ -276,229 +253,268 @@ namespace TerminalAppLocalTests
         VERIFY_SUCCEEDED(result);
     }
 
+    void TabTests::TryInitializePage()
+    {
+        // This is a very simple test to prove we can create settings and a
+        // TerminalPage and not only create them successfully, but also create a
+        // tab using those settings successfully.
+
+        const std::string settingsJson0{ R"(
+        {
+            "defaultProfile": "{6239a42c-1111-49a3-80bd-e8fdd045185c}",
+            "profiles": [
+                {
+                    "name" : "profile0",
+                    "guid": "{6239a42c-1111-49a3-80bd-e8fdd045185c}",
+                    "historySize": 1
+                },
+                {
+                    "name" : "profile1",
+                    "guid": "{6239a42c-2222-49a3-80bd-e8fdd045185c}",
+                    "historySize": 2
+                }
+            ]
+        })" };
+
+        VerifyParseSucceeded(settingsJson0);
+        auto settings0 = std::make_shared<CascadiaSettings>(false);
+        VERIFY_IS_NOT_NULL(settings0);
+        settings0->_ParseJsonString(settingsJson0, false);
+        settings0->LayerJson(settings0->_userSettings);
+        settings0->_ValidateSettings();
+
+        // This is super wacky, but we can't just initialize the
+        // com_ptr<impl::TerminalPage> in the lambda and assign it back out of
+        // the lambda. We'll crash trying to get a weak_ref to the TerminalPage
+        // during TerminalPage::Create() below.
+        //
+        // Instead, create the winrt object, then get a com_ptr to the
+        // implementation _from_ the winrt object. This seems to work, even if
+        // it's weird.
+        winrt::com_ptr<winrt::TerminalApp::implementation::TerminalPage> page{ nullptr };
+        _initializeTerminalPage(page, settings0);
+
+        auto result = RunOnUIThread([&page]() {
+            VERIFY_ARE_EQUAL(1u, page->_tabs.Size());
+        });
+        VERIFY_SUCCEEDED(result);
+    }
+
     void TabTests::TryDuplicateBadTab()
     {
-        Log::Comment(L"This test regressed recently - it is temporarily disabled while GH#5169 is investigated");
-        Log::Result(WEX::Logging::TestResults::Skipped);
-        return;
+        // * Create a tab with a profile with GUID 1
+        // * Reload the settings so that GUID 1 is no longer in the list of profiles
+        // * Try calling _DuplicateTabViewItem on tab 1
+        // * No new tab should be created (and more importantly, the app should not crash)
+        //
+        // Created to test GH#2455
 
-        // // * Create a tab with a profile with GUID 1
-        // // * Reload the settings so that GUID 1 is no longer in the list of profiles
-        // // * Try calling _DuplicateTabViewItem on tab 1
-        // // * No new tab should be created (and more importantly, the app should not crash)
-        // //
-        // // Created to test GH#2455
+        const std::string settingsJson0{ R"(
+        {
+            "defaultProfile": "{6239a42c-1111-49a3-80bd-e8fdd045185c}",
+            "profiles": [
+                {
+                    "name" : "profile0",
+                    "guid": "{6239a42c-1111-49a3-80bd-e8fdd045185c}",
+                    "historySize": 1
+                },
+                {
+                    "name" : "profile1",
+                    "guid": "{6239a42c-2222-49a3-80bd-e8fdd045185c}",
+                    "historySize": 2
+                }
+            ]
+        })" };
 
-        // const std::string settingsJson0{ R"(
-        // {
-        //     "defaultProfile": "{6239a42c-1111-49a3-80bd-e8fdd045185c}",
-        //     "profiles": [
-        //         {
-        //             "name" : "profile0",
-        //             "guid": "{6239a42c-1111-49a3-80bd-e8fdd045185c}",
-        //             "historySize": 1
-        //         },
-        //         {
-        //             "name" : "profile1",
-        //             "guid": "{6239a42c-2222-49a3-80bd-e8fdd045185c}",
-        //             "historySize": 2
-        //         }
-        //     ]
-        // })" };
+        const std::string settingsJson1{ R"(
+        {
+            "defaultProfile": "{6239a42c-1111-49a3-80bd-e8fdd045185c}",
+            "profiles": [
+                {
+                    "name" : "profile1",
+                    "guid": "{6239a42c-2222-49a3-80bd-e8fdd045185c}",
+                    "historySize": 2
+                }
+            ]
+        })" };
 
-        // const std::string settingsJson1{ R"(
-        // {
-        //     "defaultProfile": "{6239a42c-1111-49a3-80bd-e8fdd045185c}",
-        //     "profiles": [
-        //         {
-        //             "name" : "profile1",
-        //             "guid": "{6239a42c-2222-49a3-80bd-e8fdd045185c}",
-        //             "historySize": 2
-        //         }
-        //     ]
-        // })" };
+        VerifyParseSucceeded(settingsJson0);
+        auto settings0 = std::make_shared<CascadiaSettings>(false);
+        VERIFY_IS_NOT_NULL(settings0);
+        settings0->_ParseJsonString(settingsJson0, false);
+        settings0->LayerJson(settings0->_userSettings);
+        settings0->_ValidateSettings();
 
-        // VerifyParseSucceeded(settingsJson0);
-        // auto settings0 = std::make_shared<CascadiaSettings>(false);
-        // VERIFY_IS_NOT_NULL(settings0);
-        // settings0->_ParseJsonString(settingsJson0, false);
-        // settings0->LayerJson(settings0->_userSettings);
-        // settings0->_ValidateSettings();
+        VerifyParseSucceeded(settingsJson1);
+        auto settings1 = std::make_shared<CascadiaSettings>(false);
+        VERIFY_IS_NOT_NULL(settings1);
+        settings1->_ParseJsonString(settingsJson1, false);
+        settings1->LayerJson(settings1->_userSettings);
+        settings1->_ValidateSettings();
 
-        // VerifyParseSucceeded(settingsJson1);
-        // auto settings1 = std::make_shared<CascadiaSettings>(false);
-        // VERIFY_IS_NOT_NULL(settings1);
-        // settings1->_ParseJsonString(settingsJson1, false);
-        // settings1->LayerJson(settings1->_userSettings);
-        // settings1->_ValidateSettings();
+        const auto guid1 = Microsoft::Console::Utils::GuidFromString(L"{6239a42c-1111-49a3-80bd-e8fdd045185c}");
+        const auto guid2 = Microsoft::Console::Utils::GuidFromString(L"{6239a42c-2222-49a3-80bd-e8fdd045185c}");
+        const auto guid3 = Microsoft::Console::Utils::GuidFromString(L"{6239a42c-3333-49a3-80bd-e8fdd045185c}");
 
-        // const auto guid1 = Microsoft::Console::Utils::GuidFromString(L"{6239a42c-1111-49a3-80bd-e8fdd045185c}");
-        // const auto guid2 = Microsoft::Console::Utils::GuidFromString(L"{6239a42c-2222-49a3-80bd-e8fdd045185c}");
-        // const auto guid3 = Microsoft::Console::Utils::GuidFromString(L"{6239a42c-3333-49a3-80bd-e8fdd045185c}");
+        // This is super wacky, but we can't just initialize the
+        // com_ptr<impl::TerminalPage> in the lambda and assign it back out of
+        // the lambda. We'll crash trying to get a weak_ref to the TerminalPage
+        // during TerminalPage::Create() below.
+        //
+        // Instead, create the winrt object, then get a com_ptr to the
+        // implementation _from_ the winrt object. This seems to work, even if
+        // it's weird.
+        winrt::com_ptr<winrt::TerminalApp::implementation::TerminalPage> page{ nullptr };
+        _initializeTerminalPage(page, settings0);
 
-        // // This is super wacky, but we can't just initialize the
-        // // com_ptr<impl::TerminalPage> in the lambda and assign it back out of
-        // // the lambda. We'll crash trying to get a weak_ref to the TerminalPage
-        // // during TerminalPage::Create() below.
-        // //
-        // // Instead, create the winrt object, then get a com_ptr to the
-        // // implementation _from_ the winrt object. This seems to work, even if
-        // // it's weird.
-        // winrt::com_ptr<winrt::TerminalApp::implementation::TerminalPage> page{ nullptr };
-        // _initializeTerminalPage(page, settings0);
+        auto result = RunOnUIThread([&page]() {
+            VERIFY_ARE_EQUAL(1u, page->_tabs.Size());
+        });
+        VERIFY_SUCCEEDED(result);
 
-        // auto result = RunOnUIThread([&page]() {
-        //     VERIFY_ARE_EQUAL(1u, page->_tabs.Size());
-        // });
-        // VERIFY_SUCCEEDED(result);
+        Log::Comment(L"Duplicate the first tab");
+        result = RunOnUIThread([&page]() {
+            page->_DuplicateTabViewItem();
+            VERIFY_ARE_EQUAL(2u, page->_tabs.Size());
+        });
+        VERIFY_SUCCEEDED(result);
 
-        // Log::Comment(L"Duplicate the first tab");
-        // result = RunOnUIThread([&page]() {
-        //     page->_DuplicateTabViewItem();
-        //     VERIFY_ARE_EQUAL(2u, page->_tabs.Size());
-        // });
-        // VERIFY_SUCCEEDED(result);
+        Log::Comment(NoThrowString().Format(
+            L"Change the settings of the TerminalPage so the first profile is "
+            L"no longer in the list of profiles"));
+        result = RunOnUIThread([&page, settings1]() {
+            page->_settings = settings1;
+        });
+        VERIFY_SUCCEEDED(result);
 
-        // Log::Comment(NoThrowString().Format(
-        //     L"Change the settings of the TerminalPage so the first profile is "
-        //     L"no longer in the list of profiles"));
-        // result = RunOnUIThread([&page, settings1]() {
-        //     page->_settings = settings1;
-        // });
-        // VERIFY_SUCCEEDED(result);
-
-        // Log::Comment(L"Duplicate the tab, and don't crash");
-        // result = RunOnUIThread([&page]() {
-        //     page->_DuplicateTabViewItem();
-        //     VERIFY_ARE_EQUAL(2u, page->_tabs.Size(), L"We should gracefully do nothing here - the profile no longer exists.");
-        // });
-        // VERIFY_SUCCEEDED(result);
+        Log::Comment(L"Duplicate the tab, and don't crash");
+        result = RunOnUIThread([&page]() {
+            page->_DuplicateTabViewItem();
+            VERIFY_ARE_EQUAL(2u, page->_tabs.Size(), L"We should gracefully do nothing here - the profile no longer exists.");
+        });
+        VERIFY_SUCCEEDED(result);
     }
 
     void TabTests::TryDuplicateBadPane()
     {
-        Log::Comment(L"This test regressed recently - it is temporarily disabled while GH#5169 is investigated");
-        Log::Result(WEX::Logging::TestResults::Skipped);
-        return;
+        // * Create a tab with a profile with GUID 1
+        // * Reload the settings so that GUID 1 is no longer in the list of profiles
+        // * Try calling _SplitPane(Duplicate) on tab 1
+        // * No new pane should be created (and more importantly, the app should not crash)
+        //
+        // Created to test GH#2455
 
-        // // * Create a tab with a profile with GUID 1
-        // // * Reload the settings so that GUID 1 is no longer in the list of profiles
-        // // * Try calling _SplitPane(Duplicate) on tab 1
-        // // * No new pane should be created (and more importantly, the app should not crash)
-        // //
-        // // Created to test GH#2455
+        const std::string settingsJson0{ R"(
+        {
+            "defaultProfile": "{6239a42c-1111-49a3-80bd-e8fdd045185c}",
+            "profiles": [
+                {
+                    "name" : "profile0",
+                    "guid": "{6239a42c-1111-49a3-80bd-e8fdd045185c}",
+                    "historySize": 1
+                },
+                {
+                    "name" : "profile1",
+                    "guid": "{6239a42c-2222-49a3-80bd-e8fdd045185c}",
+                    "historySize": 2
+                }
+            ]
+        })" };
 
-        // const std::string settingsJson0{ R"(
-        // {
-        //     "defaultProfile": "{6239a42c-1111-49a3-80bd-e8fdd045185c}",
-        //     "profiles": [
-        //         {
-        //             "name" : "profile0",
-        //             "guid": "{6239a42c-1111-49a3-80bd-e8fdd045185c}",
-        //             "historySize": 1
-        //         },
-        //         {
-        //             "name" : "profile1",
-        //             "guid": "{6239a42c-2222-49a3-80bd-e8fdd045185c}",
-        //             "historySize": 2
-        //         }
-        //     ]
-        // })" };
+        const std::string settingsJson1{ R"(
+        {
+            "defaultProfile": "{6239a42c-1111-49a3-80bd-e8fdd045185c}",
+            "profiles": [
+                {
+                    "name" : "profile1",
+                    "guid": "{6239a42c-2222-49a3-80bd-e8fdd045185c}",
+                    "historySize": 2
+                }
+            ]
+        })" };
 
-        // const std::string settingsJson1{ R"(
-        // {
-        //     "defaultProfile": "{6239a42c-1111-49a3-80bd-e8fdd045185c}",
-        //     "profiles": [
-        //         {
-        //             "name" : "profile1",
-        //             "guid": "{6239a42c-2222-49a3-80bd-e8fdd045185c}",
-        //             "historySize": 2
-        //         }
-        //     ]
-        // })" };
+        VerifyParseSucceeded(settingsJson0);
+        auto settings0 = std::make_shared<CascadiaSettings>(false);
+        VERIFY_IS_NOT_NULL(settings0);
+        settings0->_ParseJsonString(settingsJson0, false);
+        settings0->LayerJson(settings0->_userSettings);
+        settings0->_ValidateSettings();
 
-        // VerifyParseSucceeded(settingsJson0);
-        // auto settings0 = std::make_shared<CascadiaSettings>(false);
-        // VERIFY_IS_NOT_NULL(settings0);
-        // settings0->_ParseJsonString(settingsJson0, false);
-        // settings0->LayerJson(settings0->_userSettings);
-        // settings0->_ValidateSettings();
+        VerifyParseSucceeded(settingsJson1);
+        auto settings1 = std::make_shared<CascadiaSettings>(false);
+        VERIFY_IS_NOT_NULL(settings1);
+        settings1->_ParseJsonString(settingsJson1, false);
+        settings1->LayerJson(settings1->_userSettings);
+        settings1->_ValidateSettings();
 
-        // VerifyParseSucceeded(settingsJson1);
-        // auto settings1 = std::make_shared<CascadiaSettings>(false);
-        // VERIFY_IS_NOT_NULL(settings1);
-        // settings1->_ParseJsonString(settingsJson1, false);
-        // settings1->LayerJson(settings1->_userSettings);
-        // settings1->_ValidateSettings();
+        const auto guid1 = Microsoft::Console::Utils::GuidFromString(L"{6239a42c-1111-49a3-80bd-e8fdd045185c}");
+        const auto guid2 = Microsoft::Console::Utils::GuidFromString(L"{6239a42c-2222-49a3-80bd-e8fdd045185c}");
+        const auto guid3 = Microsoft::Console::Utils::GuidFromString(L"{6239a42c-3333-49a3-80bd-e8fdd045185c}");
 
-        // const auto guid1 = Microsoft::Console::Utils::GuidFromString(L"{6239a42c-1111-49a3-80bd-e8fdd045185c}");
-        // const auto guid2 = Microsoft::Console::Utils::GuidFromString(L"{6239a42c-2222-49a3-80bd-e8fdd045185c}");
-        // const auto guid3 = Microsoft::Console::Utils::GuidFromString(L"{6239a42c-3333-49a3-80bd-e8fdd045185c}");
+        // This is super wacky, but we can't just initialize the
+        // com_ptr<impl::TerminalPage> in the lambda and assign it back out of
+        // the lambda. We'll crash trying to get a weak_ref to the TerminalPage
+        // during TerminalPage::Create() below.
+        //
+        // Instead, create the winrt object, then get a com_ptr to the
+        // implementation _from_ the winrt object. This seems to work, even if
+        // it's weird.
+        winrt::com_ptr<winrt::TerminalApp::implementation::TerminalPage> page{ nullptr };
+        _initializeTerminalPage(page, settings0);
 
-        // // This is super wacky, but we can't just initialize the
-        // // com_ptr<impl::TerminalPage> in the lambda and assign it back out of
-        // // the lambda. We'll crash trying to get a weak_ref to the TerminalPage
-        // // during TerminalPage::Create() below.
-        // //
-        // // Instead, create the winrt object, then get a com_ptr to the
-        // // implementation _from_ the winrt object. This seems to work, even if
-        // // it's weird.
-        // winrt::com_ptr<winrt::TerminalApp::implementation::TerminalPage> page{ nullptr };
-        // _initializeTerminalPage(page, settings0);
+        auto result = RunOnUIThread([&page]() {
+            VERIFY_ARE_EQUAL(1u, page->_tabs.Size());
+        });
+        VERIFY_SUCCEEDED(result);
 
-        // auto result = RunOnUIThread([&page]() {
-        //     VERIFY_ARE_EQUAL(1u, page->_tabs.Size());
-        // });
-        // VERIFY_SUCCEEDED(result);
+        result = RunOnUIThread([&page]() {
+            VERIFY_ARE_EQUAL(1u, page->_tabs.Size());
+            auto tab = page->_GetStrongTabImpl(0);
+            VERIFY_ARE_EQUAL(1, tab->GetLeafPaneCount());
+        });
+        VERIFY_SUCCEEDED(result);
 
-        // result = RunOnUIThread([&page]() {
-        //     VERIFY_ARE_EQUAL(1u, page->_tabs.Size());
-        //     auto tab = page->_GetStrongTabImpl(0);
-        //     VERIFY_ARE_EQUAL(1, tab->_GetLeafPaneCount());
-        // });
-        // VERIFY_SUCCEEDED(result);
+        Log::Comment(NoThrowString().Format(L"Duplicate the first pane"));
+        result = RunOnUIThread([&page]() {
+            page->_SplitPane(SplitState::Automatic, SplitType::Duplicate, nullptr);
 
-        // Log::Comment(NoThrowString().Format(L"Duplicate the first pane"));
-        // result = RunOnUIThread([&page]() {
-        //     page->_SplitPane(SplitState::Automatic, SplitType::Duplicate, nullptr);
+            VERIFY_ARE_EQUAL(1u, page->_tabs.Size());
+            auto tab = page->_GetStrongTabImpl(0);
+            VERIFY_ARE_EQUAL(2, tab->GetLeafPaneCount());
+        });
+        VERIFY_SUCCEEDED(result);
 
-        //     VERIFY_ARE_EQUAL(1u, page->_tabs.Size());
-        //     auto tab = page->_GetStrongTabImpl(0);
-        //     VERIFY_ARE_EQUAL(2, tab->_GetLeafPaneCount());
-        // });
-        // VERIFY_SUCCEEDED(result);
+        Log::Comment(NoThrowString().Format(
+            L"Change the settings of the TerminalPage so the first profile is "
+            L"no longer in the list of profiles"));
+        result = RunOnUIThread([&page, settings1]() {
+            page->_settings = settings1;
+        });
+        VERIFY_SUCCEEDED(result);
 
-        // Log::Comment(NoThrowString().Format(
-        //     L"Change the settings of the TerminalPage so the first profile is "
-        //     L"no longer in the list of profiles"));
-        // result = RunOnUIThread([&page, settings1]() {
-        //     page->_settings = settings1;
-        // });
-        // VERIFY_SUCCEEDED(result);
+        Log::Comment(NoThrowString().Format(L"Duplicate the pane, and don't crash"));
+        result = RunOnUIThread([&page]() {
+            page->_SplitPane(SplitState::Automatic, SplitType::Duplicate, nullptr);
 
-        // Log::Comment(NoThrowString().Format(L"Duplicate the pane, and don't crash"));
-        // result = RunOnUIThread([&page]() {
-        //     page->_SplitPane(SplitState::Automatic, SplitType::Duplicate, nullptr);
+            VERIFY_ARE_EQUAL(1u, page->_tabs.Size());
+            auto tab = page->_GetStrongTabImpl(0);
+            VERIFY_ARE_EQUAL(2,
+                             tab->GetLeafPaneCount(),
+                             L"We should gracefully do nothing here - the profile no longer exists.");
+        });
+        VERIFY_SUCCEEDED(result);
 
-        //     VERIFY_ARE_EQUAL(1u, page->_tabs.Size());
-        //     auto tab = page->_GetStrongTabImpl(0);
-        //     VERIFY_ARE_EQUAL(2,
-        //                      tab->_GetLeafPaneCount(),
-        //                      L"We should gracefully do nothing here - the profile no longer exists.");
-        // });
-        // VERIFY_SUCCEEDED(result);
-
-        // auto cleanup = wil::scope_exit([] {
-        //     auto result = RunOnUIThread([]() {
-        //         // There's something causing us to crash north of
-        //         // TSFInputControl::NotifyEnter, or LayoutRequested. It's very
-        //         // unclear what that issue is. Since these tests don't run in
-        //         // CI, simply log a message so that the dev running these tests
-        //         // knows it's expected.
-        //         Log::Comment(L"This test often crashes on cleanup, even when it succeeds. If it succeeded, then crashes, that's okay.");
-        //     });
-        //     VERIFY_SUCCEEDED(result);
-        // });
+        auto cleanup = wil::scope_exit([] {
+            auto result = RunOnUIThread([]() {
+                // There's something causing us to crash north of
+                // TSFInputControl::NotifyEnter, or LayoutRequested. It's very
+                // unclear what that issue is. Since these tests don't run in
+                // CI, simply log a message so that the dev running these tests
+                // knows it's expected.
+                Log::Comment(L"This test often crashes on cleanup, even when it succeeds. If it succeeded, then crashes, that's okay.");
+            });
+            VERIFY_SUCCEEDED(result);
+        });
     }
 
 }

src/cascadia/LocalTests_TerminalApp/TerminalApp.LocalTests.vcxproj

@@ -74,15 +74,14 @@
 
   <!-- ========================= Project References ======================== -->
   <ItemGroup>
-    <ProjectReference Include="$(OpenConsoleDir)\src\cascadia\TerminalApp\lib\TerminalAppLib.vcxproj" />
+    <ProjectReference Include="$(OpenConsoleDir)\src\cascadia\TerminalApp\TerminalAppLib.vcxproj" />
     <ProjectReference Include="$(OpenConsoleDir)\src\types\lib\types.vcxproj" />
 
     <!-- If you don't reference these projects here, the
     _ConsoleGenerateAdditionalWinmdManifests step won't gather the winmd's -->
-    <ProjectReference Include="$(OpenConsoleDir)src\cascadia\TerminalSettings\TerminalSettings.vcxproj" />
     <ProjectReference Include="$(OpenConsoleDir)src\cascadia\TerminalControl\TerminalControl.vcxproj" />
     <ProjectReference Include="$(OpenConsoleDir)src\cascadia\TerminalConnection\TerminalConnection.vcxproj" />
-    <ProjectReference Include="$(OpenConsoleDir)src\cascadia\TerminalApp\TerminalApp.vcxproj" />
+    <ProjectReference Include="$(OpenConsoleDir)src\cascadia\TerminalApp\dll\TerminalApp.vcxproj" />
   </ItemGroup>
 
   <!-- ========================= Globals ======================== -->
@@ -90,7 +89,7 @@
   <!-- ====================== Compiler & Linker Flags ===================== -->
   <ItemDefinitionGroup>
     <ClCompile>
-      <AdditionalIncludeDirectories>..;$(OpenConsoleDir)\dep;$(OpenConsoleDir)\dep\jsoncpp\json;$(OpenConsoleDir)src\inc;$(OpenConsoleDir)src\inc\test;$(WinRT_IncludePath)\..\cppwinrt\winrt;"$(OpenConsoleDir)\src\cascadia\TerminalApp\lib\Generated Files";%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+      <AdditionalIncludeDirectories>..;$(OpenConsoleDir)\dep;$(OpenConsoleDir)\dep\jsoncpp\json;$(OpenConsoleDir)src\inc;$(OpenConsoleDir)src\inc\test;$(WinRT_IncludePath)\..\cppwinrt\winrt;"$(OpenConsoleDir)\src\cascadia\TerminalApp\Generated Files";%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
       <PrecompiledHeaderFile>pch.h</PrecompiledHeaderFile>
 
       <!-- Manually disable unreachable code warning, because jconcpp has a ton of that. -->

src/cascadia/LocalTests_TerminalApp/TestHostApp/TestHostApp.vcxproj

@@ -45,11 +45,11 @@
     "taef.png" is actually in the package. taef.png will get copied to the
     OutputPath when taef is run, but if this isn't set to false, then the CI
     will try and make sure taef.png is in the OutputPath at build time.-->
-  
+
   <PropertyGroup Label="UserMacros">
     <GenerateAppxPackageOnBuild>false</GenerateAppxPackageOnBuild>
   </PropertyGroup>
-  
+
   <ItemDefinitionGroup>
     <ClCompile>
       <DisableSpecificWarnings>4453;%(DisableSpecificWarnings)</DisableSpecificWarnings>
@@ -94,10 +94,9 @@
     <ProjectReference Include="$(OpenConsoleDir)src\cascadia\TerminalConnection\TerminalConnection.vcxproj">
       <Project>{CA5CAD1A-C46D-4588-B1C0-40F31AE9100B}</Project>
     </ProjectReference>
-    <ProjectReference Include="$(OpenConsoleDir)src\cascadia\TerminalSettings\TerminalSettings.vcxproj" />
     <ProjectReference Include="$(OpenConsoleDir)src\cascadia\TerminalControl\TerminalControl.vcxproj" />
 
-    <ProjectReference Include="$(OpenConsoleDir)src\cascadia\TerminalApp\TerminalApp.vcxproj">
+    <ProjectReference Include="$(OpenConsoleDir)src\cascadia\TerminalApp\dll\TerminalApp.vcxproj">
       <Project>{ca5cad1a-44bd-4ac7-ac72-f16e576fdd12}</Project>
     </ProjectReference>
 
@@ -114,7 +113,7 @@
 
   <ItemGroup>
     <Reference Include="Microsoft.VisualStudio.TestPlatform.TestExecutor.WinRTCore">
-      <HintPath>$(OpenConsoleDir)\packages\Taef.Redist.Wlk.10.51.200127004\lib\Microsoft.VisualStudio.TestPlatform.TestExecutor.WinRTCore.winmd</HintPath>
+      <HintPath>$(OpenConsoleDir)\packages\Taef.Redist.Wlk.10.57.200731005-develop\lib\Microsoft.VisualStudio.TestPlatform.TestExecutor.WinRTCore.winmd</HintPath>
       <IsWinMDFile>true</IsWinMDFile>
 
       <!-- This path is _relative to the .winmd_ -->

src/cascadia/LocalTests_TerminalApp/TestUtils.h

@@ -24,18 +24,18 @@ public:
     // Return Value:
     // - The ActionAndArgs bound to the given key, or nullptr if nothing is bound to it.
     static const winrt::TerminalApp::ActionAndArgs GetActionAndArgs(const winrt::TerminalApp::implementation::AppKeyBindings& bindings,
-                                                                    const winrt::Microsoft::Terminal::Settings::KeyChord& kc)
+                                                                    const winrt::Microsoft::Terminal::TerminalControl::KeyChord& kc)
     {
         std::wstring buffer{ L"" };
-        if (WI_IsFlagSet(kc.Modifiers(), winrt::Microsoft::Terminal::Settings::KeyModifiers::Ctrl))
+        if (WI_IsFlagSet(kc.Modifiers(), winrt::Microsoft::Terminal::TerminalControl::KeyModifiers::Ctrl))
         {
             buffer += L"Ctrl+";
         }
-        if (WI_IsFlagSet(kc.Modifiers(), winrt::Microsoft::Terminal::Settings::KeyModifiers::Shift))
+        if (WI_IsFlagSet(kc.Modifiers(), winrt::Microsoft::Terminal::TerminalControl::KeyModifiers::Shift))
         {
             buffer += L"Shift+";
         }
-        if (WI_IsFlagSet(kc.Modifiers(), winrt::Microsoft::Terminal::Settings::KeyModifiers::Alt))
+        if (WI_IsFlagSet(kc.Modifiers(), winrt::Microsoft::Terminal::TerminalControl::KeyModifiers::Alt))
         {
             buffer += L"Alt+";
         }

src/cascadia/PublicTerminalCore/HwndTerminal.cpp

@@ -242,7 +242,7 @@ HRESULT HwndTerminal::Initialize()
     _terminal->Create(COORD{ 80, 25 }, 1000, *_renderer);
     _terminal->SetDefaultBackground(RGB(12, 12, 12));
     _terminal->SetDefaultForeground(RGB(204, 204, 204));
-    _terminal->SetWriteInputCallback([=](std::wstring & input) noexcept { _WriteTextToConnection(input); });
+    _terminal->SetWriteInputCallback([=](std::wstring& input) noexcept { _WriteTextToConnection(input); });
     localPointerToThread->EnablePainting();
 
     _multiClickTime = std::chrono::milliseconds{ GetDoubleClickTime() };
@@ -433,7 +433,15 @@ void _stdcall TerminalSendOutput(void* terminal, LPCWSTR data)
     publicTerminal->SendOutput(data);
 }
 
-HRESULT _stdcall TerminalTriggerResize(void* terminal, double width, double height, _Out_ COORD* dimensions)
+/// <summary>
+/// Triggers a terminal resize using the new width and height in pixel.
+/// </summary>
+/// <param name="terminal">Terminal pointer.</param>
+/// <param name="width">New width of the terminal in pixels.</param>
+/// <param name="height">New height of the terminal in pixels</param>
+/// <param name="dimensions">Out parameter containing the columns and rows that fit the new size.</param>
+/// <returns>HRESULT of the attempted resize.</returns>
+HRESULT _stdcall TerminalTriggerResize(_In_ void* terminal, _In_ short width, _In_ short height, _Out_ COORD* dimensions)
 {
     const auto publicTerminal = static_cast<HwndTerminal*>(terminal);
 
@@ -446,10 +454,55 @@ HRESULT _stdcall TerminalTriggerResize(void* terminal, double width, double heig
         static_cast<int>(height),
         0));
 
-    const SIZE windowSize{ static_cast<short>(width), static_cast<short>(height) };
+    const SIZE windowSize{ width, height };
     return publicTerminal->Refresh(windowSize, dimensions);
 }
 
+/// <summary>
+/// Helper method for resizing the terminal using character column and row counts
+/// </summary>
+/// <param name="terminal">Pointer to the terminal object.</param>
+/// <param name="dimensionsInCharacters">New terminal size in row and column count.</param>
+/// <param name="dimensionsInPixels">Out parameter with the new size of the renderer.</param>
+/// <returns>HRESULT of the attempted resize.</returns>
+HRESULT _stdcall TerminalTriggerResizeWithDimension(_In_ void* terminal, _In_ COORD dimensionsInCharacters, _Out_ SIZE* dimensionsInPixels)
+{
+    RETURN_HR_IF_NULL(E_INVALIDARG, dimensionsInPixels);
+
+    const auto publicTerminal = static_cast<const HwndTerminal*>(terminal);
+
+    const auto viewInCharacters = Viewport::FromDimensions({ 0, 0 }, { (dimensionsInCharacters.X), (dimensionsInCharacters.Y) });
+    const auto viewInPixels = publicTerminal->_renderEngine->GetViewportInPixels(viewInCharacters);
+
+    dimensionsInPixels->cx = viewInPixels.Width();
+    dimensionsInPixels->cy = viewInPixels.Height();
+
+    COORD unused{ 0, 0 };
+
+    return TerminalTriggerResize(terminal, viewInPixels.Width(), viewInPixels.Height(), &unused);
+}
+
+/// <summary>
+/// Calculates the amount of rows and columns that fit in the provided width and height.
+/// </summary>
+/// <param name="terminal">Terminal pointer</param>
+/// <param name="width">Width of the terminal area to calculate.</param>
+/// <param name="height">Height of the terminal area to calculate.</param>
+/// <param name="dimensions">Out parameter containing the columns and rows that fit the new size.</param>
+/// <returns>HRESULT of the calculation.</returns>
+HRESULT _stdcall TerminalCalculateResize(_In_ void* terminal, _In_ short width, _In_ short height, _Out_ COORD* dimensions)
+{
+    const auto publicTerminal = static_cast<const HwndTerminal*>(terminal);
+
+    const auto viewInPixels = Viewport::FromDimensions({ 0, 0 }, { width, height });
+    const auto viewInCharacters = publicTerminal->_renderEngine->GetViewportInCharacters(viewInPixels);
+
+    dimensions->X = viewInCharacters.Width();
+    dimensions->Y = viewInCharacters.Height();
+
+    return S_OK;
+}
+
 void _stdcall TerminalDpiChanged(void* terminal, int newDpi)
 {
     const auto publicTerminal = static_cast<HwndTerminal*>(terminal);
@@ -760,18 +813,6 @@ void _stdcall TerminalSetTheme(void* terminal, TerminalTheme theme, LPCWSTR font
     publicTerminal->Refresh(windowSize, &dimensions);
 }
 
-// Resizes the terminal to the specified rows and columns.
-HRESULT _stdcall TerminalResize(void* terminal, COORD dimensions)
-{
-    const auto publicTerminal = static_cast<const HwndTerminal*>(terminal);
-
-    auto lock = publicTerminal->_terminal->LockForWriting();
-    publicTerminal->_terminal->ClearSelection();
-    publicTerminal->_renderer->TriggerRedrawAll();
-
-    return publicTerminal->_terminal->UserResize(dimensions);
-}
-
 void _stdcall TerminalBlinkCursor(void* terminal)
 {
     const auto publicTerminal = static_cast<const HwndTerminal*>(terminal);

src/cascadia/PublicTerminalCore/HwndTerminal.hpp

@@ -27,8 +27,9 @@ extern "C" {
 __declspec(dllexport) HRESULT _stdcall CreateTerminal(HWND parentHwnd, _Out_ void** hwnd, _Out_ void** terminal);
 __declspec(dllexport) void _stdcall TerminalSendOutput(void* terminal, LPCWSTR data);
 __declspec(dllexport) void _stdcall TerminalRegisterScrollCallback(void* terminal, void __stdcall callback(int, int, int));
-__declspec(dllexport) HRESULT _stdcall TerminalTriggerResize(void* terminal, double width, double height, _Out_ COORD* dimensions);
-__declspec(dllexport) HRESULT _stdcall TerminalResize(void* terminal, COORD dimensions);
+__declspec(dllexport) HRESULT _stdcall TerminalTriggerResize(_In_ void* terminal, _In_ short width, _In_ short height, _Out_ COORD* dimensions);
+__declspec(dllexport) HRESULT _stdcall TerminalTriggerResizeWithDimension(_In_ void* terminal, _In_ COORD dimensions, _Out_ SIZE* dimensionsInPixels);
+__declspec(dllexport) HRESULT _stdcall TerminalCalculateResize(_In_ void* terminal, _In_ short width, _In_ short height, _Out_ COORD* dimensions);
 __declspec(dllexport) void _stdcall TerminalDpiChanged(void* terminal, int newDpi);
 __declspec(dllexport) void _stdcall TerminalUserScroll(void* terminal, int viewTop);
 __declspec(dllexport) void _stdcall TerminalClearSelection(void* terminal);
@@ -90,7 +91,9 @@ private:
     std::optional<til::point> _singleClickTouchdownPos;
 
     friend HRESULT _stdcall CreateTerminal(HWND parentHwnd, _Out_ void** hwnd, _Out_ void** terminal);
-    friend HRESULT _stdcall TerminalResize(void* terminal, COORD dimensions);
+    friend HRESULT _stdcall TerminalTriggerResize(_In_ void* terminal, _In_ short width, _In_ short height, _Out_ COORD* dimensions);
+    friend HRESULT _stdcall TerminalTriggerResizeWithDimension(_In_ void* terminal, _In_ COORD dimensions, _Out_ SIZE* dimensionsInPixels);
+    friend HRESULT _stdcall TerminalCalculateResize(_In_ void* terminal, _In_ short width, _In_ short height, _Out_ COORD* dimensions);
     friend void _stdcall TerminalDpiChanged(void* terminal, int newDpi);
     friend void _stdcall TerminalUserScroll(void* terminal, int viewTop);
     friend void _stdcall TerminalClearSelection(void* terminal);

src/cascadia/TerminalApp/ActionAndArgs.cpp

@@ -2,40 +2,49 @@
 #include "ActionArgs.h"
 #include "ActionAndArgs.h"
 #include "ActionAndArgs.g.cpp"
+
+#include "JsonUtils.h"
+
 #include <LibraryResources.h>
 
+static constexpr std::string_view AdjustFontSizeKey{ "adjustFontSize" };
+static constexpr std::string_view CloseOtherTabsKey{ "closeOtherTabs" };
+static constexpr std::string_view ClosePaneKey{ "closePane" };
+static constexpr std::string_view CloseTabKey{ "closeTab" };
+static constexpr std::string_view CloseTabsAfterKey{ "closeTabsAfter" };
+static constexpr std::string_view CloseWindowKey{ "closeWindow" };
 static constexpr std::string_view CopyTextKey{ "copy" };
-static constexpr std::string_view PasteTextKey{ "paste" };
-static constexpr std::string_view OpenNewTabDropdownKey{ "openNewTabDropdown" };
 static constexpr std::string_view DuplicateTabKey{ "duplicateTab" };
+static constexpr std::string_view ExecuteCommandlineKey{ "wt" };
+static constexpr std::string_view FindKey{ "find" };
+static constexpr std::string_view MoveFocusKey{ "moveFocus" };
 static constexpr std::string_view NewTabKey{ "newTab" };
 static constexpr std::string_view NewWindowKey{ "newWindow" };
-static constexpr std::string_view CloseWindowKey{ "closeWindow" };
-static constexpr std::string_view CloseTabKey{ "closeTab" };
-static constexpr std::string_view ClosePaneKey{ "closePane" };
-static constexpr std::string_view SwitchtoTabKey{ "switchToTab" };
 static constexpr std::string_view NextTabKey{ "nextTab" };
-static constexpr std::string_view PrevTabKey{ "prevTab" };
-static constexpr std::string_view AdjustFontSizeKey{ "adjustFontSize" };
-static constexpr std::string_view ResetFontSizeKey{ "resetFontSize" };
-static constexpr std::string_view ScrollupKey{ "scrollUp" };
-static constexpr std::string_view ScrolldownKey{ "scrollDown" };
-static constexpr std::string_view ScrolluppageKey{ "scrollUpPage" };
-static constexpr std::string_view ScrolldownpageKey{ "scrollDownPage" };
-static constexpr std::string_view SwitchToTabKey{ "switchToTab" };
+static constexpr std::string_view OpenNewTabDropdownKey{ "openNewTabDropdown" };
 static constexpr std::string_view OpenSettingsKey{ "openSettings" }; // TODO GH#2557: Add args for OpenSettings
-static constexpr std::string_view SplitPaneKey{ "splitPane" };
+static constexpr std::string_view OpenTabColorPickerKey{ "openTabColorPicker" };
+static constexpr std::string_view PasteTextKey{ "paste" };
+static constexpr std::string_view PrevTabKey{ "prevTab" };
+static constexpr std::string_view RenameTabKey{ "renameTab" };
+static constexpr std::string_view ResetFontSizeKey{ "resetFontSize" };
 static constexpr std::string_view ResizePaneKey{ "resizePane" };
-static constexpr std::string_view MoveFocusKey{ "moveFocus" };
-static constexpr std::string_view FindKey{ "find" };
-static constexpr std::string_view ToggleRetroEffectKey{ "toggleRetroEffect" };
+static constexpr std::string_view ScrolldownKey{ "scrollDown" };
+static constexpr std::string_view ScrolldownpageKey{ "scrollDownPage" };
+static constexpr std::string_view ScrollupKey{ "scrollUp" };
+static constexpr std::string_view ScrolluppageKey{ "scrollUpPage" };
+static constexpr std::string_view SendInputKey{ "sendInput" };
+static constexpr std::string_view SetColorSchemeKey{ "setColorScheme" };
+static constexpr std::string_view SetTabColorKey{ "setTabColor" };
+static constexpr std::string_view SplitPaneKey{ "splitPane" };
+static constexpr std::string_view SwitchToTabKey{ "switchToTab" };
+static constexpr std::string_view TabSearchKey{ "tabSearch" };
+static constexpr std::string_view ToggleAlwaysOnTopKey{ "toggleAlwaysOnTop" };
+static constexpr std::string_view ToggleCommandPaletteKey{ "commandPalette" };
 static constexpr std::string_view ToggleFocusModeKey{ "toggleFocusMode" };
 static constexpr std::string_view ToggleFullscreenKey{ "toggleFullscreen" };
-static constexpr std::string_view ToggleAlwaysOnTopKey{ "toggleAlwaysOnTop" };
-static constexpr std::string_view SetTabColorKey{ "setTabColor" };
-static constexpr std::string_view OpenTabColorPickerKey{ "openTabColorPicker" };
-static constexpr std::string_view RenameTabKey{ "renameTab" };
-static constexpr std::string_view ToggleCommandPaletteKey{ "commandPalette" };
+static constexpr std::string_view TogglePaneZoomKey{ "togglePaneZoom" };
+static constexpr std::string_view ToggleRetroEffectKey{ "toggleRetroEffect" };
 
 static constexpr std::string_view ActionKey{ "action" };
 
@@ -44,6 +53,8 @@ static constexpr std::string_view UnboundKey{ "unbound" };
 
 namespace winrt::TerminalApp::implementation
 {
+    using namespace ::TerminalApp;
+
     // Specifically use a map here over an unordered_map. We want to be able to
     // iterate over these entries in-order when we're serializing the keybindings.
     // HERE BE DRAGONS:
@@ -53,38 +64,45 @@ namespace winrt::TerminalApp::implementation
     // the map are all const for the lifetime of the app, we have nothing to worry
     // about here.
     const std::map<std::string_view, ShortcutAction, std::less<>> ActionAndArgs::ActionKeyNamesMap{
+        { AdjustFontSizeKey, ShortcutAction::AdjustFontSize },
+        { CloseOtherTabsKey, ShortcutAction::CloseOtherTabs },
+        { ClosePaneKey, ShortcutAction::ClosePane },
+        { CloseTabKey, ShortcutAction::CloseTab },
+        { CloseTabsAfterKey, ShortcutAction::CloseTabsAfter },
+        { CloseWindowKey, ShortcutAction::CloseWindow },
         { CopyTextKey, ShortcutAction::CopyText },
-        { PasteTextKey, ShortcutAction::PasteText },
-        { OpenNewTabDropdownKey, ShortcutAction::OpenNewTabDropdown },
         { DuplicateTabKey, ShortcutAction::DuplicateTab },
+        { ExecuteCommandlineKey, ShortcutAction::ExecuteCommandline },
+        { FindKey, ShortcutAction::Find },
+        { MoveFocusKey, ShortcutAction::MoveFocus },
         { NewTabKey, ShortcutAction::NewTab },
         { NewWindowKey, ShortcutAction::NewWindow },
-        { CloseWindowKey, ShortcutAction::CloseWindow },
-        { CloseTabKey, ShortcutAction::CloseTab },
-        { ClosePaneKey, ShortcutAction::ClosePane },
         { NextTabKey, ShortcutAction::NextTab },
-        { PrevTabKey, ShortcutAction::PrevTab },
-        { AdjustFontSizeKey, ShortcutAction::AdjustFontSize },
-        { ResetFontSizeKey, ShortcutAction::ResetFontSize },
-        { ScrollupKey, ShortcutAction::ScrollUp },
-        { ScrolldownKey, ShortcutAction::ScrollDown },
-        { ScrolluppageKey, ShortcutAction::ScrollUpPage },
-        { ScrolldownpageKey, ShortcutAction::ScrollDownPage },
-        { SwitchToTabKey, ShortcutAction::SwitchToTab },
-        { ResizePaneKey, ShortcutAction::ResizePane },
-        { MoveFocusKey, ShortcutAction::MoveFocus },
+        { OpenNewTabDropdownKey, ShortcutAction::OpenNewTabDropdown },
         { OpenSettingsKey, ShortcutAction::OpenSettings },
-        { ToggleRetroEffectKey, ShortcutAction::ToggleRetroEffect },
+        { OpenTabColorPickerKey, ShortcutAction::OpenTabColorPicker },
+        { PasteTextKey, ShortcutAction::PasteText },
+        { PrevTabKey, ShortcutAction::PrevTab },
+        { RenameTabKey, ShortcutAction::RenameTab },
+        { ResetFontSizeKey, ShortcutAction::ResetFontSize },
+        { ResizePaneKey, ShortcutAction::ResizePane },
+        { ScrolldownKey, ShortcutAction::ScrollDown },
+        { ScrolldownpageKey, ShortcutAction::ScrollDownPage },
+        { ScrollupKey, ShortcutAction::ScrollUp },
+        { ScrolluppageKey, ShortcutAction::ScrollUpPage },
+        { SendInputKey, ShortcutAction::SendInput },
+        { SetColorSchemeKey, ShortcutAction::SetColorScheme },
+        { SetTabColorKey, ShortcutAction::SetTabColor },
+        { SplitPaneKey, ShortcutAction::SplitPane },
+        { SwitchToTabKey, ShortcutAction::SwitchToTab },
+        { TabSearchKey, ShortcutAction::TabSearch },
+        { ToggleAlwaysOnTopKey, ShortcutAction::ToggleAlwaysOnTop },
+        { ToggleCommandPaletteKey, ShortcutAction::ToggleCommandPalette },
         { ToggleFocusModeKey, ShortcutAction::ToggleFocusMode },
         { ToggleFullscreenKey, ShortcutAction::ToggleFullscreen },
-        { ToggleAlwaysOnTopKey, ShortcutAction::ToggleAlwaysOnTop },
-        { SplitPaneKey, ShortcutAction::SplitPane },
-        { SetTabColorKey, ShortcutAction::SetTabColor },
-        { OpenTabColorPickerKey, ShortcutAction::OpenTabColorPicker },
+        // { TogglePaneZoomKey, ShortcutAction::TogglePaneZoom }, // TODO GH#7252: Re-enable pane zooming
+        { ToggleRetroEffectKey, ShortcutAction::ToggleRetroEffect },
         { UnboundKey, ShortcutAction::Invalid },
-        { FindKey, ShortcutAction::Find },
-        { RenameTabKey, ShortcutAction::RenameTab },
-        { ToggleCommandPaletteKey, ShortcutAction::ToggleCommandPalette },
     };
 
     using ParseResult = std::tuple<IActionArgs, std::vector<::TerminalApp::SettingsLoadWarnings>>;
@@ -96,25 +114,21 @@ namespace winrt::TerminalApp::implementation
     // placed into this map, with the corresponding deserializer function as the
     // value.
     static const std::map<ShortcutAction, ParseActionFunction, std::less<>> argParsers{
-        { ShortcutAction::CopyText, winrt::TerminalApp::implementation::CopyTextArgs::FromJson },
-
-        { ShortcutAction::NewTab, winrt::TerminalApp::implementation::NewTabArgs::FromJson },
-
-        { ShortcutAction::SwitchToTab, winrt::TerminalApp::implementation::SwitchToTabArgs::FromJson },
-
-        { ShortcutAction::ResizePane, winrt::TerminalApp::implementation::ResizePaneArgs::FromJson },
-
-        { ShortcutAction::MoveFocus, winrt::TerminalApp::implementation::MoveFocusArgs::FromJson },
-
-        { ShortcutAction::AdjustFontSize, winrt::TerminalApp::implementation::AdjustFontSizeArgs::FromJson },
-
-        { ShortcutAction::SplitPane, winrt::TerminalApp::implementation::SplitPaneArgs::FromJson },
-
-        { ShortcutAction::OpenSettings, winrt::TerminalApp::implementation::OpenSettingsArgs::FromJson },
-
-        { ShortcutAction::SetTabColor, winrt::TerminalApp::implementation::SetTabColorArgs::FromJson },
-
-        { ShortcutAction::RenameTab, winrt::TerminalApp::implementation::RenameTabArgs::FromJson },
+        { ShortcutAction::AdjustFontSize, AdjustFontSizeArgs::FromJson },
+        { ShortcutAction::CloseOtherTabs, CloseOtherTabsArgs::FromJson },
+        { ShortcutAction::CloseTabsAfter, CloseTabsAfterArgs::FromJson },
+        { ShortcutAction::CopyText, CopyTextArgs::FromJson },
+        { ShortcutAction::ExecuteCommandline, ExecuteCommandlineArgs::FromJson },
+        { ShortcutAction::MoveFocus, MoveFocusArgs::FromJson },
+        { ShortcutAction::NewTab, NewTabArgs::FromJson },
+        { ShortcutAction::OpenSettings, OpenSettingsArgs::FromJson },
+        { ShortcutAction::RenameTab, RenameTabArgs::FromJson },
+        { ShortcutAction::ResizePane, ResizePaneArgs::FromJson },
+        { ShortcutAction::SendInput, SendInputArgs::FromJson },
+        { ShortcutAction::SetColorScheme, SetColorSchemeArgs::FromJson },
+        { ShortcutAction::SetTabColor, SetTabColorArgs::FromJson },
+        { ShortcutAction::SplitPane, SplitPaneArgs::FromJson },
+        { ShortcutAction::SwitchToTab, SwitchToTabArgs::FromJson },
 
         { ShortcutAction::Invalid, nullptr },
     };
@@ -183,11 +197,9 @@ namespace winrt::TerminalApp::implementation
         }
         else if (json.isObject())
         {
-            const auto actionVal = json[JsonKey(ActionKey)];
-            if (actionVal.isString())
+            if (const auto actionString{ JsonUtils::GetValueForKey<std::optional<std::string>>(json, ActionKey) })
             {
-                auto actionString = actionVal.asString();
-                action = GetActionFromString(actionString);
+                action = GetActionFromString(*actionString);
                 argsVal = json;
             }
         }
@@ -234,38 +246,45 @@ namespace winrt::TerminalApp::implementation
         // to load the resources at _init_, only at runtime.
         static const auto GeneratedActionNames = []() {
             return std::unordered_map<ShortcutAction, winrt::hstring>{
+                { ShortcutAction::AdjustFontSize, RS_(L"AdjustFontSizeCommandKey") },
+                { ShortcutAction::CloseOtherTabs, L"" }, // Intentionally omitted, must be generated by GenerateName
+                { ShortcutAction::ClosePane, RS_(L"ClosePaneCommandKey") },
+                { ShortcutAction::CloseTab, RS_(L"CloseTabCommandKey") },
+                { ShortcutAction::CloseTabsAfter, L"" }, // Intentionally omitted, must be generated by GenerateName
+                { ShortcutAction::CloseWindow, RS_(L"CloseWindowCommandKey") },
                 { ShortcutAction::CopyText, RS_(L"CopyTextCommandKey") },
-                { ShortcutAction::PasteText, RS_(L"PasteTextCommandKey") },
-                { ShortcutAction::OpenNewTabDropdown, RS_(L"OpenNewTabDropdownCommandKey") },
                 { ShortcutAction::DuplicateTab, RS_(L"DuplicateTabCommandKey") },
+                { ShortcutAction::ExecuteCommandline, RS_(L"ExecuteCommandlineCommandKey") },
+                { ShortcutAction::Find, RS_(L"FindCommandKey") },
+                { ShortcutAction::Invalid, L"" },
+                { ShortcutAction::MoveFocus, RS_(L"MoveFocusCommandKey") },
                 { ShortcutAction::NewTab, RS_(L"NewTabCommandKey") },
                 { ShortcutAction::NewWindow, RS_(L"NewWindowCommandKey") },
-                { ShortcutAction::CloseWindow, RS_(L"CloseWindowCommandKey") },
-                { ShortcutAction::CloseTab, RS_(L"CloseTabCommandKey") },
-                { ShortcutAction::ClosePane, RS_(L"ClosePaneCommandKey") },
                 { ShortcutAction::NextTab, RS_(L"NextTabCommandKey") },
-                { ShortcutAction::PrevTab, RS_(L"PrevTabCommandKey") },
-                { ShortcutAction::AdjustFontSize, RS_(L"AdjustFontSizeCommandKey") },
-                { ShortcutAction::ResetFontSize, RS_(L"ResetFontSizeCommandKey") },
-                { ShortcutAction::ScrollUp, RS_(L"ScrollUpCommandKey") },
-                { ShortcutAction::ScrollDown, RS_(L"ScrollDownCommandKey") },
-                { ShortcutAction::ScrollUpPage, RS_(L"ScrollUpPageCommandKey") },
-                { ShortcutAction::ScrollDownPage, RS_(L"ScrollDownPageCommandKey") },
-                { ShortcutAction::SwitchToTab, RS_(L"SwitchToTabCommandKey") },
-                { ShortcutAction::ResizePane, RS_(L"ResizePaneCommandKey") },
-                { ShortcutAction::MoveFocus, RS_(L"MoveFocusCommandKey") },
+                { ShortcutAction::OpenNewTabDropdown, RS_(L"OpenNewTabDropdownCommandKey") },
                 { ShortcutAction::OpenSettings, RS_(L"OpenSettingsCommandKey") },
-                { ShortcutAction::ToggleRetroEffect, RS_(L"ToggleRetroEffectCommandKey") },
+                { ShortcutAction::OpenTabColorPicker, RS_(L"OpenTabColorPickerCommandKey") },
+                { ShortcutAction::PasteText, RS_(L"PasteTextCommandKey") },
+                { ShortcutAction::PrevTab, RS_(L"PrevTabCommandKey") },
+                { ShortcutAction::RenameTab, RS_(L"ResetTabNameCommandKey") },
+                { ShortcutAction::ResetFontSize, RS_(L"ResetFontSizeCommandKey") },
+                { ShortcutAction::ResizePane, RS_(L"ResizePaneCommandKey") },
+                { ShortcutAction::ScrollDown, RS_(L"ScrollDownCommandKey") },
+                { ShortcutAction::ScrollDownPage, RS_(L"ScrollDownPageCommandKey") },
+                { ShortcutAction::ScrollUp, RS_(L"ScrollUpCommandKey") },
+                { ShortcutAction::ScrollUpPage, RS_(L"ScrollUpPageCommandKey") },
+                { ShortcutAction::SendInput, L"" },
+                { ShortcutAction::SetColorScheme, L"" },
+                { ShortcutAction::SetTabColor, RS_(L"ResetTabColorCommandKey") },
+                { ShortcutAction::SplitPane, RS_(L"SplitPaneCommandKey") },
+                { ShortcutAction::SwitchToTab, RS_(L"SwitchToTabCommandKey") },
+                { ShortcutAction::TabSearch, RS_(L"TabSearchCommandKey") },
+                { ShortcutAction::ToggleAlwaysOnTop, RS_(L"ToggleAlwaysOnTopCommandKey") },
+                { ShortcutAction::ToggleCommandPalette, RS_(L"ToggleCommandPaletteCommandKey") },
                 { ShortcutAction::ToggleFocusMode, RS_(L"ToggleFocusModeCommandKey") },
                 { ShortcutAction::ToggleFullscreen, RS_(L"ToggleFullscreenCommandKey") },
-                { ShortcutAction::ToggleAlwaysOnTop, RS_(L"ToggleAlwaysOnTopCommandKey") },
-                { ShortcutAction::SplitPane, RS_(L"SplitPaneCommandKey") },
-                { ShortcutAction::Invalid, L"" },
-                { ShortcutAction::Find, RS_(L"FindCommandKey") },
-                { ShortcutAction::SetTabColor, RS_(L"ResetTabColorCommandKey") },
-                { ShortcutAction::OpenTabColorPicker, RS_(L"OpenTabColorPickerCommandKey") },
-                { ShortcutAction::RenameTab, RS_(L"ResetTabNameCommandKey") },
-                { ShortcutAction::ToggleCommandPalette, RS_(L"ToggleCommandPaletteCommandKey") },
+                { ShortcutAction::TogglePaneZoom, RS_(L"TogglePaneZoomCommandKey") },
+                { ShortcutAction::ToggleRetroEffect, RS_(L"ToggleRetroEffectCommandKey") },
             };
         }();
 
@@ -281,5 +300,4 @@ namespace winrt::TerminalApp::implementation
         const auto found = GeneratedActionNames.find(_Action);
         return found != GeneratedActionNames.end() ? found->second : L"";
     }
-
 }

src/cascadia/TerminalApp/ActionArgs.cpp

@@ -13,13 +13,20 @@
 #include "ResizePaneArgs.g.cpp"
 #include "MoveFocusArgs.g.cpp"
 #include "AdjustFontSizeArgs.g.cpp"
+#include "SendInputArgs.g.cpp"
 #include "SplitPaneArgs.g.cpp"
 #include "OpenSettingsArgs.g.cpp"
+#include "SetColorSchemeArgs.g.cpp"
 #include "SetTabColorArgs.g.cpp"
 #include "RenameTabArgs.g.cpp"
+#include "ExecuteCommandlineArgs.g.cpp"
+
+#include "Utils.h"
 
 #include <LibraryResources.h>
 
+using namespace winrt::Microsoft::Terminal::TerminalControl;
+
 namespace winrt::TerminalApp::implementation
 {
     winrt::hstring NewTerminalArgs::GenerateName() const
@@ -61,11 +68,47 @@ namespace winrt::TerminalApp::implementation
 
     winrt::hstring CopyTextArgs::GenerateName() const
     {
+        std::wstringstream ss;
+
         if (_SingleLine)
         {
-            return RS_(L"CopyTextAsSingleLineCommandKey");
+            ss << RS_(L"CopyTextAsSingleLineCommandKey").c_str();
         }
-        return RS_(L"CopyTextCommandKey");
+        else
+        {
+            ss << RS_(L"CopyTextCommandKey").c_str();
+        }
+
+        if (_CopyFormatting != nullptr)
+        {
+            ss << L", copyFormatting: ";
+            if (_CopyFormatting.Value() == CopyFormat::All)
+            {
+                ss << L"all, ";
+            }
+            else if (_CopyFormatting.Value() == static_cast<CopyFormat>(0))
+            {
+                ss << L"none, ";
+            }
+            else
+            {
+                if (WI_IsFlagSet(_CopyFormatting.Value(), CopyFormat::HTML))
+                {
+                    ss << L"html, ";
+                }
+
+                if (WI_IsFlagSet(_CopyFormatting.Value(), CopyFormat::RTF))
+                {
+                    ss << L"rtf, ";
+                }
+            }
+
+            // Chop off the last ","
+            auto result = ss.str();
+            return winrt::hstring{ result.substr(0, result.size() - 2) };
+        }
+
+        return winrt::hstring{ ss.str() };
     }
 
     winrt::hstring NewTabArgs::GenerateName() const
@@ -164,6 +207,16 @@ namespace winrt::TerminalApp::implementation
         }
     }
 
+    winrt::hstring SendInputArgs::GenerateName() const
+    {
+        // The string will be similar to the following:
+        // * "Send Input: ...input..."
+
+        auto escapedInput = VisualizeControlCodes(_Input);
+        auto name = fmt::format(std::wstring_view(RS_(L"SendInputCommandKey")), escapedInput);
+        return winrt::hstring{ name };
+    }
+
     winrt::hstring SplitPaneArgs::GenerateName() const
     {
         // The string will be similar to the following:
@@ -228,6 +281,19 @@ namespace winrt::TerminalApp::implementation
         }
     }
 
+    winrt::hstring SetColorSchemeArgs::GenerateName() const
+    {
+        // "Set color scheme to "{_SchemeName}""
+        if (!_SchemeName.empty())
+        {
+            return winrt::hstring{
+                fmt::format(std::wstring_view(RS_(L"SetColorSchemeCommandKey")),
+                            _SchemeName.c_str())
+            };
+        }
+        return L"";
+    }
+
     winrt::hstring SetTabColorArgs::GenerateName() const
     {
         // "Set tab color to #RRGGBB"
@@ -258,4 +324,42 @@ namespace winrt::TerminalApp::implementation
         return RS_(L"ResetTabNameCommandKey");
     }
 
+    winrt::hstring ExecuteCommandlineArgs::GenerateName() const
+    {
+        // "Run commandline "{_Commandline}" in this window"
+        if (!_Commandline.empty())
+        {
+            return winrt::hstring{
+                fmt::format(std::wstring_view(RS_(L"ExecuteCommandlineCommandKey")),
+                            _Commandline.c_str())
+            };
+        }
+        return L"";
+    }
+
+    winrt::hstring CloseOtherTabsArgs::GenerateName() const
+    {
+        if (_Index)
+        {
+            // "Close tabs other than index {0}"
+            return winrt::hstring{
+                fmt::format(std::wstring_view(RS_(L"CloseOtherTabsCommandKey")),
+                            _Index.Value())
+            };
+        }
+        return RS_(L"CloseOtherTabsDefaultCommandKey");
+    }
+
+    winrt::hstring CloseTabsAfterArgs::GenerateName() const
+    {
+        if (_Index)
+        {
+            // "Close tabs after index {0}"
+            return winrt::hstring{
+                fmt::format(std::wstring_view(RS_(L"CloseTabsAfterCommandKey")),
+                            _Index.Value())
+            };
+        }
+        return RS_(L"CloseTabsAfterDefaultCommandKey");
+    }
 }

src/cascadia/TerminalApp/ActionArgs.h

@@ -13,16 +13,23 @@
 #include "ResizePaneArgs.g.h"
 #include "MoveFocusArgs.g.h"
 #include "AdjustFontSizeArgs.g.h"
+#include "SendInputArgs.g.h"
 #include "SplitPaneArgs.g.h"
 #include "OpenSettingsArgs.g.h"
+#include "SetColorSchemeArgs.g.h"
 #include "SetTabColorArgs.g.h"
 #include "RenameTabArgs.g.h"
+#include "ExecuteCommandlineArgs.g.h"
+#include "CloseOtherTabsArgs.g.h"
+#include "CloseTabsAfterArgs.g.h"
 
 #include "../../cascadia/inc/cppwinrt_utils.h"
 #include "Utils.h"
 #include "JsonUtils.h"
 #include "TerminalWarnings.h"
 
+#include "TerminalSettingsSerializationHelpers.h"
+
 // Notes on defining ActionArgs and ActionEventArgs:
 // * All properties specific to an action should be defined as an ActionArgs
 //   class that implements IActionArgs
@@ -31,6 +38,7 @@
 
 namespace winrt::TerminalApp::implementation
 {
+    using namespace ::TerminalApp;
     using FromJsonResult = std::tuple<winrt::TerminalApp::IActionArgs, std::vector<::TerminalApp::SettingsLoadWarnings>>;
 
     struct ActionEventArgs : public ActionEventArgsT<ActionEventArgs>
@@ -73,26 +81,11 @@ namespace winrt::TerminalApp::implementation
         {
             // LOAD BEARING: Not using make_self here _will_ break you in the future!
             auto args = winrt::make_self<NewTerminalArgs>();
-            if (auto commandline{ json[JsonKey(CommandlineKey)] })
-            {
-                args->_Commandline = winrt::to_hstring(commandline.asString());
-            }
-            if (auto startingDirectory{ json[JsonKey(StartingDirectoryKey)] })
-            {
-                args->_StartingDirectory = winrt::to_hstring(startingDirectory.asString());
-            }
-            if (auto tabTitle{ json[JsonKey(TabTitleKey)] })
-            {
-                args->_TabTitle = winrt::to_hstring(tabTitle.asString());
-            }
-            if (auto index{ json[JsonKey(ProfileIndexKey)] })
-            {
-                args->_ProfileIndex = index.asInt();
-            }
-            if (auto profile{ json[JsonKey(ProfileKey)] })
-            {
-                args->_Profile = winrt::to_hstring(profile.asString());
-            }
+            JsonUtils::GetValueForKey(json, CommandlineKey, args->_Commandline);
+            JsonUtils::GetValueForKey(json, StartingDirectoryKey, args->_StartingDirectory);
+            JsonUtils::GetValueForKey(json, TabTitleKey, args->_TabTitle);
+            JsonUtils::GetValueForKey(json, ProfileIndexKey, args->_ProfileIndex);
+            JsonUtils::GetValueForKey(json, ProfileKey, args->_Profile);
             return *args;
         }
     };
@@ -101,8 +94,10 @@ namespace winrt::TerminalApp::implementation
     {
         CopyTextArgs() = default;
         GETSET_PROPERTY(bool, SingleLine, false);
+        GETSET_PROPERTY(Windows::Foundation::IReference<Microsoft::Terminal::TerminalControl::CopyFormat>, CopyFormatting, nullptr);
 
         static constexpr std::string_view SingleLineKey{ "singleLine" };
+        static constexpr std::string_view CopyFormattingKey{ "copyFormatting" };
 
     public:
         hstring GenerateName() const;
@@ -112,7 +107,8 @@ namespace winrt::TerminalApp::implementation
             auto otherAsUs = other.try_as<CopyTextArgs>();
             if (otherAsUs)
             {
-                return otherAsUs->_SingleLine == _SingleLine;
+                return otherAsUs->_SingleLine == _SingleLine &&
+                       otherAsUs->_CopyFormatting == _CopyFormatting;
             }
             return false;
         };
@@ -120,10 +116,8 @@ namespace winrt::TerminalApp::implementation
         {
             // LOAD BEARING: Not using make_self here _will_ break you in the future!
             auto args = winrt::make_self<CopyTextArgs>();
-            if (auto singleLine{ json[JsonKey(SingleLineKey)] })
-            {
-                args->_SingleLine = singleLine.asBool();
-            }
+            JsonUtils::GetValueForKey(json, SingleLineKey, args->_SingleLine);
+            JsonUtils::GetValueForKey(json, CopyFormattingKey, args->_CopyFormatting);
             return { *args, {} };
         }
     };
@@ -177,49 +171,11 @@ namespace winrt::TerminalApp::implementation
         {
             // LOAD BEARING: Not using make_self here _will_ break you in the future!
             auto args = winrt::make_self<SwitchToTabArgs>();
-            if (auto tabIndex{ json[JsonKey(TabIndexKey)] })
-            {
-                args->_TabIndex = tabIndex.asUInt();
-            }
+            JsonUtils::GetValueForKey(json, TabIndexKey, args->_TabIndex);
             return { *args, {} };
         }
     };
 
-    // Possible Direction values
-    // TODO:GH#2550/#3475 - move these to a centralized deserializing place
-    static constexpr std::string_view LeftString{ "left" };
-    static constexpr std::string_view RightString{ "right" };
-    static constexpr std::string_view UpString{ "up" };
-    static constexpr std::string_view DownString{ "down" };
-
-    // Function Description:
-    // - Helper function for parsing a Direction from a string
-    // Arguments:
-    // - directionString: the string to attempt to parse
-    // Return Value:
-    // - The encoded Direction value, or Direction::None if it was an invalid string
-    static TerminalApp::Direction ParseDirection(const std::string& directionString)
-    {
-        if (directionString == LeftString)
-        {
-            return TerminalApp::Direction::Left;
-        }
-        else if (directionString == RightString)
-        {
-            return TerminalApp::Direction::Right;
-        }
-        else if (directionString == UpString)
-        {
-            return TerminalApp::Direction::Up;
-        }
-        else if (directionString == DownString)
-        {
-            return TerminalApp::Direction::Down;
-        }
-        // default behavior for invalid data
-        return TerminalApp::Direction::None;
-    };
-
     struct ResizePaneArgs : public ResizePaneArgsT<ResizePaneArgs>
     {
         ResizePaneArgs() = default;
@@ -243,10 +199,7 @@ namespace winrt::TerminalApp::implementation
         {
             // LOAD BEARING: Not using make_self here _will_ break you in the future!
             auto args = winrt::make_self<ResizePaneArgs>();
-            if (auto directionString{ json[JsonKey(DirectionKey)] })
-            {
-                args->_Direction = ParseDirection(directionString.asString());
-            }
+            JsonUtils::GetValueForKey(json, DirectionKey, args->_Direction);
             if (args->_Direction == TerminalApp::Direction::None)
             {
                 return { nullptr, { ::TerminalApp::SettingsLoadWarnings::MissingRequiredParameter } };
@@ -281,10 +234,7 @@ namespace winrt::TerminalApp::implementation
         {
             // LOAD BEARING: Not using make_self here _will_ break you in the future!
             auto args = winrt::make_self<MoveFocusArgs>();
-            if (auto directionString{ json[JsonKey(DirectionKey)] })
-            {
-                args->_Direction = ParseDirection(directionString.asString());
-            }
+            JsonUtils::GetValueForKey(json, DirectionKey, args->_Direction);
             if (args->_Direction == TerminalApp::Direction::None)
             {
                 return { nullptr, { ::TerminalApp::SettingsLoadWarnings::MissingRequiredParameter } };
@@ -319,47 +269,41 @@ namespace winrt::TerminalApp::implementation
         {
             // LOAD BEARING: Not using make_self here _will_ break you in the future!
             auto args = winrt::make_self<AdjustFontSizeArgs>();
-            if (auto jsonDelta{ json[JsonKey(AdjustFontSizeDelta)] })
-            {
-                args->_Delta = jsonDelta.asInt();
-            }
+            JsonUtils::GetValueForKey(json, AdjustFontSizeDelta, args->_Delta);
             return { *args, {} };
         }
     };
 
-    // Possible SplitState values
-    // TODO:GH#2550/#3475 - move these to a centralized deserializing place
-    static constexpr std::string_view VerticalKey{ "vertical" };
-    static constexpr std::string_view HorizontalKey{ "horizontal" };
-    static constexpr std::string_view AutomaticKey{ "auto" };
-    static TerminalApp::SplitState ParseSplitState(const std::string& stateString)
+    struct SendInputArgs : public SendInputArgsT<SendInputArgs>
     {
-        if (stateString == VerticalKey)
-        {
-            return TerminalApp::SplitState::Vertical;
-        }
-        else if (stateString == HorizontalKey)
-        {
-            return TerminalApp::SplitState::Horizontal;
-        }
-        else if (stateString == AutomaticKey)
-        {
-            return TerminalApp::SplitState::Automatic;
-        }
-        // default behavior for invalid data
-        return TerminalApp::SplitState::Automatic;
-    };
+        SendInputArgs() = default;
+        GETSET_PROPERTY(winrt::hstring, Input, L"");
 
-    // Possible SplitType values
-    static constexpr std::string_view DuplicateKey{ "duplicate" };
-    static TerminalApp::SplitType ParseSplitModeState(const std::string& stateString)
-    {
-        if (stateString == DuplicateKey)
+        static constexpr std::string_view InputKey{ "input" };
+
+    public:
+        hstring GenerateName() const;
+
+        bool Equals(const IActionArgs& other)
         {
-            return TerminalApp::SplitType::Duplicate;
+            if (auto otherAsUs = other.try_as<SendInputArgs>(); otherAsUs)
+            {
+                return otherAsUs->_Input == _Input;
+            }
+            return false;
+        };
+        static FromJsonResult FromJson(const Json::Value& json)
+        {
+            // LOAD BEARING: Not using make_self here _will_ break you in the future!
+            auto args = winrt::make_self<SendInputArgs>();
+            JsonUtils::GetValueForKey(json, InputKey, args->_Input);
+            if (args->_Input.empty())
+            {
+                return { nullptr, { ::TerminalApp::SettingsLoadWarnings::MissingRequiredParameter } };
+            }
+            return { *args, {} };
         }
-        return TerminalApp::SplitType::Manual;
-    }
+    };
 
     struct SplitPaneArgs : public SplitPaneArgsT<SplitPaneArgs>
     {
@@ -391,48 +335,12 @@ namespace winrt::TerminalApp::implementation
             // LOAD BEARING: Not using make_self here _will_ break you in the future!
             auto args = winrt::make_self<SplitPaneArgs>();
             args->_TerminalArgs = NewTerminalArgs::FromJson(json);
-            if (auto jsonStyle{ json[JsonKey(SplitKey)] })
-            {
-                args->_SplitStyle = ParseSplitState(jsonStyle.asString());
-            }
-            if (auto jsonStyle{ json[JsonKey(SplitModeKey)] })
-            {
-                args->_SplitMode = ParseSplitModeState(jsonStyle.asString());
-            }
+            JsonUtils::GetValueForKey(json, SplitKey, args->_SplitStyle);
+            JsonUtils::GetValueForKey(json, SplitModeKey, args->_SplitMode);
             return { *args, {} };
         }
     };
 
-    // Possible SettingsTarget values
-    // TODO:GH#2550/#3475 - move these to a centralized deserializing place
-    static constexpr std::string_view SettingsFileString{ "settingsFile" };
-    static constexpr std::string_view DefaultsFileString{ "defaultsFile" };
-    static constexpr std::string_view AllFilesString{ "allFiles" };
-
-    // Function Description:
-    // - Helper function for parsing a SettingsTarget from a string
-    // Arguments:
-    // - targetString: the string to attempt to parse
-    // Return Value:
-    // - The encoded SettingsTarget value, or SettingsTarget::SettingsFile if it was an invalid string
-    static TerminalApp::SettingsTarget ParseSettingsTarget(const std::string& targetString)
-    {
-        if (targetString == SettingsFileString)
-        {
-            return TerminalApp::SettingsTarget::SettingsFile;
-        }
-        else if (targetString == DefaultsFileString)
-        {
-            return TerminalApp::SettingsTarget::DefaultsFile;
-        }
-        else if (targetString == AllFilesString)
-        {
-            return TerminalApp::SettingsTarget::AllFiles;
-        }
-        // default behavior for invalid data
-        return TerminalApp::SettingsTarget::SettingsFile;
-    };
-
     struct OpenSettingsArgs : public OpenSettingsArgsT<OpenSettingsArgs>
     {
         OpenSettingsArgs() = default;
@@ -456,9 +364,38 @@ namespace winrt::TerminalApp::implementation
         {
             // LOAD BEARING: Not using make_self here _will_ break you in the future!
             auto args = winrt::make_self<OpenSettingsArgs>();
-            if (auto targetString{ json[JsonKey(TargetKey)] })
+            JsonUtils::GetValueForKey(json, TargetKey, args->_Target);
+            return { *args, {} };
+        }
+    };
+
+    struct SetColorSchemeArgs : public SetColorSchemeArgsT<SetColorSchemeArgs>
+    {
+        SetColorSchemeArgs() = default;
+        GETSET_PROPERTY(winrt::hstring, SchemeName, L"");
+
+        static constexpr std::string_view NameKey{ "colorScheme" };
+
+    public:
+        hstring GenerateName() const;
+
+        bool Equals(const IActionArgs& other)
+        {
+            auto otherAsUs = other.try_as<SetColorSchemeArgs>();
+            if (otherAsUs)
             {
-                args->_Target = ParseSettingsTarget(targetString.asString());
+                return otherAsUs->_SchemeName == _SchemeName;
+            }
+            return false;
+        };
+        static FromJsonResult FromJson(const Json::Value& json)
+        {
+            // LOAD BEARING: Not using make_self here _will_ break you in the future!
+            auto args = winrt::make_self<SetColorSchemeArgs>();
+            JsonUtils::GetValueForKey(json, NameKey, args->_SchemeName);
+            if (args->_SchemeName.empty())
+            {
+                return { nullptr, { ::TerminalApp::SettingsLoadWarnings::MissingRequiredParameter } };
             }
             return { *args, {} };
         }
@@ -487,16 +424,10 @@ namespace winrt::TerminalApp::implementation
         {
             // LOAD BEARING: Not using make_self here _will_ break you in the future!
             auto args = winrt::make_self<SetTabColorArgs>();
-            std::optional<til::color> temp;
-            try
+            if (const auto temp{ JsonUtils::GetValueForKey<std::optional<til::color>>(json, ColorKey) })
             {
-                ::TerminalApp::JsonUtils::GetOptionalColor(json, ColorKey, temp);
-                if (temp.has_value())
-                {
-                    args->_TabColor = static_cast<uint32_t>(temp.value());
-                }
+                args->_TabColor = static_cast<uint32_t>(*temp);
             }
-            CATCH_LOG();
             return { *args, {} };
         }
     };
@@ -524,10 +455,95 @@ namespace winrt::TerminalApp::implementation
         {
             // LOAD BEARING: Not using make_self here _will_ break you in the future!
             auto args = winrt::make_self<RenameTabArgs>();
-            if (auto title{ json[JsonKey(TitleKey)] })
+            JsonUtils::GetValueForKey(json, TitleKey, args->_Title);
+            return { *args, {} };
+        }
+    };
+
+    struct ExecuteCommandlineArgs : public ExecuteCommandlineArgsT<ExecuteCommandlineArgs>
+    {
+        ExecuteCommandlineArgs() = default;
+        GETSET_PROPERTY(winrt::hstring, Commandline, L"");
+
+        static constexpr std::string_view CommandlineKey{ "commandline" };
+
+    public:
+        hstring GenerateName() const;
+
+        bool Equals(const IActionArgs& other)
+        {
+            auto otherAsUs = other.try_as<ExecuteCommandlineArgs>();
+            if (otherAsUs)
             {
-                args->_Title = winrt::to_hstring(title.asString());
+                return otherAsUs->_Commandline == _Commandline;
             }
+            return false;
+        };
+        static FromJsonResult FromJson(const Json::Value& json)
+        {
+            // LOAD BEARING: Not using make_self here _will_ break you in the future!
+            auto args = winrt::make_self<ExecuteCommandlineArgs>();
+            JsonUtils::GetValueForKey(json, CommandlineKey, args->_Commandline);
+            if (args->_Commandline.empty())
+            {
+                return { nullptr, { ::TerminalApp::SettingsLoadWarnings::MissingRequiredParameter } };
+            }
+            return { *args, {} };
+        }
+    };
+
+    struct CloseOtherTabsArgs : public CloseOtherTabsArgsT<CloseOtherTabsArgs>
+    {
+        CloseOtherTabsArgs() = default;
+        GETSET_PROPERTY(winrt::Windows::Foundation::IReference<uint32_t>, Index, nullptr);
+
+        static constexpr std::string_view IndexKey{ "index" };
+
+    public:
+        hstring GenerateName() const;
+
+        bool Equals(const IActionArgs& other)
+        {
+            auto otherAsUs = other.try_as<CloseOtherTabsArgs>();
+            if (otherAsUs)
+            {
+                return otherAsUs->_Index == _Index;
+            }
+            return false;
+        };
+        static FromJsonResult FromJson(const Json::Value& json)
+        {
+            // LOAD BEARING: Not using make_self here _will_ break you in the future!
+            auto args = winrt::make_self<CloseOtherTabsArgs>();
+            JsonUtils::GetValueForKey(json, IndexKey, args->_Index);
+            return { *args, {} };
+        }
+    };
+
+    struct CloseTabsAfterArgs : public CloseTabsAfterArgsT<CloseTabsAfterArgs>
+    {
+        CloseTabsAfterArgs() = default;
+        GETSET_PROPERTY(winrt::Windows::Foundation::IReference<uint32_t>, Index, nullptr);
+
+        static constexpr std::string_view IndexKey{ "index" };
+
+    public:
+        hstring GenerateName() const;
+
+        bool Equals(const IActionArgs& other)
+        {
+            auto otherAsUs = other.try_as<CloseTabsAfterArgs>();
+            if (otherAsUs)
+            {
+                return otherAsUs->_Index == _Index;
+            }
+            return false;
+        };
+        static FromJsonResult FromJson(const Json::Value& json)
+        {
+            // LOAD BEARING: Not using make_self here _will_ break you in the future!
+            auto args = winrt::make_self<CloseTabsAfterArgs>();
+            JsonUtils::GetValueForKey(json, IndexKey, args->_Index);
             return { *args, {} };
         }
     };

src/cascadia/TerminalApp/ActionArgs.idl

@@ -67,6 +67,7 @@ namespace TerminalApp
     [default_interface] runtimeclass CopyTextArgs : IActionArgs
     {
         Boolean SingleLine { get; };
+        Windows.Foundation.IReference<Microsoft.Terminal.TerminalControl.CopyFormat> CopyFormatting { get; };
     };
 
     [default_interface] runtimeclass NewTabArgs : IActionArgs
@@ -94,6 +95,11 @@ namespace TerminalApp
         Int32 Delta { get; };
     };
 
+    [default_interface] runtimeclass SendInputArgs : IActionArgs
+    {
+        String Input { get; };
+    };
+
     [default_interface] runtimeclass SplitPaneArgs : IActionArgs
     {
         SplitState SplitStyle { get; };
@@ -106,6 +112,11 @@ namespace TerminalApp
         SettingsTarget Target { get; };
     };
 
+    [default_interface] runtimeclass SetColorSchemeArgs : IActionArgs
+    {
+        String SchemeName { get; };
+    };
+
     [default_interface] runtimeclass SetTabColorArgs : IActionArgs
     {
         Windows.Foundation.IReference<UInt32> TabColor { get; };
@@ -115,4 +126,19 @@ namespace TerminalApp
     {
         String Title { get; };
     };
+
+    [default_interface] runtimeclass ExecuteCommandlineArgs : IActionArgs
+    {
+        String Commandline;
+    };
+
+    [default_interface] runtimeclass CloseOtherTabsArgs : IActionArgs
+    {
+        Windows.Foundation.IReference<UInt32> Index { get; };
+    };
+
+    [default_interface] runtimeclass CloseTabsAfterArgs : IActionArgs
+    {
+        Windows.Foundation.IReference<UInt32> Index { get; };
+    };
 }

src/cascadia/TerminalApp/App.idl

@@ -1,7 +1,7 @@
 // Copyright (c) Microsoft Corporation.
 // Licensed under the MIT license.
 
-import "../AppLogic.idl";
+import "AppLogic.idl";
 
 namespace TerminalApp
 {

src/cascadia/TerminalApp/AppActionHandlers.cpp

@@ -11,9 +11,9 @@ using namespace winrt::Windows::ApplicationModel::DataTransfer;
 using namespace winrt::Windows::UI::Xaml;
 using namespace winrt::Windows::UI::Text;
 using namespace winrt::Windows::UI::Core;
+using namespace winrt::Windows::Foundation::Collections;
 using namespace winrt::Windows::System;
 using namespace winrt::Microsoft::Terminal;
-using namespace winrt::Microsoft::Terminal::Settings;
 using namespace winrt::Microsoft::Terminal::TerminalControl;
 using namespace winrt::Microsoft::Terminal::TerminalConnection;
 using namespace ::TerminalApp;
@@ -89,6 +89,21 @@ namespace winrt::TerminalApp::implementation
         args.Handled(true);
     }
 
+    void TerminalPage::_HandleSendInput(const IInspectable& /*sender*/,
+                                        const TerminalApp::ActionEventArgs& args)
+    {
+        if (args == nullptr)
+        {
+            args.Handled(false);
+        }
+        else if (const auto& realArgs = args.ActionArgs().try_as<TerminalApp::SendInputArgs>())
+        {
+            const auto termControl = _GetActiveControl();
+            termControl.SendInput(realArgs.Input());
+            args.Handled(true);
+        }
+    }
+
     void TerminalPage::_HandleSplitPane(const IInspectable& /*sender*/,
                                         const TerminalApp::ActionEventArgs& args)
     {
@@ -103,6 +118,28 @@ namespace winrt::TerminalApp::implementation
         }
     }
 
+    void TerminalPage::_HandleTogglePaneZoom(const IInspectable& /*sender*/,
+                                             const TerminalApp::ActionEventArgs& args)
+    {
+        auto activeTab = _GetFocusedTab();
+
+        // Don't do anything if there's only one pane. It's already zoomed.
+        if (activeTab && activeTab->GetLeafPaneCount() > 1)
+        {
+            // First thing's first, remove the current content from the UI
+            // tree. This is important, because we might be leaving zoom, and if
+            // a pane is zoomed, then it's currently in the UI tree, and should
+            // be removed before it's re-added in Pane::Restore
+            _tabContent.Children().Clear();
+
+            activeTab->ToggleZoom();
+
+            // Update the selected tab, to trigger us to re-add the tab's GetRootElement to the UI tree
+            _UpdatedSelectedTab(_tabView.SelectedIndex());
+        }
+        args.Handled(true);
+    }
+
     void TerminalPage::_HandleScrollUpPage(const IInspectable& /*sender*/,
                                            const TerminalApp::ActionEventArgs& args)
     {
@@ -200,7 +237,7 @@ namespace winrt::TerminalApp::implementation
     {
         if (const auto& realArgs = args.ActionArgs().try_as<TerminalApp::CopyTextArgs>())
         {
-            const auto handled = _CopyText(realArgs.SingleLine());
+            const auto handled = _CopyText(realArgs.SingleLine(), realArgs.CopyFormatting());
             args.Handled(handled);
         }
     }
@@ -265,12 +302,34 @@ namespace winrt::TerminalApp::implementation
     {
         // TODO GH#6677: When we add support for commandline mode, first set the
         // mode that the command palette should be in, before making it visible.
+        CommandPalette().EnableCommandPaletteMode();
         CommandPalette().Visibility(CommandPalette().Visibility() == Visibility::Visible ?
                                         Visibility::Collapsed :
                                         Visibility::Visible);
         args.Handled(true);
     }
 
+    void TerminalPage::_HandleSetColorScheme(const IInspectable& /*sender*/,
+                                             const TerminalApp::ActionEventArgs& args)
+    {
+        args.Handled(false);
+        if (const auto& realArgs = args.ActionArgs().try_as<TerminalApp::SetColorSchemeArgs>())
+        {
+            if (auto activeTab = _GetFocusedTab())
+            {
+                if (auto activeControl = activeTab->GetActiveTerminalControl())
+                {
+                    auto controlSettings = activeControl.Settings();
+                    if (_settings->ApplyColorScheme(controlSettings, realArgs.SchemeName()))
+                    {
+                        activeControl.UpdateSettings(controlSettings);
+                        args.Handled(true);
+                    }
+                }
+            }
+        }
+    }
+
     void TerminalPage::_HandleSetTabColor(const IInspectable& /*sender*/,
                                           const TerminalApp::ActionEventArgs& args)
     {
@@ -289,11 +348,11 @@ namespace winrt::TerminalApp::implementation
         {
             if (tabColor.has_value())
             {
-                activeTab->SetTabColor(tabColor.value());
+                activeTab->SetRuntimeTabColor(tabColor.value());
             }
             else
             {
-                activeTab->ResetTabColor();
+                activeTab->ResetRuntimeTabColor();
             }
         }
         args.Handled(true);
@@ -334,4 +393,106 @@ namespace winrt::TerminalApp::implementation
         }
         args.Handled(true);
     }
+
+    void TerminalPage::_HandleExecuteCommandline(const IInspectable& /*sender*/,
+                                                 const TerminalApp::ActionEventArgs& actionArgs)
+    {
+        if (const auto& realArgs = actionArgs.ActionArgs().try_as<TerminalApp::ExecuteCommandlineArgs>())
+        {
+            auto actions = winrt::single_threaded_vector<winrt::TerminalApp::ActionAndArgs>(std::move(
+                TerminalPage::ConvertExecuteCommandlineToActions(realArgs)));
+
+            if (_startupActions.Size() != 0)
+            {
+                actionArgs.Handled(true);
+                _ProcessStartupActions(actions, false);
+            }
+        }
+    }
+
+    void TerminalPage::_HandleCloseOtherTabs(const IInspectable& /*sender*/,
+                                             const TerminalApp::ActionEventArgs& actionArgs)
+    {
+        if (const auto& realArgs = actionArgs.ActionArgs().try_as<TerminalApp::CloseOtherTabsArgs>())
+        {
+            uint32_t index;
+            if (realArgs.Index())
+            {
+                index = realArgs.Index().Value();
+            }
+            else if (auto focusedTabIndex = _GetFocusedTabIndex())
+            {
+                index = *focusedTabIndex;
+            }
+            else
+            {
+                // Do nothing
+                actionArgs.Handled(false);
+                return;
+            }
+
+            // Remove tabs after the current one
+            while (_tabs.Size() > index + 1)
+            {
+                _RemoveTabViewItemByIndex(_tabs.Size() - 1);
+            }
+
+            // Remove all of them leading up to the selected tab
+            while (_tabs.Size() > 1)
+            {
+                _RemoveTabViewItemByIndex(0);
+            }
+
+            actionArgs.Handled(true);
+        }
+    }
+
+    void TerminalPage::_HandleCloseTabsAfter(const IInspectable& /*sender*/,
+                                             const TerminalApp::ActionEventArgs& actionArgs)
+    {
+        if (const auto& realArgs = actionArgs.ActionArgs().try_as<TerminalApp::CloseTabsAfterArgs>())
+        {
+            uint32_t index;
+            if (realArgs.Index())
+            {
+                index = realArgs.Index().Value();
+            }
+            else if (auto focusedTabIndex = _GetFocusedTabIndex())
+            {
+                index = *focusedTabIndex;
+            }
+            else
+            {
+                // Do nothing
+                actionArgs.Handled(false);
+                return;
+            }
+
+            // Remove tabs after the current one
+            while (_tabs.Size() > index + 1)
+            {
+                _RemoveTabViewItemByIndex(_tabs.Size() - 1);
+            }
+
+            // TODO:GH#7182 For whatever reason, if you run this action
+            // when the tab that's currently focused is _before_ the `index`
+            // param, then the tabs will expand to fill the entire width of the
+            // tab row, until you mouse over them. Probably has something to do
+            // with tabs not resizing down until there's a mouse exit event.
+
+            actionArgs.Handled(true);
+        }
+    }
+
+    void TerminalPage::_HandleOpenTabSearch(const IInspectable& /*sender*/,
+                                            const TerminalApp::ActionEventArgs& args)
+    {
+        auto opt = _GetFocusedTabIndex();
+        uint32_t startIdx = opt.value_or(0);
+
+        CommandPalette().EnableTabSwitcherMode(true, startIdx);
+        CommandPalette().Visibility(Visibility::Visible);
+
+        args.Handled(true);
+    }
 }

src/cascadia/TerminalApp/AppCommandlineArgs.cpp

@@ -599,7 +599,7 @@ void AppCommandlineArgs::_addCommandsForArg(std::vector<Commandline>& commands,
 // - <none>
 // Return Value:
 // - the deque of actions we've buffered as a result of parsing commands.
-std::deque<winrt::TerminalApp::ActionAndArgs>& AppCommandlineArgs::GetStartupActions()
+std::vector<winrt::TerminalApp::ActionAndArgs>& AppCommandlineArgs::GetStartupActions()
 {
     return _startupActions;
 }
@@ -658,7 +658,8 @@ void AppCommandlineArgs::ValidateStartupCommands()
         auto newTerminalArgs = winrt::make_self<implementation::NewTerminalArgs>();
         args->TerminalArgs(*newTerminalArgs);
         newTabAction->Args(*args);
-        _startupActions.push_front(*newTabAction);
+        // push the arg onto the front
+        _startupActions.insert(_startupActions.begin(), 1, *newTabAction);
     }
 }
 
@@ -666,3 +667,52 @@ std::optional<winrt::TerminalApp::LaunchMode> AppCommandlineArgs::GetLaunchMode(
 {
     return _launchMode;
 }
+
+// Method Description:
+// - Attempts to parse an array of commandline args into a list of
+//   commands to execute, and then parses these commands. As commands are
+//   successfully parsed, they will generate ShortcutActions for us to be
+//   able to execute. If we fail to parse any commands, we'll return the
+//   error code from the failure to parse that command, and stop processing
+//   additional commands.
+// - The first arg in args should be the program name "wt" (or some variant). It
+//   will be ignored during parsing.
+// Arguments:
+// - args: an array of strings to process as a commandline. These args can contain spaces
+// Return Value:
+// - 0 if the commandline was successfully parsed
+int AppCommandlineArgs::ParseArgs(winrt::array_view<const winrt::hstring>& args)
+{
+    auto commands = ::TerminalApp::AppCommandlineArgs::BuildCommands(args);
+
+    for (auto& cmdBlob : commands)
+    {
+        // On one hand, it seems like we should be able to have one
+        // AppCommandlineArgs for parsing all of them, and collect the
+        // results one at a time.
+        //
+        // On the other hand, re-using a CLI::App seems to leave state from
+        // previous parsings around, so we could get mysterious behavior
+        // where one command affects the values of the next.
+        //
+        // From https://cliutils.github.io/CLI11/book/chapters/options.html:
+        // > If that option is not given, CLI11 will not touch the initial
+        // > value. This allows you to set up defaults by simply setting
+        // > your value beforehand.
+        //
+        // So we pretty much need the to either manually reset the state
+        // each command, or build new ones.
+        const auto result = ParseCommand(cmdBlob);
+
+        // If this succeeded, result will be 0. Otherwise, the caller should
+        // exit(result), to exit the program.
+        if (result != 0)
+        {
+            return result;
+        }
+    }
+
+    // If all the args were successfully parsed, we'll have some commands
+    // built in _appArgs, which we'll use when the application starts up.
+    return 0;
+}

src/cascadia/TerminalApp/AppCommandlineArgs.h

@@ -28,13 +28,15 @@ public:
 
     AppCommandlineArgs();
     ~AppCommandlineArgs() = default;
+
     int ParseCommand(const Commandline& command);
+    int ParseArgs(winrt::array_view<const winrt::hstring>& args);
 
     static std::vector<Commandline> BuildCommands(const std::vector<const wchar_t*>& args);
     static std::vector<Commandline> BuildCommands(winrt::array_view<const winrt::hstring>& args);
 
     void ValidateStartupCommands();
-    std::deque<winrt::TerminalApp::ActionAndArgs>& GetStartupActions();
+    std::vector<winrt::TerminalApp::ActionAndArgs>& GetStartupActions();
     const std::string& GetExitMessage();
     bool ShouldExitEarly() const noexcept;
 
@@ -90,7 +92,7 @@ private:
     std::optional<winrt::TerminalApp::LaunchMode> _launchMode{ std::nullopt };
     // Are you adding more args here? Make sure to reset them in _resetStateToDefault
 
-    std::deque<winrt::TerminalApp::ActionAndArgs> _startupActions;
+    std::vector<winrt::TerminalApp::ActionAndArgs> _startupActions;
     std::string _exitMessage;
     bool _shouldExitEarly{ false };
 

src/cascadia/TerminalApp/AppKeyBindings.cpp

@@ -9,12 +9,12 @@
 
 using namespace winrt::Microsoft::Terminal;
 using namespace winrt::TerminalApp;
-using namespace winrt::Microsoft::Terminal::Settings;
+using namespace winrt::Microsoft::Terminal::TerminalControl;
 
 namespace winrt::TerminalApp::implementation
 {
     void AppKeyBindings::SetKeyBinding(const TerminalApp::ActionAndArgs& actionAndArgs,
-                                       const Settings::KeyChord& chord)
+                                       const KeyChord& chord)
     {
         _keyShortcuts[chord] = actionAndArgs;
     }
@@ -25,7 +25,7 @@ namespace winrt::TerminalApp::implementation
     // - chord: the keystroke to remove the action for.
     // Return Value:
     // - <none>
-    void AppKeyBindings::ClearKeyBinding(const Settings::KeyChord& chord)
+    void AppKeyBindings::ClearKeyBinding(const KeyChord& chord)
     {
         _keyShortcuts.erase(chord);
     }
@@ -53,6 +53,11 @@ namespace winrt::TerminalApp::implementation
     // - The bound keychord, if this ActionAndArgs is bound to a key, otherwise nullptr.
     KeyChord AppKeyBindings::GetKeyBindingForActionWithArgs(TerminalApp::ActionAndArgs const& actionAndArgs)
     {
+        if (actionAndArgs == nullptr)
+        {
+            return { nullptr };
+        }
+
         for (auto& kv : _keyShortcuts)
         {
             const auto action = kv.second.Action();
@@ -67,7 +72,7 @@ namespace winrt::TerminalApp::implementation
         return { nullptr };
     }
 
-    bool AppKeyBindings::TryKeyChord(const Settings::KeyChord& kc)
+    bool AppKeyBindings::TryKeyChord(const KeyChord& kc)
     {
         const auto keyIter = _keyShortcuts.find(kc);
         if (keyIter != _keyShortcuts.end())
@@ -87,19 +92,19 @@ namespace winrt::TerminalApp::implementation
     // - Takes the KeyModifier flags from Terminal and maps them to the WinRT types which are used by XAML
     // Return Value:
     // - a Windows::System::VirtualKeyModifiers object with the flags of which modifiers used.
-    Windows::System::VirtualKeyModifiers AppKeyBindings::ConvertVKModifiers(Settings::KeyModifiers modifiers)
+    Windows::System::VirtualKeyModifiers AppKeyBindings::ConvertVKModifiers(KeyModifiers modifiers)
     {
         Windows::System::VirtualKeyModifiers keyModifiers = Windows::System::VirtualKeyModifiers::None;
 
-        if (WI_IsFlagSet(modifiers, Settings::KeyModifiers::Ctrl))
+        if (WI_IsFlagSet(modifiers, KeyModifiers::Ctrl))
         {
             keyModifiers |= Windows::System::VirtualKeyModifiers::Control;
         }
-        if (WI_IsFlagSet(modifiers, Settings::KeyModifiers::Shift))
+        if (WI_IsFlagSet(modifiers, KeyModifiers::Shift))
         {
             keyModifiers |= Windows::System::VirtualKeyModifiers::Shift;
         }
-        if (WI_IsFlagSet(modifiers, Settings::KeyModifiers::Alt))
+        if (WI_IsFlagSet(modifiers, KeyModifiers::Alt))
         {
             // note: Menu is the Alt VK_MENU
             keyModifiers |= Windows::System::VirtualKeyModifiers::Menu;

src/cascadia/TerminalApp/AppKeyBindings.h

@@ -20,10 +20,10 @@ namespace winrt::TerminalApp::implementation
 {
     struct KeyChordHash
     {
-        std::size_t operator()(const winrt::Microsoft::Terminal::Settings::KeyChord& key) const
+        std::size_t operator()(const winrt::Microsoft::Terminal::TerminalControl::KeyChord& key) const
         {
             std::hash<int32_t> keyHash;
-            std::hash<winrt::Microsoft::Terminal::Settings::KeyModifiers> modifiersHash;
+            std::hash<winrt::Microsoft::Terminal::TerminalControl::KeyModifiers> modifiersHash;
             std::size_t hashedKey = keyHash(key.Vkey());
             std::size_t hashedMods = modifiersHash(key.Modifiers());
             return hashedKey ^ hashedMods;
@@ -32,7 +32,7 @@ namespace winrt::TerminalApp::implementation
 
     struct KeyChordEquality
     {
-        bool operator()(const winrt::Microsoft::Terminal::Settings::KeyChord& lhs, const winrt::Microsoft::Terminal::Settings::KeyChord& rhs) const
+        bool operator()(const winrt::Microsoft::Terminal::TerminalControl::KeyChord& lhs, const winrt::Microsoft::Terminal::TerminalControl::KeyChord& rhs) const
         {
             return lhs.Modifiers() == rhs.Modifiers() && lhs.Vkey() == rhs.Vkey();
         }
@@ -42,15 +42,15 @@ namespace winrt::TerminalApp::implementation
     {
         AppKeyBindings() = default;
 
-        bool TryKeyChord(winrt::Microsoft::Terminal::Settings::KeyChord const& kc);
+        bool TryKeyChord(winrt::Microsoft::Terminal::TerminalControl::KeyChord const& kc);
 
         void SetKeyBinding(TerminalApp::ActionAndArgs const& actionAndArgs,
-                           winrt::Microsoft::Terminal::Settings::KeyChord const& chord);
-        void ClearKeyBinding(winrt::Microsoft::Terminal::Settings::KeyChord const& chord);
-        Microsoft::Terminal::Settings::KeyChord GetKeyBindingForAction(TerminalApp::ShortcutAction const& action);
-        Microsoft::Terminal::Settings::KeyChord GetKeyBindingForActionWithArgs(TerminalApp::ActionAndArgs const& actionAndArgs);
+                           winrt::Microsoft::Terminal::TerminalControl::KeyChord const& chord);
+        void ClearKeyBinding(winrt::Microsoft::Terminal::TerminalControl::KeyChord const& chord);
+        Microsoft::Terminal::TerminalControl::KeyChord GetKeyBindingForAction(TerminalApp::ShortcutAction const& action);
+        Microsoft::Terminal::TerminalControl::KeyChord GetKeyBindingForActionWithArgs(TerminalApp::ActionAndArgs const& actionAndArgs);
 
-        static Windows::System::VirtualKeyModifiers ConvertVKModifiers(winrt::Microsoft::Terminal::Settings::KeyModifiers modifiers);
+        static Windows::System::VirtualKeyModifiers ConvertVKModifiers(winrt::Microsoft::Terminal::TerminalControl::KeyModifiers modifiers);
 
         // Defined in AppKeyBindingsSerialization.cpp
         std::vector<::TerminalApp::SettingsLoadWarnings> LayerJson(const Json::Value& json);
@@ -59,7 +59,7 @@ namespace winrt::TerminalApp::implementation
         void SetDispatch(const winrt::TerminalApp::ShortcutActionDispatch& dispatch);
 
     private:
-        std::unordered_map<winrt::Microsoft::Terminal::Settings::KeyChord, TerminalApp::ActionAndArgs, KeyChordHash, KeyChordEquality> _keyShortcuts;
+        std::unordered_map<winrt::Microsoft::Terminal::TerminalControl::KeyChord, TerminalApp::ActionAndArgs, KeyChordHash, KeyChordEquality> _keyShortcuts;
 
         winrt::TerminalApp::ShortcutActionDispatch _dispatch{ nullptr };
 

src/cascadia/TerminalApp/AppKeyBindings.idl

@@ -1,19 +1,19 @@
 // Copyright (c) Microsoft Corporation.
 // Licensed under the MIT license.
-import "../ActionArgs.idl";
-import "../ShortcutActionDispatch.idl";
+import "ActionArgs.idl";
+import "ShortcutActionDispatch.idl";
 
 namespace TerminalApp
 {
-    [default_interface] runtimeclass AppKeyBindings : Microsoft.Terminal.Settings.IKeyBindings
+    [default_interface] runtimeclass AppKeyBindings : Microsoft.Terminal.TerminalControl.IKeyBindings
     {
         AppKeyBindings();
 
-        void SetKeyBinding(ActionAndArgs actionAndArgs, Microsoft.Terminal.Settings.KeyChord chord);
-        void ClearKeyBinding(Microsoft.Terminal.Settings.KeyChord chord);
+        void SetKeyBinding(ActionAndArgs actionAndArgs, Microsoft.Terminal.TerminalControl.KeyChord chord);
+        void ClearKeyBinding(Microsoft.Terminal.TerminalControl.KeyChord chord);
 
-        Microsoft.Terminal.Settings.KeyChord GetKeyBindingForAction(ShortcutAction action);
-        Microsoft.Terminal.Settings.KeyChord GetKeyBindingForActionWithArgs(ActionAndArgs actionAndArgs);
+        Microsoft.Terminal.TerminalControl.KeyChord GetKeyBindingForAction(ShortcutAction action);
+        Microsoft.Terminal.TerminalControl.KeyChord GetKeyBindingForActionWithArgs(ActionAndArgs actionAndArgs);
 
         void SetDispatch(ShortcutActionDispatch dispatch);
     }

src/cascadia/TerminalApp/AppKeyBindingsSerialization.cpp

@@ -12,9 +12,8 @@
 #include "KeyChordSerialization.h"
 #include "Utils.h"
 #include "JsonUtils.h"
-#include <winrt/Microsoft.Terminal.Settings.h>
 
-using namespace winrt::Microsoft::Terminal::Settings;
+using namespace winrt::Microsoft::Terminal::TerminalControl;
 using namespace winrt::TerminalApp;
 
 static constexpr std::string_view KeysKey{ "keys" };

src/cascadia/TerminalApp/AppLogic.cpp

@@ -15,7 +15,6 @@ using namespace winrt::Windows::UI::Xaml::Controls;
 using namespace winrt::Windows::UI::Core;
 using namespace winrt::Windows::System;
 using namespace winrt::Microsoft::Terminal;
-using namespace winrt::Microsoft::Terminal::Settings;
 using namespace winrt::Microsoft::Terminal::TerminalControl;
 using namespace ::TerminalApp;
 
@@ -39,7 +38,8 @@ static const std::array<std::wstring_view, static_cast<uint32_t>(SettingsLoadWar
     USES_RESOURCE(L"AtLeastOneKeybindingWarning"),
     USES_RESOURCE(L"TooManyKeysForChord"),
     USES_RESOURCE(L"MissingRequiredParameter"),
-    USES_RESOURCE(L"LegacyGlobalsProperty")
+    USES_RESOURCE(L"LegacyGlobalsProperty"),
+    USES_RESOURCE(L"FailedToParseCommandJson")
 };
 static const std::array<std::wstring_view, static_cast<uint32_t>(SettingsLoadErrors::ERRORS_SIZE)> settingsLoadErrorsLabels {
     USES_RESOURCE(L"NoProfilesText"),
@@ -474,7 +474,7 @@ namespace winrt::TerminalApp::implementation
     // - <none>
     // Return Value:
     // - a point containing the requested dimensions in pixels.
-    winrt::Windows::Foundation::Point AppLogic::GetLaunchDimensions(uint32_t dpi)
+    winrt::Windows::Foundation::Size AppLogic::GetLaunchDimensions(uint32_t dpi)
     {
         if (!_loadedInitialSettings)
         {
@@ -504,7 +504,7 @@ namespace winrt::TerminalApp::implementation
             // of the height calculation here.
             auto titlebar = TitlebarControl{ static_cast<uint64_t>(0) };
             titlebar.Measure({ SHRT_MAX, SHRT_MAX });
-            proposedSize.Y += (titlebar.DesiredSize().Height) * scale;
+            proposedSize.Height += (titlebar.DesiredSize().Height) * scale;
         }
         else if (_settings->GlobalSettings().AlwaysShowTabs())
         {
@@ -519,7 +519,7 @@ namespace winrt::TerminalApp::implementation
             // For whatever reason, there's about 6px of unaccounted-for space
             // in the application. I couldn't tell you where these 6px are
             // coming from, but they need to be included in this math.
-            proposedSize.Y += (tabControl.DesiredSize().Height + 6) * scale;
+            proposedSize.Width += (tabControl.DesiredSize().Height + 6) * scale;
         }
 
         return proposedSize;
@@ -633,6 +633,12 @@ namespace winrt::TerminalApp::implementation
             hr = E_INVALIDARG;
             _settingsLoadExceptionText = _GetErrorText(ex.Error());
         }
+        catch (const ::TerminalApp::SettingsTypedDeserializationException& e)
+        {
+            hr = E_INVALIDARG;
+            std::string_view what{ e.what() };
+            _settingsLoadExceptionText = til::u8u16(what);
+        }
         catch (...)
         {
             hr = wil::ResultFromCaughtException();
@@ -932,6 +938,13 @@ namespace winrt::TerminalApp::implementation
                 if (auto focusedElement{ focusedObject.try_as<Windows::UI::Xaml::FrameworkElement>() })
                 {
                     focusedObject = focusedElement.Parent();
+
+                    // Parent() seems to return null when the focusedElement is created from an ItemTemplate.
+                    // Use the VisualTreeHelper's GetParent as a fallback.
+                    if (!focusedObject)
+                    {
+                        focusedObject = winrt::Windows::UI::Xaml::Media::VisualTreeHelper::GetParent(focusedElement);
+                    }
                 }
                 else
                 {
@@ -974,7 +987,7 @@ namespace winrt::TerminalApp::implementation
     //   or 0. (see AppLogic::_ParseArgs)
     int32_t AppLogic::SetStartupCommandline(array_view<const winrt::hstring> args)
     {
-        const auto result = _ParseArgs(args);
+        const auto result = _appArgs.ParseArgs(args);
         if (result == 0)
         {
             _appArgs.ValidateStartupCommands();
@@ -984,53 +997,6 @@ namespace winrt::TerminalApp::implementation
         return result;
     }
 
-    // Method Description:
-    // - Attempts to parse an array of commandline args into a list of
-    //   commands to execute, and then parses these commands. As commands are
-    //   successfully parsed, they will generate ShortcutActions for us to be
-    //   able to execute. If we fail to parse any commands, we'll return the
-    //   error code from the failure to parse that command, and stop processing
-    //   additional commands.
-    // Arguments:
-    // - args: an array of strings to process as a commandline. These args can contain spaces
-    // Return Value:
-    // - 0 if the commandline was successfully parsed
-    int AppLogic::_ParseArgs(winrt::array_view<const hstring>& args)
-    {
-        auto commands = ::TerminalApp::AppCommandlineArgs::BuildCommands(args);
-
-        for (auto& cmdBlob : commands)
-        {
-            // On one hand, it seems like we should be able to have one
-            // AppCommandlineArgs for parsing all of them, and collect the
-            // results one at a time.
-            //
-            // On the other hand, re-using a CLI::App seems to leave state from
-            // previous parsings around, so we could get mysterious behavior
-            // where one command affects the values of the next.
-            //
-            // From https://cliutils.github.io/CLI11/book/chapters/options.html:
-            // > If that option is not given, CLI11 will not touch the initial
-            // > value. This allows you to set up defaults by simply setting
-            // > your value beforehand.
-            //
-            // So we pretty much need the to either manually reset the state
-            // each command, or build new ones.
-            const auto result = _appArgs.ParseCommand(cmdBlob);
-
-            // If this succeeded, result will be 0. Otherwise, the caller should
-            // exit(result), to exit the program.
-            if (result != 0)
-            {
-                return result;
-            }
-        }
-
-        // If all the args were successfully parsed, we'll have some commands
-        // built in _appArgs, which we'll use when the application starts up.
-        return 0;
-    }
-
     // Method Description:
     // - If there were any errors parsing the commandline that was used to
     //   initialize the terminal, this will return a string containing that

src/cascadia/TerminalApp/AppLogic.h

@@ -37,7 +37,7 @@ namespace winrt::TerminalApp::implementation
         bool Fullscreen() const;
         bool AlwaysOnTop() const;
 
-        Windows::Foundation::Point GetLaunchDimensions(uint32_t dpi);
+        Windows::Foundation::Size GetLaunchDimensions(uint32_t dpi);
         winrt::Windows::Foundation::Point GetLaunchInitialPositions(int32_t defaultInitialX, int32_t defaultInitialY);
         winrt::Windows::UI::Xaml::ElementTheme GetRequestedTheme();
         LaunchMode GetLaunchMode();

src/cascadia/TerminalApp/AppLogic.idl

@@ -1,9 +1,9 @@
 // Copyright (c) Microsoft Corporation.
 // Licensed under the MIT license.
 
-import "../TerminalPage.idl";
-import "../ShortcutActionDispatch.idl";
-import "../IDirectKeyListener.idl";
+import "TerminalPage.idl";
+import "ShortcutActionDispatch.idl";
+import "IDirectKeyListener.idl";
 
 namespace TerminalApp
 {
@@ -45,7 +45,8 @@ namespace TerminalApp
         Boolean Fullscreen { get; };
         Boolean AlwaysOnTop { get; };
 
-        Windows.Foundation.Point GetLaunchDimensions(UInt32 dpi);
+        Windows.Foundation.Size GetLaunchDimensions(UInt32 dpi);
+
         Windows.Foundation.Point GetLaunchInitialPositions(Int32 defaultInitialX, Int32 defaultInitialY);
         Windows.UI.Xaml.ElementTheme GetRequestedTheme();
         LaunchMode GetLaunchMode();

src/cascadia/TerminalApp/AzureCloudShellGenerator.cpp

@@ -37,8 +37,6 @@ std::vector<TerminalApp::Profile> AzureCloudShellGenerator::GenerateProfiles()
         azureCloudShellProfile.SetCommandline(L"Azure");
         azureCloudShellProfile.SetStartingDirectory(DEFAULT_STARTING_DIRECTORY);
         azureCloudShellProfile.SetColorScheme({ L"Vintage" });
-        azureCloudShellProfile.SetAcrylicOpacity(0.6);
-        azureCloudShellProfile.SetUseAcrylic(true);
         azureCloudShellProfile.SetConnectionType(AzureConnectionType);
         profiles.emplace_back(azureCloudShellProfile);
     }

src/cascadia/TerminalApp/CascadiaSettings.cpp

@@ -17,7 +17,6 @@
 #include "WslDistroGenerator.h"
 #include "AzureCloudShellGenerator.h"
 
-using namespace winrt::Microsoft::Terminal::Settings;
 using namespace ::TerminalApp;
 using namespace winrt::Microsoft::Terminal::TerminalControl;
 using namespace winrt::TerminalApp;
@@ -229,7 +228,7 @@ void CascadiaSettings::_ResolveDefaultProfile()
     if (unparsedDefaultProfile)
     {
         auto maybeParsedDefaultProfile{ _GetProfileGuidByName(*unparsedDefaultProfile) };
-        auto defaultProfileGuid{ Utils::CoalesceOptionals(maybeParsedDefaultProfile, GUID{}) };
+        auto defaultProfileGuid{ til::coalesce_value(maybeParsedDefaultProfile, GUID{}) };
         GlobalSettings().DefaultProfile(defaultProfileGuid);
     }
 }
@@ -569,7 +568,7 @@ GUID CascadiaSettings::_GetProfileForArgs(const NewTerminalArgs& newTerminalArgs
         profileByName = _GetProfileGuidByName(newTerminalArgs.Profile());
     }
 
-    return Utils::CoalesceOptionals(profileByName, profileByIndex, _globals.DefaultProfile());
+    return til::coalesce_value(profileByName, profileByIndex, _globals.DefaultProfile());
 }
 
 // Method Description:
@@ -695,14 +694,11 @@ void CascadiaSettings::_ValidateNoGlobalsKey()
 // - The new settings string.
 std::string CascadiaSettings::_ApplyFirstRunChangesToSettingsTemplate(std::string_view settingsTemplate) const
 {
+    // We're using replace_needle_in_haystack_inplace here, because it's more
+    // efficient to iteratively modify a single string in-place than it is to
+    // keep copying over the contents and modifying a copy (which
+    // replace_needle_in_haystack would do).
     std::string finalSettings{ settingsTemplate };
-    auto replace{ [](std::string& haystack, std::string_view needle, std::string_view replacement) {
-        auto pos{ std::string::npos };
-        while ((pos = haystack.rfind(needle, pos)) != std::string::npos)
-        {
-            haystack.replace(pos, needle.size(), replacement);
-        }
-    } };
 
     std::wstring defaultProfileGuid{ DEFAULT_WINDOWS_POWERSHELL_GUID };
     if (const auto psCoreProfileGuid{ _GetProfileGuidByName(PowershellCoreProfileGenerator::GetPreferredPowershellProfileName()) })
@@ -710,14 +706,22 @@ std::string CascadiaSettings::_ApplyFirstRunChangesToSettingsTemplate(std::strin
         defaultProfileGuid = Utils::GuidToString(*psCoreProfileGuid);
     }
 
-    replace(finalSettings, "%DEFAULT_PROFILE%", til::u16u8(defaultProfileGuid));
+    til::replace_needle_in_haystack_inplace(finalSettings,
+                                            "%DEFAULT_PROFILE%",
+                                            til::u16u8(defaultProfileGuid));
     if (const auto appLogic{ winrt::TerminalApp::implementation::AppLogic::Current() })
     {
-        replace(finalSettings, "%VERSION%", til::u16u8(appLogic->ApplicationVersion()));
-        replace(finalSettings, "%PRODUCT%", til::u16u8(appLogic->ApplicationDisplayName()));
+        til::replace_needle_in_haystack_inplace(finalSettings,
+                                                "%VERSION%",
+                                                til::u16u8(appLogic->ApplicationVersion()));
+        til::replace_needle_in_haystack_inplace(finalSettings,
+                                                "%PRODUCT%",
+                                                til::u16u8(appLogic->ApplicationDisplayName()));
     }
 
-    replace(finalSettings, "%COMMAND_PROMPT_LOCALIZED_NAME%", RS_A(L"CommandPromptDisplayName"));
+    til::replace_needle_in_haystack_inplace(finalSettings,
+                                            "%COMMAND_PROMPT_LOCALIZED_NAME%",
+                                            RS_A(L"CommandPromptDisplayName"));
 
     return finalSettings;
 }
@@ -730,7 +734,7 @@ std::string CascadiaSettings::_ApplyFirstRunChangesToSettingsTemplate(std::strin
 // - profileGuid: the GUID of the profile to find the scheme for.
 // Return Value:
 // - a non-owning pointer to the scheme.
-const ColorScheme* CascadiaSettings::GetColorSchemeForProfile(const GUID profileGuid) const
+const ColorScheme CascadiaSettings::GetColorSchemeForProfile(const GUID profileGuid) const
 {
     auto* profile = FindProfile(profileGuid);
     if (!profile)
@@ -741,10 +745,33 @@ const ColorScheme* CascadiaSettings::GetColorSchemeForProfile(const GUID profile
     auto scheme = _globals.GetColorSchemes().find(schemeName);
     if (scheme != _globals.GetColorSchemes().end())
     {
-        return &scheme->second;
+        return scheme->second;
     }
     else
     {
         return nullptr;
     }
 }
+
+// Method Description:
+// - Apply the color scheme (provided by name) to the given IControlSettings.
+//   The settings are modified in-place.
+// - If the name doesn't correspond to any of our schemes, this does nothing.
+// Arguments:
+// - settings: the IControlSettings object to modify
+// - name: the name of the scheme to apply
+// Return Value:
+// - true iff we found a matching scheme for the name schemeName
+bool CascadiaSettings::ApplyColorScheme(winrt::Microsoft::Terminal::TerminalControl::IControlSettings& settings,
+                                        std::wstring_view schemeName)
+{
+    std::wstring name{ schemeName };
+    auto schemeAndName = _globals.GetColorSchemes().find(name);
+    if (schemeAndName != _globals.GetColorSchemes().end())
+    {
+        const auto& scheme = schemeAndName->second;
+        scheme.ApplyScheme(settings);
+        return true;
+    }
+    return false;
+}

src/cascadia/TerminalApp/CascadiaSettings.h

@@ -22,6 +22,8 @@ Author(s):
 #include "Profile.h"
 #include "IDynamicProfileGenerator.h"
 
+#include "ColorScheme.h"
+
 // fwdecl unittest classes
 namespace TerminalAppLocalTests
 {
@@ -39,9 +41,17 @@ namespace TerminalAppUnitTests
 
 namespace TerminalApp
 {
+    class SettingsTypedDeserializationException;
     class CascadiaSettings;
 };
 
+class TerminalApp::SettingsTypedDeserializationException final : public std::runtime_error
+{
+public:
+    SettingsTypedDeserializationException(const std::string_view description) :
+        runtime_error(description.data()) {}
+};
+
 class TerminalApp::CascadiaSettings final
 {
 public:
@@ -54,8 +64,8 @@ public:
 
     static const CascadiaSettings& GetCurrentAppSettings();
 
-    std::tuple<GUID, winrt::Microsoft::Terminal::Settings::TerminalSettings> BuildSettings(const winrt::TerminalApp::NewTerminalArgs& newTerminalArgs) const;
-    winrt::Microsoft::Terminal::Settings::TerminalSettings BuildSettings(GUID profileGuid) const;
+    std::tuple<GUID, winrt::TerminalApp::TerminalSettings> BuildSettings(const winrt::TerminalApp::NewTerminalArgs& newTerminalArgs) const;
+    winrt::TerminalApp::TerminalSettings BuildSettings(GUID profileGuid) const;
 
     GlobalAppSettings& GlobalSettings();
 
@@ -70,10 +80,12 @@ public:
     static std::filesystem::path GetDefaultSettingsPath();
 
     const Profile* FindProfile(GUID profileGuid) const noexcept;
-    const ColorScheme* GetColorSchemeForProfile(const GUID profileGuid) const;
+    const winrt::TerminalApp::ColorScheme GetColorSchemeForProfile(const GUID profileGuid) const;
 
     std::vector<TerminalApp::SettingsLoadWarnings>& GetWarnings();
 
+    bool ApplyColorScheme(winrt::Microsoft::Terminal::TerminalControl::IControlSettings& settings, std::wstring_view schemeName);
+
 private:
     GlobalAppSettings _globals;
     std::vector<Profile> _profiles;
@@ -89,7 +101,7 @@ private:
     void _LayerOrCreateProfile(const Json::Value& profileJson);
     Profile* _FindMatchingProfile(const Json::Value& profileJson);
     void _LayerOrCreateColorScheme(const Json::Value& schemeJson);
-    ColorScheme* _FindMatchingColorScheme(const Json::Value& schemeJson);
+    winrt::com_ptr<winrt::TerminalApp::implementation::ColorScheme> _FindMatchingColorScheme(const Json::Value& schemeJson);
     void _ParseJsonString(std::string_view fileData, const bool isDefaultSettings);
     static const Json::Value& _GetProfilesJsonObject(const Json::Value& json);
     static const Json::Value& _GetDisabledProfileSourcesJsonObject(const Json::Value& json);

src/cascadia/TerminalApp/CascadiaSettingsSerialization.cpp

@@ -19,7 +19,6 @@
 // "Generated Files" directory.
 
 using namespace ::TerminalApp;
-using namespace winrt::Microsoft::Terminal::TerminalControl;
 using namespace winrt::TerminalApp;
 using namespace ::Microsoft::Console;
 
@@ -42,6 +41,54 @@ static constexpr std::string_view Utf8Bom{ u8"\uFEFF" };
 static constexpr std::string_view SettingsSchemaFragment{ "\n"
                                                           R"(    "$schema": "https://aka.ms/terminal-profiles-schema")" };
 
+static std::tuple<size_t, size_t> _LineAndColumnFromPosition(const std::string_view string, ptrdiff_t position)
+{
+    size_t line = 1, column = position + 1;
+    auto lastNL = string.find_last_of('\n', position);
+    if (lastNL != std::string::npos)
+    {
+        column = (position - lastNL);
+        line = std::count(string.cbegin(), string.cbegin() + lastNL + 1, '\n') + 1;
+    }
+
+    return { line, column };
+}
+
+static void _CatchRethrowSerializationExceptionWithLocationInfo(std::string_view settingsString)
+{
+    std::string msg;
+
+    try
+    {
+        throw;
+    }
+    catch (const JsonUtils::DeserializationError& e)
+    {
+        static constexpr std::string_view basicHeader{ "* Line {line}, Column {column}\n{message}" };
+        static constexpr std::string_view keyedHeader{ "* Line {line}, Column {column} ({key})\n{message}" };
+
+        std::string jsonValueAsString{ "array or object" };
+        try
+        {
+            jsonValueAsString = e.jsonValue.asString();
+        }
+        catch (...)
+        {
+            // discard: we're in the middle of error handling
+        }
+
+        msg = fmt::format("  Have: \"{}\"\n  Expected: {}", jsonValueAsString, e.expectedType);
+
+        auto [l, c] = _LineAndColumnFromPosition(settingsString, e.jsonValue.getOffsetStart());
+        msg = fmt::format((e.key ? keyedHeader : basicHeader),
+                          fmt::arg("line", l),
+                          fmt::arg("column", c),
+                          fmt::arg("key", e.key.value_or("")),
+                          fmt::arg("message", msg));
+        throw SettingsTypedDeserializationException{ msg };
+    }
+}
+
 // Method Description:
 // - Creates a CascadiaSettings from whatever's saved on disk, or instantiates
 //      a new one with the default values. If we're running as a packaged app,
@@ -90,16 +137,23 @@ std::unique_ptr<CascadiaSettings> CascadiaSettings::LoadAll()
         needToWriteFile = true;
     }
 
-    // See microsoft/terminal#2325: find the defaultSettings from the user's
-    // settings. Layer those settings upon all the existing profiles we have
-    // (defaults and dynamic profiles). We'll also set
-    // _userDefaultProfileSettings here. When we LayerJson below to apply the
-    // user settings, we'll make sure to use these defaultSettings _before_ any
-    // profiles the user might have.
-    resultPtr->_ApplyDefaultsFromUserSettings();
+    try
+    {
+        // See microsoft/terminal#2325: find the defaultSettings from the user's
+        // settings. Layer those settings upon all the existing profiles we have
+        // (defaults and dynamic profiles). We'll also set
+        // _userDefaultProfileSettings here. When we LayerJson below to apply the
+        // user settings, we'll make sure to use these defaultSettings _before_ any
+        // profiles the user might have.
+        resultPtr->_ApplyDefaultsFromUserSettings();
 
-    // Apply the user's settings
-    resultPtr->LayerJson(resultPtr->_userSettings);
+        // Apply the user's settings
+        resultPtr->LayerJson(resultPtr->_userSettings);
+    }
+    catch (...)
+    {
+        _CatchRethrowSerializationExceptionWithLocationInfo(resultPtr->_userSettingsString);
+    }
 
     // After layering the user settings, check if there are any new profiles
     // that need to be inserted into their user settings file.
@@ -249,9 +303,9 @@ void CascadiaSettings::_LoadDynamicProfiles()
     const auto disabledProfileSources = CascadiaSettings::_GetDisabledProfileSourcesJsonObject(_userSettings);
     if (disabledProfileSources.isArray())
     {
-        for (const auto& ns : disabledProfileSources)
+        for (const auto& json : disabledProfileSources)
         {
-            ignoredNamespaces.emplace(GetWstringFromJson(ns));
+            ignoredNamespaces.emplace(JsonUtils::GetValue<std::wstring>(json));
         }
     }
 
@@ -654,7 +708,8 @@ void CascadiaSettings::_LayerOrCreateColorScheme(const Json::Value& schemeJson)
     }
     else
     {
-        _globals.AddColorScheme(ColorScheme::FromJson(schemeJson));
+        const auto scheme = implementation::ColorScheme::FromJson(schemeJson);
+        _globals.AddColorScheme(*scheme);
     }
 }
 
@@ -669,19 +724,15 @@ void CascadiaSettings::_LayerOrCreateColorScheme(const Json::Value& schemeJson)
 // Return Value:
 // - a ColorScheme that can be layered with the given json object, iff such a
 //   color scheme exists.
-ColorScheme* CascadiaSettings::_FindMatchingColorScheme(const Json::Value& schemeJson)
+winrt::com_ptr<implementation::ColorScheme> CascadiaSettings::_FindMatchingColorScheme(const Json::Value& schemeJson)
 {
-    if (auto schemeName = ColorScheme::GetNameFromJson(schemeJson))
+    if (auto schemeName = implementation::ColorScheme::GetNameFromJson(schemeJson))
     {
         auto& schemes = _globals.GetColorSchemes();
         auto iterator = schemes.find(*schemeName);
         if (iterator != schemes.end())
         {
-            // HERE BE DRAGONS: Returning a pointer to a type in the vector is
-            // maybe not the _safest_ thing, but we have a mind to make Profile
-            // and ColorScheme winrt types in the future, so this will be safer
-            // then.
-            return &iterator->second;
+            return winrt::get_self<implementation::ColorScheme>(iterator->second)->get_strong();
         }
     }
     return nullptr;

src/cascadia/TerminalApp/ColorScheme.cpp

@@ -8,10 +8,12 @@
 #include "Utils.h"
 #include "JsonUtils.h"
 
+#include "ColorScheme.g.cpp"
+
 using namespace ::Microsoft::Console;
 using namespace TerminalApp;
-using namespace winrt::Microsoft::Terminal::Settings;
-using namespace winrt::Microsoft::Terminal::TerminalControl;
+using namespace winrt::TerminalApp::implementation;
+using namespace winrt::Windows::UI;
 
 static constexpr std::string_view NameKey{ "name" };
 static constexpr std::string_view ForegroundKey{ "foreground" };
@@ -47,7 +49,7 @@ ColorScheme::ColorScheme() :
 {
 }
 
-ColorScheme::ColorScheme(std::wstring name, til::color defaultFg, til::color defaultBg, til::color cursorColor) :
+ColorScheme::ColorScheme(winrt::hstring name, Color defaultFg, Color defaultBg, Color cursorColor) :
     _schemeName{ name },
     _table{},
     _defaultForeground{ defaultFg },
@@ -68,7 +70,7 @@ ColorScheme::~ColorScheme()
 // - terminalSettings: the object to apply our settings to.
 // Return Value:
 // - <none>
-void ColorScheme::ApplyScheme(TerminalSettings terminalSettings) const
+void ColorScheme::ApplyScheme(const winrt::Microsoft::Terminal::TerminalControl::IControlSettings& terminalSettings) const
 {
     terminalSettings.DefaultForeground(static_cast<COLORREF>(_defaultForeground));
     terminalSettings.DefaultBackground(static_cast<COLORREF>(_defaultBackground));
@@ -88,10 +90,10 @@ void ColorScheme::ApplyScheme(TerminalSettings terminalSettings) const
 // - json: an object which should be a serialization of a ColorScheme object.
 // Return Value:
 // - a new ColorScheme instance created from the values in `json`
-ColorScheme ColorScheme::FromJson(const Json::Value& json)
+winrt::com_ptr<ColorScheme> ColorScheme::FromJson(const Json::Value& json)
 {
-    ColorScheme result;
-    result.LayerJson(json);
+    auto result = winrt::make_self<ColorScheme>();
+    result->LayerJson(json);
     return result;
 }
 
@@ -105,9 +107,9 @@ ColorScheme ColorScheme::FromJson(const Json::Value& json)
 // - true iff the json object has the same `name` as we do.
 bool ColorScheme::ShouldBeLayered(const Json::Value& json) const
 {
-    if (const auto name{ json[JsonKey(NameKey)] })
+    std::wstring nameFromJson{};
+    if (JsonUtils::GetValueForKey(json, NameKey, nameFromJson))
     {
-        const auto nameFromJson = GetWstringFromJson(name);
         return nameFromJson == _schemeName;
     }
     return false;
@@ -125,69 +127,48 @@ bool ColorScheme::ShouldBeLayered(const Json::Value& json) const
 // <none>
 void ColorScheme::LayerJson(const Json::Value& json)
 {
-    if (auto name{ json[JsonKey(NameKey)] })
-    {
-        _schemeName = winrt::to_hstring(name.asString());
-    }
-    if (auto fgString{ json[JsonKey(ForegroundKey)] })
-    {
-        const auto color = Utils::ColorFromHexString(fgString.asString());
-        _defaultForeground = color;
-    }
-    if (auto bgString{ json[JsonKey(BackgroundKey)] })
-    {
-        const auto color = Utils::ColorFromHexString(bgString.asString());
-        _defaultBackground = color;
-    }
-    if (auto sbString{ json[JsonKey(SelectionBackgroundKey)] })
-    {
-        const auto color = Utils::ColorFromHexString(sbString.asString());
-        _selectionBackground = color;
-    }
-    if (auto sbString{ json[JsonKey(CursorColorKey)] })
-    {
-        const auto color = Utils::ColorFromHexString(sbString.asString());
-        _cursorColor = color;
-    }
+    JsonUtils::GetValueForKey(json, NameKey, _schemeName);
+    JsonUtils::GetValueForKey(json, ForegroundKey, _defaultForeground);
+    JsonUtils::GetValueForKey(json, BackgroundKey, _defaultBackground);
+    JsonUtils::GetValueForKey(json, SelectionBackgroundKey, _selectionBackground);
+    JsonUtils::GetValueForKey(json, CursorColorKey, _cursorColor);
 
     int i = 0;
     for (const auto& current : TableColors)
     {
-        if (auto str{ json[JsonKey(current)] })
-        {
-            const auto color = Utils::ColorFromHexString(str.asString());
-            _table.at(i) = color;
-        }
+        JsonUtils::GetValueForKey(json, current, _table.at(i));
         i++;
     }
 }
 
-std::wstring_view ColorScheme::GetName() const noexcept
+winrt::hstring ColorScheme::Name() const noexcept
 {
-    return { _schemeName };
+    return _schemeName;
 }
 
-std::array<til::color, COLOR_TABLE_SIZE>& ColorScheme::GetTable() noexcept
+winrt::com_array<Color> ColorScheme::Table() const noexcept
 {
-    return _table;
+    winrt::com_array<Color> result{ COLOR_TABLE_SIZE };
+    std::transform(_table.begin(), _table.end(), result.begin(), [](til::color c) -> Color { return c; });
+    return result;
 }
 
-til::color ColorScheme::GetForeground() const noexcept
+Color ColorScheme::Foreground() const noexcept
 {
     return _defaultForeground;
 }
 
-til::color ColorScheme::GetBackground() const noexcept
+Color ColorScheme::Background() const noexcept
 {
     return _defaultBackground;
 }
 
-til::color ColorScheme::GetSelectionBackground() const noexcept
+Color ColorScheme::SelectionBackground() const noexcept
 {
     return _selectionBackground;
 }
 
-til::color ColorScheme::GetCursorColor() const noexcept
+Color ColorScheme::CursorColor() const noexcept
 {
     return _cursorColor;
 }
@@ -200,11 +181,7 @@ til::color ColorScheme::GetCursorColor() const noexcept
 // - the name of the color scheme represented by `json` as a std::wstring optional
 //   i.e. the value of the `name` property.
 // - returns std::nullopt if `json` doesn't have the `name` property
-std::optional<std::wstring> TerminalApp::ColorScheme::GetNameFromJson(const Json::Value& json)
+std::optional<std::wstring> ColorScheme::GetNameFromJson(const Json::Value& json)
 {
-    if (const auto name{ json[JsonKey(NameKey)] })
-    {
-        return GetWstringFromJson(name);
-    }
-    return std::nullopt;
+    return JsonUtils::GetValueForKey<std::optional<std::wstring>>(json, NameKey);
 }

src/cascadia/TerminalApp/ColorScheme.h

@@ -15,10 +15,11 @@ Author(s):
 
 --*/
 #pragma once
-#include <winrt/Microsoft.Terminal.Settings.h>
-#include <winrt/Microsoft.Terminal.TerminalControl.h>
+#include "TerminalSettings.h"
 #include "../../inc/conattrs.hpp"
 
+#include "ColorScheme.g.h"
+
 // fwdecl unittest classes
 namespace TerminalAppLocalTests
 {
@@ -26,41 +27,44 @@ namespace TerminalAppLocalTests
     class ColorSchemeTests;
 };
 
-namespace TerminalApp
+namespace winrt::TerminalApp::implementation
 {
-    class ColorScheme;
-};
+    struct ColorScheme : ColorSchemeT<ColorScheme>
+    {
+    public:
+        ColorScheme();
+        ColorScheme(hstring name, Windows::UI::Color defaultFg, Windows::UI::Color defaultBg, Windows::UI::Color cursorColor);
+        ~ColorScheme();
 
-class TerminalApp::ColorScheme
+        void ApplyScheme(const winrt::Microsoft::Terminal::TerminalControl::IControlSettings& terminalSettings) const;
+
+        static com_ptr<ColorScheme> FromJson(const Json::Value& json);
+        bool ShouldBeLayered(const Json::Value& json) const;
+        void LayerJson(const Json::Value& json);
+
+        hstring Name() const noexcept;
+        com_array<Windows::UI::Color> Table() const noexcept;
+        Windows::UI::Color Foreground() const noexcept;
+        Windows::UI::Color Background() const noexcept;
+        Windows::UI::Color SelectionBackground() const noexcept;
+        Windows::UI::Color CursorColor() const noexcept;
+
+        static std::optional<std::wstring> GetNameFromJson(const Json::Value& json);
+
+    private:
+        hstring _schemeName;
+        std::array<til::color, COLOR_TABLE_SIZE> _table;
+        til::color _defaultForeground;
+        til::color _defaultBackground;
+        til::color _selectionBackground;
+        til::color _cursorColor;
+
+        friend class TerminalAppLocalTests::SettingsTests;
+        friend class TerminalAppLocalTests::ColorSchemeTests;
+    };
+}
+
+namespace winrt::TerminalApp::factory_implementation
 {
-public:
-    ColorScheme();
-    ColorScheme(std::wstring name, til::color defaultFg, til::color defaultBg, til::color cursorColor);
-    ~ColorScheme();
-
-    void ApplyScheme(winrt::Microsoft::Terminal::Settings::TerminalSettings terminalSettings) const;
-
-    static ColorScheme FromJson(const Json::Value& json);
-    bool ShouldBeLayered(const Json::Value& json) const;
-    void LayerJson(const Json::Value& json);
-
-    std::wstring_view GetName() const noexcept;
-    std::array<til::color, COLOR_TABLE_SIZE>& GetTable() noexcept;
-    til::color GetForeground() const noexcept;
-    til::color GetBackground() const noexcept;
-    til::color GetSelectionBackground() const noexcept;
-    til::color GetCursorColor() const noexcept;
-
-    static std::optional<std::wstring> GetNameFromJson(const Json::Value& json);
-
-private:
-    std::wstring _schemeName;
-    std::array<til::color, COLOR_TABLE_SIZE> _table;
-    til::color _defaultForeground;
-    til::color _defaultBackground;
-    til::color _selectionBackground;
-    til::color _cursorColor;
-
-    friend class TerminalAppLocalTests::SettingsTests;
-    friend class TerminalAppLocalTests::ColorSchemeTests;
-};
+    BASIC_FACTORY(ColorScheme);
+}

src/cascadia/TerminalApp/ColorScheme.idl

@@ -0,0 +1,21 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT license.
+
+namespace TerminalApp
+{
+    [default_interface] runtimeclass ColorScheme {
+        ColorScheme();
+        ColorScheme(String name, Windows.UI.Color defaultFg, Windows.UI.Color defaultBg, Windows.UI.Color cursorColor);
+
+        void ApplyScheme(Microsoft.Terminal.TerminalControl.IControlSettings terminalSettings);
+
+        String Name { get; };
+
+        Windows.UI.Color Foreground { get; };
+        Windows.UI.Color Background { get; };
+        Windows.UI.Color SelectionBackground { get; };
+        Windows.UI.Color CursorColor { get; };
+
+        Windows.UI.Color[] Table { get; };
+    }
+}

src/cascadia/TerminalApp/Command.cpp

@@ -7,18 +7,47 @@
 
 #include "Utils.h"
 #include "ActionAndArgs.h"
+#include "JsonUtils.h"
 #include <LibraryResources.h>
+#include "TerminalSettingsSerializationHelpers.h"
 
-using namespace winrt::Microsoft::Terminal::Settings;
 using namespace winrt::TerminalApp;
+using namespace winrt::Windows::Foundation;
+using namespace ::TerminalApp;
+
+namespace winrt
+{
+    namespace MUX = Microsoft::UI::Xaml;
+    namespace WUX = Windows::UI::Xaml;
+}
 
 static constexpr std::string_view NameKey{ "name" };
-static constexpr std::string_view IconPathKey{ "iconPath" };
+static constexpr std::string_view IconKey{ "icon" };
 static constexpr std::string_view ActionKey{ "command" };
 static constexpr std::string_view ArgsKey{ "args" };
+static constexpr std::string_view IterateOnKey{ "iterateOn" };
+static constexpr std::string_view CommandsKey{ "commands" };
+
+static constexpr std::string_view ProfileNameToken{ "${profile.name}" };
+static constexpr std::string_view ProfileIconToken{ "${profile.icon}" };
+static constexpr std::string_view SchemeNameToken{ "${scheme.name}" };
 
 namespace winrt::TerminalApp::implementation
 {
+    Command::Command()
+    {
+        _setAction(nullptr);
+    }
+
+    Collections::IMapView<winrt::hstring, TerminalApp::Command> Command::NestedCommands()
+    {
+        return _subcommands ? _subcommands.GetView() : nullptr;
+    }
+
+    bool Command::HasNestedCommands()
+    {
+        return _subcommands ? _subcommands.Size() > 0 : false;
+    }
     // Function Description:
     // - attempt to get the name of this command from the provided json object.
     //   * If the "name" property is a string, return that value.
@@ -35,25 +64,17 @@ namespace winrt::TerminalApp::implementation
         {
             if (name.isObject())
             {
-                try
+                if (const auto resourceKey{ JsonUtils::GetValueForKey<std::optional<std::wstring>>(name, "key") })
                 {
-                    if (const auto keyJson{ name[JsonKey("key")] })
+                    if (HasLibraryResourceWithName(*resourceKey))
                     {
-                        // Make sure the key is present before we try
-                        // loading it. Otherwise we'll crash
-                        const auto resourceKey = GetWstringFromJson(keyJson);
-                        if (HasLibraryResourceWithName(resourceKey))
-                        {
-                            return GetLibraryResourceString(resourceKey);
-                        }
+                        return GetLibraryResourceString(*resourceKey);
                     }
                 }
-                CATCH_LOG();
             }
             else if (name.isString())
             {
-                auto nameStr = name.asString();
-                return winrt::to_hstring(nameStr);
+                return JsonUtils::GetValue<winrt::hstring>(name);
             }
         }
 
@@ -86,6 +107,70 @@ namespace winrt::TerminalApp::implementation
         return actionAndArgs->GenerateName();
     }
 
+    // Method Description:
+    // - Actually initialize our IconSource for our _lastIconPath. Supports a variety of icons:
+    //    * If the icon is a path to an image, we'll use that.
+    //    * If it isn't, then we'll try and use the text as a FontIcon. If the
+    //      character is in the range of symbols reserved for the Segoe MDL2
+    //      Asserts, well treat it as such. Otherwise, we'll default to a Sego
+    //      UI icon, so things like emoji will work.
+    // - MUST BE CALLED ON THE UI THREAD.
+    // Arguments:
+    // - <none>
+    // Return Value:
+    // - <none>
+    void Command::RefreshIcon()
+    {
+        if (!_lastIconPath.empty())
+        {
+            _setIconSource(GetColoredIcon<winrt::WUX::Controls::IconSource>(_lastIconPath));
+
+            // If we fail to set the icon source using the "icon" as a path,
+            // let's try it as a symbol/emoji.
+            //
+            // Anything longer that 2 wchar_t's _isn't_ an emoji or symbol, so
+            // don't do this if it's just an invalid path.
+            if (IconSource() == nullptr && _lastIconPath.size() <= 2)
+            {
+                try
+                {
+                    WUX::Controls::FontIconSource icon;
+                    const wchar_t ch = _lastIconPath[0];
+
+                    // The range of MDL2 Icons isn't explicitly defined, but
+                    // we're using this based off the table on:
+                    // https://docs.microsoft.com/en-us/windows/uwp/design/style/segoe-ui-symbol-font
+                    const bool isMDL2Icon = ch >= L'\uE700' && ch <= L'\uF8FF';
+                    if (isMDL2Icon)
+                    {
+                        icon.FontFamily(WUX::Media::FontFamily{ L"Segoe MDL2 Assets" });
+                    }
+                    else
+                    {
+                        // Note: you _do_ need to manually set the font here.
+                        icon.FontFamily(WUX::Media::FontFamily{ L"Segoe UI" });
+                    }
+                    icon.FontSize(12);
+                    icon.Glyph(_lastIconPath);
+                    _setIconSource(icon);
+                }
+                CATCH_LOG();
+            }
+        }
+        if (IconSource() == nullptr)
+        {
+            // Set the default IconSource to a BitmapIconSource with a null source
+            // (instead of just nullptr) because there's a really weird crash when swapping
+            // data bound IconSourceElements in a ListViewTemplate (i.e. CommandPalette).
+            // Swapping between nullptr IconSources and non-null IconSources causes a crash
+            // to occur, but swapping between IconSources with a null source and non-null IconSources
+            // work perfectly fine :shrug:.
+            winrt::Windows::UI::Xaml::Controls::BitmapIconSource icon;
+            icon.UriSource(nullptr);
+            _setIconSource(icon);
+        }
+    }
+
     // Method Description:
     // - Deserialize a Command from the `json` object. The json object should
     //   contain a "name" and "action", and optionally an "icon".
@@ -106,35 +191,76 @@ namespace winrt::TerminalApp::implementation
     {
         auto result = winrt::make_self<Command>();
 
-        // TODO GH#6644: iconPath not implemented quite yet. Can't seem to get
-        // the binding quite right. Additionally, do we want it to be an image,
-        // or a FontIcon? I've had difficulty binding either/or.
+        bool nested = false;
+        JsonUtils::GetValueForKey(json, IterateOnKey, result->_IterateOn);
 
-        if (const auto actionJson{ json[JsonKey(ActionKey)] })
+        // For iterable commands, we'll make another pass at parsing them once
+        // the json is patched. So ignore parsing sub-commands for now. Commands
+        // will only be marked iterable on the first pass.
+        if (const auto nestedCommandsJson{ json[JsonKey(CommandsKey)] })
         {
-            auto actionAndArgs = ActionAndArgs::FromJson(actionJson, warnings);
+            // Initialize our list of subcommands.
+            result->_subcommands = winrt::single_threaded_map<winrt::hstring, winrt::TerminalApp::Command>();
+            auto nestedWarnings = Command::LayerJson(result->_subcommands, nestedCommandsJson);
+            // It's possible that the nested commands have some warnings
+            warnings.insert(warnings.end(), nestedWarnings.begin(), nestedWarnings.end());
 
-            if (actionAndArgs)
-            {
-                result->_setAction(*actionAndArgs);
-            }
-            else
-            {
-                // Something like
-                //      { name: "foo", action: "unbound" }
-                // will _remove_ the "foo" command, by returning null here.
-                return nullptr;
-            }
-
-            result->_setName(_nameFromJsonOrAction(json, actionAndArgs));
+            nested = true;
         }
-        else
+        else if (json.isMember(JsonKey(CommandsKey)))
         {
-            // { name: "foo", action: null } will land in this case, which
+            // { "name": "foo", "commands": null } will land in this case, which
             // should also be used for unbinding.
             return nullptr;
         }
 
+        // Only get the icon path right now. The icon needs to be resolved into
+        // an IconSource on the UI thread, which will be done by RefreshIcon.
+        JsonUtils::GetValueForKey(json, IconKey, result->_lastIconPath);
+
+        // If we're a nested command, we can ignore the current action.
+        if (!nested)
+        {
+            if (const auto actionJson{ json[JsonKey(ActionKey)] })
+            {
+                auto actionAndArgs = ActionAndArgs::FromJson(actionJson, warnings);
+
+                if (actionAndArgs)
+                {
+                    result->_setAction(*actionAndArgs);
+                }
+                else
+                {
+                    // Something like
+                    //      { name: "foo", action: "unbound" }
+                    // will _remove_ the "foo" command, by returning null here.
+                    return nullptr;
+                }
+
+                // If an iterable command doesn't have a name set, we'll still just
+                // try and generate a fake name for the command give the string we
+                // currently have. It'll probably generate something like "New tab,
+                // profile: ${profile.name}". This string will only be temporarily
+                // used internally, so there's no problem.
+                result->_setName(_nameFromJsonOrAction(json, actionAndArgs));
+            }
+            else
+            {
+                // { name: "foo", action: null } will land in this case, which
+                // should also be used for unbinding.
+                return nullptr;
+            }
+        }
+        else
+        {
+            result->_setName(_nameFromJson(json));
+        }
+
+        // Stash the original json value in this object. If the command is
+        // iterable, we'll need to re-parse it later, once we know what all the
+        // values we can iterate on are.
+        result->_originalJson = json;
+
         if (result->_Name.empty())
         {
             return nullptr;
@@ -154,7 +280,7 @@ namespace winrt::TerminalApp::implementation
     // - json: A Json::Value containing an array of serialized commands
     // Return Value:
     // - A vector containing any warnings detected while parsing
-    std::vector<::TerminalApp::SettingsLoadWarnings> Command::LayerJson(std::unordered_map<winrt::hstring, winrt::TerminalApp::Command>& commands,
+    std::vector<::TerminalApp::SettingsLoadWarnings> Command::LayerJson(Windows::Foundation::Collections::IMap<winrt::hstring, winrt::TerminalApp::Command>& commands,
                                                                         const Json::Value& json)
     {
         std::vector<::TerminalApp::SettingsLoadWarnings> warnings;
@@ -169,7 +295,7 @@ namespace winrt::TerminalApp::implementation
                     if (result)
                     {
                         // Override commands with the same name
-                        commands.insert_or_assign(result->Name(), *result);
+                        commands.Insert(result->Name(), *result);
                     }
                     else
                     {
@@ -179,7 +305,7 @@ namespace winrt::TerminalApp::implementation
                         const auto name = _nameFromJson(value);
                         if (!name.empty())
                         {
-                            commands.erase(name);
+                            commands.Remove(name);
                         }
                     }
                 }
@@ -188,4 +314,197 @@ namespace winrt::TerminalApp::implementation
         }
         return warnings;
     }
+
+    // Function Description:
+    // - Helper to escape a string as a json string. This function will also
+    //   trim off the leading and trailing double-quotes, so the output string
+    //   can be inserted directly into another json blob.
+    // Arguments:
+    // - input: the string to JSON escape.
+    // Return Value:
+    // - the input string escaped properly to be inserted into another json blob.
+    std::string _escapeForJson(const std::string& input)
+    {
+        Json::Value inJson{ input };
+        Json::StreamWriterBuilder builder;
+        builder.settings_["indentation"] = "";
+        std::string out{ Json::writeString(builder, inJson) };
+        if (out.size() >= 2)
+        {
+            // trim off the leading/trailing '"'s
+            auto ss{ out.substr(1, out.size() - 2) };
+            return ss;
+        }
+        return out;
+    }
+
+    // Method Description:
+    // - Iterate over all the provided commands, and recursively expand any
+    //   commands with `iterateOn` set. If we successfully generated expanded
+    //   commands for them, then we'll remove the original command, and add all
+    //   the newly generated commands.
+    // - For more specific implementation details, see _expandCommand.
+    // Arguments:
+    // - commands: a map of commands to expand. Newly created commands will be
+    //   inserted into the map to replace the expandable commands.
+    // - profiles: A list of all the profiles that this command should be expanded on.
+    // - warnings: If there were any warnings during parsing, they'll be
+    //   appended to this vector.
+    // Return Value:
+    // - <none>
+    void Command::ExpandCommands(Windows::Foundation::Collections::IMap<winrt::hstring, winrt::TerminalApp::Command>& commands,
+                                 gsl::span<const ::TerminalApp::Profile> profiles,
+                                 gsl::span<winrt::TerminalApp::ColorScheme> schemes,
+                                 std::vector<::TerminalApp::SettingsLoadWarnings>& warnings)
+    {
+        std::vector<winrt::hstring> commandsToRemove;
+        std::vector<winrt::TerminalApp::Command> commandsToAdd;
+
+        // First, collect up all the commands that need replacing.
+        for (const auto& nameAndCmd : commands)
+        {
+            auto cmd{ get_self<implementation::Command>(nameAndCmd.Value()) };
+
+            auto newCommands = _expandCommand(cmd, profiles, schemes, warnings);
+            if (newCommands.size() > 0)
+            {
+                commandsToRemove.push_back(nameAndCmd.Key());
+                commandsToAdd.insert(commandsToAdd.end(), newCommands.begin(), newCommands.end());
+            }
+        }
+
+        // Second, remove all the commands that need to be removed.
+        for (auto& name : commandsToRemove)
+        {
+            commands.Remove(name);
+        }
+
+        // Finally, add all the new commands.
+        for (auto& cmd : commandsToAdd)
+        {
+            commands.Insert(cmd.Name(), cmd);
+        }
+    }
+
+    // Function Description:
+    // - Attempts to expand the given command into many commands, if the command
+    //   has `"iterateOn": "profiles"` set.
+    // - If it doesn't, this function will do
+    //   nothing and return an empty vector.
+    // - If it does, we're going to attempt to build a new set of commands using
+    //   the given command as a prototype. We'll attempt to create a new command
+    //   for each and every profile, to replace the original command.
+    //   * For the new commands, we'll replace any instance of "${profile.name}"
+    //     in the original json used to create this action with the name of the
+    //     given profile.
+    // - If we encounter any errors while re-parsing the json with the replaced
+    //   name, we'll just return immediately.
+    // - At the end, we'll return all the new commands we've build for the given command.
+    // Arguments:
+    // - expandable: the Command to potentially turn into more commands
+    // - profiles: A list of all the profiles that this command should be expanded on.
+    // - warnings: If there were any warnings during parsing, they'll be
+    //   appended to this vector.
+    // Return Value:
+    // - and empty vector if the command wasn't expandable, otherwise a list of
+    //   the newly-created commands.
+    std::vector<winrt::TerminalApp::Command> Command::_expandCommand(Command* const expandable,
+                                                                     gsl::span<const ::TerminalApp::Profile> profiles,
+                                                                     gsl::span<winrt::TerminalApp::ColorScheme> schemes,
+                                                                     std::vector<::TerminalApp::SettingsLoadWarnings>& warnings)
+    {
+        std::vector<winrt::TerminalApp::Command> newCommands;
+
+        if (expandable->HasNestedCommands())
+        {
+            ExpandCommands(expandable->_subcommands, profiles, schemes, warnings);
+        }
+
+        if (expandable->_IterateOn == ExpandCommandType::None)
+        {
+            return newCommands;
+        }
+
+        std::string errs; // This string will receive any error text from failing to parse.
+        std::unique_ptr<Json::CharReader> reader{ Json::CharReaderBuilder::CharReaderBuilder().newCharReader() };
+
+        // First, get a string for the original Json::Value
+        auto oldJsonString = expandable->_originalJson.toStyledString();
+
+        auto reParseJson = [&](const auto& newJsonString) -> bool {
+            // - Now, re-parse the modified value.
+            Json::Value newJsonValue;
+            const auto actualDataStart = newJsonString.data();
+            const auto actualDataEnd = newJsonString.data() + newJsonString.size();
+            if (!reader->parse(actualDataStart, actualDataEnd, &newJsonValue, &errs))
+            {
+                warnings.push_back(::TerminalApp::SettingsLoadWarnings::FailedToParseCommandJson);
+                // If we encounter a re-parsing error, just stop processing the rest of the commands.
+                return false;
+            }
+
+            // Pass the new json back though FromJson, to get the new expanded value.
+            if (auto newCmd{ Command::FromJson(newJsonValue, warnings) })
+            {
+                newCommands.push_back(*newCmd);
+            }
+            return true;
+        };
+
+        if (expandable->_IterateOn == ExpandCommandType::Profiles)
+        {
+            for (const auto& p : profiles)
+            {
+                // For each profile, create a new command. This command will have:
+                // * the icon path and keychord text of the original command
+                // * the Name will have any instances of "${profile.name}"
+                //   replaced with the profile's name
+                // * for the action, we'll take the original json, replace any
+                //   instances of "${profile.name}" with the profile's name,
+                //   then re-attempt to parse the action and args.
+
+                // Replace all the keywords in the original json, and try and parse that
+
+                // - Escape the profile name for JSON appropriately
+                auto escapedProfileName = _escapeForJson(til::u16u8(p.GetName()));
+                auto escapedProfileIcon = _escapeForJson(til::u16u8(p.GetExpandedIconPath()));
+                auto newJsonString = til::replace_needle_in_haystack(oldJsonString,
+                                                                     ProfileNameToken,
+                                                                     escapedProfileName);
+                til::replace_needle_in_haystack_inplace(newJsonString,
+                                                        ProfileIconToken,
+                                                        escapedProfileIcon);
+
+                // If we encounter a re-parsing error, just stop processing the rest of the commands.
+                if (!reParseJson(newJsonString))
+                {
+                    break;
+                }
+            }
+        }
+        else if (expandable->_IterateOn == ExpandCommandType::ColorSchemes)
+        {
+            for (const auto& s : schemes)
+            {
+                // For each scheme, create a new command. We'll take the
+                // original json, replace any instances of "${scheme.name}" with
+                // the scheme's name, then re-attempt to parse the action and
+                // args.
+
+                // - Escape the profile name for JSON appropriately
+                auto escapedSchemeName = _escapeForJson(til::u16u8(s.Name()));
+                auto newJsonString = til::replace_needle_in_haystack(oldJsonString,
+                                                                     SchemeNameToken,
+                                                                     escapedSchemeName);
+
+                // If we encounter a re-parsing error, just stop processing the rest of the commands.
+                if (!reParseJson(newJsonString))
+                {
+                    break;
+                }
+            }
+        }
+
+        return newCommands;
+    }
 }

src/cascadia/TerminalApp/Command.h

@@ -1,4 +1,4 @@
-/*++
+/*++
 Copyright (c) Microsoft Corporation
 Licensed under the MIT license.
 
@@ -20,22 +20,60 @@ Author(s):
 
 #include "Command.g.h"
 #include "TerminalWarnings.h"
+#include "Profile.h"
 #include "..\inc\cppwinrt_utils.h"
+#include "SettingsTypes.h"
+
+// fwdecl unittest classes
+namespace TerminalAppLocalTests
+{
+    class SettingsTests;
+    class CommandTests;
+};
 
 namespace winrt::TerminalApp::implementation
 {
     struct Command : CommandT<Command>
     {
-        Command() = default;
+        Command();
 
-        static winrt::com_ptr<Command> FromJson(const Json::Value& json, std::vector<::TerminalApp::SettingsLoadWarnings>& warnings);
-        static std::vector<::TerminalApp::SettingsLoadWarnings> LayerJson(std::unordered_map<winrt::hstring, winrt::TerminalApp::Command>& commands,
+        static winrt::com_ptr<Command> FromJson(const Json::Value& json,
+                                                std::vector<::TerminalApp::SettingsLoadWarnings>& warnings);
+
+        static void ExpandCommands(Windows::Foundation::Collections::IMap<winrt::hstring, winrt::TerminalApp::Command>& commands,
+                                   gsl::span<const ::TerminalApp::Profile> profiles,
+                                   gsl::span<winrt::TerminalApp::ColorScheme> schemes,
+                                   std::vector<::TerminalApp::SettingsLoadWarnings>& warnings);
+
+        static std::vector<::TerminalApp::SettingsLoadWarnings> LayerJson(Windows::Foundation::Collections::IMap<winrt::hstring, winrt::TerminalApp::Command>& commands,
                                                                           const Json::Value& json);
+        bool HasNestedCommands();
+        Windows::Foundation::Collections::IMapView<winrt::hstring, TerminalApp::Command> NestedCommands();
+
+        void RefreshIcon();
+
+        winrt::Windows::UI::Xaml::Data::INotifyPropertyChanged::PropertyChanged_revoker propertyChangedRevoker;
 
         WINRT_CALLBACK(PropertyChanged, Windows::UI::Xaml::Data::PropertyChangedEventHandler);
         OBSERVABLE_GETSET_PROPERTY(winrt::hstring, Name, _PropertyChangedHandlers);
         OBSERVABLE_GETSET_PROPERTY(winrt::TerminalApp::ActionAndArgs, Action, _PropertyChangedHandlers);
         OBSERVABLE_GETSET_PROPERTY(winrt::hstring, KeyChordText, _PropertyChangedHandlers);
+        OBSERVABLE_GETSET_PROPERTY(winrt::Windows::UI::Xaml::Controls::IconSource, IconSource, _PropertyChangedHandlers, nullptr);
+
+        GETSET_PROPERTY(::TerminalApp::ExpandCommandType, IterateOn, ::TerminalApp::ExpandCommandType::None);
+
+    private:
+        Json::Value _originalJson;
+        Windows::Foundation::Collections::IMap<winrt::hstring, winrt::TerminalApp::Command> _subcommands{ nullptr };
+
+        winrt::hstring _lastIconPath{};
+
+        static std::vector<winrt::TerminalApp::Command> _expandCommand(Command* const expandable,
+                                                                       gsl::span<const ::TerminalApp::Profile> profiles,
+                                                                       gsl::span<winrt::TerminalApp::ColorScheme> schemes,
+                                                                       std::vector<::TerminalApp::SettingsLoadWarnings>& warnings);
+        friend class TerminalAppLocalTests::SettingsTests;
+        friend class TerminalAppLocalTests::CommandTests;
     };
 }
 

src/cascadia/TerminalApp/Command.idl

@@ -1,7 +1,7 @@
 // Copyright (c) Microsoft Corporation.
 // Licensed under the MIT license.
 
-import "../ShortcutActionDispatch.idl";
+import "ShortcutActionDispatch.idl";
 
 namespace TerminalApp
 {
@@ -12,5 +12,11 @@ namespace TerminalApp
         String Name;
         ActionAndArgs Action;
         String KeyChordText;
+
+        Windows.UI.Xaml.Controls.IconSource IconSource;
+        void RefreshIcon();
+
+        Boolean HasNestedCommands { get; };
+        Windows.Foundation.Collections.IMapView<String, Command> NestedCommands { get; };
     }
 }

src/cascadia/TerminalApp/CommandPalette.cpp

@@ -3,9 +3,13 @@
 
 #include "pch.h"
 #include "CommandPalette.h"
+#include "ActionAndArgs.h"
+#include "ActionArgs.h"
+#include "Command.h"
+
+#include <LibraryResources.h>
 
 #include "CommandPalette.g.cpp"
-#include <winrt/Microsoft.Terminal.Settings.h>
 
 using namespace winrt;
 using namespace winrt::TerminalApp;
@@ -13,15 +17,22 @@ using namespace winrt::Windows::UI::Core;
 using namespace winrt::Windows::UI::Xaml;
 using namespace winrt::Windows::System;
 using namespace winrt::Windows::Foundation;
+using namespace winrt::Windows::Foundation::Collections;
 
 namespace winrt::TerminalApp::implementation
 {
-    CommandPalette::CommandPalette()
+    CommandPalette::CommandPalette() :
+        _switcherStartIdx{ 0 }
     {
         InitializeComponent();
 
         _filteredActions = winrt::single_threaded_observable_vector<winrt::TerminalApp::Command>();
-        _allActions = winrt::single_threaded_vector<winrt::TerminalApp::Command>();
+        _nestedActionStack = winrt::single_threaded_vector<winrt::TerminalApp::Command>();
+        _currentNestedCommands = winrt::single_threaded_vector<winrt::TerminalApp::Command>();
+        _allCommands = winrt::single_threaded_vector<winrt::TerminalApp::Command>();
+        _allTabActions = winrt::single_threaded_vector<winrt::TerminalApp::Command>();
+
+        _switchToMode(CommandPaletteMode::ActionMode);
 
         if (CommandPaletteShadow())
         {
@@ -39,8 +50,23 @@ namespace winrt::TerminalApp::implementation
         RegisterPropertyChangedCallback(UIElement::VisibilityProperty(), [this](auto&&, auto&&) {
             if (Visibility() == Visibility::Visible)
             {
-                _searchBox().Focus(FocusState::Programmatic);
-                _filteredActionsView().SelectedIndex(0);
+                if (_currentMode == CommandPaletteMode::TabSwitchMode)
+                {
+                    _searchBox().Visibility(Visibility::Collapsed);
+                    _filteredActionsView().Focus(FocusState::Keyboard);
+                    _filteredActionsView().SelectedIndex(_switcherStartIdx);
+                    _filteredActionsView().ScrollIntoView(_filteredActionsView().SelectedItem());
+
+                    // Do this right after becoming visible so we can quickly catch scenarios where
+                    // modifiers aren't held down (e.g. command palette invocation).
+                    _anchorKeyUpHandler();
+                }
+                else
+                {
+                    _searchBox().Focus(FocusState::Programmatic);
+                    _updateFilteredActions();
+                    _filteredActionsView().SelectedIndex(0);
+                }
 
                 TraceLoggingWrite(
                     g_hTerminalAppProvider, // handle to TerminalApp tracelogging provider
@@ -56,6 +82,19 @@ namespace winrt::TerminalApp::implementation
                 _dismissPalette();
             }
         });
+
+        // Focusing the ListView when the Command Palette control is set to Visible
+        // for the first time fails because the ListView hasn't finished loading by
+        // the time Focus is called. Luckily, We can listen to SizeChanged to know
+        // when the ListView has been measured out and is ready, and we'll immediately
+        // revoke the handler because we only needed to handle it once on initialization.
+        _sizeChangedRevoker = _filteredActionsView().SizeChanged(winrt::auto_revoke, [this](auto /*s*/, auto /*e*/) {
+            if (_currentMode == CommandPaletteMode::TabSwitchMode)
+            {
+                _filteredActionsView().Focus(FocusState::Keyboard);
+            }
+            _sizeChangedRevoker.revoke();
+        });
     }
 
     // Method Description:
@@ -66,7 +105,7 @@ namespace winrt::TerminalApp::implementation
     //   list. Otherwise, we're attempting to move to the previous.
     // Return Value:
     // - <none>
-    void CommandPalette::_selectNextItem(const bool moveDown)
+    void CommandPalette::SelectNextItem(const bool moveDown)
     {
         const auto selected = _filteredActionsView().SelectedIndex();
         const int numItems = ::base::saturated_cast<int>(_filteredActionsView().Items().Size());
@@ -78,6 +117,34 @@ namespace winrt::TerminalApp::implementation
         _filteredActionsView().ScrollIntoView(_filteredActionsView().SelectedItem());
     }
 
+    void CommandPalette::_previewKeyDownHandler(IInspectable const& /*sender*/,
+                                                Windows::UI::Xaml::Input::KeyRoutedEventArgs const& e)
+    {
+        auto key = e.OriginalKey();
+
+        // Some keypresses such as Tab, Return, Esc, and Arrow Keys are ignored by controls because
+        // they're not considered input key presses. While they don't raise KeyDown events,
+        // they do raise PreviewKeyDown events.
+        //
+        // Only give anchored tab switcher the ability to cycle through tabs with the tab button.
+        // For unanchored mode, accessibility becomes an issue when we try to hijack tab since it's
+        // a really widely used keyboard navigation key.
+        if (_currentMode == CommandPaletteMode::TabSwitchMode && key == VirtualKey::Tab)
+        {
+            auto const state = CoreWindow::GetForCurrentThread().GetKeyState(winrt::Windows::System::VirtualKey::Shift);
+            if (WI_IsFlagSet(state, CoreVirtualKeyStates::Down))
+            {
+                SelectNextItem(false);
+                e.Handled(true);
+            }
+            else
+            {
+                SelectNextItem(true);
+                e.Handled(true);
+            }
+        }
+    }
+
     // Method Description:
     // - Process keystrokes in the input box. This is used for moving focus up
     //   and down the list of commands in Action mode, and for executing
@@ -94,40 +161,151 @@ namespace winrt::TerminalApp::implementation
         if (key == VirtualKey::Up)
         {
             // Action Mode: Move focus to the next item in the list.
-            _selectNextItem(false);
+            SelectNextItem(false);
             e.Handled(true);
         }
         else if (key == VirtualKey::Down)
         {
             // Action Mode: Move focus to the previous item in the list.
-            _selectNextItem(true);
+            SelectNextItem(true);
             e.Handled(true);
         }
         else if (key == VirtualKey::Enter)
         {
-            // Action Mode: Dispatch the action of the selected command.
-
-            if (const auto selectedItem = _filteredActionsView().SelectedItem())
+            // Action, TabSwitch or TabSearchMode Mode: Dispatch the action of the selected command.
+            if (_currentMode != CommandPaletteMode::CommandlineMode)
             {
-                _dispatchCommand(selectedItem.try_as<Command>());
+                if (const auto selectedItem = _filteredActionsView().SelectedItem())
+                {
+                    _dispatchCommand(selectedItem.try_as<TerminalApp::Command>());
+                }
+            }
+            // Commandline Mode: Use the input to synthesize an ExecuteCommandline action
+            else if (_currentMode == CommandPaletteMode::CommandlineMode)
+            {
+                _dispatchCommandline();
             }
 
             e.Handled(true);
         }
         else if (key == VirtualKey::Escape)
         {
-            // Action Mode: Dismiss the palette if the text is empty, otherwise clear the search string.
-            if (_searchBox().Text().empty())
+            // Action, TabSearch, TabSwitch Mode: Dismiss the palette if the
+            // text is empty, otherwise clear the search string.
+            if (_currentMode != CommandPaletteMode::CommandlineMode)
             {
-                _dismissPalette();
+                if (_searchBox().Text().empty())
+                {
+                    _dismissPalette();
+                }
+                else
+                {
+                    _searchBox().Text(L"");
+                }
             }
-            else
+            else if (_currentMode == CommandPaletteMode::CommandlineMode)
             {
-                _searchBox().Text(L"");
+                const auto currentInput = _getPostPrefixInput();
+                if (currentInput.empty())
+                {
+                    // The user's only input "> " so far. We should just dismiss
+                    // the palette. This is like dismissing the Action mode with
+                    // empty input.
+                    _dismissPalette();
+                }
+                else
+                {
+                    // Clear out the current input. We'll leave a ">" in the
+                    // input (to stay in commandline mode), and a leading space
+                    // (if they currently had one).
+                    const bool hasLeadingSpace = (_searchBox().Text().size()) - (currentInput.size()) > 1;
+                    _searchBox().Text(hasLeadingSpace ? L"> " : L">");
+
+                    // This will conveniently move the cursor to the end of the
+                    // text input for us.
+                    _searchBox().Select(_searchBox().Text().size(), 0);
+                }
             }
 
             e.Handled(true);
         }
+        else
+        {
+            const auto vkey = ::gsl::narrow_cast<WORD>(e.OriginalKey());
+
+            // In the interest of not telling all modes to check for keybindings, limit to TabSwitch mode for now.
+            if (_currentMode == CommandPaletteMode::TabSwitchMode)
+            {
+                auto const ctrlDown = WI_IsFlagSet(CoreWindow::GetForCurrentThread().GetKeyState(winrt::Windows::System::VirtualKey::Control), CoreVirtualKeyStates::Down);
+                auto const altDown = WI_IsFlagSet(CoreWindow::GetForCurrentThread().GetKeyState(winrt::Windows::System::VirtualKey::Menu), CoreVirtualKeyStates::Down);
+                auto const shiftDown = WI_IsFlagSet(CoreWindow::GetForCurrentThread().GetKeyState(winrt::Windows::System::VirtualKey::Shift), CoreVirtualKeyStates::Down);
+
+                auto success = _bindings.TryKeyChord({
+                    ctrlDown,
+                    altDown,
+                    shiftDown,
+                    vkey,
+                });
+
+                if (success)
+                {
+                    e.Handled(true);
+                }
+            }
+        }
+    }
+
+    // Method Description:
+    // - Implements the Alt handler
+    // Return value:
+    // - whether the key was handled
+    bool CommandPalette::OnDirectKeyEvent(const uint32_t vkey, const uint8_t /*scanCode*/, const bool down)
+    {
+        auto handled = false;
+        if (_currentMode == CommandPaletteMode::TabSwitchMode)
+        {
+            if (vkey == VK_MENU && !down)
+            {
+                _anchorKeyUpHandler();
+                handled = true;
+            }
+        }
+        return handled;
+    }
+
+    void CommandPalette::_keyUpHandler(IInspectable const& /*sender*/,
+                                       Windows::UI::Xaml::Input::KeyRoutedEventArgs const& e)
+    {
+        if (_currentMode == CommandPaletteMode::TabSwitchMode)
+        {
+            _anchorKeyUpHandler();
+            e.Handled(true);
+        }
+    }
+
+    // Method Description:
+    // - Handles anchor key ups during TabSwitchMode.
+    //   We assume that at least one modifier key should be held down in order to "anchor"
+    //   the ATS UI in place. So this function is called to check if any modifiers are
+    //   still held down, and if not, dispatch the selected tab action and close the ATS.
+    // Return value:
+    // - <none>
+    void CommandPalette::_anchorKeyUpHandler()
+    {
+        auto const ctrlDown = WI_IsFlagSet(CoreWindow::GetForCurrentThread().GetKeyState(winrt::Windows::System::VirtualKey::Control), CoreVirtualKeyStates::Down);
+        auto const altDown = WI_IsFlagSet(CoreWindow::GetForCurrentThread().GetKeyState(winrt::Windows::System::VirtualKey::Menu), CoreVirtualKeyStates::Down);
+        auto const shiftDown = WI_IsFlagSet(CoreWindow::GetForCurrentThread().GetKeyState(winrt::Windows::System::VirtualKey::Shift), CoreVirtualKeyStates::Down);
+
+        if (!ctrlDown && !altDown && !shiftDown)
+        {
+            if (const auto selectedItem = _filteredActionsView().SelectedItem())
+            {
+                if (const auto data = selectedItem.try_as<TerminalApp::Command>())
+                {
+                    _dispatchCommand(data);
+                }
+            }
+        }
     }
 
     // Method Description:
@@ -172,6 +350,59 @@ namespace winrt::TerminalApp::implementation
         _dispatchCommand(e.ClickedItem().try_as<TerminalApp::Command>());
     }
 
+    // Method Description:
+    // - This is called when the user selects a command with subcommands. It
+    //   will update our UI to now display the list of subcommands instead, and
+    //   clear the search text so the user can search from the new list of
+    //   commands.
+    // Arguments:
+    // - <none>
+    // Return Value:
+    // - <none>
+    void CommandPalette::_updateUIForStackChange()
+    {
+        if (_searchBox().Text().empty())
+        {
+            // Manually call _filterTextChanged, because setting the text to the
+            // empty string won't update it for us (as it won't actually change value.)
+            _filterTextChanged(nullptr, nullptr);
+        }
+
+        // Changing the value of the search box will trigger _filterTextChanged,
+        // which will cause us to refresh the list of filterable commands.
+        _searchBox().Text(L"");
+    }
+
+    // Method Description:
+    // - Retrieve the list of commands that we should currently be filtering.
+    //   * If the user has command with subcommands, this will return that command's subcommands.
+    //   * If we're in Tab Switcher mode, return the tab actions.
+    //   * Otherwise, just return the list of all the top-level commands.
+    // Arguments:
+    // - <none>
+    // Return Value:
+    // - A list of Commands to filter.
+    Collections::IVector<TerminalApp::Command> CommandPalette::_commandsToFilter()
+    {
+        switch (_currentMode)
+        {
+        case CommandPaletteMode::ActionMode:
+            if (_nestedActionStack.Size() > 0)
+            {
+                return _currentNestedCommands;
+            }
+
+            return _allCommands;
+        case CommandPaletteMode::TabSearchMode:
+        case CommandPaletteMode::TabSwitchMode:
+            return _allTabActions;
+        case CommandPaletteMode::CommandlineMode:
+            return winrt::single_threaded_vector<TerminalApp::Command>();
+        default:
+            return _allCommands;
+        }
+    }
+
     // Method Description:
     // - Helper method for retrieving the action from a command the user
     //   selected, and dispatching that command. Also fires a tracelogging event
@@ -185,17 +416,110 @@ namespace winrt::TerminalApp::implementation
     {
         if (command)
         {
-            const auto actionAndArgs = command.Action();
-            _dispatch.DoAction(actionAndArgs);
+            if (command.HasNestedCommands())
+            {
+                // If this Command had subcommands, then don't dispatch the
+                // action. Instead, display a new list of commands for the user
+                // to pick from.
+                _nestedActionStack.Append(command);
+                ParentCommandName(command.Name());
+                _currentNestedCommands.Clear();
+                for (const auto& nameAndCommand : command.NestedCommands())
+                {
+                    _currentNestedCommands.Append(nameAndCommand.Value());
+                }
 
-            TraceLoggingWrite(
-                g_hTerminalAppProvider, // handle to TerminalApp tracelogging provider
-                "CommandPaletteDispatchedAction",
-                TraceLoggingDescription("Event emitted when the user selects an action in the Command Palette"),
-                TraceLoggingUInt32(_searchBox().Text().size(), "SearchTextLength", "Number of characters in the search string"),
-                TraceLoggingKeyword(MICROSOFT_KEYWORD_MEASURES),
-                TelemetryPrivacyDataTag(PDT_ProductAndServicePerformance));
+                _updateUIForStackChange();
+            }
+            else
+            {
+                // First stash the search text length, because _close will clear this.
+                const auto searchTextLength = _searchBox().Text().size();
 
+                // An action from the root command list has depth=0
+                const auto nestedCommandDepth = _nestedActionStack.Size();
+
+                // Close before we dispatch so that actions that open the command
+                // palette like the Tab Switcher will be able to have the last laugh.
+                _close();
+
+                const auto actionAndArgs = command.Action();
+                _dispatch.DoAction(actionAndArgs);
+
+                TraceLoggingWrite(
+                    g_hTerminalAppProvider, // handle to TerminalApp tracelogging provider
+                    "CommandPaletteDispatchedAction",
+                    TraceLoggingDescription("Event emitted when the user selects an action in the Command Palette"),
+                    TraceLoggingUInt32(searchTextLength, "SearchTextLength", "Number of characters in the search string"),
+                    TraceLoggingUInt32(nestedCommandDepth, "NestedCommandDepth", "the depth in the tree of commands for the dispatched action"),
+                    TraceLoggingKeyword(MICROSOFT_KEYWORD_MEASURES),
+                    TelemetryPrivacyDataTag(PDT_ProductAndServicePerformance));
+            }
+        }
+    }
+
+    // Method Description:
+    // - Get all the input text in _searchBox that follows the prefix character
+    //   and any whitespace following that prefix character. This can be used in
+    //   commandline mode to get all the useful input that the user input after
+    //   the leading ">" prefix.
+    // - Note that this will behave unexpectedly in Action Mode.
+    // Arguments:
+    // - <none>
+    // Return Value:
+    // - the string of input following the prefix character.
+    std::wstring CommandPalette::_getPostPrefixInput()
+    {
+        const std::wstring input{ _searchBox().Text() };
+        if (input.empty())
+        {
+            return input;
+        }
+
+        const auto rawCmdline{ input.substr(1) };
+
+        // Trim leading whitespace
+        const auto firstNonSpace = rawCmdline.find_first_not_of(L" ");
+        if (firstNonSpace == std::wstring::npos)
+        {
+            // All the following characters are whitespace.
+            return L"";
+        }
+
+        return rawCmdline.substr(firstNonSpace);
+    }
+
+    // Method Description:
+    // - Dispatch the current search text as a ExecuteCommandline action.
+    // Arguments:
+    // - <none>
+    // Return Value:
+    // - <none>
+    void CommandPalette::_dispatchCommandline()
+    {
+        const auto input = _getPostPrefixInput();
+        if (input.empty())
+        {
+            return;
+        }
+        winrt::hstring cmdline{ input };
+
+        // Build the ExecuteCommandline action from the values we've parsed on the commandline.
+        auto executeActionAndArgs = winrt::make_self<implementation::ActionAndArgs>();
+        executeActionAndArgs->Action(ShortcutAction::ExecuteCommandline);
+        auto args = winrt::make_self<implementation::ExecuteCommandlineArgs>();
+        args->Commandline(cmdline);
+        executeActionAndArgs->Args(*args);
+
+        TraceLoggingWrite(
+            g_hTerminalAppProvider, // handle to TerminalApp tracelogging provider
+            "CommandPaletteDispatchedCommandline",
+            TraceLoggingDescription("Event emitted when the user runs a commandline in the Command Palette"),
+            TraceLoggingKeyword(MICROSOFT_KEYWORD_MEASURES),
+            TelemetryPrivacyDataTag(PDT_ProductAndServicePerformance));
+
+        if (_dispatch.DoAction(*executeActionAndArgs))
+        {
             _close();
         }
     }
@@ -230,23 +554,102 @@ namespace winrt::TerminalApp::implementation
     void CommandPalette::_filterTextChanged(IInspectable const& /*sender*/,
                                             Windows::UI::Xaml::RoutedEventArgs const& /*args*/)
     {
+        if (_currentMode == CommandPaletteMode::CommandlineMode || _currentMode == CommandPaletteMode::ActionMode)
+        {
+            _evaluatePrefix();
+        }
+
         _updateFilteredActions();
         _filteredActionsView().SelectedIndex(0);
 
         _noMatchesText().Visibility(_filteredActions.Size() > 0 ? Visibility::Collapsed : Visibility::Visible);
     }
 
-    Collections::IObservableVector<Command> CommandPalette::FilteredActions()
+    void CommandPalette::_evaluatePrefix()
+    {
+        auto newMode = CommandPaletteMode::ActionMode;
+
+        auto inputText = _searchBox().Text();
+        if (inputText.size() > 0)
+        {
+            if (inputText[0] == L'>')
+            {
+                newMode = CommandPaletteMode::CommandlineMode;
+            }
+        }
+
+        if (newMode != _currentMode)
+        {
+            _switchToMode(newMode);
+        }
+    }
+
+    Collections::IObservableVector<TerminalApp::Command> CommandPalette::FilteredActions()
     {
         return _filteredActions;
     }
 
-    void CommandPalette::SetActions(Collections::IVector<TerminalApp::Command> const& actions)
+    void CommandPalette::SetKeyBindings(Microsoft::Terminal::TerminalControl::IKeyBindings bindings)
     {
-        _allActions = actions;
+        _bindings = bindings;
+    }
+
+    void CommandPalette::SetCommands(Collections::IVector<TerminalApp::Command> const& actions)
+    {
+        _allCommands = actions;
         _updateFilteredActions();
     }
 
+    void CommandPalette::EnableCommandPaletteMode()
+    {
+        _switchToMode(CommandPaletteMode::ActionMode);
+        _updateFilteredActions();
+    }
+
+    void CommandPalette::_switchToMode(CommandPaletteMode mode)
+    {
+        // The smooth remove/add animations that happen during
+        // UpdateFilteredActions don't work very well when switching between
+        // modes because of the sheer amount of remove/adds. So, let's just
+        // clear + append when switching between modes.
+        if (mode != _currentMode)
+        {
+            _currentMode = mode;
+            _filteredActions.Clear();
+            auto commandsToFilter = _commandsToFilter();
+
+            for (auto action : commandsToFilter)
+            {
+                _filteredActions.Append(action);
+            }
+        }
+
+        // Leaving this block of code outside the above if-statement
+        // guarantees that the correct text is shown for the mode
+        // whenever _switchToMode is called.
+        switch (_currentMode)
+        {
+        case CommandPaletteMode::TabSearchMode:
+        case CommandPaletteMode::TabSwitchMode:
+        {
+            SearchBoxText(RS_(L"TabSwitcher_SearchBoxText"));
+            NoMatchesText(RS_(L"TabSwitcher_NoMatchesText"));
+            ControlName(RS_(L"TabSwitcherControlName"));
+            break;
+        }
+        case CommandPaletteMode::CommandlineMode:
+            NoMatchesText(RS_(L"CmdPalCommandlinePrompt"));
+            ControlName(RS_(L"CommandPaletteControlName"));
+            break;
+        case CommandPaletteMode::ActionMode:
+        default:
+            SearchBoxText(RS_(L"CommandPalette_SearchBox/PlaceholderText"));
+            NoMatchesText(RS_(L"CommandPalette_NoMatchesText/Text"));
+            ControlName(RS_(L"CommandPaletteControlName"));
+            break;
+        }
+    }
+
     // This is a helper to aid in sorting commands by their `Name`s, alphabetically.
     static bool _compareCommandNames(const TerminalApp::Command& lhs, const TerminalApp::Command& rhs)
     {
@@ -260,13 +663,23 @@ namespace winrt::TerminalApp::implementation
     {
         TerminalApp::Command command;
         int weight;
+        int inOrderCounter;
 
         bool operator<(const WeightedCommand& other) const
         {
-            // If two commands have the same weight, then we'll sort them alphabetically.
             if (weight == other.weight)
             {
-                return !_compareCommandNames(command, other.command);
+                // If two commands have the same weight, then we'll sort them alphabetically.
+                // If they both have the same name, fall back to the order in which they were
+                // pushed into the heap.
+                if (command.Name() == other.command.Name())
+                {
+                    return inOrderCounter > other.inOrderCounter;
+                }
+                else
+                {
+                    return !_compareCommandNames(command, other.command);
+                }
             }
             return weight < other.weight;
         }
@@ -287,16 +700,30 @@ namespace winrt::TerminalApp::implementation
         auto searchText = _searchBox().Text();
         const bool addAll = searchText.empty();
 
+        auto commandsToFilter = _commandsToFilter();
+
         // If there's no filter text, then just add all the commands in order to the list.
         // - TODO GH#6647:Possibly add the MRU commands first in order, followed
         //   by the rest of the commands.
         if (addAll)
         {
+            // If TabSwitcherMode, just add all as is. We don't want
+            // them to be sorted alphabetically.
+            if (_currentMode == CommandPaletteMode::TabSearchMode || _currentMode == CommandPaletteMode::TabSwitchMode)
+            {
+                for (auto action : commandsToFilter)
+                {
+                    actions.push_back(action);
+                }
+
+                return actions;
+            }
+
             // Add all the commands, but make sure they're sorted alphabetically.
             std::vector<TerminalApp::Command> sortedCommands;
-            sortedCommands.reserve(_allActions.Size());
+            sortedCommands.reserve(commandsToFilter.Size());
 
-            for (auto action : _allActions)
+            for (auto action : commandsToFilter)
             {
                 sortedCommands.push_back(action);
             }
@@ -326,7 +753,12 @@ namespace winrt::TerminalApp::implementation
         // appear first in the list. The ordering will be determined by the
         // match weight produced by _getWeight.
         std::priority_queue<WeightedCommand> heap;
-        for (auto action : _allActions)
+
+        // TODO GH#7205: Find a better way to ensure that WCs of the same
+        // weight and name stay in the order in which they were pushed onto
+        // the PQ.
+        uint32_t counter = 0;
+        for (auto action : commandsToFilter)
         {
             const auto weight = CommandPalette::_getWeight(searchText, action.Name());
             if (weight > 0)
@@ -334,6 +766,8 @@ namespace winrt::TerminalApp::implementation
                 WeightedCommand wc;
                 wc.command = action;
                 wc.weight = weight;
+                wc.inOrderCounter = counter++;
+
                 heap.push(wc);
             }
         }
@@ -362,6 +796,12 @@ namespace winrt::TerminalApp::implementation
     // - <none>
     void CommandPalette::_updateFilteredActions()
     {
+        if (_currentMode == CommandPaletteMode::CommandlineMode)
+        {
+            _filteredActions.Clear();
+            return;
+        }
+
         auto actions = _collectFilteredActions();
 
         // Make _filteredActions look identical to actions, using only Insert and Remove.
@@ -503,8 +943,160 @@ namespace winrt::TerminalApp::implementation
     {
         Visibility(Visibility::Collapsed);
 
+        // Reset visibility in case anchor mode tab switcher just finished.
+        _searchBox().Visibility(Visibility::Visible);
+
         // Clear the text box each time we close the dialog. This is consistent with VsCode.
         _searchBox().Text(L"");
+
+        _nestedActionStack.Clear();
+
+        ParentCommandName(L"");
+        _currentNestedCommands.Clear();
     }
 
+    // Method Description:
+    // - Listens for changes to TerminalPage's _tabs vector. Updates our vector of
+    //   tab switching commands accordingly.
+    // Arguments:
+    // - s: The vector being listened to.
+    // - e: The vector changed args that tells us whether a change, insert, or removal was performed
+    //      on the listened-to vector.
+    // Return Value:
+    // - <none>
+    void CommandPalette::OnTabsChanged(const IInspectable& s, const IVectorChangedEventArgs& e)
+    {
+        if (auto tabList = s.try_as<IObservableVector<TerminalApp::Tab>>())
+        {
+            auto idx = e.Index();
+            auto changedEvent = e.CollectionChange();
+
+            switch (changedEvent)
+            {
+            case CollectionChange::ItemChanged:
+            {
+                winrt::com_ptr<Command> item;
+                item.copy_from(winrt::get_self<Command>(_allTabActions.GetAt(idx)));
+                item->propertyChangedRevoker.revoke();
+
+                auto tab = tabList.GetAt(idx);
+                GenerateCommandForTab(idx, false, tab);
+                UpdateTabIndices(idx);
+                break;
+            }
+            case CollectionChange::ItemInserted:
+            {
+                auto tab = tabList.GetAt(idx);
+                GenerateCommandForTab(idx, true, tab);
+                UpdateTabIndices(idx);
+                break;
+            }
+            case CollectionChange::ItemRemoved:
+            {
+                winrt::com_ptr<Command> item;
+                item.copy_from(winrt::get_self<Command>(_allTabActions.GetAt(idx)));
+                item->propertyChangedRevoker.revoke();
+
+                _allTabActions.RemoveAt(idx);
+                UpdateTabIndices(idx);
+                break;
+            }
+            }
+
+            _updateFilteredActions();
+        }
+    }
+
+    // Method Description:
+    // - In the case where a tab is removed or reordered, the given indices of
+    //   the tab switch commands following the removed/reordered tab will get out of sync by 1
+    //   (e.g. if tab 1 is removed, tabs 2,3,4,... need to become tabs 1,2,3,...)
+    //   This function just loops through the tabs following startIdx and adjusts their given indices.
+    // Arguments:
+    // - startIdx: The index to start the update loop at.
+    // Return Value:
+    // - <none>
+    void CommandPalette::UpdateTabIndices(const uint32_t startIdx)
+    {
+        for (auto i = startIdx; i < _allTabActions.Size(); ++i)
+        {
+            auto command = _allTabActions.GetAt(i);
+
+            command.Action().Args().as<implementation::SwitchToTabArgs>()->TabIndex(i);
+        }
+    }
+
+    // Method Description:
+    // - Create a tab switching command based on the given tab object and insert/update the command
+    //   at the given index. The command will call a SwitchToTab action on the given idx.
+    // Arguments:
+    // - idx: The index to insert or update the tab switch command.
+    // - tab: The tab object to refer to when creating the tab switch command.
+    // Return Value:
+    // - <none>
+    void CommandPalette::GenerateCommandForTab(const uint32_t idx, bool inserted, TerminalApp::Tab& tab)
+    {
+        auto focusTabAction = winrt::make_self<implementation::ActionAndArgs>();
+        auto args = winrt::make_self<implementation::SwitchToTabArgs>();
+        args->TabIndex(idx);
+
+        focusTabAction->Action(ShortcutAction::SwitchToTab);
+        focusTabAction->Args(*args);
+
+        auto command = winrt::make_self<implementation::Command>();
+        command->Action(*focusTabAction);
+        command->Name(tab.Title());
+        command->IconSource(tab.IconSource());
+
+        // Listen for changes to the Tab so we can update this Command's attributes accordingly.
+        auto weakThis{ get_weak() };
+        auto weakCommand{ command->get_weak() };
+        command->propertyChangedRevoker = tab.PropertyChanged(winrt::auto_revoke, [weakThis, weakCommand, tab](auto&&, const Windows::UI::Xaml::Data::PropertyChangedEventArgs& args) {
+            auto palette{ weakThis.get() };
+            auto command{ weakCommand.get() };
+
+            if (palette && command)
+            {
+                if (args.PropertyName() == L"Title")
+                {
+                    if (command->Name() != tab.Title())
+                    {
+                        command->Name(tab.Title());
+                    }
+                }
+                if (args.PropertyName() == L"IconSource")
+                {
+                    if (command->IconSource() != tab.IconSource())
+                    {
+                        command->IconSource(tab.IconSource());
+                    }
+                }
+            }
+        });
+
+        if (inserted)
+        {
+            _allTabActions.InsertAt(idx, *command);
+        }
+        else
+        {
+            _allTabActions.SetAt(idx, *command);
+        }
+    }
+
+    void CommandPalette::EnableTabSwitcherMode(const bool searchMode, const uint32_t startIdx)
+    {
+        _switcherStartIdx = startIdx;
+
+        if (searchMode)
+        {
+            _switchToMode(CommandPaletteMode::TabSearchMode);
+        }
+        else
+        {
+            _switchToMode(CommandPaletteMode::TabSwitchMode);
+        }
+
+        _updateFilteredActions();
+    }
 }

src/cascadia/TerminalApp/CommandPalette.h

@@ -8,41 +8,95 @@
 
 namespace winrt::TerminalApp::implementation
 {
+    enum class CommandPaletteMode
+    {
+        ActionMode = 0,
+        TabSearchMode,
+        TabSwitchMode,
+        CommandlineMode
+    };
+
     struct CommandPalette : CommandPaletteT<CommandPalette>
     {
         CommandPalette();
 
         Windows::Foundation::Collections::IObservableVector<TerminalApp::Command> FilteredActions();
-        void SetActions(Windows::Foundation::Collections::IVector<TerminalApp::Command> const& actions);
+
+        void SetCommands(Windows::Foundation::Collections::IVector<TerminalApp::Command> const& actions);
+        void SetKeyBindings(Microsoft::Terminal::TerminalControl::IKeyBindings bindings);
+
+        void EnableCommandPaletteMode();
 
         void SetDispatch(const winrt::TerminalApp::ShortcutActionDispatch& dispatch);
 
+        bool OnDirectKeyEvent(const uint32_t vkey, const uint8_t scanCode, const bool down);
+
+        void SelectNextItem(const bool moveDown);
+
+        // Tab Switcher
+        void EnableTabSwitcherMode(const bool searchMode, const uint32_t startIdx);
+        void OnTabsChanged(const Windows::Foundation::IInspectable& s, const Windows::Foundation::Collections::IVectorChangedEventArgs& e);
+
+        WINRT_CALLBACK(PropertyChanged, Windows::UI::Xaml::Data::PropertyChangedEventHandler);
+        OBSERVABLE_GETSET_PROPERTY(winrt::hstring, NoMatchesText, _PropertyChangedHandlers);
+        OBSERVABLE_GETSET_PROPERTY(winrt::hstring, SearchBoxText, _PropertyChangedHandlers);
+        OBSERVABLE_GETSET_PROPERTY(winrt::hstring, ControlName, _PropertyChangedHandlers);
+        OBSERVABLE_GETSET_PROPERTY(winrt::hstring, ParentCommandName, _PropertyChangedHandlers);
+
     private:
         friend struct CommandPaletteT<CommandPalette>; // for Xaml to bind events
 
+        Windows::Foundation::Collections::IVector<TerminalApp::Command> _allCommands{ nullptr };
+        Windows::Foundation::Collections::IVector<TerminalApp::Command> _currentNestedCommands{ nullptr };
         Windows::Foundation::Collections::IObservableVector<TerminalApp::Command> _filteredActions{ nullptr };
-        Windows::Foundation::Collections::IVector<TerminalApp::Command> _allActions{ nullptr };
+        Windows::Foundation::Collections::IVector<TerminalApp::Command> _nestedActionStack{ nullptr };
+
         winrt::TerminalApp::ShortcutActionDispatch _dispatch;
 
+        Windows::Foundation::Collections::IVector<TerminalApp::Command> _commandsToFilter();
+
         void _filterTextChanged(Windows::Foundation::IInspectable const& sender,
                                 Windows::UI::Xaml::RoutedEventArgs const& args);
+        void _previewKeyDownHandler(Windows::Foundation::IInspectable const& sender,
+                                    Windows::UI::Xaml::Input::KeyRoutedEventArgs const& e);
         void _keyDownHandler(Windows::Foundation::IInspectable const& sender,
                              Windows::UI::Xaml::Input::KeyRoutedEventArgs const& e);
+        void _keyUpHandler(Windows::Foundation::IInspectable const& sender,
+                           Windows::UI::Xaml::Input::KeyRoutedEventArgs const& e);
+
+        void _updateUIForStackChange();
 
         void _rootPointerPressed(Windows::Foundation::IInspectable const& sender, Windows::UI::Xaml::Input::PointerRoutedEventArgs const& e);
         void _backdropPointerPressed(Windows::Foundation::IInspectable const& sender, Windows::UI::Xaml::Input::PointerRoutedEventArgs const& e);
 
         void _listItemClicked(Windows::Foundation::IInspectable const& sender, Windows::UI::Xaml::Controls::ItemClickEventArgs const& e);
 
-        void _selectNextItem(const bool moveDown);
-
         void _updateFilteredActions();
+
         std::vector<winrt::TerminalApp::Command> _collectFilteredActions();
+
         static int _getWeight(const winrt::hstring& searchText, const winrt::hstring& name);
         void _close();
 
-        void _dispatchCommand(const TerminalApp::Command& command);
+        CommandPaletteMode _currentMode;
+        void _switchToMode(CommandPaletteMode mode);
 
+        void _evaluatePrefix();
+        std::wstring _getPostPrefixInput();
+
+        Microsoft::Terminal::TerminalControl::IKeyBindings _bindings;
+
+        // Tab Switcher
+        void GenerateCommandForTab(const uint32_t idx, bool inserted, winrt::TerminalApp::Tab& tab);
+        void UpdateTabIndices(const uint32_t startIdx);
+        Windows::Foundation::Collections::IVector<TerminalApp::Command> _allTabActions{ nullptr };
+        uint32_t _switcherStartIdx;
+        void _anchorKeyUpHandler();
+
+        winrt::Windows::UI::Xaml::Controls::ListView::SizeChanged_revoker _sizeChangedRevoker;
+
+        void _dispatchCommand(const TerminalApp::Command& command);
+        void _dispatchCommandline();
         void _dismissPalette();
     };
 }

src/cascadia/TerminalApp/CommandPalette.idl

@@ -1,18 +1,31 @@
 // Copyright (c) Microsoft Corporation.
 // Licensed under the MIT license.
 
-import "../Command.idl";
+import "Command.idl";
+import "IDirectKeyListener.idl";
 
 namespace TerminalApp
 {
-    [default_interface] runtimeclass CommandPalette : Windows.UI.Xaml.Controls.Grid
+    [default_interface] runtimeclass CommandPalette : Windows.UI.Xaml.Controls.UserControl, Windows.UI.Xaml.Data.INotifyPropertyChanged, IDirectKeyListener
     {
         CommandPalette();
 
+        String NoMatchesText { get; };
+        String SearchBoxText { get; };
+        String ControlName { get; };
+        String ParentCommandName { get; };
+
         Windows.Foundation.Collections.IObservableVector<Command> FilteredActions { get; };
 
-        void SetActions(Windows.Foundation.Collections.IVector<Command> actions);
+        void SetCommands(Windows.Foundation.Collections.IVector<Command> actions);
+        void SetKeyBindings(Microsoft.Terminal.TerminalControl.IKeyBindings bindings);
+        void EnableCommandPaletteMode();
+
+        void SelectNextItem(Boolean moveDown);
 
         void SetDispatch(ShortcutActionDispatch dispatch);
+
+        void EnableTabSwitcherMode(Boolean searchMode, UInt32 startIdx);
+        void OnTabsChanged(IInspectable s, Windows.Foundation.Collections.IVectorChangedEventArgs e);
     }
 }

src/cascadia/TerminalApp/CommandPalette.xaml

@@ -1,6 +1,6 @@
 <!-- Copyright (c) Microsoft Corporation. All rights reserved. Licensed under
 the MIT License. See LICENSE in the project root for license information. -->
-<Grid
+<UserControl
     x:Class="TerminalApp.CommandPalette"
     xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
     xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
@@ -9,10 +9,17 @@ the MIT License. See LICENSE in the project root for license information. -->
     xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
     xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
     xmlns:Windows10version1903="http://schemas.microsoft.com/winfx/2006/xaml/presentation?IsApiContractPresent(Windows.Foundation.UniversalApiContract, 8)"
+    TabNavigation="Cycle"
+    IsTabStop="True"
+    AllowFocusOnInteraction="True"
     PointerPressed="_rootPointerPressed"
-    mc:Ignorable="d">
+    PreviewKeyDown="_previewKeyDownHandler"
+    KeyDown="_keyDownHandler"
+    PreviewKeyUp="_keyUpHandler"
+    mc:Ignorable="d"
+    AutomationProperties.Name="{x:Bind ControlName, Mode=OneWay}">
 
-    <Grid.Resources>
+    <UserControl.Resources>
         <ResourceDictionary>
 
             <!-- ThemeShadow is only on 18362. This "Windows10version1903" bit
@@ -20,7 +27,9 @@ the MIT License. See LICENSE in the project root for license information. -->
             <Windows10version1903:ThemeShadow x:Name="CommandPaletteShadow" />
 
             <!-- This creates an instance of our CommandKeyChordVisibilityConverter we can reference below -->
-            <local:CommandKeyChordVisibilityConverter x:Key="CommandKeyChordVisibilityConverter"/>
+            <local:EmptyStringVisibilityConverter x:Key="CommandKeyChordVisibilityConverter"/>
+            <local:EmptyStringVisibilityConverter x:Key="ParentCommandVisibilityConverter"/>
+            <local:HasNestedCommandsVisibilityConverter x:Key="HasNestedCommandsVisibilityConverter"/>
 
             <ResourceDictionary.ThemeDictionaries>
                 <ResourceDictionary x:Key="Dark">
@@ -100,29 +109,30 @@ the MIT License. See LICENSE in the project root for license information. -->
                 </ResourceDictionary>
             </ResourceDictionary.ThemeDictionaries>
         </ResourceDictionary>
+    </UserControl.Resources>
 
-    </Grid.Resources>
+    <Grid>
 
-    <Grid.ColumnDefinitions>
-        <ColumnDefinition Width="2*" />
-        <ColumnDefinition Width="6*" />
-        <ColumnDefinition Width="2*" />
-    </Grid.ColumnDefinitions>
+        <Grid.ColumnDefinitions>
+            <ColumnDefinition Width="2*" />
+            <ColumnDefinition Width="6*" />
+            <ColumnDefinition Width="2*" />
+        </Grid.ColumnDefinitions>
 
-    <Grid.RowDefinitions>
-        <RowDefinition Height="8*"/>
-        <RowDefinition Height="2*"/>
-    </Grid.RowDefinitions>
+        <Grid.RowDefinitions>
+            <RowDefinition Height="8*"/>
+            <RowDefinition Height="2*"/>
+        </Grid.RowDefinitions>
 
-    <!-- Setting the row/col span of this shadow backdrop is a bit of a hack. In
-    order to receive pointer events, an element needs to be _not_ transparent.
-    However, we want to be able to eat all the clicks outside the immediate
-    bounds of the command palette, and we don't want a semi-transparent overlay
-    over all of the UI. Fortunately, if we make this _shadowBackdrop the size of
-    the entire page, then it can be mostly transparent, and cause the root grid
-    to receive clicks _anywhere_ in its bounds. -->
+        <!-- Setting the row/col span of this shadow backdrop is a bit of a hack. In
+        order to receive pointer events, an element needs to be _not_ transparent.
+        However, we want to be able to eat all the clicks outside the immediate
+        bounds of the command palette, and we don't want a semi-transparent overlay
+        over all of the UI. Fortunately, if we make this _shadowBackdrop the size of
+        the entire page, then it can be mostly transparent, and cause the root grid
+        to receive clicks _anywhere_ in its bounds. -->
 
-    <Grid
+        <Grid
         x:Name="_shadowBackdrop"
         Background="Transparent"
         Grid.Column="0"
@@ -133,7 +143,7 @@ the MIT License. See LICENSE in the project root for license information. -->
         VerticalAlignment="Stretch">
         </Grid>
 
-    <Grid
+        <Grid
         x:Name="_backdrop"
         Style="{ThemeResource CommandPaletteBackground}"
         CornerRadius="{ThemeResource ControlCornerRadius}"
@@ -145,33 +155,43 @@ the MIT License. See LICENSE in the project root for license information. -->
         HorizontalAlignment="Stretch"
         VerticalAlignment="Top">
 
-        <Grid.RowDefinitions>
-            <RowDefinition Height="Auto"/>
-            <RowDefinition Height="Auto"/>
-            <RowDefinition Height="*"/>
-        </Grid.RowDefinitions>
+            <Grid.RowDefinitions>
+                <RowDefinition Height="Auto"/>
+                <RowDefinition Height="Auto"/>
+                <RowDefinition Height="*"/>
+            </Grid.RowDefinitions>
 
-        <TextBox
+            <TextBox
             Grid.Row="0"
-            x:Uid="CommandPalette_SearchBox"
             x:Name="_searchBox"
             Margin="8"
             IsSpellCheckEnabled="False"
             TextChanged="_filterTextChanged"
-            KeyDown="_keyDownHandler"
+            PlaceholderText="{x:Bind SearchBoxText, Mode=OneWay}"
             Text="">
-        </TextBox>
+            </TextBox>
 
-        <TextBlock
-            Padding="16"
-            x:Name="_noMatchesText"
-            x:Uid="CommandPalette_NoMatchesText"
-            FontStyle="Italic"
-            Visibility="Collapsed"
-            Grid.Row="1">
-        </TextBlock>
+            <TextBlock
+                Padding="16, 0, 16, 4"
+                x:Name="_parentCommandText"
+                FontStyle="Italic"
+                Visibility="{x:Bind ParentCommandName,
+                             Mode=OneWay,
+                             Converter={StaticResource ParentCommandVisibilityConverter}}"
+                Grid.Row="1"
+                Text="{x:Bind ParentCommandName, Mode=OneWay}">
+            </TextBlock>
 
-        <ListView
+            <TextBlock
+                Padding="16"
+                x:Name="_noMatchesText"
+                FontStyle="Italic"
+                Visibility="Collapsed"
+                Grid.Row="1"
+                Text="{x:Bind NoMatchesText, Mode=OneWay}">
+            </TextBlock>
+
+            <ListView
             Grid.Row="2"
             x:Name="_filteredActionsView"
             HorizontalAlignment="Stretch"
@@ -181,57 +201,79 @@ the MIT License. See LICENSE in the project root for license information. -->
             AllowDrop="False"
             IsItemClickEnabled="True"
             ItemClick="_listItemClicked"
+            PreviewKeyDown="_keyDownHandler"
             ItemsSource="{x:Bind FilteredActions}">
 
-            <ItemsControl.ItemTemplate >
-                <DataTemplate x:DataType="local:Command">
+                <ItemsControl.ItemTemplate >
+                    <DataTemplate x:DataType="local:Command">
 
-                    <!-- This HorizontalContentAlignment="Stretch" is important
-                    to make sure it takes the entire width of the line -->
-                    <ListViewItem HorizontalContentAlignment="Stretch"
+                        <!-- This HorizontalContentAlignment="Stretch" is important
+                        to make sure it takes the entire width of the line -->
+                        <ListViewItem HorizontalContentAlignment="Stretch"
                                   AutomationProperties.Name="{x:Bind Name, Mode=OneWay}"
                                   AutomationProperties.AcceleratorKey="{x:Bind KeyChordText, Mode=OneWay}">
 
-                        <Grid HorizontalAlignment="Stretch"  >
+                            <Grid HorizontalAlignment="Stretch" ColumnSpacing="8" >
 
-                            <Grid.ColumnDefinitions>
-                                <ColumnDefinition Width="16"/>
-                                <ColumnDefinition Width="Auto"/>
-                                <ColumnDefinition Width="*"/>
-                            </Grid.ColumnDefinitions>
+                                <Grid.ColumnDefinitions>
+                                    <ColumnDefinition Width="16"/>   <!-- icon -->
+                                    <ColumnDefinition Width="Auto"/> <!-- command label -->
+                                    <ColumnDefinition Width="*"/>    <!-- key chord -->
+                                    <ColumnDefinition Width="16"/>   <!-- gutter for scrollbar -->
+                                </Grid.ColumnDefinitions>
 
-                            <!-- TODO GH#6644: Add Icon to command palette entries, in column 0 -->
+                                <IconSourceElement
+                                    Grid.Column="0"
+                                    Width="16"
+                                    Height="16"
+                                    IconSource="{x:Bind IconSource, Mode=OneWay}"/>
 
-                            <TextBlock Grid.Column="1"
+                                <TextBlock Grid.Column="1"
                                        HorizontalAlignment="Left"
                                        Text="{x:Bind Name, Mode=OneWay}" />
 
-                            <!-- The block for the key chord is only visible
-                            when there's actual text set as the label. See
-                            CommandKeyChordVisibilityConverter for details. -->
-                            <Border
-                                Grid.Column="2"
-                                Visibility="{x:Bind KeyChordText,
-                                             Mode=OneWay,
-                                             Converter={StaticResource CommandKeyChordVisibilityConverter}}"
-                                Style="{ThemeResource KeyChordBorderStyle}"
-                                Padding="2,0,2,0"
-                                HorizontalAlignment="Right"
-                                VerticalAlignment="Center">
+                                <!-- The block for the key chord is only visible
+                                when there's actual text set as the label. See
+                                CommandKeyChordVisibilityConverter for details. -->
+                                <Border
+                                    Grid.Column="2"
+                                    Visibility="{x:Bind KeyChordText,
+                                                 Mode=OneWay,
+                                                 Converter={StaticResource CommandKeyChordVisibilityConverter}}"
+                                    Style="{ThemeResource KeyChordBorderStyle}"
+                                    Padding="2,0,2,0"
+                                    HorizontalAlignment="Right"
+                                    VerticalAlignment="Center">
 
-                                <TextBlock
-                                    Style="{ThemeResource KeyChordTextBlockStyle}"
-                                    FontSize="12"
-                                    Text="{x:Bind KeyChordText, Mode=OneWay}" />
-                            </Border>
+                                    <TextBlock
+                                        Style="{ThemeResource KeyChordTextBlockStyle}"
+                                        FontSize="12"
+                                        Text="{x:Bind KeyChordText, Mode=OneWay}" />
+                                </Border>
+
+                                <!-- xE70E is ChevronUp. Rotated 90 degrees, it's _ChevronRight_ -->
+                                <FontIcon
+                                    FontFamily="Segoe MDL2 Assets"
+                                    Glyph="&#xE70E;"
+                                    HorizontalAlignment="Right"
+                                    Visibility="{x:Bind HasNestedCommands,
+                                                 Mode=OneWay,
+                                                 Converter={StaticResource HasNestedCommandsVisibilityConverter}}"
+                                    Grid.Column="2">
+
+                                    <FontIcon.RenderTransform>
+                                        <RotateTransform CenterX="0.5" CenterY="0.5" Angle="90"/>
+                                    </FontIcon.RenderTransform>
+                                </FontIcon>
+
+                            </Grid>
+                        </ListViewItem>
+                    </DataTemplate>
+                </ItemsControl.ItemTemplate>
+            </ListView>
+
+        </Grid>
 
-                        </Grid>
-                    </ListViewItem>
-                </DataTemplate>
-            </ItemsControl.ItemTemplate>
-        </ListView>
 
     </Grid>
-
-
-</Grid>
+</UserControl>

src/cascadia/TerminalApp/DebugTapConnection.cpp

@@ -3,6 +3,7 @@
 
 #include "pch.h"
 #include "DebugTapConnection.h"
+#include "Utils.h"
 
 using namespace ::winrt::Microsoft::Terminal::TerminalConnection;
 using namespace ::winrt::Windows::Foundation;
@@ -91,36 +92,15 @@ namespace winrt::Microsoft::TerminalApp::implementation
         return ConnectionState::Failed;
     }
 
-    static std::wstring _sanitizeString(const std::wstring_view str)
-    {
-        std::wstring newString{ str.begin(), str.end() };
-        for (auto& ch : newString)
-        {
-            if (ch < 0x20)
-            {
-                ch += 0x2400;
-            }
-            else if (ch == 0x20)
-            {
-                ch = 0x2423; // replace space with ␣
-            }
-            else if (ch == 0x7f)
-            {
-                ch = 0x2421; // replace del with ␡
-            }
-        }
-        return newString;
-    }
-
     void DebugTapConnection::_OutputHandler(const hstring str)
     {
-        _TerminalOutputHandlers(_sanitizeString(str));
+        _TerminalOutputHandlers(VisualizeControlCodes(str));
     }
 
     // Called by the DebugInputTapConnection to print user input
     void DebugTapConnection::_PrintInput(const hstring& str)
     {
-        auto clean{ _sanitizeString(str) };
+        auto clean{ VisualizeControlCodes(str) };
         auto formatted{ wil::str_printf<std::wstring>(L"\x1b[91m%ls\x1b[m", clean.data()) };
         _TerminalOutputHandlers(formatted);
     }

src/cascadia/TerminalApp/EmptyStringVisibilityConverter.cpp

@@ -1,6 +1,6 @@
 #include "pch.h"
-#include "CommandKeyChordVisibilityConverter.h"
-#include "CommandKeyChordVisibilityConverter.g.cpp"
+#include "EmptyStringVisibilityConverter.h"
+#include "EmptyStringVisibilityConverter.g.cpp"
 
 using namespace winrt::Windows;
 using namespace winrt::Windows::UI::Xaml;
@@ -9,7 +9,7 @@ namespace winrt::TerminalApp::implementation
 {
     // Method Description:
     // - Attempt to convert something into another type. For the
-    //   CommandKeyChordVisibilityConverter, we're gonna check if `value` is a
+    //   EmptyStringVisibilityConverter, we're gonna check if `value` is a
     //   string, and try and convert it into a Visibility value. If the input
     //   param wasn't a string, or was the empty string, we'll return
     //   Visibility::Collapsed. Otherwise, we'll return Visible.
@@ -18,20 +18,20 @@ namespace winrt::TerminalApp::implementation
     // - value: the input object to attempt to convert into a Visibility.
     // Return Value:
     // - Visible if the object was a string and wasn't the empty string.
-    Foundation::IInspectable CommandKeyChordVisibilityConverter::Convert(Foundation::IInspectable const& value,
-                                                                         Windows::UI::Xaml::Interop::TypeName const& /* targetType */,
-                                                                         Foundation::IInspectable const& /* parameter */,
-                                                                         hstring const& /* language */)
+    Foundation::IInspectable EmptyStringVisibilityConverter::Convert(Foundation::IInspectable const& value,
+                                                                     Windows::UI::Xaml::Interop::TypeName const& /* targetType */,
+                                                                     Foundation::IInspectable const& /* parameter */,
+                                                                     hstring const& /* language */)
     {
         const auto& name = winrt::unbox_value_or<hstring>(value, L"");
         return winrt::box_value(name.empty() ? Visibility::Collapsed : Visibility::Visible);
     }
 
     // unused for one-way bindings
-    Foundation::IInspectable CommandKeyChordVisibilityConverter::ConvertBack(Foundation::IInspectable const& /* value */,
-                                                                             Windows::UI::Xaml::Interop::TypeName const& /* targetType */,
-                                                                             Foundation::IInspectable const& /* parameter */,
-                                                                             hstring const& /* language */)
+    Foundation::IInspectable EmptyStringVisibilityConverter::ConvertBack(Foundation::IInspectable const& /* value */,
+                                                                         Windows::UI::Xaml::Interop::TypeName const& /* targetType */,
+                                                                         Foundation::IInspectable const& /* parameter */,
+                                                                         hstring const& /* language */)
     {
         throw hresult_not_implemented();
     }

src/cascadia/TerminalApp/EmptyStringVisibilityConverter.h

@@ -1,13 +1,13 @@
 #pragma once
 
-#include "CommandKeyChordVisibilityConverter.g.h"
+#include "EmptyStringVisibilityConverter.g.h"
 #include "..\inc\cppwinrt_utils.h"
 
 namespace winrt::TerminalApp::implementation
 {
-    struct CommandKeyChordVisibilityConverter : CommandKeyChordVisibilityConverterT<CommandKeyChordVisibilityConverter>
+    struct EmptyStringVisibilityConverter : EmptyStringVisibilityConverterT<EmptyStringVisibilityConverter>
     {
-        CommandKeyChordVisibilityConverter() = default;
+        EmptyStringVisibilityConverter() = default;
 
         Windows::Foundation::IInspectable Convert(Windows::Foundation::IInspectable const& value,
                                                   Windows::UI::Xaml::Interop::TypeName const& targetType,
@@ -23,5 +23,5 @@ namespace winrt::TerminalApp::implementation
 
 namespace winrt::TerminalApp::factory_implementation
 {
-    BASIC_FACTORY(CommandKeyChordVisibilityConverter);
+    BASIC_FACTORY(EmptyStringVisibilityConverter);
 }

src/cascadia/TerminalApp/EmptyStringVisibilityConverter.idl

@@ -6,14 +6,14 @@ namespace TerminalApp
     // See https://docs.microsoft.com/en-us/windows/uwp/data-binding/data-binding-quickstart
 
     // We use the default attribute to declare IValueConverter as the default
-    // interface. In the listing, CommandKeyChordVisibilityConverter has only a
+    // interface. In the listing, EmptyStringVisibilityConverter has only a
     // constructor, and no methods, so no default interface is generated for it.
     // The default attribute is optimal if you won't be adding instance members
-    // to CommandKeyChordVisibilityConverter, because no QueryInterface will be
+    // to EmptyStringVisibilityConverter, because no QueryInterface will be
     // required to call the IValueConverter methods
-    runtimeclass CommandKeyChordVisibilityConverter : [default] Windows.UI.Xaml.Data.IValueConverter
+    runtimeclass EmptyStringVisibilityConverter : [default] Windows.UI.Xaml.Data.IValueConverter
     {
-        CommandKeyChordVisibilityConverter();
+        EmptyStringVisibilityConverter();
     };
 
 }

src/cascadia/TerminalApp/GlobalAppSettings.cpp

@@ -7,11 +7,10 @@
 #include "../../inc/DefaultSettings.h"
 #include "Utils.h"
 #include "JsonUtils.h"
+#include "TerminalSettingsSerializationHelpers.h"
 
 using namespace TerminalApp;
-using namespace winrt::Microsoft::Terminal::Settings;
 using namespace winrt::TerminalApp;
-using namespace winrt::Windows::Data::Json;
 using namespace winrt::Windows::UI::Xaml;
 using namespace ::Microsoft::Console;
 using namespace winrt::Microsoft::UI::Xaml::Controls;
@@ -37,6 +36,7 @@ static constexpr std::string_view ConfirmCloseAllKey{ "confirmCloseAllTabs" };
 static constexpr std::string_view SnapToGridOnResizeKey{ "snapToGridOnResize" };
 static constexpr std::string_view EnableStartupTaskKey{ "startOnUserLogin" };
 static constexpr std::string_view AlwaysOnTopKey{ "alwaysOnTop" };
+static constexpr std::string_view UseTabSwitcherKey{ "useTabSwitcher" };
 
 static constexpr std::string_view DebugFeaturesKey{ "debugFeatures" };
 
@@ -44,21 +44,6 @@ static constexpr std::string_view ForceFullRepaintRenderingKey{ "experimental.re
 static constexpr std::string_view SoftwareRenderingKey{ "experimental.rendering.software" };
 static constexpr std::string_view ForceVTInputKey{ "experimental.input.forceVT" };
 
-// Launch mode values
-static constexpr std::wstring_view DefaultLaunchModeValue{ L"default" };
-static constexpr std::wstring_view MaximizedLaunchModeValue{ L"maximized" };
-static constexpr std::wstring_view FullscreenLaunchModeValue{ L"fullscreen" };
-
-// Tab Width Mode values
-static constexpr std::wstring_view EqualTabWidthModeValue{ L"equal" };
-static constexpr std::wstring_view TitleLengthTabWidthModeValue{ L"titleLength" };
-static constexpr std::wstring_view TitleLengthCompactModeValue{ L"compact" };
-
-// Theme values
-static constexpr std::wstring_view LightThemeValue{ L"light" };
-static constexpr std::wstring_view DarkThemeValue{ L"dark" };
-static constexpr std::wstring_view SystemThemeValue{ L"system" };
-
 #ifdef _DEBUG
 static constexpr bool debugFeaturesDefault{ true };
 #else
@@ -76,6 +61,7 @@ GlobalAppSettings::GlobalAppSettings() :
     _WordDelimiters{ DEFAULT_WORD_DELIMITERS },
     _DebugFeaturesEnabled{ debugFeaturesDefault }
 {
+    _commands = winrt::single_threaded_map<winrt::hstring, winrt::TerminalApp::Command>();
 }
 
 GlobalAppSettings::~GlobalAppSettings()
@@ -149,66 +135,53 @@ GlobalAppSettings GlobalAppSettings::FromJson(const Json::Value& json)
 
 void GlobalAppSettings::LayerJson(const Json::Value& json)
 {
-    if (auto defaultProfile{ json[JsonKey(DefaultProfileKey)] })
-    {
-        _unparsedDefaultProfile.emplace(GetWstringFromJson(defaultProfile));
-    }
+    JsonUtils::GetValueForKey(json, DefaultProfileKey, _unparsedDefaultProfile);
 
-    JsonUtils::GetBool(json, AlwaysShowTabsKey, _AlwaysShowTabs);
+    JsonUtils::GetValueForKey(json, AlwaysShowTabsKey, _AlwaysShowTabs);
 
-    JsonUtils::GetBool(json, ConfirmCloseAllKey, _ConfirmCloseAllTabs);
+    JsonUtils::GetValueForKey(json, ConfirmCloseAllKey, _ConfirmCloseAllTabs);
 
-    JsonUtils::GetInt(json, InitialRowsKey, _InitialRows);
+    JsonUtils::GetValueForKey(json, InitialRowsKey, _InitialRows);
 
-    JsonUtils::GetInt(json, InitialColsKey, _InitialCols);
+    JsonUtils::GetValueForKey(json, InitialColsKey, _InitialCols);
 
-    if (auto initialPosition{ json[JsonKey(InitialPositionKey)] })
-    {
-        _ParseInitialPosition(initialPosition.asString(), _InitialPosition);
-    }
+    JsonUtils::GetValueForKey(json, InitialPositionKey, _InitialPosition);
 
-    JsonUtils::GetBool(json, ShowTitleInTitlebarKey, _ShowTitleInTitlebar);
+    JsonUtils::GetValueForKey(json, ShowTitleInTitlebarKey, _ShowTitleInTitlebar);
 
-    JsonUtils::GetBool(json, ShowTabsInTitlebarKey, _ShowTabsInTitlebar);
+    JsonUtils::GetValueForKey(json, ShowTabsInTitlebarKey, _ShowTabsInTitlebar);
 
-    JsonUtils::GetWstring(json, WordDelimitersKey, _WordDelimiters);
+    JsonUtils::GetValueForKey(json, WordDelimitersKey, _WordDelimiters);
 
-    JsonUtils::GetBool(json, CopyOnSelectKey, _CopyOnSelect);
+    JsonUtils::GetValueForKey(json, CopyOnSelectKey, _CopyOnSelect);
 
-    JsonUtils::GetBool(json, CopyFormattingKey, _CopyFormatting);
+    JsonUtils::GetValueForKey(json, CopyFormattingKey, _CopyFormatting);
 
-    JsonUtils::GetBool(json, WarnAboutLargePasteKey, _WarnAboutLargePaste);
+    JsonUtils::GetValueForKey(json, WarnAboutLargePasteKey, _WarnAboutLargePaste);
 
-    JsonUtils::GetBool(json, WarnAboutMultiLinePasteKey, _WarnAboutMultiLinePaste);
+    JsonUtils::GetValueForKey(json, WarnAboutMultiLinePasteKey, _WarnAboutMultiLinePaste);
 
-    if (auto launchMode{ json[JsonKey(LaunchModeKey)] })
-    {
-        _LaunchMode = _ParseLaunchMode(GetWstringFromJson(launchMode));
-    }
+    JsonUtils::GetValueForKey(json, LaunchModeKey, _LaunchMode);
 
-    if (auto theme{ json[JsonKey(ThemeKey)] })
-    {
-        _Theme = _ParseTheme(GetWstringFromJson(theme));
-    }
+    JsonUtils::GetValueForKey(json, ThemeKey, _Theme);
 
-    if (auto tabWidthMode{ json[JsonKey(TabWidthModeKey)] })
-    {
-        _TabWidthMode = _ParseTabWidthMode(GetWstringFromJson(tabWidthMode));
-    }
+    JsonUtils::GetValueForKey(json, TabWidthModeKey, _TabWidthMode);
 
-    JsonUtils::GetBool(json, SnapToGridOnResizeKey, _SnapToGridOnResize);
+    JsonUtils::GetValueForKey(json, SnapToGridOnResizeKey, _SnapToGridOnResize);
 
-    JsonUtils::GetBool(json, ForceFullRepaintRenderingKey, _ForceFullRepaintRendering);
+    // GetValueForKey will only override the current value if the key exists
+    JsonUtils::GetValueForKey(json, DebugFeaturesKey, _DebugFeaturesEnabled);
 
-    JsonUtils::GetBool(json, SoftwareRenderingKey, _SoftwareRendering);
-    JsonUtils::GetBool(json, ForceVTInputKey, _ForceVTInput);
+    JsonUtils::GetValueForKey(json, ForceFullRepaintRenderingKey, _ForceFullRepaintRendering);
 
-    // GetBool will only override the current value if the key exists
-    JsonUtils::GetBool(json, DebugFeaturesKey, _DebugFeaturesEnabled);
+    JsonUtils::GetValueForKey(json, SoftwareRenderingKey, _SoftwareRendering);
+    JsonUtils::GetValueForKey(json, ForceVTInputKey, _ForceVTInput);
 
-    JsonUtils::GetBool(json, EnableStartupTaskKey, _StartOnUserLogin);
+    JsonUtils::GetValueForKey(json, EnableStartupTaskKey, _StartOnUserLogin);
 
-    JsonUtils::GetBool(json, AlwaysOnTopKey, _AlwaysOnTop);
+    JsonUtils::GetValueForKey(json, AlwaysOnTopKey, _AlwaysOnTop);
+
+    JsonUtils::GetValueForKey(json, UseTabSwitcherKey, _UseTabSwitcher);
 
     // This is a helper lambda to get the keybindings and commands out of both
     // and array of objects. We'll use this twice, once on the legacy
@@ -229,123 +202,12 @@ void GlobalAppSettings::LayerJson(const Json::Value& json)
             warnings = winrt::TerminalApp::implementation::Command::LayerJson(_commands, bindings);
             // It's possible that the user provided commands have some warnings
             // in them, similar to the keybindings.
-            _keybindingsWarnings.insert(_keybindingsWarnings.end(), warnings.begin(), warnings.end());
         }
     };
     parseBindings(LegacyKeybindingsKey);
     parseBindings(ActionsKey);
 }
 
-// Method Description:
-// - Helper function for converting a user-specified cursor style corresponding
-//   CursorStyle enum value
-// Arguments:
-// - themeString: The string value from the settings file to parse
-// Return Value:
-// - The corresponding enum value which maps to the string provided by the user
-ElementTheme GlobalAppSettings::_ParseTheme(const std::wstring& themeString) noexcept
-{
-    if (themeString == LightThemeValue)
-    {
-        return ElementTheme::Light;
-    }
-    else if (themeString == DarkThemeValue)
-    {
-        return ElementTheme::Dark;
-    }
-    // default behavior for invalid data or SystemThemeValue
-    return ElementTheme::Default;
-}
-
-// Method Description:
-// - Helper function for converting the initial position string into
-//   2 coordinate values. We allow users to only provide one coordinate,
-//   thus, we use comma as the separator:
-//   (100, 100): standard input string
-//   (, 100), (100, ): if a value is missing, we set this value as a default
-//   (,): both x and y are set to default
-//   (abc, 100): if a value is not valid, we treat it as default
-//   (100, 100, 100): we only read the first two values, this is equivalent to (100, 100)
-// Arguments:
-// - initialPosition: the initial position string from json
-//   ret: reference to a struct whose optionals will be populated
-// Return Value:
-// - None
-void GlobalAppSettings::_ParseInitialPosition(const std::string& initialPosition,
-                                              LaunchPosition& ret) noexcept
-{
-    static constexpr char singleCharDelim = ',';
-    std::stringstream tokenStream(initialPosition);
-    std::string token;
-    uint8_t initialPosIndex = 0;
-
-    // Get initial position values till we run out of delimiter separated values in the stream
-    // or we hit max number of allowable values (= 2)
-    // Non-numeral values or empty string will be caught as exception and we do not assign them
-    for (; std::getline(tokenStream, token, singleCharDelim) && (initialPosIndex < 2); initialPosIndex++)
-    {
-        try
-        {
-            int32_t position = std::stoi(token);
-            if (initialPosIndex == 0)
-            {
-                ret.x.emplace(position);
-            }
-
-            if (initialPosIndex == 1)
-            {
-                ret.y.emplace(position);
-            }
-        }
-        catch (...)
-        {
-            // Do nothing
-        }
-    }
-}
-
-// Method Description:
-// - Helper function for converting the user-specified launch mode
-//   to a LaunchMode enum value
-// Arguments:
-// - launchModeString: The string value from the settings file to parse
-// Return Value:
-// - The corresponding enum value which maps to the string provided by the user
-LaunchMode GlobalAppSettings::_ParseLaunchMode(const std::wstring& launchModeString) noexcept
-{
-    if (launchModeString == MaximizedLaunchModeValue)
-    {
-        return LaunchMode::MaximizedMode;
-    }
-    else if (launchModeString == FullscreenLaunchModeValue)
-    {
-        return LaunchMode::FullscreenMode;
-    }
-
-    return LaunchMode::DefaultMode;
-}
-
-// Method Description:
-// - Helper function for converting the user-specified tab width
-//   to a TabViewWidthMode enum value
-// Arguments:
-// - tabWidthModeString: The string value from the settings file to parse
-// Return Value:
-// - The corresponding enum value which maps to the string provided by the user
-TabViewWidthMode GlobalAppSettings::_ParseTabWidthMode(const std::wstring& tabWidthModeString) noexcept
-{
-    if (tabWidthModeString == TitleLengthTabWidthModeValue)
-    {
-        return TabViewWidthMode::SizeToContent;
-    }
-    else if (tabWidthModeString == TitleLengthCompactModeValue)
-    {
-        return TabViewWidthMode::Compact;
-    }
-    // default behavior for invalid data or EqualTabWidthValue
-    return TabViewWidthMode::Equal;
-}
-
 // Method Description:
 // - Adds the given colorscheme to our map of schemes, using its name as the key.
 // Arguments:
@@ -354,7 +216,7 @@ TabViewWidthMode GlobalAppSettings::_ParseTabWidthMode(const std::wstring& tabWi
 // - <none>
 void GlobalAppSettings::AddColorScheme(ColorScheme scheme)
 {
-    std::wstring name{ scheme.GetName() };
+    std::wstring name{ scheme.Name() };
     _colorSchemes[name] = std::move(scheme);
 }
 
@@ -372,7 +234,12 @@ std::vector<TerminalApp::SettingsLoadWarnings> GlobalAppSettings::GetKeybindings
     return _keybindingsWarnings;
 }
 
-const std::unordered_map<winrt::hstring, winrt::TerminalApp::Command>& GlobalAppSettings::GetCommands() const noexcept
+const winrt::Windows::Foundation::Collections::IMap<winrt::hstring, winrt::TerminalApp::Command>& GlobalAppSettings::GetCommands() const noexcept
+{
+    return _commands;
+}
+
+winrt::Windows::Foundation::Collections::IMap<winrt::hstring, winrt::TerminalApp::Command>& GlobalAppSettings::GetCommands() noexcept
 {
     return _commands;
 }

src/cascadia/TerminalApp/GlobalAppSettings.h

@@ -15,8 +15,10 @@ Author(s):
 --*/
 #pragma once
 #include "AppKeyBindings.h"
-#include "ColorScheme.h"
 #include "Command.h"
+#include "SettingsTypes.h"
+
+#include "ColorScheme.g.h"
 
 // fwdecl unittest classes
 namespace TerminalAppLocalTests
@@ -28,12 +30,6 @@ namespace TerminalAppLocalTests
 namespace TerminalApp
 {
     class GlobalAppSettings;
-
-    struct LaunchPosition
-    {
-        std::optional<int> x;
-        std::optional<int> y;
-    };
 };
 
 class TerminalApp::GlobalAppSettings final
@@ -42,20 +38,21 @@ public:
     GlobalAppSettings();
     ~GlobalAppSettings();
 
-    std::unordered_map<std::wstring, ColorScheme>& GetColorSchemes() noexcept;
-    const std::unordered_map<std::wstring, ColorScheme>& GetColorSchemes() const noexcept;
-    void AddColorScheme(ColorScheme scheme);
+    std::unordered_map<std::wstring, winrt::TerminalApp::ColorScheme>& GetColorSchemes() noexcept;
+    const std::unordered_map<std::wstring, winrt::TerminalApp::ColorScheme>& GetColorSchemes() const noexcept;
+    void AddColorScheme(winrt::TerminalApp::ColorScheme scheme);
 
     winrt::TerminalApp::AppKeyBindings GetKeybindings() const noexcept;
 
     static GlobalAppSettings FromJson(const Json::Value& json);
     void LayerJson(const Json::Value& json);
 
-    void ApplyToSettings(winrt::Microsoft::Terminal::Settings::TerminalSettings& settings) const noexcept;
+    void ApplyToSettings(winrt::TerminalApp::TerminalSettings& settings) const noexcept;
 
     std::vector<TerminalApp::SettingsLoadWarnings> GetKeybindingsWarnings() const;
 
-    const std::unordered_map<winrt::hstring, winrt::TerminalApp::Command>& GetCommands() const noexcept;
+    const winrt::Windows::Foundation::Collections::IMap<winrt::hstring, winrt::TerminalApp::Command>& GetCommands() const noexcept;
+    winrt::Windows::Foundation::Collections::IMap<winrt::hstring, winrt::TerminalApp::Command>& GetCommands() noexcept;
 
     // These are implemented manually to handle the string/GUID exchange
     // by higher layers in the app.
@@ -73,7 +70,7 @@ public:
     GETSET_PROPERTY(bool, ShowTabsInTitlebar, true);
     GETSET_PROPERTY(std::wstring, WordDelimiters); // default value set in constructor
     GETSET_PROPERTY(bool, CopyOnSelect, false);
-    GETSET_PROPERTY(bool, CopyFormatting, false);
+    GETSET_PROPERTY(winrt::Microsoft::Terminal::TerminalControl::CopyFormat, CopyFormatting, 0);
     GETSET_PROPERTY(bool, WarnAboutLargePaste, true);
     GETSET_PROPERTY(bool, WarnAboutMultiLinePaste, true);
     GETSET_PROPERTY(LaunchPosition, InitialPosition);
@@ -85,6 +82,7 @@ public:
     GETSET_PROPERTY(bool, DebugFeaturesEnabled); // default value set in constructor
     GETSET_PROPERTY(bool, StartOnUserLogin, false);
     GETSET_PROPERTY(bool, AlwaysOnTop, false);
+    GETSET_PROPERTY(bool, UseTabSwitcher, true);
 
 private:
     std::optional<std::wstring> _unparsedDefaultProfile;
@@ -93,17 +91,8 @@ private:
     winrt::com_ptr<winrt::TerminalApp::implementation::AppKeyBindings> _keybindings;
     std::vector<::TerminalApp::SettingsLoadWarnings> _keybindingsWarnings;
 
-    std::unordered_map<std::wstring, ColorScheme> _colorSchemes;
-    std::unordered_map<winrt::hstring, winrt::TerminalApp::Command> _commands;
-
-    static winrt::Windows::UI::Xaml::ElementTheme _ParseTheme(const std::wstring& themeString) noexcept;
-
-    static winrt::Microsoft::UI::Xaml::Controls::TabViewWidthMode _ParseTabWidthMode(const std::wstring& tabWidthModeString) noexcept;
-
-    static void _ParseInitialPosition(const std::string& initialPosition,
-                                      LaunchPosition& ret) noexcept;
-
-    static winrt::TerminalApp::LaunchMode _ParseLaunchMode(const std::wstring& launchModeString) noexcept;
+    std::unordered_map<std::wstring, winrt::TerminalApp::ColorScheme> _colorSchemes;
+    winrt::Windows::Foundation::Collections::IMap<winrt::hstring, winrt::TerminalApp::Command> _commands;
 
     friend class TerminalAppLocalTests::SettingsTests;
     friend class TerminalAppLocalTests::ColorSchemeTests;