update output path for kbm

<!-- Enter a brief description/summary of your PR here. What does it
fix/what does it change/how was it tested (even manually, if necessary)?
-->
## Summary of the Pull Request

> [Target feature branch ``feature/KeyboardManagerWinUI3``]

Refactor the New Keyboard Manager code to generalize functions (like
Keyboard Hook) for use across pages. Implement Code-behind and the Text
Remapping Page.

- Implement the Text Remapping page
- Restructure the Key Remappings code
- Implement unified Keyboard Hook for all Pages
- Implement Save and Delete for Text Page
- Adjust the Text Page list UI
- Create Input Control for Text Page
- Validate the user input in Text Page and show teaching tip for the
validation error
- Move Remapping Saving into Helper
- Move Remapping Delete into Helper
- Don't check for duplicates if the original keys are the same as the
remapping being edited
- Use InputMode to indicate the active toggle for Original Keys/Remapped
Keys
- Add Rectangle for all pages


![image](https://github.com/user-attachments/assets/e109d82f-01c5-4da7-9efb-facea4070808)

![image](https://github.com/user-attachments/assets/09cc4462-43eb-4823-9b01-ab630a0bf9ed)

![image](https://github.com/user-attachments/assets/9b85c0f6-cbce-40cc-8e65-b755cb852eae)

![image](https://github.com/user-attachments/assets/ff7945cc-6535-4697-812e-93c2effab14e)

![image](https://github.com/user-attachments/assets/7cf887c8-24f3-45bd-956f-b3d655844974)

![image](https://github.com/user-attachments/assets/d958bb16-66b9-44e0-8918-32ddcc780f02)

.github/actions/spell-check/expect.txt

@@ -198,6 +198,7 @@ CLIPBOARDUPDATE
 CLIPCHILDREN
 CLIPSIBLINGS
 closesocket
+clp
 CLSCTX
 clsids
 Clusion
@@ -1045,6 +1046,7 @@ NOINHERITLAYOUT
 NOINTERFACE
 NOINVERT
 NOLINKINFO
+nologo
 NOMCX
 NOMINMAX
 NOMIRRORBITMAP
@@ -1277,6 +1279,7 @@ pstm
 PStr
 pstream
 pstrm
+pswd
 PSYSTEM
 psz
 ptb
@@ -1423,6 +1426,7 @@ searchterm
 SEARCHUI
 SECONDARYDISPLAY
 secpol
+securestring
 SEEMASKINVOKEIDLIST
 SELCHANGE
 SENDCHANGE
@@ -1978,4 +1982,12 @@ zoomit
 ZOOMITX
 ZXk
 ZXNs
-zzz
+zzz
+ACIE
+AOklab
+BCIE
+BOklab
+culori
+Evercoder
+LCh
+CIELCh

.pipelines/ESRPSigning_core.json

@@ -127,6 +127,7 @@
 
                 "PowerToys.KeyboardManager.dll",
                 "KeyboardManagerEditor\\PowerToys.KeyboardManagerEditor.exe",
+                "KeyboardManagerEditorUI\\PowerToys.KeyboardManagerEditorUI.exe",
                 "KeyboardManagerEngine\\PowerToys.KeyboardManagerEngine.exe",
                 "PowerToys.KeyboardManagerEditorLibraryWrapper.dll",
 

.pipelines/tsa.json

@@ -3,5 +3,5 @@
     "notificationAliases": ["powertoys@microsoft.com"],
     "instanceUrl": "https://microsoft.visualstudio.com",
     "projectName": "OS",
-    "areaPath": "OS\\Windows Client and Services\\WinPD\\DEEP-Developer Experience, Ecosystem and Partnerships\\SHINE\\PowerToys"
+    "areaPath": "OS\\Windows Client and Services\\WinPD\\DEEP-Developer Experience, Ecosystem and Partnerships\\DIVE\\PowerToys"
 }

installer/PowerToysSetup/Product.wxs

@@ -79,10 +79,7 @@
       <ComponentGroupRef Id="ToolComponentGroup" />
       <ComponentGroupRef Id="MonacoSRCHeatGenerated" />
       <ComponentGroupRef Id="WorkspacesComponentGroup" />
-
-      <?if $(var.CIBuild) = "true" ?>
-        <ComponentGroupRef Id="CmdPalComponentGroup" />
-      <?endif?>
+      <ComponentGroupRef Id="CmdPalComponentGroup" />
     </Feature>
 
     <SetProperty Id="ARPINSTALLLOCATION" Value="[INSTALLFOLDER]" After="CostFinalize" />

src/common/ManagedCommon/ColorFormatHelper.cs

@@ -141,6 +141,40 @@ namespace ManagedCommon
             return lab;
         }
 
+        /// <summary>
+        /// Convert a given <see cref="Color"/> to a Oklab color
+        /// </summary>
+        /// <param name="color">The <see cref="Color"/> to convert</param>
+        /// <returns>The perceptual lightness [0..1] and two chromaticities [-0.5..0.5]</returns>
+        public static (double Lightness, double ChromaticityA, double ChromaticityB) ConvertToOklabColor(Color color)
+        {
+            var linear = ConvertSRGBToLinearRGB(color.R / 255d, color.G / 255d, color.B / 255d);
+            var oklab = GetOklabColorFromLinearRGB(linear.R, linear.G, linear.B);
+            return oklab;
+        }
+
+        /// <summary>
+        /// Convert a given <see cref="Color"/> to a Oklch color
+        /// </summary>
+        /// <param name="color">The <see cref="Color"/> to convert</param>
+        /// <returns>The perceptual lightness [0..1], the chroma [0..0.5], and the hue angle [0°..360°]</returns>
+        public static (double Lightness, double Chroma, double Hue) ConvertToOklchColor(Color color)
+        {
+            var oklab = ConvertToOklabColor(color);
+            var oklch = GetOklchColorFromOklab(oklab.Lightness, oklab.ChromaticityA, oklab.ChromaticityB);
+
+            return oklch;
+        }
+
+        public static (double R, double G, double B) ConvertSRGBToLinearRGB(double r, double g, double b)
+        {
+            // inverse companding, gamma correction must be undone
+            double rLinear = (r > 0.04045) ? Math.Pow((r + 0.055) / 1.055, 2.4) : (r / 12.92);
+            double gLinear = (g > 0.04045) ? Math.Pow((g + 0.055) / 1.055, 2.4) : (g / 12.92);
+            double bLinear = (b > 0.04045) ? Math.Pow((b + 0.055) / 1.055, 2.4) : (b / 12.92);
+            return (rLinear, gLinear, bLinear);
+        }
+
         /// <summary>
         /// Convert a given <see cref="Color"/> to a CIE XYZ color (XYZ)
         /// The constants of the formula matches this Wikipedia page, but at a higher precision:
@@ -156,10 +190,7 @@ namespace ManagedCommon
             double g = color.G / 255d;
             double b = color.B / 255d;
 
-            // inverse companding, gamma correction must be undone
-            double rLinear = (r > 0.04045) ? Math.Pow((r + 0.055) / 1.055, 2.4) : (r / 12.92);
-            double gLinear = (g > 0.04045) ? Math.Pow((g + 0.055) / 1.055, 2.4) : (g / 12.92);
-            double bLinear = (b > 0.04045) ? Math.Pow((b + 0.055) / 1.055, 2.4) : (b / 12.92);
+            (double rLinear, double gLinear, double bLinear) = ConvertSRGBToLinearRGB(r, g, b);
 
             return (
                 (rLinear * 0.41239079926595948) + (gLinear * 0.35758433938387796) + (bLinear * 0.18048078840183429),
@@ -210,6 +241,63 @@ namespace ManagedCommon
             return (l, a, b);
         }
 
+        /// <summary>
+        /// Convert a linear RGB color <see cref="double"/> to an Oklab color.
+        /// The constants of this formula come from https://github.com/Evercoder/culori/blob/2bedb8f0507116e75f844a705d0b45cf279b15d0/src/oklab/convertLrgbToOklab.js
+        /// and the implementation is based on https://bottosson.github.io/posts/oklab/
+        /// </summary>
+        /// <param name="r">Linear R value</param>
+        /// <param name="g">Linear G value</param>
+        /// <param name="b">Linear B value</param>
+        /// <returns>The perceptual lightness [0..1] and two chromaticities [-0.5..0.5]</returns>
+        private static (double Lightness, double ChromaticityA, double ChromaticityB)
+            GetOklabColorFromLinearRGB(double r, double g, double b)
+        {
+            double l = (0.41222147079999993 * r) + (0.5363325363 * g) + (0.0514459929 * b);
+            double m = (0.2119034981999999 * r) + (0.6806995450999999 * g) + (0.1073969566 * b);
+            double s = (0.08830246189999998 * r) + (0.2817188376 * g) + (0.6299787005000002 * b);
+
+            double l_ = Math.Cbrt(l);
+            double m_ = Math.Cbrt(m);
+            double s_ = Math.Cbrt(s);
+
+            return (
+                (0.2104542553 * l_) + (0.793617785 * m_) - (0.0040720468 * s_),
+                (1.9779984951 * l_) - (2.428592205 * m_) + (0.4505937099 * s_),
+                (0.0259040371 * l_) + (0.7827717662 * m_) - (0.808675766 * s_)
+            );
+        }
+
+        /// <summary>
+        /// Convert an Oklab color <see cref="double"/> from Cartesian form to its polar form Oklch
+        /// https://bottosson.github.io/posts/oklab/#the-oklab-color-space
+        /// </summary>
+        /// <param name="lightness">The <see cref="lightness"/></param>
+        /// <param name="chromaticity_a">The <see cref="chromaticity_a"/></param>
+        /// <param name="chromaticity_b">The <see cref="chromaticity_b"/></param>
+        /// <returns>The perceptual lightness [0..1], the chroma [0..0.5], and the hue angle [0°..360°]</returns>
+        private static (double Lightness, double Chroma, double Hue)
+            GetOklchColorFromOklab(double lightness, double chromaticity_a, double chromaticity_b)
+        {
+            return GetLCHColorFromLAB(lightness, chromaticity_a, chromaticity_b);
+        }
+
+        /// <summary>
+        /// Convert a color in Cartesian form (Lab) to its polar form (LCh)
+        /// </summary>
+        /// <param name="lightness">The <see cref="lightness"/></param>
+        /// <param name="chromaticity_a">The <see cref="chromaticity_a"/></param>
+        /// <param name="chromaticity_b">The <see cref="chromaticity_b"/></param>
+        /// <returns>The lightness, chroma, and hue angle</returns>
+        private static (double Lightness, double Chroma, double Hue)
+            GetLCHColorFromLAB(double lightness, double chromaticity_a, double chromaticity_b)
+        {
+            // Lab to LCh transformation
+            double chroma = Math.Sqrt(Math.Pow(chromaticity_a, 2) + Math.Pow(chromaticity_b, 2));
+            double hue = Math.Round(chroma, 3) == 0 ? 0.0 : ((Math.Atan2(chromaticity_b, chromaticity_a) * 180d / Math.PI) + 360d) % 360d;
+            return (lightness, chroma, hue);
+        }
+
         /// <summary>
         /// Convert a given <see cref="Color"/> to a natural color (hue, whiteness, blackness)
         /// </summary>
@@ -276,12 +364,17 @@ namespace ManagedCommon
             { "Br", 'p' },   // brightness       percent
             { "In", 'p' },   // intensity        percent
             { "Ll", 'p' },   // lightness (HSL)  percent
-            { "Lc", 'p' },   // lightness(CIELAB)percent
             { "Va", 'p' },   // value            percent
             { "Wh", 'p' },   // whiteness        percent
             { "Bn", 'p' },   // blackness        percent
-            { "Ca", 'p' },   // chromaticityA    percent
-            { "Cb", 'p' },   // chromaticityB    percent
+            { "Lc", 'p' },   // lightness (CIE)         percent
+            { "Ca", 'p' },   // chromaticityA (CIELAB)  percent
+            { "Cb", 'p' },   // chromaticityB (CIELAB)  percent
+            { "Lo", 'p' },   // lightness (Oklab/Oklch) percent
+            { "Oa", 'p' },   // chromaticityA (Oklab)   percent
+            { "Ob", 'p' },   // chromaticityB (Oklab)   percent
+            { "Oc", 'p' },   // chroma (Oklch)          percent
+            { "Oh", 'p' },   // hue angle (Oklch)       percent
             { "Xv", 'i' },   // X value          int
             { "Yv", 'i' },   // Y value          int
             { "Zv", 'i' },   // Z value          int
@@ -424,6 +517,10 @@ namespace ManagedCommon
                     var (lightnessC, _, _) = ConvertToCIELABColor(color);
                     lightnessC = Math.Round(lightnessC, 2);
                     return lightnessC.ToString(CultureInfo.InvariantCulture);
+                case "Lo":
+                    var (lightnessO, _, _) = ConvertToOklabColor(color);
+                    lightnessO = Math.Round(lightnessO, 2);
+                    return lightnessO.ToString(CultureInfo.InvariantCulture);
                 case "Wh":
                     var (_, whiteness, _) = ConvertToHWBColor(color);
                     whiteness = Math.Round(whiteness * 100);
@@ -440,6 +537,22 @@ namespace ManagedCommon
                     var (_, _, chromaticityB) = ConvertToCIELABColor(color);
                     chromaticityB = Math.Round(chromaticityB, 2);
                     return chromaticityB.ToString(CultureInfo.InvariantCulture);
+                case "Oa":
+                    var (_, chromaticityAOklab, _) = ConvertToOklabColor(color);
+                    chromaticityAOklab = Math.Round(chromaticityAOklab, 2);
+                    return chromaticityAOklab.ToString(CultureInfo.InvariantCulture);
+                case "Ob":
+                    var (_, _, chromaticityBOklab) = ConvertToOklabColor(color);
+                    chromaticityBOklab = Math.Round(chromaticityBOklab, 2);
+                    return chromaticityBOklab.ToString(CultureInfo.InvariantCulture);
+                case "Oc":
+                    var (_, chromaOklch, _) = ConvertToOklchColor(color);
+                    chromaOklch = Math.Round(chromaOklch, 2);
+                    return chromaOklch.ToString(CultureInfo.InvariantCulture);
+                case "Oh":
+                    var (_, _, hueOklch) = ConvertToOklchColor(color);
+                    hueOklch = Math.Round(hueOklch, 2);
+                    return hueOklch.ToString(CultureInfo.InvariantCulture);
                 case "Xv":
                     var (x, _, _) = ConvertToCIEXYZColor(color);
                     x = Math.Round(x * 100, 4);
@@ -495,8 +608,10 @@ namespace ManagedCommon
                 case "HSI": return "hsi(%Hu, %Si%, %In%)";
                 case "HWB": return "hwb(%Hu, %Wh%, %Bn%)";
                 case "NCol": return "%Hn, %Wh%, %Bn%";
-                case "CIELAB": return "CIELab(%Lc, %Ca, %Cb)";
                 case "CIEXYZ": return "XYZ(%Xv, %Yv, %Zv)";
+                case "CIELAB": return "CIELab(%Lc, %Ca, %Cb)";
+                case "Oklab": return "oklab(%Lo, %Oa, %Ob)";
+                case "Oklch": return "oklch(%Lo, %Oc, %Oh)";
                 case "VEC4": return "(%Reff, %Grff, %Blff, 1f)";
                 case "Decimal": return "%Dv";
                 case "HEX Int": return "0xFF%ReX%GrX%BlX";

src/common/utils/package.h

@@ -301,6 +301,7 @@ namespace package
         if (!std::filesystem::exists(directoryPath))
         {
             Logger::error(L"The directory '" + directoryPath + L"' does not exist.");
+            return {};
         }
 
         const std::regex pattern(R"(^.+\.(appx|msix|msixbundle)$)", std::regex_constants::icase);

src/modules/AdvancedPaste/AdvancedPaste/Helpers/OcrHelpers.cs

@@ -18,10 +18,19 @@ public static class OcrHelpers
 {
     public static async Task<string> ExtractTextAsync(SoftwareBitmap bitmap, CancellationToken cancellationToken)
     {
-        var ocrLanguage = GetOCRLanguage() ?? throw new InvalidOperationException("Unable to determine OCR language");
+        var ocrLanguage = GetOCRLanguage();
         cancellationToken.ThrowIfCancellationRequested();
 
-        var ocrEngine = OcrEngine.TryCreateFromLanguage(ocrLanguage) ?? throw new InvalidOperationException("Unable to create OCR engine");
+        OcrEngine ocrEngine;
+        if (ocrLanguage is not null)
+        {
+            ocrEngine = OcrEngine.TryCreateFromLanguage(ocrLanguage) ?? throw new InvalidOperationException("Unable to create OCR engine from specified language");
+        }
+        else
+        {
+            ocrEngine = OcrEngine.TryCreateFromUserProfileLanguages() ?? throw new InvalidOperationException("Unable to create OCR engine from user profile language");
+        }
+
         cancellationToken.ThrowIfCancellationRequested();
 
         var ocrResult = await ocrEngine.RecognizeAsync(bitmap);

src/modules/cmdpal/CmdPalModuleInterface/CmdPalModuleInterface.vcxproj

@@ -2,6 +2,7 @@
 <Project DefaultTargets="Build"
   xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
   <Import Project="..\..\..\..\packages\Microsoft.Windows.CppWinRT.2.0.240111.5\build\native\Microsoft.Windows.CppWinRT.props" Condition="Exists('..\..\..\..\packages\Microsoft.Windows.CppWinRT.2.0.240111.5\build\native\Microsoft.Windows.CppWinRT.props')" />
+  <Import Project="..\Microsoft.CmdPal.UI\CmdPal.pre.props" Condition="Exists('..\Microsoft.CmdPal.UI\CmdPal.pre.props')" />
   <PropertyGroup Label="Globals">
     <VCProjectVersion>17.0</VCProjectVersion>
     <Keyword>Win32Proj</Keyword>
@@ -49,13 +50,20 @@
   </ItemGroup>
   <ItemDefinitionGroup>
     <ClCompile>
-      <PreprocessorDefinitions>EXAMPLEPOWERTOY_EXPORTS;_WINDOWS;_USRDLL;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <PreprocessorDefinitions>
+        EXAMPLEPOWERTOY_EXPORTS;_WINDOWS;_USRDLL;
+        %(PreprocessorDefinitions);
+      </PreprocessorDefinitions>
+      <PreprocessorDefinitions Condition="'$(CommandPaletteBranding)'=='' or '$(CommandPaletteBranding)'=='Dev'">
+        IS_DEV_BRANDING;%(PreprocessorDefinitions)
+      </PreprocessorDefinitions>
       <AdditionalIncludeDirectories>..\..\..\common\inc;..\..\..\common\Telemetry;..\..\;..\..\..\;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
     </ClCompile>
     <Link>
       <OutputFile>$(OutDir)$(TargetName)$(TargetExt)</OutputFile>
     </Link>
   </ItemDefinitionGroup>
+
   <ItemGroup>
     <ClInclude Include="pch.h" />
     <ClInclude Include="resource.h" />

src/modules/cmdpal/CmdPalModuleInterface/dllmain.cpp

@@ -3,6 +3,7 @@
 
 #include <interface/powertoy_module_interface.h>
 
+#include <atomic>
 #include <common/logger/logger.h>
 #include <common/utils/logger_helper.h>
 #include <common/SettingsAPI/settings_helpers.h>
@@ -10,10 +11,11 @@
 #include <common/utils/resources.h>
 #include <common/utils/package.h>
 #include <common/utils/process_path.h>
+#include <common/utils/winapi_error.h>
 #include <common/interop/shared_constants.h>
 #include <Psapi.h>
 #include <TlHelp32.h>
-#include <common/utils/winapi_error.h>
+#include <thread>
 
 HINSTANCE g_hInst_cmdPal = 0;
 
@@ -37,8 +39,6 @@ BOOL APIENTRY DllMain(HMODULE hInstance,
 class CmdPal : public PowertoyModuleIface
 {
 private:
-    bool m_enabled = false;
-
     std::wstring app_name;
 
     //contains the non localized key of the powertoy
@@ -46,7 +46,10 @@ private:
 
     HANDLE m_hTerminateEvent;
 
-    void LaunchApp(const std::wstring& appPath, const std::wstring& commandLineArgs, bool elevated)
+    // Track if this is the first call to enable
+    bool firstEnableCall = true;
+
+    static bool LaunchApp(const std::wstring& appPath, const std::wstring& commandLineArgs, bool elevated, bool silentFail)
     {
         std::wstring dir = std::filesystem::path(appPath).parent_path();
 
@@ -54,6 +57,10 @@ private:
         sei.cbSize = sizeof(SHELLEXECUTEINFO);
         sei.hwnd = nullptr;
         sei.fMask = SEE_MASK_NOCLOSEPROCESS | SEE_MASK_NO_CONSOLE;
+        if (silentFail)
+        {
+            sei.fMask = sei.fMask | SEE_MASK_FLAG_NO_UI;
+        }
         sei.lpVerb = elevated ? L"runas" : L"open";
         sei.lpFile = appPath.c_str();
         sei.lpParameters = commandLineArgs.c_str();
@@ -64,7 +71,11 @@ private:
         {
             std::wstring error = get_last_error_or_default(GetLastError());
             Logger::error(L"Failed to launch process. {}", error);
+            return false;
         }
+
+        m_launched.store(true);
+        return true;
     }
 
     std::vector<DWORD> GetProcessesIdByName(const std::wstring& processName)
@@ -122,6 +133,9 @@ private:
     }
 
 public:
+    static std::atomic<bool> m_enabled;
+    static std::atomic<bool> m_launched;
+
     CmdPal()
     {
         app_name = L"CmdPal";
@@ -133,10 +147,7 @@ public:
 
     ~CmdPal()
     {
-        if (m_enabled)
-        {
-        }
-        m_enabled = false;
+        CmdPal::m_enabled.store(false);
     }
 
     // Destroy the powertoy and free memory
@@ -203,15 +214,18 @@ public:
     {
         Logger::trace("CmdPal::enable()");
 
-        m_enabled = true;
+        CmdPal::m_enabled.store(true);
 
-        try
-        {
-            std::wstring packageName = L"Microsoft.CommandPalette";
-#ifdef _DEBUG
-            packageName = L"Microsoft.CommandPalette.Dev";
+        std::wstring packageName = L"Microsoft.CommandPalette";
+        std::wstring launchPath = L"shell:AppsFolder\\Microsoft.CommandPalette_8wekyb3d8bbwe!App";
+#ifdef IS_DEV_BRANDING
+        packageName = L"Microsoft.CommandPalette.Dev";
+        launchPath = L"shell:AppsFolder\\Microsoft.CommandPalette.Dev_8wekyb3d8bbwe!App";
 #endif
-            if (!package::GetRegisteredPackage(packageName, false).has_value())
+
+        if (!package::GetRegisteredPackage(packageName, false).has_value())
+        {
+            try
             {
                 Logger::info(L"CmdPal not installed. Installing...");
 
@@ -238,19 +252,34 @@ public:
                     }
                 }
             }
-        }
-        catch (std::exception& e)
-        {
-            std::string errorMessage{ "Exception thrown while trying to install CmdPal package: " };
-            errorMessage += e.what();
-            Logger::error(errorMessage);
+            catch (std::exception& e)
+            {
+                std::string errorMessage{ "Exception thrown while trying to install CmdPal package: " };
+                errorMessage += e.what();
+                Logger::error(errorMessage);
+            }
         }
 
-#if _DEBUG
-        LaunchApp(std::wstring{ L"shell:AppsFolder\\" } + L"Microsoft.CommandPalette.Dev_8wekyb3d8bbwe!App", L"RunFromPT", false);
-#else
-        LaunchApp(std::wstring{ L"shell:AppsFolder\\" } + L"Microsoft.CommandPalette_8wekyb3d8bbwe!App", L"RunFromPT", false);
-#endif
+        if (!package::GetRegisteredPackage(packageName, false).has_value())
+        {
+            Logger::error("Cmdpal is not registered, quit..");
+            return;
+        }
+
+        if (!firstEnableCall)
+        {
+            Logger::trace("Not first attempt, try to launch");
+            LaunchApp(launchPath, L"RunFromPT", false /*no elevated*/, false /*error pop up*/);
+        }
+        else
+        {
+            // If first time enable, do retry launch.
+            Logger::trace("First attempt, try to launch");
+            std::thread launchThread(&CmdPal::RetryLaunch, launchPath);
+            launchThread.detach();
+        }
+
+        firstEnableCall = false;
     }
 
     virtual void disable()
@@ -258,7 +287,44 @@ public:
         Logger::trace("CmdPal::disable()");
         TerminateCmdPal();
 
-        m_enabled = false;
+        CmdPal::m_enabled.store(false);
+    }
+
+    static void RetryLaunch(std::wstring path)
+    {
+        const int base_delay_milliseconds = 1000;
+        int max_retry = 9; // 2**9 - 1 seconds. Control total wait time within 10 min.
+        int retry = 0;
+        do
+        {
+            auto launch_result = LaunchApp(path, L"RunFromPT", false, retry < max_retry);
+            if (launch_result)
+            {
+                Logger::info(L"CmdPal launched successfully after {} retries.", retry);
+                return;
+            }
+            else
+            {
+                Logger::error(L"Retry {} launch CmdPal launch failed.", retry);
+            }
+
+            // When we got max retry, we don't need to wait for the next retry.
+            if (retry < max_retry)
+            {
+                int delay = base_delay_milliseconds * (1 << (retry));
+                std::this_thread::sleep_for(std::chrono::milliseconds(delay));
+            }
+            ++retry;
+        } while (retry <= max_retry && m_enabled.load() && !m_launched.load());
+
+        if (!m_enabled.load() || m_launched.load())
+        {
+            Logger::error(L"Retry cancelled. CmdPal is disabled or already launched.");
+        }
+        else
+        {
+            Logger::error(L"CmdPal launch failed after {} attempts.", retry);
+        }
     }
 
     virtual bool on_hotkey(size_t) override
@@ -273,11 +339,14 @@ public:
 
     virtual bool is_enabled() override
     {
-        return m_enabled;
+        return CmdPal::m_enabled.load();
     }
 };
 
+std::atomic<bool> CmdPal::m_enabled{ false };
+std::atomic<bool> CmdPal::m_launched{ false };
+
 extern "C" __declspec(dllexport) PowertoyModuleIface* __cdecl powertoy_create()
 {
     return new CmdPal();
-}
+}

src/modules/cmdpal/Microsoft.CmdPal.Common/Contracts/IFileService.cs

@@ -1,14 +0,0 @@
-// Copyright (c) Microsoft Corporation
-// The Microsoft Corporation licenses this file to you under the MIT license.
-// See the LICENSE file in the project root for more information.
-
-namespace Microsoft.CmdPal.Common.Contracts;
-
-public interface IFileService
-{
-    T Read<T>(string folderPath, string fileName);
-
-    void Save<T>(string folderPath, string fileName, T content);
-
-    void Delete(string folderPath, string fileName);
-}

src/modules/cmdpal/Microsoft.CmdPal.Common/Contracts/ILocalSettingsService.cs

@@ -1,16 +0,0 @@
-// Copyright (c) Microsoft Corporation
-// The Microsoft Corporation licenses this file to you under the MIT license.
-// See the LICENSE file in the project root for more information.
-
-using System.Threading.Tasks;
-
-namespace Microsoft.CmdPal.Common.Contracts;
-
-public interface ILocalSettingsService
-{
-    Task<bool> HasSettingAsync(string key);
-
-    Task<T?> ReadSettingAsync<T>(string key);
-
-    Task SaveSettingAsync<T>(string key, T value);
-}

src/modules/cmdpal/Microsoft.CmdPal.Common/Extensions/ApplicationExtensions.cs

@@ -1,40 +0,0 @@
-// Copyright (c) Microsoft Corporation
-// The Microsoft Corporation licenses this file to you under the MIT license.
-// See the LICENSE file in the project root for more information.
-
-using Microsoft.CmdPal.Common.Services;
-using Microsoft.UI.Xaml;
-
-namespace Microsoft.CmdPal.Common.Extensions;
-
-/// <summary>
-/// Extension class implementing extension methods for <see cref="Application"/>.
-/// </summary>
-public static partial class ApplicationExtensions
-{
-    /// <summary>
-    /// Get registered services at the application level from anywhere in the
-    /// application.
-    ///
-    /// Note:
-    /// https://learn.microsoft.com/uwp/api/windows.ui.xaml.application.current?view=winrt-22621#windows-ui-xaml-application-current
-    /// "Application is a singleton that implements the static Current property
-    /// to provide shared access to the Application instance for the current
-    /// application. The singleton pattern ensures that state managed by
-    /// Application, including shared resources and properties, is available
-    /// from a single, shared location."
-    ///
-    /// Example of usage:
-    /// <code>
-    /// Application.Current.GetService<T>()
-    /// </code>
-    /// </summary>
-    /// <typeparam name="T">Service type.</typeparam>
-    /// <param name="application">Current application.</param>
-    /// <returns>Service reference.</returns>
-    public static T GetService<T>(this Application application)
-        where T : class
-    {
-        return (application as IApp)!.GetService<T>();
-    }
-}

src/modules/cmdpal/Microsoft.CmdPal.Common/Extensions/IHostExtensions.cs

@@ -1,41 +0,0 @@
-// Copyright (c) Microsoft Corporation
-// The Microsoft Corporation licenses this file to you under the MIT license.
-// See the LICENSE file in the project root for more information.
-
-using System;
-using System.Diagnostics.CodeAnalysis;
-using Microsoft.Extensions.DependencyInjection;
-using Microsoft.Extensions.Hosting;
-
-namespace Microsoft.CmdPal.Common.Extensions;
-
-public static partial class IHostExtensions
-{
-    /// <summary>
-    /// <inheritdoc cref="ActivatorUtilities.CreateInstance(IServiceProvider, Type, object[])"/>
-    /// </summary>
-    public static T CreateInstance<[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicConstructors)] T>(this IHost host, params object[] parameters)
-    {
-        return ActivatorUtilities.CreateInstance<T>(host.Services, parameters);
-    }
-
-    /// <summary>
-    /// Gets the service object for the specified type, or throws an exception
-    /// if type was not registered.
-    /// </summary>
-    /// <typeparam name="T">Service type</typeparam>
-    /// <param name="host">Host object</param>
-    /// <returns>Service object</returns>
-    /// <exception cref="ArgumentException">Throw an exception if the specified
-    /// type is not registered</exception>
-    public static T GetService<T>(this IHost host)
-        where T : class
-    {
-        if (host.Services.GetService(typeof(T)) is not T service)
-        {
-            throw new ArgumentException($"{typeof(T)} needs to be registered in ConfigureServices.");
-        }
-
-        return service;
-    }
-}

src/modules/cmdpal/Microsoft.CmdPal.Common/Helpers/Json.cs

@@ -1,51 +0,0 @@
-// Copyright (c) Microsoft Corporation
-// The Microsoft Corporation licenses this file to you under the MIT license.
-// See the LICENSE file in the project root for more information.
-
-using System;
-using System.IO;
-using System.Text;
-using System.Text.Json;
-using System.Text.Json.Serialization.Metadata;
-using System.Threading.Tasks;
-using Microsoft.CmdPal.Common.JsonSerilizerContext;
-
-namespace Microsoft.CmdPal.Common.Helpers;
-
-public static partial class Json
-{
-    public static async Task<T> ToObjectAsync<T>(string value)
-    {
-        if (typeof(T) == typeof(bool))
-        {
-            return (T)(object)bool.Parse(value);
-        }
-
-        JsonTypeInfo<T>? typeInfo = (JsonTypeInfo<T>?)CommonSerializationContext.Default.GetTypeInfo(typeof(T));
-        if (typeInfo == null)
-        {
-            throw new InvalidOperationException($"Type {typeof(T)} is not supported for deSerialization.");
-        }
-
-        await using var stream = new MemoryStream(Encoding.UTF8.GetBytes(value));
-        return (await JsonSerializer.DeserializeAsync<T>(stream, typeInfo))!;
-    }
-
-    public static async Task<string> StringifyAsync<T>(T value)
-    {
-        if (typeof(T) == typeof(bool))
-        {
-            return value!.ToString()!.ToLowerInvariant();
-        }
-
-        JsonTypeInfo<T>? typeInfo = (JsonTypeInfo<T>?)CommonSerializationContext.Default.GetTypeInfo(typeof(T));
-        if (typeInfo == null)
-        {
-            throw new InvalidOperationException($"Type {typeof(T)} is not supported for serialization.");
-        }
-
-        await using var stream = new MemoryStream();
-        await JsonSerializer.SerializeAsync(stream, value, typeInfo);
-        return Encoding.UTF8.GetString(stream.ToArray());
-    }
-}

src/modules/cmdpal/Microsoft.CmdPal.Common/Models/LocalSettingsOptions.cs

@@ -1,18 +0,0 @@
-// Copyright (c) Microsoft Corporation
-// The Microsoft Corporation licenses this file to you under the MIT license.
-// See the LICENSE file in the project root for more information.
-
-namespace Microsoft.CmdPal.Common.Models;
-
-public partial class LocalSettingsOptions
-{
-    public string? ApplicationDataFolder
-    {
-        get; set;
-    }
-
-    public string? LocalSettingsFile
-    {
-        get; set;
-    }
-}

src/modules/cmdpal/Microsoft.CmdPal.Common/NativeMethods.txt

@@ -1,16 +1,7 @@
-EnableWindow
-CoCreateInstance
-FileOpenDialog
-FileSaveDialog
-IFileOpenDialog
-IFileSaveDialog
-SHCreateItemFromParsingName
 GetCurrentPackageFullName
 SetWindowLong
 GetWindowLong
 WINDOW_EX_STYLE
-SHLoadIndirectString
-StrFormatByteSizeEx
 SFBS_FLAGS
 MAX_PATH
 GetDpiForWindow

src/modules/cmdpal/Microsoft.CmdPal.Common/Services/FileService.cs

@@ -1,64 +0,0 @@
-// Copyright (c) Microsoft Corporation
-// The Microsoft Corporation licenses this file to you under the MIT license.
-// See the LICENSE file in the project root for more information.
-
-using System;
-using System.IO;
-using System.Text;
-using System.Text.Json;
-using System.Text.Json.Serialization.Metadata;
-using Microsoft.CmdPal.Common.Contracts;
-using Microsoft.CmdPal.Common.JsonSerilizerContext;
-
-namespace Microsoft.CmdPal.Common.Services;
-
-public partial class FileService : IFileService
-{
-    private static readonly Encoding _encoding = new UTF8Encoding(encoderShouldEmitUTF8Identifier: false);
-
-#pragma warning disable CS8603 // Possible null reference return.
-    public T Read<T>(string folderPath, string fileName)
-    {
-        var path = Path.Combine(folderPath, fileName);
-        if (File.Exists(path))
-        {
-            using var fileStream = File.OpenText(path);
-
-            JsonTypeInfo<T>? typeInfo = (JsonTypeInfo<T>?)CommonSerializationContext.Default.GetTypeInfo(typeof(T));
-            if (typeInfo == null)
-            {
-                throw new InvalidOperationException($"Type {typeof(T)} is not supported for deSerialization.");
-            }
-
-            return JsonSerializer.Deserialize<T>(fileStream.BaseStream, typeInfo);
-        }
-
-        return default;
-    }
-#pragma warning restore CS8603 // Possible null reference return.
-
-    public void Save<T>(string folderPath, string fileName, T content)
-    {
-        if (!Directory.Exists(folderPath))
-        {
-            Directory.CreateDirectory(folderPath);
-        }
-
-        JsonTypeInfo<T>? typeInfo = (JsonTypeInfo<T>?)CommonSerializationContext.Default.GetTypeInfo(typeof(T));
-        if (typeInfo == null)
-        {
-            throw new InvalidOperationException($"Type {typeof(T)} is not supported for serialization.");
-        }
-
-        var fileContent = JsonSerializer.Serialize(content, typeInfo);
-        File.WriteAllText(Path.Combine(folderPath, fileName), fileContent, _encoding);
-    }
-
-    public void Delete(string folderPath, string fileName)
-    {
-        if (fileName != null && File.Exists(Path.Combine(folderPath, fileName)))
-        {
-            File.Delete(Path.Combine(folderPath, fileName));
-        }
-    }
-}

src/modules/cmdpal/Microsoft.CmdPal.Common/Services/IApp.cs

@@ -1,18 +0,0 @@
-// Copyright (c) Microsoft Corporation
-// The Microsoft Corporation licenses this file to you under the MIT license.
-// See the LICENSE file in the project root for more information.
-
-namespace Microsoft.CmdPal.Common.Services;
-
-/// <summary>
-/// Interface for the current application singleton object exposing the API
-/// that can be accessed from anywhere in the application.
-/// </summary>
-public interface IApp
-{
-    /// <summary>
-    /// Gets services registered at the application level.
-    /// </summary>
-    public T GetService<T>()
-        where T : class;
-}

src/modules/cmdpal/Microsoft.CmdPal.Common/Services/LocalSettingsService.cs

@@ -1,120 +0,0 @@
-// Copyright (c) Microsoft Corporation
-// The Microsoft Corporation licenses this file to you under the MIT license.
-// See the LICENSE file in the project root for more information.
-
-using System;
-using System.Collections.Generic;
-using System.IO;
-using System.Threading.Tasks;
-using Microsoft.CmdPal.Common.Contracts;
-using Microsoft.CmdPal.Common.Helpers;
-using Microsoft.CmdPal.Common.Models;
-using Microsoft.Extensions.Options;
-using Windows.Storage;
-
-namespace Microsoft.CmdPal.Common.Services;
-
-public partial class LocalSettingsService : ILocalSettingsService
-{
-    // TODO! for now, we're hardcoding the path as effectively:
-    // %localappdata%\CmdPal\LocalSettings.json
-    private const string DefaultApplicationDataFolder = "CmdPal";
-    private const string DefaultLocalSettingsFile = "LocalSettings.json";
-
-    private readonly IFileService _fileService;
-    private readonly LocalSettingsOptions _options;
-
-    private readonly string _localApplicationData = Environment.GetFolderPath(Environment.SpecialFolder.LocalApplicationData);
-    private readonly string _applicationDataFolder;
-    private readonly string _localSettingsFile;
-
-    private readonly bool _isMsix;
-
-    private Dictionary<string, object> _settings;
-    private bool _isInitialized;
-
-    public LocalSettingsService(IFileService fileService, IOptions<LocalSettingsOptions> options)
-    {
-        _isMsix = false; // RuntimeHelper.IsMSIX;
-
-        _fileService = fileService;
-        _options = options.Value;
-
-        _applicationDataFolder = Path.Combine(_localApplicationData, _options.ApplicationDataFolder ?? DefaultApplicationDataFolder);
-        _localSettingsFile = _options.LocalSettingsFile ?? DefaultLocalSettingsFile;
-
-        _settings = new Dictionary<string, object>();
-    }
-
-    private async Task InitializeAsync()
-    {
-        if (!_isInitialized)
-        {
-            _settings = await Task.Run(() => _fileService.Read<Dictionary<string, object>>(_applicationDataFolder, _localSettingsFile)) ?? new Dictionary<string, object>();
-
-            _isInitialized = true;
-        }
-    }
-
-    public async Task<bool> HasSettingAsync(string key)
-    {
-        if (_isMsix)
-        {
-            return ApplicationData.Current.LocalSettings.Values.ContainsKey(key);
-        }
-        else
-        {
-            await InitializeAsync();
-
-            if (_settings != null)
-            {
-                return _settings.ContainsKey(key);
-            }
-        }
-
-        return false;
-    }
-
-    public async Task<T?> ReadSettingAsync<T>(string key)
-    {
-        if (_isMsix)
-        {
-            if (ApplicationData.Current.LocalSettings.Values.TryGetValue(key, out var obj))
-            {
-                return await Json.ToObjectAsync<T>((string)obj);
-            }
-        }
-        else
-        {
-            await InitializeAsync();
-
-            if (_settings != null && _settings.TryGetValue(key, out var obj))
-            {
-                var s = obj.ToString();
-
-                if (s != null)
-                {
-                    return await Json.ToObjectAsync<T>(s);
-                }
-            }
-        }
-
-        return default;
-    }
-
-    public async Task SaveSettingAsync<T>(string key, T value)
-    {
-        if (_isMsix)
-        {
-            ApplicationData.Current.LocalSettings.Values[key] = await Json.StringifyAsync(value!);
-        }
-        else
-        {
-            await InitializeAsync();
-
-            _settings[key] = await Json.StringifyAsync(value!);
-
-            await Task.Run(() => _fileService.Save(_applicationDataFolder, _localSettingsFile, _settings));
-        }
-    }
-}

src/modules/cmdpal/Microsoft.CmdPal.UI.ViewModels/AppStateModel.cs

@@ -49,7 +49,7 @@ public partial class AppStateModel : ObservableObject
             // Read the JSON content from the file
             var jsonContent = File.ReadAllText(FilePath);
 
-            var loaded = JsonSerializer.Deserialize<AppStateModel>(jsonContent, _deserializerOptions);
+            var loaded = JsonSerializer.Deserialize<AppStateModel>(jsonContent, JsonSerializationContext.Default.AppStateModel);
 
             Debug.WriteLine(loaded != null ? "Loaded settings file" : "Failed to parse");
 
@@ -73,7 +73,7 @@ public partial class AppStateModel : ObservableObject
         try
         {
             // Serialize the main dictionary to JSON and save it to the file
-            var settingsJson = JsonSerializer.Serialize(model, _serializerOptions);
+            var settingsJson = JsonSerializer.Serialize(model, JsonSerializationContext.Default.AppStateModel);
 
             // Is it valid JSON?
             if (JsonNode.Parse(settingsJson) is JsonObject newSettings)
@@ -89,7 +89,7 @@ public partial class AppStateModel : ObservableObject
                         savedSettings[item.Key] = item.Value != null ? item.Value.DeepClone() : null;
                     }
 
-                    var serialized = savedSettings.ToJsonString(_serializerOptions);
+                    var serialized = savedSettings.ToJsonString(JsonSerializationContext.Default.AppStateModel.Options);
                     File.WriteAllText(FilePath, serialized);
 
                     // TODO: Instead of just raising the event here, we should
@@ -122,18 +122,19 @@ public partial class AppStateModel : ObservableObject
         return Path.Combine(directory, "state.json");
     }
 
-    private static readonly JsonSerializerOptions _serializerOptions = new()
-    {
-        WriteIndented = true,
-        Converters = { new JsonStringEnumConverter() },
-    };
+    // [UnconditionalSuppressMessage("AOT", "IL3050:Calling members annotated with 'RequiresDynamicCodeAttribute' may break functionality when AOT compiling.", Justification = "<Pending>")]
+    // private static readonly JsonSerializerOptions _serializerOptions = new()
+    // {
+    //    WriteIndented = true,
+    //    Converters = { new JsonStringEnumConverter() },
+    // };
 
-    private static readonly JsonSerializerOptions _deserializerOptions = new()
-    {
-        PropertyNameCaseInsensitive = true,
-        IncludeFields = true,
-        AllowTrailingCommas = true,
-        PreferredObjectCreationHandling = JsonObjectCreationHandling.Populate,
-        ReadCommentHandling = JsonCommentHandling.Skip,
-    };
+    // private static readonly JsonSerializerOptions _deserializerOptions = new()
+    // {
+    //    PropertyNameCaseInsensitive = true,
+    //    IncludeFields = true,
+    //    AllowTrailingCommas = true,
+    //    PreferredObjectCreationHandling = JsonObjectCreationHandling.Populate,
+    //    ReadCommentHandling = JsonCommentHandling.Skip,
+    // };
 }

src/modules/cmdpal/Microsoft.CmdPal.UI.ViewModels/CommandBarViewModel.cs

@@ -4,18 +4,14 @@
 
 using System.Collections.ObjectModel;
 using CommunityToolkit.Mvvm.ComponentModel;
-using CommunityToolkit.Mvvm.Input;
 using CommunityToolkit.Mvvm.Messaging;
 using Microsoft.CmdPal.UI.ViewModels.Messages;
-using Microsoft.CommandPalette.Extensions;
-using Microsoft.CommandPalette.Extensions.Toolkit;
 using Windows.System;
 
 namespace Microsoft.CmdPal.UI.ViewModels;
 
 public partial class CommandBarViewModel : ObservableObject,
-    IRecipient<UpdateCommandBarMessage>,
-    IRecipient<UpdateItemKeybindingsMessage>
+    IRecipient<UpdateCommandBarMessage>
 {
     public ICommandBarContext? SelectedItem
     {
@@ -53,20 +49,17 @@ public partial class CommandBarViewModel : ObservableObject,
     public partial PageViewModel? CurrentPage { get; set; }
 
     [ObservableProperty]
-    public partial ObservableCollection<CommandContextItemViewModel> ContextCommands { get; set; } = [];
+    public partial ObservableCollection<ContextMenuStackViewModel> ContextMenuStack { get; set; } = [];
 
-    private Dictionary<KeyChord, CommandContextItemViewModel>? _contextKeybindings;
+    public ContextMenuStackViewModel? ContextMenu => ContextMenuStack.LastOrDefault();
 
     public CommandBarViewModel()
     {
         WeakReferenceMessenger.Default.Register<UpdateCommandBarMessage>(this);
-        WeakReferenceMessenger.Default.Register<UpdateItemKeybindingsMessage>(this);
     }
 
     public void Receive(UpdateCommandBarMessage message) => SelectedItem = message.ViewModel;
 
-    public void Receive(UpdateItemKeybindingsMessage message) => _contextKeybindings = message.Keys;
-
     private void SetSelectedItem(ICommandBarContext? value)
     {
         if (value != null)
@@ -111,7 +104,10 @@ public partial class CommandBarViewModel : ObservableObject,
         if (SelectedItem.MoreCommands.Count() > 1)
         {
             ShouldShowContextMenu = true;
-            ContextCommands = [.. SelectedItem.AllCommands.Where(c => c.ShouldBeVisible)];
+
+            ContextMenuStack.Clear();
+            ContextMenuStack.Add(new ContextMenuStackViewModel(SelectedItem));
+            OnPropertyChanged(nameof(ContextMenu));
         }
         else
         {
@@ -125,43 +121,80 @@ public partial class CommandBarViewModel : ObservableObject,
 
     // InvokeItemCommand is what this will be in Xaml due to source generator
     // this comes in when an item in the list is tapped
-    [RelayCommand]
-    private void InvokeItem(CommandContextItemViewModel item) =>
-       WeakReferenceMessenger.Default.Send<PerformCommandMessage>(new(item.Command.Model, item.Model));
+    // [RelayCommand]
+    public ContextKeybindingResult InvokeItem(CommandContextItemViewModel item) =>
+        PerformCommand(item);
 
     // this comes in when the primary button is tapped
     public void InvokePrimaryCommand()
     {
-        if (PrimaryCommand != null)
-        {
-            WeakReferenceMessenger.Default.Send<PerformCommandMessage>(new(PrimaryCommand.Command.Model, PrimaryCommand.Model));
-        }
+        PerformCommand(SecondaryCommand);
     }
 
     // this comes in when the secondary button is tapped
     public void InvokeSecondaryCommand()
     {
-        if (SecondaryCommand != null)
+        PerformCommand(SecondaryCommand);
+    }
+
+    public ContextKeybindingResult CheckKeybinding(bool ctrl, bool alt, bool shift, bool win, VirtualKey key)
+    {
+        var matchedItem = ContextMenu?.CheckKeybinding(ctrl, alt, shift, win, key);
+        return matchedItem != null ? PerformCommand(matchedItem) : ContextKeybindingResult.Unhandled;
+    }
+
+    private ContextKeybindingResult PerformCommand(CommandItemViewModel? command)
+    {
+        if (command == null)
         {
-            WeakReferenceMessenger.Default.Send<PerformCommandMessage>(new(SecondaryCommand.Command.Model, SecondaryCommand.Model));
+            return ContextKeybindingResult.Unhandled;
+        }
+
+        if (command.HasMoreCommands)
+        {
+            ContextMenuStack.Add(new ContextMenuStackViewModel(command));
+            OnPropertyChanging(nameof(ContextMenu));
+            OnPropertyChanged(nameof(ContextMenu));
+            return ContextKeybindingResult.KeepOpen;
+        }
+        else
+        {
+            WeakReferenceMessenger.Default.Send<PerformCommandMessage>(new(command.Command.Model, command.Model));
+            return ContextKeybindingResult.Hide;
         }
     }
 
-    public bool CheckKeybinding(bool ctrl, bool alt, bool shift, bool win, VirtualKey key)
+    public bool CanPopContextStack()
     {
-        if (_contextKeybindings != null)
+        return ContextMenuStack.Count > 1;
+    }
+
+    public void PopContextStack()
+    {
+        if (ContextMenuStack.Count > 1)
         {
-            // Does the pressed key match any of the keybindings?
-            var pressedKeyChord = KeyChordHelpers.FromModifiers(ctrl, alt, shift, win, key, 0);
-            if (_contextKeybindings.TryGetValue(pressedKeyChord, out var item))
-            {
-                // TODO GH #245: This is a bit of a hack, but we need to make sure that the keybindings are updated before we send the message
-                // so that the correct item is activated.
-                WeakReferenceMessenger.Default.Send<PerformCommandMessage>(new(item));
-                return true;
-            }
+            ContextMenuStack.RemoveAt(ContextMenuStack.Count - 1);
         }
 
-        return false;
+        OnPropertyChanging(nameof(ContextMenu));
+        OnPropertyChanged(nameof(ContextMenu));
+    }
+
+    public void ClearContextStack()
+    {
+        while (ContextMenuStack.Count > 1)
+        {
+            ContextMenuStack.RemoveAt(ContextMenuStack.Count - 1);
+        }
+
+        OnPropertyChanging(nameof(ContextMenu));
+        OnPropertyChanged(nameof(ContextMenu));
     }
 }
+
+public enum ContextKeybindingResult
+{
+    Unhandled,
+    Hide,
+    KeepOpen,
+}

src/modules/cmdpal/Microsoft.CmdPal.UI.ViewModels/CommandItemViewModel.cs

@@ -48,7 +48,7 @@ public partial class CommandItemViewModel : ExtensionObjectViewModel, ICommandBa
 
     public List<CommandContextItemViewModel> MoreCommands { get; private set; } = [];
 
-    IEnumerable<CommandContextItemViewModel> ICommandBarContext.MoreCommands => MoreCommands;
+    IEnumerable<CommandContextItemViewModel> IContextMenuContext.MoreCommands => MoreCommands;
 
     public bool HasMoreCommands => MoreCommands.Count > 0;
 
@@ -187,23 +187,26 @@ public partial class CommandItemViewModel : ExtensionObjectViewModel, ICommandBa
         // use Initialize straight up
         MoreCommands.ForEach(contextItem =>
         {
-            contextItem.InitializeProperties();
+            contextItem.SlowInitializeProperties();
         });
 
-        _defaultCommandContextItem = new(new CommandContextItem(model.Command!), PageContext)
+        if (!string.IsNullOrEmpty(model.Command.Name))
         {
-            _itemTitle = Name,
-            Subtitle = Subtitle,
-            Command = Command,
+            _defaultCommandContextItem = new(new CommandContextItem(model.Command!), PageContext)
+            {
+                _itemTitle = Name,
+                Subtitle = Subtitle,
+                Command = Command,
 
-            // TODO this probably should just be a CommandContextItemViewModel(CommandItemViewModel) ctor, or a copy ctor or whatever
-        };
+                // TODO this probably should just be a CommandContextItemViewModel(CommandItemViewModel) ctor, or a copy ctor or whatever
+            };
 
-        // Only set the icon on the context item for us if our command didn't
-        // have its own icon
-        if (!Command.HasIcon)
-        {
-            _defaultCommandContextItem._listItemIcon = _listItemIcon;
+            // Only set the icon on the context item for us if our command didn't
+            // have its own icon
+            if (!Command.HasIcon)
+            {
+                _defaultCommandContextItem._listItemIcon = _listItemIcon;
+            }
         }
 
         Initialized |= InitializedState.SelectionInitialized;
@@ -398,23 +401,6 @@ public partial class CommandItemViewModel : ExtensionObjectViewModel, ICommandBa
         base.SafeCleanup();
         Initialized |= InitializedState.CleanedUp;
     }
-
-    /// <summary>
-    /// Generates a mapping of key -> command item for this particular item's
-    /// MoreCommands. (This won't include the primary Command, but it will
-    /// include the secondary one). This map can be used to quickly check if a
-    /// shortcut key was pressed
-    /// </summary>
-    /// <returns>a dictionary of KeyChord -> Context commands, for all commands
-    /// that have a shortcut key set.</returns>
-    internal Dictionary<KeyChord, CommandContextItemViewModel> Keybindings()
-    {
-        return MoreCommands
-            .Where(c => c.HasRequestedShortcut)
-            .ToDictionary(
-            c => c.RequestedShortcut ?? new KeyChord(0, 0, 0),
-            c => c);
-    }
 }
 
 [Flags]

src/modules/cmdpal/Microsoft.CmdPal.UI.ViewModels/Commands/CreatedExtensionForm.cs

@@ -13,12 +13,13 @@ internal sealed partial class CreatedExtensionForm : NewExtensionFormBase
 {
     public CreatedExtensionForm(string name, string displayName, string path)
     {
+        var serializeString = (string? s) => JsonSerializer.Serialize(s, JsonSerializationContext.Default.String);
         TemplateJson = CardTemplate;
         DataJson = $$"""
 {
-    "name": {{JsonSerializer.Serialize(name)}},
-    "directory": {{JsonSerializer.Serialize(path)}},
-    "displayName": {{JsonSerializer.Serialize(displayName)}}
+    "name": {{serializeString(name)}},
+    "directory": {{serializeString(path)}},
+    "displayName": {{serializeString(displayName)}}
 }
 """;
         _name = name;
@@ -28,13 +29,13 @@ internal sealed partial class CreatedExtensionForm : NewExtensionFormBase
 
     public override ICommandResult SubmitForm(string inputs, string data)
     {
-        JsonObject? dataInput = JsonNode.Parse(data)?.AsObject();
+        var dataInput = JsonNode.Parse(data)?.AsObject();
         if (dataInput == null)
         {
             return CommandResult.KeepOpen();
         }
 
-        string verb = dataInput["x"]?.AsValue()?.ToString() ?? string.Empty;
+        var verb = dataInput["x"]?.AsValue()?.ToString() ?? string.Empty;
         return verb switch
         {
             "sln" => OpenSolution(),
@@ -47,7 +48,7 @@ internal sealed partial class CreatedExtensionForm : NewExtensionFormBase
     private ICommandResult OpenSolution()
     {
         string[] parts = [_path, _name, $"{_name}.sln"];
-        string pathToSolution = Path.Combine(parts);
+        var pathToSolution = Path.Combine(parts);
         ShellHelpers.OpenInShell(pathToSolution);
         return CommandResult.Hide();
     }
@@ -55,7 +56,7 @@ internal sealed partial class CreatedExtensionForm : NewExtensionFormBase
     private ICommandResult OpenDirectory()
     {
         string[] parts = [_path, _name];
-        string pathToDir = Path.Combine(parts);
+        var pathToDir = Path.Combine(parts);
         ShellHelpers.OpenInShell(pathToDir);
         return CommandResult.Hide();
     }

src/modules/cmdpal/Microsoft.CmdPal.UI.ViewModels/Commands/NewExtensionForm.cs

@@ -194,9 +194,8 @@ internal sealed partial class NewExtensionForm : NewExtensionFormBase
         Directory.Delete(tempDir, true);
     }
 
-    private string FormatJsonString(string str)
-    {
+    private string FormatJsonString(string str) =>
+
         // Escape the string for JSON
-        return JsonSerializer.Serialize(str);
-    }
+        JsonSerializer.Serialize(str, JsonSerializationContext.Default.String);
 }

src/modules/cmdpal/Microsoft.CmdPal.UI.ViewModels/ContentFormViewModel.cs

@@ -51,15 +51,16 @@ public partial class ContentFormViewModel(IFormContent _form, WeakReference<IPag
             // If we fail to parse the card JSON, then display _our own card_
             // with the exception
             AdaptiveCardTemplate template = new(ErrorCardJson);
+            var serializeString = (string? s) => JsonSerializer.Serialize(s, JsonSerializationContext.Default.String);
 
             // todo: we could probably stick Card.Errors in there too
             var dataJson = $$"""
 {
-    "error_message": {{JsonSerializer.Serialize(e.Message)}},
-    "error_stack": {{JsonSerializer.Serialize(e.StackTrace)}},
-    "inner_exception": {{JsonSerializer.Serialize(e.InnerException?.Message)}},
-    "template_json": {{JsonSerializer.Serialize(TemplateJson)}},
-    "data_json": {{JsonSerializer.Serialize(DataJson)}}
+    "error_message": {{serializeString(e.Message)}},
+    "error_stack": {{serializeString(e.StackTrace)}},
+    "inner_exception": {{serializeString(e.InnerException?.Message)}},
+    "template_json": {{serializeString(TemplateJson)}},
+    "data_json": {{serializeString(DataJson)}}
 }
 """;
             var cardJson = template.Expand(dataJson);

src/modules/cmdpal/Microsoft.CmdPal.UI.ViewModels/ContextMenuStackViewModel.cs

@@ -0,0 +1,82 @@
+// Copyright (c) Microsoft Corporation
+// The Microsoft Corporation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using System.Collections.ObjectModel;
+using CommunityToolkit.Mvvm.ComponentModel;
+using Microsoft.CmdPal.UI.ViewModels.Messages;
+using Microsoft.CommandPalette.Extensions.Toolkit;
+using Windows.System;
+
+namespace Microsoft.CmdPal.UI.ViewModels;
+
+public partial class ContextMenuStackViewModel : ObservableObject
+{
+    [ObservableProperty]
+    public partial ObservableCollection<CommandContextItemViewModel> FilteredItems { get; set; }
+
+    private readonly IContextMenuContext _context;
+    private string _lastSearchText = string.Empty;
+
+    // private Dictionary<KeyChord, CommandContextItemViewModel>? _contextKeybindings;
+    public ContextMenuStackViewModel(IContextMenuContext context)
+    {
+        _context = context;
+        FilteredItems = [.. context.AllCommands];
+    }
+
+    public void SetSearchText(string searchText)
+    {
+        if (searchText == _lastSearchText)
+        {
+            return;
+        }
+
+        _lastSearchText = searchText;
+
+        var commands = _context.AllCommands.Where(c => c.ShouldBeVisible);
+        if (string.IsNullOrEmpty(searchText))
+        {
+            ListHelpers.InPlaceUpdateList(FilteredItems, commands);
+            return;
+        }
+
+        var newResults = ListHelpers.FilterList<CommandContextItemViewModel>(commands, searchText, ScoreContextCommand);
+        ListHelpers.InPlaceUpdateList(FilteredItems, newResults);
+    }
+
+    private static int ScoreContextCommand(string query, CommandContextItemViewModel item)
+    {
+        if (string.IsNullOrEmpty(query) || string.IsNullOrWhiteSpace(query))
+        {
+            return 1;
+        }
+
+        if (string.IsNullOrEmpty(item.Title))
+        {
+            return 0;
+        }
+
+        var nameMatch = StringMatcher.FuzzySearch(query, item.Title);
+
+        var descriptionMatch = StringMatcher.FuzzySearch(query, item.Subtitle);
+
+        return new[] { nameMatch.Score, (descriptionMatch.Score - 4) / 2, 0 }.Max();
+    }
+
+    public CommandContextItemViewModel? CheckKeybinding(bool ctrl, bool alt, bool shift, bool win, VirtualKey key)
+    {
+        var keybindings = _context.Keybindings();
+        if (keybindings != null)
+        {
+            // Does the pressed key match any of the keybindings?
+            var pressedKeyChord = KeyChordHelpers.FromModifiers(ctrl, alt, shift, win, key, 0);
+            if (keybindings.TryGetValue(pressedKeyChord, out var item))
+            {
+                return item;
+            }
+        }
+
+        return null;
+    }
+}

src/modules/cmdpal/Microsoft.CmdPal.UI.ViewModels/ListViewModel.cs

@@ -344,8 +344,6 @@ public partial class ListViewModel : PageViewModel, IDisposable
            {
                WeakReferenceMessenger.Default.Send<UpdateCommandBarMessage>(new(item));
 
-               WeakReferenceMessenger.Default.Send<UpdateItemKeybindingsMessage>(new(item.Keybindings()));
-
                if (ShowDetails && item.HasDetails)
                {
                    WeakReferenceMessenger.Default.Send<ShowDetailsMessage>(new(item.Details));

src/modules/cmdpal/Microsoft.CmdPal.UI.ViewModels/Messages/TryCommandKeybindingMessage.cs

@@ -2,8 +2,11 @@
 // The Microsoft Corporation licenses this file to you under the MIT license.
 // See the LICENSE file in the project root for more information.
 
-using Microsoft.CommandPalette.Extensions;
+using Windows.System;
 
 namespace Microsoft.CmdPal.UI.ViewModels.Messages;
 
-public record UpdateItemKeybindingsMessage(Dictionary<KeyChord, CommandContextItemViewModel>? Keys);
+public record TryCommandKeybindingMessage(bool Ctrl, bool Alt, bool Shift, bool Win, VirtualKey Key)
+{
+    public bool Handled { get; set; }
+}

src/modules/cmdpal/Microsoft.CmdPal.UI.ViewModels/Messages/UpdateCommandBarMessage.cs

@@ -3,6 +3,7 @@
 // See the LICENSE file in the project root for more information.
 
 using System.ComponentModel;
+using Microsoft.CommandPalette.Extensions;
 
 namespace Microsoft.CmdPal.UI.ViewModels.Messages;
 
@@ -13,22 +14,42 @@ public record UpdateCommandBarMessage(ICommandBarContext? ViewModel)
 {
 }
 
-// Represents everything the command bar needs to know about to show command
-// buttons at the bottom.
-//
-// This is implemented by both ListItemViewModel and ContentPageViewModel,
-// the two things with sub-commands.
-public interface ICommandBarContext : INotifyPropertyChanged
+public interface IContextMenuContext : INotifyPropertyChanged
 {
     public IEnumerable<CommandContextItemViewModel> MoreCommands { get; }
 
     public bool HasMoreCommands { get; }
 
+    public List<CommandContextItemViewModel> AllCommands { get; }
+
+    /// <summary>
+    /// Generates a mapping of key -> command item for this particular item's
+    /// MoreCommands. (This won't include the primary Command, but it will
+    /// include the secondary one). This map can be used to quickly check if a
+    /// shortcut key was pressed
+    /// </summary>
+    /// <returns>a dictionary of KeyChord -> Context commands, for all commands
+    /// that have a shortcut key set.</returns>
+    public Dictionary<KeyChord, CommandContextItemViewModel> Keybindings()
+    {
+        return MoreCommands
+            .Where(c => c.HasRequestedShortcut)
+            .ToDictionary(
+            c => c.RequestedShortcut ?? new KeyChord(0, 0, 0),
+            c => c);
+    }
+}
+
+// Represents everything the command bar needs to know about to show command
+// buttons at the bottom.
+//
+// This is implemented by both ListItemViewModel and ContentPageViewModel,
+// the two things with sub-commands.
+public interface ICommandBarContext : IContextMenuContext
+{
     public string SecondaryCommandName { get; }
 
     public CommandItemViewModel? PrimaryCommand { get; }
 
     public CommandItemViewModel? SecondaryCommand { get; }
-
-    public List<CommandContextItemViewModel> AllCommands { get; }
 }

src/modules/cmdpal/Microsoft.CmdPal.UI.ViewModels/Microsoft.CmdPal.UI.ViewModels.csproj

@@ -1,5 +1,7 @@
 <Project Sdk="Microsoft.NET.Sdk">
   <Import Project="..\..\..\Common.Dotnet.CsWinRT.props" />
+  <Import Project="..\..\..\Common.Dotnet.AotCompatibility.props" />
+
   <PropertyGroup>
     <ImplicitUsings>enable</ImplicitUsings>
     <Nullable>enable</Nullable>
@@ -67,4 +69,15 @@
     </Content>
   </ItemGroup>
 
+  <!-- Just mark it as AOT compatible. Do not publish with AOT now. We need fully test before we really publish it as AOT enabled-->
+  <!--<PropertyGroup>
+    <SelfContained>true</SelfContained>
+    <WindowsAppSDKSelfContained>true</WindowsAppSDKSelfContained>
+    <PublishTrimmed>true</PublishTrimmed>
+    <PublishSingleFile>true</PublishSingleFile>
+    --><!-- <DisableRuntimeMarshalling>true</DisableRuntimeMarshalling> --><!--
+    <PublishAot>true</PublishAot>
+	<EnableMsixTooling>true</EnableMsixTooling>
+  </PropertyGroup>-->
+
 </Project>

src/modules/cmdpal/Microsoft.CmdPal.UI.ViewModels/Models/ExtensionService.cs

@@ -11,7 +11,7 @@ using Windows.Foundation.Collections;
 
 namespace Microsoft.CmdPal.UI.ViewModels.Models;
 
-public class ExtensionService : IExtensionService, IDisposable
+public partial class ExtensionService : IExtensionService, IDisposable
 {
     public event TypedEventHandler<IExtensionService, IEnumerable<IExtensionWrapper>>? OnExtensionAdded;
 

src/modules/cmdpal/Microsoft.CmdPal.UI.ViewModels/Models/ExtensionWrapper.cs

@@ -12,6 +12,7 @@ using Windows.Win32;
 using Windows.Win32.System.Com;
 using WinRT;
 
+// [assembly: System.Runtime.CompilerServices.DisableRuntimeMarshalling]
 namespace Microsoft.CmdPal.UI.ViewModels.Models;
 
 public class ExtensionWrapper : IExtensionWrapper
@@ -113,25 +114,36 @@ public class ExtensionWrapper : IExtensionWrapper
                         // -2147467262: E_NOINTERFACE
                         // -2147024893: E_PATH_NOT_FOUND
                         var guid = typeof(IExtension).GUID;
-                        var hr = PInvoke.CoCreateInstance(Guid.Parse(ExtensionClassId), null, CLSCTX.CLSCTX_LOCAL_SERVER, guid, out var extensionObj);
 
-                        if (hr.Value == -2147024893)
+                        unsafe
                         {
-                            Logger.LogDebug($"Failed to find {ExtensionDisplayName}: {hr}. It may have been uninstalled or deleted.");
+                            var hr = PInvoke.CoCreateInstance(Guid.Parse(ExtensionClassId), null, CLSCTX.CLSCTX_LOCAL_SERVER, guid, out var extensionObj);
 
-                            // We don't really need to throw this exception.
-                            // We'll just return out nothing.
-                            return;
+                            if (hr.Value == -2147024893)
+                            {
+                                Logger.LogDebug($"Failed to find {ExtensionDisplayName}: {hr}. It may have been uninstalled or deleted.");
+
+                                // We don't really need to throw this exception.
+                                // We'll just return out nothing.
+                                return;
+                            }
+
+                            extensionPtr = Marshal.GetIUnknownForObject((nint)extensionObj);
+                            if (hr < 0)
+                            {
+                                Logger.LogDebug($"Failed to instantiate {ExtensionDisplayName}: {hr}");
+                                Marshal.ThrowExceptionForHR(hr);
+                            }
+
+                            // extensionPtr = Marshal.GetIUnknownForObject(extensionObj);
+                            extensionPtr = (nint)extensionObj;
+                            if (hr < 0)
+                            {
+                                Marshal.ThrowExceptionForHR(hr);
+                            }
+
+                            _extensionObject = MarshalInterface<IExtension>.FromAbi(extensionPtr);
                         }
-
-                        extensionPtr = Marshal.GetIUnknownForObject(extensionObj);
-                        if (hr < 0)
-                        {
-                            Logger.LogDebug($"Failed to instantiate {ExtensionDisplayName}: {hr}");
-                            Marshal.ThrowExceptionForHR(hr);
-                        }
-
-                        _extensionObject = MarshalInterface<IExtension>.FromAbi(extensionPtr);
                     }
                     finally
                     {

src/modules/cmdpal/Microsoft.CmdPal.UI.ViewModels/NativeMethods.json

@@ -0,0 +1,4 @@
+{
+  "$schema": "https://aka.ms/CsWin32.schema.json",
+  "allowMarshaling": false
+}

src/modules/cmdpal/Microsoft.CmdPal.UI.ViewModels/PageViewModel.cs

@@ -99,7 +99,7 @@ public partial class PageViewModel : ExtensionObjectViewModel, IPageContext
 
     //// Run on background thread from ListPage.xaml.cs
     [RelayCommand]
-    private Task<bool> InitializeAsync()
+    internal Task<bool> InitializeAsync()
     {
         // TODO: We may want a SemaphoreSlim lock here.
 
@@ -182,6 +182,7 @@ public partial class PageViewModel : ExtensionObjectViewModel, IPageContext
             return; // throw?
         }
 
+        var updateProperty = true;
         switch (propertyName)
         {
             case nameof(Name):
@@ -198,9 +199,21 @@ public partial class PageViewModel : ExtensionObjectViewModel, IPageContext
             case nameof(Icon):
                 this.Icon = new(model.Icon);
                 break;
+            default:
+                updateProperty = false;
+                break;
         }
 
-        UpdateProperty(propertyName);
+        // GH #38829: If we always UpdateProperty here, then there's a possible
+        // race condition, where we raise the PropertyChanged(SearchText)
+        // before the subclass actually retrieves the new SearchText from the
+        // model. In that race situation, if the UI thread handles the
+        // PropertyChanged before ListViewModel fetches the SearchText, it'll
+        // think that the old search text is the _new_ value.
+        if (updateProperty)
+        {
+            UpdateProperty(propertyName);
+        }
     }
 
     public new void ShowException(Exception ex, string? extensionHint = null)

src/modules/cmdpal/Microsoft.CmdPal.UI.ViewModels/RecentCommandsManager.cs

@@ -10,7 +10,7 @@ namespace Microsoft.CmdPal.UI.ViewModels;
 public partial class RecentCommandsManager : ObservableObject
 {
     [JsonInclude]
-    private List<HistoryItem> History { get; set; } = [];
+    internal List<HistoryItem> History { get; set; } = [];
 
     public RecentCommandsManager()
     {

src/modules/cmdpal/Microsoft.CmdPal.UI.ViewModels/SettingsModel.cs

@@ -93,7 +93,7 @@ public partial class SettingsModel : ObservableObject
             // Read the JSON content from the file
             var jsonContent = File.ReadAllText(FilePath);
 
-            var loaded = JsonSerializer.Deserialize<SettingsModel>(jsonContent, _deserializerOptions);
+            var loaded = JsonSerializer.Deserialize<SettingsModel>(jsonContent, JsonSerializationContext.Default.SettingsModel);
 
             Debug.WriteLine(loaded != null ? "Loaded settings file" : "Failed to parse");
 
@@ -117,7 +117,7 @@ public partial class SettingsModel : ObservableObject
         try
         {
             // Serialize the main dictionary to JSON and save it to the file
-            var settingsJson = JsonSerializer.Serialize(model, _serializerOptions);
+            var settingsJson = JsonSerializer.Serialize(model, JsonSerializationContext.Default.SettingsModel);
 
             // Is it valid JSON?
             if (JsonNode.Parse(settingsJson) is JsonObject newSettings)
@@ -133,7 +133,7 @@ public partial class SettingsModel : ObservableObject
                         savedSettings[item.Key] = item.Value != null ? item.Value.DeepClone() : null;
                     }
 
-                    var serialized = savedSettings.ToJsonString(_serializerOptions);
+                    var serialized = savedSettings.ToJsonString(JsonSerializationContext.Default.Options);
                     File.WriteAllText(FilePath, serialized);
 
                     // TODO: Instead of just raising the event here, we should
@@ -166,19 +166,34 @@ public partial class SettingsModel : ObservableObject
         return Path.Combine(directory, "settings.json");
     }
 
-    private static readonly JsonSerializerOptions _serializerOptions = new()
-    {
-        WriteIndented = true,
-        Converters = { new JsonStringEnumConverter() },
-    };
+    // [UnconditionalSuppressMessage("AOT", "IL3050:Calling members annotated with 'RequiresDynamicCodeAttribute' may break functionality when AOT compiling.", Justification = "<Pending>")]
+    // private static readonly JsonSerializerOptions _serializerOptions = new()
+    // {
+    //    WriteIndented = true,
+    //    Converters = { new JsonStringEnumConverter() },
+    // };
+    // private static readonly JsonSerializerOptions _deserializerOptions = new()
+    // {
+    //    PropertyNameCaseInsensitive = true,
+    //    IncludeFields = true,
+    //    Converters = { new JsonStringEnumConverter() },
+    //    AllowTrailingCommas = true,
+    // };
+}
 
-    private static readonly JsonSerializerOptions _deserializerOptions = new()
-    {
-        PropertyNameCaseInsensitive = true,
-        IncludeFields = true,
-        Converters = { new JsonStringEnumConverter() },
-        AllowTrailingCommas = true,
-    };
+[JsonSerializable(typeof(float))]
+[JsonSerializable(typeof(int))]
+[JsonSerializable(typeof(string))]
+[JsonSerializable(typeof(bool))]
+[JsonSerializable(typeof(HistoryItem))]
+[JsonSerializable(typeof(SettingsModel))]
+[JsonSerializable(typeof(AppStateModel))]
+[JsonSerializable(typeof(List<HistoryItem>), TypeInfoPropertyName = "HistoryList")]
+[JsonSerializable(typeof(Dictionary<string, object>), TypeInfoPropertyName = "Dictionary")]
+[JsonSourceGenerationOptions(UseStringEnumConverter = true, WriteIndented = true, IncludeFields = true, PropertyNameCaseInsensitive = true, AllowTrailingCommas = true)]
+[System.Diagnostics.CodeAnalysis.SuppressMessage("StyleCop.CSharp.MaintainabilityRules", "SA1402:File may only contain a single type", Justification = "Just used here")]
+internal sealed partial class JsonSerializationContext : JsonSerializerContext
+{
 }
 
 public enum MonitorBehavior

src/modules/cmdpal/Microsoft.CmdPal.UI.ViewModels/ShellViewModel.cs

@@ -109,9 +109,12 @@ public partial class ShellViewModel(IServiceProvider _serviceProvider, TaskSched
                     // TODO GH #239 switch back when using the new MD text block
                     // _ = _queue.EnqueueAsync(() =>
                     _ = Task.Factory.StartNew(
-                        () =>
+                        async () =>
                         {
-                            var result = (bool)viewModel.InitializeCommand.ExecutionTask.GetResultOrDefault()!;
+                            // bool f = await viewModel.InitializeCommand.ExecutionTask.;
+                            // var result = viewModel.InitializeCommand.ExecutionTask.GetResultOrDefault()!;
+                            // var result = viewModel.InitializeCommand.ExecutionTask.GetResultOrDefault<bool?>()!;
+                            var result = await viewModel.InitializeAsync();
 
                             CurrentPage = viewModel; // result ? viewModel : null;
                             ////LoadedState = result ? ViewModelLoadedState.Loaded : ViewModelLoadedState.Error;

src/modules/cmdpal/Microsoft.CmdPal.UI/Controls/CommandBar.xaml

@@ -225,27 +225,42 @@
                 ToolTipService.ToolTip="Ctrl+K"
                 Visibility="{x:Bind ViewModel.ShouldShowContextMenu, Mode=OneWay}">
                 <Button.Flyout>
-                    <Flyout Placement="TopEdgeAlignedRight">
-                        <ListView
-                            x:Name="CommandsDropdown"
-                            MinWidth="248"
-                            Margin="-16,-12,-16,-12"
-                            IsItemClickEnabled="True"
-                            ItemClick="CommandsDropdown_ItemClick"
-                            ItemTemplate="{StaticResource ContextMenuViewModelTemplate}"
-                            ItemsSource="{x:Bind ViewModel.ContextCommands, Mode=OneWay}"
-                            KeyDown="CommandsDropdown_KeyDown"
-                            SelectionMode="None">
-                            <ListView.ItemContainerStyle>
-                                <Style BasedOn="{StaticResource DefaultListViewItemStyle}" TargetType="ListViewItem">
-                                    <Setter Property="MinHeight" Value="0" />
-                                    <Setter Property="Padding" Value="12,7,12,7" />
-                                </Style>
-                            </ListView.ItemContainerStyle>
-                            <ListView.ItemContainerTransitions>
-                                <TransitionCollection />
-                            </ListView.ItemContainerTransitions>
-                        </ListView>
+                    <Flyout
+                        Closing="Flyout_Closing"
+                        Opened="Flyout_Opened"
+                        Placement="TopEdgeAlignedRight">
+                        <StackPanel>
+
+                            <ListView
+                                x:Name="CommandsDropdown"
+                                MinWidth="248"
+                                Margin="-16,-12,-16,-12"
+                                IsItemClickEnabled="True"
+                                ItemClick="CommandsDropdown_ItemClick"
+                                ItemTemplate="{StaticResource ContextMenuViewModelTemplate}"
+                                ItemsSource="{x:Bind ViewModel.ContextMenu.FilteredItems, Mode=OneWay}"
+                                KeyDown="CommandsDropdown_KeyDown"
+                                SelectionMode="Single">
+                                <ListView.ItemContainerStyle>
+                                    <Style BasedOn="{StaticResource DefaultListViewItemStyle}" TargetType="ListViewItem">
+                                        <Setter Property="MinHeight" Value="0" />
+                                        <Setter Property="Padding" Value="12,7,12,7" />
+                                    </Style>
+                                </ListView.ItemContainerStyle>
+                                <ListView.ItemContainerTransitions>
+                                    <TransitionCollection />
+                                </ListView.ItemContainerTransitions>
+                            </ListView>
+
+                            <TextBox
+                                x:Name="ContextFilterBox"
+                                x:Uid="ContextFilterBox"
+                                Margin="-12,12,-12,-12"
+                                KeyDown="ContextFilterBox_KeyDown"
+                                PreviewKeyDown="ContextFilterBox_PreviewKeyDown"
+                                TextChanged="ContextFilterBox_TextChanged" />
+
+                        </StackPanel>
                     </Flyout>
                 </Button.Flyout>
             </Button>

src/modules/cmdpal/Microsoft.CmdPal.UI/Controls/CommandBar.xaml.cs

@@ -18,9 +18,10 @@ namespace Microsoft.CmdPal.UI.Controls;
 
 public sealed partial class CommandBar : UserControl,
     IRecipient<OpenContextMenuMessage>,
+    IRecipient<TryCommandKeybindingMessage>,
     ICurrentPageAware
 {
-    public CommandBarViewModel ViewModel { get; set; } = new();
+    public CommandBarViewModel ViewModel { get; } = new();
 
     public PageViewModel? CurrentPageViewModel
     {
@@ -38,6 +39,9 @@ public sealed partial class CommandBar : UserControl,
 
         // RegisterAll isn't AOT compatible
         WeakReferenceMessenger.Default.Register<OpenContextMenuMessage>(this);
+        WeakReferenceMessenger.Default.Register<TryCommandKeybindingMessage>(this);
+
+        ViewModel.PropertyChanged += ViewModel_PropertyChanged;
     }
 
     public void Receive(OpenContextMenuMessage message)
@@ -52,8 +56,41 @@ public sealed partial class CommandBar : UserControl,
             ShowMode = FlyoutShowMode.Standard,
         };
         MoreCommandsButton.Flyout.ShowAt(MoreCommandsButton, options);
-        CommandsDropdown.SelectedIndex = 0;
-        CommandsDropdown.Focus(FocusState.Programmatic);
+        UpdateUiForStackChange();
+    }
+
+    public void Receive(TryCommandKeybindingMessage msg)
+    {
+        if (!ViewModel.ShouldShowContextMenu)
+        {
+            return;
+        }
+
+        var result = ViewModel?.CheckKeybinding(msg.Ctrl, msg.Alt, msg.Shift, msg.Win, msg.Key);
+
+        if (result == ContextKeybindingResult.Hide)
+        {
+            msg.Handled = true;
+        }
+        else if (result == ContextKeybindingResult.KeepOpen)
+        {
+            if (!MoreCommandsButton.Flyout.IsOpen)
+            {
+                var options = new FlyoutShowOptions
+                {
+                    ShowMode = FlyoutShowMode.Standard,
+                };
+                MoreCommandsButton.Flyout.ShowAt(MoreCommandsButton, options);
+            }
+
+            UpdateUiForStackChange();
+
+            msg.Handled = true;
+        }
+        else if (result == ContextKeybindingResult.Unhandled)
+        {
+            msg.Handled = false;
+        }
     }
 
     [System.Diagnostics.CodeAnalysis.SuppressMessage("CodeQuality", "IDE0051:Remove unused private members", Justification = "VS has a tendency to delete XAML bound methods over-aggressively")]
@@ -88,8 +125,14 @@ public sealed partial class CommandBar : UserControl,
     {
         if (e.ClickedItem is CommandContextItemViewModel item)
         {
-            ViewModel?.InvokeItemCommand.Execute(item);
-            MoreCommandsButton.Flyout.Hide();
+            if (ViewModel?.InvokeItem(item) == ContextKeybindingResult.Hide)
+            {
+                MoreCommandsButton.Flyout.Hide();
+            }
+            else
+            {
+                UpdateUiForStackChange();
+            }
         }
     }
 
@@ -106,9 +149,136 @@ public sealed partial class CommandBar : UserControl,
         var winPressed = InputKeyboardSource.GetKeyStateForCurrentThread(VirtualKey.LeftWindows).HasFlag(CoreVirtualKeyStates.Down) ||
             InputKeyboardSource.GetKeyStateForCurrentThread(VirtualKey.RightWindows).HasFlag(CoreVirtualKeyStates.Down);
 
-        if (ViewModel?.CheckKeybinding(ctrlPressed, altPressed, shiftPressed, winPressed, e.Key) ?? false)
+        var result = ViewModel?.CheckKeybinding(ctrlPressed, altPressed, shiftPressed, winPressed, e.Key);
+
+        if (result == ContextKeybindingResult.Hide)
+        {
+            e.Handled = true;
+            MoreCommandsButton.Flyout.Hide();
+            WeakReferenceMessenger.Default.Send<FocusSearchBoxMessage>();
+        }
+        else if (result == ContextKeybindingResult.KeepOpen)
         {
             e.Handled = true;
         }
+        else if (result == ContextKeybindingResult.Unhandled)
+        {
+            e.Handled = false;
+        }
+    }
+
+    private void Flyout_Opened(object sender, object e)
+    {
+        UpdateUiForStackChange();
+    }
+
+    private void Flyout_Closing(FlyoutBase sender, FlyoutBaseClosingEventArgs args)
+    {
+        ViewModel?.ClearContextStack();
+        WeakReferenceMessenger.Default.Send<FocusSearchBoxMessage>();
+    }
+
+    private void ViewModel_PropertyChanged(object? sender, System.ComponentModel.PropertyChangedEventArgs e)
+    {
+        var prop = e.PropertyName;
+        if (prop == nameof(ViewModel.ContextMenu))
+        {
+            UpdateUiForStackChange();
+        }
+    }
+
+    private void ContextFilterBox_TextChanged(object sender, TextChangedEventArgs e)
+    {
+        ViewModel.ContextMenu?.SetSearchText(ContextFilterBox.Text);
+
+        if (CommandsDropdown.SelectedIndex == -1)
+        {
+            CommandsDropdown.SelectedIndex = 0;
+        }
+    }
+
+    private void ContextFilterBox_KeyDown(object sender, KeyRoutedEventArgs e)
+    {
+        var ctrlPressed = InputKeyboardSource.GetKeyStateForCurrentThread(VirtualKey.Control).HasFlag(CoreVirtualKeyStates.Down);
+        var altPressed = InputKeyboardSource.GetKeyStateForCurrentThread(VirtualKey.Menu).HasFlag(CoreVirtualKeyStates.Down);
+        var shiftPressed = InputKeyboardSource.GetKeyStateForCurrentThread(VirtualKey.Shift).HasFlag(CoreVirtualKeyStates.Down);
+        var winPressed = InputKeyboardSource.GetKeyStateForCurrentThread(VirtualKey.LeftWindows).HasFlag(CoreVirtualKeyStates.Down) ||
+            InputKeyboardSource.GetKeyStateForCurrentThread(VirtualKey.RightWindows).HasFlag(CoreVirtualKeyStates.Down);
+
+        if (e.Key == VirtualKey.Enter)
+        {
+            if (CommandsDropdown.SelectedItem is CommandContextItemViewModel item)
+            {
+                if (ViewModel?.InvokeItem(item) == ContextKeybindingResult.Hide)
+                {
+                    MoreCommandsButton.Flyout.Hide();
+                    WeakReferenceMessenger.Default.Send<FocusSearchBoxMessage>();
+                }
+                else
+                {
+                    UpdateUiForStackChange();
+                }
+
+                e.Handled = true;
+            }
+        }
+        else if (e.Key == VirtualKey.Escape ||
+            (e.Key == VirtualKey.Left && altPressed))
+        {
+            if (ViewModel.CanPopContextStack())
+            {
+                ViewModel.PopContextStack();
+                UpdateUiForStackChange();
+            }
+            else
+            {
+                MoreCommandsButton.Flyout.Hide();
+                WeakReferenceMessenger.Default.Send<FocusSearchBoxMessage>();
+            }
+
+            e.Handled = true;
+        }
+
+        CommandsDropdown_KeyDown(sender, e);
+    }
+
+    private void ContextFilterBox_PreviewKeyDown(object sender, KeyRoutedEventArgs e)
+    {
+        if (e.Key == VirtualKey.Up)
+        {
+            // navigate previous
+            if (CommandsDropdown.SelectedIndex > 0)
+            {
+                CommandsDropdown.SelectedIndex--;
+            }
+            else
+            {
+                CommandsDropdown.SelectedIndex = CommandsDropdown.Items.Count - 1;
+            }
+
+            e.Handled = true;
+        }
+        else if (e.Key == VirtualKey.Down)
+        {
+            // navigate next
+            if (CommandsDropdown.SelectedIndex < CommandsDropdown.Items.Count - 1)
+            {
+                CommandsDropdown.SelectedIndex++;
+            }
+            else
+            {
+                CommandsDropdown.SelectedIndex = 0;
+            }
+
+            e.Handled = true;
+        }
+    }
+
+    private void UpdateUiForStackChange()
+    {
+        ContextFilterBox.Text = string.Empty;
+        ViewModel.ContextMenu?.SetSearchText(string.Empty);
+        CommandsDropdown.SelectedIndex = 0;
+        ContextFilterBox.Focus(FocusState.Programmatic);
     }
 }

src/modules/cmdpal/Microsoft.CmdPal.UI/Controls/SearchBar.xaml.cs

@@ -8,8 +8,6 @@ using CommunityToolkit.WinUI;
 using Microsoft.CmdPal.UI.ViewModels;
 using Microsoft.CmdPal.UI.ViewModels.Messages;
 using Microsoft.CmdPal.UI.Views;
-using Microsoft.CommandPalette.Extensions;
-using Microsoft.CommandPalette.Extensions.Toolkit;
 using Microsoft.UI.Dispatching;
 using Microsoft.UI.Input;
 using Microsoft.UI.Xaml;
@@ -23,7 +21,6 @@ namespace Microsoft.CmdPal.UI.Controls;
 public sealed partial class SearchBar : UserControl,
     IRecipient<GoHomeMessage>,
     IRecipient<FocusSearchBoxMessage>,
-    IRecipient<UpdateItemKeybindingsMessage>,
     ICurrentPageAware
 {
     private readonly DispatcherQueue _queue = DispatcherQueue.GetForCurrentThread();
@@ -34,8 +31,6 @@ public sealed partial class SearchBar : UserControl,
     private readonly DispatcherQueueTimer _debounceTimer = DispatcherQueue.GetForCurrentThread().CreateTimer();
     private bool _isBackspaceHeld;
 
-    private Dictionary<KeyChord, CommandContextItemViewModel>? _keyBindings;
-
     public PageViewModel? CurrentPageViewModel
     {
         get => (PageViewModel?)GetValue(CurrentPageViewModelProperty);
@@ -74,7 +69,6 @@ public sealed partial class SearchBar : UserControl,
         this.InitializeComponent();
         WeakReferenceMessenger.Default.Register<GoHomeMessage>(this);
         WeakReferenceMessenger.Default.Register<FocusSearchBoxMessage>(this);
-        WeakReferenceMessenger.Default.Register<UpdateItemKeybindingsMessage>(this);
     }
 
     public void ClearSearch()
@@ -173,17 +167,14 @@ public sealed partial class SearchBar : UserControl,
             WeakReferenceMessenger.Default.Send<NavigateBackMessage>(new());
         }
 
-        if (_keyBindings != null)
+        if (!e.Handled)
         {
-            // Does the pressed key match any of the keybindings?
-            var pressedKeyChord = KeyChordHelpers.FromModifiers(ctrlPressed, altPressed, shiftPressed, winPressed, (int)e.Key, 0);
-            if (_keyBindings.TryGetValue(pressedKeyChord, out var item))
-            {
-                // TODO GH #245: This is a bit of a hack, but we need to make sure that the keybindings are updated before we send the message
-                // so that the correct item is activated.
-                WeakReferenceMessenger.Default.Send<PerformCommandMessage>(new(item));
-                e.Handled = true;
-            }
+            // The CommandBar is responsible for handling all the item keybindings,
+            // since the bound context item may need to then show another
+            // context menu
+            TryCommandKeybindingMessage msg = new(ctrlPressed, altPressed, shiftPressed, winPressed, e.Key);
+            WeakReferenceMessenger.Default.Send(msg);
+            e.Handled = msg.Handled;
         }
     }
 
@@ -302,10 +293,5 @@ public sealed partial class SearchBar : UserControl,
 
     public void Receive(GoHomeMessage message) => ClearSearch();
 
-    public void Receive(FocusSearchBoxMessage message) => this.Focus(Microsoft.UI.Xaml.FocusState.Programmatic);
-
-    public void Receive(UpdateItemKeybindingsMessage message)
-    {
-        _keyBindings = message.Keys;
-    }
+    public void Receive(FocusSearchBoxMessage message) => FilterBox.Focus(Microsoft.UI.Xaml.FocusState.Programmatic);
 }

src/modules/cmdpal/Microsoft.CmdPal.UI/Pages/ShellPage.xaml.cs

@@ -187,8 +187,6 @@ public sealed partial class ShellPage : Microsoft.UI.Xaml.Controls.Page,
 
                     WeakReferenceMessenger.Default.Send<UpdateCommandBarMessage>(new(null));
 
-                    WeakReferenceMessenger.Default.Send<UpdateItemKeybindingsMessage>(new(null));
-
                     var isMainPage = command is MainListPage;
 
                     // Construct our ViewModel of the appropriate type and pass it the UI Thread context.

src/modules/cmdpal/Microsoft.CmdPal.UI/Strings/en-us/Resources.resw

@@ -394,6 +394,9 @@ Right-click to remove the key combination, thereby deactivating the shortcut.</v
   <data name="BehaviorSettingsHeader.Text" xml:space="preserve">
     <value>Behavior</value>
   </data>
+  <data name="ContextFilterBox.PlaceholderText" xml:space="preserve">
+    <value>Search commands...</value>
+  </data>
   <data name="Settings_GeneralPage_ShowSystemTrayIcon_SettingsCard.Header" xml:space="preserve">
     <value>Show system tray icon</value>
   </data>

src/modules/cmdpal/ext/Microsoft.CmdPal.Ext.Bookmark/AddBookmarkForm.cs

@@ -34,7 +34,7 @@ internal sealed partial class AddBookmarkForm : FormContent
             "style": "text",
             "id": "name",
             "label": "{{Resources.bookmarks_form_name_label}}",
-            "value": {{JsonSerializer.Serialize(name)}},
+            "value": {{JsonSerializer.Serialize(name, BookmarkSerializationContext.Default.String)}},
             "isRequired": true,
             "errorMessage": "{{Resources.bookmarks_form_name_required}}"
         },
@@ -42,7 +42,7 @@ internal sealed partial class AddBookmarkForm : FormContent
             "type": "Input.Text",
             "style": "text",
             "id": "bookmark",
-            "value": {{JsonSerializer.Serialize(url)}},
+            "value": {{JsonSerializer.Serialize(url, BookmarkSerializationContext.Default.String)}},
             "label": "{{Resources.bookmarks_form_bookmark_label}}",
             "isRequired": true,
             "errorMessage": "{{Resources.bookmarks_form_bookmark_required}}"

src/modules/cmdpal/ext/Microsoft.CmdPal.Ext.Bookmark/BookmarkSerializationContext.cs

@@ -0,0 +1,20 @@
+// Copyright (c) Microsoft Corporation
+// The Microsoft Corporation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using System.Collections.Generic;
+using System.Text.Json.Serialization;
+
+namespace Microsoft.CmdPal.Ext.Bookmarks;
+
+[JsonSerializable(typeof(float))]
+[JsonSerializable(typeof(int))]
+[JsonSerializable(typeof(string))]
+[JsonSerializable(typeof(bool))]
+[JsonSerializable(typeof(BookmarkData))]
+[JsonSerializable(typeof(Bookmarks))]
+[JsonSerializable(typeof(List<BookmarkData>), TypeInfoPropertyName = "BookmarkList")]
+[JsonSourceGenerationOptions(UseStringEnumConverter = true, WriteIndented = true, IncludeFields = true, PropertyNameCaseInsensitive = true, AllowTrailingCommas = true)]
+internal sealed partial class BookmarkSerializationContext : JsonSerializerContext
+{
+}

src/modules/cmdpal/ext/Microsoft.CmdPal.Ext.Bookmark/Bookmarks.cs

@@ -28,7 +28,7 @@ public sealed class Bookmarks
 
             if (!string.IsNullOrEmpty(jsonStringReading))
             {
-                data = JsonSerializer.Deserialize<Bookmarks>(jsonStringReading, _jsonOptions) ?? new Bookmarks();
+                data = JsonSerializer.Deserialize<Bookmarks>(jsonStringReading, BookmarkSerializationContext.Default.Bookmarks) ?? new Bookmarks();
             }
         }
 
@@ -37,7 +37,7 @@ public sealed class Bookmarks
 
     public static void WriteToFile(string path, Bookmarks data)
     {
-        var jsonString = JsonSerializer.Serialize(data, _jsonOptions);
+        var jsonString = JsonSerializer.Serialize(data, BookmarkSerializationContext.Default.Bookmarks);
 
         File.WriteAllText(BookmarksCommandProvider.StateJsonPath(), jsonString);
     }

src/modules/cmdpal/ext/Microsoft.CmdPal.Ext.Bookmark/Microsoft.CmdPal.Ext.Bookmarks.csproj

@@ -1,5 +1,6 @@
 <Project Sdk="Microsoft.NET.Sdk">
   <Import Project="..\..\..\..\Common.Dotnet.CsWinRT.props" />
+  <Import Project="..\..\..\..\Common.Dotnet.AotCompatibility.props" />
   <PropertyGroup>
     <RootNamespace>Microsoft.CmdPal.Ext.Bookmarks</RootNamespace>
     <Nullable>enable</Nullable>
@@ -16,7 +17,7 @@
     <ProjectReference Include="..\..\extensionsdk\Microsoft.CommandPalette.Extensions.Toolkit\Microsoft.CommandPalette.Extensions.Toolkit.csproj" />
     <ProjectReference Include="..\..\ext\Microsoft.CmdPal.Ext.Indexer\Microsoft.CmdPal.Ext.Indexer.csproj" />
   </ItemGroup>
-  
+
   <ItemGroup>
     <Compile Update="Properties\Resources.Designer.cs">
       <DependentUpon>Resources.resx</DependentUpon>
@@ -24,7 +25,7 @@
       <AutoGen>True</AutoGen>
     </Compile>
   </ItemGroup>
-  
+
   <ItemGroup>
     <Content Update="Assets\Bookmark.png">
       <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
@@ -39,5 +40,5 @@
       <Generator>PublicResXFileCodeGenerator</Generator>
     </EmbeddedResource>
   </ItemGroup>
-  
+
 </Project>

src/modules/cmdpal/ext/Microsoft.CmdPal.Ext.Calc/Microsoft.CmdPal.Ext.Calc.csproj

@@ -1,5 +1,6 @@
 <Project Sdk="Microsoft.NET.Sdk">
   <Import Project="..\..\..\..\Common.Dotnet.CsWinRT.props" />
+  <Import Project="..\..\..\..\Common.Dotnet.AotCompatibility.props" />
   <PropertyGroup>
     <RootNamespace>Microsoft.CmdPal.Ext.Calc</RootNamespace>
     <OutputPath>$(SolutionDir)$(Platform)\$(Configuration)\WinUI3Apps\CmdPal</OutputPath>

src/modules/cmdpal/ext/Microsoft.CmdPal.Ext.ClipboardHistory/Helpers/NativeMethods.cs

@@ -17,7 +17,7 @@ internal static class NativeMethods
         internal INPUTTYPE type;
         internal InputUnion data;
 
-        internal static int Size => Marshal.SizeOf(typeof(INPUT));
+        internal static int Size => Marshal.SizeOf<INPUT>();
     }
 
     [StructLayout(LayoutKind.Explicit)]

src/modules/cmdpal/ext/Microsoft.CmdPal.Ext.ClipboardHistory/Microsoft.CmdPal.Ext.ClipboardHistory.csproj

@@ -1,5 +1,6 @@
 <Project Sdk="Microsoft.NET.Sdk">
   <Import Project="..\..\..\..\Common.Dotnet.CsWinRT.props" />
+  <Import Project="..\..\..\..\Common.Dotnet.AotCompatibility.props" />
   <PropertyGroup>
     <RootNamespace>Microsoft.CmdPal.Ext.ClipboardHistory</RootNamespace>
     <OutputPath>$(SolutionDir)$(Platform)\$(Configuration)\WinUI3Apps\CmdPal</OutputPath>

src/modules/cmdpal/ext/Microsoft.CmdPal.Ext.Registry/Microsoft.CmdPal.Ext.Registry.csproj

@@ -1,5 +1,7 @@
 <Project Sdk="Microsoft.NET.Sdk">
   <Import Project="..\..\..\..\Common.Dotnet.CsWinRT.props" />
+  <Import Project="..\..\..\..\Common.Dotnet.AotCompatibility.props" />
+
   <PropertyGroup>
     <RootNamespace>Microsoft.CmdPal.Ext.Registry</RootNamespace>
     <OutputPath>$(SolutionDir)$(Platform)\$(Configuration)\WinUI3Apps\CmdPal</OutputPath>

src/modules/cmdpal/ext/Microsoft.CmdPal.Ext.Shell/Microsoft.CmdPal.Ext.Shell.csproj

@@ -1,5 +1,7 @@
 <Project Sdk="Microsoft.NET.Sdk">
   <Import Project="..\..\..\..\Common.Dotnet.CsWinRT.props" />
+  <Import Project="..\..\..\..\Common.Dotnet.AotCompatibility.props" />
+
   <PropertyGroup>
 	<Nullable>enable</Nullable>
     <RootNamespace>Microsoft.CmdPal.Ext.Shell</RootNamespace>

src/modules/cmdpal/ext/Microsoft.CmdPal.Ext.System/Helpers/NetworkConnectionProperties.cs

@@ -311,14 +311,14 @@ internal sealed class NetworkConnectionProperties
     {
         switch (property)
         {
-            case string:
-                return string.IsNullOrWhiteSpace(property) ? string.Empty : $"\n\n{title}{property}";
+            case string str:
+                return string.IsNullOrWhiteSpace(str) ? string.Empty : $"\n\n{title}{str}";
             case List<string> listString:
-                return listString.Count == 0 ? string.Empty : $"\n\n{title}{string.Join("\n\n* ", property)}";
+                return listString.Count == 0 ? string.Empty : $"\n\n{title}{string.Join("\n\n* ", listString)}";
             case List<IPAddress> listIP:
-                return listIP.Count == 0 ? string.Empty : $"\n\n{title}{string.Join("\n\n* ", property)}";
+                return listIP.Count == 0 ? string.Empty : $"\n\n{title}{string.Join("\n\n* ", listIP)}";
             case IPAddressCollection collectionIP:
-                return collectionIP.Count == 0 ? string.Empty : $"\n\n{title}{string.Join("\n\n* ", property)}";
+                return collectionIP.Count == 0 ? string.Empty : $"\n\n{title}{string.Join("\n\n* ", collectionIP)}";
             case null:
                 return string.Empty;
             default:

src/modules/cmdpal/ext/Microsoft.CmdPal.Ext.System/Microsoft.CmdPal.Ext.System.csproj

@@ -1,5 +1,6 @@
 <Project Sdk="Microsoft.NET.Sdk">
   <Import Project="..\..\..\..\Common.Dotnet.CsWinRT.props" />
+  <Import Project="..\..\..\..\Common.Dotnet.AotCompatibility.props" />
   <PropertyGroup>
     <Nullable>enable</Nullable>
     <RootNamespace>Microsoft.CmdPal.Ext.System</RootNamespace>

src/modules/cmdpal/ext/Microsoft.CmdPal.Ext.TimeDate/FallbackTimeDateItem.cs

@@ -0,0 +1,104 @@
+// Copyright (c) Microsoft Corporation
+// The Microsoft Corporation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using System;
+using System.Collections.Generic;
+using System.Drawing;
+using System.Globalization;
+using System.Linq;
+using Microsoft.CmdPal.Ext.TimeDate.Helpers;
+using Microsoft.CommandPalette.Extensions;
+using Microsoft.CommandPalette.Extensions.Toolkit;
+
+namespace Microsoft.CmdPal.Ext.TimeDate;
+
+internal sealed partial class FallbackTimeDateItem : FallbackCommandItem
+{
+    private readonly HashSet<string> _validOptions;
+    private SettingsManager _settingsManager;
+
+    public FallbackTimeDateItem(SettingsManager settings)
+         : base(new NoOpCommand(), Resources.Microsoft_plugin_timedate_fallback_display_title)
+    {
+        Title = string.Empty;
+        Subtitle = string.Empty;
+        _settingsManager = settings;
+        _validOptions = new(StringComparer.OrdinalIgnoreCase)
+        {
+            Resources.ResourceManager.GetString("Microsoft_plugin_timedate_SearchTagDate", CultureInfo.CurrentCulture),
+            Resources.ResourceManager.GetString("Microsoft_plugin_timedate_SearchTagDateNow", CultureInfo.CurrentCulture),
+
+            Resources.ResourceManager.GetString("Microsoft_plugin_timedate_SearchTagTime", CultureInfo.CurrentCulture),
+            Resources.ResourceManager.GetString("Microsoft_plugin_timedate_SearchTagTimeNow", CultureInfo.CurrentCulture),
+
+            Resources.ResourceManager.GetString("Microsoft_plugin_timedate_SearchTagFormat", CultureInfo.CurrentCulture),
+            Resources.ResourceManager.GetString("Microsoft_plugin_timedate_SearchTagFormatNow", CultureInfo.CurrentCulture),
+
+            Resources.ResourceManager.GetString("Microsoft_plugin_timedate_SearchTagWeek", CultureInfo.CurrentCulture),
+        };
+    }
+
+    public override void UpdateQuery(string query)
+    {
+        if (!_settingsManager.EnableFallbackItems || string.IsNullOrWhiteSpace(query) || !IsValidQuery(query))
+        {
+            Title = string.Empty;
+            Subtitle = string.Empty;
+            Command = new NoOpCommand();
+            return;
+        }
+
+        var availableResults = AvailableResultsList.GetList(false, _settingsManager);
+        ListItem result = null;
+        var maxScore = 0;
+
+        foreach (var f in availableResults)
+        {
+            var score = f.Score(query, f.Label, f.AlternativeSearchTag);
+            if (score > maxScore)
+            {
+                maxScore = score;
+                result = f.ToListItem();
+            }
+        }
+
+        if (result != null)
+        {
+            Title = result.Title;
+            Subtitle = result.Subtitle;
+            Icon = result.Icon;
+        }
+        else
+        {
+            Title = string.Empty;
+            Subtitle = string.Empty;
+            Command = new NoOpCommand();
+        }
+    }
+
+    private bool IsValidQuery(string query)
+    {
+        if (_validOptions.Contains(query))
+        {
+            return true;
+        }
+
+        foreach (var option in _validOptions)
+        {
+            if (option == null)
+            {
+                continue;
+            }
+
+            var parts = option.Split(';', StringSplitOptions.TrimEntries | StringSplitOptions.RemoveEmptyEntries);
+
+            if (parts.Any(part => string.Equals(part, query, StringComparison.OrdinalIgnoreCase)))
+            {
+                return true;
+            }
+        }
+
+        return false;
+    }
+}

src/modules/cmdpal/ext/Microsoft.CmdPal.Ext.TimeDate/Helpers/AvailableResultsList.cs

@@ -33,6 +33,7 @@ internal static class AvailableResultsList
         var dateTimeNowUtc = dateTimeNow.ToUniversalTime();
         var firstWeekRule = firstWeekOfYear ?? TimeAndDateHelper.GetCalendarWeekRule(settings.FirstWeekOfYear);
         var firstDayOfTheWeek = firstDayOfWeek ?? TimeAndDateHelper.GetFirstDayOfWeek(settings.FirstDayOfWeek);
+        var weekOfYear = calendar.GetWeekOfYear(dateTimeNow, firstWeekRule, firstDayOfTheWeek);
 
         results.AddRange(new[]
         {
@@ -59,14 +60,20 @@ internal static class AvailableResultsList
                 AlternativeSearchTag = ResultHelper.SelectStringFromResources(isSystemDateTime, "Microsoft_plugin_timedate_SearchTagFormat"),
                 IconType = ResultIconType.DateTime,
             },
+            new AvailableResult()
+            {
+                Value = weekOfYear.ToString(CultureInfo.CurrentCulture),
+                Label = Resources.Microsoft_plugin_timedate_WeekOfYear,
+                AlternativeSearchTag = ResultHelper.SelectStringFromResources(isSystemDateTime, "Microsoft_plugin_timedate_SearchTagDate"),
+                IconType = ResultIconType.Date,
+            },
         });
 
-        if (isKeywordSearch || !settings.OnlyDateTimeNowGlobal)
+        if (isKeywordSearch)
         {
             // We use long instead of int for unix time stamp because int is too small after 03:14:07 UTC 2038-01-19
             var unixTimestamp = ((DateTimeOffset)dateTimeNowUtc).ToUnixTimeSeconds();
             var unixTimestampMilliseconds = ((DateTimeOffset)dateTimeNowUtc).ToUnixTimeMilliseconds();
-            var weekOfYear = calendar.GetWeekOfYear(dateTimeNow, firstWeekRule, firstDayOfTheWeek);
             var era = DateTimeFormatInfo.CurrentInfo.GetEraName(calendar.GetEra(dateTimeNow));
             var eraShort = DateTimeFormatInfo.CurrentInfo.GetAbbreviatedEraName(calendar.GetEra(dateTimeNow));
 
@@ -251,13 +258,6 @@ internal static class AvailableResultsList
                     IconType = ResultIconType.Date,
                 },
                 new AvailableResult()
-                {
-                    Value = weekOfYear.ToString(CultureInfo.CurrentCulture),
-                    Label = Resources.Microsoft_plugin_timedate_WeekOfYear,
-                    AlternativeSearchTag = ResultHelper.SelectStringFromResources(isSystemDateTime, "Microsoft_plugin_timedate_SearchTagDate"),
-                    IconType = ResultIconType.Date,
-                },
-                new AvailableResult()
                 {
                     Value = DateTimeFormatInfo.CurrentInfo.GetMonthName(dateTimeNow.Month),
                     Label = Resources.Microsoft_plugin_timedate_Month,

src/modules/cmdpal/ext/Microsoft.CmdPal.Ext.TimeDate/Helpers/SettingsManager.cs

@@ -75,11 +75,11 @@ public class SettingsManager : JsonSettingsManager
         Resources.Microsoft_plugin_timedate_SettingFirstDayOfWeek,
         _firstDayOfWeekChoices);
 
-    private readonly ToggleSetting _onlyDateTimeNowGlobal = new(
-        Namespaced(nameof(OnlyDateTimeNowGlobal)),
-        Resources.Microsoft_plugin_timedate_SettingOnlyDateTimeNowGlobal,
-        Resources.Microsoft_plugin_timedate_SettingOnlyDateTimeNowGlobal_Description,
-        true); // TODO -- double check default value
+    private readonly ToggleSetting _enableFallbackItems = new(
+        Namespaced(nameof(EnableFallbackItems)),
+        Resources.Microsoft_plugin_timedate_SettingEnableFallbackItems,
+        Resources.Microsoft_plugin_timedate_SettingEnableFallbackItems_Description,
+        true);
 
     private readonly ToggleSetting _timeWithSeconds = new(
         Namespaced(nameof(TimeWithSecond)),
@@ -93,12 +93,6 @@ public class SettingsManager : JsonSettingsManager
         Resources.Microsoft_plugin_timedate_SettingDateWithWeekday_Description,
         false); // TODO -- double check default value
 
-    private readonly ToggleSetting _hideNumberMessageOnGlobalQuery = new(
-        Namespaced(nameof(HideNumberMessageOnGlobalQuery)),
-        Resources.Microsoft_plugin_timedate_SettingHideNumberMessageOnGlobalQuery,
-        Resources.Microsoft_plugin_timedate_SettingHideNumberMessageOnGlobalQuery,
-        true); // TODO -- double check default value
-
     private readonly TextSetting _customFormats = new(
         Namespaced(nameof(CustomFormats)),
         Resources.Microsoft_plugin_timedate_Setting_CustomFormats,
@@ -145,14 +139,12 @@ public class SettingsManager : JsonSettingsManager
         }
     }
 
-    public bool OnlyDateTimeNowGlobal => _onlyDateTimeNowGlobal.Value;
+    public bool EnableFallbackItems => _enableFallbackItems.Value;
 
     public bool TimeWithSecond => _timeWithSeconds.Value;
 
     public bool DateWithWeekday => _dateWithWeekday.Value;
 
-    public bool HideNumberMessageOnGlobalQuery => _hideNumberMessageOnGlobalQuery.Value;
-
     public List<string> CustomFormats => _customFormats.Value.Split(TEXTBOXNEWLINE).ToList();
 
     internal static string SettingsJsonPath()
@@ -168,10 +160,7 @@ public class SettingsManager : JsonSettingsManager
     {
         FilePath = SettingsJsonPath();
 
-        /* The following two settings make no sense with current CmdPal behavior.
-        Settings.Add(_onlyDateTimeNowGlobal);
-        Settings.Add(_hideNumberMessageOnGlobalQuery); */
-
+        Settings.Add(_enableFallbackItems);
         Settings.Add(_timeWithSeconds);
         Settings.Add(_dateWithWeekday);
         Settings.Add(_firstWeekOfYear);

src/modules/cmdpal/ext/Microsoft.CmdPal.Ext.TimeDate/Helpers/TimeDateCalculator.cs

@@ -40,7 +40,7 @@ public sealed partial class TimeDateCalculator
         var lastInputParsingErrorMsg = string.Empty;
 
         // Switch search type
-        if (isEmptySearchInput || (!isKeywordSearch && settings.OnlyDateTimeNowGlobal))
+        if (isEmptySearchInput || (!isKeywordSearch))
         {
             // Return all results for system time/date on empty keyword search
             // or only time, date and now results for system time on global queries if the corresponding setting is enabled
@@ -91,23 +91,6 @@ public sealed partial class TimeDateCalculator
             }
         }
 
-        /*htcfreek:Code obsolete with current CmdPal behavior.
-        // If search term is only a number that can't be parsed return an error message
-        if (!isEmptySearchInput && results.Count == 0 && Regex.IsMatch(query, @"\w+\d+.*$") && !query.Any(char.IsWhiteSpace) && (TimeAndDateHelper.IsSpecialInputParsing(query) || !Regex.IsMatch(query, @"\d+[\.:/]\d+")))
-        {
-            // Without plugin key word show only if message is not hidden by setting
-            if (!settings.HideNumberMessageOnGlobalQuery)
-            {
-                var er = ResultHelper.CreateInvalidInputErrorResult();
-                if (!string.IsNullOrEmpty(lastInputParsingErrorMsg))
-                {
-                    er.Details = new Details() { Body = lastInputParsingErrorMsg };
-                }
-
-                results.Add(er);
-            }
-        } */
-
         if (results.Count == 0)
         {
             var er = ResultHelper.CreateInvalidInputErrorResult();

src/modules/cmdpal/ext/Microsoft.CmdPal.Ext.TimeDate/Microsoft.CmdPal.Ext.TimeDate.csproj

@@ -1,6 +1,7 @@
 <Project Sdk="Microsoft.NET.Sdk">
   <Import Project="..\..\..\..\Common.Dotnet.CsWinRT.props" />
-  <Import Project="..\..\Microsoft.CmdPal.UI\CmdPal.pre.props" />
+	<Import Project="..\..\..\..\Common.Dotnet.AotCompatibility.props" />
+
   <PropertyGroup>
     <RootNamespace>Microsoft.CmdPal.Ext.TimeDate</RootNamespace>
     <AppendTargetFrameworkToOutputPath>false</AppendTargetFrameworkToOutputPath>

src/modules/cmdpal/ext/Microsoft.CmdPal.Ext.TimeDate/Properties/Resources.Designer.cs

@@ -213,6 +213,15 @@ namespace Microsoft.CmdPal.Ext.TimeDate {
             }
         }
         
+        /// <summary>
+        ///   Looks up a localized string similar to Open Time Data Command.
+        /// </summary>
+        public static string Microsoft_plugin_timedate_fallback_display_title {
+            get {
+                return ResourceManager.GetString("Microsoft_plugin_timedate_fallback_display_title", resourceCulture);
+            }
+        }
+        
         /// <summary>
         ///   Looks up a localized string similar to Date and time in filename-compatible format.
         /// </summary>
@@ -609,6 +618,15 @@ namespace Microsoft.CmdPal.Ext.TimeDate {
             }
         }
         
+        /// <summary>
+        ///   Looks up a localized string similar to Current Week; Calendar week; Week of the year; Week.
+        /// </summary>
+        public static string Microsoft_plugin_timedate_SearchTagWeek {
+            get {
+                return ResourceManager.GetString("Microsoft_plugin_timedate_SearchTagWeek", resourceCulture);
+            }
+        }
+        
         /// <summary>
         ///   Looks up a localized string similar to Second.
         /// </summary>
@@ -663,6 +681,24 @@ namespace Microsoft.CmdPal.Ext.TimeDate {
             }
         }
         
