Update build-installer.ps1

## Summary of the Pull Request

Added more instructions to first time building command palette

## PR Checklist

- [ ] **Closes:** #xxx
- [ ] **Communication:** I've discussed this with core contributors
already. If the work hasn't been agreed, this work might be rejected
- [ ] **Tests:** Added/updated and all pass
- [ ] **Localization:** All end-user-facing strings can be localized
- [X ] **Dev docs:** Added/updated
- [ ] **New binaries:** Added on the required places
- [ ] [JSON for
signing](https://github.com/microsoft/PowerToys/blob/main/.pipelines/ESRPSigning_core.json)
for new binaries
- [ ] [WXS for
installer](https://github.com/microsoft/PowerToys/blob/main/installer/PowerToysSetup/Product.wxs)
for new binaries and localization folder
- [ ] [YML for CI
pipeline](https://github.com/microsoft/PowerToys/blob/main/.pipelines/ci/templates/build-powertoys-steps.yml)
for new test projects
- [ ] [YML for signed
pipeline](https://github.com/microsoft/PowerToys/blob/main/.pipelines/release.yml)
- [ ] **Documentation updated:** If checked, please file a pull request
on [our docs
repo](https://github.com/MicrosoftDocs/windows-uwp/tree/docs/hub/powertoys)
and link it here: #xxx

<!-- Provide a more detailed description of the PR, other things fixed,
or any additional comments/features here -->
## Detailed Description of the Pull Request / Additional comments

<!-- Describe how you validated the behavior. Add automated tests
wherever possible, but list manual validation steps taken as well -->
## Validation Steps Performed

PowerToys.sln

@@ -60,9 +60,6 @@ EndProject
 Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "PowerRenameLib", "src\modules\powerrename\lib\PowerRenameLib.vcxproj", "{51920F1F-C28C-4ADF-8660-4238766796C2}"
 EndProject
 Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "PowerRenameTest", "src\modules\powerrename\testapp\PowerRenameTest.vcxproj", "{A3935CF4-46C5-4A88-84D3-6B12E16E6BA2}"
-	ProjectSection(ProjectDependencies) = postProject
-		{51920F1F-C28C-4ADF-8660-4238766796C2} = {51920F1F-C28C-4ADF-8660-4238766796C2}
-	EndProjectSection
 EndProject
 Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "PowerRenameUnitTests", "src\modules\powerrename\unittests\PowerRenameLibUnitTests.vcxproj", "{2151F984-E006-4A9F-92EF-C6DDE3DC8413}"
 	ProjectSection(ProjectDependencies) = postProject
@@ -744,6 +741,16 @@ Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Microsoft.CmdPal.Core.ViewM
 EndProject
 Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Microsoft.CmdPal.UITests", "src\modules\cmdpal\Microsoft.CmdPal.UITests\Microsoft.CmdPal.UITests.csproj", "{840455DF-5634-51BB-D937-9D7D32F0B0C2}"
 EndProject
+Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "Tests", "Tests", "{15EA681E-C7D8-13C7-8484-4AC65E1B71E8}"
+EndProject
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Microsoft.CmdPal.Ext.Registry.UnitTests", "src\modules\cmdpal\Tests\Microsoft.CmdPal.Ext.Registry.UnitTests\Microsoft.CmdPal.Ext.Registry.UnitTests.csproj", "{2CF0567E-1E00-4E3F-1561-BF85F5CE5FE7}"
+EndProject
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Microsoft.CmdPal.Ext.System.UnitTests", "src\modules\cmdpal\Tests\Microsoft.CmdPal.Ext.System.UnitTests\Microsoft.CmdPal.Ext.System.UnitTests.csproj", "{790247CB-2B95-E139-E933-09D10137EEAF}"
+EndProject
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Microsoft.CmdPal.Ext.TimeDate.UnitTests", "src\modules\cmdpal\Tests\Microsoft.CmdPal.Ext.TimeDate.UnitTests\Microsoft.CmdPal.Ext.TimeDate.UnitTests.csproj", "{18525614-CDB2-8BBE-B1B4-3812CD990C22}"
+EndProject
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Microsoft.CmdPal.Ext.WindowWalker.UnitTests", "src\modules\cmdpal\Tests\Microsoft.CmdPal.Ext.WindowWalker.UnitTests\Microsoft.CmdPal.Ext.WindowWalker.UnitTests.csproj", "{B0FE6EF3-5FB3-B8DC-7507-008BBB392FD8}"
+EndProject
 Global
 	GlobalSection(SolutionConfigurationPlatforms) = preSolution
 		Debug|ARM64 = Debug|ARM64
@@ -2758,6 +2765,38 @@ Global
 		{840455DF-5634-51BB-D937-9D7D32F0B0C2}.Release|ARM64.Build.0 = Release|ARM64
 		{840455DF-5634-51BB-D937-9D7D32F0B0C2}.Release|x64.ActiveCfg = Release|x64
 		{840455DF-5634-51BB-D937-9D7D32F0B0C2}.Release|x64.Build.0 = Release|x64
+		{2CF0567E-1E00-4E3F-1561-BF85F5CE5FE7}.Debug|ARM64.ActiveCfg = Debug|ARM64
+		{2CF0567E-1E00-4E3F-1561-BF85F5CE5FE7}.Debug|ARM64.Build.0 = Debug|ARM64
+		{2CF0567E-1E00-4E3F-1561-BF85F5CE5FE7}.Debug|x64.ActiveCfg = Debug|x64
+		{2CF0567E-1E00-4E3F-1561-BF85F5CE5FE7}.Debug|x64.Build.0 = Debug|x64
+		{2CF0567E-1E00-4E3F-1561-BF85F5CE5FE7}.Release|ARM64.ActiveCfg = Release|ARM64
+		{2CF0567E-1E00-4E3F-1561-BF85F5CE5FE7}.Release|ARM64.Build.0 = Release|ARM64
+		{2CF0567E-1E00-4E3F-1561-BF85F5CE5FE7}.Release|x64.ActiveCfg = Release|x64
+		{2CF0567E-1E00-4E3F-1561-BF85F5CE5FE7}.Release|x64.Build.0 = Release|x64
+		{790247CB-2B95-E139-E933-09D10137EEAF}.Debug|ARM64.ActiveCfg = Debug|ARM64
+		{790247CB-2B95-E139-E933-09D10137EEAF}.Debug|ARM64.Build.0 = Debug|ARM64
+		{790247CB-2B95-E139-E933-09D10137EEAF}.Debug|x64.ActiveCfg = Debug|x64
+		{790247CB-2B95-E139-E933-09D10137EEAF}.Debug|x64.Build.0 = Debug|x64
+		{790247CB-2B95-E139-E933-09D10137EEAF}.Release|ARM64.ActiveCfg = Release|ARM64
+		{790247CB-2B95-E139-E933-09D10137EEAF}.Release|ARM64.Build.0 = Release|ARM64
+		{790247CB-2B95-E139-E933-09D10137EEAF}.Release|x64.ActiveCfg = Release|x64
+		{790247CB-2B95-E139-E933-09D10137EEAF}.Release|x64.Build.0 = Release|x64
+		{18525614-CDB2-8BBE-B1B4-3812CD990C22}.Debug|ARM64.ActiveCfg = Debug|ARM64
+		{18525614-CDB2-8BBE-B1B4-3812CD990C22}.Debug|ARM64.Build.0 = Debug|ARM64
+		{18525614-CDB2-8BBE-B1B4-3812CD990C22}.Debug|x64.ActiveCfg = Debug|x64
+		{18525614-CDB2-8BBE-B1B4-3812CD990C22}.Debug|x64.Build.0 = Debug|x64
+		{18525614-CDB2-8BBE-B1B4-3812CD990C22}.Release|ARM64.ActiveCfg = Release|ARM64
+		{18525614-CDB2-8BBE-B1B4-3812CD990C22}.Release|ARM64.Build.0 = Release|ARM64
+		{18525614-CDB2-8BBE-B1B4-3812CD990C22}.Release|x64.ActiveCfg = Release|x64
+		{18525614-CDB2-8BBE-B1B4-3812CD990C22}.Release|x64.Build.0 = Release|x64
+		{B0FE6EF3-5FB3-B8DC-7507-008BBB392FD8}.Debug|ARM64.ActiveCfg = Debug|ARM64
+		{B0FE6EF3-5FB3-B8DC-7507-008BBB392FD8}.Debug|ARM64.Build.0 = Debug|ARM64
+		{B0FE6EF3-5FB3-B8DC-7507-008BBB392FD8}.Debug|x64.ActiveCfg = Debug|x64
+		{B0FE6EF3-5FB3-B8DC-7507-008BBB392FD8}.Debug|x64.Build.0 = Debug|x64
+		{B0FE6EF3-5FB3-B8DC-7507-008BBB392FD8}.Release|ARM64.ActiveCfg = Release|ARM64
+		{B0FE6EF3-5FB3-B8DC-7507-008BBB392FD8}.Release|ARM64.Build.0 = Release|ARM64
+		{B0FE6EF3-5FB3-B8DC-7507-008BBB392FD8}.Release|x64.ActiveCfg = Release|x64
+		{B0FE6EF3-5FB3-B8DC-7507-008BBB392FD8}.Release|x64.Build.0 = Release|x64
 	EndGlobalSection
 	GlobalSection(SolutionProperties) = preSolution
 		HideSolutionNode = FALSE
@@ -3047,6 +3086,11 @@ Global
 		{9D3F3793-EFE3-4525-8782-238015DABA62} = {89E20BCE-EB9C-46C8-8B50-E01A82E6FDC3}
 		{BCDC7246-F4F8-4EED-8DE6-037AA2E7C6D1} = {17B4FA70-001E-4D33-BBBB-0D142DBC2E20}
 		{840455DF-5634-51BB-D937-9D7D32F0B0C2} = {7520A2FE-00A2-49B8-83ED-DB216E874C04}
+		{15EA681E-C7D8-13C7-8484-4AC65E1B71E8} = {3846508C-77EB-4034-A702-F8BB263C4F79}
+		{2CF0567E-1E00-4E3F-1561-BF85F5CE5FE7} = {15EA681E-C7D8-13C7-8484-4AC65E1B71E8}
+		{790247CB-2B95-E139-E933-09D10137EEAF} = {15EA681E-C7D8-13C7-8484-4AC65E1B71E8}
+		{18525614-CDB2-8BBE-B1B4-3812CD990C22} = {15EA681E-C7D8-13C7-8484-4AC65E1B71E8}
+		{B0FE6EF3-5FB3-B8DC-7507-008BBB392FD8} = {15EA681E-C7D8-13C7-8484-4AC65E1B71E8}
 	EndGlobalSection
 	GlobalSection(ExtensibilityGlobals) = postSolution
 		SolutionGuid = {C3A2F9D1-7930-4EF4-A6FC-7EE0A99821D0}

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

@@ -56,6 +56,8 @@ public partial class ListViewModel : PageViewModel, IDisposable
 
     public CommandItemViewModel EmptyContent { get; private set; }
 
+    public bool IsMainPage { get; init; }
+
     private bool _isDynamic;
 
     private Task? _initializeItemsTask;
@@ -370,6 +372,7 @@ public partial class ListViewModel : PageViewModel, IDisposable
                }
 
                TextToSuggest = item.TextToSuggest;
+               WeakReferenceMessenger.Default.Send<UpdateSuggestionMessage>(new(item.TextToSuggest));
            });
 
         _lastSelectedItem = item;
@@ -423,6 +426,8 @@ public partial class ListViewModel : PageViewModel, IDisposable
 
                WeakReferenceMessenger.Default.Send<HideDetailsMessage>();
 
+               WeakReferenceMessenger.Default.Send<UpdateSuggestionMessage>(new(string.Empty));
+
                TextToSuggest = string.Empty;
            });
     }

src/modules/cmdpal/Microsoft.CmdPal.Core.ViewModels/Messages/UpdateSuggestionMessage.cs

@@ -0,0 +1,9 @@
+// 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.Core.ViewModels.Messages;
+
+public record UpdateSuggestionMessage(string TextToSuggest)
+{
+}

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

@@ -263,7 +263,7 @@ public partial class MainListPage : DynamicListPage,
         {
              nameMatch,
              descriptionMatch,
-             isFallback ? 1 : 0, // Always give fallbacks a chance...
+             isFallback ? 1 : 0, // Always give fallbacks a chance
         };
         var max = scores.Max();
 
@@ -273,8 +273,7 @@ public partial class MainListPage : DynamicListPage,
         // above "git" from "whatever"
         max = max + extensionTitleMatch;
 
-        // ... but downweight them
-        var matchSomething = (max / (isFallback ? 3 : 1))
+        var matchSomething = max
             + (isAliasMatch ? 9001 : (isAliasSubstringMatch ? 1 : 0));
 
         // If we matched title, subtitle, or alias (something real), then

src/modules/cmdpal/Microsoft.CmdPal.UI/App.xaml.cs

@@ -98,10 +98,12 @@ public partial class App : Application
 
         // Built-in Commands. Order matters - this is the order they'll be presented by default.
         var allApps = new AllAppsCommandProvider();
+        var files = new IndexerCommandsProvider();
+        files.SuppressFallbackWhen(ShellCommandsProvider.SuppressFileFallbackIf);
         services.AddSingleton<ICommandProvider>(allApps);
         services.AddSingleton<ICommandProvider, ShellCommandsProvider>();
         services.AddSingleton<ICommandProvider, CalculatorCommandProvider>();
-        services.AddSingleton<ICommandProvider, IndexerCommandsProvider>();
+        services.AddSingleton<ICommandProvider>(files);
         services.AddSingleton<ICommandProvider, BookmarksCommandProvider>();
 
         services.AddSingleton<ICommandProvider, WindowWalkerCommandsProvider>();

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

@@ -2,7 +2,6 @@
 // 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.Diagnostics;
 using CommunityToolkit.Mvvm.Messaging;
 using CommunityToolkit.WinUI;
 using Microsoft.CmdPal.Core.ViewModels;
@@ -21,6 +20,7 @@ namespace Microsoft.CmdPal.UI.Controls;
 public sealed partial class SearchBar : UserControl,
     IRecipient<GoHomeMessage>,
     IRecipient<FocusSearchBoxMessage>,
+    IRecipient<UpdateSuggestionMessage>,
     ICurrentPageAware
 {
     private readonly DispatcherQueue _queue = DispatcherQueue.GetForCurrentThread();
@@ -31,6 +31,10 @@ public sealed partial class SearchBar : UserControl,
     private readonly DispatcherQueueTimer _debounceTimer = DispatcherQueue.GetForCurrentThread().CreateTimer();
     private bool _isBackspaceHeld;
 
+    private bool _inSuggestion;
+    private string? _lastText;
+    private string? _deletedSuggestion;
+
     public PageViewModel? CurrentPageViewModel
     {
         get => (PageViewModel?)GetValue(CurrentPageViewModelProperty);
@@ -69,6 +73,7 @@ public sealed partial class SearchBar : UserControl,
         this.InitializeComponent();
         WeakReferenceMessenger.Default.Register<GoHomeMessage>(this);
         WeakReferenceMessenger.Default.Register<FocusSearchBoxMessage>(this);
+        WeakReferenceMessenger.Default.Register<UpdateSuggestionMessage>(this);
     }
 
     public void ClearSearch()
@@ -125,15 +130,6 @@ public sealed partial class SearchBar : UserControl,
             WeakReferenceMessenger.Default.Send<OpenContextMenuMessage>(new OpenContextMenuMessage(null, null, null, ContextMenuFilterLocation.Bottom));
             e.Handled = true;
         }
-        else if (e.Key == VirtualKey.Right)
-        {
-            if (CurrentPageViewModel != null && !string.IsNullOrEmpty(CurrentPageViewModel.TextToSuggest))
-            {
-                FilterBox.Text = CurrentPageViewModel.TextToSuggest;
-                FilterBox.Select(FilterBox.Text.Length, 0);
-                e.Handled = true;
-            }
-        }
         else if (e.Key == VirtualKey.Escape)
         {
             if (string.IsNullOrEmpty(FilterBox.Text))
@@ -200,12 +196,65 @@ public sealed partial class SearchBar : UserControl,
 
             e.Handled = true;
         }
+        else if (e.Key == VirtualKey.Right)
+        {
+            if (_inSuggestion)
+            {
+                _inSuggestion = false;
+                _lastText = null;
+                DoFilterBoxUpdate();
+            }
+        }
         else if (e.Key == VirtualKey.Down)
         {
             WeakReferenceMessenger.Default.Send<NavigateNextCommand>();
 
             e.Handled = true;
         }
+
+        if (_inSuggestion)
+        {
+            if (
+                 e.Key == VirtualKey.Back ||
+                 e.Key == VirtualKey.Delete
+                 )
+            {
+                _deletedSuggestion = FilterBox.Text;
+
+                FilterBox.Text = _lastText ?? string.Empty;
+                FilterBox.Select(FilterBox.Text.Length, 0);
+
+                // Logger.LogInfo("deleting suggestion");
+                _inSuggestion = false;
+                _lastText = null;
+
+                e.Handled = true;
+                return;
+            }
+
+            var ignoreLeave =
+
+                e.Key == VirtualKey.Up ||
+                e.Key == VirtualKey.Down ||
+
+                e.Key == VirtualKey.RightMenu ||
+                e.Key == VirtualKey.LeftMenu ||
+                e.Key == VirtualKey.Menu ||
+                e.Key == VirtualKey.Shift ||
+                e.Key == VirtualKey.RightShift ||
+                e.Key == VirtualKey.LeftShift ||
+                e.Key == VirtualKey.RightControl ||
+                e.Key == VirtualKey.LeftControl ||
+                e.Key == VirtualKey.Control;
+            if (ignoreLeave)
+            {
+                return;
+            }
+
+            // Logger.LogInfo("leaving suggestion");
+            _inSuggestion = false;
+            _lastText = null;
+        }
     }
 
     private void FilterBox_PreviewKeyUp(object sender, KeyRoutedEventArgs e)
@@ -219,7 +268,7 @@ public sealed partial class SearchBar : UserControl,
 
     private void FilterBox_TextChanged(object sender, TextChangedEventArgs e)
     {
-        Debug.WriteLine($"FilterBox_TextChanged: {FilterBox.Text}");
+        // Logger.LogInfo($"FilterBox_TextChanged: {FilterBox.Text}");
 
         // TERRIBLE HACK TODO GH #245
         // There's weird wacky bugs with debounce currently. We're trying
@@ -228,23 +277,22 @@ public sealed partial class SearchBar : UserControl,
         // (otherwise aliases just stop working)
         if (FilterBox.Text.Length == 1)
         {
-            if (CurrentPageViewModel != null)
-            {
-                CurrentPageViewModel.Filter = FilterBox.Text;
-            }
+            DoFilterBoxUpdate();
 
             return;
         }
 
+        if (_inSuggestion)
+        {
+            // Logger.LogInfo($"-- skipping, in suggestion --");
+            return;
+        }
+
         // TODO: We could encapsulate this in a Behavior if we wanted to bind to the Filter property.
         _debounceTimer.Debounce(
             () =>
             {
-                // Actually plumb Filtering to the view model
-                if (CurrentPageViewModel != null)
-                {
-                    CurrentPageViewModel.Filter = FilterBox.Text;
-                }
+                DoFilterBoxUpdate();
             },
             //// Couldn't find a good recommendation/resource for value here. PT uses 50ms as default, so that is a reasonable default
             //// This seems like a useful testing site for typing times: https://keyboardtester.info/keyboard-latency-test/
@@ -254,6 +302,21 @@ public sealed partial class SearchBar : UserControl,
             immediate: FilterBox.Text.Length <= 1);
     }
 
+    private void DoFilterBoxUpdate()
+    {
+        if (_inSuggestion)
+        {
+            // Logger.LogInfo($"--- skipping ---");
+            return;
+        }
+
+        // Actually plumb Filtering to the view model
+        if (CurrentPageViewModel != null)
+        {
+            CurrentPageViewModel.Filter = FilterBox.Text;
+        }
+    }
+
     // Used to handle the case when a ListPage's `SearchText` may have changed
     private void Page_PropertyChanged(object? sender, System.ComponentModel.PropertyChangedEventArgs e)
     {
@@ -273,6 +336,8 @@ public sealed partial class SearchBar : UserControl,
                     // ... Move the cursor to the end of the input
                     FilterBox.Select(FilterBox.Text.Length, 0);
                 }
+
+                // TODO! deal with suggestion
             }
             else if (property == nameof(ListViewModel.InitialSearchText))
             {
@@ -290,4 +355,96 @@ public sealed partial class SearchBar : UserControl,
     public void Receive(GoHomeMessage message) => ClearSearch();
 
     public void Receive(FocusSearchBoxMessage message) => FilterBox.Focus(Microsoft.UI.Xaml.FocusState.Programmatic);
+
+    public void Receive(UpdateSuggestionMessage message)
+    {
+        var suggestion = message.TextToSuggest;
+
+        _queue.TryEnqueue(new(() =>
+        {
+            var clearSuggestion = string.IsNullOrEmpty(suggestion);
+
+            if (clearSuggestion && _inSuggestion)
+            {
+                // Logger.LogInfo($"Cleared suggestion \"{_lastText}\" to {suggestion}");
+                _inSuggestion = false;
+                FilterBox.Text = _lastText ?? string.Empty;
+                _lastText = null;
+                return;
+            }
+
+            if (clearSuggestion)
+            {
+                _deletedSuggestion = null;
+                return;
+            }
+
+            if (suggestion == _deletedSuggestion)
+            {
+                return;
+            }
+            else
+            {
+                _deletedSuggestion = null;
+            }
+
+            var currentText = _lastText ?? FilterBox.Text;
+
+            _lastText = currentText;
+
+            // if (_inSuggestion)
+            // {
+            //     Logger.LogInfo($"Suggestion from \"{_lastText}\" to {suggestion}");
+            // }
+            // else
+            // {
+            //     Logger.LogInfo($"Entering suggestion from \"{_lastText}\" to {suggestion}");
+            // }
+            _inSuggestion = true;
+
+            var matchedChars = 0;
+            var suggestionStartsWithQuote = suggestion.Length > 0 && suggestion[0] == '"';
+            var currentStartsWithQuote = currentText.Length > 0 && currentText[0] == '"';
+            var skipCheckingFirst = suggestionStartsWithQuote && !currentStartsWithQuote;
+            for (int i = skipCheckingFirst ? 1 : 0, j = 0;
+                 i < suggestion.Length && j < currentText.Length;
+                 i++, j++)
+            {
+                if (string.Equals(
+                    suggestion[i].ToString(),
+                    currentText[j].ToString(),
+                    StringComparison.OrdinalIgnoreCase))
+                {
+                    matchedChars++;
+                }
+                else
+                {
+                    break;
+                }
+            }
+
+            var first = skipCheckingFirst ? "\"" : string.Empty;
+            var second = currentText.AsSpan(0, matchedChars);
+            var third = suggestion.AsSpan(matchedChars + (skipCheckingFirst ? 1 : 0));
+
+            var newText = string.Concat(
+                first,
+                second,
+                third);
+
+            FilterBox.Text = newText;
+
+            var wrappedInQuotes = suggestionStartsWithQuote && suggestion.Last() == '"';
+            if (wrappedInQuotes)
+            {
+                FilterBox.Select(
+                    (skipCheckingFirst ? 1 : 0) + matchedChars,
+                    Math.Max(0, suggestion.Length - matchedChars - 1 + (skipCheckingFirst ? -1 : 0)));
+            }
+            else
+            {
+                FilterBox.Select(matchedChars, suggestion.Length - matchedChars);
+            }
+        }));
+    }
 }

src/modules/cmdpal/Microsoft.CmdPal.UI/ExtViews/ListPage.xaml.cs

@@ -265,6 +265,13 @@ public sealed partial class ListPage : Page,
         {
             ItemsList.SelectedIndex = 0;
         }
+
+        // Always reset the selected item when the top-level list page changes
+        // its items
+        if (!sender.IsNested)
+        {
+            ItemsList.SelectedIndex = 0;
+        }
     }
 
     private void ViewModel_PropertyChanged(object? sender, System.ComponentModel.PropertyChangedEventArgs e)

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

@@ -411,7 +411,7 @@ Right-click to remove the key combination, thereby deactivating the shortcut.</v
     <value>Back</value>
   </data>
   <data name="BackButton.[using:Microsoft.UI.Xaml.Controls]ToolTipService.ToolTip" xml:space="preserve">
-    <value>Back</value>
+    <value>Back (Alt + Left arrow)</value>
   </data>
   <data name="MoreCommandsButton.[using:Microsoft.UI.Xaml.Automation]AutomationProperties.Name" xml:space="preserve">
     <value>More</value>

src/modules/cmdpal/Microsoft.CmdPal.UI/Styles/TextBox.xaml

@@ -186,6 +186,8 @@
                             x:Load="False"
                             AutomationProperties.AccessibilityView="Raw"
                             CharacterSpacing="15"
+                            FontFamily="{TemplateBinding FontFamily}"
+                            FontSize="{TemplateBinding FontSize}"
                             Foreground="{Binding PlaceholderForeground, RelativeSource={RelativeSource TemplatedParent}, TargetNullValue={ThemeResource TextControlPlaceholderForeground}}"
                             Text="{TemplateBinding Description}"
                             TextWrapping="{TemplateBinding TextWrapping}" />

src/modules/cmdpal/Microsoft.CmdPal.UI/rd.xml