+        /// <summary>
+        ///   Looks up a localized string similar to Enable fallback items for TimeDate (week, year, now, time, date).
+        /// </summary>
+        public static string Microsoft_plugin_timedate_SettingEnableFallbackItems {
+            get {
+                return ResourceManager.GetString("Microsoft_plugin_timedate_SettingEnableFallbackItems", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to Show time and date results when typing keywords like &quot;week&quot;, &quot;year&quot;, &quot;now&quot;, &quot;time&quot;, or &quot;date&quot;.
+        /// </summary>
+        public static string Microsoft_plugin_timedate_SettingEnableFallbackItems_Description {
+            get {
+                return ResourceManager.GetString("Microsoft_plugin_timedate_SettingEnableFallbackItems_Description", resourceCulture);
+            }
+        }
+        
         /// <summary>
         ///   Looks up a localized string similar to First day of the week.
         /// </summary>
@@ -780,33 +816,6 @@ namespace Microsoft.CmdPal.Ext.TimeDate {
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Hide &apos;Invalid number input&apos; error message on global queries.
-        /// </summary>
-        public static string Microsoft_plugin_timedate_SettingHideNumberMessageOnGlobalQuery {
-            get {
-                return ResourceManager.GetString("Microsoft_plugin_timedate_SettingHideNumberMessageOnGlobalQuery", resourceCulture);
-            }
-        }
-        
-        /// <summary>
-        ///   Looks up a localized string similar to Show only &apos;Time&apos;, &apos;Date&apos; and &apos;Now&apos; result for system time on global queries.
-        /// </summary>
-        public static string Microsoft_plugin_timedate_SettingOnlyDateTimeNowGlobal {
-            get {
-                return ResourceManager.GetString("Microsoft_plugin_timedate_SettingOnlyDateTimeNowGlobal", resourceCulture);
-            }
-        }
-        
-        /// <summary>
-        ///   Looks up a localized string similar to Regardless of this setting, for global queries the first word of the query has to be a complete match..
-        /// </summary>
-        public static string Microsoft_plugin_timedate_SettingOnlyDateTimeNowGlobal_Description {
-            get {
-                return ResourceManager.GetString("Microsoft_plugin_timedate_SettingOnlyDateTimeNowGlobal_Description", resourceCulture);
-            }
-        }
-        
         /// <summary>
         ///   Looks up a localized string similar to Show time with seconds.
         /// </summary>

src/modules/cmdpal/ext/Microsoft.CmdPal.Ext.TimeDate/Properties/Resources.resx

@@ -265,15 +265,6 @@
   <data name="Microsoft_plugin_timedate_SettingDateWithWeekday_Description" xml:space="preserve">
     <value>This setting applies to the 'Date' and 'Now' result.</value>
   </data>
-  <data name="Microsoft_plugin_timedate_SettingHideNumberMessageOnGlobalQuery" xml:space="preserve">
-    <value>Hide 'Invalid number input' error message on global queries</value>
-  </data>
-  <data name="Microsoft_plugin_timedate_SettingOnlyDateTimeNowGlobal" xml:space="preserve">
-    <value>Show only 'Time', 'Date' and 'Now' result for system time on global queries</value>
-  </data>
-  <data name="Microsoft_plugin_timedate_SettingOnlyDateTimeNowGlobal_Description" xml:space="preserve">
-    <value>Regardless of this setting, for global queries the first word of the query has to be a complete match.</value>
-  </data>
   <data name="Microsoft_plugin_timedate_SettingTimeWithSeconds" xml:space="preserve">
     <value>Show time with seconds</value>
   </data>
@@ -433,4 +424,16 @@
   <data name="Microsoft_plugin_timedate_DaysInMonth" xml:space="preserve">
     <value>Days in month</value>
   </data>
+  <data name="Microsoft_plugin_timedate_fallback_display_title" xml:space="preserve">
+    <value>Open Time Data Command</value>
+  </data>
+  <data name="Microsoft_plugin_timedate_SearchTagWeek" xml:space="preserve">
+    <value>Current Week; Calendar week; Week of the year; Week</value>
+  </data>
+  <data name="Microsoft_plugin_timedate_SettingEnableFallbackItems" xml:space="preserve">
+    <value>Enable fallback items for TimeDate (week, year, now, time, date)</value>
+  </data>
+  <data name="Microsoft_plugin_timedate_SettingEnableFallbackItems_Description" xml:space="preserve">
+    <value>Show time and date results when typing keywords like "week", "year", "now", "time", or "date"</value>
+  </data>
 </root>

src/modules/cmdpal/ext/Microsoft.CmdPal.Ext.TimeDate/TimeDateCommandsProvider.cs

@@ -18,6 +18,7 @@ public partial class TimeDateCommandsProvider : CommandProvider
     private static readonly SettingsManager _settingsManager = new();
     private static readonly CompositeFormat MicrosoftPluginTimedatePluginDescription = System.Text.CompositeFormat.Parse(Resources.Microsoft_plugin_timedate_plugin_description);
     private static readonly TimeDateExtensionPage _timeDateExtensionPage = new(_settingsManager);
+    private readonly FallbackTimeDateItem _fallbackTimeDateItem = new(_settingsManager);
 
     public TimeDateCommandsProvider()
     {
@@ -45,4 +46,6 @@ public partial class TimeDateCommandsProvider : CommandProvider
     }
 
     public override ICommandItem[] TopLevelCommands() => [_command];
+
+    public override IFallbackCommandItem[] FallbackCommands() => [_fallbackTimeDateItem];
 }

src/modules/cmdpal/ext/Microsoft.CmdPal.Ext.WebSearch/Helpers/HistoryItem.cs

@@ -13,5 +13,5 @@ public class HistoryItem(string searchString, DateTime timestamp)
 
     public DateTime Timestamp { get; private set; } = timestamp;
 
-    public string ToJson() => JsonSerializer.Serialize(this);
+    public string ToJson() => JsonSerializer.Serialize(this, WebSearchJsonSerializationContext.Default.HistoryItem);
 }

src/modules/cmdpal/ext/Microsoft.CmdPal.Ext.WebSearch/Helpers/SettingsManager.cs

@@ -80,7 +80,7 @@ public class SettingsManager : JsonSettingsManager
             if (File.Exists(_historyPath))
             {
                 var existingContent = File.ReadAllText(_historyPath);
-                historyItems = JsonSerializer.Deserialize<List<HistoryItem>>(existingContent) ?? [];
+                historyItems = JsonSerializer.Deserialize<List<HistoryItem>>(existingContent, WebSearchJsonSerializationContext.Default.ListHistoryItem) ?? [];
             }
             else
             {
@@ -101,7 +101,7 @@ public class SettingsManager : JsonSettingsManager
             }
 
             // Serialize the updated list back to JSON and save it
-            var historyJson = JsonSerializer.Serialize(historyItems);
+            var historyJson = JsonSerializer.Serialize(historyItems, WebSearchJsonSerializationContext.Default.ListHistoryItem);
             File.WriteAllText(_historyPath, historyJson);
         }
         catch (Exception ex)
@@ -121,7 +121,7 @@ public class SettingsManager : JsonSettingsManager
 
             // Read and deserialize JSON into a list of HistoryItem objects
             var fileContent = File.ReadAllText(_historyPath);
-            var historyItems = JsonSerializer.Deserialize<List<HistoryItem>>(fileContent) ?? [];
+            var historyItems = JsonSerializer.Deserialize<List<HistoryItem>>(fileContent, WebSearchJsonSerializationContext.Default.ListHistoryItem) ?? [];
 
             // Convert each HistoryItem to a ListItem
             var listItems = new List<ListItem>();
@@ -198,7 +198,7 @@ public class SettingsManager : JsonSettingsManager
                 if (File.Exists(_historyPath))
                 {
                     var existingContent = File.ReadAllText(_historyPath);
-                    var historyItems = JsonSerializer.Deserialize<List<HistoryItem>>(existingContent) ?? [];
+                    var historyItems = JsonSerializer.Deserialize<List<HistoryItem>>(existingContent, WebSearchJsonSerializationContext.Default.ListHistoryItem) ?? [];
 
                     // Check if trimming is needed
                     if (historyItems.Count > maxHistoryItems)
@@ -207,7 +207,7 @@ public class SettingsManager : JsonSettingsManager
                         historyItems = historyItems.Skip(historyItems.Count - maxHistoryItems).ToList();
 
                         // Save the trimmed history back to the file
-                        var trimmedHistoryJson = JsonSerializer.Serialize(historyItems);
+                        var trimmedHistoryJson = JsonSerializer.Serialize(historyItems, WebSearchJsonSerializationContext.Default.ListHistoryItem);
                         File.WriteAllText(_historyPath, trimmedHistoryJson);
                     }
                 }

src/modules/cmdpal/ext/Microsoft.CmdPal.Ext.WebSearch/Helpers/WebSearchJsonSerializationContext.cs

@@ -2,15 +2,19 @@
 // The Microsoft Corporation licenses this file to you under the MIT license.
 // See the LICENSE file in the project root for more information.
 
+using System.Collections.Generic;
 using System.Text.Json.Serialization;
+using Microsoft.CmdPal.Ext.WebSearch.Helpers;
 
-namespace Microsoft.CmdPal.Common.JsonSerilizerContext;
+namespace Microsoft.CmdPal.Ext.WebSearch;
 
 [JsonSerializable(typeof(float))]
 [JsonSerializable(typeof(int))]
 [JsonSerializable(typeof(string))]
 [JsonSerializable(typeof(bool))]
+[JsonSerializable(typeof(HistoryItem))]
+[JsonSerializable(typeof(List<HistoryItem>))]
 [JsonSourceGenerationOptions(UseStringEnumConverter = true, WriteIndented = true, IncludeFields = true, PropertyNameCaseInsensitive = true, AllowTrailingCommas = true)]
-internal sealed partial class CommonSerializationContext : JsonSerializerContext
+internal sealed partial class WebSearchJsonSerializationContext : JsonSerializerContext
 {
 }