@@ -3,5 +3,8 @@
 		<Assembly Name="Microsoft.WinUI">
 			<Type Name="Microsoft.UI.Xaml.Controls.FontIconSource" Dynamic="Required All" />
 		</Assembly>
+		<Assembly Name="Microsoft.CmdPal.UI">
+			<Type Name="Microsoft.CmdPal.UI.ContextItemTemplateSelector" Dynamic="Required All" />
+		</Assembly>
 	</Application>
 </Directives>

src/modules/cmdpal/Microsoft.CmdPal.UITests/BasicTests.cs

@@ -10,33 +10,12 @@ using Microsoft.VisualStudio.TestTools.UnitTesting;
 namespace Microsoft.CmdPal.UITests;
 
 [TestClass]
-public class BasicTests : UITestBase
+public class BasicTests : CommandPaletteTestBase
 {
     public BasicTests()
-        : base(PowerToysModule.CommandPalette)
     {
     }
 
-    private void SetSearchBox(string text)
-    {
-        Assert.AreEqual(this.Find<TextBox>("Type here to search...").SetText(text, true).Text, text);
-    }
-
-    private void SetFilesExtensionSearchBox(string text)
-    {
-        Assert.AreEqual(this.Find<TextBox>("Search for files and folders...").SetText(text, true).Text, text);
-    }
-
-    private void SetCalculatorExtensionSearchBox(string text)
-    {
-        Assert.AreEqual(this.Find<TextBox>("Type an equation...").SetText(text, true).Text, text);
-    }
-
-    private void SetTimeAndDaterExtensionSearchBox(string text)
-    {
-        Assert.AreEqual(this.Find<TextBox>("Search values or type a custom time stamp...").SetText(text, true).Text, text);
-    }
-
     [TestMethod]
     public void BasicFileSearchTest()
     {

src/modules/cmdpal/Microsoft.CmdPal.UITests/CommandPaletteTestBase.cs

@@ -0,0 +1,48 @@
+// 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 Microsoft.PowerToys.UITest;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+
+namespace Microsoft.CmdPal.UITests;
+
+public class CommandPaletteTestBase : UITestBase
+{
+    public CommandPaletteTestBase()
+        : base(PowerToysModule.CommandPalette)
+    {
+    }
+
+    protected void SetSearchBox(string text)
+    {
+        Assert.AreEqual(this.Find<TextBox>("Type here to search...").SetText(text, true).Text, text);
+    }
+
+    protected void SetFilesExtensionSearchBox(string text)
+    {
+        Assert.AreEqual(this.Find<TextBox>("Search for files and folders...").SetText(text, true).Text, text);
+    }
+
+    protected void SetCalculatorExtensionSearchBox(string text)
+    {
+        Assert.AreEqual(this.Find<TextBox>("Type an equation...").SetText(text, true).Text, text);
+    }
+
+    protected void SetTimeAndDaterExtensionSearchBox(string text)
+    {
+        Assert.AreEqual(this.Find<TextBox>("Search values or type a custom time stamp...").SetText(text, true).Text, text);
+    }
+
+    protected void OpenContextMenu()
+    {
+        var contextMenuButton = this.Find<Button>("More");
+        Assert.IsNotNull(contextMenuButton, "Context menu button not found.");
+        contextMenuButton.Click();
+    }
+}

src/modules/cmdpal/Microsoft.CmdPal.UITests/IndexerTests.cs

@@ -0,0 +1,226 @@
+// 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 System.Xml.Linq;
+using Microsoft.PowerToys.UITest;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+
+namespace Microsoft.CmdPal.UITests;
+
+[TestClass]
+public class IndexerTests : CommandPaletteTestBase
+{
+    private const string TestFileContent = "This is Indexer UI test sample";
+    private const string TestFileName = "indexer_test_item.txt";
+    private const string TestFolderName = "Downloads";
+
+    public IndexerTests()
+        : base()
+    {
+        // create a empty file in Downloads folder
+        // to ensure that the indexer has something to search for
+        var downloadsPath = Environment.GetFolderPath(Environment.SpecialFolder.UserProfile) + "\\Downloads";
+        var emptyFilePath = System.IO.Path.Combine(downloadsPath, TestFileName);
+        if (!System.IO.File.Exists(emptyFilePath))
+        {
+            using (var fileStream = System.IO.File.Create(emptyFilePath))
+            {
+                var content = TestFileContent;
+                var contentBytes = Encoding.UTF8.GetBytes(content);
+                fileStream.Write(contentBytes, 0, contentBytes.Length);
+            }
+        }
+    }
+
+    public void EnterIndexerExtension()
+    {
+        SetSearchBox("files");
+
+        var searchFileItem = this.Find<NavigationViewItem>("Search files");
+        Assert.AreEqual(searchFileItem.Name, "Search files");
+        searchFileItem.DoubleClick();
+    }
+
+    [TestMethod]
+    public void BasicIndexerSearchTest()
+    {
+        EnterIndexerExtension();
+        SetFilesExtensionSearchBox("Downloads");
+        Assert.IsNotNull(this.Find<NavigationViewItem>("Downloads"));
+    }
+
+    [TestMethod]
+    public void IndexerOpenFileTest()
+    {
+        EnterIndexerExtension();
+        SetFilesExtensionSearchBox(TestFileName);
+
+        var searchItem = this.Find<NavigationViewItem>(TestFileName);
+
+        Assert.IsNotNull(searchItem);
+
+        searchItem.Click();
+
+        var openButton = this.Find<Button>("Open");
+        Assert.IsNotNull(openButton);
+
+        openButton.Click();
+        var notepadWindow = this.Find<Window>($"{TestFileName} - Notepad", global: true);
+
+        Assert.IsNotNull(notepadWindow);
+    }
+
+    [TestMethod]
+    public void IndexerDoubleClickOpenFileTest()
+    {
+        EnterIndexerExtension();
+        SetFilesExtensionSearchBox(TestFileName);
+
+        var searchItem = this.Find<NavigationViewItem>(TestFileName);
+
+        Assert.IsNotNull(searchItem);
+
+        searchItem.DoubleClick();
+
+        var notepadWindow = this.Find<Window>($"{TestFileName} - Notepad", global: true);
+
+        Assert.IsNotNull(notepadWindow);
+    }
+
+    [TestMethod]
+    public void IndexerOpenFolderTest()
+    {
+        EnterIndexerExtension();
+        SetFilesExtensionSearchBox(TestFolderName);
+
+        var searchItem = this.Find<NavigationViewItem>(TestFolderName);
+        Assert.IsNotNull(searchItem);
+        searchItem.Click();
+
+        var openButton = this.Find<Button>("Open");
+        Assert.IsNotNull(openButton);
+
+        openButton.Click();
+        var notepadWindow = this.Find<Window>($"{TestFolderName} - File Explorer", global: true);
+
+        Assert.IsNotNull(notepadWindow);
+    }
+
+    [TestMethod]
+    public void IndexerDoubleClickOpenFolderTest()
+    {
+        EnterIndexerExtension();
+        SetFilesExtensionSearchBox(TestFolderName);
+
+        var searchItem = this.Find<NavigationViewItem>(TestFolderName);
+        Assert.IsNotNull(searchItem);
+        searchItem.DoubleClick();
+
+        var fileExplorer = this.Find<Window>($"{TestFolderName} - File Explorer", global: true);
+
+        Assert.IsNotNull(fileExplorer);
+    }
+
+    [TestMethod]
+    public void IndexerBrowseFolderTest()
+    {
+        EnterIndexerExtension();
+        SetFilesExtensionSearchBox(TestFolderName);
+
+        var searchItem = this.Find<NavigationViewItem>(TestFolderName);
+        Assert.IsNotNull(searchItem);
+        searchItem.Click();
+
+        var openButton = this.Find<Button>("Browse");
+        Assert.IsNotNull(openButton);
+
+        openButton.Click();
+
+        var testItem = this.Find<NavigationViewItem>(TestFileName);
+        Assert.IsNotNull(testItem);
+    }
+
+    [STATestMethod]
+    [TestMethod]
+    public void IndexerCopyPathTest()
+    {
+        EnterIndexerExtension();
+        SetFilesExtensionSearchBox(TestFileName);
+
+        var searchItem = this.Find<NavigationViewItem>(TestFileName);
+        Assert.IsNotNull(searchItem);
+        searchItem.Click();
+
+        OpenContextMenu();
+        var copyPathButton = this.Find<NavigationViewItem>("Copy path");
+        Assert.IsNotNull(copyPathButton);
+        copyPathButton.Click();
+
+        var clipboardContent = System.Windows.Forms.Clipboard.GetText();
+        Assert.IsTrue(clipboardContent.Contains(TestFileName), $"Clipboard content does not contain the expected file name. clipboard: {clipboardContent}");
+    }
+
+    [TestMethod]
+    public void IndexerShowInFolderTest()
+    {
+        EnterIndexerExtension();
+        SetFilesExtensionSearchBox(TestFileName);
+
+        var searchItem = this.Find<NavigationViewItem>(TestFileName);
+        Assert.IsNotNull(searchItem);
+        searchItem.Click();
+
+        OpenContextMenu();
+        var showInFolderButton = this.Find<NavigationViewItem>("Show in folder");
+        Assert.IsNotNull(showInFolderButton);
+        showInFolderButton.Click();
+
+        var fileExplorer = this.Find<Window>($"{TestFolderName} - File Explorer", global: true, timeoutMS: 20000);
+
+        Assert.IsNotNull(fileExplorer);
+    }
+
+    [TestMethod]
+    public void IndexerOpenPathInConsoleTest()
+    {
+        EnterIndexerExtension();
+        SetFilesExtensionSearchBox(TestFileName);
+
+        var searchItem = this.Find<NavigationViewItem>(TestFileName);
+        Assert.IsNotNull(searchItem);
+        searchItem.Click();
+
+        OpenContextMenu();
+        var copyPathButton = this.Find<NavigationViewItem>("Open path in console");
+        Assert.IsNotNull(copyPathButton);
+        copyPathButton.Click();
+
+        var textItem = this.Find<Window>("C:\\Windows\\system32\\cmd.exe", global: true);
+        Assert.IsNotNull(textItem, "The console did not open with the expected path.");
+    }
+
+    [TestMethod]
+    public void IndexerOpenPropertiesTest()
+    {
+        EnterIndexerExtension();
+        SetFilesExtensionSearchBox(TestFileName);
+
+        var searchItem = this.Find<NavigationViewItem>(TestFileName);
+        Assert.IsNotNull(searchItem);
+        searchItem.Click();
+
+        OpenContextMenu();
+        var copyPathButton = this.Find<NavigationViewItem>("Properties");
+        Assert.IsNotNull(copyPathButton);
+        copyPathButton.Click();
+
+        var propertiesWindow = this.Find<Window>($"{TestFileName} Properties", global: true);
+        Assert.IsNotNull(propertiesWindow, "The properties window did not open for the selected file.");
+    }
+}

src/modules/cmdpal/README.md

@@ -2,16 +2,15 @@
 
 Windows Command Palette ("CmdPal") is the next iteration of PowerToys Run. With extensibility at its core, the Command Palette is your one-stop launcher to start _anything_.
 
-By default, CmdPal is bound to <kbd>Win+Alt+Space</kbd>. 
-
+By default, CmdPal is bound to <kbd>Win+Alt+Space</kbd>.
 
 ## Creating an extension
 
-The fastest way to get started is just to run the "Create extension" command in the palette itself. That'll prompt you for a project name and a Display Name, and where you want to place your project. Then just open the `sln` it produces. You should be ready to go 🙂. 
+The fastest way to get started is just to run the "Create extension" command in the palette itself. That'll prompt you for a project name and a Display Name, and where you want to place your project. Then just open the `sln` it produces. You should be ready to go 🙂.
 
 The official API documentation can be found [on this docs site](https://learn.microsoft.com/windows/powertoys/command-palette/extensibility-overview).
 
-We've also got samples, so that you can see how the APIs in-action. 
+We've also got samples, so that you can see how the APIs in-action.
 
 * We've got [generic samples] in the repo
 * We've got [real samples] in the repo too
@@ -22,14 +21,22 @@ We've also got samples, so that you can see how the APIs in-action.
 
 ## Building CmdPal
 
-The Command Palette is included as a part of PowerToys. To get started building, open up the root `PowerToys.sln`, to get started building. 
+### Install & Build PowerToys
+
+1. Follow the install and build instructions for [PowerToys](https://github.com/microsoft/PowerToys/tree/main/doc/devdocs#compiling-powertoys)
+
+### Load & Build
+
+1. In Visual Studio, in the Solution Explorer Pane, confirm that all of the files/projects in `src\modules\CommandPalette` and `src\common\CalculatorEngineCommon` do not have `(unloaded)` on the right side
+    1. If any file has `(unloaded)`, right click on file and select `Reload Project`
+1. Now you can right click on one of the project below to `Build` and then `Deploy`:
 
 Projects of interest are:
 * `Microsoft.CmdPal.UI`: This is the main project for CmdPal. Build and run this to get the CmdPal.
 * `Microsoft.CommandPalette.Extensions`: This is the official extension interface. 
   * This is designed to be language-agnostic. Any programming language which supports implementing WinRT interfaces should be able to implement the WinRT interface. 
 * `Microsoft.CommandPalette.Extensions.Toolkit`: This is a C# helper library for creating extensions. This makes writing extensions easier.
-* Everything under "SampleExtensions": These are example plugins to demo how to author extensions. Deploy any number of these, to get a feel for how the extension API works. 
+* Everything under "SampleExtensions": These are example plugins to demo how to author extensions. Deploy any number of these, to get a feel for how the extension API works.
 
 ### Footnotes and other links
 

src/modules/cmdpal/Tests/Microsoft.CmdPal.Ext.Registry.UnitTests/BasicStructureTest.cs

@@ -0,0 +1,18 @@
+// 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.VisualStudio.TestTools.UnitTesting;
+
+namespace Microsoft.CmdPal.Ext.Registry.UnitTests;
+
+[TestClass]
+public class BasicStructureTest
+{
+    [TestMethod]
+    public void CanCreateTestClass()
+    {
+        // This is a basic test to verify the test project structure is correct
+        Assert.IsTrue(true);
+    }
+}

src/modules/cmdpal/Tests/Microsoft.CmdPal.Ext.Registry.UnitTests/KeyNameTest.cs

@@ -0,0 +1,26 @@
+// 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.Ext.Registry.Constants;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+
+namespace Microsoft.CmdPal.Ext.Registry.UnitTests;
+
+[TestClass]
+public class KeyNameTest
+{
+    [TestMethod]
+    [DataRow("HKEY", KeyName.FirstPart)]
+    [DataRow("HKEY_", KeyName.FirstPartUnderscore)]
+    [DataRow("HKCR", KeyName.ClassRootShort)]
+    [DataRow("HKCC", KeyName.CurrentConfigShort)]
+    [DataRow("HKCU", KeyName.CurrentUserShort)]
+    [DataRow("HKLM", KeyName.LocalMachineShort)]
+    [DataRow("HKPD", KeyName.PerformanceDataShort)]
+    [DataRow("HKU", KeyName.UsersShort)]
+    public void TestConstants(string shortName, string baseName)
+    {
+        Assert.AreEqual(shortName, baseName);
+    }
+}

src/modules/cmdpal/Tests/Microsoft.CmdPal.Ext.Registry.UnitTests/Microsoft.CmdPal.Ext.Registry.UnitTests.csproj

@@ -0,0 +1,22 @@
+<Project Sdk="Microsoft.NET.Sdk">
+  <!-- Look at Directory.Build.props in root for common stuff as well -->
+  <Import Project="..\..\..\..\Common.Dotnet.CsWinRT.props" />
+
+  <PropertyGroup>
+    <IsPackable>false</IsPackable>
+    <IsTestProject>true</IsTestProject>
+    <RootNamespace>Microsoft.CmdPal.Ext.Registry.UnitTests</RootNamespace>
+    <OutputPath>$(SolutionDir)$(Platform)\$(Configuration)\WinUI3Apps\CmdPal\tests\</OutputPath>
+    <AppendTargetFrameworkToOutputPath>false</AppendTargetFrameworkToOutputPath>
+    <AppendRuntimeIdentifierToOutputPath>false</AppendRuntimeIdentifierToOutputPath>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <PackageReference Include="Moq" />
+    <PackageReference Include="MSTest" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="..\..\ext\Microsoft.CmdPal.Ext.Registry\Microsoft.CmdPal.Ext.Registry.csproj" />
+  </ItemGroup>
+</Project>

src/modules/cmdpal/Tests/Microsoft.CmdPal.Ext.Registry.UnitTests/QueryHelperTest.cs

@@ -0,0 +1,52 @@
+// 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.Ext.Registry.Helpers;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+
+namespace Microsoft.CmdPal.Ext.Registry.UnitTests;
+
+[TestClass]
+public class QueryHelperTest
+{
+    [TestMethod]
+    [DataRow(@"HKLM", false, @"HKLM", "")]
+    [DataRow(@"HKLM\", false, @"HKLM\", "")]
+    [DataRow(@"HKLM\\", true, @"HKLM", "")]
+    [DataRow(@"HKLM\\Test", true, @"HKLM", "Test")]
+    [DataRow(@"HKLM\Test\\TestTest", true, @"HKLM\Test", "TestTest")]
+    [DataRow(@"HKLM\Test\\\TestTest", true, @"HKLM\Test", @"\TestTest")]
+    [DataRow("HKLM/\"Software\"/", false, @"HKLM\Software\", "")]
+    [DataRow("HKLM/\"Software\"//test", true, @"HKLM\Software", "test")]
+    [DataRow("HKLM/\"Software\"//test/123", true, @"HKLM\Software", "test/123")]
+    [DataRow("HKLM/\"Software\"//test\\123", true, @"HKLM\Software", @"test\123")]
+    [DataRow("HKLM/\"Software\"/test", false, @"HKLM\Software\test", "")]
+    [DataRow("HKLM\\Software\\\"test\"", false, @"HKLM\Software\test", "")]
+    [DataRow("HKLM\\\"Software\"\\\"test\"", false, @"HKLM\Software\test", "")]
+    [DataRow("HKLM\\\"Software\"\\\"test/software\"", false, @"HKLM\Software\test/software", "")]
+    [DataRow("HKLM\\\"Software\"/\"test\"\\hello", false, @"HKLM\Software\test\hello", "")]
+    [DataRow("HKLM\\\"Software\"\\\"test\"\\hello\\\\\"some/value\"", true, @"HKLM\Software\test\hello", "some/value")]
+    [DataRow("HKLM\\\"Software\"\\\"test\"/hello\\\\\"some/value\"", true, @"HKLM\Software\test\hello", "some/value")]
+    [DataRow("HKLM\\\"Software\"\\\"test\"\\hello\\\\some\\value", true, @"HKLM\Software\test\hello", @"some\value")]
+    public void GetQueryPartsTest(string query, bool expectedHasValueName, string expectedQueryKey, string expectedQueryValueName)
+    {
+        var hasValueName = QueryHelper.GetQueryParts(query, out var queryKey, out var queryValueName);
+
+        Assert.AreEqual(expectedHasValueName, hasValueName);
+        Assert.AreEqual(expectedQueryKey, queryKey);
+        Assert.AreEqual(expectedQueryValueName, queryValueName);
+    }
+
+    [TestMethod]
+    [DataRow(@"HKCR\*\OpenWithList", @"HKEY_CLASSES_ROOT\*\OpenWithList")]
+    [DataRow(@"HKCU\Control Panel\Accessibility", @"HKEY_CURRENT_USER\Control Panel\Accessibility")]
+    [DataRow(@"HKLM\HARDWARE\UEFI", @"HKEY_LOCAL_MACHINE\HARDWARE\UEFI")]
+    [DataRow(@"HKU\.DEFAULT\Environment", @"HKEY_USERS\.DEFAULT\Environment")]
+    [DataRow(@"HKCC\System\CurrentControlSet\Control", @"HKEY_CURRENT_CONFIG\System\CurrentControlSet\Control")]
+    [DataRow(@"HKPD\???", @"HKEY_PERFORMANCE_DATA\???")]
+    public void GetShortBaseKeyTest(string registryKeyShort, string registryKeyFull)
+    {
+        Assert.AreEqual(registryKeyShort, QueryHelper.GetKeyWithShortBaseKey(registryKeyFull));
+    }
+}

src/modules/cmdpal/Tests/Microsoft.CmdPal.Ext.Registry.UnitTests/RegistryHelperTest.cs

@@ -0,0 +1,75 @@
+// 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;
+using System.Linq;
+
+using Microsoft.CmdPal.Ext.Registry.Helpers;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+
+namespace Microsoft.CmdPal.Ext.Registry.UnitTests;
+
+[TestClass]
+public class RegistryHelperTest
+{
+    [TestMethod]
+    [DataRow(@"HKCC\System\CurrentControlSet\Control", "HKEY_CURRENT_CONFIG")]
+    [DataRow(@"HKCR\*\OpenWithList", "HKEY_CLASSES_ROOT")]
+    [DataRow(@"HKCU\Control Panel\Accessibility", "HKEY_CURRENT_USER")]
+    [DataRow(@"HKLM\HARDWARE\UEFI", "HKEY_LOCAL_MACHINE")]
+    [DataRow(@"HKPD\???", "HKEY_PERFORMANCE_DATA")]
+    [DataRow(@"HKU\.DEFAULT\Environment", "HKEY_USERS")]
+    public void GetRegistryBaseKeyTestOnlyOneBaseKey(string query, string expectedBaseKey)
+    {
+        var (baseKeyList, _) = RegistryHelper.GetRegistryBaseKey(query);
+        Assert.IsNotNull(baseKeyList);
+        Assert.IsTrue(baseKeyList.Count() == 1);
+        Assert.AreEqual(expectedBaseKey, baseKeyList.First().Name);
+    }
+
+    [TestMethod]
+    public void GetRegistryBaseKeyTestMoreThanOneBaseKey()
+    {
+        var (baseKeyList, _) = RegistryHelper.GetRegistryBaseKey("HKC\\Control Panel\\Accessibility"); /* #no-spell-check-line */
+
+        Assert.IsNotNull(baseKeyList);
+        Assert.IsTrue(baseKeyList.Count() > 1);
+
+        var list = baseKeyList.Select(found => found.Name);
+        Assert.IsTrue(list.Contains("HKEY_CLASSES_ROOT"));
+        Assert.IsTrue(list.Contains("HKEY_CURRENT_CONFIG"));
+        Assert.IsTrue(list.Contains("HKEY_CURRENT_USER"));
+    }
+
+    [TestMethod]
+    [DataRow(@"HKCR\*\OpenWithList", @"*\OpenWithList")]
+    [DataRow(@"HKCU\Control Panel\Accessibility", @"Control Panel\Accessibility")]
+    [DataRow(@"HKLM\HARDWARE\UEFI", @"HARDWARE\UEFI")]
+    [DataRow(@"HKU\.DEFAULT\Environment", @".DEFAULT\Environment")]
+    [DataRow(@"HKCC\System\CurrentControlSet\Control", @"System\CurrentControlSet\Control")]
+    [DataRow(@"HKPD\???", @"???")]
+    public void GetRegistryBaseKeyTestSubKey(string query, string expectedSubKey)
+    {
+        var (_, subKey) = RegistryHelper.GetRegistryBaseKey(query);
+        Assert.AreEqual(expectedSubKey, subKey);
+    }
+
+    [TestMethod]
+    public void GetAllBaseKeysTest()
+    {
+        var list = RegistryHelper.GetAllBaseKeys();
+
+        CollectionAssert.AllItemsAreNotNull((ICollection)list);
+        CollectionAssert.AllItemsAreUnique((ICollection)list);
+
+        var keys = list.Select(found => found.Key).ToList() as ICollection;
+
+        CollectionAssert.Contains(keys, Win32.Registry.ClassesRoot);
+        CollectionAssert.Contains(keys, Win32.Registry.CurrentConfig);
+        CollectionAssert.Contains(keys, Win32.Registry.CurrentUser);
+        CollectionAssert.Contains(keys, Win32.Registry.LocalMachine);
+        CollectionAssert.Contains(keys, Win32.Registry.PerformanceData);
+        CollectionAssert.Contains(keys, Win32.Registry.Users);
+    }
+}

src/modules/cmdpal/Tests/Microsoft.CmdPal.Ext.Registry.UnitTests/ResultHelperTest.cs

@@ -0,0 +1,32 @@
+// 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 Microsoft.CmdPal.Ext.Registry.Helpers;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+
+namespace Microsoft.CmdPal.Ext.Registry.UnitTests;
+
+[TestClass]
+public class ResultHelperTest
+{
+    [TestMethod]
+    [DataRow(@"HKEY_CLASSES_ROOT\*\OpenWithList", @"HKEY_CLASSES_ROOT\*\OpenWithList")]
+    [DataRow(@"HKEY_CURRENT_USER\Control Panel\Accessibility", @"HKEY_CURRENT_USER\Control Panel\Accessibility")]
+    [DataRow(@"HKEY_LOCAL_MACHINE\HARDWARE\UEFI", @"HKEY_LOCAL_MACHINE\HARDWARE\UEFI")]
+    [DataRow(@"HKEY_USERS\.DEFAULT\Environment", @"HKEY_USERS\.DEFAULT\Environment")]
+    [DataRow(@"HKCC\System\CurrentControlSet\Control", @"HKEY_CURRENT_CONFIG\System\CurrentControlSet\Control")]
+    [DataRow(@"HKEY_PERFORMANCE_DATA\???", @"HKEY_PERFORMANCE_DATA\???")]
+    [DataRow(@"HKCR\*\shell\Open with VS Code\command", @"HKEY_CLASSES_ROOT\*\shell\Open with VS Code\command")]
+    [DataRow(@"...ndows\CurrentVersion\Explorer\StartupApproved", @"HKEY_CURRENT_USER\Microsoft\Windows\CurrentVersion\Explorer\StartupApproved")]
+    [DataRow(@"...p\Upgrade\NetworkDriverBackup\Control\Network", @"HKEY_LOCAL_MACHINE\SYSTEM\Setup\Upgrade\NetworkDriverBackup\Control\Network")]
+    [DataRow(@"...anel\International\User Profile System Backup", @"HKEY_USERS\.DEFAULT\Control Panel\International\User Profile System Backup")]
+    [DataRow(@"...stem\CurrentControlSet\Control\Print\Printers", @"HKEY_CURRENT_CONFIG\System\CurrentControlSet\Control\Print\Printers")]
+    public void GetTruncatedTextTest_StandardCases(string registryKeyShort, string registryKeyFull)
+    {
+        Assert.AreEqual(registryKeyShort, ResultHelper.GetTruncatedText(registryKeyFull, 45));
+    }
+}

src/modules/cmdpal/Tests/Microsoft.CmdPal.Ext.System.UnitTests/BasicTests.cs

@@ -0,0 +1,84 @@
+// 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 Microsoft.CmdPal.Ext.System.Helpers;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+
+namespace Microsoft.CmdPal.Ext.System.UnitTests;
+
+[TestClass]
+public class BasicTests
+{
+    [TestMethod]
+    public void CommandsHelperTest()
+    {
+        // Setup & Act
+        var commands = Commands.GetSystemCommands(false, false, false, false);
+
+        // Assert
+        Assert.IsNotNull(commands);
+        Assert.IsTrue(commands.Count > 0);
+    }
+
+    [TestMethod]
+    public void IconsHelperTest()
+    {
+        // Assert
+        Assert.IsNotNull(Icons.FirmwareSettingsIcon);
+        Assert.IsNotNull(Icons.LockIcon);
+        Assert.IsNotNull(Icons.LogoffIcon);
+        Assert.IsNotNull(Icons.NetworkAdapterIcon);
+        Assert.IsNotNull(Icons.RecycleBinIcon);
+        Assert.IsNotNull(Icons.RestartIcon);
+        Assert.IsNotNull(Icons.RestartShellIcon);
+        Assert.IsNotNull(Icons.ShutdownIcon);
+        Assert.IsNotNull(Icons.SleepIcon);
+    }
+
+    [TestMethod]
+    public void Win32HelpersTest()
+    {
+        // Setup & Act
+        // These methods should not throw exceptions
+        var firmwareType = Win32Helpers.GetSystemFirmwareType();
+
+        // Assert
+        // Just testing that they don't throw exceptions
+        Assert.IsTrue(Enum.IsDefined(typeof(FirmwareType), firmwareType));
+    }
+
+    [TestMethod]
+    public void NetworkConnectionPropertiesTest()
+    {
+        // Test that network connection properties can be accessed without throwing exceptions
+        try
+        {
+            var networkPropertiesList = NetworkConnectionProperties.GetList();
+
+            // If we have network connections, test accessing their properties
+            if (networkPropertiesList.Count > 0)
+            {
+                var networkProperties = networkPropertiesList[0];
+
+                // Access properties (these used to be methods)
+                var ipv4 = networkProperties.IPv4;
+                var ipv6 = networkProperties.IPv6Primary;
+                var macAddress = networkProperties.PhysicalAddress;
+
+                // Test passes if no exceptions are thrown
+                Assert.IsTrue(true);
+            }
+            else
+            {
+                // If no network connections, test still passes
+                Assert.IsTrue(true);
+            }
+        }
+        catch
+        {
+            Assert.Fail("Network properties should not throw exceptions");
+        }
+    }
+}

src/modules/cmdpal/Tests/Microsoft.CmdPal.Ext.System.UnitTests/ImageTests.cs

@@ -0,0 +1,72 @@
+// 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.Linq;
+using System.Reflection;
+using Microsoft.CmdPal.Ext.System.Helpers;
+using Microsoft.CmdPal.Ext.System.Pages;
+using Microsoft.CommandPalette.Extensions;
+using Microsoft.CommandPalette.Extensions.Toolkit;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+
+namespace Microsoft.CmdPal.Ext.System.UnitTests;
+
+[TestClass]
+public class ImageTests
+{
+    [DataTestMethod]
+    [DataRow("shutdown", "ShutdownIcon")]
+    [DataRow("restart", "RestartIcon")]
+    [DataRow("sign out", "LogoffIcon")]
+    [DataRow("lock", "LockIcon")]
+    [DataRow("sleep", "SleepIcon")]
+    [DataRow("hibernate", "SleepIcon")]
+    [DataRow("recycle bin", "RecycleBinIcon")]
+    [DataRow("uefi firmware settings", "FirmwareSettingsIcon")]
+    [DataRow("IPv4 addr", "NetworkAdapterIcon")]
+    [DataRow("IPV6 addr", "NetworkAdapterIcon")]
+    [DataRow("MAC addr", "NetworkAdapterIcon")]
+    public void IconThemeDarkTest(string typedString, string expectedIconPropertyName)
+    {
+        var systemPage = new SystemCommandPage(new SettingsManager());
+
+        foreach (var item in systemPage.GetItems())
+        {
+            if (item.Title.Contains(typedString, StringComparison.OrdinalIgnoreCase) || item.Subtitle.Contains(typedString, StringComparison.OrdinalIgnoreCase))
+            {
+                var icon = item.Icon;
+                Assert.IsNotNull(icon, $"Icon for '{typedString}' should not be null.");
+                Assert.IsNotEmpty(icon.Dark.Icon, $"Icon for '{typedString}' should not be empty.");
+            }
+        }
+    }
+
+    [DataTestMethod]
+    [DataRow("shutdown", "ShutdownIcon")]
+    [DataRow("restart", "RestartIcon")]
+    [DataRow("sign out", "LogoffIcon")]
+    [DataRow("lock", "LockIcon")]
+    [DataRow("sleep", "SleepIcon")]
+    [DataRow("hibernate", "SleepIcon")]
+    [DataRow("recycle bin", "RecycleBinIcon")]
+    [DataRow("uefi firmware settings", "FirmwareSettingsIcon")]
+    [DataRow("IPv4 addr", "NetworkAdapterIcon")]
+    [DataRow("IPV6 addr", "NetworkAdapterIcon")]
+    [DataRow("MAC addr", "NetworkAdapterIcon")]
+    public void IconThemeLightTest(string typedString, string expectedIconPropertyName)
+    {
+        var systemPage = new SystemCommandPage(new SettingsManager());
+
+        foreach (var item in systemPage.GetItems())
+        {
+            if (item.Title.Contains(typedString, StringComparison.OrdinalIgnoreCase) || item.Subtitle.Contains(typedString, StringComparison.OrdinalIgnoreCase))
+            {
+                var icon = item.Icon;
+                Assert.IsNotNull(icon, $"Icon for '{typedString}' should not be null.");
+                Assert.IsNotEmpty(icon.Light.Icon, $"Icon for '{typedString}' should not be empty.");
+            }
+        }
+    }
+}

src/modules/cmdpal/Tests/Microsoft.CmdPal.Ext.System.UnitTests/Microsoft.CmdPal.Ext.System.UnitTests.csproj

@@ -0,0 +1,24 @@
+<Project Sdk="Microsoft.NET.Sdk">
+  <!-- Look at Directory.Build.props in root for common stuff as well -->
+  <Import Project="..\..\..\..\Common.Dotnet.CsWinRT.props" />
+
+  <PropertyGroup>
+    <IsPackable>false</IsPackable>
+    <IsTestProject>true</IsTestProject>
+    <RootNamespace>Microsoft.CmdPal.Ext.System.UnitTests</RootNamespace>
+    <OutputPath>$(SolutionDir)$(Platform)\$(Configuration)\WinUI3Apps\CmdPal\tests\</OutputPath>
+    <AppendTargetFrameworkToOutputPath>false</AppendTargetFrameworkToOutputPath>
+    <AppendRuntimeIdentifierToOutputPath>false</AppendRuntimeIdentifierToOutputPath>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <PackageReference Include="Moq" />
+    <PackageReference Include="MSTest" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="..\..\..\..\common\ManagedCommon\ManagedCommon.csproj" />
+    <ProjectReference Include="..\..\ext\Microsoft.CmdPal.Ext.System\Microsoft.CmdPal.Ext.System.csproj" />
+    <ProjectReference Include="..\..\extensionsdk\Microsoft.CommandPalette.Extensions.Toolkit\Microsoft.CommandPalette.Extensions.Toolkit.csproj" />
+  </ItemGroup>
+</Project>

src/modules/cmdpal/Tests/Microsoft.CmdPal.Ext.System.UnitTests/QueryTests.cs

@@ -0,0 +1,105 @@
+// 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.Linq;
+using Microsoft.CmdPal.Ext.System.Helpers;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+
+namespace Microsoft.CmdPal.Ext.System.UnitTests;
+
+[TestClass]
+public class QueryTests
+{
+    [DataTestMethod]
+    [DataRow("shutdown", "Shutdown")]
+    [DataRow("restart", "Restart")]
+    [DataRow("sign out", "Sign out")]
+    [DataRow("lock", "Lock")]
+    [DataRow("sleep", "Sleep")]
+    [DataRow("hibernate", "Hibernate")]
+    public void SystemCommandsTest(string typedString, string expectedCommand)
+    {
+        // Setup
+        var commands = Commands.GetSystemCommands(false, false, false, false);
+
+        // Act
+        var result = commands.Where(c => c.Title.Contains(expectedCommand, StringComparison.OrdinalIgnoreCase)).FirstOrDefault();
+
+        // Assert
+        Assert.IsNotNull(result);
+        Assert.IsTrue(result.Title.Contains(expectedCommand, StringComparison.OrdinalIgnoreCase));
+    }
+
+    [TestMethod]
+    public void RecycleBinCommandTest()
+    {
+        // Setup
+        var commands = Commands.GetSystemCommands(false, false, false, false);
+
+        // Act
+        var result = commands.Where(c => c.Title.Contains("Recycle", StringComparison.OrdinalIgnoreCase)).FirstOrDefault();
+
+        // Assert
+        Assert.IsNotNull(result);
+    }
+
+    [TestMethod]
+    public void NetworkCommandsTest()
+    {
+        // Test that network commands can be retrieved
+        try
+        {
+            var networkPropertiesList = NetworkConnectionProperties.GetList();
+            Assert.IsTrue(networkPropertiesList.Count >= 0); // Should not throw exceptions
+        }
+        catch (Exception ex)
+        {
+            Assert.Fail($"Network commands should not throw exceptions: {ex.Message}");
+        }
+    }
+
+    [TestMethod]
+    public void UefiCommandIsAvailableTest()
+    {
+        // Setup
+        var firmwareType = Win32Helpers.GetSystemFirmwareType();
+        var isUefiMode = firmwareType == FirmwareType.Uefi;
+
+        // Act
+        var commands = Commands.GetSystemCommands(isUefiMode, false, false, false);
+        var uefiCommand = commands.Where(c => c.Title.Contains("UEFI", StringComparison.OrdinalIgnoreCase)).FirstOrDefault();
+
+        // Assert
+        if (isUefiMode)
+        {
+            Assert.IsNotNull(uefiCommand);
+        }
+        else
+        {
+            // UEFI command may still exist but be disabled on non-UEFI systems
+            Assert.IsTrue(true); // Test environment independent
+        }
+    }
+
+    [TestMethod]
+    public void FirmwareTypeTest()
+    {
+        // Test that GetSystemFirmwareType returns a valid enum value
+        var firmwareType = Win32Helpers.GetSystemFirmwareType();
+        Assert.IsTrue(Enum.IsDefined(typeof(FirmwareType), firmwareType));
+    }
+
+    [TestMethod]
+    public void EmptyRecycleBinCommandTest()
+    {
+        // Test that empty recycle bin command exists
+        var commands = Commands.GetSystemCommands(false, false, false, false);
+        var result = commands.Where(c => c.Title.Contains("Empty", StringComparison.OrdinalIgnoreCase) &&
+                                         c.Title.Contains("Recycle", StringComparison.OrdinalIgnoreCase)).FirstOrDefault();
+
+        // Empty recycle bin command should exist
+        Assert.IsNotNull(result);
+    }
+}

src/modules/cmdpal/Tests/Microsoft.CmdPal.Ext.TimeDate.UnitTests/AvailableResultsListTests.cs

@@ -0,0 +1,494 @@
+// 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.Globalization;
+using System.Linq;
+using Microsoft.CmdPal.Ext.TimeDate.Helpers;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+
+namespace Microsoft.CmdPal.Ext.TimeDate.UnitTests;
+
+[TestClass]
+public class AvailableResultsListTests
+{
+    private CultureInfo originalCulture;
+    private CultureInfo originalUiCulture;
+
+    [TestInitialize]
+    public void Setup()
+    {
+        // Set culture to 'en-us'
+        originalCulture = CultureInfo.CurrentCulture;
+        CultureInfo.CurrentCulture = new CultureInfo("en-us", false);
+        originalUiCulture = CultureInfo.CurrentUICulture;
+        CultureInfo.CurrentUICulture = new CultureInfo("en-us", false);
+    }
+
+    [TestCleanup]
+    public void CleanUp()
+    {
+        // Set culture to original value
+        CultureInfo.CurrentCulture = originalCulture;
+        CultureInfo.CurrentUICulture = originalUiCulture;
+    }
+
+    private DateTime GetDateTimeForTest(bool embedUtc = false)
+    {
+        var dateTime = new DateTime(2022, 03, 02, 22, 30, 45);
+        if (embedUtc)
+        {
+            return DateTime.SpecifyKind(dateTime, DateTimeKind.Utc);
+        }
+        else
+        {
+            return dateTime;
+        }
+    }
+
+    [DataTestMethod]
+    [DataRow("time", "10:30 PM")]
+    [DataRow("date", "3/2/2022")]
+    [DataRow("date and time", "3/2/2022 10:30 PM")]
+    [DataRow("hour", "22")]
+    [DataRow("minute", "30")]
+    [DataRow("second", "45")]
+    [DataRow("millisecond", "0")]
+    [DataRow("day (week day)", "Wednesday")]
+    [DataRow("day of the week (week day)", "4")]
+    [DataRow("day of the month", "2")]
+    [DataRow("day of the year", "61")]
+    [DataRow("week of the month", "1")]
+    [DataRow("week of the year (calendar week, week number)", "10")]
+    [DataRow("month", "March")]
+    [DataRow("month of the year", "3")]
+    [DataRow("month and day", "March 2")]
+    [DataRow("year", "2022")]
+    [DataRow("month and year", "March 2022")]
+    [DataRow("ISO 8601", "2022-03-02T22:30:45")]
+    [DataRow("ISO 8601 with time zone", "2022-03-02T22:30:45")]
+    [DataRow("RFC1123", "Wed, 02 Mar 2022 22:30:45 GMT")]
+    [DataRow("Date and time in filename-compatible format", "2022-03-02_22-30-45")]
+    public void LocalFormatsWithShortTimeAndShortDate(string formatLabel, string expectedResult)
+    {
+        // Setup
+        var settings = new SettingsManager();
+        var helperResults = AvailableResultsList.GetList(true, settings, false, false, GetDateTimeForTest());
+
+        // Act
+        var result = helperResults.FirstOrDefault(x => x.Label.Equals(formatLabel, StringComparison.OrdinalIgnoreCase));
+
+        // Assert
+        Assert.AreEqual(expectedResult, result?.Value, $"Culture {CultureInfo.CurrentCulture.Name}, Culture UI: {CultureInfo.CurrentUICulture.Name}, Calendar: {CultureInfo.CurrentCulture.Calendar}, Region: {RegionInfo.CurrentRegion.Name}");
+    }
+
+    [TestMethod]
+    public void GetList_WithKeywordSearch_ReturnsResults()
+    {
+        // Setup
+        var settings = new SettingsManager();
+
+        // Act
+        var results = AvailableResultsList.GetList(true, settings);
+
+        // Assert
+        Assert.IsNotNull(results);
+        Assert.IsTrue(results.Count > 0, "Should return at least some results for keyword search");
+    }
+
+    [TestMethod]
+    public void GetList_WithoutKeywordSearch_ReturnsResults()
+    {
+        // Setup
+        var settings = new SettingsManager();
+
+        // Act
+        var results = AvailableResultsList.GetList(false, settings);
+
+        // Assert
+        Assert.IsNotNull(results);
+        Assert.IsTrue(results.Count > 0, "Should return at least some results for non-keyword search");
+    }
+
+    [TestMethod]
+    public void GetList_WithSpecificDateTime_ReturnsFormattedResults()
+    {
+        // Setup
+        var settings = new SettingsManager();
+        var specificDateTime = GetDateTimeForTest();
+
+        // Act
+        var results = AvailableResultsList.GetList(true, settings, null, null, specificDateTime);
+
+        // Assert
+        Assert.IsNotNull(results);
+        Assert.IsTrue(results.Count > 0, "Should return results for specific datetime");
+
+        // Verify that all results have values
+        foreach (var result in results)
+        {
+            Assert.IsNotNull(result.Label, "Result label should not be null");
+            Assert.IsNotNull(result.Value, "Result value should not be null");
+        }
+    }
+
+    [TestMethod]
+    public void GetList_ResultsHaveRequiredProperties()
+    {
+        // Setup
+        var settings = new SettingsManager();
+
+        // Act
+        var results = AvailableResultsList.GetList(true, settings);
+
+        // Assert
+        Assert.IsTrue(results.Count > 0, "Should have results");
+
+        foreach (var result in results)
+        {
+            Assert.IsNotNull(result.Label, "Each result should have a label");
+            Assert.IsNotNull(result.Value, "Each result should have a value");
+            Assert.IsFalse(string.IsNullOrWhiteSpace(result.Label), "Label should not be empty");
+            Assert.IsFalse(string.IsNullOrWhiteSpace(result.Value), "Value should not be empty");
+        }
+    }
+
+    [TestMethod]
+    public void GetList_WithDifferentCalendarSettings_ReturnsResults()
+    {
+        // Setup
+        var settings = new SettingsManager();
+
+        // Act & Assert - Test with different settings
+        var results1 = AvailableResultsList.GetList(true, settings);
+        Assert.IsNotNull(results1);
+        Assert.IsTrue(results1.Count > 0);
+
+        // Test that the method can handle different calendar settings
+        var results2 = AvailableResultsList.GetList(false, settings);
+        Assert.IsNotNull(results2);
+        Assert.IsTrue(results2.Count > 0);
+    }
+
+    [DataTestMethod]
+    [DataRow("time", "10:30 PM")]
+    [DataRow("date", "Wednesday, March 2, 2022")]
+    [DataRow("date and time", "Wednesday, March 2, 2022 10:30 PM")]
+    [DataRow("hour", "22")]
+    [DataRow("minute", "30")]
+    [DataRow("second", "45")]
+    [DataRow("millisecond", "0")]
+    [DataRow("day (week day)", "Wednesday")]
+    [DataRow("day of the week (week day)", "4")]
+    [DataRow("day of the month", "2")]
+    [DataRow("day of the year", "61")]
+    [DataRow("week of the month", "1")]
+    [DataRow("week of the year (calendar week, week number)", "10")]
+    [DataRow("month", "March")]
+    [DataRow("month of the year", "3")]
+    [DataRow("month and day", "March 2")]
+    [DataRow("year", "2022")]
+    [DataRow("month and year", "March 2022")]
+    [DataRow("ISO 8601", "2022-03-02T22:30:45")]
+    [DataRow("ISO 8601 with time zone", "2022-03-02T22:30:45")]
+    [DataRow("RFC1123", "Wed, 02 Mar 2022 22:30:45 GMT")]
+    [DataRow("Date and time in filename-compatible format", "2022-03-02_22-30-45")]
+    public void LocalFormatsWithShortTimeAndLongDate(string formatLabel, string expectedResult)
+    {
+        // Setup
+        var settings = new SettingsManager();
+        var helperResults = AvailableResultsList.GetList(true, settings, false, true, GetDateTimeForTest());
+
+        // Act
+        var result = helperResults.FirstOrDefault(x => x.Label.Equals(formatLabel, StringComparison.OrdinalIgnoreCase));
+
+        // Assert
+        Assert.AreEqual(expectedResult, result?.Value);
+    }
+
+    [DataTestMethod]
+    [DataRow("time", "10:30:45 PM")]
+    [DataRow("date", "3/2/2022")]
+    [DataRow("date and time", "3/2/2022 10:30:45 PM")]
+    [DataRow("hour", "22")]
+    [DataRow("minute", "30")]
+    [DataRow("second", "45")]
+    [DataRow("millisecond", "0")]
+    [DataRow("day (week day)", "Wednesday")]
+    [DataRow("day of the week (week day)", "4")]
+    [DataRow("day of the month", "2")]
+    [DataRow("day of the year", "61")]
+    [DataRow("week of the month", "1")]
+    [DataRow("week of the year (calendar week, week number)", "10")]
+    [DataRow("month", "March")]
+    [DataRow("month of the year", "3")]
+    [DataRow("month and day", "March 2")]
+    [DataRow("year", "2022")]
+    [DataRow("month and year", "March 2022")]
+    [DataRow("ISO 8601", "2022-03-02T22:30:45")]
+    [DataRow("ISO 8601 with time zone", "2022-03-02T22:30:45")]
+    [DataRow("RFC1123", "Wed, 02 Mar 2022 22:30:45 GMT")]
+    [DataRow("Date and time in filename-compatible format", "2022-03-02_22-30-45")]
+    public void LocalFormatsWithLongTimeAndShortDate(string formatLabel, string expectedResult)
+    {
+        // Setup
+        var settings = new SettingsManager();
+        var helperResults = AvailableResultsList.GetList(true, settings, true, false, GetDateTimeForTest());
+
+        // Act
+        var result = helperResults.FirstOrDefault(x => x.Label.Equals(formatLabel, StringComparison.OrdinalIgnoreCase));
+
+        // Assert
+        Assert.AreEqual(expectedResult, result?.Value);
+    }
+
+    [DataTestMethod]
+    [DataRow("time", "10:30:45 PM")]
+    [DataRow("date", "Wednesday, March 2, 2022")]
+    [DataRow("date and time", "Wednesday, March 2, 2022 10:30:45 PM")]
+    [DataRow("hour", "22")]
+    [DataRow("minute", "30")]
+    [DataRow("second", "45")]
+    [DataRow("millisecond", "0")]
+    [DataRow("day (week day)", "Wednesday")]
+    [DataRow("day of the week (week day)", "4")]
+    [DataRow("day of the month", "2")]
+    [DataRow("day of the year", "61")]
+    [DataRow("week of the month", "1")]
+    [DataRow("week of the year (calendar week, week number)", "10")]
+    [DataRow("month", "March")]
+    [DataRow("month of the year", "3")]
+    [DataRow("month and day", "March 2")]
+    [DataRow("year", "2022")]
+    [DataRow("month and year", "March 2022")]
+    [DataRow("ISO 8601", "2022-03-02T22:30:45")]
+    [DataRow("ISO 8601 with time zone", "2022-03-02T22:30:45")]
+    [DataRow("RFC1123", "Wed, 02 Mar 2022 22:30:45 GMT")]
+    [DataRow("Date and time in filename-compatible format", "2022-03-02_22-30-45")]
+    public void LocalFormatsWithLongTimeAndLongDate(string formatLabel, string expectedResult)
+    {
+        // Setup
+        var settings = new SettingsManager();
+        var helperResults = AvailableResultsList.GetList(true, settings, true, true, GetDateTimeForTest());
+
+        // Act
+        var result = helperResults.FirstOrDefault(x => x.Label.Equals(formatLabel, StringComparison.OrdinalIgnoreCase));
+
+        // Assert
+        Assert.AreEqual(expectedResult, result?.Value);
+    }
+
+    [DataTestMethod]
+    [DataRow("time utc", "t")]
+    [DataRow("date and time utc", "g")]
+    [DataRow("ISO 8601 UTC", "yyyy-MM-ddTHH:mm:ss")]
+    [DataRow("ISO 8601 UTC with time zone", "yyyy-MM-ddTHH:mm:ss'Z'")]
+    [DataRow("Universal time format: YYYY-MM-DD hh:mm:ss", "u")]
+    [DataRow("Date and time in filename-compatible format", "yyyy-MM-dd_HH-mm-ss")]
+    public void UtcFormatsWithShortTimeAndShortDate(string formatLabel, string expectedFormat)
+    {
+        // Setup
+        var settings = new SettingsManager();
+        var helperResults = AvailableResultsList.GetList(true, settings, false, false, GetDateTimeForTest(true));
+        var expectedResult = GetDateTimeForTest().ToString(expectedFormat, CultureInfo.CurrentCulture);
+
+        // Act
+        var result = helperResults.FirstOrDefault(x => x.Label.Equals(formatLabel, StringComparison.OrdinalIgnoreCase));
+
+        // Assert
+        Assert.AreEqual(expectedResult, result?.Value);
+    }
+
+    [DataTestMethod]
+    [DataRow("time utc", "t")]
+    [DataRow("date and time utc", "f")]
+    [DataRow("ISO 8601 UTC", "yyyy-MM-ddTHH:mm:ss")]
+    [DataRow("ISO 8601 UTC with time zone", "yyyy-MM-ddTHH:mm:ss'Z'")]
+    [DataRow("Universal time format: YYYY-MM-DD hh:mm:ss", "u")]
+    [DataRow("Date and time in filename-compatible format", "yyyy-MM-dd_HH-mm-ss")]
+    public void UtcFormatsWithShortTimeAndLongDate(string formatLabel, string expectedFormat)
+    {
+        // Setup
+        var settings = new SettingsManager();
+        var helperResults = AvailableResultsList.GetList(true, settings, false, true, GetDateTimeForTest(true));
+        var expectedResult = GetDateTimeForTest().ToString(expectedFormat, CultureInfo.CurrentCulture);
+
+        // Act
+        var result = helperResults.FirstOrDefault(x => x.Label.Equals(formatLabel, StringComparison.OrdinalIgnoreCase));
+
+        // Assert
+        Assert.AreEqual(expectedResult, result?.Value);
+    }
+
+    [DataTestMethod]
+    [DataRow("time utc", "T")]
+    [DataRow("date and time utc", "G")]
+    [DataRow("ISO 8601 UTC", "yyyy-MM-ddTHH:mm:ss")]
+    [DataRow("ISO 8601 UTC with time zone", "yyyy-MM-ddTHH:mm:ss'Z'")]
+    [DataRow("Universal time format: YYYY-MM-DD hh:mm:ss", "u")]
+    [DataRow("Date and time in filename-compatible format", "yyyy-MM-dd_HH-mm-ss")]
+    public void UtcFormatsWithLongTimeAndShortDate(string formatLabel, string expectedFormat)
+    {
+        // Setup
+        var settings = new SettingsManager();
+        var helperResults = AvailableResultsList.GetList(true, settings, true, false, GetDateTimeForTest(true));
+        var expectedResult = GetDateTimeForTest().ToString(expectedFormat, CultureInfo.CurrentCulture);
+
+        // Act
+        var result = helperResults.FirstOrDefault(x => x.Label.Equals(formatLabel, StringComparison.OrdinalIgnoreCase));
+
+        // Assert
+        Assert.AreEqual(expectedResult, result?.Value);
+    }
+
+    [DataTestMethod]
+    [DataRow("time utc", "T")]
+    [DataRow("date and time utc", "F")]
+    [DataRow("ISO 8601 UTC", "yyyy-MM-ddTHH:mm:ss")]
+    [DataRow("ISO 8601 UTC with time zone", "yyyy-MM-ddTHH:mm:ss'Z'")]
+    [DataRow("Universal time format: YYYY-MM-DD hh:mm:ss", "u")]
+    [DataRow("Date and time in filename-compatible format", "yyyy-MM-dd_HH-mm-ss")]
+    public void UtcFormatsWithLongTimeAndLongDate(string formatLabel, string expectedFormat)
+    {
+        // Setup
+        var settings = new SettingsManager();
+        var helperResults = AvailableResultsList.GetList(true, settings, true, true, GetDateTimeForTest(true));
+        var expectedResult = GetDateTimeForTest().ToString(expectedFormat, CultureInfo.CurrentCulture);
+
+        // Act
+        var result = helperResults.FirstOrDefault(x => x.Label.Equals(formatLabel, StringComparison.OrdinalIgnoreCase));
+
+        // Assert
+        Assert.AreEqual(expectedResult, result?.Value);
+    }
+
+    [TestMethod]
+    public void UnixTimestampSecondsFormat()
+    {
+        // Setup
+        string formatLabel = "Unix epoch time";
+        DateTime timeValue = DateTime.Now.ToUniversalTime();
+        var settings = new SettingsManager();
+        var helperResults = AvailableResultsList.GetList(true, settings, null, null, timeValue);
+        var expectedResult = (long)timeValue.Subtract(new DateTime(1970, 1, 1)).TotalSeconds;
+
+        // Act
+        var result = helperResults.FirstOrDefault(x => x.Label.Equals(formatLabel, StringComparison.OrdinalIgnoreCase));
+
+        // Assert
+        Assert.AreEqual(expectedResult.ToString(CultureInfo.CurrentCulture), result?.Value);
+    }
+
+    [TestMethod]
+    public void UnixTimestampMillisecondsFormat()
+    {
+        // Setup
+        string formatLabel = "Unix epoch time in milliseconds";
+        DateTime timeValue = DateTime.Now.ToUniversalTime();
+        var settings = new SettingsManager();
+        var helperResults = AvailableResultsList.GetList(true, settings, null, null, timeValue);
+        var expectedResult = (long)timeValue.Subtract(new DateTime(1970, 1, 1)).TotalMilliseconds;
+
+        // Act
+        var result = helperResults.FirstOrDefault(x => x.Label.Equals(formatLabel, StringComparison.OrdinalIgnoreCase));
+
+        // Assert
+        Assert.AreEqual(expectedResult.ToString(CultureInfo.CurrentCulture), result?.Value);
+    }
+
+    [TestMethod]
+    public void WindowsFileTimeFormat()
+    {
+        // Setup
+        string formatLabel = "Windows file time (Int64 number)";
+        DateTime timeValue = DateTime.Now;
+        var settings = new SettingsManager();
+        var helperResults = AvailableResultsList.GetList(true, settings, null, null, timeValue);
+        var expectedResult = timeValue.ToFileTime().ToString(CultureInfo.CurrentCulture);
+
+        // Act
+        var result = helperResults.FirstOrDefault(x => x.Label.Equals(formatLabel, StringComparison.OrdinalIgnoreCase));
+
+        // Assert
+        Assert.AreEqual(expectedResult, result?.Value);
+    }
+
+    [TestMethod]
+    public void ValidateEraResult()
+    {
+        // Setup
+        string formatLabel = "Era";
+        DateTime timeValue = DateTime.Now;
+        var settings = new SettingsManager();
+        var helperResults = AvailableResultsList.GetList(true, settings, null, null, timeValue);
+        var expectedResult = DateTimeFormatInfo.CurrentInfo.GetEraName(CultureInfo.CurrentCulture.Calendar.GetEra(timeValue));
+
+        // Act
+        var result = helperResults.FirstOrDefault(x => x.Label.Equals(formatLabel, StringComparison.OrdinalIgnoreCase));
+
+        // Assert
+        Assert.AreEqual(expectedResult, result?.Value);
+    }
+
+    [TestMethod]
+    public void ValidateEraAbbreviationResult()
+    {
+        // Setup
+        string formatLabel = "Era abbreviation";
+        DateTime timeValue = DateTime.Now;
+        var settings = new SettingsManager();
+        var helperResults = AvailableResultsList.GetList(true, settings, null, null, timeValue);
+        var expectedResult = DateTimeFormatInfo.CurrentInfo.GetAbbreviatedEraName(CultureInfo.CurrentCulture.Calendar.GetEra(timeValue));
+
+        // Act
+        var result = helperResults.FirstOrDefault(x => x.Label.Equals(formatLabel, StringComparison.OrdinalIgnoreCase));
+
+        // Assert
+        Assert.AreEqual(expectedResult, result?.Value);
+    }
+
+    [DataTestMethod]
+    [DataRow(CalendarWeekRule.FirstDay, "3")]
+    [DataRow(CalendarWeekRule.FirstFourDayWeek, "2")]
+    [DataRow(CalendarWeekRule.FirstFullWeek, "2")]
+    public void DifferentFirstWeekSettingConfigurations(CalendarWeekRule weekRule, string expectedWeekOfYear)
+    {
+        // Setup
+        DateTime timeValue = new DateTime(2021, 1, 12);
+        var settings = new SettingsManager();
+        var helperResults = AvailableResultsList.GetList(true, settings, null, null, timeValue, weekRule, DayOfWeek.Sunday);
+
+        // Act
+        var resultWeekOfYear = helperResults.FirstOrDefault(x => x.Label.Equals("week of the year (calendar week, week number)", StringComparison.OrdinalIgnoreCase));
+
+        // Assert
+        Assert.AreEqual(expectedWeekOfYear, resultWeekOfYear?.Value);
+    }
+
+    [DataTestMethod]
+    [DataRow(DayOfWeek.Monday, "2", "2", "5")]
+    [DataRow(DayOfWeek.Tuesday, "3", "3", "4")]
+    [DataRow(DayOfWeek.Wednesday, "3", "3", "3")]
+    [DataRow(DayOfWeek.Thursday, "3", "3", "2")]
+    [DataRow(DayOfWeek.Friday, "3", "3", "1")]
+    [DataRow(DayOfWeek.Saturday, "2", "2", "7")]
+    [DataRow(DayOfWeek.Sunday, "2", "2", "6")]
+    public void DifferentFirstDayOfWeekSettingConfigurations(DayOfWeek dayOfWeek, string expectedWeekOfYear, string expectedWeekOfMonth, string expectedDayInWeek)
+    {
+        // Setup
+        DateTime timeValue = new DateTime(2024, 1, 12); // Friday
+        var settings = new SettingsManager();
+        var helperResults = AvailableResultsList.GetList(true, settings, null, null, timeValue, CalendarWeekRule.FirstDay, dayOfWeek);
+
+        // Act
+        var resultWeekOfYear = helperResults.FirstOrDefault(x => x.Label.Equals("week of the year (calendar week, week number)", StringComparison.OrdinalIgnoreCase));
+        var resultWeekOfMonth = helperResults.FirstOrDefault(x => x.Label.Equals("week of the month", StringComparison.OrdinalIgnoreCase));
+        var resultDayInWeek = helperResults.FirstOrDefault(x => x.Label.Equals("day of the week (week day)", StringComparison.OrdinalIgnoreCase));
+
+        // Assert
+        Assert.AreEqual(expectedWeekOfYear, resultWeekOfYear?.Value);
+        Assert.AreEqual(expectedWeekOfMonth, resultWeekOfMonth?.Value);
+        Assert.AreEqual(expectedDayInWeek, resultDayInWeek?.Value);
+    }
+}

src/modules/cmdpal/Tests/Microsoft.CmdPal.Ext.TimeDate.UnitTests/BasicTests.cs

@@ -0,0 +1,28 @@
+// 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 Microsoft.VisualStudio.TestTools.UnitTesting;
+
+namespace Microsoft.CmdPal.Ext.TimeDate.UnitTests;
+
+[TestClass]
+public class BasicTests
+{
+    [TestMethod]
+    public void BasicTest()
+    {
+        // This is a basic test to verify the test project can run
+        Assert.IsTrue(true);
+    }
+
+    [TestMethod]
+    public void DateTimeTest()
+    {
+        // Test basic DateTime functionality
+        var now = DateTime.Now;
+        Assert.IsNotNull(now);
+        Assert.IsTrue(now > DateTime.MinValue);
+    }
+}

src/modules/cmdpal/Tests/Microsoft.CmdPal.Ext.TimeDate.UnitTests/FallbackTimeDateItemTests.cs

@@ -0,0 +1,86 @@
+// 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.Globalization;
+using Microsoft.CmdPal.Ext.TimeDate.Helpers;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+
+namespace Microsoft.CmdPal.Ext.TimeDate.UnitTests;
+
+[TestClass]
+public class FallbackTimeDateItemTests
+{
+    private CultureInfo originalCulture;
+    private CultureInfo originalUiCulture;
+
+    [TestInitialize]
+    public void Setup()
+    {
+        // Set culture to 'en-us'
+        originalCulture = CultureInfo.CurrentCulture;
+        CultureInfo.CurrentCulture = new CultureInfo("en-us", false);
+        originalUiCulture = CultureInfo.CurrentUICulture;
+        CultureInfo.CurrentUICulture = new CultureInfo("en-us", false);
+    }
+
+    [TestCleanup]
+    public void Cleanup()
+    {
+        // Restore original culture
+        CultureInfo.CurrentCulture = originalCulture;
+        CultureInfo.CurrentUICulture = originalUiCulture;
+    }
+
+    [DataTestMethod]
+    [DataRow("time", "12:00 PM")]
+    [DataRow("date", "7/1/2025")]
+    [DataRow("week", "27")]
+    public void FallbackQueryTests(string query, string expectedTitle)
+    {
+        // Setup
+        var settingsManager = new SettingsManager();
+        DateTime now = new DateTime(2025, 7, 1, 12, 0, 0); // Fixed date for testing
+        var fallbackItem = new FallbackTimeDateItem(settingsManager, now);
+
+        // Act & Assert - Test that UpdateQuery doesn't throw exceptions
+        try
+        {
+            fallbackItem.UpdateQuery(query);
+            Assert.IsTrue(
+                fallbackItem.Title.Contains(expectedTitle, StringComparison.OrdinalIgnoreCase),
+                $"Expected title to contain '{expectedTitle}', but got '{fallbackItem.Title}'");
+            Assert.IsNotNull(fallbackItem.Subtitle, "Subtitle should not be null");
+            Assert.IsNotNull(fallbackItem.Icon, "Icon should not be null");
+        }
+        catch (Exception ex)
+        {
+            Assert.Fail($"UpdateQuery should not throw exceptions: {ex.Message}");
+        }
+    }
+
+    [DataTestMethod]
+    [DataRow(null)]
+    [DataRow("invalid input")]
+    public void InvalidQueryTests(string query)
+    {
+        // Setup
+        var settingsManager = new SettingsManager();
+        DateTime now = new DateTime(2025, 7, 1, 12, 0, 0); // Fixed date for testing
+        var fallbackItem = new FallbackTimeDateItem(settingsManager, now);
+
+        // Act & Assert - Test that UpdateQuery doesn't throw exceptions
+        try
+        {
+            fallbackItem.UpdateQuery(query);
+
+            Assert.AreEqual(string.Empty, fallbackItem.Title, "Title should be empty for invalid queries");
+            Assert.AreEqual(string.Empty, fallbackItem.Subtitle, "Subtitle should be empty for invalid queries");
+        }
+        catch (Exception ex)
+        {
+            Assert.Fail($"UpdateQuery should not throw exceptions: {ex.Message}");
+        }
+    }
+}

src/modules/cmdpal/Tests/Microsoft.CmdPal.Ext.TimeDate.UnitTests/IconTests.cs

@@ -0,0 +1,127 @@
+// 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.Globalization;
+using Microsoft.CmdPal.Ext.TimeDate.Helpers;
+using Microsoft.CommandPalette.Extensions.Toolkit;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+
+namespace Microsoft.CmdPal.Ext.TimeDate.UnitTests;
+
+[TestClass]
+public class IconTests
+{
+    private CultureInfo originalCulture;
+    private CultureInfo originalUiCulture;
+
+    [TestInitialize]
+    public void Setup()
+    {
+        // Set culture to 'en-us'
+        originalCulture = CultureInfo.CurrentCulture;
+        CultureInfo.CurrentCulture = new CultureInfo("en-us", false);
+        originalUiCulture = CultureInfo.CurrentUICulture;
+        CultureInfo.CurrentUICulture = new CultureInfo("en-us", false);
+    }
+
+    [TestCleanup]
+    public void CleanUp()
+    {
+        // Set culture to original value
+        CultureInfo.CurrentCulture = originalCulture;
+        CultureInfo.CurrentUICulture = originalUiCulture;
+    }
+
+    [TestMethod]
+    public void TimeDateCommandsProvider_HasIcon()
+    {
+        // Setup
+        var provider = new TimeDateCommandsProvider();
+
+        // Act
+        var icon = provider.Icon;
+
+        // Assert
+        Assert.IsNotNull(icon, "Provider should have an icon");
+    }
+
+    [TestMethod]
+    public void TimeDateCommandsProvider_TopLevelCommands_HaveIcons()
+    {
+        // Setup
+        var provider = new TimeDateCommandsProvider();
+
+        // Act
+        var commands = provider.TopLevelCommands();
+
+        // Assert
+        Assert.IsNotNull(commands);
+        Assert.IsTrue(commands.Length > 0, "Should have at least one top-level command");
+
+        foreach (var command in commands)
+        {
+            Assert.IsNotNull(command.Icon, "Each command should have an icon");
+        }
+    }
+
+    [TestMethod]
+    public void AvailableResults_HaveIcons()
+    {
+        // Setup
+        var settings = new SettingsManager();
+
+        // Act
+        var results = AvailableResultsList.GetList(true, settings);
+
+        // Assert
+        Assert.IsNotNull(results);
+        Assert.IsTrue(results.Count > 0, "Should have results");
+
+        foreach (var result in results)
+        {
+            Assert.IsNotNull(result.GetIconInfo(), $"Result '{result.Label}' should have an icon");
+        }
+    }
+
+    [DataTestMethod]
+    [DataRow(ResultIconType.Time, "\uE823")]
+    [DataRow(ResultIconType.Date, "\uE787")]
+    [DataRow(ResultIconType.DateTime, "\uEC92")]
+    public void ResultHelper_CreateListItem_PreservesIcon(ResultIconType resultIconType, string expectedIcon)
+    {
+        // Setup
+        var availableResult = new AvailableResult
+        {
+            Label = "Test Label",
+            Value = "Test Value",
+            IconType = resultIconType,
+        };
+
+        // Act
+        var listItem = availableResult.ToListItem();
+
+        var icon = listItem.Icon;
+
+        // Assert
+        Assert.IsNotNull(listItem);
+        Assert.IsNotNull(listItem.Icon, "ListItem should preserve the icon from AvailableResult");
+        Assert.AreEqual(expectedIcon, icon.Dark.Icon, $"Icon for {resultIconType} should match expected value");
+    }
+
+    [TestMethod]
+    public void Icons_AreNotEmpty()
+    {
+        // Setup
+        var settings = new SettingsManager();
+        var results = AvailableResultsList.GetList(true, settings);
+
+        // Act & Assert
+        foreach (var result in results)
+        {
+            Assert.IsNotNull(result.GetIconInfo(), $"Result '{result.Label}' should have an icon");
+            Assert.IsFalse(string.IsNullOrWhiteSpace(result.GetIconInfo().ToString()), $"Icon for '{result.Label}' should not be empty");
+        }
+    }
+}

src/modules/cmdpal/Tests/Microsoft.CmdPal.Ext.TimeDate.UnitTests/Microsoft.CmdPal.Ext.TimeDate.UnitTests.csproj

@@ -0,0 +1,23 @@
+<Project Sdk="Microsoft.NET.Sdk">
+  <!-- Look at Directory.Build.props in root for common stuff as well -->
+  <Import Project="..\..\..\..\Common.Dotnet.CsWinRT.props" />
+
+  <PropertyGroup>
+    <IsPackable>false</IsPackable>
+    <IsTestProject>true</IsTestProject>
+    <RootNamespace>Microsoft.CmdPal.Ext.TimeDate.UnitTests</RootNamespace>
+    <OutputPath>$(SolutionDir)$(Platform)\$(Configuration)\WinUI3Apps\CmdPal\tests\</OutputPath>
+    <AppendTargetFrameworkToOutputPath>false</AppendTargetFrameworkToOutputPath>
+    <AppendRuntimeIdentifierToOutputPath>false</AppendRuntimeIdentifierToOutputPath>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <PackageReference Include="Moq" />
+    <PackageReference Include="MSTest" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="..\..\..\..\common\ManagedCommon\ManagedCommon.csproj" />
+    <ProjectReference Include="..\..\ext\Microsoft.CmdPal.Ext.TimeDate\Microsoft.CmdPal.Ext.TimeDate.csproj" />
+  </ItemGroup>
+</Project>

src/modules/cmdpal/Tests/Microsoft.CmdPal.Ext.TimeDate.UnitTests/QueryTests.cs

@@ -0,0 +1,350 @@
+// 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.Globalization;
+using System.Linq;
+using Microsoft.CmdPal.Ext.TimeDate.Helpers;
+using Microsoft.CommandPalette.Extensions.Toolkit;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+
+namespace Microsoft.CmdPal.Ext.TimeDate.UnitTests;
+
+[TestClass]
+public class QueryTests
+{
+    private CultureInfo originalCulture;
+    private CultureInfo originalUiCulture;
+
+    [TestInitialize]
+    public void Setup()
+    {
+        // Set culture to 'en-us'
+        originalCulture = CultureInfo.CurrentCulture;
+        CultureInfo.CurrentCulture = new CultureInfo("en-us", false);
+        originalUiCulture = CultureInfo.CurrentUICulture;
+        CultureInfo.CurrentUICulture = new CultureInfo("en-us", false);
+    }
+
+    [TestCleanup]
+    public void CleanUp()
+    {
+        // Set culture to original value
+        CultureInfo.CurrentCulture = originalCulture;
+        CultureInfo.CurrentUICulture = originalUiCulture;
+    }
+
+    [DataTestMethod]
+    [DataRow("time", 1)] // Common time queries should return results
+    [DataRow("date", 1)] // Common date queries should return results
+    [DataRow("now", 1)] // Now should return multiple results
+    [DataRow("current", 1)] // Current should return multiple results
+    [DataRow("year", 1)] // Year-related queries should return results
+    [DataRow("time::10:10:10", 1)] // Specific time format should return results
+    [DataRow("date::10/10/10", 1)] // Specific date format should return results
+    public void CountBasicQueries(string query, int expectedMinResultCount)
+    {
+        // Setup
+        var settings = new SettingsManager();
+
+        // Act
+        var results = TimeDateCalculator.ExecuteSearch(settings, query);
+
+        // Assert
+        Assert.IsTrue(
+            results.Count >= expectedMinResultCount,
+            $"Expected at least {expectedMinResultCount} results for query '{query}', but got {results.Count}");
+    }
+
+    [DataTestMethod]
+    [DataRow("time")]
+    [DataRow("date")]
+    [DataRow("year")]
+    [DataRow("now")]
+    [DataRow("current")]
+    [DataRow("")]
+    [DataRow("now::10:10:10")] // Windows file time
+    public void AllQueriesReturnResults(string query)
+    {
+        // Setup
+        var settings = new SettingsManager();
+
+        // Act
+        var results = TimeDateCalculator.ExecuteSearch(settings, query);
+
+        // Assert
+        Assert.IsNotNull(results);
+        Assert.IsTrue(results.Count > 0, $"Query '{query}' should return at least one result");
+    }
+
+    [DataTestMethod]
+    [DataRow("time", "Time")]
+    [DataRow("date", "Date")]
+    [DataRow("now", "Now")]
+    [DataRow("unix", "Unix epoch time")]
+    [DataRow("unix epoch time in milli", "Unix epoch time in milliseconds")]
+    [DataRow("file", "Windows file time (Int64 number)")]
+    [DataRow("hour", "Hour")]
+    [DataRow("minute", "Minute")]
+    [DataRow("second", "Second")]
+    [DataRow("millisecond", "Millisecond")]
+    [DataRow("day", "Day (Week day)")]
+    [DataRow("day of week", "Day of the week (Week day)")]
+    [DataRow("day of month", "Day of the month")]
+    [DataRow("day of year", "Day of the year")]
+    [DataRow("week of month", "Week of the month")]
+    [DataRow("week of year", "Week of the year (Calendar week, Week number)")]
+    [DataRow("month", "Month")]
+    [DataRow("month of year", "Month of the year")]
+    [DataRow("month and d", "Month and day")]
+    [DataRow("month and y", "Month and year")]
+    [DataRow("year", "Year")]
+    [DataRow("era", "Era")]
+    [DataRow("era a", "Era abbreviation")]
+    [DataRow("universal", "Universal time format: YYYY-MM-DD hh:mm:ss")]
+    [DataRow("iso", "ISO 8601")]
+    [DataRow("rfc", "RFC1123")]
+    [DataRow("time::12:30", "Time")]
+    [DataRow("date::10.10.2022", "Date")]
+    [DataRow("time::u1646408119", "Time")]
+    [DataRow("time::ft637820085517321977", "Time")]
+    [DataRow("week day", "Day (Week day)")]
+    [DataRow("cal week", "Week of the year (Calendar week, Week number)")]
+    [DataRow("week num", "Week of the year (Calendar week, Week number)")]
+    [DataRow("days in mo", "Days in month")]
+    [DataRow("Leap y", "Leap year")]
+    public void CanFindFormatResult(string query, string expectedSubtitle)
+    {
+        // Setup
+        var settings = new SettingsManager();
+
+        // Act
+        var results = TimeDateCalculator.ExecuteSearch(settings, query);
+
+        // Assert
+        var matchingResult = results.FirstOrDefault(x => x.Subtitle?.StartsWith(expectedSubtitle, StringComparison.CurrentCulture) == true);
+        Assert.IsNotNull(matchingResult, $"Could not find result with subtitle starting with '{expectedSubtitle}' for query '{query}'");
+    }
+
+    [DataTestMethod]
+    [DataRow("12:30", "Time")]
+    [DataRow("10.10.2022", "Date")]
+    [DataRow("u1646408119", "Date and time")]
+    [DataRow("u+1646408119", "Date and time")]
+    [DataRow("u-1646408119", "Date and time")]
+    [DataRow("ums1646408119", "Date and time")]
+    [DataRow("ums+1646408119", "Date and time")]
+    [DataRow("ums-1646408119", "Date and time")]
+    [DataRow("ft637820085517321977", "Date and time")]
+    public void DateTimeNumberOnlyInput(string query, string expectedSubtitle)
+    {
+        // Setup
+        var settings = new SettingsManager();
+
+        // Act
+        var results = TimeDateCalculator.ExecuteSearch(settings, query);
+
+        // Assert
+        var matchingResult = results.FirstOrDefault(x => x.Subtitle?.StartsWith(expectedSubtitle, StringComparison.CurrentCulture) == true);
+        Assert.IsNotNull(matchingResult, $"Could not find result with subtitle starting with '{expectedSubtitle}' for query '{query}'");
+    }
+
+    [DataTestMethod]
+    [DataRow("abcdefg")]
+    [DataRow("timmmmeeee")]
+    [DataRow("timtaaaetetaae::u1646408119")]
+    [DataRow("time:eeee")]
+    [DataRow("time::eeee")]
+    [DataRow("time//eeee")]
+    public void InvalidInputShowsErrorResults(string query)
+    {
+        // Setup
+        var settings = new SettingsManager();
+
+        // Act
+        var results = TimeDateCalculator.ExecuteSearch(settings, query);
+
+        // Assert
+        Assert.IsNotNull(results, $"Results should not be null for query '{query}'");
+        Assert.IsTrue(results.Count > 0, $"Query '{query}' should return at least one result");
+
+        // For invalid input, cmdpal returns an error result
+        var hasErrorResult = results.Any(r => r.Title?.StartsWith("Error: Invalid input", StringComparison.CurrentCulture) == true);
+        Assert.IsTrue(hasErrorResult, $"Query '{query}' should return an error result for invalid input");
+    }
+
+    [DataTestMethod]
+    [DataRow("ug1646408119")] // Invalid prefix
+    [DataRow("u9999999999999")] // Unix number + prefix is longer than 12 characters
+    [DataRow("ums999999999999999")] // Unix number in milliseconds + prefix is longer than 17 characters
+    [DataRow("-u99999999999")] // Unix number with wrong placement of - sign
+    [DataRow("+ums9999999999")] // Unix number in milliseconds with wrong placement of + sign
+    [DataRow("0123456")] // Missing prefix
+    [DataRow("ft63782008ab55173dasdas21977")] // Number contains letters
+    [DataRow("ft63782008ab55173dasdas")] // Number contains letters at the end
+    [DataRow("ft12..548")] // Number contains wrong punctuation
+    [DataRow("ft12..54//8")] // Number contains wrong punctuation and other characters
+    [DataRow("time::ft12..54//8")] // Number contains wrong punctuation and other characters
+    [DataRow("ut2ed.5555")] // Number contains letters
+    [DataRow("12..54//8")] // Number contains punctuation and other characters, but no special prefix
+    [DataRow("ft::1288gg8888")] // Number contains delimiter and letters, but no special prefix
+    [DataRow("date::12::55")]
+    [DataRow("date::12:aa:55")]
+    [DataRow("10.aa.22")]
+    [DataRow("12::55")]
+    [DataRow("12:aa:55")]
+    public void InvalidNumberInputShowsErrorMessage(string query)
+    {
+        // Setup
+        var settings = new SettingsManager();
+
+        // Act
+        var results = TimeDateCalculator.ExecuteSearch(settings, query);
+
+        // Assert
+        Assert.IsNotNull(results, $"Results should not be null for query '{query}'");
+        Assert.IsTrue(results.Count > 0, $"Should return at least one result (error message) for invalid query '{query}'");
+
+        // Check if we get an error result
+        var errorResult = results.FirstOrDefault(r => r.Title?.StartsWith("Error: Invalid input", StringComparison.CurrentCulture) == true);
+        Assert.IsNotNull(errorResult, $"Should return an error result for invalid query '{query}'");
+    }
+
+    [DataTestMethod]
+    [DataRow("10.10aa")] // Input contains <Number>.<Number> (Can be part of a date.)
+    [DataRow("10:10aa")] // Input contains <Number>:<Number> (Can be part of a time.)
+    [DataRow("10/10aa")] // Input contains <Number>/<Number> (Can be part of a date.)
+    public void InvalidInputNotShowsErrorMessage(string query)
+    {
+        // Setup
+        var settings = new SettingsManager();
+
+        // Act
+        var results = TimeDateCalculator.ExecuteSearch(settings, query);
+
+        // Assert
+        Assert.IsNotNull(results, $"Results should not be null for query '{query}'");
+
+        // These queries are ambiguous and cmdpal returns an error for them
+        // This test might need to be adjusted based on actual cmdpal behavior
+        if (results.Count > 0)
+        {
+            var hasErrorResult = results.Any(r => r.Title?.StartsWith("Error: Invalid input", StringComparison.CurrentCulture) == true);
+
+            // For these ambiguous inputs, cmdpal may return error results, which is acceptable
+            // We just verify that the system handles them gracefully (doesn't crash)
+            Assert.IsTrue(true, $"Query '{query}' handled gracefully");
+        }
+    }
+
+    [DataTestMethod]
+    [DataRow("time", "time", true)] // Full word match should work
+    [DataRow("date", "date", true)] // Full word match should work
+    [DataRow("now", "now", true)] // Full word match should work
+    [DataRow("year", "year", true)] // Full word match should work
+    [DataRow("abcdefg", "", false)] // Invalid query should return error
+    public void ValidateBehaviorOnSearchQueries(string query, string expectedMatchTerm, bool shouldHaveValidResults)
+    {
+        // Setup
+        var settings = new SettingsManager();
+
+        // Act
+        var results = TimeDateCalculator.ExecuteSearch(settings, query);
+
+        // Assert
+        Assert.IsNotNull(results, $"Results should not be null for query '{query}'");
+        Assert.IsTrue(results.Count > 0, $"Query '{query}' should return at least one result");
+
+        if (shouldHaveValidResults)
+        {
+            // Should have non-error results
+            var hasValidResult = results.Any(r => !r.Title?.StartsWith("Error: Invalid input", StringComparison.CurrentCulture) == true);
+            Assert.IsTrue(hasValidResult, $"Query '{query}' should return valid (non-error) results");
+
+            if (!string.IsNullOrEmpty(expectedMatchTerm))
+            {
+                var hasMatchingResult = results.Any(r =>
+                    r.Title?.Contains(expectedMatchTerm, StringComparison.CurrentCultureIgnoreCase) == true ||
+                    r.Subtitle?.Contains(expectedMatchTerm, StringComparison.CurrentCultureIgnoreCase) == true);
+                Assert.IsTrue(hasMatchingResult, $"Query '{query}' should return results containing '{expectedMatchTerm}'");
+            }
+        }
+        else
+        {
+            // Should have error results
+            var hasErrorResult = results.Any(r => r.Title?.StartsWith("Error: Invalid input", StringComparison.CurrentCulture) == true);
+            Assert.IsTrue(hasErrorResult, $"Query '{query}' should return error results for invalid input");
+        }
+    }
+
+    [TestMethod]
+    public void EmptyQueryReturnsAllResults()
+    {
+        // Setup
+        var settings = new SettingsManager();
+
+        // Act
+        var results = TimeDateCalculator.ExecuteSearch(settings, string.Empty);
+
+        // Assert
+        Assert.IsNotNull(results);
+        Assert.IsTrue(results.Count > 0, "Empty query should return all available results");
+    }
+
+    [TestMethod]
+    public void NullQueryReturnsAllResults()
+    {
+        // Setup
+        var settings = new SettingsManager();
+
+        // Act
+        var results = TimeDateCalculator.ExecuteSearch(settings, null);
+
+        // Assert
+        Assert.IsNotNull(results);
+        Assert.IsTrue(results.Count > 0, "Null query should return all available results");
+    }
+
+    [DataTestMethod]
+    [DataRow("time u", "Time UTC")]
+    [DataRow("now u", "Now UTC")]
+    [DataRow("iso utc", "ISO 8601 UTC")]
+    [DataRow("iso zone", "ISO 8601 with time zone")]
+    [DataRow("iso utc zone", "ISO 8601 UTC with time zone")]
+    public void UTCRelatedQueries(string query, string expectedSubtitle)
+    {
+        // Setup
+        var settings = new SettingsManager();
+
+        // Act
+        var results = TimeDateCalculator.ExecuteSearch(settings, query);
+
+        // Assert
+        Assert.IsNotNull(results);
+        Assert.IsTrue(results.Count > 0, $"Query '{query}' should return results");
+
+        var matchingResult = results.FirstOrDefault(x => x.Subtitle?.StartsWith(expectedSubtitle, StringComparison.CurrentCulture) == true);
+        Assert.IsNotNull(matchingResult, $"Could not find result with subtitle starting with '{expectedSubtitle}' for query '{query}'");
+    }
+
+    [DataTestMethod]
+    [DataRow("time::12:30:45")]
+    [DataRow("date::2023-12-25")]
+    [DataRow("now::u1646408119")]
+    [DataRow("current::ft637820085517321977")]
+    public void DelimiterQueriesReturnResults(string query)
+    {
+        // Setup
+        var settings = new SettingsManager();
+
+        // Act
+        var results = TimeDateCalculator.ExecuteSearch(settings, query);
+
+        // Assert
+        Assert.IsNotNull(results);
+
+        // Delimiter queries should return results even if parsing fails (error results)
+        Assert.IsTrue(results.Count > 0, $"Delimiter query '{query}' should return at least one result");
+    }
+}

src/modules/cmdpal/Tests/Microsoft.CmdPal.Ext.TimeDate.UnitTests/ResultHelperTests.cs

@@ -0,0 +1,143 @@
+// 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.Globalization;
+using Microsoft.CmdPal.Ext.TimeDate.Helpers;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+
+namespace Microsoft.CmdPal.Ext.TimeDate.UnitTests;
+
+[TestClass]
+public class ResultHelperTests
+{
+    private CultureInfo originalCulture;
+    private CultureInfo originalUiCulture;
+
+    [TestInitialize]
+    public void Setup()
+    {
+        // Set culture to 'en-us'
+        originalCulture = CultureInfo.CurrentCulture;
+        CultureInfo.CurrentCulture = new CultureInfo("en-us", false);
+        originalUiCulture = CultureInfo.CurrentUICulture;
+        CultureInfo.CurrentUICulture = new CultureInfo("en-us", false);
+    }
+
+    [TestCleanup]
+    public void CleanUp()
+    {
+        // Set culture to original value
+        CultureInfo.CurrentCulture = originalCulture;
+        CultureInfo.CurrentUICulture = originalUiCulture;
+    }
+
+    [TestMethod]
+    public void ResultHelper_CreateListItem_ReturnsValidItem()
+    {
+        // Setup
+        var availableResult = new AvailableResult
+        {
+            Label = "Test Label",
+            Value = "Test Value",
+        };
+
+        // Act
+        var listItem = availableResult.ToListItem();
+
+        // Assert
+        Assert.IsNotNull(listItem);
+        Assert.AreEqual("Test Value", listItem.Title);
+        Assert.AreEqual("Test Label", listItem.Subtitle);
+    }
+
+    [TestMethod]
+    public void ResultHelper_CreateListItem_HandlesNullInput()
+    {
+        AvailableResult availableResult = null;
+
+        // Act & Assert
+        Assert.ThrowsException<System.NullReferenceException>(() => availableResult.ToListItem());
+    }
+
+    [TestMethod]
+    public void ResultHelper_CreateListItem_HandlesEmptyValues()
+    {
+        // Setup
+        var availableResult = new AvailableResult
+        {
+            Label = string.Empty,
+            Value = string.Empty,
+        };
+
+        // Act
+        var listItem = availableResult.ToListItem();
+
+        // Assert
+        Assert.IsNotNull(listItem);
+        Assert.AreEqual("Copy", listItem.Title);
+        Assert.AreEqual(string.Empty, listItem.Subtitle);
+    }
+
+    [TestMethod]
+    public void ResultHelper_CreateListItem_WithIcon()
+    {
+        // Setup
+        var availableResult = new AvailableResult
+        {
+            Label = "Test Label",
+            Value = "Test Value",
+            IconType = ResultIconType.Date,
+        };
+
+        // Act
+        var listItem = availableResult.ToListItem();
+
+        // Assert
+        Assert.IsNotNull(listItem);
+        Assert.AreEqual("Test Value", listItem.Title);
+        Assert.AreEqual("Test Label", listItem.Subtitle);
+        Assert.IsNotNull(listItem.Icon);
+    }
+
+    [TestMethod]
+    public void ResultHelper_CreateListItem_WithLongText()
+    {
+        // Setup
+        var longText = new string('A', 1000);
+        var availableResult = new AvailableResult
+        {
+            Label = longText,
+            Value = longText,
+        };
+
+        // Act
+        var listItem = availableResult.ToListItem();
+
+        // Assert
+        Assert.IsNotNull(listItem);
+        Assert.AreEqual(longText, listItem.Title);
+        Assert.AreEqual(longText, listItem.Subtitle);
+    }
+
+    [TestMethod]
+    public void ResultHelper_CreateListItem_WithSpecialCharacters()
+    {
+        // Setup
+        var specialText = "Test & < > \" ' \n \t";
+        var availableResult = new AvailableResult
+        {
+            Label = specialText,
+            Value = specialText,
+        };
+
+        // Act
+        var listItem = availableResult.ToListItem();
+
+        // Assert
+        Assert.IsNotNull(listItem);
+        Assert.AreEqual(specialText, listItem.Title);
+        Assert.AreEqual(specialText, listItem.Subtitle);
+    }
+}

src/modules/cmdpal/Tests/Microsoft.CmdPal.Ext.TimeDate.UnitTests/SettingsManagerTests.cs

@@ -0,0 +1,85 @@
+// 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.Globalization;
+using Microsoft.CmdPal.Ext.TimeDate.Helpers;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+
+namespace Microsoft.CmdPal.Ext.TimeDate.UnitTests;
+
+[TestClass]
+public class SettingsManagerTests
+{
+    private CultureInfo originalCulture;
+    private CultureInfo originalUiCulture;
+
+    [TestInitialize]
+    public void Setup()
+    {
+        // Set culture to 'en-us'
+        originalCulture = CultureInfo.CurrentCulture;
+        CultureInfo.CurrentCulture = new CultureInfo("en-us", false);
+        originalUiCulture = CultureInfo.CurrentUICulture;
+        CultureInfo.CurrentUICulture = new CultureInfo("en-us", false);
+    }
+
+    [TestCleanup]
+    public void Cleanup()
+    {
+        // Restore original culture
+        CultureInfo.CurrentCulture = originalCulture;
+        CultureInfo.CurrentUICulture = originalUiCulture;
+    }
+
+    [TestMethod]
+    public void SettingsManagerInitializationTest()
+    {
+        // Act
+        var settingsManager = new SettingsManager();
+
+        // Assert
+        Assert.IsNotNull(settingsManager);
+        Assert.IsNotNull(settingsManager.Settings);
+    }
+
+    [TestMethod]
+    public void DefaultSettingsValidation()
+    {
+        // Act
+        var settingsManager = new SettingsManager();
+
+        // Assert - Check that properties are accessible
+        var enableFallback = settingsManager.EnableFallbackItems;
+        var timeWithSecond = settingsManager.TimeWithSecond;
+        var dateWithWeekday = settingsManager.DateWithWeekday;
+        var firstWeekOfYear = settingsManager.FirstWeekOfYear;
+        var firstDayOfWeek = settingsManager.FirstDayOfWeek;
+        var customFormats = settingsManager.CustomFormats;
+
+        Assert.IsNotNull(customFormats);
+    }
+
+    [TestMethod]
+    public void SettingsPropertiesAccessibilityTest()
+    {
+        // Setup
+        var settingsManager = new SettingsManager();
+
+        // Act & Assert - Verify all properties are accessible without exception
+        try
+        {
+            _ = settingsManager.EnableFallbackItems;
+            _ = settingsManager.TimeWithSecond;
+            _ = settingsManager.DateWithWeekday;
+            _ = settingsManager.FirstWeekOfYear;
+            _ = settingsManager.FirstDayOfWeek;
+            _ = settingsManager.CustomFormats;
+        }
+        catch (Exception ex)
+        {
+            Assert.Fail($"Settings properties should be accessible: {ex.Message}");
+        }
+    }
+}

src/modules/cmdpal/Tests/Microsoft.CmdPal.Ext.TimeDate.UnitTests/StringParserTests.cs

@@ -0,0 +1,135 @@
+// 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.Globalization;
+using Microsoft.CmdPal.Ext.TimeDate.Helpers;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+
+namespace Microsoft.CmdPal.Ext.TimeDate.UnitTests;
+
+[TestClass]
+public class StringParserTests
+{
+    private CultureInfo originalCulture;
+    private CultureInfo originalUiCulture;
+
+    [TestInitialize]
+    public void Setup()
+    {
+        // Set culture to 'en-us'
+        originalCulture = CultureInfo.CurrentCulture;
+        CultureInfo.CurrentCulture = new CultureInfo("en-us", false);
+        originalUiCulture = CultureInfo.CurrentUICulture;
+        CultureInfo.CurrentUICulture = new CultureInfo("en-us", false);
+    }
+
+    [DataTestMethod]
+    [DataRow("10/29/2022 17:05:10", true, "G", "10/29/2022 5:05:10 PM")]
+    [DataRow("Saturday, October 29, 2022 5:05:10 PM", true, "G", "10/29/2022 5:05:10 PM")]
+    [DataRow("10/29/2022", true, "d", "10/29/2022")]
+    [DataRow("Saturday, October 29, 2022", true, "d", "10/29/2022")]
+    [DataRow("17:05:10", true, "T", "5:05:10 PM")]
+    [DataRow("5:05:10 PM", true, "T", "5:05:10 PM")]
+    [DataRow("10456", false, "", "")]
+    [DataRow("u10456", true, "", "")] // Value is UTC and can be different based on system
+    [DataRow("u-10456", true, "", "")] // Value is UTC and can be different based on system
+    [DataRow("u+10456", true, "", "")] // Value is UTC and can be different based on system
+    [DataRow("ums10456", true, "", "")] // Value is UTC and can be different based on system
+    [DataRow("ums-10456", true, "", "")] // Value is UTC and can be different based on system
+    [DataRow("ums+10456", true, "", "")] // Value is UTC and can be different based on system
+    [DataRow("ft10456", true, "", "")] // Value is UTC and can be different based on system
+    [DataRow("oa-657434.99999999", true, "G", "1/1/0100 11:59:59 PM")]
+    [DataRow("oa2958465.99999999", true, "G", "12/31/9999 11:59:59 PM")]
+    [DataRow("oa-657435", false, "", "")] // Value to low
+    [DataRow("oa2958466", false, "", "")] // Value to large
+    [DataRow("exc1.99998843", true, "G", "1/1/1900 11:59:59 PM")]
+    [DataRow("exc59.99998843", true, "G", "2/28/1900 11:59:59 PM")]
+    [DataRow("exc61", true, "G", "3/1/1900 12:00:00 AM")]
+    [DataRow("exc62.99998843", true, "G", "3/2/1900 11:59:59 PM")]
+    [DataRow("exc2958465.99998843", true, "G", "12/31/9999 11:59:59 PM")]
+    [DataRow("exc0", false, "", "")] // Day 0 means in Excel 0/1/1900 and this is a fake date.
+    [DataRow("exc0.99998843", false, "", "")] // Day 0 means in Excel 0/1/1900 and this is a fake date.
+    [DataRow("exc60.99998843", false, "", "")] // Day 60 means in Excel 2/29/1900 and this is a fake date in Excel which we cannot support.
+    [DataRow("exc60", false, "", "")] // Day 60 means in Excel 2/29/1900 and this is a fake date in Excel which we cannot support.
+    [DataRow("exc-1", false, "", "")] // Value to low
+    [DataRow("exc2958466", false, "", "")] // Value to large
+    [DataRow("exf0.99998843", true, "G", "1/1/1904 11:59:59 PM")]
+    [DataRow("exf2957003.99998843", true, "G", "12/31/9999 11:59:59 PM")]
+    [DataRow("exf-0.5", false, "", "")] // Value to low
+    [DataRow("exf2957004", false, "", "")] // Value to large
+    public void ConvertStringToDateTime(string typedString, bool expectedBool, string stringType, string expectedString)
+    {
+        // Act
+        var boolResult = TimeAndDateHelper.ParseStringAsDateTime(in typedString, out DateTime result, out _);
+
+        // Assert
+        Assert.AreEqual(expectedBool, boolResult);
+        if (!string.IsNullOrEmpty(expectedString))
+        {
+            Assert.AreEqual(expectedString, result.ToString(stringType, CultureInfo.CurrentCulture));
+        }
+    }
+
+    [TestMethod]
+    public void ParseStringAsDateTime_BasicTest()
+    {
+        // Test basic string parsing functionality
+        var testCases = new[]
+        {
+            ("2023-12-25", true),
+            ("12/25/2023", true),
+            ("invalid date", false),
+            (string.Empty, false),
+        };
+
+        foreach (var (input, expectedSuccess) in testCases)
+        {
+            // Act
+            var result = TimeAndDateHelper.ParseStringAsDateTime(in input, out DateTime dateTime, out var errorMessage);
+
+            // Assert
+            Assert.AreEqual(expectedSuccess, result, $"Failed for input: {input}");
+            if (!expectedSuccess)
+            {
+                Assert.IsFalse(string.IsNullOrEmpty(errorMessage), $"Error message should not be empty for invalid input: {input}");
+            }
+        }
+    }
+
+    [TestMethod]
+    public void ParseStringAsDateTime_UnixTimestampTest()
+    {
+        // Test Unix timestamp parsing
+        var unixTimestamp = "u1640995200"; // 2022-01-01 00:00:00 UTC
+
+        // Act
+        var result = TimeAndDateHelper.ParseStringAsDateTime(in unixTimestamp, out DateTime dateTime, out var errorMessage);
+
+        // Assert
+        Assert.IsTrue(result, "Unix timestamp parsing should succeed");
+        Assert.IsTrue(string.IsNullOrEmpty(errorMessage), "Error message should be empty for valid Unix timestamp");
+    }
+
+    [TestMethod]
+    public void ParseStringAsDateTime_FileTimeTest()
+    {
+        // Test Windows file time parsing
+        var fileTime = "ft132857664000000000"; // Some valid file time
+
+        // Act
+        var result = TimeAndDateHelper.ParseStringAsDateTime(in fileTime, out DateTime dateTime, out var errorMessage);
+
+        // Assert
+        Assert.IsTrue(result, "File time parsing should succeed");
+    }
+
+    [TestCleanup]
+    public void CleanUp()
+    {
+        // Set culture to original value
+        CultureInfo.CurrentCulture = originalCulture;
+        CultureInfo.CurrentUICulture = originalUiCulture;
+    }
+}

src/modules/cmdpal/Tests/Microsoft.CmdPal.Ext.TimeDate.UnitTests/TimeAndDateHelperTests.cs

@@ -0,0 +1,132 @@
+// 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.Globalization;
+using Microsoft.CmdPal.Ext.TimeDate.Helpers;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+
+namespace Microsoft.CmdPal.Ext.TimeDate.UnitTests;
+
+[TestClass]
+public class TimeAndDateHelperTests
+{
+    private CultureInfo originalCulture;
+    private CultureInfo originalUiCulture;
+
+    [TestInitialize]
+    public void Setup()
+    {
+        // Set culture to 'en-us'
+        originalCulture = CultureInfo.CurrentCulture;
+        CultureInfo.CurrentCulture = new CultureInfo("en-us", false);
+        originalUiCulture = CultureInfo.CurrentUICulture;
+        CultureInfo.CurrentUICulture = new CultureInfo("en-us", false);
+    }
+
+    [TestCleanup]
+    public void Cleanup()
+    {
+        // Restore original culture
+        CultureInfo.CurrentCulture = originalCulture;
+        CultureInfo.CurrentUICulture = originalUiCulture;
+    }
+
+    [DataTestMethod]
+    [DataRow(-1, null)] // default setting
+    [DataRow(0, CalendarWeekRule.FirstDay)]
+    [DataRow(1, CalendarWeekRule.FirstFullWeek)]
+    [DataRow(2, CalendarWeekRule.FirstFourDayWeek)]
+    [DataRow(30, null)] // wrong setting
+    public void GetCalendarWeekRuleBasedOnPluginSetting(int setting, CalendarWeekRule? valueExpected)
+    {
+        // Act
+        var result = TimeAndDateHelper.GetCalendarWeekRule(setting);
+
+        // Assert
+        if (valueExpected == null)
+        {
+            // falls back to system setting.
+            Assert.AreEqual(DateTimeFormatInfo.CurrentInfo.CalendarWeekRule, result);
+        }
+        else
+        {
+            Assert.AreEqual(valueExpected, result);
+        }
+    }
+
+    [DataTestMethod]
+    [DataRow(-1, null)] // default setting
+    [DataRow(0, DayOfWeek.Sunday)]
+    [DataRow(1, DayOfWeek.Monday)]
+    [DataRow(2, DayOfWeek.Tuesday)]
+    [DataRow(3, DayOfWeek.Wednesday)]
+    [DataRow(4, DayOfWeek.Thursday)]
+    [DataRow(5, DayOfWeek.Friday)]
+    [DataRow(6, DayOfWeek.Saturday)]
+    [DataRow(30, null)] // wrong setting
+    public void GetFirstDayOfWeekBasedOnPluginSetting(int setting, DayOfWeek? valueExpected)
+    {
+        // Act
+        var result = TimeAndDateHelper.GetFirstDayOfWeek(setting);
+
+        // Assert
+        if (valueExpected == null)
+        {
+            // falls back to system setting.
+            Assert.AreEqual(DateTimeFormatInfo.CurrentInfo.FirstDayOfWeek, result);
+        }
+        else
+        {
+            Assert.AreEqual(valueExpected, result);
+        }
+    }
+
+    [DataTestMethod]
+    [DataRow("yyyy-MM-dd", "2023-12-25")]
+    [DataRow("MM/dd/yyyy", "12/25/2023")]
+    [DataRow("dd.MM.yyyy", "25.12.2023")]
+    public void GetDateTimeFormatTest(string format, string expectedPattern)
+    {
+        // Setup
+        var testDate = new DateTime(2023, 12, 25);
+
+        // Act
+        var result = testDate.ToString(format, CultureInfo.CurrentCulture);
+
+        // Assert
+        Assert.AreEqual(expectedPattern, result);
+    }
+
+    [TestMethod]
+    public void GetCurrentTimeFormatTest()
+    {
+        // Setup
+        var testDateTime = new DateTime(2023, 12, 25, 14, 30, 45);
+
+        // Act
+        var timeResult = testDateTime.ToString("T", CultureInfo.CurrentCulture);
+        var dateResult = testDateTime.ToString("d", CultureInfo.CurrentCulture);
+
+        // Assert
+        Assert.AreEqual("2:30:45 PM", timeResult);
+        Assert.AreEqual("12/25/2023", dateResult);
+    }
+
+    [DataTestMethod]
+    [DataRow("yyyy-MM-dd HH:mm:ss", "2023-12-25 14:30:45")]
+    [DataRow("dddd, MMMM dd, yyyy", "Monday, December 25, 2023")]
+    [DataRow("HH:mm:ss tt", "14:30:45 PM")]
+    public void ValidateCustomDateTimeFormats(string format, string expectedResult)
+    {
+        // Setup
+        var testDate = new DateTime(2023, 12, 25, 14, 30, 45);
+
+        // Act
+        var result = testDate.ToString(format, CultureInfo.CurrentCulture);
+
+        // Assert
+        Assert.AreEqual(expectedResult, result);
+    }
+}

src/modules/cmdpal/Tests/Microsoft.CmdPal.Ext.TimeDate.UnitTests/TimeDateCalculatorTests.cs

@@ -0,0 +1,124 @@
+// 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 Microsoft.CmdPal.Ext.TimeDate.Helpers;
+using Microsoft.CommandPalette.Extensions.Toolkit;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+
+namespace Microsoft.CmdPal.Ext.TimeDate.UnitTests;
+
+[TestClass]
+public class TimeDateCalculatorTests
+{
+    private CultureInfo originalCulture;
+    private CultureInfo originalUiCulture;
+
+    [TestInitialize]
+    public void Setup()
+    {
+        // Set culture to 'en-us'
+        originalCulture = CultureInfo.CurrentCulture;
+        CultureInfo.CurrentCulture = new CultureInfo("en-us", false);
+        originalUiCulture = CultureInfo.CurrentUICulture;
+        CultureInfo.CurrentUICulture = new CultureInfo("en-us", false);
+    }
+
+    [TestCleanup]
+    public void Cleanup()
+    {
+        // Restore original culture
+        CultureInfo.CurrentCulture = originalCulture;
+        CultureInfo.CurrentUICulture = originalUiCulture;
+    }
+
+    [TestMethod]
+    public void CountAllResults()
+    {
+        // Setup
+        var settings = new SettingsManager();
+
+        // Act
+        var results = TimeDateCalculator.ExecuteSearch(settings, string.Empty);
+
+        // Assert
+        Assert.IsTrue(results.Count > 0);
+    }
+
+    [TestMethod]
+    public void ValidateEmptyQuery()
+    {
+        // Setup
+        var settings = new SettingsManager();
+
+        // Act
+        var results = TimeDateCalculator.ExecuteSearch(settings, string.Empty);
+
+        // Assert
+        Assert.IsNotNull(results);
+    }
+
+    [TestMethod]
+    public void ValidateNullQuery()
+    {
+        // Setup
+        var settings = new SettingsManager();
+
+        // Act
+        var results = TimeDateCalculator.ExecuteSearch(settings, null);
+
+        // Assert
+        Assert.IsNotNull(results);
+    }
+
+    [TestMethod]
+    public void ValidateTimeParsing()
+    {
+        // Setup
+        var settings = new SettingsManager();
+        var query = "time::10:30:45";
+
+        // Act
+        var results = TimeDateCalculator.ExecuteSearch(settings, query);
+
+        // Assert
+        Assert.IsNotNull(results);
+        Assert.IsTrue(results.Count >= 0); // May have 0 results due to invalid format, but shouldn't crash
+    }
+
+    [TestMethod]
+    public void ValidateDateParsing()
+    {
+        // Setup
+        var settings = new SettingsManager();
+        var query = "date::12/25/2023";
+
+        // Act
+        var results = TimeDateCalculator.ExecuteSearch(settings, query);
+
+        // Assert
+        Assert.IsNotNull(results);
+        Assert.IsTrue(results.Count >= 0); // May have 0 results due to invalid format, but shouldn't crash
+    }
+
+    [TestMethod]
+    public void ValidateCommonQueries()
+    {
+        // Setup
+        var settings = new SettingsManager();
+        var queries = new[] { "time", "date", "now", "current" };
+
+        foreach (var query in queries)
+        {
+            // Act
+            var results = TimeDateCalculator.ExecuteSearch(settings, query);
+
+            // Assert
+            Assert.IsNotNull(results, $"Results should not be null for query: {query}");
+        }
+    }
+}

src/modules/cmdpal/Tests/Microsoft.CmdPal.Ext.TimeDate.UnitTests/TimeDateCommandsProviderTests.cs

@@ -0,0 +1,109 @@
+// 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.Globalization;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+
+namespace Microsoft.CmdPal.Ext.TimeDate.UnitTests
+{
+    [TestClass]
+    public class TimeDateCommandsProviderTests
+    {
+        private CultureInfo originalCulture;
+        private CultureInfo originalUiCulture;
+
+        [TestInitialize]
+        public void Setup()
+        {
+            // Set culture to 'en-us'
+            originalCulture = CultureInfo.CurrentCulture;
+            CultureInfo.CurrentCulture = new CultureInfo("en-us", false);
+            originalUiCulture = CultureInfo.CurrentUICulture;
+            CultureInfo.CurrentUICulture = new CultureInfo("en-us", false);
+        }
+
+        [TestCleanup]
+        public void Cleanup()
+        {
+            // Restore original culture
+            CultureInfo.CurrentCulture = originalCulture;
+            CultureInfo.CurrentUICulture = originalUiCulture;
+        }
+
+        [TestMethod]
+        public void TimeDateCommandsProviderInitializationTest()
+        {
+            // Act
+            var provider = new TimeDateCommandsProvider();
+
+            // Assert
+            Assert.IsNotNull(provider);
+            Assert.IsNotNull(provider.DisplayName);
+            Assert.AreEqual("DateTime", provider.Id);
+            Assert.IsNotNull(provider.Icon);
+            Assert.IsNotNull(provider.Settings);
+        }
+
+        [TestMethod]
+        public void TopLevelCommandsTest()
+        {
+            // Setup
+            var provider = new TimeDateCommandsProvider();
+
+            // Act
+            var commands = provider.TopLevelCommands();
+
+            // Assert
+            Assert.IsNotNull(commands);
+            Assert.AreEqual(1, commands.Length);
+            Assert.IsNotNull(commands[0]);
+            Assert.IsNotNull(commands[0].Title);
+            Assert.IsNotNull(commands[0].Icon);
+        }
+
+        [TestMethod]
+        public void FallbackCommandsTest()
+        {
+            // Setup
+            var provider = new TimeDateCommandsProvider();
+
+            // Act
+            var fallbackCommands = provider.FallbackCommands();
+
+            // Assert
+            Assert.IsNotNull(fallbackCommands);
+            Assert.AreEqual(1, fallbackCommands.Length);
+            Assert.IsNotNull(fallbackCommands[0]);
+        }
+
+        [TestMethod]
+        public void DisplayNameTest()
+        {
+            // Setup
+            var provider = new TimeDateCommandsProvider();
+
+            // Act
+            var displayName = provider.DisplayName;
+
+            // Assert
+            Assert.IsFalse(string.IsNullOrEmpty(displayName));
+        }
+
+        [TestMethod]
+        public void GetTranslatedPluginDescriptionTest()
+        {
+            // Setup
+            var provider = new TimeDateCommandsProvider();
+
+            // Act
+            var commands = provider.TopLevelCommands();
+            var subtitle = commands[0].Subtitle;
+
+            // Assert
+            Assert.IsFalse(string.IsNullOrEmpty(subtitle));
+            Assert.IsTrue(subtitle.Contains("Provides time and date values in different formats"));
+        }
+    }
+}

src/modules/cmdpal/Tests/Microsoft.CmdPal.Ext.WindowWalker.UnitTests/Microsoft.CmdPal.Ext.WindowWalker.UnitTests.csproj

@@ -0,0 +1,24 @@
+<Project Sdk="Microsoft.NET.Sdk">
+  <!-- Look at Directory.Build.props in root for common stuff as well -->
+  <Import Project="..\..\..\..\Common.Dotnet.CsWinRT.props" />
+
+  <PropertyGroup>
+    <IsPackable>false</IsPackable>
+    <IsTestProject>true</IsTestProject>
+    <RootNamespace>Microsoft.CmdPal.Ext.WindowWalker.UnitTests</RootNamespace>
+    <OutputPath>$(SolutionDir)$(Platform)\$(Configuration)\WinUI3Apps\CmdPal\tests\</OutputPath>
+    <AppendTargetFrameworkToOutputPath>false</AppendTargetFrameworkToOutputPath>
+    <AppendRuntimeIdentifierToOutputPath>false</AppendRuntimeIdentifierToOutputPath>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <PackageReference Include="Moq" />
+    <PackageReference Include="MSTest" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="..\..\..\..\common\ManagedCommon\ManagedCommon.csproj" />
+    <ProjectReference Include="..\..\ext\Microsoft.CmdPal.Ext.WindowWalker\Microsoft.CmdPal.Ext.WindowWalker.csproj" />
+    <ProjectReference Include="..\..\extensionsdk\Microsoft.CommandPalette.Extensions.Toolkit\Microsoft.CommandPalette.Extensions.Toolkit.csproj" />
+  </ItemGroup>
+</Project>

src/modules/cmdpal/Tests/Microsoft.CmdPal.Ext.WindowWalker.UnitTests/PluginSettingsTests.cs

@@ -0,0 +1,60 @@
+// 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.Reflection;
+
+using Microsoft.CmdPal.Ext.WindowWalker.Helpers;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+
+namespace Microsoft.CmdPal.Ext.WindowWalker.UnitTests;
+
+[TestClass]
+public class PluginSettingsTests
+{
+    [DataTestMethod]
+    [DataRow("ResultsFromVisibleDesktopOnly")]
+    [DataRow("SubtitleShowPid")]
+    [DataRow("SubtitleShowDesktopName")]
+    [DataRow("ConfirmKillProcess")]
+    [DataRow("KillProcessTree")]
+    [DataRow("OpenAfterKillAndClose")]
+    [DataRow("HideKillProcessOnElevatedProcesses")]
+    [DataRow("HideExplorerSettingInfo")]
+    [DataRow("InMruOrder")]
+    public void DoesSettingExist(string name)
+    {
+        // Setup
+        Type settings = SettingsManager.Instance?.GetType();
+
+        // Act
+        var result = settings?.GetProperty(name, BindingFlags.Public | BindingFlags.Instance);
+
+        // Assert
+        Assert.IsNotNull(result);
+    }
+
+    [DataTestMethod]
+    [DataRow("ResultsFromVisibleDesktopOnly", false)]
+    [DataRow("SubtitleShowPid", false)]
+    [DataRow("SubtitleShowDesktopName", true)]
+    [DataRow("ConfirmKillProcess", true)]
+    [DataRow("KillProcessTree", false)]
+    [DataRow("OpenAfterKillAndClose", false)]
+    [DataRow("HideKillProcessOnElevatedProcesses", false)]
+    [DataRow("HideExplorerSettingInfo", true)]
+    [DataRow("InMruOrder", true)]
+    public void DefaultValues(string name, bool valueExpected)
+    {
+        // Setup
+        SettingsManager setting = SettingsManager.Instance;
+
+        // Act
+        PropertyInfo propertyInfo = setting?.GetType()?.GetProperty(name, BindingFlags.Public | BindingFlags.Instance);
+        var result = propertyInfo?.GetValue(setting);
+
+        // Assert
+        Assert.AreEqual(valueExpected, result);
+    }
+}

src/modules/cmdpal/ext/Microsoft.CmdPal.Ext.Apps/AppCache.cs

@@ -4,6 +4,7 @@
 
 using System;
 using System.Collections.Generic;
+using System.IO;
 using System.Linq;
 using System.Threading.Tasks;
 using Microsoft.CmdPal.Ext.Apps.Programs;
@@ -46,7 +47,19 @@ public sealed partial class AppCache : IDisposable
             UpdateUWPIconPath(ThemeHelper.GetCurrentTheme());
         });
 
-        Task.WaitAll(a, b);
+        try
+        {
+            Task.WaitAll(a, b);
+        }
+        catch (AggregateException ex)
+        {
+            ManagedCommon.Logger.LogError("One or more errors occurred while indexing apps");
+
+            foreach (var inner in ex.InnerExceptions)
+            {
+                ManagedCommon.Logger.LogError(inner.Message, inner);
+            }
+        }
 
         AllAppsSettings.Instance.LastIndexTime = DateTime.Today;
     }
@@ -57,7 +70,14 @@ public sealed partial class AppCache : IDisposable
         {
             foreach (UWPApplication app in _packageRepository)
             {
-                app.UpdateLogoPath(theme);
+                try
+                {
+                    app.UpdateLogoPath(theme);
+                }
+                catch (Exception ex)
+                {
+                    ManagedCommon.Logger.LogError($"Failed to update icon path for app {app.Name}", ex);
+                }
             }
         }
     }

src/modules/cmdpal/ext/Microsoft.CmdPal.Ext.Apps/Programs/UWP.cs

@@ -128,14 +128,6 @@ public partial class UWP
 
     public static UWPApplication[] All()
     {
-        var windows10 = new Version(10, 0);
-        var support = Environment.OSVersion.Version.Major >= windows10.Major;
-
-        if (!support)
-        {
-            return Array.Empty<UWPApplication>();
-        }
-
         var appsBag = new ConcurrentBag<UWPApplication>();
 
         Parallel.ForEach(CurrentUserPackages(), p =>

src/modules/cmdpal/ext/Microsoft.CmdPal.Ext.Apps/Storage/PackageRepository.cs

@@ -115,11 +115,7 @@ internal sealed partial class PackageRepository : ListRepository<UWPApplication>
 
     public void IndexPrograms()
     {
-        var windows10 = new Version(10, 0);
-        var support = Environment.OSVersion.Version.Major >= windows10.Major;
-
-        var applications = support ? Programs.UWP.All() : Array.Empty<UWPApplication>();
-
+        var applications = UWP.All();
         SetList(applications);
     }
 }

src/modules/cmdpal/ext/Microsoft.CmdPal.Ext.Apps/Storage/Win32ProgramRepository.cs

@@ -267,8 +267,7 @@ internal sealed partial class Win32ProgramRepository : ListRepository<Programs.W
 
     public void IndexPrograms()
     {
-        var applications = Programs.Win32Program.All(_settings);
-
+        var applications = Win32Program.All(_settings);
         SetList(applications);
     }
 }

src/modules/cmdpal/ext/Microsoft.CmdPal.Ext.Calc/Helper/ResultHelper.cs

@@ -30,13 +30,14 @@ public static class ResultHelper
 
         var copyCommandItem = CreateResult(roundedResult, inputCulture, outputCulture, query);
 
+        // No TextToSuggest on the main save command item. We don't want to keep suggesting what the result is,
+        // as the user is typing it.
         return new ListItem(saveCommand)
         {
             // Using CurrentCulture since this is user facing
             Icon = Icons.ResultIcon,
             Title = result,
             Subtitle = query,
-            TextToSuggest = result,
             MoreCommands = [
                 new CommandContextItem(copyCommandItem.Command)
                 {

src/modules/cmdpal/ext/Microsoft.CmdPal.Ext.Indexer/FallbackOpenFileItem.cs

@@ -23,6 +23,8 @@ internal sealed partial class FallbackOpenFileItem : FallbackCommandItem, System
 
     private uint _queryCookie = 10;
 
+    private Func<string, bool> _suppressCallback;
+
     public FallbackOpenFileItem()
         : base(_baseCommandWithId, Resources.Indexer_Find_Path_fallback_display_title)
     {
@@ -44,6 +46,17 @@ internal sealed partial class FallbackOpenFileItem : FallbackCommandItem, System
             return;
         }
 
+        if (_suppressCallback != null && _suppressCallback(query))
+        {
+            Command = new NoOpCommand();
+            Title = string.Empty;
+            Subtitle = string.Empty;
+            Icon = null;
+            MoreCommands = null;
+
+            return;
+        }
+
         if (Path.Exists(query))
         {
             // Exit 1: The query is a direct path to a file. Great! Return it.
@@ -128,4 +141,9 @@ internal sealed partial class FallbackOpenFileItem : FallbackCommandItem, System
         _searchEngine.Dispose();
         GC.SuppressFinalize(this);
     }
+
+    public void SuppressFallbackWhen(Func<string, bool> callback)
+    {
+        _suppressCallback = callback;
+    }
 }

src/modules/cmdpal/ext/Microsoft.CmdPal.Ext.Indexer/IndexerCommandsProvider.cs

@@ -2,6 +2,7 @@
 // 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 Microsoft.CmdPal.Ext.Indexer.Data;
 using Microsoft.CmdPal.Ext.Indexer.Properties;
 using Microsoft.CommandPalette.Extensions;
@@ -41,4 +42,9 @@ public partial class IndexerCommandsProvider : CommandProvider
         [
             _fallbackFileItem
         ];
+
+    public void SuppressFallbackWhen(Func<string, bool> callback)
+    {
+        _fallbackFileItem.SuppressFallbackWhen(callback);
+    }
 }

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

@@ -10,6 +10,13 @@
     <!-- MRT from windows app sdk will search for a pri file with the same name of the module before defaulting to resources.pri -->
     <ProjectPriFileName>Microsoft.CmdPal.Ext.Registry.pri</ProjectPriFileName>
   </PropertyGroup>
+
+  <ItemGroup>
+    <AssemblyAttribute Include="System.Runtime.CompilerServices.InternalsVisibleTo">
+      <_Parameter1>Microsoft.CmdPal.Ext.Registry.UnitTests</_Parameter1>
+    </AssemblyAttribute>
+  </ItemGroup>
+
   <ItemGroup>
     <PackageReference Include="System.ServiceProcess.ServiceController" />
   </ItemGroup>

src/modules/cmdpal/ext/Microsoft.CmdPal.Ext.Shell/Commands/ExecuteItem.cs

@@ -36,7 +36,7 @@ internal sealed partial class ExecuteItem : InvokableCommand
         else
         {
             Name = Properties.Resources.generic_run_command;
-            Icon = Icons.ReturnIcon;
+            Icon = Icons.RunV2Icon;
         }
 
         Cmd = cmd;
@@ -44,36 +44,6 @@ internal sealed partial class ExecuteItem : InvokableCommand
         _runas = type;
     }
 
-    private static bool ExistInPath(string filename)
-    {
-        if (File.Exists(filename))
-        {
-            return true;
-        }
-        else
-        {
-            var values = Environment.GetEnvironmentVariable("PATH");
-            if (values != null)
-            {
-                foreach (var path in values.Split(';'))
-                {
-                    var path1 = Path.Combine(path, filename);
-                    var path2 = Path.Combine(path, filename + ".exe");
-                    if (File.Exists(path1) || File.Exists(path2))
-                    {
-                        return true;
-                    }
-                }
-
-                return false;
-            }
-            else
-            {
-                return false;
-            }
-        }
-    }
-
     private void Execute(Func<ProcessStartInfo, Process?> startProcess, ProcessStartInfo info)
     {
         if (startProcess == null)
@@ -184,7 +154,7 @@ internal sealed partial class ExecuteItem : InvokableCommand
                     if (parts.Length == 2)
                     {
                         var filename = parts[0];
-                        if (ExistInPath(filename))
+                        if (ShellListPageHelpers.FileExistInPath(filename))
                         {
                             var arguments = parts[1];
                             if (_settings.LeaveShellOpen)

src/modules/cmdpal/ext/Microsoft.CmdPal.Ext.Shell/FallbackExecuteItem.cs

@@ -2,39 +2,197 @@
 // 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.Ext.Shell.Commands;
+using System;
+using System.IO;
+using System.Threading;
+using System.Threading.Tasks;
 using Microsoft.CmdPal.Ext.Shell.Helpers;
+using Microsoft.CmdPal.Ext.Shell.Pages;
 using Microsoft.CmdPal.Ext.Shell.Properties;
 using Microsoft.CommandPalette.Extensions.Toolkit;
 
 namespace Microsoft.CmdPal.Ext.Shell;
 
-internal sealed partial class FallbackExecuteItem : FallbackCommandItem
+internal sealed partial class FallbackExecuteItem : FallbackCommandItem, IDisposable
 {
-    private readonly ExecuteItem _executeItem;
-    private readonly SettingsManager _settings;
+    private CancellationTokenSource? _cancellationTokenSource;
+    private Task? _currentUpdateTask;
 
     public FallbackExecuteItem(SettingsManager settings)
         : base(
-            new ExecuteItem(string.Empty, settings) { Id = "com.microsoft.run.fallback" },
+            new NoOpCommand() { Id = "com.microsoft.run.fallback" },
             Resources.shell_command_display_title)
     {
-        _settings = settings;
-        _executeItem = (ExecuteItem)this.Command!;
         Title = string.Empty;
-        _executeItem.Name = string.Empty;
         Subtitle = Properties.Resources.generic_run_command;
         Icon = Icons.RunV2Icon; // Defined in Icons.cs and contains the execute command icon.
     }
 
     public override void UpdateQuery(string query)
     {
-        _executeItem.Cmd = query;
-        _executeItem.Name = string.IsNullOrEmpty(query) ? string.Empty : Properties.Resources.generic_run_command;
-        Title = query;
-        MoreCommands = [
-            new CommandContextItem(new ExecuteItem(query, _settings, RunAsType.Administrator)),
-            new CommandContextItem(new ExecuteItem(query, _settings, RunAsType.OtherUser)),
-        ];
+        // Cancel any ongoing query processing
+        _cancellationTokenSource?.Cancel();
+
+        _cancellationTokenSource = new CancellationTokenSource();
+        var cancellationToken = _cancellationTokenSource.Token;
+
+        try
+        {
+            // Save the latest update task
+            _currentUpdateTask = DoUpdateQueryAsync(query, cancellationToken);
+        }
+        catch (OperationCanceledException)
+        {
+            // DO NOTHING HERE
+            return;
+        }
+        catch (Exception)
+        {
+            // Handle other exceptions
+            return;
+        }
+
+        // Await the task to ensure only the latest one gets processed
+        _ = ProcessUpdateResultsAsync(_currentUpdateTask);
+    }
+
+    private async Task ProcessUpdateResultsAsync(Task updateTask)
+    {
+        try
+        {
+            await updateTask;
+        }
+        catch (OperationCanceledException)
+        {
+            // Handle cancellation gracefully
+        }
+        catch (Exception)
+        {
+            // Handle other exceptions
+        }
+    }
+
+    private async Task DoUpdateQueryAsync(string query, CancellationToken cancellationToken)
+    {
+        // Check for cancellation at the start
+        cancellationToken.ThrowIfCancellationRequested();
+
+        var searchText = query.Trim();
+        var expanded = Environment.ExpandEnvironmentVariables(searchText);
+        searchText = expanded;
+        if (string.IsNullOrEmpty(searchText) || string.IsNullOrWhiteSpace(searchText))
+        {
+            Command = null;
+            Title = string.Empty;
+            return;
+        }
+
+        ShellListPage.ParseExecutableAndArgs(searchText, out var exe, out var args);
+
+        // Check for cancellation before file system operations
+        cancellationToken.ThrowIfCancellationRequested();
+
+        var exeExists = false;
+        var fullExePath = string.Empty;
+        var pathIsDir = false;
+
+        try
+        {
+            // Create a timeout for file system operations (200ms)
+            using var timeoutCts = new CancellationTokenSource(TimeSpan.FromMilliseconds(200));
+            using var combinedCts = CancellationTokenSource.CreateLinkedTokenSource(cancellationToken, timeoutCts.Token);
+            var timeoutToken = combinedCts.Token;
+
+            // Use Task.Run with timeout for file system operations
+            var fileSystemTask = Task.Run(
+                () =>
+                {
+                    exeExists = ShellListPageHelpers.FileExistInPath(exe, out fullExePath);
+                    pathIsDir = Directory.Exists(exe);
+                },
+                CancellationToken.None);
+
+            // Wait for either completion or timeout
+            await fileSystemTask.WaitAsync(timeoutToken);
+        }
+        catch (OperationCanceledException) when (cancellationToken.IsCancellationRequested)
+        {
+            // Main cancellation token was cancelled, re-throw
+            throw;
+        }
+        catch (TimeoutException)
+        {
+            // Timeout occurred - use defaults
+            return;
+        }
+        catch (OperationCanceledException)
+        {
+            // Timeout occurred (from WaitAsync) - use defaults
+            return;
+        }
+        catch (Exception)
+        {
+            // Handle any other exceptions that might bubble up
+            return;
+        }
+
+        // Check for cancellation before updating UI properties
+        cancellationToken.ThrowIfCancellationRequested();
+
+        if (exeExists)
+        {
+            // TODO we need to probably get rid of the settings for this provider entirely
+            var exeItem = ShellListPage.CreateExeItem(exe, args, fullExePath);
+            Title = exeItem.Title;
+            Subtitle = exeItem.Subtitle;
+            Icon = exeItem.Icon;
+            Command = exeItem.Command;
+            MoreCommands = exeItem.MoreCommands;
+        }
+        else if (pathIsDir)
+        {
+            var pathItem = new PathListItem(exe, query);
+            Title = pathItem.Title;
+            Subtitle = pathItem.Subtitle;
+            Icon = pathItem.Icon;
+            Command = pathItem.Command;
+            MoreCommands = pathItem.MoreCommands;
+        }
+        else if (System.Uri.TryCreate(searchText, UriKind.Absolute, out var uri))
+        {
+            Command = new OpenUrlCommand(searchText) { Result = CommandResult.Dismiss() };
+            Title = searchText;
+        }
+        else
+        {
+            Command = null;
+            Title = string.Empty;
+        }
+
+        // Final cancellation check
+        cancellationToken.ThrowIfCancellationRequested();
+    }
+
+    public void Dispose()
+    {
+        _cancellationTokenSource?.Cancel();
+        _cancellationTokenSource?.Dispose();
+    }
+
+    internal static bool SuppressFileFallbackIf(string query)
+    {
+        var searchText = query.Trim();
+        var expanded = Environment.ExpandEnvironmentVariables(searchText);
+        searchText = expanded;
+        if (string.IsNullOrEmpty(searchText) || string.IsNullOrWhiteSpace(searchText))
+        {
+            return false;
+        }
+
+        ShellListPage.ParseExecutableAndArgs(searchText, out var exe, out var args);
+        var exeExists = ShellListPageHelpers.FileExistInPath(exe, out var fullExePath);
+        var pathIsDir = Directory.Exists(exe);
+
+        return exeExists || pathIsDir;
     }
 }

src/modules/cmdpal/ext/Microsoft.CmdPal.Ext.Shell/Helpers/ShellListPageHelpers.cs

@@ -4,11 +4,9 @@
 
 using System;
 using System.Collections.Generic;
-using System.Globalization;
-using System.Linq;
-using System.Reflection;
+using System.IO;
 using System.Text;
-using System.Threading.Tasks;
+using System.Threading;
 using Microsoft.CmdPal.Ext.Shell.Commands;
 using Microsoft.CommandPalette.Extensions.Toolkit;
 
@@ -26,7 +24,7 @@ public class ShellListPageHelpers
 
     private ListItem GetCurrentCmd(string cmd)
     {
-        ListItem result = new ListItem(new ExecuteItem(cmd, _settings))
+        var result = new ListItem(new ExecuteItem(cmd, _settings))
         {
             Title = cmd,
             Subtitle = Properties.Resources.cmd_plugin_name + ": " + Properties.Resources.cmd_execute_through_shell,
@@ -36,58 +34,6 @@ public class ShellListPageHelpers
         return result;
     }
 
-    private List<ListItem> GetHistoryCmds(string cmd, ListItem result)
-    {
-        IEnumerable<ListItem?> history = _settings.Count.Where(o => o.Key.Contains(cmd, StringComparison.CurrentCultureIgnoreCase))
-            .OrderByDescending(o => o.Value)
-            .Select(m =>
-            {
-                if (m.Key == cmd)
-                {
-                    // Using CurrentCulture since this is user facing
-                    result.Subtitle = Properties.Resources.cmd_plugin_name + ": " + string.Format(CultureInfo.CurrentCulture, CmdHasBeenExecutedTimes, m.Value);
-                    return null;
-                }
-
-                var ret = new ListItem(new ExecuteItem(m.Key, _settings))
-                {
-                    Title = m.Key,
-
-                    // Using CurrentCulture since this is user facing
-                    Subtitle = Properties.Resources.cmd_plugin_name + ": " + string.Format(CultureInfo.CurrentCulture, CmdHasBeenExecutedTimes, m.Value),
-                    Icon = Icons.HistoryIcon,
-                };
-                return ret;
-            }).Where(o => o != null).Take(4);
-        return history.Select(o => o!).ToList();
-    }
-
-    public List<ListItem> Query(string query)
-    {
-        ArgumentNullException.ThrowIfNull(query);
-
-        List<ListItem> results = new List<ListItem>();
-        var cmd = query;
-        if (string.IsNullOrEmpty(cmd))
-        {
-            results = ResultsFromHistory();
-        }
-        else
-        {
-            var queryCmd = GetCurrentCmd(cmd);
-            results.Add(queryCmd);
-            var history = GetHistoryCmds(cmd, queryCmd);
-            results.AddRange(history);
-        }
-
-        foreach (var currItem in results)
-        {
-            currItem.MoreCommands = LoadContextMenus(currItem).ToArray();
-        }
-
-        return results;
-    }
-
     public List<CommandContextItem> LoadContextMenus(ListItem listItem)
     {
         var resultList = new List<CommandContextItem>
@@ -99,18 +45,53 @@ public class ShellListPageHelpers
         return resultList;
     }
 
-    private List<ListItem> ResultsFromHistory()
+    internal static bool FileExistInPath(string filename)
     {
-        IEnumerable<ListItem> history = _settings.Count.OrderByDescending(o => o.Value)
-            .Select(m => new ListItem(new ExecuteItem(m.Key, _settings))
+        return FileExistInPath(filename, out var _);
+    }
+
+    internal static bool FileExistInPath(string filename, out string fullPath, CancellationToken? token = null)
+    {
+        fullPath = string.Empty;
+
+        if (File.Exists(filename))
+        {
+            token?.ThrowIfCancellationRequested();
+            fullPath = Path.GetFullPath(filename);
+            return true;
+        }
+        else
+        {
+            var values = Environment.GetEnvironmentVariable("PATH");
+            if (values != null)
             {
-                Title = m.Key,
+                foreach (var path in values.Split(';'))
+                {
+                    var path1 = Path.Combine(path, filename);
+                    if (File.Exists(path1))
+                    {
+                        fullPath = Path.GetFullPath(path1);
+                        return true;
+                    }
 
-                // Using CurrentCulture since this is user facing
-                Subtitle = Properties.Resources.cmd_plugin_name + ": " + string.Format(CultureInfo.CurrentCulture, CmdHasBeenExecutedTimes, m.Value),
-                Icon = Icons.HistoryIcon,
-            }).Take(5);
+                    token?.ThrowIfCancellationRequested();
 
-        return history.ToList();
+                    var path2 = Path.Combine(path, filename + ".exe");
+                    if (File.Exists(path2))
+                    {
+                        fullPath = Path.GetFullPath(path2);
+                        return true;
+                    }
+
+                    token?.ThrowIfCancellationRequested();
+                }
+
+                return false;
+            }
+            else
+            {
+                return false;
+            }
+        }
     }
 }

src/modules/cmdpal/ext/Microsoft.CmdPal.Ext.Shell/Icons.cs

@@ -10,11 +10,9 @@ internal sealed class Icons
 {
     internal static IconInfo RunV2Icon { get; } = IconHelpers.FromRelativePath("Assets\\Run.svg");
 
-    internal static IconInfo HistoryIcon { get; } = new IconInfo("\uE81C"); // History
+    internal static IconInfo FolderIcon { get; } = new IconInfo("📁");
 
     internal static IconInfo AdminIcon { get; } = new IconInfo("\xE7EF"); // Admin Icon
 
     internal static IconInfo UserIcon { get; } = new IconInfo("\xE7EE"); // User Icon
-
-    internal static IconInfo ReturnIcon { get; } = new IconInfo("\uE751"); // Return Key Icon
 }

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

@@ -15,6 +15,10 @@
   <ItemGroup>
     <ProjectReference Include="..\..\extensionsdk\Microsoft.CommandPalette.Extensions.Toolkit\Microsoft.CommandPalette.Extensions.Toolkit.csproj" />
   </ItemGroup>
+  <ItemGroup>
+    <PackageReference Include="System.CommandLine" />
+  </ItemGroup>
+  
   <ItemGroup>
     <Compile Update="Properties\Resources.Designer.cs">
       <DependentUpon>Resources.resx</DependentUpon>

src/modules/cmdpal/ext/Microsoft.CmdPal.Ext.Shell/Pages/RunExeItem.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.Threading.Tasks;
+using Microsoft.CommandPalette.Extensions;
+using Microsoft.CommandPalette.Extensions.Toolkit;
+using Windows.Storage.Streams;
+
+namespace Microsoft.CmdPal.Ext.Shell.Pages;
+
+internal sealed partial class RunExeItem : ListItem
+{
+    private readonly Lazy<IconInfo> _icon;
+
+    public override IIconInfo? Icon { get => _icon.Value; set => base.Icon = value; }
+
+    internal string FullExePath { get; private set; }
+
+    internal string Exe { get; private set; }
+
+    private string _args = string.Empty;
+
+    public RunExeItem(string exe, string args, string fullExePath)
+    {
+        FullExePath = fullExePath;
+        Exe = exe;
+        var command = new AnonymousCommand(Run)
+        {
+            Name = Properties.Resources.generic_run_command,
+            Result = CommandResult.Dismiss(),
+        };
+        Command = command;
+        Subtitle = FullExePath;
+
+        _icon = new Lazy<IconInfo>(() =>
+        {
+            var t = FetchIcon();
+            t.Wait();
+            return t.Result;
+        });
+
+        UpdateArgs(args);
+
+        MoreCommands = [
+            new CommandContextItem(
+                new AnonymousCommand(RunAsAdmin)
+            {
+                Name = Properties.Resources.cmd_run_as_administrator,
+                Icon = Icons.AdminIcon,
+            }),
+            new CommandContextItem(
+                new AnonymousCommand(RunAsOther)
+            {
+                Name = Properties.Resources.cmd_run_as_user,
+                Icon = Icons.UserIcon,
+            }),
+        ];
+    }
+
+    internal void UpdateArgs(string args)
+    {
+        _args = args;
+        Title = string.IsNullOrEmpty(_args) ? Exe : Exe + " " + _args; // todo! you're smarter than this
+    }
+
+    public async Task<IconInfo> FetchIcon()
+    {
+        IconInfo? icon = null;
+
+        try
+        {
+            var stream = await ThumbnailHelper.GetThumbnail(FullExePath);
+            if (stream != null)
+            {
+                var data = new IconData(RandomAccessStreamReference.CreateFromStream(stream));
+                icon = new IconInfo(data, data);
+                ((AnonymousCommand?)Command)!.Icon = icon;
+            }
+        }
+        catch
+        {
+        }
+
+        icon = icon ?? new IconInfo(FullExePath);
+        return icon;
+    }
+
+    public void Run()
+    {
+        ShellHelpers.OpenInShell(FullExePath, _args);
+    }
+
+    public void RunAsAdmin()
+    {
+        ShellHelpers.OpenInShell(FullExePath, _args, runAs: ShellHelpers.ShellRunAsType.Administrator);
+    }
+
+    public void RunAsOther()
+    {
+        ShellHelpers.OpenInShell(FullExePath, _args, runAs: ShellHelpers.ShellRunAsType.OtherUser);
+    }
+}

src/modules/cmdpal/ext/Microsoft.CmdPal.Ext.Shell/Pages/ShellListPage.cs

@@ -2,6 +2,12 @@
 // 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.Linq;
+using System.Threading;
+using System.Threading.Tasks;
 using Microsoft.CmdPal.Ext.Shell.Helpers;
 using Microsoft.CmdPal.Ext.Shell.Properties;
 using Microsoft.CommandPalette.Extensions;
@@ -9,20 +15,436 @@ using Microsoft.CommandPalette.Extensions.Toolkit;
 
 namespace Microsoft.CmdPal.Ext.Shell.Pages;
 
-internal sealed partial class ShellListPage : DynamicListPage
+internal sealed partial class ShellListPage : DynamicListPage, IDisposable
 {
     private readonly ShellListPageHelpers _helper;
 
-    public ShellListPage(SettingsManager settingsManager)
+    private readonly List<ListItem> _topLevelItems = [];
+    private readonly List<ListItem> _historyItems = [];
+    private RunExeItem? _exeItem;
+    private List<ListItem> _pathItems = [];
+    private ListItem? _uriItem;
+
+    private CancellationTokenSource? _cancellationTokenSource;
+    private Task? _currentSearchTask;
+
+    public ShellListPage(SettingsManager settingsManager, bool addBuiltins = false)
     {
         Icon = Icons.RunV2Icon;
         Id = "com.microsoft.cmdpal.shell";
         Name = Resources.cmd_plugin_name;
         PlaceholderText = Resources.list_placeholder_text;
         _helper = new(settingsManager);
+
+        EmptyContent = new CommandItem()
+        {
+            Title = Resources.cmd_plugin_name,
+            Icon = Icons.RunV2Icon,
+            Subtitle = Resources.list_placeholder_text,
+        };
+
+        if (addBuiltins)
+        {
+            // here, we _could_ add built-in providers if we wanted. links to apps, calc, etc.
+            // That would be a truly run-first experience
+        }
     }
 
-    public override void UpdateSearchText(string oldSearch, string newSearch) => RaiseItemsChanged(0);
+    public override void UpdateSearchText(string oldSearch, string newSearch)
+    {
+        if (newSearch == oldSearch)
+        {
+            return;
+        }
 
-    public override IListItem[] GetItems() => [.. _helper.Query(SearchText)];
+        DoUpdateSearchText(newSearch);
+    }
+
+    private void DoUpdateSearchText(string newSearch)
+    {
+        // Cancel any ongoing search
+        _cancellationTokenSource?.Cancel();
+
+        _cancellationTokenSource = new CancellationTokenSource();
+        var cancellationToken = _cancellationTokenSource.Token;
+
+        IsLoading = true;
+
+        try
+        {
+            // Save the latest search task
+            _currentSearchTask = BuildListItemsForSearchAsync(newSearch, cancellationToken);
+        }
+        catch (OperationCanceledException)
+        {
+            // DO NOTHING HERE
+            return;
+        }
+        catch (Exception)
+        {
+            // Handle other exceptions
+            return;
+        }
+
+        // Await the task to ensure only the latest one gets processed
+        _ = ProcessSearchResultsAsync(_currentSearchTask, newSearch);
+    }
+
+    private async Task ProcessSearchResultsAsync(Task searchTask, string newSearch)
+    {
+        try
+        {
+            await searchTask;
+
+            // Ensure this is still the latest task
+            if (_currentSearchTask == searchTask)
+            {
+                // The search results have already been updated in BuildListItemsForSearchAsync
+                IsLoading = false;
+                RaiseItemsChanged();
+            }
+        }
+        catch (OperationCanceledException)
+        {
+            // Handle cancellation gracefully
+        }
+        catch (Exception)
+        {
+            // Handle other exceptions
+            IsLoading = false;
+        }
+    }
+
+    private async Task BuildListItemsForSearchAsync(string newSearch, CancellationToken cancellationToken)
+    {
+        // Check for cancellation at the start
+        cancellationToken.ThrowIfCancellationRequested();
+
+        // If the search text is the start of a path to a file (it might be a
+        // UNC path), then we want to list all the files that start with that text:
+
+        // 1. Check if the search text is a valid path
+        // 2. If it is, then list all the files that start with that text
+        var searchText = newSearch.Trim();
+
+        var expanded = Environment.ExpandEnvironmentVariables(searchText);
+
+        // Check for cancellation after environment expansion
+        cancellationToken.ThrowIfCancellationRequested();
+
+        // TODO we can be smarter about only re-reading the filesystem if the
+        // new search is just the oldSearch+some chars
+        if (string.IsNullOrEmpty(searchText) || string.IsNullOrWhiteSpace(searchText))
+        {
+            _pathItems.Clear();
+            _exeItem = null;
+            _uriItem = null;
+            return;
+        }
+
+        ParseExecutableAndArgs(expanded, out var exe, out var args);
+
+        // Check for cancellation before file system operations
+        cancellationToken.ThrowIfCancellationRequested();
+
+        // Reset the path resolution flag
+        var couldResolvePath = false;
+
+        var exeExists = false;
+        var fullExePath = string.Empty;
+        var pathIsDir = false;
+
+        try
+        {
+            // Create a timeout for file system operations (200ms)
+            using var timeoutCts = new CancellationTokenSource(TimeSpan.FromMilliseconds(200));
+            using var combinedCts = CancellationTokenSource.CreateLinkedTokenSource(cancellationToken, timeoutCts.Token);
+            var timeoutToken = combinedCts.Token;
+
+            // Use Task.Run with timeout - this will actually timeout even if the sync operations don't respond to cancellation
+            var pathResolutionTask = Task.Run(
+                () =>
+            {
+                // Don't check cancellation token here - let the Task timeout handle it
+                exeExists = ShellListPageHelpers.FileExistInPath(exe, out fullExePath);
+                pathIsDir = Directory.Exists(expanded);
+                couldResolvePath = true;
+            },
+                CancellationToken.None); // Use None here since we're handling timeout differently
+
+            // Wait for either completion or timeout
+            await pathResolutionTask.WaitAsync(timeoutToken);
+        }
+        catch (OperationCanceledException) when (cancellationToken.IsCancellationRequested)
+        {
+            // Main cancellation token was cancelled, re-throw
+            throw;
+        }
+        catch (TimeoutException)
+        {
+            // Timeout occurred
+            couldResolvePath = false;
+        }
+        catch (OperationCanceledException)
+        {
+            // Timeout occurred (from WaitAsync)
+            couldResolvePath = false;
+        }
+        catch (Exception)
+        {
+            // Handle any other exceptions that might bubble up
+            couldResolvePath = false;
+        }
+
+        cancellationToken.ThrowIfCancellationRequested();
+
+        _pathItems.Clear();
+
+        // We want to show path items:
+        // * If there's no args, AND (the path doesn't exist OR the path is a dir)
+        if (string.IsNullOrEmpty(args)
+            && (!exeExists || pathIsDir)
+            && couldResolvePath)
+        {
+            await CreatePathItemsAsync(expanded, searchText, cancellationToken);
+        }
+
+        // Check for cancellation before creating exe items
+        cancellationToken.ThrowIfCancellationRequested();
+
+        if (couldResolvePath && exeExists)
+        {
+            CreateAndAddExeItems(exe, args, fullExePath);
+        }
+        else
+        {
+            _exeItem = null;
+        }
+
+        // Only create the URI item if we didn't make a file or exe item for it.
+        if (!exeExists && !pathIsDir)
+        {
+            CreateUriItems(searchText);
+        }
+        else
+        {
+            _uriItem = null;
+        }
+
+        // Final cancellation check
+        cancellationToken.ThrowIfCancellationRequested();
+    }
+
+    private static ListItem PathToListItem(string path, string originalPath, string args = "")
+    {
+        var pathItem = new PathListItem(path, originalPath);
+
+        // Is this path an executable? If so, then make a RunExeItem
+        if (IsExecutable(path))
+        {
+            var exeItem = new RunExeItem(Path.GetFileName(path), args, path);
+
+            exeItem.MoreCommands = [
+            .. exeItem.MoreCommands,
+            .. pathItem.MoreCommands];
+            return exeItem;
+        }
+
+        return pathItem;
+    }
+
+    public override IListItem[] GetItems()
+    {
+        var filteredTopLevel = ListHelpers.FilterList(_topLevelItems, SearchText);
+        List<ListItem> uriItems = _uriItem != null ? [_uriItem] : [];
+        List<ListItem> exeItems = _exeItem != null ? [_exeItem] : [];
+        return
+            exeItems
+            .Concat(filteredTopLevel)
+            .Concat(_historyItems)
+            .Concat(_pathItems)
+            .Concat(uriItems)
+            .ToArray();
+    }
+
+    internal static RunExeItem CreateExeItem(string exe, string args, string fullExePath)
+    {
+        // PathToListItem will return a RunExeItem if it can find a executable.
+        // It will ALSO add the file search commands to the RunExeItem.
+        return PathToListItem(fullExePath, exe, args) as RunExeItem ??
+               new RunExeItem(exe, args, fullExePath);
+    }
+
+    private void CreateAndAddExeItems(string exe, string args, string fullExePath)
+    {
+        // If we already have an exe item, and the exe is the same, we can just update it
+        if (_exeItem != null && _exeItem.FullExePath.Equals(fullExePath, StringComparison.OrdinalIgnoreCase))
+        {
+            _exeItem.UpdateArgs(args);
+        }
+        else
+        {
+            _exeItem = CreateExeItem(exe, args, fullExePath);
+        }
+    }
+
+    private static bool IsExecutable(string path)
+    {
+        // Is this path an executable?
+        // check all the extensions in PATHEXT
+        var extensions = Environment.GetEnvironmentVariable("PATHEXT")?.Split(';') ?? Array.Empty<string>();
+        return extensions.Any(ext => string.Equals(Path.GetExtension(path), ext, StringComparison.OrdinalIgnoreCase));
+    }
+
+    private async Task CreatePathItemsAsync(string searchPath, string originalPath, CancellationToken cancellationToken)
+    {
+        var directoryPath = string.Empty;
+        var searchPattern = string.Empty;
+
+        var startsWithQuote = searchPath.Length > 0 && searchPath[0] == '"';
+        var endsWithQuote = searchPath.Last() == '"';
+        var trimmed = (startsWithQuote && endsWithQuote) ? searchPath.Substring(1, searchPath.Length - 2) : searchPath;
+        var isDriveRoot = trimmed.Length == 2 && trimmed[1] == ':';
+
+        // we should also handle just drive roots, ala c:\ or d:\
+        // we need to handle this case first, because "C:" does exist, but we need to append the "\" in that case
+        if (isDriveRoot)
+        {
+            directoryPath = trimmed + "\\";
+            searchPattern = $"*";
+        }
+
+        // Easiest case: text is literally already a full directory
+        else if (Directory.Exists(trimmed))
+        {
+            directoryPath = trimmed;
+            searchPattern = $"*";
+        }
+
+        // Check if the search text is a valid path
+        else if (Path.IsPathRooted(trimmed) && Path.GetDirectoryName(trimmed) is string directoryName)
+        {
+            directoryPath = directoryName;
+            searchPattern = $"{Path.GetFileName(trimmed)}*";
+        }
+
+        // Check if the search text is a valid UNC path
+        else if (trimmed.StartsWith(@"\\", System.StringComparison.CurrentCultureIgnoreCase) &&
+                 trimmed.Contains(@"\\"))
+        {
+            directoryPath = trimmed;
+            searchPattern = $"*";
+        }
+
+        // Check for cancellation before directory operations
+        cancellationToken.ThrowIfCancellationRequested();
+
+        var dirExists = Directory.Exists(directoryPath);
+
+        // searchPath is fully expanded, and originalPath is not. We might get:
+        // * original: X%Y%Z\partial
+        // * search: X_foo_Z\partial
+        // and we want the result `X_foo_Z\partialOne` to use the suggestion `X%Y%Z\partialOne`
+        //
+        // To do this:
+        // * Get the directoryPath
+        // * trim that out of the beginning of searchPath -> searchPathTrailer
+        // * everything left from searchPath? remove searchPathTrailer from the end of originalPath
+        // that gets us the expanded original dir
+
+        // Check if the directory exists
+        if (dirExists)
+        {
+            // Check for cancellation before file system enumeration
+            cancellationToken.ThrowIfCancellationRequested();
+
+            // Get all the files in the directory that start with the search text
+            // Run this on a background thread to avoid blocking
+            var files = await Task.Run(() => Directory.GetFileSystemEntries(directoryPath, searchPattern), cancellationToken);
+
+            // Check for cancellation after file enumeration
+            cancellationToken.ThrowIfCancellationRequested();
+
+            var searchPathTrailer = trimmed.Remove(0, Math.Min(directoryPath.Length, trimmed.Length));
+            var originalBeginning = originalPath.Remove(originalPath.Length - searchPathTrailer.Length);
+            if (isDriveRoot)
+            {
+                originalBeginning = string.Concat(originalBeginning, '\\');
+            }
+
+            // Create a list of commands for each file
+            var commands = files.Select(f => PathToListItem(f, originalBeginning)).ToList();
+
+            // Final cancellation check before updating results
+            cancellationToken.ThrowIfCancellationRequested();
+
+            // Add the commands to the list
+            _pathItems = commands;
+        }
+        else
+        {
+            _pathItems.Clear();
+        }
+    }
+
+    internal static void ParseExecutableAndArgs(string input, out string executable, out string arguments)
+    {
+        input = input.Trim();
+        executable = string.Empty;
+        arguments = string.Empty;
+
+        if (string.IsNullOrEmpty(input))
+        {
+            return;
+        }
+
+        if (input.StartsWith("\"", System.StringComparison.InvariantCultureIgnoreCase))
+        {
+            // Find the closing quote
+            var closingQuoteIndex = input.IndexOf('\"', 1);
+            if (closingQuoteIndex > 0)
+            {
+                executable = input.Substring(1, closingQuoteIndex - 1);
+                if (closingQuoteIndex + 1 < input.Length)
+                {
+                    arguments = input.Substring(closingQuoteIndex + 1).TrimStart();
+                }
+            }
+        }
+        else
+        {
+            // Executable ends at first space
+            var firstSpaceIndex = input.IndexOf(' ');
+            if (firstSpaceIndex > 0)
+            {
+                executable = input.Substring(0, firstSpaceIndex);
+                arguments = input[(firstSpaceIndex + 1)..].TrimStart();
+            }
+            else
+            {
+                executable = input;
+            }
+        }
+    }
+
+    internal void CreateUriItems(string searchText)
+    {
+        if (!System.Uri.TryCreate(searchText, UriKind.Absolute, out var uri))
+        {
+            _uriItem = null;
+            return;
+        }
+
+        var command = new OpenUrlCommand(searchText) { Result = CommandResult.Dismiss() };
+        _uriItem = new ListItem(command)
+        {
+            Title = searchText,
+        };
+    }
+
+    public void Dispose()
+    {
+        _cancellationTokenSource?.Cancel();
+        _cancellationTokenSource?.Dispose();
+    }
 }

src/modules/cmdpal/ext/Microsoft.CmdPal.Ext.Shell/PathListItem.cs

@@ -0,0 +1,68 @@
+// 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 Microsoft.CommandPalette.Extensions;
+using Microsoft.CommandPalette.Extensions.Toolkit;
+
+namespace Microsoft.CmdPal.Ext.Shell;
+
+internal sealed partial class PathListItem : ListItem
+{
+    private readonly Lazy<IconInfo> _icon;
+    private readonly bool _isDirectory;
+
+    public override IIconInfo? Icon { get => _icon.Value; set => base.Icon = value; }
+
+    public PathListItem(string path, string originalDir)
+        : base(new OpenUrlCommand(path))
+    {
+        var fileName = Path.GetFileName(path);
+        _isDirectory = Directory.Exists(path);
+        if (_isDirectory)
+        {
+            path = path + "\\";
+            fileName = fileName + "\\";
+        }
+
+        Title = fileName;
+        Subtitle = path;
+
+        // NOTE ME:
+        // If there are spaces on originalDir, trim them off, BEFORE combining originalDir and fileName.
+        // THEN add quotes at the end
+
+        // Trim off leading & trailing quote, if there is one
+        var trimmed = originalDir.Trim('"');
+        var originalPath = Path.Combine(trimmed, fileName);
+        var suggestion = originalPath;
+        var hasSpace = originalPath.Contains(' ');
+        if (hasSpace)
+        {
+            // wrap it in quotes
+            suggestion = string.Concat("\"", suggestion, "\"");
+        }
+
+        TextToSuggest = suggestion;
+        MoreCommands = [
+            new CommandContextItem(new CopyTextCommand(path) { Name = Properties.Resources.copy_path_command_name }) { }
+        ];
+
+        // MoreCommands = [
+        //    new CommandContextItem(new OpenWithCommand(indexerItem)),
+        //    new CommandContextItem(new ShowFileInFolderCommand(indexerItem.FullPath) { Name = Resources.Indexer_Command_ShowInFolder }),
+        //    new CommandContextItem(new CopyPathCommand(indexerItem)),
+        //    new CommandContextItem(new OpenInConsoleCommand(indexerItem)),
+        //    new CommandContextItem(new OpenPropertiesCommand(indexerItem)),
+        // ];
+        _icon = new Lazy<IconInfo>(() =>
+        {
+            var iconStream = ThumbnailHelper.GetThumbnail(path).Result;
+            var icon = iconStream != null ? IconInfo.FromStream(iconStream) :
+             _isDirectory ? Icons.FolderIcon : Icons.RunV2Icon;
+            return icon;
+        });
+    }
+}

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

@@ -132,6 +132,15 @@ namespace Microsoft.CmdPal.Ext.Shell.Properties {
             }
         }
         
+        /// <summary>
+        ///   Looks up a localized string similar to Copy path.
+        /// </summary>
+        public static string copy_path_command_name {
+            get {
+                return ResourceManager.GetString("copy_path_command_name", resourceCulture);
+            }
+        }
+        
         /// <summary>
         ///   Looks up a localized string similar to Find and run the executable file.
         /// </summary>

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

@@ -190,4 +190,7 @@
   <data name="shell_command_display_title" xml:space="preserve">
     <value>Run commands</value>
   </data>
+  <data name="copy_path_command_name" xml:space="preserve">
+    <value>Copy path</value>
+  </data>
 </root>

src/modules/cmdpal/ext/Microsoft.CmdPal.Ext.Shell/ShellCommandsProvider.cs

@@ -13,6 +13,7 @@ namespace Microsoft.CmdPal.Ext.Shell;
 public partial class ShellCommandsProvider : CommandProvider
 {
     private readonly CommandItem _shellPageItem;
+
     private readonly SettingsManager _settingsManager = new();
     private readonly FallbackCommandItem _fallbackItem;
 
@@ -39,4 +40,6 @@ public partial class ShellCommandsProvider : CommandProvider
     public override ICommandItem[] TopLevelCommands() => [_shellPageItem];
 
     public override IFallbackCommandItem[]? FallbackCommands() => [_fallbackItem];
+
+    public static bool SuppressFileFallbackIf(string query) => FallbackExecuteItem.SuppressFileFallbackIf(query);
 }

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

@@ -33,4 +33,9 @@
       <CustomToolNamespace>Microsoft.CmdPal.Ext.System</CustomToolNamespace>
     </EmbeddedResource>
   </ItemGroup>
+  <ItemGroup>
+    <AssemblyAttribute Include="System.Runtime.CompilerServices.InternalsVisibleTo">
+      <_Parameter1>Microsoft.CmdPal.Ext.System.UnitTests</_Parameter1>
+    </AssemblyAttribute>
+  </ItemGroup>
 </Project>

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

@@ -17,13 +17,16 @@ internal sealed partial class FallbackTimeDateItem : FallbackCommandItem
 {
     private readonly HashSet<string> _validOptions;
     private SettingsManager _settingsManager;
+    private DateTime? _timestamp;
 
-    public FallbackTimeDateItem(SettingsManager settings)
+    public FallbackTimeDateItem(SettingsManager settings, DateTime? timestamp = null)
          : base(new NoOpCommand(), Resources.Microsoft_plugin_timedate_fallback_display_title)
     {
         Title = string.Empty;
         Subtitle = string.Empty;
         _settingsManager = settings;
+        _timestamp = timestamp;
+
         _validOptions = new(StringComparer.OrdinalIgnoreCase)
         {
             Resources.ResourceManager.GetString("Microsoft_plugin_timedate_SearchTagDate", CultureInfo.CurrentCulture),
@@ -49,7 +52,7 @@ internal sealed partial class FallbackTimeDateItem : FallbackCommandItem
             return;
         }
 
-        var availableResults = AvailableResultsList.GetList(false, _settingsManager);
+        var availableResults = AvailableResultsList.GetList(false, _settingsManager, timestamp: _timestamp);
         ListItem result = null;
         var maxScore = 0;
 

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

@@ -298,6 +298,7 @@ internal static class TimeAndDateHelper
         }
         else
         {
+            inputParsingErrorMsg = Resources.Microsoft_plugin_timedate_InvalidInput_ErrorMessageTitle;
             timestamp = new DateTime(1, 1, 1, 1, 1, 1);
             Logger.LogWarning($"Failed to parse input: '{input}'. Format not recognized.");
             return false;

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

@@ -11,6 +11,12 @@
     <ProjectPriFileName>Microsoft.CmdPal.Ext.TimeDate.pri</ProjectPriFileName>
   </PropertyGroup>
 
+  <ItemGroup>
+    <AssemblyAttribute Include="System.Runtime.CompilerServices.InternalsVisibleTo">
+      <_Parameter1>Microsoft.CmdPal.Ext.TimeDate.UnitTests</_Parameter1>
+    </AssemblyAttribute>
+  </ItemGroup>
+
   <ItemGroup>
     <EmbeddedResource Update="Properties\Resources.resx">
       <LastGenOutput>Resources.Designer.cs</LastGenOutput>

src/modules/cmdpal/ext/Microsoft.CmdPal.Ext.WebSearch/FallbackExecuteSearchItem.cs

@@ -15,21 +15,26 @@ internal sealed partial class FallbackExecuteSearchItem : FallbackCommandItem
 {
     private readonly SearchWebCommand _executeItem;
     private static readonly CompositeFormat PluginOpen = System.Text.CompositeFormat.Parse(Properties.Resources.plugin_open);
+    private static readonly CompositeFormat SubtitleText = System.Text.CompositeFormat.Parse(Properties.Resources.web_search_fallback_subtitle);
+    private string _title;
 
     public FallbackExecuteSearchItem(SettingsManager settings)
         : base(new SearchWebCommand(string.Empty, settings) { Id = "com.microsoft.websearch.fallback" }, Resources.command_item_title)
     {
         _executeItem = (SearchWebCommand)this.Command!;
         Title = string.Empty;
+        Subtitle = string.Empty;
         _executeItem.Name = string.Empty;
-        Subtitle = string.Format(CultureInfo.CurrentCulture, PluginOpen, BrowserInfo.Name ?? BrowserInfo.MSEdgeName);
+        _title = string.Format(CultureInfo.CurrentCulture, PluginOpen, BrowserInfo.Name ?? BrowserInfo.MSEdgeName);
         Icon = Icons.WebSearch;
     }
 
     public override void UpdateQuery(string query)
     {
         _executeItem.Arguments = query;
-        _executeItem.Name = string.IsNullOrEmpty(query) ? string.Empty : Properties.Resources.open_in_default_browser;
-        Title = query;
+        var isEmpty = string.IsNullOrEmpty(query);
+        _executeItem.Name = isEmpty ? string.Empty : Properties.Resources.open_in_default_browser;
+        Title = isEmpty ? string.Empty : _title;
+        Subtitle = string.Format(CultureInfo.CurrentCulture, SubtitleText, query);
     }
 }

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

@@ -248,5 +248,14 @@ namespace Microsoft.CmdPal.Ext.WebSearch.Properties {
                 return ResourceManager.GetString("settings_page_name", resourceCulture);
             }
         }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to Search for &quot;{0}&quot;.
+        /// </summary>
+        public static string web_search_fallback_subtitle {
+            get {
+                return ResourceManager.GetString("web_search_fallback_subtitle", resourceCulture);
+            }
+        }
     }
 }

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

@@ -178,6 +178,9 @@
   <data name="settings_page_name" xml:space="preserve">
     <value>Settings</value>
   </data>
+  <data name="web_search_fallback_subtitle" xml:space="preserve">
+    <value>Search for "{0}"</value>
+  </data>
   <data name="open_url_fallback_title" xml:space="preserve">
     <value>Open URL</value>
   </data>

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

@@ -46,4 +46,9 @@
       <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
     </None>
   </ItemGroup>
+  <ItemGroup>
+    <AssemblyAttribute Include="System.Runtime.CompilerServices.InternalsVisibleTo">
+      <_Parameter1>Microsoft.CmdPal.Ext.WindowWalker.UnitTests</_Parameter1>
+    </AssemblyAttribute>
+  </ItemGroup>
 </Project>

src/modules/peek/Peek.UITests/Peek.UITests.csproj

@@ -15,6 +15,27 @@
     <PackageReference Include="MSTest" />
     <ProjectReference Include="..\..\..\common\UITestAutomation\UITestAutomation.csproj" />
   </ItemGroup>
+
+  <ItemGroup>
+	<EmbeddedResource Include="Baseline\PeekFilePreviewTests_TestSingleFilePreview_2_arm64.png" />
+	<EmbeddedResource Include="Baseline\PeekFilePreviewTests_TestSingleFilePreview_4_arm64.png" />
+	<EmbeddedResource Include="Baseline\PeekFilePreviewTests_TestSingleFilePreview_5_arm64.png" />
+	<EmbeddedResource Include="Baseline\PeekFilePreviewTests_TestSingleFilePreview_6_arm64.png" />
+	<EmbeddedResource Include="Baseline\PeekFilePreviewTests_TestSingleFilePreview_7_arm64.png" />
+	<EmbeddedResource Include="Baseline\PeekFilePreviewTests_TestSingleFilePreview_8_arm64.png" />
+	<EmbeddedResource Include="Baseline\PeekFilePreviewTests_TestSingleFilePreview_2_x64Win11.png" />
+	<EmbeddedResource Include="Baseline\PeekFilePreviewTests_TestSingleFilePreview_4_x64Win11.png" />
+	<EmbeddedResource Include="Baseline\PeekFilePreviewTests_TestSingleFilePreview_5_x64Win11.png" />
+	<EmbeddedResource Include="Baseline\PeekFilePreviewTests_TestSingleFilePreview_6_x64Win11.png" />
+	<EmbeddedResource Include="Baseline\PeekFilePreviewTests_TestSingleFilePreview_7_x64Win11.png" />
+	<EmbeddedResource Include="Baseline\PeekFilePreviewTests_TestSingleFilePreview_8_x64Win11.png" />
+	<EmbeddedResource Include="Baseline\PeekFilePreviewTests_TestSingleFilePreview_2_x64Win10.png" />
+	<EmbeddedResource Include="Baseline\PeekFilePreviewTests_TestSingleFilePreview_4_x64Win10.png" />
+	<EmbeddedResource Include="Baseline\PeekFilePreviewTests_TestSingleFilePreview_5_x64Win10.png" />
+	<EmbeddedResource Include="Baseline\PeekFilePreviewTests_TestSingleFilePreview_6_x64Win10.png" />
+	<EmbeddedResource Include="Baseline\PeekFilePreviewTests_TestSingleFilePreview_7_x64Win10.png" />
+	<EmbeddedResource Include="Baseline\PeekFilePreviewTests_TestSingleFilePreview_8_x64Win10.png" />
+  </ItemGroup>
   <ItemGroup>
     <Content Include="TestAssets\**\*">
         <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>

src/modules/peek/Peek.UITests/PeekFilePreviewTests.cs

@@ -70,14 +70,15 @@ public class PeekFilePreviewTests : UITestBase
 
     /// <summary>
     /// Test PDF document preview
+    /// ToDo: need to open settings to enable PDF preview in Peek
     /// </summary>
-    [TestMethod("Peek.FilePreview.PDFDocument")]
-    [TestCategory("Preview files")]
-    public void PeekPDFDocumentPreview()
-    {
-        string pdfPath = Path.GetFullPath(@".\TestAssets\3.pdf");
-        TestSingleFilePreview(pdfPath, "3", 10000);
-    }
+    // [TestMethod("Peek.FilePreview.PDFDocument")]
+    // [TestCategory("Preview files")]
+    // public void PeekPDFDocumentPreview()
+    // {
+    //    string pdfPath = Path.GetFullPath(@".\TestAssets\3.pdf");
+    //    TestSingleFilePreview(pdfPath, "3", 10000);
+    // }
 
     /// <summary>
     /// Test QOI image preview
@@ -704,7 +705,7 @@ public class PeekFilePreviewTests : UITestBase
     /// </summary>
     /// <param name="filePath">Full path to the file to test</param>
     /// <param name="expectedFileName">Expected file name for visual comparison</param>
-    private void TestSingleFilePreview(string filePath, string expectedFileName, int? delayMs = null)
+    private void TestSingleFilePreview(string filePath, string expectedFileName, int? delayMs = 5000)
     {
         Element? previewWindow = null;
 

tools/build/build-installer.ps1

@@ -4,46 +4,74 @@ Build and package PowerToys (CmdPal and installer) for a specific platform and c
 
 .DESCRIPTION
 This script automates the end-to-end build and packaging process for PowerToys, including:
-- Restoring and building all necessary solutions (CmdPal, BugReportTool, StylesReportTool, etc.)
+- Restoring and building all necessary solutions (CmdPal, BugReportTool, etc.)
 - Cleaning up old output
 - Signing generated .msix packages
 - Building the WiX-based MSI and bootstrapper installers
 
 It is designed to work in local development.
+The cert used to sign the packages is generated by 
 
 .PARAMETER Platform
-Specifies the target platform for the build (e.g., 'arm64', 'x64'). Default is 'arm64'.
+Specifies the target platform for the build (e.g., 'arm64', 'x64'). Default is 'x64'.
 
 .PARAMETER Configuration
 Specifies the build configuration (e.g., 'Debug', 'Release'). Default is 'Release'.
 
+.PARAMETER PerUser
+Specifies whether to build a per-user installer (true) or machine-wide installer (false). Default is true (per-user).
+
 .EXAMPLE
 .\build-installer.ps1
 Runs the installer build pipeline for ARM64 Release (default).
 
 .EXAMPLE
 .\build-installer.ps1 -Platform x64 -Configuration Release
-Runs the pipeline for x64 Debug.
+Runs the pipeline for x64 Release.
+
+.EXAMPLE
+.\build-installer.ps1 -Platform x64 -Configuration Release -PerUser false
+Runs the pipeline for x64 Release with machine-wide installer.
 
 .NOTES
-- Requires MSBuild, WiX Toolset, and Git to be installed and accessible from your environment.
 - Make sure to run this script from a Developer PowerShell (e.g., VS2022 Developer PowerShell).
 - Generated MSIX files will be signed using cert-sign-package.ps1.
 - This script will clean previous outputs under the build directories and installer directory (except *.exe files).
 - First time run need admin permission to trust the certificate.
-- The built installer will be placed under: installer/PowerToysSetup/[Platform]/[Configuration]/UserSetup 
+- The built installer will be placed under: installer/PowerToysSetup/[Platform]/[Configuration]/User[Machine]Setup 
   relative to the solution root directory.
-- The installer can't be run right after the build, I need to copy it to another file before it can be run.
+- To run the full installation in other machines, call "./cert-management.ps1" to export the cert used to sign the packages.
+  And trust the cert in the target machine.
 #>
 
-
 param (
-    [string]$Platform = 'arm64',
-    [string]$Configuration = 'Release'
+    [string]$Platform = 'x64',
+    [string]$Configuration = 'Release',
+    [string]$PerUser = 'true'
 )
 
-$repoRoot = Resolve-Path "$PSScriptRoot\..\.."
-Set-Location $repoRoot
+# Find the PowerToys repository root automatically
+$scriptDir = Split-Path -Parent $MyInvocation.MyCommand.Definition
+$repoRoot = $scriptDir
+
+# Navigate up from the script location to find the repo root
+# Script is typically in tools\build, so go up two levels
+while ($repoRoot -and -not (Test-Path (Join-Path $repoRoot "PowerToys.sln"))) {
+    $parentDir = Split-Path -Parent $repoRoot
+    if ($parentDir -eq $repoRoot) {
+        # Reached the root of the drive, PowerToys.sln not found
+        Write-Error "Could not find PowerToys repository root. Make sure this script is in the PowerToys repository."
+        exit 1
+    }
+    $repoRoot = $parentDir
+}
+
+if (-not $repoRoot -or -not (Test-Path (Join-Path $repoRoot "PowerToys.sln"))) {
+    Write-Error "Could not locate PowerToys.sln. Please ensure this script is run from within the PowerToys repository."
+    exit 1
+}
+
+Write-Host "PowerToys repository root detected: $repoRoot"
 
 function RunMSBuild {
     param (
@@ -53,8 +81,9 @@ function RunMSBuild {
 
     $base = @(
         $Solution
-        "/p:Platform=`"$Platform`""
+        "/p:Platform=$Platform"
         "/p:Configuration=$Configuration"
+        "/p:CIBuild=true"
         '/verbosity:normal'
         '/clp:Summary;PerformanceSummary;ErrorsOnly;WarningsOnly'
         '/nologo'
@@ -62,13 +91,18 @@ function RunMSBuild {
 
     $cmd = $base + ($ExtraArgs -split ' ')
     Write-Host ("[MSBUILD] {0} {1}" -f $Solution, ($cmd -join ' '))
-    & msbuild.exe @cmd
-
-    if ($LASTEXITCODE -ne 0) {
-        Write-Error ("Build failed: {0}  {1}" -f $Solution, $ExtraArgs)
-        exit $LASTEXITCODE
+    
+    # Run MSBuild from the repository root directory
+    Push-Location $repoRoot
+    try {
+        & msbuild.exe @cmd
+        if ($LASTEXITCODE -ne 0) {
+            Write-Error ("Build failed: {0}  {1}" -f $Solution, $ExtraArgs)
+            exit $LASTEXITCODE
+        }
+    } finally {
+        Pop-Location
     }
-
 }
 
 function RestoreThenBuild {
@@ -81,9 +115,9 @@ function RestoreThenBuild {
 }
 
 Write-Host ("Make sure wix is installed and available")
-& "$PSScriptRoot\ensure-wix.ps1"
+& (Join-Path $PSScriptRoot "ensure-wix.ps1")
 
-Write-Host ("[PIPELINE] Start | Platform={0} Configuration={1}" -f $Platform, $Configuration)
+Write-Host ("[PIPELINE] Start | Platform={0} Configuration={1} PerUser={2}" -f $Platform, $Configuration, $PerUser)
 Write-Host ''
 
 $cmdpalOutputPath = Join-Path $repoRoot "$Platform\$Configuration\WinUI3Apps\CmdPal"
@@ -93,7 +127,7 @@ if (Test-Path $cmdpalOutputPath) {
     Remove-Item $cmdpalOutputPath -Recurse -Force -ErrorAction Ignore
 }
 
-RestoreThenBuild '.\PowerToys.sln'
+RestoreThenBuild 'PowerToys.sln'
 
 $msixSearchRoot = Join-Path $repoRoot "$Platform\$Configuration"
 $msixFiles = Get-ChildItem -Path $msixSearchRoot -Recurse -Filter *.msix |
@@ -101,22 +135,27 @@ Select-Object -ExpandProperty FullName
 
 if ($msixFiles.Count) {
     Write-Host ("[SIGN] .msix file(s): {0}" -f ($msixFiles -join '; '))
-    & "$PSScriptRoot\cert-sign-package.ps1" -TargetPaths $msixFiles
+    & (Join-Path $PSScriptRoot "cert-sign-package.ps1") -TargetPaths $msixFiles
 }
 else {
     Write-Warning "[SIGN] No .msix files found in $msixSearchRoot"
 }
 
-RestoreThenBuild '.\tools\BugReportTool\BugReportTool.sln'
-RestoreThenBuild '.\tools\StylesReportTool\StylesReportTool.sln'
+RestoreThenBuild 'tools\BugReportTool\BugReportTool.sln'
+RestoreThenBuild 'tools\StylesReportTool\StylesReportTool.sln'
 
 Write-Host '[CLEAN] installer (keep *.exe)'
-git clean -xfd -e '*.exe' -- .\installer\ | Out-Null
+Push-Location $repoRoot
+try {
+    git clean -xfd -e '*.exe' -- .\installer\ | Out-Null
+} finally {
+    Pop-Location
+}
 
-RunMSBuild  '.\installer\PowerToysSetup.sln' '/t:restore /p:RestorePackagesConfig=true'
+RunMSBuild 'installer\PowerToysSetup.sln' '/t:restore /p:RestorePackagesConfig=true'
 
-RunMSBuild '.\installer\PowerToysSetup.sln' '/m /t:PowerToysInstaller /p:PerUser=true'
+RunMSBuild 'installer\PowerToysSetup.sln' "/m /t:PowerToysInstaller /p:PerUser=$PerUser"
 
-RunMSBuild '.\installer\PowerToysSetup.sln' '/m /t:PowerToysBootstrapper /p:PerUser=true'
+RunMSBuild 'installer\PowerToysSetup.sln' "/m /t:PowerToysBootstrapper /p:PerUser=$PerUser"
 
-Write-Host '[PIPELINE] Completed'
+Write-Host '[PIPELINE] Completed'

tools/build/cert-management.ps1

@@ -152,4 +152,37 @@ function Export-CertificateFiles {
     if (-not $CerPath -and -not $PfxPath) {
         Write-Warning "No output path specified. Nothing was exported."
     }
+}
+
+# Main execution when script is run directly
+if ($MyInvocation.InvocationName -ne '.') {
+    Write-Host "=== PowerToys Certificate Management ===" -ForegroundColor Green
+    Write-Host ""
+    
+    # Ensure certificate exists and is trusted
+    Write-Host "Checking for existing certificate or creating new one..." -ForegroundColor Yellow
+    $cert = EnsureCertificate
+    
+    if ($cert) {
+        # Export the certificate to a .cer file
+        $exportPath = Join-Path (Get-Location) "PowerToys-CodeSigning.cer"
+        Write-Host ""
+        Write-Host "Exporting certificate..." -ForegroundColor Yellow
+        Export-CertificateFiles -Certificate $cert -CerPath $exportPath
+        
+        Write-Host ""
+        Write-Host "=== IMPORTANT NOTES ===" -ForegroundColor Red
+        Write-Host "The certificate has been exported to: $exportPath" -ForegroundColor White
+        Write-Host ""
+        Write-Host "To use this certificate for code signing, you need to:" -ForegroundColor Yellow
+        Write-Host "1. Import this certificate into 'Trusted People' store" -ForegroundColor White
+        Write-Host "2. Import this certificate into 'Trusted Root Certification Authorities' store" -ForegroundColor White
+        Write-Host "Certificate Details:" -ForegroundColor Green
+        Write-Host "Subject: $($cert.Subject)" -ForegroundColor White
+        Write-Host "Thumbprint: $($cert.Thumbprint)" -ForegroundColor White
+        Write-Host "Valid Until: $($cert.NotAfter)" -ForegroundColor White
+    } else {
+        Write-Error "Failed to create or find certificate. Please check the error messages above."
+        exit 1
+    }
 }