src/modules/cmdpal/ext/Microsoft.CmdPal.Ext.WebSearch/Microsoft.CmdPal.Ext.WebSearch.csproj

@@ -1,5 +1,6 @@
 <Project Sdk="Microsoft.NET.Sdk">
   <Import Project="..\..\..\..\Common.Dotnet.CsWinRT.props" />
+  <Import Project="..\..\..\..\Common.Dotnet.AotCompatibility.props" />
   <PropertyGroup>
     <RootNamespace>Microsoft.CmdPal.Ext.WebSearch</RootNamespace>
 	<Nullable>enable</Nullable>

src/modules/cmdpal/ext/Microsoft.CmdPal.Ext.WindowWalker/Microsoft.CmdPal.Ext.WindowWalker.csproj

@@ -1,5 +1,7 @@
 <Project Sdk="Microsoft.NET.Sdk">
   <Import Project="..\..\..\..\Common.Dotnet.CsWinRT.props" />
+  <Import Project="..\..\..\..\Common.Dotnet.AotCompatibility.props" />
+
   <PropertyGroup>
 	<Nullable>enable</Nullable>
     <RootNamespace>Microsoft.CmdPal.Ext.WindowWalker</RootNamespace>

src/modules/cmdpal/ext/Microsoft.CmdPal.Ext.WindowsServices/Microsoft.CmdPal.Ext.WindowsServices.csproj

@@ -1,5 +1,7 @@
 <Project Sdk="Microsoft.NET.Sdk">
   <Import Project="..\..\..\..\Common.Dotnet.CsWinRT.props" />
+  <Import Project="..\..\..\..\Common.Dotnet.AotCompatibility.props" />
+
   <PropertyGroup>
     <RootNamespace>Microsoft.CmdPal.Ext.WindowsServices</RootNamespace>
     <OutputPath>$(SolutionDir)$(Platform)\$(Configuration)\WinUI3Apps\CmdPal</OutputPath>

src/modules/cmdpal/ext/Microsoft.CmdPal.Ext.WindowsSettings/Helpers/JsonSettingsListHelper.cs

@@ -4,10 +4,8 @@
 
 using System;
 using System.IO;
-using System.Linq;
 using System.Reflection;
 using System.Text.Json;
-using System.Text.Json.Serialization;
 
 namespace Microsoft.CmdPal.Ext.WindowsSettings.Helpers;
 
@@ -21,6 +19,8 @@ internal static class JsonSettingsListHelper
     /// </summary>
     private const string _settingsFile = "WindowsSettings.json";
 
+    private const string _extTypeNamespace = "Microsoft.CmdPal.Ext.WindowsSettings";
+
     private static readonly JsonSerializerOptions _serializerOptions = new()
     {
     };
@@ -32,7 +32,6 @@ internal static class JsonSettingsListHelper
     internal static Classes.WindowsSettings ReadAllPossibleSettings()
     {
         var assembly = Assembly.GetExecutingAssembly();
-        var type = assembly.GetTypes().FirstOrDefault(x => x.Name == nameof(WindowsSettingsCommandsProvider));
 
 #pragma warning disable CS8632 // The annotation for nullable reference types should only be used in code within a '#nullable' annotations context.
         Classes.WindowsSettings? settings = null;
@@ -40,7 +39,7 @@ internal static class JsonSettingsListHelper
 
         try
         {
-            var resourceName = $"{type?.Namespace}.{_settingsFile}";
+            var resourceName = $"{_extTypeNamespace}.{_settingsFile}";
             using var stream = assembly.GetManifestResourceStream(resourceName);
             if (stream is null)
             {
@@ -48,12 +47,13 @@ internal static class JsonSettingsListHelper
             }
 
             var options = _serializerOptions;
-            options.Converters.Add(new JsonStringEnumConverter());
 
+            // Why we need it? I don't see any enum usage in WindowsSettings
+            // options.Converters.Add(new JsonStringEnumConverter());
             using var reader = new StreamReader(stream);
             var text = reader.ReadToEnd();
 
-            settings = JsonSerializer.Deserialize<Classes.WindowsSettings>(text, options);
+            settings = JsonSerializer.Deserialize(text, WindowsSettingsJsonSerializationContext.Default.WindowsSettings);
         }
 #pragma warning disable CS0168
         catch (Exception exception)

src/modules/cmdpal/ext/Microsoft.CmdPal.Ext.WindowsSettings/JsonSerializationContext.cs

@@ -0,0 +1,22 @@
+// Copyright (c) Microsoft Corporation
+// The Microsoft Corporation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Text.Json.Serialization;
+using System.Threading.Tasks;
+
+namespace Microsoft.CmdPal.Ext.WindowsSettings;
+
+[JsonSerializable(typeof(float))]
+[JsonSerializable(typeof(int))]
+[JsonSerializable(typeof(string))]
+[JsonSerializable(typeof(bool))]
+[JsonSerializable(typeof(Classes.WindowsSettings))]
+[JsonSourceGenerationOptions(UseStringEnumConverter = true, WriteIndented = true, IncludeFields = true, PropertyNameCaseInsensitive = true, AllowTrailingCommas = true)]
+internal sealed partial class WindowsSettingsJsonSerializationContext : JsonSerializerContext
+{
+}

src/modules/cmdpal/ext/Microsoft.CmdPal.Ext.WindowsSettings/Microsoft.CmdPal.Ext.WindowsSettings.csproj

@@ -1,5 +1,6 @@
 <Project Sdk="Microsoft.NET.Sdk">
   <Import Project="..\..\..\..\Common.Dotnet.CsWinRT.props" />
+  <Import Project="..\..\..\..\Common.Dotnet.AotCompatibility.props" />
   <PropertyGroup>
     <RootNamespace>Microsoft.CmdPal.Ext.WindowsSettings</RootNamespace>
     <OutputPath>$(SolutionDir)$(Platform)\$(Configuration)\WinUI3Apps\CmdPal</OutputPath>

src/modules/cmdpal/ext/Microsoft.CmdPal.Ext.WindowsTerminal/Microsoft.CmdPal.Ext.WindowsTerminal.csproj

@@ -1,6 +1,8 @@
 <Project Sdk="Microsoft.NET.Sdk">
   <Import Project="..\..\..\..\Common.Dotnet.CsWinRT.props" />
+  <Import Project="..\..\..\..\Common.Dotnet.AotCompatibility.props" />
   <Import Project="..\..\Microsoft.CmdPal.UI\CmdPal.pre.props" />
+
   <PropertyGroup>
     <RootNamespace>Microsoft.CmdPal.Ext.WindowsTerminal</RootNamespace>
     <!-- <OutputPath>$(SolutionDir)$(Platform)\$(Configuration)\WinUI3Apps\CmdPal</OutputPath> -->

src/modules/cmdpal/ext/SamplePagesExtension/EvilSamplesPage.cs

@@ -6,6 +6,7 @@ using System.Threading;
 using System.Threading.Tasks;
 using Microsoft.CommandPalette.Extensions;
 using Microsoft.CommandPalette.Extensions.Toolkit;
+using Windows.System;
 
 namespace SamplePagesExtension;
 
@@ -76,7 +77,136 @@ public partial class EvilSamplesPage : ListPage
            {
                Body = "This is a test for GH#512. If it doesn't appear immediately, it's likely InvokeCommand is happening on the UI thread.",
            },
-        }
+        },
+
+        // More edge cases than truly evil
+        new ListItem(
+            new ToastCommand("Primary command invoked", MessageState.Info) { Name = "Primary command", Icon = new IconInfo("\uF146") }) // dial 1
+        {
+            Title = "anonymous command test",
+            Subtitle = "Try pressing Ctrl+1 with me selected",
+            Icon = new IconInfo("\uE712"),  // "More" dots
+            MoreCommands = [
+                new CommandContextItem(
+                    new ToastCommand("Secondary command invoked", MessageState.Warning) { Name = "Secondary command", Icon = new IconInfo("\uF147") }) // dial 2
+                {
+                    Title = "I'm a second command",
+                    RequestedShortcut = KeyChordHelpers.FromModifiers(ctrl: true, vkey: VirtualKey.Number1),
+                },
+                new CommandContextItem("nested...")
+                {
+                    Title = "We can go deeper...",
+                    Icon = new IconInfo("\uF148"),
+                    RequestedShortcut = KeyChordHelpers.FromModifiers(ctrl: true, vkey: VirtualKey.Number2),
+                    MoreCommands = [
+                        new CommandContextItem(
+                            new ToastCommand("Nested A invoked") { Name = "Do it", Icon = new IconInfo("A") })
+                        {
+                            Title = "Nested A",
+                            RequestedShortcut = KeyChordHelpers.FromModifiers(alt: true, vkey: VirtualKey.A),
+                        },
+
+                        new CommandContextItem(
+                            new ToastCommand("Nested B invoked") { Name = "Do it", Icon = new IconInfo("B") })
+                        {
+                            Title = "Nested B...",
+                            RequestedShortcut = KeyChordHelpers.FromModifiers(ctrl: true, vkey: VirtualKey.B),
+                            MoreCommands = [
+                                new CommandContextItem(
+                                    new ToastCommand("Nested C invoked") { Name = "Do it" })
+                                {
+                                    Title = "You get it",
+                                    RequestedShortcut = KeyChordHelpers.FromModifiers(ctrl: true, vkey: VirtualKey.B),
+                                }
+                            ],
+                        },
+                    ],
+                }
+            ],
+        },
+        new ListItem(
+            new ToastCommand("Primary command invoked", MessageState.Info) { Name = "Primary command", Icon = new IconInfo("\uF146") }) // dial 1
+        {
+            Title = "noop command test",
+            Subtitle = "Try pressing Ctrl+1 with me selected",
+            Icon = new IconInfo("\uE712"),  // "More" dots
+            MoreCommands = [
+                new CommandContextItem(
+                    new ToastCommand("Secondary command invoked", MessageState.Warning) { Name = "Secondary command", Icon = new IconInfo("\uF147") }) // dial 2
+                {
+                    Title = "I'm a second command",
+                    RequestedShortcut = KeyChordHelpers.FromModifiers(ctrl: true, vkey: VirtualKey.Number1),
+                },
+                new CommandContextItem(new NoOpCommand())
+                {
+                    Title = "We can go deeper...",
+                    Icon = new IconInfo("\uF148"),
+                    RequestedShortcut = KeyChordHelpers.FromModifiers(ctrl: true, vkey: VirtualKey.Number2),
+                    MoreCommands = [
+                        new CommandContextItem(
+                            new ToastCommand("Nested A invoked") { Name = "Do it", Icon = new IconInfo("A") })
+                        {
+                            Title = "Nested A",
+                            RequestedShortcut = KeyChordHelpers.FromModifiers(alt: true, vkey: VirtualKey.A),
+                        },
+
+                        new CommandContextItem(
+                            new ToastCommand("Nested B invoked") { Name = "Do it", Icon = new IconInfo("B") })
+                        {
+                            Title = "Nested B...",
+                            RequestedShortcut = KeyChordHelpers.FromModifiers(ctrl: true, vkey: VirtualKey.B),
+                            MoreCommands = [
+                                new CommandContextItem(
+                                    new ToastCommand("Nested C invoked") { Name = "Do it" })
+                                {
+                                    Title = "You get it",
+                                    RequestedShortcut = KeyChordHelpers.FromModifiers(ctrl: true, vkey: VirtualKey.B),
+                                }
+                            ],
+                        },
+                    ],
+                }
+            ],
+        },
+        new ListItem(
+            new ToastCommand("Primary command invoked", MessageState.Info) { Name = "Primary command", Icon = new IconInfo("\uF146") }) // dial 1
+        {
+            Title = "noop secondary command test",
+            Subtitle = "Try pressing Ctrl+1 with me selected",
+            Icon = new IconInfo("\uE712"),  // "More" dots
+            MoreCommands = [
+                new CommandContextItem(new NoOpCommand())
+                {
+                    Title = "We can go deeper...",
+                    Icon = new IconInfo("\uF148"),
+                    RequestedShortcut = KeyChordHelpers.FromModifiers(ctrl: true, vkey: VirtualKey.Number2),
+                    MoreCommands = [
+                        new CommandContextItem(
+                            new ToastCommand("Nested A invoked") { Name = "Do it", Icon = new IconInfo("A") })
+                        {
+                            Title = "Nested A",
+                            RequestedShortcut = KeyChordHelpers.FromModifiers(alt: true, vkey: VirtualKey.A),
+                        },
+
+                        new CommandContextItem(
+                            new ToastCommand("Nested B invoked") { Name = "Do it", Icon = new IconInfo("B") })
+                        {
+                            Title = "Nested B...",
+                            RequestedShortcut = KeyChordHelpers.FromModifiers(ctrl: true, vkey: VirtualKey.B),
+                            MoreCommands = [
+                                new CommandContextItem(
+                                    new ToastCommand("Nested C invoked") { Name = "Do it" })
+                                {
+                                    Title = "You get it",
+                                    RequestedShortcut = KeyChordHelpers.FromModifiers(ctrl: true, vkey: VirtualKey.B),
+                                }
+                            ],
+                        },
+                    ],
+                }
+            ],
+        },
+
     ];
 
     public EvilSamplesPage()

src/modules/cmdpal/ext/SamplePagesExtension/Pages/SampleListPage.cs

@@ -69,62 +69,47 @@ internal sealed partial class SampleListPage : ListPage
             },
 
             new ListItem(
-                new AnonymousCommand(() =>
-                {
-                    var t = new ToastStatusMessage(new StatusMessage()
-                    {
-                        Message = "Primary command invoked",
-                        State = MessageState.Info,
-                    });
-                    t.Show();
-                })
-                {
-                    Result = CommandResult.KeepOpen(),
-                    Icon = new IconInfo("\uE712"),
-                })
+                new ToastCommand("Primary command invoked", MessageState.Info) { Name = "Primary command", Icon = new IconInfo("\uF146") }) // dial 1
             {
                 Title = "You can add context menu items too. Press Ctrl+k",
                 Subtitle = "Try pressing Ctrl+1 with me selected",
-                Icon = new IconInfo("\uE712"),
+                Icon = new IconInfo("\uE712"),  // "More" dots
                 MoreCommands = [
                     new CommandContextItem(
-                        new AnonymousCommand(() =>
-                        {
-                            var t = new ToastStatusMessage(new StatusMessage()
-                            {
-                                Message = "Secondary command invoked",
-                                State = MessageState.Warning,
-                            });
-                            t.Show();
-                        })
-                        {
-                            Name = "Secondary command",
-                            Icon = new IconInfo("\uF147"), // Dial 2
-                            Result = CommandResult.KeepOpen(),
-                        })
+                        new ToastCommand("Secondary command invoked", MessageState.Warning) { Name = "Secondary command", Icon = new IconInfo("\uF147") }) // dial 2
                     {
                         Title = "I'm a second command",
                         RequestedShortcut = KeyChordHelpers.FromModifiers(ctrl: true, vkey: VirtualKey.Number1),
                     },
                     new CommandContextItem(
-                        new AnonymousCommand(() =>
-                        {
-                            var t = new ToastStatusMessage(new StatusMessage()
-                            {
-                                Message = "Third command invoked",
-                                State = MessageState.Error,
-                            });
-                            t.Show();
-                        })
-                        {
-                            Name = "Do it",
-                            Icon = new IconInfo("\uF148"), // dial 3
-                            Result = CommandResult.KeepOpen(),
-                        })
+                        new ToastCommand("Third command invoked", MessageState.Error) { Name = "Do 3", Icon = new IconInfo("\uF148") }) // dial 3
                     {
-                        Title = "A third command too",
+                        Title = "We can go deeper...",
                         Icon = new IconInfo("\uF148"),
                         RequestedShortcut = KeyChordHelpers.FromModifiers(ctrl: true, vkey: VirtualKey.Number2),
+                        MoreCommands = [
+                            new CommandContextItem(
+                                new ToastCommand("Nested A invoked") { Name = "Do it", Icon = new IconInfo("A") })
+                            {
+                                Title = "Nested A",
+                                RequestedShortcut = KeyChordHelpers.FromModifiers(alt: true, vkey: VirtualKey.A),
+                            },
+
+                            new CommandContextItem(
+                                new ToastCommand("Nested B invoked") { Name = "Do it", Icon = new IconInfo("B") })
+                            {
+                                Title = "Nested B...",
+                                RequestedShortcut = KeyChordHelpers.FromModifiers(ctrl: true, vkey: VirtualKey.B),
+                                MoreCommands = [
+                                    new CommandContextItem(
+                                        new ToastCommand("Nested C invoked") { Name = "Do it" })
+                                    {
+                                        Title = "You get it",
+                                        RequestedShortcut = KeyChordHelpers.FromModifiers(ctrl: true, vkey: VirtualKey.B),
+                                    }
+                                ],
+                            },
+                        ],
                     }
                 ],
             },
@@ -183,7 +168,6 @@ internal sealed partial class SampleListPage : ListPage
             {
                 Title = "Get the name of the Foreground window",
             },
-
         ];
     }
 }

src/modules/cmdpal/ext/SamplePagesExtension/Pages/ToastCommand.cs

@@ -0,0 +1,23 @@
+// Copyright (c) Microsoft Corporation
+// The Microsoft Corporation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using Microsoft.CommandPalette.Extensions;
+using Microsoft.CommandPalette.Extensions.Toolkit;
+
+namespace SamplePagesExtension;
+
+internal sealed partial class ToastCommand(string message, MessageState state = MessageState.Info) : InvokableCommand
+{
+    public override ICommandResult Invoke()
+    {
+        var t = new ToastStatusMessage(new StatusMessage()
+        {
+            Message = message,
+            State = state,
+        });
+        t.Show();
+
+        return CommandResult.KeepOpen();
+    }
+}

src/modules/cmdpal/extensionsdk/Microsoft.CommandPalette.Extensions.Toolkit/JsonSerializationContext.cs

@@ -16,7 +16,6 @@ namespace Microsoft.CommandPalette.Extensions.Toolkit;
 [JsonSerializable(typeof(List<ChoiceSetSetting>))]
 [JsonSerializable(typeof(Dictionary<string, object>), TypeInfoPropertyName = "Dictionary")]
 [JsonSourceGenerationOptions(UseStringEnumConverter = true, WriteIndented = true)]
-[System.Diagnostics.CodeAnalysis.SuppressMessage("StyleCop.CSharp.MaintainabilityRules", "SA1402:File may only contain a single type", Justification = "Just used here")]
 internal partial class JsonSerializationContext : JsonSerializerContext
 {
 }

src/modules/cmdpal/extensionsdk/Microsoft.CommandPalette.Extensions.Toolkit/ListItem.cs

@@ -61,4 +61,9 @@ public partial class ListItem : CommandItem, IListItem
         : base(command)
     {
     }
+
+    public ListItem()
+        : base()
+    {
+    }
 }

src/modules/colorPicker/ColorPickerUI/Helpers/ColorRepresentationHelper.cs

@@ -243,6 +243,40 @@ namespace ColorPicker.Helpers
                    $", {chromaticityB.ToString(CultureInfo.InvariantCulture)})";
         }
 
+        /// <summary>
+        /// Returns a <see cref="string"/> representation of a Oklab color
+        /// </summary>
+        /// <param name="color">The <see cref="Color"/> for the Oklab color presentation</param>
+        /// <returns>A <see cref="string"/> representation of a Oklab color</returns>
+        private static string ColorToOklab(Color color)
+        {
+            var (lightness, chromaticityA, chromaticityB) = ColorFormatHelper.ConvertToOklabColor(color);
+            lightness = Math.Round(lightness, 2);
+            chromaticityA = Math.Round(chromaticityA, 2);
+            chromaticityB = Math.Round(chromaticityB, 2);
+
+            return $"oklab({lightness.ToString(CultureInfo.InvariantCulture)}" +
+                   $", {chromaticityA.ToString(CultureInfo.InvariantCulture)}" +
+                   $", {chromaticityB.ToString(CultureInfo.InvariantCulture)})";
+        }
+
+        /// <summary>
+        /// Returns a <see cref="string"/> representation of a CIE LCh color
+        /// </summary>
+        /// <param name="color">The <see cref="Color"/> for the CIE LCh color presentation</param>
+        /// <returns>A <see cref="string"/> representation of a CIE LCh color</returns>
+        private static string ColorToOklch(Color color)
+        {
+            var (lightness, chroma, hue) = ColorFormatHelper.ConvertToOklchColor(color);
+            lightness = Math.Round(lightness, 2);
+            chroma = Math.Round(chroma, 2);
+            hue = Math.Round(hue, 2);
+
+            return $"oklch({lightness.ToString(CultureInfo.InvariantCulture)}" +
+                   $", {chroma.ToString(CultureInfo.InvariantCulture)}" +
+                   $", {hue.ToString(CultureInfo.InvariantCulture)})";
+        }
+
         /// <summary>
         /// Returns a <see cref="string"/> representation of a CIE XYZ color
         /// </summary>

src/modules/colorPicker/ColorPickerUI/ViewModels/ColorEditorViewModel.cs

@@ -301,6 +301,12 @@ namespace ColorPicker.ViewModels
                     FormatName = ColorRepresentationType.NCol.ToString(),
                     Convert = (Color color) => ColorRepresentationHelper.GetStringRepresentationFromMediaColor(color, ColorRepresentationType.NCol.ToString()),
                 });
+            _allColorRepresentations.Add(
+                new ColorFormatModel()
+                {
+                    FormatName = ColorRepresentationType.CIEXYZ.ToString(),
+                    Convert = (Color color) => ColorRepresentationHelper.GetStringRepresentationFromMediaColor(color, ColorRepresentationType.CIEXYZ.ToString()),
+                });
             _allColorRepresentations.Add(
                 new ColorFormatModel()
                 {
@@ -310,8 +316,14 @@ namespace ColorPicker.ViewModels
             _allColorRepresentations.Add(
                 new ColorFormatModel()
                 {
-                    FormatName = ColorRepresentationType.CIEXYZ.ToString(),
-                    Convert = (Color color) => ColorRepresentationHelper.GetStringRepresentationFromMediaColor(color, ColorRepresentationType.CIEXYZ.ToString()),
+                    FormatName = ColorRepresentationType.Oklab.ToString(),
+                    Convert = (Color color) => ColorRepresentationHelper.GetStringRepresentationFromMediaColor(color, ColorRepresentationType.Oklab.ToString()),
+                });
+            _allColorRepresentations.Add(
+                new ColorFormatModel()
+                {
+                    FormatName = ColorRepresentationType.Oklch.ToString(),
+                    Convert = (Color color) => ColorRepresentationHelper.GetStringRepresentationFromMediaColor(color, ColorRepresentationType.Oklch.ToString()),
                 });
             _allColorRepresentations.Add(
                 new ColorFormatModel()

src/modules/colorPicker/UnitTest-ColorPickerUI/Helpers/ColorConverterTest.cs

@@ -364,9 +364,6 @@ namespace Microsoft.ColorPicker.UnitTests
         [DataRow("8080FF", 59.20, 33.10, -63.46)] // blue
         [DataRow("BF40BF", 50.10, 65.50, -41.48)] // magenta
         [DataRow("BFBF00", 75.04, -17.35, 76.03)] // yellow
-        [DataRow("008000", 46.23, -51.70, 49.90)] // green
-        [DataRow("8080FF", 59.20, 33.10, -63.46)] // blue
-        [DataRow("BF40BF", 50.10, 65.50, -41.48)] // magenta
         [DataRow("0048BA", 34.35, 27.94, -64.80)] // absolute zero
         [DataRow("B0BF1A", 73.91, -23.39, 71.15)] // acid green
         [DataRow("D0FF14", 93.87, -40.20, 88.97)] // arctic lime
@@ -401,13 +398,121 @@ namespace Microsoft.ColorPicker.UnitTests
             var result = ColorFormatHelper.ConvertToCIELABColor(color);
 
             // lightness[0..100]
-            Assert.AreEqual(Math.Round(result.Lightness, 2), lightness);
+            Assert.AreEqual(lightness, Math.Round(result.Lightness, 2));
 
             // chromaticityA[-128..127]
-            Assert.AreEqual(Math.Round(result.ChromaticityA, 2), chromaticityA);
+            Assert.AreEqual(chromaticityA, Math.Round(result.ChromaticityA, 2));
 
             // chromaticityB[-128..127]
-            Assert.AreEqual(Math.Round(result.ChromaticityB, 2), chromaticityB);
+            Assert.AreEqual(chromaticityB, Math.Round(result.ChromaticityB, 2));
+        }
+
+        // Test data calculated using https://oklch.com (which uses https://github.com/Evercoder/culori)
+        [TestMethod]
+        [DataRow("FFFFFF", 1.00, 0.00, 0.00)] // white
+        [DataRow("808080", 0.6, 0.00, 0.00)] // gray
+        [DataRow("000000", 0.00, 0.00, 0.00)] // black
+        [DataRow("FF0000", 0.628, 0.22, 0.13)] // red
+        [DataRow("008000", 0.52, -0.14, 0.11)] // green
+        [DataRow("80FFFF", 0.928, -0.11, -0.03)] // cyan
+        [DataRow("8080FF", 0.661, 0.03, -0.18)] // blue
+        [DataRow("BF40BF", 0.598, 0.18, -0.11)] // magenta
+        [DataRow("BFBF00", 0.779, -0.06, 0.16)] // yellow
+        [DataRow("0048BA", 0.444, -0.03, -0.19)] // absolute zero
+        [DataRow("B0BF1A", 0.767, -0.07, 0.15)] // acid green
+        [DataRow("D0FF14", 0.934, -0.12, 0.19)] // arctic lime
+        [DataRow("1B4D3E", 0.382, -0.06, 0.01)] // brunswick green
+        [DataRow("FFEF00", 0.935, -0.05, 0.19)] // canary yellow
+        [DataRow("FFA600", 0.794, 0.06, 0.16)] // cheese
+        [DataRow("1A2421", 0.25, -0.02, 0)] // dark jungle green
+        [DataRow("003399", 0.371, -0.02, -0.17)] // dark powder blue
+        [DataRow("D70A53", 0.563, 0.22, 0.04)] // debian red
+        [DataRow("80FFD5", 0.916, -0.13, 0.02)] // fathom secret green
+        [DataRow("EFDFBB", 0.907, 0, 0.05)] // dutch white
+        [DataRow("5218FA", 0.489, 0.05, -0.28)] // han purple
+        [DataRow("FF496C", 0.675, 0.21, 0.05)] // infra red
+        [DataRow("545AA7", 0.5, 0.02, -0.12)] // liberty
+        [DataRow("E6A8D7", 0.804, 0.09, -0.04)] // light orchid
+        [DataRow("ADDFAD", 0.856, -0.07, 0.05)] // light moss green
+        [DataRow("E3F988", 0.942, -0.07, 0.12)] // mindaro
+        public void ColorRGBtoOklabTest(string hexValue, double lightness, double chromaticityA, double chromaticityB)
+        {
+            if (string.IsNullOrWhiteSpace(hexValue))
+            {
+                Assert.IsNotNull(hexValue);
+            }
+
+            Assert.IsTrue(hexValue.Length >= 6);
+
+            var red = int.Parse(hexValue.AsSpan(0, 2), NumberStyles.HexNumber, CultureInfo.InvariantCulture);
+            var green = int.Parse(hexValue.AsSpan(2, 2), NumberStyles.HexNumber, CultureInfo.InvariantCulture);
+            var blue = int.Parse(hexValue.AsSpan(4, 2), NumberStyles.HexNumber, CultureInfo.InvariantCulture);
+
+            var color = Color.FromArgb(255, red, green, blue);
+            var result = ColorFormatHelper.ConvertToOklabColor(color);
+
+            // lightness[0..1]
+            Assert.AreEqual(lightness, Math.Round(result.Lightness, 3));
+
+            // chromaticityA[-0.5..0.5]
+            Assert.AreEqual(chromaticityA, Math.Round(result.ChromaticityA, 2));
+
+            // chromaticityB[-0.5..0.5]
+            Assert.AreEqual(chromaticityB, Math.Round(result.ChromaticityB, 2));
+        }
+
+        // Test data calculated using https://oklch.com (which uses https://github.com/Evercoder/culori)
+        [TestMethod]
+        [DataRow("FFFFFF", 1.00, 0.00, 0.00)] // white
+        [DataRow("808080", 0.6, 0.00, 0.00)] // gray
+        [DataRow("000000", 0.00, 0.00, 0.00)] // black
+        [DataRow("FF0000", 0.628, 0.258, 29.23)] // red
+        [DataRow("008000", 0.52, 0.177, 142.5)] // green
+        [DataRow("80FFFF", 0.928, 0.113, 195.38)] // cyan
+        [DataRow("8080FF", 0.661, 0.184, 280.13)] // blue
+        [DataRow("BF40BF", 0.598, 0.216, 327.86)] // magenta
+        [DataRow("BFBF00", 0.779, 0.17, 109.77)] // yellow
+        [DataRow("0048BA", 0.444, 0.19, 260.86)] // absolute zero
+        [DataRow("B0BF1A", 0.767, 0.169, 115.4)] // acid green
+        [DataRow("D0FF14", 0.934, 0.224, 122.28)] // arctic lime
+        [DataRow("1B4D3E", 0.382, 0.06, 170.28)] // brunswick green
+        [DataRow("FFEF00", 0.935, 0.198, 104.67)] // canary yellow
+        [DataRow("FFA600", 0.794, 0.171, 71.19)] // cheese
+        [DataRow("1A2421", 0.25, 0.015, 174.74)] // dark jungle green
+        [DataRow("003399", 0.371, 0.173, 262.12)] // dark powder blue
+        [DataRow("D70A53", 0.563, 0.222, 11.5)] // debian red
+        [DataRow("80FFD5", 0.916, 0.129, 169.38)] // fathom secret green
+        [DataRow("EFDFBB", 0.907, 0.05, 86.89)] // dutch white
+        [DataRow("5218FA", 0.489, 0.286, 279.13)] // han purple
+        [DataRow("FF496C", 0.675, 0.217, 14.37)] // infra red
+        [DataRow("545AA7", 0.5, 0.121, 277.7)] // liberty
+        [DataRow("E6A8D7", 0.804, 0.095, 335.4)] // light orchid
+        [DataRow("ADDFAD", 0.856, 0.086, 144.78)] // light moss green
+        [DataRow("E3F988", 0.942, 0.141, 118.24)] // mindaro
+        public void ColorRGBtoOklchTest(string hexValue, double lightness, double chroma, double hue)
+        {
+            if (string.IsNullOrWhiteSpace(hexValue))
+            {
+                Assert.IsNotNull(hexValue);
+            }
+
+            Assert.IsTrue(hexValue.Length >= 6);
+
+            var red = int.Parse(hexValue.AsSpan(0, 2), NumberStyles.HexNumber, CultureInfo.InvariantCulture);
+            var green = int.Parse(hexValue.AsSpan(2, 2), NumberStyles.HexNumber, CultureInfo.InvariantCulture);
+            var blue = int.Parse(hexValue.AsSpan(4, 2), NumberStyles.HexNumber, CultureInfo.InvariantCulture);
+
+            var color = Color.FromArgb(255, red, green, blue);
+            var result = ColorFormatHelper.ConvertToOklchColor(color);
+
+            // lightness[0..1]
+            Assert.AreEqual(lightness, Math.Round(result.Lightness, 3));
+
+            // chroma[0..0.5]
+            Assert.AreEqual(chroma, Math.Round(result.Chroma, 3));
+
+            // hue[0°..360°]
+            Assert.AreEqual(hue, Math.Round(result.Hue, 2));
         }
 
         // The following results are computed using LittleCMS2, an open-source color management engine,
@@ -428,9 +533,6 @@ namespace Microsoft.ColorPicker.UnitTests
         [DataRow("8080FF", 34.6688, 27.2469, 98.0434)] // blue
         [DataRow("BF40BF", 32.7217, 18.5062, 51.1405)] // magenta
         [DataRow("BFBF00", 40.1154, 48.3384, 7.2171)] // yellow
-        [DataRow("008000", 7.7188, 15.4377, 2.5729)] // green
-        [DataRow("8080FF", 34.6688, 27.2469, 98.0434)] // blue
-        [DataRow("BF40BF", 32.7217, 18.5062, 51.1405)] // magenta
         [DataRow("0048BA", 11.1792, 8.1793, 47.4455)] // absolute zero
         [DataRow("B0BF1A", 36.7205, 46.5663, 8.0311)] // acid green
         [DataRow("D0FF14", 61.8965, 84.9797, 13.8037)] // arctic lime

src/modules/colorPicker/UnitTest-ColorPickerUI/Helpers/ColorRepresentationHelperTest.cs

@@ -23,8 +23,10 @@ namespace Microsoft.ColorPicker.UnitTests
         [DataRow("HSV", "hsv(0, 0%, 0%)")]
         [DataRow("HWB", "hwb(0, 0%, 100%)")]
         [DataRow("RGB", "rgb(0, 0, 0)")]
-        [DataRow("CIELAB", "CIELab(0, 0, 0)")]
         [DataRow("CIEXYZ", "XYZ(0, 0, 0)")]
+        [DataRow("CIELAB", "CIELab(0, 0, 0)")]
+        [DataRow("Oklab", "oklab(0, 0, 0)")]
+        [DataRow("Oklch", "oklch(0, 0, 0)")]
         [DataRow("VEC4", "(0f, 0f, 0f, 1f)")]
         [DataRow("Decimal", "0")]
         [DataRow("HEX Int", "0xFF000000")]

src/modules/keyboardmanager/KeyboardManagerEditorLibraryWrapper/KeyboardManagerEditorLibraryWrapper.cpp

@@ -1,20 +1,709 @@
 #include "pch.h"
 #include "KeyboardManagerEditorLibraryWrapper.h"
+#include <algorithm>
+#include <cstring>
+#include <vector>
+#include <string>
+#include <memory>
 
 #include <common/utils/logger_helper.h>
 #include <keyboardmanager/KeyboardManagerEditor/KeyboardManagerEditor.h>
+#include <keyboardmanager/KeyboardManagerEditorLibrary/EditorHelpers.h>
+#include <common/interop/keyboard_layout.h>
 
-// Test function to call the remapping helper function
-
-bool CheckIfRemappingsAreValid()
+extern "C"
 {
-    RemapBuffer remapBuffer;
+    void* CreateMappingConfiguration()
+    {
+        return new MappingConfiguration();
+    }
 
-    // Mock valid key to key remappings
-    remapBuffer.push_back(RemapBufferRow{ RemapBufferItem({ (DWORD)0x41, (DWORD)0x42 }), std::wstring() });
-    remapBuffer.push_back(RemapBufferRow{ RemapBufferItem({ (DWORD)0x42, (DWORD)0x43 }), std::wstring() });
+    void DestroyMappingConfiguration(void* config)
+    {
+        delete static_cast<MappingConfiguration*>(config);
+    }
 
-    auto result = LoadingAndSavingRemappingHelper::CheckIfRemappingsAreValid(remapBuffer);
+    bool LoadMappingSettings(void* config)
+    {
+        return static_cast<MappingConfiguration*>(config)->LoadSettings();
+    }
 
-    return result == ShortcutErrorType::NoError;
+    bool SaveMappingSettings(void* config)
+    {
+        return static_cast<MappingConfiguration*>(config)->SaveSettingsToFile();
+    }
+
+    wchar_t* AllocateAndCopyString(const std::wstring& str)
+    {
+        size_t len = str.length();
+        wchar_t* buffer = new wchar_t[len + 1];
+        wcscpy_s(buffer, len + 1, str.c_str());
+        return buffer;
+    }
+
+    int GetSingleKeyRemapCount(void* config)
+    {
+        auto mapping = static_cast<MappingConfiguration*>(config);
+        return static_cast<int>(mapping->singleKeyReMap.size());
+    }
+
+    bool GetSingleKeyRemap(void* config, int index, SingleKeyMapping* mapping)
+    {
+        auto mappingConfig = static_cast<MappingConfiguration*>(config);
+
+        std::vector<std::pair<DWORD, KeyShortcutTextUnion>> allMappings;
+
+        for (const auto& kv : mappingConfig->singleKeyReMap)
+        {
+            allMappings.push_back(kv);
+        }
+
+        if (index < 0 || index >= allMappings.size())
+        {
+            return false;
+        }
+
+        const auto& kv = allMappings[index];
+        mapping->originalKey = static_cast<int>(kv.first);
+
+        // Remap to single key
+        if (kv.second.index() == 0)
+        {
+            mapping->targetKey = AllocateAndCopyString(std::to_wstring(std::get<DWORD>(kv.second)));
+            mapping->isShortcut = false;
+        }
+        // Remap to shortcut
+        else if (kv.second.index() == 1)
+        {
+            mapping->targetKey = AllocateAndCopyString(std::get<Shortcut>(kv.second).ToHstringVK().c_str());
+            mapping->isShortcut = true;
+        }
+        else
+        {
+            mapping->targetKey = AllocateAndCopyString(L"");
+            mapping->isShortcut = false;
+        }
+
+        return true;
+    }
+
+    int GetSingleKeyToTextRemapCount(void* config)
+    {
+        auto mapping = static_cast<MappingConfiguration*>(config);
+        return static_cast<int>(mapping->singleKeyToTextReMap.size());
+    }
+
+    bool GetSingleKeyToTextRemap(void* config, int index, KeyboardTextMapping* mapping)
+    {
+        auto mappingConfig = static_cast<MappingConfiguration*>(config);
+
+        if (index < 0 || index >= mappingConfig->singleKeyToTextReMap.size())
+        {
+            return false;
+        }
+
+        auto it = mappingConfig->singleKeyToTextReMap.begin();
+        std::advance(it, index);
+
+        mapping->originalKey = static_cast<int>(it->first);
+        std::wstring text = std::get<std::wstring>(it->second);
+        mapping->targetText = AllocateAndCopyString(text);
+
+        return true;
+    }
+
+    int GetShortcutRemapCountByType(void* config, int operationType)
+    {
+        auto mapping = static_cast<MappingConfiguration*>(config);
+        int count = 0;
+
+        for (const auto& kv : mapping->osLevelShortcutReMap)
+        {
+            bool shouldCount = false;
+
+
+            if (operationType == 0)
+            {
+                if ((kv.second.targetShortcut.index() == 0) ||
+                    (kv.second.targetShortcut.index() == 1 &&
+                     std::get<Shortcut>(kv.second.targetShortcut).operationType == Shortcut::OperationType::RemapShortcut))
+                {
+                    shouldCount = true;
+                }
+            }
+            else if (operationType == 1)
+            {
+
+                if (kv.second.targetShortcut.index() == 1 &&
+                    std::get<Shortcut>(kv.second.targetShortcut).operationType == Shortcut::OperationType::RunProgram)
+                {
+                    shouldCount = true;
+                }
+            }
+            else if (operationType == 2)
+            {
+                if (kv.second.targetShortcut.index() == 1 &&
+                    std::get<Shortcut>(kv.second.targetShortcut).operationType == Shortcut::OperationType::OpenURI)
+                {
+                    shouldCount = true;
+                }
+            }
+            else if (operationType == 3)
+            {
+                if (kv.second.targetShortcut.index() == 2)
+                {
+                    shouldCount = true;
+                }
+            }
+
+            if (shouldCount)
+            {
+                count++;
+            }
+        }
+
+        for (const auto& appMap : mapping->appSpecificShortcutReMap)
+        {
+            for (const auto& shortcutKv : appMap.second)
+            {
+                bool shouldCount = false;
+
+                if (operationType == 0)
+                {
+                    if ((shortcutKv.second.targetShortcut.index() == 0) ||
+                        (shortcutKv.second.targetShortcut.index() == 1 &&
+                         std::get<Shortcut>(shortcutKv.second.targetShortcut).operationType == Shortcut::OperationType::RemapShortcut))
+                    {
+                        shouldCount = true;
+                    }
+                }
+                else if (operationType == 1)
+                {
+                    if (shortcutKv.second.targetShortcut.index() == 1 &&
+                        std::get<Shortcut>(shortcutKv.second.targetShortcut).operationType == Shortcut::OperationType::RunProgram)
+                    {
+                        shouldCount = true;
+                    }
+                }
+                else if (operationType == 2)
+                {
+                    if (shortcutKv.second.targetShortcut.index() == 1 &&
+                        std::get<Shortcut>(shortcutKv.second.targetShortcut).operationType == Shortcut::OperationType::OpenURI)
+                    {
+                        shouldCount = true;
+                    }
+                }
+                else if (operationType == 3)
+                {
+                    if (shortcutKv.second.targetShortcut.index() == 2)
+                    {
+                        shouldCount = true;
+                    }
+                }
+
+                if (shouldCount)
+                {
+                    count++;
+                }
+            }
+        }
+
+        return count;
+    }
+
+bool GetShortcutRemapByType(void* config, int operationType, int index, ShortcutMapping* mapping)
+    {
+        auto mappingConfig = static_cast<MappingConfiguration*>(config);
+
+        std::vector<std::tuple<Shortcut, KeyShortcutTextUnion, std::wstring>> filteredMappings;
+
+        for (const auto& kv : mappingConfig->osLevelShortcutReMap)
+        {
+            bool shouldAdd = false;
+
+            if (operationType == 0) // RemapShortcut
+            {
+                if ((kv.second.targetShortcut.index() == 0) ||
+                    (kv.second.targetShortcut.index() == 1 &&
+                     std::get<Shortcut>(kv.second.targetShortcut).operationType == Shortcut::OperationType::RemapShortcut))
+                {
+                    shouldAdd = true;
+                }
+            }
+            else if (operationType == 1) // RunProgram
+            {
+                if (kv.second.targetShortcut.index() == 1 &&
+                    std::get<Shortcut>(kv.second.targetShortcut).operationType == Shortcut::OperationType::RunProgram)
+                {
+                    shouldAdd = true;
+                }
+            }
+            else if (operationType == 2) // OpenURI
+            {
+                if (kv.second.targetShortcut.index() == 1 &&
+                    std::get<Shortcut>(kv.second.targetShortcut).operationType == Shortcut::OperationType::OpenURI)
+                {
+                    shouldAdd = true;
+                }
+            }
+            else if (operationType == 3)
+            {
+                if (kv.second.targetShortcut.index() == 2)
+                {
+                    shouldAdd = true;
+                }
+            }
+
+            if (shouldAdd)
+            {
+                filteredMappings.push_back(std::make_tuple(kv.first, kv.second.targetShortcut, L""));
+            }
+        }
+
+        for (const auto& appKv : mappingConfig->appSpecificShortcutReMap)
+        {
+            for (const auto& shortcutKv : appKv.second)
+            {
+                bool shouldAdd = false;
+
+                if (operationType == 0) // RemapShortcut
+                {
+                    if ((shortcutKv.second.targetShortcut.index() == 0) ||
+                        (shortcutKv.second.targetShortcut.index() == 1 &&
+                         std::get<Shortcut>(shortcutKv.second.targetShortcut).operationType == Shortcut::OperationType::RemapShortcut))
+                    {
+                        shouldAdd = true;
+                    }
+                }
+                else if (operationType == 1) // RunProgram
+                {
+                    if (shortcutKv.second.targetShortcut.index() == 1 &&
+                        std::get<Shortcut>(shortcutKv.second.targetShortcut).operationType == Shortcut::OperationType::RunProgram)
+                    {
+                        shouldAdd = true;
+                    }
+                }
+                else if (operationType == 2) // OpenURI
+                {
+                    if (shortcutKv.second.targetShortcut.index() == 1 &&
+                        std::get<Shortcut>(shortcutKv.second.targetShortcut).operationType == Shortcut::OperationType::OpenURI)
+                    {
+                        shouldAdd = true;
+                    }
+                }
+                else if (operationType == 3)
+                {
+                    if (shortcutKv.second.targetShortcut.index() == 2)
+                    {
+                        shouldAdd = true;
+                    }
+                }
+
+                if (shouldAdd)
+                {
+                    filteredMappings.push_back(std::make_tuple(
+                        shortcutKv.first, shortcutKv.second.targetShortcut, appKv.first));
+                }
+            }
+        }
+
+        if (index < 0 || index >= filteredMappings.size())
+        {
+            return false;
+        }
+
+        const auto& [origShortcut, targetShortcutUnion, app] = filteredMappings[index];
+
+        std::wstring origKeysStr = origShortcut.ToHstringVK().c_str();
+        mapping->originalKeys = AllocateAndCopyString(origKeysStr);
+        mapping->targetApp = AllocateAndCopyString(app);
+
+        if (targetShortcutUnion.index() == 0)
+        {
+            DWORD targetKey = std::get<DWORD>(targetShortcutUnion);
+            mapping->targetKeys = AllocateAndCopyString(std::to_wstring(targetKey));
+            mapping->operationType = 0;
+            mapping->targetText = AllocateAndCopyString(L"");
+            mapping->programPath = AllocateAndCopyString(L"");
+            mapping->programArgs = AllocateAndCopyString(L"");
+            mapping->uriToOpen = AllocateAndCopyString(L"");
+        }
+        else if (targetShortcutUnion.index() == 1)
+        {
+            Shortcut targetShortcut = std::get<Shortcut>(targetShortcutUnion);
+            std::wstring targetKeysStr = targetShortcut.ToHstringVK().c_str();
+
+            mapping->operationType = static_cast<int>(targetShortcut.operationType);
+
+            if (targetShortcut.operationType == Shortcut::OperationType::RunProgram)
+            {
+                mapping->targetKeys = AllocateAndCopyString(targetKeysStr);
+                mapping->targetText = AllocateAndCopyString(L"");
+                mapping->programPath = AllocateAndCopyString(targetShortcut.runProgramFilePath);
+                mapping->programArgs = AllocateAndCopyString(targetShortcut.runProgramArgs);
+                mapping->uriToOpen = AllocateAndCopyString(L"");
+            }
+            else if (targetShortcut.operationType == Shortcut::OperationType::OpenURI)
+            {
+                mapping->targetKeys = AllocateAndCopyString(targetKeysStr);
+                mapping->targetText = AllocateAndCopyString(L"");
+                mapping->programPath = AllocateAndCopyString(L"");
+                mapping->programArgs = AllocateAndCopyString(L"");
+                mapping->uriToOpen = AllocateAndCopyString(targetShortcut.uriToOpen);
+            }
+            else
+            {
+                mapping->targetKeys = AllocateAndCopyString(targetKeysStr);
+                mapping->targetText = AllocateAndCopyString(L"");
+                mapping->programPath = AllocateAndCopyString(L"");
+                mapping->programArgs = AllocateAndCopyString(L"");
+                mapping->uriToOpen = AllocateAndCopyString(L"");
+            }
+        }
+        else if (targetShortcutUnion.index() == 2)
+        {
+            std::wstring text = std::get<std::wstring>(targetShortcutUnion);
+            mapping->targetKeys = AllocateAndCopyString(L"");
+            mapping->operationType = 0;
+            mapping->targetText = AllocateAndCopyString(text);
+            mapping->programPath = AllocateAndCopyString(L"");
+            mapping->programArgs = AllocateAndCopyString(L"");
+            mapping->uriToOpen = AllocateAndCopyString(L"");
+        }
+
+        return true;
+    }
+
+    int GetShortcutRemapCount(void* config)
+    {
+        auto mapping = static_cast<MappingConfiguration*>(config);
+        int count = static_cast<int>(mapping->osLevelShortcutReMap.size());
+
+        for (const auto& appMap : mapping->appSpecificShortcutReMap)
+        {
+            count += static_cast<int>(appMap.second.size());
+        }
+
+        return count;
+    }
+
+    bool GetShortcutRemap(void* config, int index, ShortcutMapping* mapping)
+    {
+        auto mappingConfig = static_cast<MappingConfiguration*>(config);
+
+        std::vector<std::tuple<Shortcut, KeyShortcutTextUnion, std::wstring>> allMappings;
+
+        for (const auto& kv : mappingConfig->osLevelShortcutReMap)
+        {
+            allMappings.push_back(std::make_tuple(kv.first, kv.second.targetShortcut, L""));
+        }
+
+        for (const auto& appKv : mappingConfig->appSpecificShortcutReMap)
+        {
+            for (const auto& shortcutKv : appKv.second)
+            {
+                allMappings.push_back(std::make_tuple(
+                    shortcutKv.first, shortcutKv.second.targetShortcut, appKv.first));
+            }
+        }
+
+        if (index < 0 || index >= allMappings.size())
+        {
+            return false;
+        }
+
+        const auto& [origShortcut, targetShortcutUnion, app] = allMappings[index];
+
+        std::wstring origKeysStr = origShortcut.ToHstringVK().c_str();
+        mapping->originalKeys = AllocateAndCopyString(origKeysStr);
+
+        mapping->targetApp = AllocateAndCopyString(app);
+
+        if (targetShortcutUnion.index() == 0)
+        {
+            DWORD targetKey = std::get<DWORD>(targetShortcutUnion);
+            mapping->targetKeys = AllocateAndCopyString(std::to_wstring(targetKey));
+            mapping->operationType = 0;
+            mapping->targetText = AllocateAndCopyString(L"");
+            mapping->programPath = AllocateAndCopyString(L"");
+            mapping->programArgs = AllocateAndCopyString(L"");
+            mapping->uriToOpen = AllocateAndCopyString(L"");
+        }
+        else if (targetShortcutUnion.index() == 1)
+        {
+            Shortcut targetShortcut = std::get<Shortcut>(targetShortcutUnion);
+            std::wstring targetKeysStr = targetShortcut.ToHstringVK().c_str();
+
+            mapping->operationType = static_cast<int>(targetShortcut.operationType);
+
+            if (targetShortcut.operationType == Shortcut::OperationType::RunProgram)
+            {
+                mapping->targetKeys = AllocateAndCopyString(targetKeysStr);
+                mapping->targetText = AllocateAndCopyString(L"");
+                mapping->programPath = AllocateAndCopyString(targetShortcut.runProgramFilePath);
+                mapping->programArgs = AllocateAndCopyString(targetShortcut.runProgramArgs);
+                mapping->uriToOpen = AllocateAndCopyString(L"");
+            }
+            else if (targetShortcut.operationType == Shortcut::OperationType::OpenURI)
+            {
+                mapping->targetKeys = AllocateAndCopyString(targetKeysStr);
+                mapping->targetText = AllocateAndCopyString(L"");
+                mapping->programPath = AllocateAndCopyString(L"");
+                mapping->programArgs = AllocateAndCopyString(L"");
+                mapping->uriToOpen = AllocateAndCopyString(targetShortcut.uriToOpen);
+            }
+            else
+            {
+                mapping->targetKeys = AllocateAndCopyString(targetKeysStr);
+                mapping->targetText = AllocateAndCopyString(L"");
+                mapping->programPath = AllocateAndCopyString(L"");
+                mapping->programArgs = AllocateAndCopyString(L"");
+                mapping->uriToOpen = AllocateAndCopyString(L"");
+            }
+        }
+        else if (targetShortcutUnion.index() == 2)
+        {
+            std::wstring text = std::get<std::wstring>(targetShortcutUnion);
+            mapping->targetKeys = AllocateAndCopyString(L"");
+            mapping->operationType = 0;
+            mapping->targetText = AllocateAndCopyString(text);
+            mapping->programPath = AllocateAndCopyString(L"");
+            mapping->programArgs = AllocateAndCopyString(L"");
+            mapping->uriToOpen = AllocateAndCopyString(L"");
+        }
+
+        return true;
+    }
+
+    void FreeString(wchar_t* str)
+    {
+        delete[] str;
+    }
+
+    bool AddSingleKeyRemap(void* config, int originalKey, int targetKey)
+    {
+        auto mappingConfig = static_cast<MappingConfiguration*>(config);
+        return mappingConfig->AddSingleKeyRemap(static_cast<DWORD>(originalKey), static_cast<DWORD>(targetKey));
+    }
+
+    bool AddSingleKeyToTextRemap(void* config, int originalKey, const wchar_t* text)
+    {
+        auto mappingConfig = static_cast<MappingConfiguration*>(config);
+
+        if (text == nullptr)
+        {
+            return false;
+        }
+
+        return mappingConfig->AddSingleKeyToTextRemap(static_cast<DWORD>(originalKey), text);
+    }
+
+    bool AddSingleKeyToShortcutRemap(void* config, int originalKey, const wchar_t* targetKeys)
+    {
+        auto mappingConfig = static_cast<MappingConfiguration*>(config);
+
+        if (!targetKeys)
+        {
+            return false;
+        }
+
+        Shortcut targetShortcut(targetKeys);
+
+        return mappingConfig->AddSingleKeyRemap(static_cast<DWORD>(originalKey), targetShortcut);
+    }
+
+    bool AddShortcutRemap(void* config,
+                          const wchar_t* originalKeys,
+                          const wchar_t* targetKeys,
+                          const wchar_t* targetApp,
+                          int operationType = 0)
+    {
+        auto mappingConfig = static_cast<MappingConfiguration*>(config);
+
+        Shortcut originalShortcut(originalKeys);
+
+        KeyShortcutTextUnion targetShortcut;
+
+        switch (operationType)
+        {
+        case 3:
+            targetShortcut = std::wstring(targetKeys);
+            break;
+        
+        default:
+            targetShortcut = Shortcut(targetKeys);
+            std::get<Shortcut>(targetShortcut).operationType = static_cast<Shortcut::OperationType>(operationType);
+            break;
+        }
+
+        std::wstring app(targetApp ? targetApp : L"");
+
+        if (app.empty())
+        {
+            return mappingConfig->AddOSLevelShortcut(originalShortcut, targetShortcut);
+        }
+        else
+        {
+            return mappingConfig->AddAppSpecificShortcut(app, originalShortcut, targetShortcut);
+        }
+    }
+
+    void GetKeyDisplayName(int keyCode, wchar_t* keyName, int maxCount)
+    {
+        if (keyName == nullptr || maxCount <= 0)
+        {
+            return;
+        }
+        LayoutMap layoutMap;
+        std::wstring name = layoutMap.GetKeyName(static_cast<DWORD>(keyCode));
+        wcsncpy_s(keyName, maxCount, name.c_str(), _TRUNCATE);
+    }
+
+    int GetKeyCodeFromName(const wchar_t* keyName)
+    {
+        if (keyName == nullptr)
+        {
+            return 0;
+        }
+
+        LayoutMap layoutMap;
+        std::wstring name(keyName);
+        return static_cast<int>(layoutMap.GetKeyFromName(name));
+    }
+
+    // Function to get the type of a key (Win, Ctrl, Alt, Shift, or Action)
+    int GetKeyType(int key)
+    {
+        return static_cast<int>(Helpers::GetKeyType(static_cast<DWORD>(key)));
+    }
+
+    // Function to check if a shortcut is illegal
+    bool IsShortcutIllegal(const wchar_t* shortcutKeys)
+    {
+        if (!shortcutKeys)
+        {
+            return false;
+        }
+
+        Shortcut shortcut(shortcutKeys);
+
+        ShortcutErrorType result = EditorHelpers::IsShortcutIllegal(shortcut);
+
+        // Return true if an error was detected (anything other than NoError)
+        return result != ShortcutErrorType::NoError;
+    }
+
+    // Function to check if two shortcuts are equal
+    bool AreShortcutsEqual(const wchar_t* lShort, const wchar_t* rShort)
+    {
+        if (!lShort || !rShort)
+        {
+            return false;
+        }
+
+        Shortcut lhs(lShort);
+        Shortcut rhs(rShort);
+
+        return lhs == rhs;
+    }
+
+    // Function to delete a single key remapping
+    bool DeleteSingleKeyRemap(void* config, int originalKey)
+    {
+        auto mappingConfig = static_cast<MappingConfiguration*>(config);
+
+        // Find and delete the single key remapping
+        auto it = mappingConfig->singleKeyReMap.find(static_cast<DWORD>(originalKey));
+        if (it != mappingConfig->singleKeyReMap.end())
+        {
+            mappingConfig->singleKeyReMap.erase(it);
+            return true;
+        }
+
+        return false;
+    }
+
+    bool DeleteSingleKeyToTextRemap(void* config, int originalKey)
+    {
+        auto mappingConfig = static_cast<MappingConfiguration*>(config);
+        auto it = mappingConfig->singleKeyToTextReMap.find(originalKey);
+        if (it != mappingConfig->singleKeyToTextReMap.end())
+        {
+            mappingConfig->singleKeyToTextReMap.erase(it);
+            return true;
+        }
+        return false;
+    }
+
+    // Function to delete a shortcut remapping
+    bool DeleteShortcutRemap(void* config, const wchar_t* originalKeys, const wchar_t* targetApp)
+    {
+        auto mappingConfig = static_cast<MappingConfiguration*>(config);
+
+        if (originalKeys == nullptr)
+        {
+            return false;
+        }
+
+        std::wstring appName = targetApp ? targetApp : L"";
+        Shortcut shortcut(originalKeys);
+
+        // Determine the type of remapping to delete based on the app name
+        if (appName.empty())
+        {
+            // Delete OS level shortcut mapping
+            auto it = mappingConfig->osLevelShortcutReMap.find(shortcut);
+            if (it != mappingConfig->osLevelShortcutReMap.end())
+            {
+                mappingConfig->osLevelShortcutReMap.erase(it);
+                return true;
+            }
+        }
+        else
+        {
+            // Delete app-specific shortcut mapping
+            auto appIt = mappingConfig->appSpecificShortcutReMap.find(appName);
+            if (appIt != mappingConfig->appSpecificShortcutReMap.end())
+            {
+                auto shortcutIt = appIt->second.find(shortcut);
+                if (shortcutIt != appIt->second.end())
+                {
+                    appIt->second.erase(shortcutIt);
+
+                    // If the app-specific mapping is empty, remove the app entry
+                    if (appIt->second.empty())
+                    {
+                        mappingConfig->appSpecificShortcutReMap.erase(appIt);
+                    }
+
+                    return true;
+                }
+            }
+        }
+
+        return false;
+    }
 }
+
+// Get the list of keyboard keys in Editor
+int GetKeyboardKeysList(bool isShortcut, KeyNamePair* keyList, int maxCount)
+{
+    if (keyList == nullptr || maxCount <= 0)
+    {
+        return 0;
+    }
+
+    LayoutMap layoutMap;
+    auto keyNameList = layoutMap.GetKeyNameList(isShortcut);
+
+    int count = (std::min)(static_cast<int>(keyNameList.size()), maxCount);
+
+    // Transfer the key list to the output struct format
+    for (int i = 0; i < count; ++i)
+    {
+        keyList[i].keyCode = static_cast<int>(keyNameList[i].first);
+        wcsncpy_s(keyList[i].keyName, keyNameList[i].second.c_str(), _countof(keyList[i].keyName) - 1);
+    }
+
+    return count;
+}

src/modules/keyboardmanager/KeyboardManagerEditorLibraryWrapper/KeyboardManagerEditorLibraryWrapper.h

@@ -4,4 +4,77 @@
 #include <keyboardmanager/common/Input.h>
 #include <keyboardmanager/common/MappingConfiguration.h>
 
-extern "C" __declspec(dllexport) bool CheckIfRemappingsAreValid();
+struct KeyNamePair
+{
+    int keyCode;
+    wchar_t keyName[64];
+};
+
+struct SingleKeyMapping
+{
+    int originalKey;
+    wchar_t* targetKey;
+    bool isShortcut;
+};
+
+struct KeyboardTextMapping
+{
+    int originalKey;
+    wchar_t* targetText;
+};
+
+struct ShortcutMapping
+{
+    wchar_t* originalKeys;
+    wchar_t* targetKeys;
+    wchar_t* targetApp;
+    int operationType;
+    wchar_t* targetText;
+    wchar_t* programPath;
+    wchar_t* programArgs;
+    wchar_t* uriToOpen;
+};
+
+extern "C"
+{
+    __declspec(dllexport) void* CreateMappingConfiguration();
+    __declspec(dllexport) void DestroyMappingConfiguration(void* config);
+    __declspec(dllexport) bool LoadMappingSettings(void* config);
+    __declspec(dllexport) bool SaveMappingSettings(void* config);
+
+    __declspec(dllexport) int GetSingleKeyRemapCount(void* config);
+    __declspec(dllexport) bool GetSingleKeyRemap(void* config, int index, SingleKeyMapping* mapping);
+
+    __declspec(dllexport) int GetSingleKeyToTextRemapCount(void* config);
+    __declspec(dllexport) bool GetSingleKeyToTextRemap(void* config, int index, KeyboardTextMapping* mapping);
+
+    __declspec(dllexport) int GetShortcutRemapCountByType(void* config, int operationType);
+    __declspec(dllexport) bool GetShortcutRemapByType(void* config, int operationType, int index, ShortcutMapping* mapping);
+   
+    __declspec(dllexport) int GetShortcutRemapCount(void* config);
+    __declspec(dllexport) bool GetShortcutRemap(void* config, int index, ShortcutMapping* mapping);
+
+    __declspec(dllexport) bool AddSingleKeyRemap(void* config, int originalKey, int targetKey);
+    __declspec(dllexport) bool AddSingleKeyToTextRemap(void* config, int originalKey, const wchar_t* text);
+    __declspec(dllexport) bool AddSingleKeyToShortcutRemap(void* config,
+                                                           int originalKey,
+                                                           const wchar_t* targetKeys);
+    __declspec(dllexport) bool AddShortcutRemap(void* config,
+                                                const wchar_t* originalKeys,
+                                                const wchar_t* targetKeys,
+                                                const wchar_t* targetApp,
+                                                int operationType);
+
+    __declspec(dllexport) void GetKeyDisplayName(int keyCode, wchar_t* keyName, int maxCount);
+    __declspec(dllexport) int GetKeyCodeFromName(const wchar_t* keyName);
+    __declspec(dllexport) void FreeString(wchar_t* str);
+    __declspec(dllexport) int GetKeyType(int keyCode);
+
+    __declspec(dllexport) bool IsShortcutIllegal(const wchar_t* shortcutKeys);
+    __declspec(dllexport) bool AreShortcutsEqual(const wchar_t* lShort, const wchar_t* rShort);
+
+    __declspec(dllexport) bool DeleteSingleKeyRemap(void* config, int originalKey);
+    __declspec(dllexport) bool DeleteSingleKeyToTextRemap(void* config, int originalKey);
+    __declspec(dllexport) bool DeleteShortcutRemap(void* config, const wchar_t* originalKeys, const wchar_t* targetApp);
+}
+extern "C" __declspec(dllexport) int GetKeyboardKeysList(bool isShortcut, KeyNamePair* keyList, int maxCount);

src/modules/keyboardmanager/KeyboardManagerEditorUI/App.xaml

@@ -8,7 +8,8 @@
         <ResourceDictionary>
             <ResourceDictionary.MergedDictionaries>
                 <XamlControlsResources xmlns="using:Microsoft.UI.Xaml.Controls" />
-                <!--  Other merged dictionaries here  -->
+                <ResourceDictionary Source="/Styles/KeyVisual.xaml" />
+                <ResourceDictionary Source="/Styles/CommonStyle.xaml" />
             </ResourceDictionary.MergedDictionaries>
             <!--  Other app resources here  -->
         </ResourceDictionary>

src/modules/keyboardmanager/KeyboardManagerEditorUI/App.xaml.cs

@@ -7,7 +7,11 @@ using System.Collections.Generic;
 using System.IO;
 using System.Linq;
 using System.Runtime.InteropServices.WindowsRuntime;
+using System.Threading.Tasks;
+using KeyboardManagerEditorUI.Helpers;
 using ManagedCommon;
+using Microsoft.UI;
+using Microsoft.UI.Dispatching;
 using Microsoft.UI.Xaml;
 using Microsoft.UI.Xaml.Controls;
 using Microsoft.UI.Xaml.Controls.Primitives;
@@ -35,8 +39,13 @@ namespace KeyboardManagerEditorUI
         public App()
         {
             this.InitializeComponent();
-            Logger.InitializeLogger("\\Keyboard Manager\\WinUI3Editor\\Logs");
-            Logger.LogInfo("keyboard-manager WinUI3 editor logger is initialized");
+
+            Task.Run(() =>
+            {
+                Logger.InitializeLogger("\\Keyboard Manager\\WinUI3Editor\\Logs");
+            });
+
+            UnhandledException += App_UnhandledException;
         }
 
         /// <summary>
@@ -46,10 +55,37 @@ namespace KeyboardManagerEditorUI
         protected override void OnLaunched(Microsoft.UI.Xaml.LaunchActivatedEventArgs args)
         {
             window = new MainWindow();
-            window.Activate();
+
+            var appWindow = window.AppWindow;
+
+            var windowSize = new Windows.Graphics.SizeInt32(EditorConstants.DefaultEditorWindowWidth, EditorConstants.DefaultEditorWindowHeight);
+            appWindow.Resize(windowSize);
+
+            window.DispatcherQueue.TryEnqueue(() =>
+            {
+                window.Activate();
+                window.DispatcherQueue.TryEnqueue(DispatcherQueuePriority.Low, () =>
+                {
+                    (window.Content as FrameworkElement)?.UpdateLayout();
+                });
+            });
+
             Logger.LogInfo("keyboard-manager WinUI3 editor window is launched");
         }
 
+        /// <summary>
+        /// Log the unhandled exception for the editor.
+        /// </summary>
+        private void App_UnhandledException(object sender, Microsoft.UI.Xaml.UnhandledExceptionEventArgs e)
+        {
+            Logger.LogError("Unhandled exception", e.Exception);
+        }
+
+        public Window? GetWindow()
+        {
+            return window;
+        }
+
         private Window? window;
     }
 }

src/modules/keyboardmanager/KeyboardManagerEditorUI/Helpers/EditorConstants.cs

@@ -0,0 +1,22 @@
+// Copyright (c) Microsoft Corporation
+// The Microsoft Corporation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace KeyboardManagerEditorUI.Helpers
+{
+    public static class EditorConstants
+    {
+        // Default window size
+        public const int DefaultEditorWindowWidth = 960;
+        public const int DefaultEditorWindowHeight = 600;
+
+        // Default notification timeout
+        public const int DefaultNotificationTimeout = 1500;
+    }
+}

src/modules/keyboardmanager/KeyboardManagerEditorUI/Helpers/KeyInputMode.cs

@@ -0,0 +1,12 @@
+// Copyright (c) Microsoft Corporation
+// The Microsoft Corporation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+namespace KeyboardManagerEditorUI.Helpers
+{
+    public enum KeyInputMode
+    {
+        OriginalKeys,
+        RemappedKeys,
+    }
+}

src/modules/keyboardmanager/KeyboardManagerEditorUI/Helpers/KeyboardHookHelper.cs

@@ -0,0 +1,239 @@
+// Copyright (c) Microsoft Corporation
+// The Microsoft Corporation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using KeyboardManagerEditorUI.Interop;
+using Microsoft.PowerToys.Settings.UI.Library;
+using Windows.System;
+
+namespace KeyboardManagerEditorUI.Helpers
+{
+    public class KeyboardHookHelper : IDisposable
+    {
+        private static KeyboardHookHelper? _instance;
+
+        public static KeyboardHookHelper Instance => _instance ??= new KeyboardHookHelper();
+
+        private KeyboardMappingService _mappingService;
+
+        private HotkeySettingsControlHook? _keyboardHook;
+
+        // The active page using this keyboard hook
+        private IKeyboardHookTarget? _activeTarget;
+
+        private HashSet<VirtualKey> _currentlyPressedKeys = new();
+        private List<VirtualKey> _keyPressOrder = new();
+
+        private bool _disposed;
+
+        // Singleton to make sure only one instance of the hook is active
+        private KeyboardHookHelper()
+        {
+            _mappingService = new KeyboardMappingService();
+        }
+
+        public void ActivateHook(IKeyboardHookTarget target)
+        {
+            CleanupHook();
+
+            _activeTarget = target;
+
+            _currentlyPressedKeys.Clear();
+            _keyPressOrder.Clear();
+
+            _keyboardHook = new HotkeySettingsControlHook(
+                KeyDown,
+                KeyUp,
+                () => true,
+                (key, extraInfo) => true);
+        }
+
+        public void CleanupHook()
+        {
+            if (_keyboardHook != null)
+            {
+                _keyboardHook.Dispose();
+                _keyboardHook = null;
+            }
+
+            _currentlyPressedKeys.Clear();
+            _keyPressOrder.Clear();
+            _activeTarget = null;
+        }
+
+        private void KeyDown(int key)
+        {
+            if (_activeTarget == null)
+            {
+                return;
+            }
+
+            VirtualKey virtualKey = (VirtualKey)key;
+
+            if (_currentlyPressedKeys.Contains(virtualKey))
+            {
+                return;
+            }
+
+            // if no keys are pressed, clear the lists when a new key is pressed
+            if (_currentlyPressedKeys.Count == 0)
+            {
+                _activeTarget.ClearKeys();
+                _keyPressOrder.Clear();
+            }
+
+            // Count current modifiers
+            int modifierCount = _currentlyPressedKeys.Count(k => RemappingHelper.IsModifierKey(k));
+
+            // If adding this key would exceed the limits (4 modifiers + 1 action key), don't add it and show notification
+            if ((RemappingHelper.IsModifierKey(virtualKey) && modifierCount >= 4) ||
+                (!RemappingHelper.IsModifierKey(virtualKey) && _currentlyPressedKeys.Count >= 5))
+            {
+                _activeTarget.OnInputLimitReached();
+                return;
+            }
+
+            // Check if this is a different variant of a modifier key already pressed
+            if (RemappingHelper.IsModifierKey(virtualKey))
+            {
+                // Remove existing variant of this modifier key if a new one is pressed
+                // This is to ensure that only one variant of a modifier key is displayed at a time
+                RemoveExistingModifierVariant(virtualKey);
+            }
+
+            if (_currentlyPressedKeys.Add(virtualKey))
+            {
+                _keyPressOrder.Add(virtualKey);
+
+                // Notify the target page
+                _activeTarget.OnKeyDown(virtualKey, GetFormattedKeyList());
+            }
+        }
+
+        private void KeyUp(int key)
+        {
+            if (_activeTarget == null)
+            {
+                return;
+            }
+
+            VirtualKey virtualKey = (VirtualKey)key;
+
+            if (_currentlyPressedKeys.Remove(virtualKey))
+            {
+                _keyPressOrder.Remove(virtualKey);
+
+                _activeTarget.OnKeyUp(virtualKey, GetFormattedKeyList());
+            }
+        }
+
+        // Display the modifier keys and the action key in order, e.g. "Ctrl + Alt + A"
+        private List<string> GetFormattedKeyList()
+        {
+            if (_activeTarget == null)
+            {
+                return new List<string>();
+            }
+
+            List<string> keyList = new List<string>();
+            List<VirtualKey> modifierKeys = new List<VirtualKey>();
+            VirtualKey? actionKey = null;
+
+            foreach (var key in _keyPressOrder)
+            {
+                if (!_currentlyPressedKeys.Contains(key))
+                {
+                    continue;
+                }
+
+                if (RemappingHelper.IsModifierKey(key))
+                {
+                    if (!modifierKeys.Contains(key))
+                    {
+                        modifierKeys.Add(key);
+                    }
+                }
+                else
+                {
+                    actionKey = key;
+                }
+            }
+
+            foreach (var key in modifierKeys)
+            {
+                keyList.Add(_mappingService.GetKeyDisplayName((int)key));
+            }
+
+            if (actionKey.HasValue)
+            {
+                keyList.Add(_mappingService.GetKeyDisplayName((int)actionKey.Value));
+            }
+
+            return keyList;
+        }
+
+        private void RemoveExistingModifierVariant(VirtualKey key)
+        {
+            KeyType keyType = (KeyType)KeyboardManagerInterop.GetKeyType((int)key);
+
+            // No need to remove if the key is an action key
+            if (keyType == KeyType.Action)
+            {
+                return;
+            }
+
+            foreach (var existingKey in _currentlyPressedKeys.ToList())
+            {
+                if (existingKey != key)
+                {
+                    KeyType existingKeyType = (KeyType)KeyboardManagerInterop.GetKeyType((int)existingKey);
+
+                    // Remove the existing key if it is a modifier key and has the same type as the new key
+                    if (existingKeyType == keyType)
+                    {
+                        _currentlyPressedKeys.Remove(existingKey);
+                        _keyPressOrder.Remove(existingKey);
+                    }
+                }
+            }
+        }
+
+        public void Dispose()
+        {
+            Dispose(true);
+            GC.SuppressFinalize(this);
+        }
+
+        private void Dispose(bool disposing)
+        {
+            if (!_disposed)
+            {
+                if (disposing)
+                {
+                    CleanupHook();
+                    _mappingService?.Dispose();
+                }
+
+                _disposed = true;
+            }
+        }
+    }
+
+    public interface IKeyboardHookTarget
+    {
+        void OnKeyDown(VirtualKey key, List<string> formattedKeys);
+
+        void OnKeyUp(VirtualKey key, List<string> formattedKeys)
+        {
+        }
+
+        void ClearKeys();
+
+        void OnInputLimitReached();
+    }
+}

src/modules/keyboardmanager/KeyboardManagerEditorUI/Helpers/Remapping.cs

@@ -0,0 +1,47 @@
+// Copyright (c) Microsoft Corporation
+// The Microsoft Corporation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using System;
+using System.Collections.Generic;
+using System.ComponentModel;
+using System.Linq;
+using System.Runtime.CompilerServices;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace KeyboardManagerEditorUI.Helpers
+{
+    public partial class Remapping : INotifyPropertyChanged
+    {
+        public List<string> OriginalKeys { get; set; } = new List<string>();
+
+        public List<string> RemappedKeys { get; set; } = new List<string>();
+
+        public bool IsAllApps { get; set; } = true;
+
+        public string AppName { get; set; } = "All Apps";
+
+        private bool IsEnabledValue { get; set; } = true;
+
+        public event PropertyChangedEventHandler? PropertyChanged;
+
+        public bool IsEnabled
+        {
+            get => IsEnabledValue;
+            set
+            {
+                if (IsEnabledValue != value)
+                {
+                    IsEnabledValue = value;
+                    OnPropertyChanged();
+                }
+            }
+        }
+
+        private void OnPropertyChanged([CallerMemberName] string propertyName = "")
+        {
+            PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(propertyName));
+        }
+    }
+}

src/modules/keyboardmanager/KeyboardManagerEditorUI/Helpers/RemappingHelper.cs

@@ -0,0 +1,144 @@
+// Copyright (c) Microsoft Corporation
+// The Microsoft Corporation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using System;
+using System.Collections.Generic;
+using System.Globalization;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using KeyboardManagerEditorUI.Interop;
+using ManagedCommon;
+using Windows.System;
+
+namespace KeyboardManagerEditorUI.Helpers
+{
+    public static class RemappingHelper
+    {
+        public static bool SaveMapping(KeyboardMappingService mappingService, List<string> originalKeys, List<string> remappedKeys, bool isAppSpecific, string appName)
+        {
+            if (mappingService == null)
+            {
+                Logger.LogError("Mapping service is null, cannot save mapping");
+                return false;
+            }
+
+            try
+            {
+                if (originalKeys == null || originalKeys.Count == 0 || remappedKeys == null || remappedKeys.Count == 0)
+                {
+                    return false;
+                }
+
+                if (originalKeys.Count == 1)
+                {
+                    int originalKey = mappingService.GetKeyCodeFromName(originalKeys[0]);
+                    if (originalKey != 0)
+                    {
+                        if (remappedKeys.Count == 1)
+                        {
+                            int targetKey = mappingService.GetKeyCodeFromName(remappedKeys[0]);
+                            if (targetKey != 0)
+                            {
+                                mappingService.AddSingleKeyMapping(originalKey, targetKey);
+                            }
+                        }
+                        else
+                        {
+                            string targetKeys = string.Join(";", remappedKeys.Select(k => mappingService.GetKeyCodeFromName(k).ToString(CultureInfo.InvariantCulture)));
+                            mappingService.AddSingleKeyMapping(originalKey, targetKeys);
+                        }
+                    }
+                }
+                else
+                {
+                    string originalKeysString = string.Join(";", originalKeys.Select(k => mappingService.GetKeyCodeFromName(k).ToString(CultureInfo.InvariantCulture)));
+                    string targetKeysString = string.Join(";", remappedKeys.Select(k => mappingService.GetKeyCodeFromName(k).ToString(CultureInfo.InvariantCulture)));
+
+                    if (isAppSpecific && !string.IsNullOrEmpty(appName))
+                    {
+                        mappingService.AddShortcutMapping(originalKeysString, targetKeysString, appName);
+                    }
+                    else
+                    {
+                        mappingService.AddShortcutMapping(originalKeysString, targetKeysString);
+                    }
+                }
+
+                return mappingService.SaveSettings();
+            }
+            catch (Exception ex)
+            {
+                Logger.LogError("Error saving mapping: " + ex.Message);
+                return false;
+            }
+        }
+
+        public static bool DeleteRemapping(KeyboardMappingService mappingService, Remapping remapping)
+        {
+            if (mappingService == null)
+            {
+                return false;
+            }
+
+            try
+            {
+                if (remapping.OriginalKeys.Count == 1)
+                {
+                    // Single key mapping
+                    int originalKey = mappingService.GetKeyCodeFromName(remapping.OriginalKeys[0]);
+                    if (originalKey != 0)
+                    {
+                        if (mappingService.DeleteSingleKeyMapping(originalKey))
+                        {
+                            // Save settings after successful deletion
+                            return mappingService.SaveSettings();
+                        }
+                    }
+                }
+                else if (remapping.OriginalKeys.Count > 1)
+                {
+                    // Shortcut mapping
+                    string originalKeysString = string.Join(";", remapping.OriginalKeys.Select(k => mappingService.GetKeyCodeFromName(k).ToString(CultureInfo.InvariantCulture)));
+
+                    bool deleteResult;
+                    if (!remapping.IsAllApps && !string.IsNullOrEmpty(remapping.AppName))
+                    {
+                        // App-specific shortcut key mapping
+                        deleteResult = mappingService.DeleteShortcutMapping(originalKeysString, remapping.AppName);
+                    }
+                    else
+                    {
+                        // Global shortcut key mapping
+                        deleteResult = mappingService.DeleteShortcutMapping(originalKeysString);
+                    }
+
+                    return deleteResult ? mappingService.SaveSettings() : false;
+                }
+
+                return false;
+            }
+            catch (Exception ex)
+            {
+                Logger.LogError($"Error deleting remapping: {ex.Message}");
+                return false;
+            }
+        }
+
+        public static bool IsModifierKey(VirtualKey key)
+        {
+            return key == VirtualKey.Control
+                || key == VirtualKey.LeftControl
+                || key == VirtualKey.RightControl
+                || key == VirtualKey.Menu
+                || key == VirtualKey.LeftMenu
+                || key == VirtualKey.RightMenu
+                || key == VirtualKey.Shift
+                || key == VirtualKey.LeftShift
+                || key == VirtualKey.RightShift
+                || key == VirtualKey.LeftWindows
+                || key == VirtualKey.RightWindows;
+        }
+    }
+}

src/modules/keyboardmanager/KeyboardManagerEditorUI/Helpers/TextMapping.cs

@@ -0,0 +1,23 @@
+// Copyright (c) Microsoft Corporation
+// The Microsoft Corporation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace KeyboardManagerEditorUI.Helpers
+{
+    public class TextMapping
+    {
+        public List<string> Keys { get; set; } = new List<string>();
+
+        public string Text { get; set; } = string.Empty;
+
+        public bool IsAllApps { get; set; } = true;
+
+        public string AppName { get; set; } = "All Apps";
+    }
+}

src/modules/keyboardmanager/KeyboardManagerEditorUI/Helpers/URLShortcut.cs

@@ -0,0 +1,19 @@
+// Copyright (c) Microsoft Corporation
+// The Microsoft Corporation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace KeyboardManagerEditorUI.Helpers
+{
+    public class URLShortcut
+    {
+        public List<string> Shortcut { get; set; } = new List<string>();
+
+        public string URL { get; set; } = string.Empty;
+    }
+}

src/modules/keyboardmanager/KeyboardManagerEditorUI/Helpers/ValidationErrorType.cs

@@ -0,0 +1,25 @@
+// Copyright (c) Microsoft Corporation
+// The Microsoft Corporation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace KeyboardManagerEditorUI.Helpers
+{
+    public enum ValidationErrorType
+    {
+        NoError,
+        EmptyOriginalKeys,
+        EmptyRemappedKeys,
+        ModifierOnly,
+        EmptyAppName,
+        IllegalShortcut,
+        DuplicateMapping,
+        SelfMapping,
+        EmptyTargetText,
+    }
+}

src/modules/keyboardmanager/KeyboardManagerEditorUI/Helpers/ValidationHelper.cs

@@ -0,0 +1,299 @@
+// Copyright (c) Microsoft Corporation
+// The Microsoft Corporation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using System;
+using System.Collections.Generic;
+using System.Globalization;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using KeyboardManagerEditorUI.Interop;
+
+namespace KeyboardManagerEditorUI.Helpers
+{
+    public static class ValidationHelper
+    {
+        public static readonly Dictionary<ValidationErrorType, (string Title, string Message)> ValidationMessages = new()
+        {
+            { ValidationErrorType.EmptyOriginalKeys, ("Missing Original Keys", "Please enter at least one original key to create a remapping.") },
+            { ValidationErrorType.EmptyRemappedKeys, ("Missing Target Keys", "Please enter at least one target key to create a remapping.") },
+            { ValidationErrorType.ModifierOnly, ("Invalid Shortcut", "Shortcuts must contain at least one action key in addition to modifier keys (Ctrl, Alt, Shift, Win).") },
+            { ValidationErrorType.EmptyAppName, ("Missing Application Name", "You've selected app-specific remapping but haven't specified an application name. Please enter the application name.") },
+            { ValidationErrorType.IllegalShortcut, ("Reserved System Shortcut", "Win+L and Ctrl+Alt+Delete are reserved system shortcuts and cannot be remapped.") },
+            { ValidationErrorType.DuplicateMapping, ("Duplicate Remapping", "This key or shortcut is already remapped.") },
+            { ValidationErrorType.SelfMapping, ("Invalid Remapping", "A key or shortcut cannot be remapped to itself. Please choose a different target.") },
+            { ValidationErrorType.EmptyTargetText, ("Missing Target Text", "Please enter the text to be inserted when the shortcut is pressed.") },
+        };
+
+        public static ValidationErrorType ValidateKeyMapping(
+            List<string> originalKeys,
+            List<string> remappedKeys,
+            bool isAppSpecific,
+            string appName,
+            KeyboardMappingService mappingService,
+            bool isEditMode = false,
+            Remapping? editingRemapping = null)
+        {
+            // Check if original keys are empty
+            if (originalKeys == null || originalKeys.Count == 0)
+            {
+                return ValidationErrorType.EmptyOriginalKeys;
+            }
+
+            // Check if remapped keys are empty
+            if (remappedKeys == null || remappedKeys.Count == 0)
+            {
+                return ValidationErrorType.EmptyRemappedKeys;
+            }
+
+            // Check if shortcut contains only modifier keys
+            if ((originalKeys.Count > 1 && ContainsOnlyModifierKeys(originalKeys)) ||
+                (remappedKeys.Count > 1 && ContainsOnlyModifierKeys(remappedKeys)))
+            {
+                return ValidationErrorType.ModifierOnly;
+            }
+
+            // Check if app specific is checked but no app name is provided
+            if (isAppSpecific && string.IsNullOrWhiteSpace(appName))
+            {
+                return ValidationErrorType.EmptyAppName;
+            }
+
+            // Check if this is a shortcut (multiple keys) and if it's an illegal combination
+            if (originalKeys.Count > 1)
+            {
+                string shortcutKeysString = string.Join(";", originalKeys.Select(k => mappingService.GetKeyCodeFromName(k).ToString(CultureInfo.InvariantCulture)));
+
+                if (KeyboardManagerInterop.IsShortcutIllegal(shortcutKeysString))
+                {
+                    return ValidationErrorType.IllegalShortcut;
+                }
+            }
+
+            // Check for duplicate mappings
+            if (IsDuplicateMapping(originalKeys, isAppSpecific, appName, mappingService, isEditMode, editingRemapping))
+            {
+                return ValidationErrorType.DuplicateMapping;
+            }
+
+            // Check for self-mapping
+            if (IsSelfMapping(originalKeys, remappedKeys, mappingService))
+            {
+                return ValidationErrorType.SelfMapping;
+            }
+
+            return ValidationErrorType.NoError;
+        }
+
+        public static ValidationErrorType ValidateTextMapping(
+            List<string> keys,
+            string textContent,
+            bool isAppSpecific,
+            string appName,
+            KeyboardMappingService mappingService)
+        {
+            // Check if original keys are empty
+            if (keys == null || keys.Count == 0)
+            {
+                return ValidationErrorType.EmptyOriginalKeys;
+            }
+
+            // Check if text content is empty
+            if (string.IsNullOrWhiteSpace(textContent))
+            {
+                return ValidationErrorType.EmptyTargetText;
+            }
+
+            // Check if shortcut contains only modifier keys
+            if (keys.Count > 1 && ContainsOnlyModifierKeys(keys))
+            {
+                return ValidationErrorType.ModifierOnly;
+            }
+
+            // Check if app specific is checked but no app name is provided
+            if (isAppSpecific && string.IsNullOrWhiteSpace(appName))
+            {
+                return ValidationErrorType.EmptyAppName;
+            }
+
+            // Check if this is a shortcut (multiple keys) and if it's an illegal combination
+            if (keys.Count > 1)
+            {
+                string shortcutKeysString = string.Join(";", keys.Select(k => mappingService.GetKeyCodeFromName(k).ToString(CultureInfo.InvariantCulture)));
+
+                if (KeyboardManagerInterop.IsShortcutIllegal(shortcutKeysString))
+                {
+                    return ValidationErrorType.IllegalShortcut;
+                }
+            }
+
+            // No errors found
+            return ValidationErrorType.NoError;
+        }
+
+        public static bool IsDuplicateMapping(
+            List<string> originalKeys,
+            bool isAppSpecific,
+            string appName,
+            KeyboardMappingService mappingService,
+            bool isEditMode = false,
+            Remapping? editingRemapping = null)
+        {
+            if (mappingService == null || originalKeys == null || originalKeys.Count == 0)
+            {
+                return false;
+            }
+
+            // For single key remapping
+            if (originalKeys.Count == 1)
+            {
+                int originalKeyCode = mappingService.GetKeyCodeFromName(originalKeys[0]);
+                if (originalKeyCode == 0)
+                {
+                    return false;
+                }
+
+                // Check if the key is already remapped
+                foreach (var mapping in mappingService.GetSingleKeyMappings())
+                {
+                    if (mapping.OriginalKey == originalKeyCode)
+                    {
+                        // Skip if the remapping is the same as the one being edited
+                        if (isEditMode && editingRemapping != null &&
+                            editingRemapping.OriginalKeys.Count == 1 &&
+                            mappingService.GetKeyCodeFromName(editingRemapping.OriginalKeys[0]) == originalKeyCode)
+                        {
+                            continue;
+                        }
+
+                        return true;
+                    }
+                }
+            }
+
+            // For shortcut remapping
+            else
+            {
+                string originalKeysString = string.Join(";", originalKeys.Select(
+                    k => mappingService.GetKeyCodeFromName(k).ToString(CultureInfo.InvariantCulture)));
+
+                // Don't check for duplicates if the original keys are the same as the remapping being edited
+                bool isEditingExistingRemapping = false;
+                if (isEditMode && editingRemapping != null)
+                {
+                    string editingOriginalKeysString = string.Join(";", editingRemapping.OriginalKeys.Select(k =>
+                                    mappingService.GetKeyCodeFromName(k).ToString(CultureInfo.InvariantCulture)));
+
+                    if (KeyboardManagerInterop.AreShortcutsEqual(originalKeysString, editingOriginalKeysString))
+                    {
+                        isEditingExistingRemapping = true;
+                    }
+                }
+
+                // Check if the shortcut is already remapped in the same app context
+                foreach (var mapping in mappingService.GetShortcutMappingsByType(ShortcutOperationType.RemapShortcut))
+                {
+                    if (KeyboardManagerInterop.AreShortcutsEqual(originalKeysString, mapping.OriginalKeys))
+                    {
+                        // If both are global (all apps)
+                        if (!isAppSpecific && string.IsNullOrEmpty(mapping.TargetApp))
+                        {
+                            // Skip if the remapping is the same as the one being edited
+                            if (editingRemapping != null && editingRemapping.OriginalKeys.Count > 1 && editingRemapping.IsAllApps && isEditingExistingRemapping)
+                            {
+                                continue;
+                            }
+
+                            return true;
+                        }
+
+                        // If both are for the same specific app
+                        else if (isAppSpecific && !string.IsNullOrEmpty(mapping.TargetApp)
+                            && string.Equals(mapping.TargetApp, appName, StringComparison.OrdinalIgnoreCase))
+                        {
+                            // Skip if the remapping is the same as the one being edited
+                            if (editingRemapping != null && editingRemapping.OriginalKeys.Count > 1 && !editingRemapping.IsAllApps &&
+                                string.Equals(editingRemapping.AppName, appName, StringComparison.OrdinalIgnoreCase) && isEditingExistingRemapping)
+                            {
+                                continue;
+                            }
+
+                            return true;
+                        }
+                    }
+                }
+            }
+
+            return false;
+        }
+
+        public static bool IsSelfMapping(List<string> originalKeys, List<string> remappedKeys, KeyboardMappingService mappingService)
+        {
+            if (mappingService == null)
+            {
+                return false;
+            }
+
+            // If either list is empty, it's not a self-mapping
+            if (originalKeys == null || remappedKeys == null ||
+                originalKeys.Count == 0 || remappedKeys.Count == 0)
+            {
+                return false;
+            }
+
+            string originalKeysString = string.Join(";", originalKeys.Select(k => mappingService.GetKeyCodeFromName(k).ToString(CultureInfo.InvariantCulture)));
+            string remappedKeysString = string.Join(";", remappedKeys.Select(k => mappingService.GetKeyCodeFromName(k).ToString(CultureInfo.InvariantCulture)));
+
+            return KeyboardManagerInterop.AreShortcutsEqual(originalKeysString, remappedKeysString);
+        }
+
+        public static bool ContainsOnlyModifierKeys(List<string> keys)
+        {
+            if (keys == null || keys.Count == 0)
+            {
+                return false;
+            }
+
+            foreach (string key in keys)
+            {
+                int keyCode = KeyboardManagerInterop.GetKeyCodeFromName(key);
+                var keyType = (KeyType)KeyboardManagerInterop.GetKeyType(keyCode);
+
+                // If any key is an action key, return false
+                if (keyType == KeyType.Action)
+                {
+                    return false;
+                }
+            }
+
+            // All keys are modifier keys
+            return true;
+        }
+
+        public static bool IsKeyOrphaned(int originalKey, KeyboardMappingService mappingService)
+        {
+            // Check all single key mappings
+            foreach (var mapping in mappingService.GetSingleKeyMappings())
+            {
+                if (!mapping.IsShortcut && int.TryParse(mapping.TargetKey, out int targetKey) && targetKey == originalKey)
+                {
+                    return false;
+                }
+            }
+
+            // Check all shortcut mappings
+            foreach (var mapping in mappingService.GetShortcutMappings())
+            {
+                string[] targetKeys = mapping.TargetKeys.Split(';');
+                if (targetKeys.Length == 1 && int.TryParse(targetKeys[0], out int shortcutTargetKey) && shortcutTargetKey == originalKey)
+                {
+                    return false;
+                }
+            }
+
+            // No mapping found for the original key
+            return true;
+        }
+    }
+}

src/modules/keyboardmanager/KeyboardManagerEditorUI/Interop/KeyMapping.cs

@@ -0,0 +1,21 @@
+// Copyright (c) Microsoft Corporation
+// The Microsoft Corporation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace KeyboardManagerEditorUI.Interop
+{
+    public class KeyMapping
+    {
+        public int OriginalKey { get; set; }
+
+        public string TargetKey { get; set; } = string.Empty;
+
+        public bool IsShortcut { get; set; }
+    }
+}

src/modules/keyboardmanager/KeyboardManagerEditorUI/Interop/KeyToTextMapping.cs

@@ -0,0 +1,19 @@
+// Copyright (c) Microsoft Corporation
+// The Microsoft Corporation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace KeyboardManagerEditorUI.Interop
+{
+    public class KeyToTextMapping
+    {
+        public int OriginalKey { get; set; }
+
+        public string TargetText { get; set; } = string.Empty;
+    }
+}

src/modules/keyboardmanager/KeyboardManagerEditorUI/Interop/KeyType.cs

@@ -0,0 +1,21 @@
+// Copyright (c) Microsoft Corporation
+// The Microsoft Corporation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace KeyboardManagerEditorUI.Interop
+{
+    public enum KeyType
+    {
+        Win = 0,
+        Ctrl = 1,
+        Alt = 2,
+        Shift = 3,
+        Action = 4,
+    }
+}

src/modules/keyboardmanager/KeyboardManagerEditorUI/Interop/KeyboardManagerInterop.cs

@@ -0,0 +1,159 @@
+// Copyright (c) Microsoft Corporation
+// The Microsoft Corporation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Runtime.InteropServices;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace KeyboardManagerEditorUI.Interop
+{
+    public static class KeyboardManagerInterop
+    {
+        private const string DllName = "Powertoys.KeyboardManagerEditorLibraryWrapper.dll";
+
+        // Configuration Management
+        [DllImport(DllName)]
+        internal static extern IntPtr CreateMappingConfiguration();
+
+        [DllImport(DllName)]
+        internal static extern void DestroyMappingConfiguration(IntPtr config);
+
+        [DllImport(DllName)]
+        [return: MarshalAs(UnmanagedType.Bool)]
+        internal static extern bool LoadMappingSettings(IntPtr config);
+
+        [DllImport(DllName)]
+        [return: MarshalAs(UnmanagedType.Bool)]
+        internal static extern bool SaveMappingSettings(IntPtr config);
+
+        // Get Mapping Functions
+        [DllImport(DllName)]
+        internal static extern int GetSingleKeyRemapCount(IntPtr config);
+
+        [DllImport(DllName)]
+        [return: MarshalAs(UnmanagedType.Bool)]
+        internal static extern bool GetSingleKeyRemap(IntPtr config, int index, ref SingleKeyMapping mapping);
+
+        [DllImport(DllName)]
+        internal static extern int GetSingleKeyToTextRemapCount(IntPtr config);
+
+        [DllImport(DllName)]
+        [return: MarshalAs(UnmanagedType.Bool)]
+        internal static extern bool GetSingleKeyToTextRemap(IntPtr config, int index, ref KeyboardTextMapping mapping);
+
+        [DllImport(DllName)]
+        internal static extern int GetShortcutRemapCount(IntPtr config);
+
+        [DllImport(DllName)]
+        [return: MarshalAs(UnmanagedType.Bool)]
+        internal static extern bool GetShortcutRemap(IntPtr config, int index, ref ShortcutMapping mapping);
+
+        [DllImport(DllName)]
+        internal static extern int GetShortcutRemapCountByType(IntPtr config, int operationType);
+
+        [DllImport(DllName)]
+        [return: MarshalAs(UnmanagedType.Bool)]
+        internal static extern bool GetShortcutRemapByType(IntPtr config, int operationType, int index, ref ShortcutMapping mapping);
+
+        // Add Mapping Functions
+        [DllImport(DllName)]
+        [return: MarshalAs(UnmanagedType.Bool)]
+        internal static extern bool AddSingleKeyRemap(IntPtr config, int originalKey, int targetKey);
+
+        [DllImport(DllName)]
+        [return: MarshalAs(UnmanagedType.Bool)]
+        internal static extern bool AddSingleKeyToTextRemap(IntPtr config, int originalKey, [MarshalAs(UnmanagedType.LPWStr)] string targetText);
+
+        [DllImport(DllName)]
+        [return: MarshalAs(UnmanagedType.Bool)]
+        internal static extern bool AddSingleKeyToShortcutRemap(IntPtr config, int originalKey, [MarshalAs(UnmanagedType.LPWStr)] string targetKeys);
+
+        [DllImport(DllName)]
+        [return: MarshalAs(UnmanagedType.Bool)]
+        internal static extern bool AddShortcutRemap(
+            IntPtr config,
+            [MarshalAs(UnmanagedType.LPWStr)] string originalKeys,
+            [MarshalAs(UnmanagedType.LPWStr)] string targetKeys,
+            [MarshalAs(UnmanagedType.LPWStr)] string targetApp,
+            int operationType = 0);
+
+        // Delete Mapping Functions
+        [DllImport(DllName)]
+        internal static extern bool DeleteSingleKeyRemap(IntPtr mappingConfiguration, int originalKey);
+
+        [DllImport(DllName)]
+        [return: MarshalAs(UnmanagedType.Bool)]
+        internal static extern bool DeleteSingleKeyToTextRemap(IntPtr config, int originalKey);
+
+        [DllImport(DllName)]
+        internal static extern bool DeleteShortcutRemap(IntPtr mappingConfiguration, [MarshalAs(UnmanagedType.LPWStr)] string originalKeys, [MarshalAs(UnmanagedType.LPWStr)] string targetApp);
+
+        // Key Utility Functions
+        [DllImport(DllName)]
+        internal static extern int GetKeyCodeFromName([MarshalAs(UnmanagedType.LPWStr)] string keyName);
+
+        [DllImport(DllName, CharSet = CharSet.Unicode)]
+        internal static extern void GetKeyDisplayName(int keyCode, [Out] StringBuilder keyName, int maxLength);
+
+        [DllImport(DllName)]
+        internal static extern int GetKeyType(int keyCode);
+
+        // Validation Functions
+        [DllImport(DllName)]
+        [return: MarshalAs(UnmanagedType.Bool)]
+        internal static extern bool IsShortcutIllegal([MarshalAs(UnmanagedType.LPWStr)] string shortcutKeys);
+
+        [DllImport(DllName)]
+        [return: MarshalAs(UnmanagedType.Bool)]
+        internal static extern bool AreShortcutsEqual([MarshalAs(UnmanagedType.LPWStr)] string lShort, [MarshalAs(UnmanagedType.LPWStr)] string rShortcut);
+
+        // String Management Functions
+        [DllImport(DllName)]
+        internal static extern void FreeString(IntPtr str);
+
+        public static string GetStringAndFree(IntPtr handle)
+        {
+            if (handle == IntPtr.Zero)
+            {
+                return string.Empty;
+            }
+
+            string? result = Marshal.PtrToStringUni(handle);
+            FreeString(handle);
+            return result ?? string.Empty;
+        }
+    }
+
+    [StructLayout(LayoutKind.Sequential)]
+    public struct SingleKeyMapping
+    {
+        public int OriginalKey;
+        public IntPtr TargetKey;
+        [MarshalAs(UnmanagedType.Bool)]
+        public bool IsShortcut;
+    }
+
+    [StructLayout(LayoutKind.Sequential)]
+    public struct KeyboardTextMapping
+    {
+        public int OriginalKey;
+        public IntPtr TargetText;
+    }
+
+    [StructLayout(LayoutKind.Sequential)]
+    public struct ShortcutMapping
+    {
+        public IntPtr OriginalKeys;
+        public IntPtr TargetKeys;
+        public IntPtr TargetApp;
+        public int OperationType;
+        public IntPtr TargetText;
+        public IntPtr ProgramPath;
+        public IntPtr ProgramArgs;
+        public IntPtr UriToOpen;
+    }
+}

src/modules/keyboardmanager/KeyboardManagerEditorUI/Interop/KeyboardMappingService.cs

@@ -0,0 +1,243 @@
+// Copyright (c) Microsoft Corporation
+// The Microsoft Corporation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Runtime.InteropServices;
+using System.Text;
+using System.Threading.Tasks;
+using ManagedCommon;
+
+namespace KeyboardManagerEditorUI.Interop
+{
+    public class KeyboardMappingService : IDisposable
+    {
+        private IntPtr _configHandle;
+        private bool _disposed;
+
+        public KeyboardMappingService()
+        {
+            _configHandle = KeyboardManagerInterop.CreateMappingConfiguration();
+            if (_configHandle == IntPtr.Zero)
+            {
+                Logger.LogError("Failed to create mapping configuration");
+                throw new InvalidOperationException("Failed to create mapping configuration");
+            }
+
+            KeyboardManagerInterop.LoadMappingSettings(_configHandle);
+        }
+
+        public List<KeyMapping> GetSingleKeyMappings()
+        {
+            var result = new List<KeyMapping>();
+            int count = KeyboardManagerInterop.GetSingleKeyRemapCount(_configHandle);
+
+            for (int i = 0; i < count; i++)
+            {
+                var mapping = default(SingleKeyMapping);
+                if (KeyboardManagerInterop.GetSingleKeyRemap(_configHandle, i, ref mapping))
+                {
+                    result.Add(new KeyMapping
+                    {
+                        OriginalKey = mapping.OriginalKey,
+                        TargetKey = KeyboardManagerInterop.GetStringAndFree(mapping.TargetKey),
+                        IsShortcut = mapping.IsShortcut,
+                    });
+                }
+            }
+
+            return result;
+        }
+
+        public List<ShortcutKeyMapping> GetShortcutMappings()
+        {
+            var result = new List<ShortcutKeyMapping>();
+            int count = KeyboardManagerInterop.GetShortcutRemapCount(_configHandle);
+
+            for (int i = 0; i < count; i++)
+            {
+                var mapping = default(ShortcutMapping);
+                if (KeyboardManagerInterop.GetShortcutRemap(_configHandle, i, ref mapping))
+                {
+                    result.Add(new ShortcutKeyMapping
+                    {
+                        OriginalKeys = KeyboardManagerInterop.GetStringAndFree(mapping.OriginalKeys),
+                        TargetKeys = KeyboardManagerInterop.GetStringAndFree(mapping.TargetKeys),
+                        TargetApp = KeyboardManagerInterop.GetStringAndFree(mapping.TargetApp),
+                        OperationType = (ShortcutOperationType)mapping.OperationType,
+                        TargetText = KeyboardManagerInterop.GetStringAndFree(mapping.TargetText),
+                        ProgramPath = KeyboardManagerInterop.GetStringAndFree(mapping.ProgramPath),
+                        ProgramArgs = KeyboardManagerInterop.GetStringAndFree(mapping.ProgramArgs),
+                        UriToOpen = KeyboardManagerInterop.GetStringAndFree(mapping.UriToOpen),
+                    });
+                }
+            }
+
+            return result;
+        }
+
+        public List<ShortcutKeyMapping> GetShortcutMappingsByType(ShortcutOperationType operationType)
+        {
+            var result = new List<ShortcutKeyMapping>();
+            int count = KeyboardManagerInterop.GetShortcutRemapCountByType(_configHandle, (int)operationType);
+
+            for (int i = 0; i < count; i++)
+            {
+                var mapping = default(ShortcutMapping);
+                if (KeyboardManagerInterop.GetShortcutRemapByType(_configHandle, (int)operationType, i, ref mapping))
+                {
+                    result.Add(new ShortcutKeyMapping
+                    {
+                        OriginalKeys = KeyboardManagerInterop.GetStringAndFree(mapping.OriginalKeys),
+                        TargetKeys = KeyboardManagerInterop.GetStringAndFree(mapping.TargetKeys),
+                        TargetApp = KeyboardManagerInterop.GetStringAndFree(mapping.TargetApp),
+                        OperationType = (ShortcutOperationType)mapping.OperationType,
+                        TargetText = KeyboardManagerInterop.GetStringAndFree(mapping.TargetText),
+                        ProgramPath = KeyboardManagerInterop.GetStringAndFree(mapping.ProgramPath),
+                        ProgramArgs = KeyboardManagerInterop.GetStringAndFree(mapping.ProgramArgs),
+                        UriToOpen = KeyboardManagerInterop.GetStringAndFree(mapping.UriToOpen),
+                    });
+                }
+            }
+
+            return result;
+        }
+
+        public List<KeyToTextMapping> GetKeyToTextMappings()
+        {
+            var result = new List<KeyToTextMapping>();
+            int count = KeyboardManagerInterop.GetSingleKeyToTextRemapCount(_configHandle);
+
+            for (int i = 0; i < count; i++)
+            {
+                var mapping = default(KeyboardTextMapping);
+                if (KeyboardManagerInterop.GetSingleKeyToTextRemap(_configHandle, i, ref mapping))
+                {
+                    result.Add(new KeyToTextMapping
+                    {
+                        OriginalKey = mapping.OriginalKey,
+                        TargetText = KeyboardManagerInterop.GetStringAndFree(mapping.TargetText),
+                    });
+                }
+            }
+
+            return result;
+        }
+
+        public string GetKeyDisplayName(int keyCode)
+        {
+            var keyName = new StringBuilder(64);
+            KeyboardManagerInterop.GetKeyDisplayName(keyCode, keyName, keyName.Capacity);
+            return keyName.ToString();
+        }
+
+        public int GetKeyCodeFromName(string keyName)
+        {
+            if (string.IsNullOrEmpty(keyName))
+            {
+                return 0;
+            }
+
+            return KeyboardManagerInterop.GetKeyCodeFromName(keyName);
+        }
+
+        public bool AddSingleKeyMapping(int originalKey, int targetKey)
+        {
+            return KeyboardManagerInterop.AddSingleKeyRemap(_configHandle, originalKey, targetKey);
+        }
+
+        public bool AddSingleKeyMapping(int originalKey, string targetKeys)
+        {
+            if (string.IsNullOrEmpty(targetKeys))
+            {
+                return false;
+            }
+
+            if (!targetKeys.Contains(';') && int.TryParse(targetKeys, out int targetKey))
+            {
+                return KeyboardManagerInterop.AddSingleKeyRemap(_configHandle, originalKey, targetKey);
+            }
+            else
+            {
+                return KeyboardManagerInterop.AddSingleKeyToShortcutRemap(_configHandle, originalKey, targetKeys);
+            }
+        }
+
+        public bool AddSingleKeyToTextMapping(int originalKey, string targetText)
+        {
+            if (string.IsNullOrEmpty(targetText))
+            {
+                return false;
+            }
+
+            return KeyboardManagerInterop.AddSingleKeyToTextRemap(_configHandle, originalKey, targetText);
+        }
+
+        public bool AddShortcutMapping(string originalKeys, string targetKeys, string targetApp = "", ShortcutOperationType operationType = ShortcutOperationType.RemapShortcut)
+        {
+            if (string.IsNullOrEmpty(originalKeys) || string.IsNullOrEmpty(targetKeys))
+            {
+                return false;
+            }
+
+            return KeyboardManagerInterop.AddShortcutRemap(_configHandle, originalKeys, targetKeys, targetApp, (int)operationType);
+        }
+
+        public bool SaveSettings()
+        {
+            return KeyboardManagerInterop.SaveMappingSettings(_configHandle);
+        }
+
+        public bool DeleteSingleKeyMapping(int originalKey)
+        {
+            return KeyboardManagerInterop.DeleteSingleKeyRemap(_configHandle, originalKey);
+        }
+
+        public bool DeleteSingleKeyToTextMapping(int originalKey)
+        {
+            if (originalKey == 0)
+            {
+                return false;
+            }
+
+            return KeyboardManagerInterop.DeleteSingleKeyToTextRemap(_configHandle, originalKey);
+        }
+
+        public bool DeleteShortcutMapping(string originalKeys, string targetApp = "")
+        {
+            if (string.IsNullOrEmpty(originalKeys))
+            {
+                return false;
+            }
+
+            return KeyboardManagerInterop.DeleteShortcutRemap(_configHandle, originalKeys, targetApp ?? string.Empty);
+        }
+
+        public void Dispose()
+        {
+            Dispose(true);
+            GC.SuppressFinalize(this);
+        }
+
+        protected virtual void Dispose(bool disposing)
+        {
+            if (!_disposed)
+            {
+                if (_configHandle != IntPtr.Zero)
+                {
+                    KeyboardManagerInterop.DestroyMappingConfiguration(_configHandle);
+                    _configHandle = IntPtr.Zero;
+                }
+
+                _disposed = true;
+            }
+        }
+
+        ~KeyboardMappingService()
+        {
+            Dispose(false);
+        }
+    }
+}