restore original codes

<!-- Enter a brief description/summary of your PR here. What does it
fix/what does it change/how was it tested (even manually, if necessary)?
-->
## Summary of the Pull Request
Root cause: Workspaces uses DPI-unaware coordinates (via
GetDpiUnawareScreens()
which runs in a temporary DPI-unaware thread) to store/match window
positions
across different DPI settings. However, WorkspacesEditor itself uses
PerMonitorV2
DPI awareness for UI clarity. When assigning these DPI-unaware
coordinates directly
to WPF window properties, WPF automatically scaled them again based on
current DPI,
causing incorrect overlay positioning.

Fix: Use SetWindowPositionDpiUnaware() to bypass WPF's automatic DPI
scaling
by temporarily switching to DPI-unaware context when calling Win32
SetWindowPos.

Fix #45174

<!-- Please review the items on the PR checklist before submitting-->
## PR Checklist

- [ ] Closes: #45174
<!-- - [ ] Closes: #yyy (add separate lines for additional resolved
issues) -->
- [ ] **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
- [ ] **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
Verified in local build vs production build, and the problem fixed in
local build.

.github/actions/spell-check/candidate.patterns

@@ -565,7 +565,7 @@ perl(?:\s+-[a-zA-Z]\w*)+
 regexp?\.MustCompile\((?:`[^`]*`|".*"|'.*')\)
 
 # regex choice
-\(\?:[^)]+\|[^)]+\)
+# \(\?:[^)]+\|[^)]+\)
 
 # proto
 ^\s*(\w+)\s\g{-1} =

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

@@ -101,11 +101,16 @@
 ^doc/devdocs/akaLinks\.md$
 ^NOTICE\.md$
 ^src/common/CalculatorEngineCommon/exprtk\.hpp$
+^src/common/UnitTests-CommonUtils/
 ^src/common/ManagedCommon/ColorFormatHelper\.cs$
 ^src/common/notifications/BackgroundActivatorDLL/cpp\.hint$
 ^src/common/sysinternals/Eula/
+^src/modules/cmdpal/Tests/Microsoft\.CommandPalette\.Extensions\.Toolkit\.UnitTests/FuzzyMatcherComparisonTests.cs$
+^src/modules/cmdpal/Tests/Microsoft\.CommandPalette\.Extensions\.Toolkit\.UnitTests/FuzzyMatcherDiacriticsTests.cs$
 ^src/modules/cmdpal/doc/initial-sdk-spec/list-elements-mock-002\.pdn$
 ^src/modules/cmdpal/ext/SamplePagesExtension/Pages/SampleMarkdownImagesPage\.cs$
+^src/modules/cmdpal/Microsoft\.CmdPal\.UI/Settings/InternalPage\.SampleData\.cs$
+^src/modules/cmdpal/Tests/Microsoft\.CmdPal\.Core\.Common\.UnitTests/.*\.TestData\.cs$
 ^src/modules/colorPicker/ColorPickerUI/Shaders/GridShader\.cso$
 ^src/modules/launcher/Plugins/Microsoft\.PowerToys\.Run\.Plugin\.TimeDate/Properties/
 ^src/modules/MouseUtils/MouseJumpUI/MainForm\.resx$

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

@@ -597,6 +597,7 @@ frm
 FROMTOUCH
 fsanitize
 fsmgmt
+ftps
 fuzzingtesting
 fxf
 FZE
@@ -634,6 +635,7 @@ GMEM
 GNumber
 googleai
 googlegemini
+Gotchas
 gpedit
 gpo
 GPOCA
@@ -891,9 +893,9 @@ Lclean
 Ldone
 Ldr
 LEFTALIGN
+leftclick
 LEFTSCROLLBAR
 LEFTTEXT
-leftclick
 LError
 LEVELID
 LExit
@@ -1022,7 +1024,9 @@ MERGEPAINT
 Metacharacter
 metadatamatters
 Metadatas
+Metacharacter
 metafile
+Metacharacter
 mfc
 Mgmt
 Microwaved
@@ -1069,7 +1073,7 @@ mouseutils
 MOVESIZEEND
 MOVESIZESTART
 MRM
-MRT
+Mrt
 mru
 MSAL
 msc
@@ -1330,7 +1334,7 @@ phwnd
 pici
 pidl
 PIDLIST
-PII
+pii
 pinfo
 pinvoke
 pipename
@@ -1487,7 +1491,9 @@ regfile
 REGISTERCLASSFAILED
 REGISTRYHEADER
 REGISTRYPREVIEWEXT
+registryroot
 regkey
+regroot
 regsvr
 REINSTALLMODE
 releaseblog
@@ -1716,6 +1722,7 @@ srw
 srwlock
 sse
 ssf
+Ssn
 sszzz
 STACKFRAME
 stackoverflow
@@ -1825,6 +1832,7 @@ TEXTBOXNEWLINE
 textextractor
 TEXTINCLUDE
 tfopen
+tgamma
 tgz
 THEMECHANGED
 themeresources
@@ -2166,4 +2174,4 @@ Zoneszonabletester
 Zoomin
 zoomit
 ZOOMITX
-Zorder
+Zorder

.pipelines/v2/oneFuzz.yml

@@ -35,7 +35,9 @@ stages:
             ${{ else }}:
               name: SHINE-OSS-L
             ${{ if eq(parameters.useVSPreview, true) }}:
-              demands: ImageOverride -equals SHINE-VS17-Preview
+              demands: ImageOverride -equals SHINE-VS18-Preview
+            ${{ else }}:
+              demands: ImageOverride -equals SHINE-VS18-Latest
           buildPlatforms:
             - ${{ parameters.platform }}
           buildConfigurations: [Release]

.pipelines/v2/release.yml

@@ -51,7 +51,9 @@ extends:
     pool:
       name: SHINE-INT-S
       ${{ if eq(parameters.useVSPreview, true) }}:
-        demands: ImageOverride -equals SHINE-VS17-Preview
+        demands: ImageOverride -equals SHINE-VS18-Preview
+      ${{ else }}:
+        demands: ImageOverride -equals SHINE-VS18-Latest
       os: windows
     sdl:
       tsa:
@@ -74,7 +76,9 @@ extends:
                 demands:
                   # Our INT agents have a large disk mounted at P:\
                   - ${{ if eq(parameters.useVSPreview, true) }}:
-                    - ImageOverride -equals SHINE-VS17-Preview
+                    - ImageOverride -equals SHINE-VS18-Latest-Preview
+                  - ${{ else }}:
+                    - ImageOverride -equals SHINE-VS18-Latest
                 os: windows
               variables:
                 IsPipeline: 1 # The installer uses this to detect whether it should pick up localizations
@@ -87,6 +91,7 @@ extends:
               official: true
               codeSign: true
               runTests: false
+              buildTests: false
               signingIdentity:
                 serviceName: $(SigningServiceName)
                 appId: $(SigningAppId)

.pipelines/v2/templates/job-build-project.yml

@@ -253,11 +253,12 @@ jobs:
       displayName: Build PowerToys main project
     inputs:
       solution: 'PowerToys.slnx'
-      vsVersion: 17.0
+      vsVersion: 18.0
       msbuildArgs: >-
         -restore -graph
         /p:RestorePackagesConfig=true
         /p:CIBuild=true
+        /p:BuildTests=${{ parameters.buildTests }}
         /bl:$(LogOutputDirectory)\build-0-main.binlog
         ${{ parameters.additionalBuildOptions }}
         $(MSBuildCacheParameters)
@@ -276,7 +277,7 @@ jobs:
     condition: and(succeeded(), eq(variables['BuildPlatform'], 'arm64'))
     inputs:
       solution: PowerToys.slnx
-      vsVersion: 17.0
+      vsVersion: 18.0
       msbuildArgs: >-
         -restore
         /p:Configuration=$(BuildConfiguration)
@@ -338,7 +339,7 @@ jobs:
     displayName: Build BugReportTool
     inputs:
       solution: '**/tools/BugReportTool/BugReportTool.sln'
-      vsVersion: 17.0
+      vsVersion: 18.0
       msbuildArgs: >-
         -restore -graph
         /p:RestorePackagesConfig=true
@@ -359,7 +360,7 @@ jobs:
     displayName: Build StylesReportTool
     inputs:
       solution: '**/tools/StylesReportTool/StylesReportTool.sln'
-      vsVersion: 17.0
+      vsVersion: 18.0
       msbuildArgs: >-
         -restore -graph
         /p:RestorePackagesConfig=true
@@ -381,7 +382,7 @@ jobs:
       displayName: Publish ${{ project }} for Packaging
       inputs:
         solution: ${{ project }}
-        vsVersion: 17.0
+        vsVersion: 18.0
         msbuildArgs: >-
           /target:Publish
           /graph

.pipelines/v2/templates/job-build-ui-tests.yml

@@ -82,7 +82,7 @@ jobs:
       displayName: Build UI Test Projects
       inputs:
         solution: '**/*UITest*.csproj'
-        vsVersion: 17.0
+        vsVersion: 18.0
         msbuildArgs: >-
           -restore
           -graph
@@ -103,7 +103,7 @@ jobs:
         displayName: 'Build UI Test Module: ${{ module }}'
         inputs:
           solution: '**/*${{ module }}*.csproj'
-          vsVersion: 17.0
+          vsVersion: 18.0
           msbuildArgs: >-
             -restore
             -graph

.pipelines/v2/templates/pipeline-ci-build.yml

@@ -49,7 +49,9 @@ stages:
               ${{ else }}:
                 name: SHINE-OSS-L
               ${{ if eq(parameters.useVSPreview, true) }}:
-                demands: ImageOverride -equals SHINE-VS17-Preview
+                demands: ImageOverride -equals SHINE-VS18-Preview
+              ${{ else }}:
+                demands: ImageOverride -equals SHINE-VS18-Latest
             buildPlatforms:
               - ${{ platform }}
             buildConfigurations: [Release]
@@ -57,6 +59,7 @@ stages:
             enableMsBuildCaching: ${{ parameters.enableMsBuildCaching }}
             msBuildCacheIsReadOnly: ${{ parameters.msBuildCacheIsReadOnly }}
             runTests: ${{ parameters.runTests }}
+            buildTests: true
             useVSPreview: ${{ parameters.useVSPreview }}
             useLatestWinAppSDK: ${{ parameters.useLatestWinAppSDK }}
             ${{ if eq(parameters.useLatestWinAppSDK, true) }}:
@@ -76,7 +79,9 @@ stages:
             ${{ else }}:
               name: SHINE-OSS-L
             ${{ if eq(parameters.useVSPreview, true) }}:
-              demands: ImageOverride -equals SHINE-VS17-Preview
+              demands: ImageOverride -equals SHINE-VS18-Preview
+            ${{ else }}:
+              demands: ImageOverride -equals SHINE-VS18-Latest
           buildConfigurations: [Release]
           official: false
           codeSign: false

.pipelines/v2/templates/pipeline-ui-tests-full-build.yml

@@ -29,7 +29,9 @@ stages:
             ${{ else }}:
               name: SHINE-OSS-L
             ${{ if eq(parameters.useVSPreview, true) }}:
-              demands: ImageOverride -equals SHINE-VS17-Preview
+              demands: ImageOverride -equals SHINE-VS18-Preview
+            ${{ else }}:
+              demands: ImageOverride -equals SHINE-VS18-Latest
           buildPlatforms:
             - ${{ parameters.platform }}
           buildConfigurations: [Release]

.pipelines/v2/templates/steps-build-installer-vnext.yml

@@ -36,7 +36,7 @@ steps:
     displayName: Build Shared Support DLLs
     inputs:
       solution: "**/installer/PowerToysSetup.slnx"
-      vsVersion: 17.0
+      vsVersion: 18.0
       msbuildArgs: >-
         /t:PowerToysSetupCustomActionsVNext;SilentFilesInUseBAFunction
         /p:RunBuildEvents=true;RestorePackagesConfig=true;CIBuild=true
@@ -75,7 +75,7 @@ steps:
     displayName: 💻 Build VNext MSI
     inputs:
       solution: "**/installer/PowerToysSetup.slnx"
-      vsVersion: 17.0
+      vsVersion: 18.0
       msbuildArgs: >-
         -restore
         /t:PowerToysInstallerVNext
@@ -92,7 +92,7 @@ steps:
     displayName: 👤 Build VNext MSI
     inputs:
       solution: "**/installer/PowerToysSetup.slnx"
-      vsVersion: 17.0
+      vsVersion: 18.0
       msbuildArgs: >-
         /t:PowerToysInstallerVNext
         /p:RunBuildEvents=false;PerUser=true;BuildProjectReferences=false;CIBuild=true
@@ -143,7 +143,7 @@ steps:
     displayName: 💻 Build VNext Bootstrapper
     inputs:
       solution: "**/installer/PowerToysSetup.slnx"
-      vsVersion: 17.0
+      vsVersion: 18.0
       msbuildArgs: >-
         -restore
         /t:PowerToysBootstrapperVNext
@@ -160,7 +160,7 @@ steps:
     displayName: 👤 Build VNext Bootstrapper
     inputs:
       solution: "**/installer/PowerToysSetup.slnx"
-      vsVersion: 17.0
+      vsVersion: 18.0
       msbuildArgs: >-
         /t:PowerToysBootstrapperVNext
         /p:PerUser=true;BuildProjectReferences=false;CIBuild=true

.pipelines/verifyAndSetLatestVCToolsVersion.ps1

@@ -1,9 +1,16 @@
-$VSInstances = ([xml](& 'C:\Program Files (x86)\Microsoft Visual Studio\Installer\vswhere.exe' -latest -requires Microsoft.VisualStudio.Component.VC.Tools.x86.x64 -include packages -format xml))
+# Build common vswhere base arguments
+$vsWhereBaseArgs = @('-latest', '-requires', 'Microsoft.VisualStudio.Component.VC.Tools.x86.x64')
+if ($env:VCWhereExtraVersionTarget) {
+    # Add version target if specified (e.g., '-version [18.0,19.0)' for VS2026)
+    $vsWhereBaseArgs += $env:VCWhereExtraVersionTarget.Split(' ')
+}
+
+$VSInstances = ([xml](& 'C:\Program Files (x86)\Microsoft Visual Studio\Installer\vswhere.exe' @vsWhereBaseArgs -include packages -format xml))
 $VSPackages = $VSInstances.instances.instance.packages.package
 $LatestVCPackage = ($VSPackages | ? { $_.id -eq "Microsoft.VisualCpp.Tools.Core" })
 $LatestVCToolsVersion = $LatestVCPackage.version;
 
-$VSRoot = (& 'C:\Program Files (x86)\Microsoft Visual Studio\Installer\vswhere.exe' -latest -requires Microsoft.VisualStudio.Component.VC.Tools.x86.x64 -property 'resolvedInstallationPath')
+$VSRoot = (& 'C:\Program Files (x86)\Microsoft Visual Studio\Installer\vswhere.exe' @vsWhereBaseArgs -property 'resolvedInstallationPath')
 $VCToolsRoot = Join-Path $VSRoot "VC\Tools\MSVC"
 
 # We have observed a few instances where the VC tools package version actually
@@ -24,5 +31,12 @@ If ($Null -Eq (Get-Item $PackageVCToolPath -ErrorAction:Ignore)) {
 }
 
 Write-Output "Latest VCToolsVersion: $LatestVCToolsVersion"
-Write-Output "Updating VCToolsVersion environment variable for job"
-Write-Output "##vso[task.setvariable variable=VCToolsVersion]$LatestVCToolsVersion"
+
+# VS2026 (MSVC 14.50+) doesn't need explicit VCToolsVersion - let MSBuild auto-select
+$MajorMinorVersion = [Version]::Parse($LatestVCToolsVersion)
+If ($MajorMinorVersion.Major -eq 14 -and $MajorMinorVersion.Minor -ge 50) {
+    Write-Output "VS2026 detected (MSVC 14.50+). Skipping VCToolsVersion override to allow MSBuild auto-selection."
+} Else {
+    Write-Output "Updating VCToolsVersion environment variable for job"
+    Write-Output "##vso[task.setvariable variable=VCToolsVersion]$LatestVCToolsVersion"
+}

.pipelines/verifyNoticeMdAgainstNugetPackages.ps1

@@ -90,9 +90,15 @@ if ($noticeMatch.Success) {
     $currentNoticePackageList = ""
 }
 
+# Test-only packages that are allowed to be in NOTICE.md but not in the build
+# (e.g., when BuildTests=false, these packages won't appear in the NuGet list)
+$allowedExtraPackages = @(
+	"- Moq"
+)
+
 if (!$noticeFile.Trim().EndsWith($returnList.Trim()))
 {
-	Write-Host -ForegroundColor Red "Notice.md does not match NuGet list."
+	Write-Host -ForegroundColor Yellow "Notice.md does not exactly match NuGet list. Analyzing differences..."
 
 	# Show detailed differences
 	$generatedPackages = $returnList -split "`r`n|`n" | Where-Object { $_.Trim() -ne "" } | Sort-Object
@@ -105,7 +111,7 @@ if (!$noticeFile.Trim().EndsWith($returnList.Trim()))
 	# Find packages in proj file list but not in NOTICE.md
 	$missingFromNotice = $generatedPackages | Where-Object { $noticePackages -notcontains $_ }
 	if ($missingFromNotice.Count -gt 0) {
-		Write-Host -ForegroundColor Red "MissingFromNotice:"
+		Write-Host -ForegroundColor Red "MissingFromNotice (ERROR - these must be added to NOTICE.md):"
 		foreach ($pkg in $missingFromNotice) {
 			Write-Host -ForegroundColor Red "  $pkg"
 		}
@@ -114,10 +120,23 @@ if (!$noticeFile.Trim().EndsWith($returnList.Trim()))
 
 	# Find packages in NOTICE.md but not in proj file list
 	$extraInNotice = $noticePackages | Where-Object { $generatedPackages -notcontains $_ }
-	if ($extraInNotice.Count -gt 0) {
-		Write-Host -ForegroundColor Yellow "ExtraInNotice:"
-		foreach ($pkg in $extraInNotice) {
-			Write-Host -ForegroundColor Yellow "  $pkg"
+	
+	# Filter out allowed extra packages (test-only dependencies)
+	$unexpectedExtra = $extraInNotice | Where-Object { $allowedExtraPackages -notcontains $_ }
+	$allowedExtra = $extraInNotice | Where-Object { $allowedExtraPackages -contains $_ }
+
+	if ($allowedExtra.Count -gt 0) {
+		Write-Host -ForegroundColor Green "ExtraInNotice (OK - allowed test-only packages):"
+		foreach ($pkg in $allowedExtra) {
+			Write-Host -ForegroundColor Green "  $pkg"
+		}
+		Write-Host ""
+	}
+
+	if ($unexpectedExtra.Count -gt 0) {
+		Write-Host -ForegroundColor Red "ExtraInNotice (ERROR - unexpected packages in NOTICE.md):"
+		foreach ($pkg in $unexpectedExtra) {
+			Write-Host -ForegroundColor Red "  $pkg"
 		}
 		Write-Host ""
 	}
@@ -127,10 +146,17 @@ if (!$noticeFile.Trim().EndsWith($returnList.Trim()))
 	Write-Host "  Proj file list has $($generatedPackages.Count) packages"
 	Write-Host "  NOTICE.md has $($noticePackages.Count) packages"
 	Write-Host "  MissingFromNotice: $($missingFromNotice.Count) packages"
-	Write-Host "  ExtraInNotice: $($extraInNotice.Count) packages"
+	Write-Host "  ExtraInNotice (allowed): $($allowedExtra.Count) packages"
+	Write-Host "  ExtraInNotice (unexpected): $($unexpectedExtra.Count) packages"
 	Write-Host ""
 
-	exit 1
+	# Fail if there are missing packages OR unexpected extra packages
+	if ($missingFromNotice.Count -gt 0 -or $unexpectedExtra.Count -gt 0) {
+		Write-Host -ForegroundColor Red "FAILED: NOTICE.md mismatch detected."
+		exit 1
+	} else {
+		Write-Host -ForegroundColor Green "PASSED: NOTICE.md matches (with allowed test-only packages)."
+	}
 }
 
 exit 0

AGENTS.md

@@ -40,7 +40,7 @@ These instruction files are automatically applied when working in their respecti
 
 ### Prerequisites
 
-- Visual Studio 2022 17.4+
+- Visual Studio 2022 17.4+ or Visual Studio 2026
 - Windows 10 1803+ (April 2018 Update or newer)
 - Initialize submodules once: `git submodule update --init --recursive`
 

Cpp.Build.props

@@ -2,6 +2,12 @@
 <Project ToolsVersion="4.0"
   xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
 
+  <!-- Skip building C++ test projects when BuildTests=false -->
+  <PropertyGroup Condition="'$(_IsSkippedTestProject)' == 'true'">
+    <UsePrecompiledHeaders>false</UsePrecompiledHeaders>
+    <RunCodeAnalysis>false</RunCodeAnalysis>
+  </PropertyGroup>
+
   <!-- Project configurations -->
   <ItemGroup Label="ProjectConfigurations">
     <ProjectConfiguration Include="Debug|x64">
@@ -51,7 +57,7 @@
       <PrecompiledHeader Condition="'$(UsePrecompiledHeaders)' != 'false'">Use</PrecompiledHeader>
       <PrecompiledHeaderFile>pch.h</PrecompiledHeaderFile>
       <WarningLevel>Level4</WarningLevel>
-      <DisableSpecificWarnings>4679;5271;%(DisableSpecificWarnings)</DisableSpecificWarnings>
+      <DisableSpecificWarnings>4679;4706;4874;5271;%(DisableSpecificWarnings)</DisableSpecificWarnings>
       <DisableAnalyzeExternal >true</DisableAnalyzeExternal>
       <ExternalWarningLevel>TurnOffAllWarnings</ExternalWarningLevel>
       <ConformanceMode>false</ConformanceMode>
@@ -110,6 +116,7 @@
   <!-- Props that are constant for both Debug and Release configurations -->
   <PropertyGroup Label="Configuration">
     <PlatformToolset>v143</PlatformToolset>
+    <PlatformToolset Condition="'$(VisualStudioVersion)' == '18.0'">v145</PlatformToolset>
     <CharacterSet>Unicode</CharacterSet>
     <DesktopCompatible>true</DesktopCompatible>
     <SpectreMitigation>Spectre</SpectreMitigation>

Directory.Build.props

@@ -19,6 +19,39 @@
     <PlatformTarget>$(Platform)</PlatformTarget>
   </PropertyGroup>
 
+  <!--
+    Completely skip building test projects when BuildTests=false (e.g., Release pipeline).
+    This avoids InternalsVisibleTo/signing issues by not compiling test code at all.
+    Match: projects ending in Test, Tests, UnitTests, UITests, FuzzTests, or in a folder named Tests.
+    Also matches projects starting with UnitTests- (e.g., UnitTests-CommonLib).
+    Also removes all PackageReference/ProjectReference to prevent NuGet restore and dependency builds.
+    Note: Checking both 'false' and 'False' to handle YAML boolean serialization.
+  -->
+  <PropertyGroup Condition="'$(BuildTests)' == 'false' or '$(BuildTests)' == 'False'">
+    <_ProjectName>$(MSBuildProjectName)</_ProjectName>
+    <!-- Match any project ending with "Test" or "Tests" (covers UnitTests, UITests, FuzzTests, etc.) -->
+    <_IsSkippedTestProject Condition="$(_ProjectName.EndsWith('Test'))">true</_IsSkippedTestProject>
+    <_IsSkippedTestProject Condition="$(_ProjectName.EndsWith('Tests'))">true</_IsSkippedTestProject>
+    <!-- Match projects starting with UnitTests- or UITest- prefix -->
+    <_IsSkippedTestProject Condition="$(_ProjectName.StartsWith('UnitTests-'))">true</_IsSkippedTestProject>
+    <_IsSkippedTestProject Condition="$(_ProjectName.StartsWith('UITest-'))">true</_IsSkippedTestProject>
+    <!-- Match projects in a Tests folder -->
+    <_IsSkippedTestProject Condition="$(MSBuildProjectDirectory.Contains('\Tests\'))">true</_IsSkippedTestProject>
+  </PropertyGroup>
+
+  <PropertyGroup Condition="'$(_IsSkippedTestProject)' == 'true'">
+    <EnableDefaultItems>false</EnableDefaultItems>
+    <EnableDefaultCompileItems>false</EnableDefaultCompileItems>
+    <GenerateAssemblyInfo>false</GenerateAssemblyInfo>
+    <GenerateGlobalUsings>false</GenerateGlobalUsings>
+    <ImplicitUsings>disable</ImplicitUsings>
+    <!-- Disable all code analysis for skipped test projects -->
+    <EnableNETAnalyzers>false</EnableNETAnalyzers>
+    <RunAnalyzers>false</RunAnalyzers>
+    <RunAnalyzersDuringBuild>false</RunAnalyzersDuringBuild>
+    <TreatWarningsAsErrors>false</TreatWarningsAsErrors>
+  </PropertyGroup>
+
   <PropertyGroup Condition="'$(MSBuildProjectExtension)' == '.csproj'">
     <Version>$(Version).0</Version>
     <RepositoryUrl>https://github.com/microsoft/PowerToys</RepositoryUrl>
@@ -30,7 +63,9 @@
     <_PropertySheetDisplayName>PowerToys.Root.Props</_PropertySheetDisplayName>
     <ForceImportBeforeCppProps>$(MsbuildThisFileDirectory)\Cpp.Build.props</ForceImportBeforeCppProps>
   </PropertyGroup>
-  <ItemGroup Condition="'$(MSBuildProjectExtension)' == '.csproj'">
+
+
+  <ItemGroup Condition="'$(MSBuildProjectExtension)' == '.csproj' and '$(_IsSkippedTestProject)' != 'true'">
     <PackageReference Include="StyleCop.Analyzers">
       <PrivateAssets>all</PrivateAssets>
       <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>

Directory.Build.targets

@@ -28,4 +28,41 @@
   <PropertyGroup Condition="'$(IgnoreExperimentalWarnings)' == 'true'">
     <NoWarn>$(NoWarn);CS8305;SA1500;CA1852</NoWarn>
   </PropertyGroup>
-</Project>
+
+  <!-- Skipped test projects when BuildTests=false: no-op build and remove references.
+       This must be in targets (not props) so it runs AFTER the project file adds its items. -->
+  <PropertyGroup Condition="'$(_IsSkippedTestProject)' == 'true'">
+    <BuildDependsOn />
+    <CoreBuildDependsOn />
+    <RebuildDependsOn />
+  </PropertyGroup>
+
+  <!-- For C# projects: remove all items -->
+  <ItemGroup Condition="'$(_IsSkippedTestProject)' == 'true' and '$(MSBuildProjectExtension)' == '.csproj'">
+    <PackageReference Remove="@(PackageReference)" />
+    <ProjectReference Remove="@(ProjectReference)" />
+    <Reference Remove="@(Reference)" />
+    <Compile Remove="@(Compile)" />
+    <Content Remove="@(Content)" />
+    <EmbeddedResource Remove="@(EmbeddedResource)" />
+    <None Remove="@(None)" />
+    <Using Remove="@(Using)" />
+    <GlobalUsing Remove="@(GlobalUsing)" />
+  </ItemGroup>
+
+  <!-- For C++ projects (vcxproj): remove all compile/link items to prevent build -->
+  <ItemGroup Condition="'$(_IsSkippedTestProject)' == 'true' and '$(MSBuildProjectExtension)' == '.vcxproj'">
+    <ClCompile Remove="@(ClCompile)" />
+    <ClInclude Remove="@(ClInclude)" />
+    <Link Remove="@(Link)" />
+    <Lib Remove="@(Lib)" />
+    <ProjectReference Remove="@(ProjectReference)" />
+    <None Remove="@(None)" />
+    <ResourceCompile Remove="@(ResourceCompile)" />
+    <Midl Remove="@(Midl)" />
+  </ItemGroup>
+
+  <!-- Note: For C++ skipped test projects, build is effectively skipped by removing all compile items above.
+       We don't define empty Build/Rebuild/Clean targets here because MSBuild Target definitions with Condition
+       on the Target element still override the default targets even when condition is false. -->
+</Project>

PowerToys.slnx

@@ -55,6 +55,7 @@
       <Platform Solution="*|x64" Project="x64" />
     </Project>
     <Project Path="src/common/UnitTests-CommonLib/UnitTests-CommonLib.vcxproj" Id="1a066c63-64b3-45f8-92fe-664e1cce8077" />
+    <Project Path="src/common/UnitTests-CommonUtils/UnitTests-CommonUtils.vcxproj" Id="8b5cfb38-ccba-40a8-ad7a-89c57b070884" />
     <Project Path="src/common/updating/updating.vcxproj" Id="17da04df-e393-4397-9cf0-84dabe11032e" />
     <Project Path="src/common/version/version.vcxproj" Id="cc6e41ac-8174-4e8a-8d22-85dd7f4851df" />
   </Folder>
@@ -300,6 +301,10 @@
     </Project>
   </Folder>
   <Folder Name="/modules/CommandPalette/Tests/">
+    <Project Path="src/modules/cmdpal/Tests/Microsoft.CmdPal.Core.Common.UnitTests/Microsoft.CmdPal.Core.Common.UnitTests.csproj">
+      <Platform Solution="*|ARM64" Project="ARM64" />
+      <Platform Solution="*|x64" Project="x64" />
+    </Project>
     <Project Path="src/modules/cmdpal/Tests/Microsoft.CmdPal.Ext.Apps.UnitTests/Microsoft.CmdPal.Ext.Apps.UnitTests.csproj">
       <Platform Solution="*|ARM64" Project="ARM64" />
       <Platform Solution="*|x64" Project="x64" />
@@ -356,6 +361,10 @@
       <Platform Solution="*|ARM64" Project="ARM64" />
       <Platform Solution="*|x64" Project="x64" />
     </Project>
+    <Project Path="src/modules/cmdpal/Tests/Microsoft.CommandPalette.Extensions.Toolkit.UnitTests/Microsoft.CommandPalette.Extensions.Toolkit.UnitTests.csproj" Id="2eca18b7-33b7-4829-88f1-439b20fd60f6">
+      <Platform Solution="*|ARM64" Project="ARM64" />
+      <Platform Solution="*|x64" Project="x64" />
+    </Project>
   </Folder>
   <Folder Name="/modules/CommandPalette/UI/">
     <Project Path="src/modules/cmdpal/Microsoft.CmdPal.UI.ViewModels/Microsoft.CmdPal.UI.ViewModels.csproj">

README.md

@@ -51,19 +51,19 @@ But to get started quickly, choose one of the installation methods below:
 Go to the <a href="https://aka.ms/installPowerToys">PowerToys GitHub releases</a>, click Assets to reveal the downloads, and choose the installer that matches your architecture and install scope. For most devices, that's the x64 per-user installer.
 
 <!-- items that need to be updated release to release -->
-[github-next-release-work]: https://github.com/microsoft/PowerToys/issues?q=is%3Aissue+milestone%3A%22PowerToys+0.97%22
-[github-current-release-work]: https://github.com/microsoft/PowerToys/issues?q=is%3Aissue+milestone%3A%22PowerToys+0.96%22
-[ptUserX64]: https://github.com/microsoft/PowerToys/releases/download/v0.97.0/PowerToysUserSetup-0.97.0-x64.exe 
-[ptUserArm64]: https://github.com/microsoft/PowerToys/releases/download/v0.97.0/PowerToysUserSetup-0.97.0-arm64.exe 
-[ptMachineX64]: https://github.com/microsoft/PowerToys/releases/download/v0.97.0/PowerToysSetup-0.97.0-x64.exe 
-[ptMachineArm64]: https://github.com/microsoft/PowerToys/releases/download/v0.97.0/PowerToysSetup-0.97.0-arm64.exe
+[github-next-release-work]: https://github.com/microsoft/PowerToys/issues?q=is%3Aissue+milestone%3A%22PowerToys+0.98%22
+[github-current-release-work]: https://github.com/microsoft/PowerToys/issues?q=is%3Aissue+milestone%3A%22PowerToys+0.97%22
+[ptUserX64]: https://github.com/microsoft/PowerToys/releases/download/v0.97.1/PowerToysUserSetup-0.97.1-x64.exe 
+[ptUserArm64]: https://github.com/microsoft/PowerToys/releases/download/v0.97.1/PowerToysUserSetup-0.97.1-arm64.exe 
+[ptMachineX64]: https://github.com/microsoft/PowerToys/releases/download/v0.97.1/PowerToysSetup-0.97.1-x64.exe 
+[ptMachineArm64]: https://github.com/microsoft/PowerToys/releases/download/v0.97.1/PowerToysSetup-0.97.1-arm64.exe
  
 |  Description   | Filename |
 |----------------|----------|
-| Per user - x64       | [PowerToysUserSetup-0.97.0-x64.exe][ptUserX64] |
-| Per user - ARM64     | [PowerToysUserSetup-0.97.0-arm64.exe][ptUserArm64] |
-| Machine wide - x64   | [PowerToysSetup-0.97.0-x64.exe][ptMachineX64] |
-| Machine wide - ARM64 | [PowerToysSetup-0.97.0-arm64.exe][ptMachineArm64] |
+| Per user - x64       | [PowerToysUserSetup-0.97.1-x64.exe][ptUserX64] |
+| Per user - ARM64     | [PowerToysUserSetup-0.97.1-arm64.exe][ptUserArm64] |
+| Machine wide - x64   | [PowerToysSetup-0.97.1-x64.exe][ptMachineX64] |
+| Machine wide - ARM64 | [PowerToysSetup-0.97.1-arm64.exe][ptMachineArm64] |
 
 </details>
 
@@ -103,18 +103,38 @@ There are <a href="https://learn.microsoft.com/windows/powertoys/install#communi
 </details>
 
 ## ✨ What's new
-**Version 0.97 (January 2026)**
+**Version 0.97.1 (January 2026)**
 
-For an in-depth look at the latest changes, visit the [Windows Command Line blog](https://aka.ms/powertoys-releaseblog).
+This patch release fixes several important stability issues identified in v0.97.0 based on incoming reports. Check out the [v0.97.0](https://github.com/microsoft/PowerToys/releases/tag/v0.97.0) notes for the full list of changes.
 
-**✨ Highlights**
-- **Command Palette**: Major expansion with PowerToys extension (Windows 11 only), Remote Desktop built-in extension, theme customization, drag-and-drop support, fallback ranking controls, sections/separators for pages, pinyin Chinese matching, and many UX refinements.
-- **Settings**: Quick Access flyout is now a standalone process for significantly faster startup, theme-adaptive tray icon, AOT serialization, and multiple UI/accessibility fixes
-- **CursorWrap (New!)**: New mouse utility that lets your cursor wrap around screen edges, making multi-monitor navigation faster and more seamless.
-- **Advanced Paste**: Image input for AI, color detection in clipboard history, Foundry Local improvements, Azure AI icons, and multiple bug fixes
-- **CLI Support Expanded**: FancyZones, Image Resizer, and File Locksmith can now be controlled from the command line for layout management, batch image resizing, and file lock inspection.
-- **LightSwitch**: Added support for automatically following Windows Night Light mode.
-- **Release Experience & Quality**: Refreshed "What’s new" dialog, plus many performance improvements, stability fixes, and refinements across PowerToys.
+**Highlights**
+
+### Advanced Paste
+- #44862: Fixed Settings UI advanced paste page crash by using correct settings repository for null checking.
+
+### Command Palette
+- #44886: Fixed personalization section not appearing by using latest MSIX for installation.
+- #44938: Fixed loading of icons from internet shortcuts. Thanks [@jiripolasek](https://github.com/jiripolasek)!
+- #45076: Fixed potential deadlock from lazy-loading AppListItem details. Thanks [@jiripolasek](https://github.com/jiripolasek)!
+
+### Cursor Wrap
+- #44936: Added improved multi-monitor support; Added laptop lid close detection for dynamic monitor topology updates. Thanks [@mikehall-ms](https://github.com/mikehall-ms)!
+- #44936: Added new settings dropdown to constrain wrapping to horizontal-only, vertical-only, or both directions. Thanks [@mikehall-ms](https://github.com/mikehall-ms)!
+
+### Peek
+- #44995: Fixed Space key triggering Peek during file rename, search, or address bar typing.
+
+### PowerRename
+- #44944: Fixed regex `$` not working, preventing users from adding text at the end of filenames.
+
+### Runner
+- #44931: Monochrome tray icon now adapts to Windows system theme instead of app theme.
+- #44982: Fixed right-click menu to dynamically update based on Quick Access enabled/disabled state.
+
+### GPO / Enterprise
+- #45028: Added CursorWrap policy definition to ADMX templates. Thanks [@htcfreek](https://github.com/htcfreek)!
+
+For the full list of v0.97 changes, visit the [Windows Command Line blog](https://aka.ms/powertoys-releaseblog).
 
 ## Advanced Paste
 
@@ -289,7 +309,7 @@ For an in-depth look at the latest changes, visit the [Windows Command Line blog
 - Stabilized FancyZones UI tests with more reliable selectors and screen recordings.
 
 ## 🛣️ Roadmap 
-We are planning some nice new features and improvements for the next releases – PowerDisplay, Command Palette improvements and a brand-new Shortcut Guide experience! Stay tuned for [v0.97][github-next-release-work]!
+We are planning some nice new features and improvements for the next releases – PowerDisplay, Command Palette improvements and a brand-new Shortcut Guide experience! Stay tuned for [v0.98][github-next-release-work]!
 
 ## ❤️ PowerToys Community 
 The PowerToys team is extremely grateful to have the [support of an amazing active community][community-link]. The work you do is incredibly important. PowerToys wouldn't be nearly what it is today without your help filing bugs, updating documentation, guiding the design, or writing features. We want to say thank you and take time to recognize your work. Your contributions and feedback improve PowerToys month after month!

doc/devdocs/core/installer.md

@@ -88,7 +88,7 @@
 ### Building PowerToys Locally
 
 #### One stop script for building installer
-1. Open developer powershell for vs 2022
+1. Open `Developer Powershell for VS 2022` or `Developer PowerShell for VS` for VS 2026.
 2. Run tools\build\build-installer.ps1
 > For the first-time setup, please run the installer as an administrator. This ensures that the Wix tool can move wix.target to the desired location and trust the certificate used to sign the MSIX packages.
 
@@ -109,7 +109,7 @@ dotnet tool install --global wix --version 5.0.2
 
 ##### From the command line
 
-1. From the start menu, open a `Developer Command Prompt for VS 2022`
+1. From the start menu, open a `Developer Command Prompt for VS 2022` or `Developer Command Prompt for VS`
 1. Ensure `nuget.exe` is in your `%path%`
 1. In the repo root, run these commands:
   
@@ -140,7 +140,7 @@ If you prefer, you can alternatively build prerequisite projects for the install
 
 The resulting installer will be available in the `installer\PowerToysSetupVNext\x64\Release\` folder.
 
-To build the installer from the command line, run `Developer Command Prompt for VS 2022` in admin mode and execute the following commands. The generated installer package will be located at `\installer\PowerToysSetupVNext\{platform}\Release\MachineSetup`.
+To build the installer from the command line, run `Developer Command Prompt for VS 2022` or `Developer Command Prompt for VS` in admin mode and execute the following commands. The generated installer package will be located at `\installer\PowerToysSetupVNext\{platform}\Release\MachineSetup`.
 
 ```
 git clean -xfd  -e *exe -- .\installer\

doc/devdocs/development/debugging.md

@@ -15,7 +15,7 @@ Before you can start debugging PowerToys, you need to set up your development en
 
 You can build the entire solution from the command line, which is sometimes faster than building within Visual Studio:
 
-1. Open Developer Command Prompt for VS 2022
+1. Open `Developer Command Prompt for VS 2022` or `Developer Command Prompt for VS`
 2. Navigate to the repository root directory
 3. Run the following command(don't forget to set the correct platform):
    ```pwsh
@@ -105,7 +105,7 @@ If you encounter build errors about missing image files (e.g., `.png`, `.ico`, o
 
 1. **Clean the solution in Visual Studio**: Build > Clean Solution
 
-   Or from the command line (Developer Command Prompt for VS 2022):
+   Or from the command line (Developer Command Prompt for VS 2022 or Developer Command Prompt for VS):
    ```pwsh
    msbuild PowerToys.slnx /t:Clean /p:Platform=x64 /p:Configuration=Debug
    ```

doc/devdocs/development/dev-with-vscode.md

@@ -15,9 +15,11 @@ VS Code extensions Needed:
 ---
 
 ## Building in VS Code
-### Configure developer powershell for vs2022 for more convenient dev in vscode.
+### Configure Developer Powershell for VS 2022 or Developer Powershell for VS for more convenient dev in vscode.
 1. Configure profile in in settings, entry:  "terminal.integrated.profiles.windows"
-2. Add below config as entry:
+2. Add below config as entry (choose VS 2022 or VS 2026 based on your installation):
+
+**For Visual Studio 2022:**
 ```json
     "Developer PowerShell for VS 2022": {
 		// Configure based on your preference
@@ -27,16 +29,35 @@ VS Code extensions Needed:
             "-Command",
             "& {",
             "$orig = Get-Location;",
-            // Configure based on your environment
+            // Adjust path based on your edition (Community/Professional/Enterprise)
             "& 'C:\\Program Files\\Microsoft Visual Studio\\2022\\Enterprise\\Common7\\Tools\\Launch-VsDevShell.ps1';",
             "Set-Location $orig",
             "}"
         ]
     },
 ```
-3. [Optional] Set Developer PowerShell for VS 2022 as your default profile, so that you can get a deep integration with vscode coding agent. 
 
-4. Now You can build with plain `msbuild` or configure tasks.json in below section
+**For Visual Studio 2026:**
+```json
+    "Developer PowerShell for VS": {
+		// Configure based on your preference
+        "path": "C:\\Program Files\\WindowsApps\\Microsoft.PowerShell_7.5.2.0_arm64__8wekyb3d8bbwe\\pwsh.exe",
+        "args": [
+            "-NoExit",
+            "-Command",
+            "& {",
+            "$orig = Get-Location;",
+            // Adjust path based on your edition (Community/Professional/Enterprise)
+            "& 'C:\\Program Files\\Microsoft Visual Studio\\18\\Enterprise\\Common7\\Tools\\Launch-VsDevShell.ps1';",
+            "Set-Location $orig",
+            "}"
+        ]
+    },
+```
+
+3. [Optional] Set your Developer PowerShell profile as the default, so that you can get a deep integration with vscode coding agent. 
+
+4. Now you can build with plain `msbuild` or configure tasks.json in below section.
 Or reach out to "tools\build\BUILD-GUIDELINES.md"
 
 ### Sample plain msbuild command

doc/devdocs/development/new-powertoy.md

@@ -0,0 +1,311 @@
+# 🧭 Creating a new PowerToy: end-to-end developer guide
+
+First of all, thank you for wanting to contribute to PowerToys. The work we do would not be possible without the support of community supporters like you.
+
+This guide documents the process of building a new PowerToys utility from scratch, including architecture decisions, integration steps, and common pitfalls.
+
+---
+
+## 1. Overview and prerequisites
+
+A PowerToy module is a self-contained utility integrated into the PowerToys ecosystem. It can be UI-based, service-based, or both.
+
+### Requirements
+
+- [Visual Studio 2026](https://visualstudio.microsoft.com/downloads/) and the following workloads/individual components:
+  - Desktop Development with C++
+  - WinUI application development
+  - .NET desktop development
+  - Windows 10 SDK (10.0.22621.0)
+  - Windows 11 SDK (10.0.26100.3916)
+- .NET 8 SDK
+- Fork the [PowerToys repository](https://github.com/microsoft/PowerToys/tree/main) locally
+- [Validate that you are able to build and run](https://github.com/microsoft/PowerToys/blob/main/doc/devdocs/development/debugging.md) `PowerToys.slnx`.
+
+Optional: 
+- [WiX v5 toolset](https://github.com/microsoft/PowerToys/tree/main) for the installer
+
+> [!NOTE]
+> To ensure all the correct VS Workloads are installed, use [the WinGet configuration files](https://github.com/microsoft/PowerToys/tree/e13d6a78aafbcf32a4bb5f8581d041e1d057c3f1/.config) in the project repository. (Use the one that matches your VS distribution. ie: VS Community would use `configuration.winget`)
+
+### Folder structure
+
+```
+src/
+  modules/
+    your_module/
+      YourModule.sln
+      YourModuleInterface/
+      YourModuleUI/ (if needed)
+      YourModuleService/ (if needed)
+```
+
+---
+## 2. Design and planning
+
+### Decide the type of module
+
+Think about how your module works and which existing modules behave similarly. You are going to want to think about the UI needed for the application, the lifecycle, whether it is a service that is always running or event based. Below are some basic scenarios with some modules to explore. You can write your application in C++ or C#.
+- **UI-only:** e.g., ColorPicker
+- **Background service:** e.g., LightSwitch, Awake
+- **Hybrid (UI + background logic):** e.g., ShortcutGuide
+- **C++/C# interop:** e.g., PowerRename 
+
+### Write your module interface
+
+Begin by setting up the [PowerToy module template project](https://github.com/microsoft/PowerToys/tree/main/tools/project_template). This will generate boilerplate for you to begin your new module. Below are the key headers in the Module Interface (`dllmain.cpp`) and an explanation of their purpose:
+1. This is where module settings are defined. These can be anything from strings, bools, ints, and even custom Enums.
+```c++
+struct ModuleSettings {};
+```
+
+2. This is the header for the full class. It inherits the PowerToyModuleIface
+```c++
+class ModuleInterface : public PowertoyModuleIface 
+{
+  private:
+    // the private members of the class
+    // Can include the enabled variable, logic for event handlers, or hotkeys.
+  public:
+    // the public members of the class
+    // Will include the constructor and initialization logic.
+}
+```
+
+> [!NOTE]
+> Many of the class functions are boilerplate and need simple string replacements with your module name. The rest of the functions below will require bigger changes.
+
+3. GPO stands for "Group Policy Object" and allows for administrators to configure settings across a network of machines. It is required that your module is on this list of settings. You can right click the `powertoys_gpo` object to go to the definition and set up the `getConfiguredModuleEnabledValue` for your module.
+```c++
+virtual powertoys_gpo::gpo_rule_configured_t gpo_policy_enabled_configuration() override
+{
+    return powertoys_gpo::getConfiguredModuleEnabledValue();
+}
+```
+
+4. `init_settings()` initializes the settings for the interface. Will either pull from existing settings.json or use defaults.
+```c++
+void ModuleInterface::init_settings()
+```
+
+5. `get_config` retrieves the settings from the settings.json file.
+```c++
+virtual bool get_config(wchar_t* buffer, int* buffer_size) override
+```
+
+6. `set_config` sets the new settings to the settings.json file.
+```c++
+virtual void set_config(const wchar_t* config) override
+```
+
+7. `call_custom_action` allows custom actions to be called based on signals from the settings app.
+```c++
+void call_custom_action(const wchar_t* action) override
+```
+
+8. Lifecycle events control whether the module is enabled or not, as well as the default status of the module.
+```c++
+virtual void enable() // starts the module
+virtual void disable() // terminates the module and performs any cleanup
+virtual bool is_enabled() // returns if the module is currently enabled
+virtual bool is_enabled_by_default() const override // allows the module to dictate whether it should be enabled by default in the PowerToys app.
+```
+
+9. Hotkey functions control the status of the hotkey.
+```c++
+// takes the hotkey from settings into a format that the interface can understand
+void parse_hotkey(PowerToysSettings::PowerToyValues& settings) 
+
+// returns the hotkeys from settings
+virtual size_t get_hotkeys(Hotkey* hotkeys, size_t buffer_size) override 
+
+// performs logic when the hotkey event is fired
+virtual bool on_hotkey(size_t hotkeyId) override 
+```
+
+### Notes
+
+- Keep module logic isolated under `/modules/<YourModule>`
+- Use shared utilities from [`common`](https://github.com/microsoft/PowerToys/tree/main/src/common) instead of cross-module dependencies
+- init/set/get config use preset functions to access the settings. Check out the [`settings_objects.h`](https://github.com/microsoft/PowerToys/blob/main/src/common/SettingsAPI/settings_helpers.h) in `src\common\SettingsAPI`
+
+---
+## 3. Bootstrapping your module
+
+1. Use the [template](https://github.com/microsoft/PowerToys/tree/main/tools/project_template) to generate the module interface starter code.
+2. Update all projects and namespaces with your module name.
+3. Update GUIDs in `.vcxproj` and solution files.
+4. Update the functions mentioned in the above section with your custom logic.
+5. In order for your module to be detected by the runner you are required to add  references to various lists. In order to register your module, add the corresponding module reference to the lists that can be found in the following files. (Hint: search other modules names to find the lists quicker)
+    - `src/runner/modules.h`
+    - `src/runner/modules.cpp`
+    - `src/runner/resource.h`
+    - `src/runner/settings_window.h`
+    - `src/runner/settings_window.cpp`
+    - `src/runner/main.cpp`
+    - `src/common/logger.h` (for logging)
+6. ModuleInterface should build your `ModuleInterface.dll`. This will allow the runner to interact with your service.
+
+> [!TIP]
+> Mismatched module IDs are one of the most common causes of load failures. Keep your ID consistent across manifest, registry, and service.
+
+---
+## 4. Write your service
+
+This is going to look different for every PowerToy. It may be easier to develop the application independently, and then link in the PowerToys settings logic later. But you have to write the service first, before connecting it to the runner.
+
+### Notes
+
+- This is a separate project from the Module Interface.
+- You can develop this project using C# or C++.
+- Set the service icon using the `.rc` file.
+- Set the service name in the `.vcxproj` by setting the `<TargetName>`
+```
+<PropertyGroup>
+  <OutDir>..\..\..\..\$(Platform)\$(Configuration)\$(MSBuildProjectName)\</OutDir>
+  <TargetName>PowerToys.LightSwitchService</TargetName>
+</PropertyGroup>
+```
+- To view the code of the `.vcxproj`, right click the item and select **Unload project**
+- Use the following functions to interact with settings from your service
+```
+ModuleSettings::instance().InitFileWatcher();
+ModuleSettings::instance().LoadSettings();
+auto& settings = ModuleSettings::instance().settings();
+```
+These come from the `ModuleSettings.h` file that lives with the Service. You can copy this from another module (e.g., Light Switch) and adjust to fit your needs.
+
+If your module has a user interface:
+- Use the **WinUI Blank App** template when setting up your project
+- Use [Windows design best practices](https://learn.microsoft.com/windows/apps/design/basics/)
+- Use the [WinUI 3 Gallery](https://apps.microsoft.com/detail/9p3jfpwwdzrc) for help with your UI code, and additional guidance.
+
+## 5. Settings integration
+
+PowerToys settings are stored per-module as JSON under:
+
+```
+%LOCALAPPDATA%\Microsoft\PowerToys\<module>\settings.json
+```
+
+### Implementation steps
+
+- In `src\settings-ui\Settings.UI.Library\` create `<module>Properties.cs` and `<module>Settings.cs`
+- `<module>Properties.cs` is where you will define your defaults. Every setting needs to be represented here. This should match what was set in the Module Interface.
+- `<module>Settings.cs`is where your settings.json will be built from. The structure should match the following
+```cs
+public ModuleSettings()
+{
+    Name = ModuleName;
+    Version = Assembly.GetExecutingAssembly().GetName().Version.ToString();
+    Properties = new ModuleProperties(); // settings properties you set above.
+}
+```
+
+- In `src\settings-ui\Settings.UI\ViewModels` create `<module>ViewModel.cs` this is where the interaction happens between your settings page in the PowerToys app and the settings file that is stored on the device. Changes here will trigger the settings watcher via a `NotifyPropertyChanged` event.
+- Create a `SettingsPage.xaml` at `src\settings-ui\Settings.UI\SettingsXAML\Views`. This will be the page where the user interacts with the settings of your module.
+- Be sure to use resource strings for user facing strings so they can be localized. (`x:Uid` connects to Resources.resw)
+```xaml
+// LightSwitch.xaml
+<ComboBoxItem
+    x:Uid="LightSwitch_ModeOff"
+    AutomationProperties.AutomationId="OffCBItem_LightSwitch"
+    Tag="Off" />
+
+// Resources.resw
+<data name="LightSwitch_ModeOff.Content" xml:space="preserve">
+  <value>Off</value>
+</data>
+```
+> [!IMPORTANT]
+> In the above example we use `.Content` to target the content of the Combobox. This can change per UI element (e.g., `.Text`, `.Header`, etc.)
+
+> **Reminder:** Manual changes via external editors (VS Code, Notepad) do **not** trigger the settings watcher. Only changes written through PowerToys trigger reloads.
+
+---
+
+### Gotchas:
+
+- Only use the WinUI 3 framework, _not_ UWP.
+- Use [`DispatcherQueue`](https://learn.microsoft.com/windows/apps/develop/dispatcherqueue) when updating UI from non-UI threads.
+
+---
+## 6. Building and debugging
+
+### Debugging steps
+
+1. If this is your first time debugging PowerToys, be sure to follow [these steps first](https://github.com/microsoft/PowerToys/blob/main/doc/devdocs/development/debugging.md#pre-debugging-setup).
+2. Set "runner" as the start up project and ensure your build configuration is set to match your system (ARM64/x64)
+3. Select <kbd>F5</kbd> or the **Local Windows Debugger** button to begin debugging. This should start the PowerToys runner.
+4. To set breakpoints in your service, select Ctrl+Alt+P and search for your service to attach to the runner.
+5. Use logs to document changes. The logs live at `%LOCALAPPDATA%\Microsoft\PowerToys\RunnerLogs` and `%LOCALAPPDATA%\Microsoft\PowerToys\Module\Service\<version>` for the specific module.
+
+> [!TIP]
+> PowerToys caches `.nuget` artifacts aggressively. Use `git clean -xfd` when builds behave unexpectedly.
+
+---
+## 7. Installer and packaging (WiX)
+
+### Add your module to installer
+
+1. Install [`WixToolset.Heat`](https://www.nuget.org/packages/WixToolset.Heat/) for Wix5 via nuget
+2. Inside `installer\PowerToysInstallerVNext` add a new file for your module: `Module.wxs`
+3. Inside of this file you will need copy the format from another module (ie: Light Switch) and replace the strings and GUID values.
+4. The key part will be `<!--ModuleNameFiles_Component_Def-->` which is a placeholder for code that will be generated by `generateFileComponents.ps1`.
+5. Inside `Product.wxs` add a line item in the `<Feature Id="CoreFeature" ... >` section. It will look like a list of ` <ComponentGroupRef Id="ModuleComponentGroup" />` items.
+6. Inside `generateFileComponents.ps1` you will need to add an entry to the bottom for your new module. It will follow the following format. `-fileListName <Module>Files` will match the string you set in `Module.wxs`, `<ModuleServiceName>` will match the name of your exe.
+```bash
+# Module Name
+Generate-FileList -fileDepsJson "" -fileListName <Module>Files -wxsFilePath $PSScriptRoot\<Module>.wxs -depsPath "$PSScriptRoot..\..\..\$platform\Release\<ModuleServiceName>"
+Generate-FileComponents -fileListName "<Module>Files" -wxsFilePath $PSScriptRoot\<Module>.wxs -regroot $registryroot
+```
+---
+## 8. Testing and validation
+
+### UI tests
+
+- Place under `/modules/<YourModule>/Tests`
+- Create a new [WinUI Unit Test App](https://learn.microsoft.com/windows/apps/winui/winui3/testing/create-winui-unit-test-project)
+- Write unit tests following the format from previous modules (ie: Light Switch). This can be to test your standalone UI (if you're a module like Color Picker) or to verify that the Settings UI in the PowerToys app is controlling your service.
+
+### Manual validation
+
+- Enable/disable in PowerToys Settings
+- Check initialization in logs
+- Confirm icons, tooltips, and OOBE page appear correctly
+
+### Pro tips
+
+1. Validate wake/sleep and elevation states. Background modules often fail silently after resume if event handles aren’t recreated.
+2. Use Windows Sandbox to simulate clean install environments
+3. To simulate a "new user" you can delete the PowerToys folder from `%LOCALAPPDATA%\Microsoft`
+
+### Shortcut conflict detection
+
+If your module has a shortcut, ensure that it is properly registered following [the steps listed in the documentation](https://github.com/microsoft/PowerToys/blob/main/doc/devdocs/core/settings/settings-implementation.md#shortcut-conflict-detection) for conflict detection.
+
+---
+## 9. The final touches
+
+### Out-of-Box experience (OOBE) page
+
+The OOBE page is a custom settings page that gives the user at a glance information about each module. This window opens before the Settings application for new users and after updates. Create `OOBE<ModuleName>.xaml` at `src\settings-ui\Settings.UI\SettingsXAML\OOBE\Views`. You will also need to add your module name to the enum at `src\settings-ui\Settings.UI\OOBE\Enums\PowerToysModules.cs`.
+
+### Module assets
+
+Now that your PowerToy is _done_ you can start to think about the assets that will represent your module.
+- Module Icon: This will be displayed in a number of places: OOBE page, in the README, on the home screen of PowerToys, on your individual module settings page, etc.  
+- Module Image: This is the image you see at the top of each individual settings page.
+- OOBE Image: This is the header you see on the OOBE page for each module
+
+> [!NOTE]
+> This step is something that the Design team will handle internally to ensure consistency throughout the application. If you have ideas or recommendations on what the icon or screenshots should be for your module feel free to leave it in the "Additional Comments" section of the PR and the team will take it into consideration.
+
+### Documentation
+
+There are two types of documentation that will be required when submitting a new PowerToy:
+1. Developer documentation: This will live in the [PowerToys repo](https://github.com/microsoft/PowerToys/blob/main/doc/devdocs/modules) at `/doc/devdocs/modules/` and should tell a developer how to work on your app. It should outline the module architecture, key files, testing, and tips on debugging if necessary.
+2. Microsoft Learn documentation: When your new Module is ready to be merged into the PowerToys repository, an internal team member will create Microsoft Learn documentation so that users will understand how to use your module. There is not much work on your end as the developer for this step, but keep an eye on your PR in case we need more information about your PowerToy for this step.
+
+---
+Thank you again for contributing! If you need help, feel free to [open an issue](https://github.com/microsoft/PowerToys/issues/new/choose) and use the `Needs-Team-Response` label so we know you need attention.

doc/devdocs/modules/advancedpaste.md

@@ -18,13 +18,28 @@ Advanced Paste is a PowerToys module that provides enhanced clipboard pasting wi
 
 TODO: Add implementation details
 
+### Paste with AI Preview
+
+The "Show preview" setting (`ShowCustomPreview`) controls whether AI-generated results are displayed in a preview window before pasting. **The preview feature does not consume additional AI credits**—the preview displays the same AI response that was already generated, cached locally from a single API call.
+
+The implementation flow:
+1. User initiates "Paste with AI" action
+2. A single AI API call is made via `ExecutePasteFormatAsync`
+3. The result is cached in `GeneratedResponses`
+4. If preview is enabled, the cached result is displayed in the preview UI
+5. User can paste the cached result without any additional API calls
+
+See the `ExecutePasteFormatAsync(PasteFormat, PasteActionSource)` method in `OptionsViewModel.cs` for the implementation.
+
 ## Debugging
 
 TODO: Add debugging information
 
 ## Settings
 
-TODO: Add settings documentation
+| Setting | Description |
+|---------|-------------|
+| `ShowCustomPreview` | When enabled, shows AI-generated results in a preview window before pasting. Does not affect AI credit consumption. |
 
 ## Future Improvements
 

doc/devdocs/modules/fancyzones.md

@@ -152,7 +152,7 @@ FancyZones is divided into several projects:
 ## Development Environment Setup
 
 ### Prerequisites
-- Visual Studio 2022: Required for building and debugging
+- Visual Studio 2022 or 2026: Required for building and debugging
 - Windows 10 SDK: Ensure the latest version is installed
 - PowerToys Repository: Clone from GitHub
 
@@ -183,7 +183,7 @@ FancyZones is divided into several projects:
 ## Debugging
 
 ### Setup for Debugging
-1. In Visual Studio 2022, set FancyZonesEditor as the startup project
+1. In Visual Studio 2022 or 2026, set FancyZonesEditor as the startup project
 2. Set breakpoints in the code where needed
 3. Click Run to start debugging
 

doc/devdocs/readme.md

@@ -79,7 +79,7 @@ Once you've discussed your proposed feature/fix/etc. with a team member, and an
 ### Prerequisites for Compiling PowerToys
 
 1. Windows 10 April 2018 Update (version 1803) or newer
-1. Visual Studio Community/Professional/Enterprise 2022 17.4 or newer
+1. Visual Studio Community/Professional/Enterprise 2022 17.4 or newer, or Visual Studio 2026
 1. A local clone of the PowerToys repository
 1. Enable long paths in Windows (see [Enable Long Paths](https://docs.microsoft.com/windows/win32/fileio/maximum-file-path-limitation#enabling-long-paths-in-windows-10-version-1607-and-later) for details)
 

installer/PowerToysSetupCustomActionsVNext/PowerToysSetupCustomActionsVNext.vcxproj

@@ -14,13 +14,13 @@
   <PropertyGroup Condition="'$(Configuration)'=='Debug'" Label="Configuration">
     <ConfigurationType>DynamicLibrary</ConfigurationType>
     <CharacterSet>Unicode</CharacterSet>
-    <PlatformToolset>v143</PlatformToolset>
+    
   </PropertyGroup>
   <PropertyGroup Condition="'$(Configuration)'=='Release'" Label="Configuration">
     <ConfigurationType>DynamicLibrary</ConfigurationType>
     <CharacterSet>Unicode</CharacterSet>
     <WholeProgramOptimization>true</WholeProgramOptimization>
-    <PlatformToolset>v143</PlatformToolset>
+    
   </PropertyGroup>
   <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
   <Import Project="..\..\deps\spdlog.props" />

installer/PowerToysSetupVNext/Directory.Build.props

@@ -1,5 +1,5 @@
 <Project>
-  <Import Project="..\..\src\Version.props" Condition="Exists('..\..\src\Version.props')" />
+  <Import Project="..\..\Directory.Build.props" />
   <PropertyGroup>
     <!-- Set BaseIntermediateOutputPath for each project to avoid conflicts -->
     <BaseIntermediateOutputPath Condition="'$(MSBuildProjectName)' == 'PowerToysInstallerVNext'">obj\Installer\</BaseIntermediateOutputPath>

installer/PowerToysSetupVNext/SilentFilesInUseBA/SilentFilesInUseBAFunction.vcxproj

@@ -37,14 +37,14 @@
   <PropertyGroup Condition="'$(Configuration)'=='Debug'" Label="Configuration">
     <ConfigurationType>DynamicLibrary</ConfigurationType>
     <UseDebugLibraries>true</UseDebugLibraries>
-    <PlatformToolset>v143</PlatformToolset>
+    
     <CharacterSet>Unicode</CharacterSet>
   </PropertyGroup>
   
   <PropertyGroup Condition="'$(Configuration)'=='Release'" Label="Configuration">
     <ConfigurationType>DynamicLibrary</ConfigurationType>
     <UseDebugLibraries>false</UseDebugLibraries>
-    <PlatformToolset>v143</PlatformToolset>
+    
     <WholeProgramOptimization>true</WholeProgramOptimization>
     <CharacterSet>Unicode</CharacterSet>
   </PropertyGroup>
@@ -68,11 +68,10 @@
     <ClCompile Include="SilentFilesInUseBAFunctions.cpp" />
     <ClCompile Include="bafunctions.cpp">
       <PrecompiledHeader>Create</PrecompiledHeader>
-      <PrecompiledHeaderFile>precomp.h</PrecompiledHeaderFile>
     </ClCompile>
   </ItemGroup>
   <ItemGroup>
-    <ClInclude Include="precomp.h" />
+    <ClInclude Include="pch.h" />
     <ClInclude Include="resource.h" />
   </ItemGroup>
   <ItemGroup>

installer/PowerToysSetupVNext/SilentFilesInUseBA/SilentFilesInUseBAFunctions.cpp

@@ -1,6 +1,6 @@
 // Copyright (c) .NET Foundation and contributors. All rights reserved. Licensed under the Microsoft Reciprocal License. See LICENSE.TXT file in the project root for full license information.
 
-#include "precomp.h"
+#include "pch.h"
 #include "BalBaseBAFunctions.h"
 #include "BalBaseBAFunctionsProc.h"
 
@@ -18,7 +18,6 @@ public: // IBootstrapperApplication
 
         BalLog(BOOTSTRAPPER_LOG_LEVEL_STANDARD, "*** CUSTOM BA FUNCTION SYSTEM ACTIVE *** Running detect begin BA function. fCached=%d, registrationType=%d, cPackages=%u, fCancel=%d", fCached, registrationType, cPackages, *pfCancel);
 
-    LExit:
         return hr;
     }
 
@@ -37,7 +36,6 @@ public: // IBAFunctions
         // BalExitOnFailure(hr, "Change this message to represent real error handling.");
         //-------------------------------------------------------------------------------------------------
 
-    LExit:
         return hr;
     }
 
@@ -58,7 +56,7 @@ public: // IBAFunctions
         __in DWORD cFiles,
         __in_ecount_z(cFiles) LPCWSTR* rgwzFiles,
         __in int nRecommendation,
-        __in BOOTSTRAPPER_FILES_IN_USE_TYPE source,
+        __in BOOTSTRAPPER_FILES_IN_USE_TYPE /* source */,
         __inout int* pResult
         )
     {

installer/PowerToysSetupVNext/SilentFilesInUseBA/bafunctions.cpp

@@ -1,6 +1,6 @@
 // Copyright (c) .NET Foundation and contributors. All rights reserved. Licensed under the Microsoft Reciprocal License. See LICENSE.TXT file in the project root for full license information.
 
-#include "precomp.h"
+#include "pch.h"
 
 static HINSTANCE vhInstance = NULL;
 

src/ActionRunner/actionRunner.cpp

@@ -104,66 +104,6 @@ int WINAPI WinMain(HINSTANCE, HINSTANCE, LPSTR, int)
             }
         }
     }
-    else if (action == RUN_AS_USER || action == RUN_AS_ADMIN)
-    {
-        // Handle "Run as different user" and "Run as administrator" actions.
-        // This is used by Command Palette to work around WinUI3/MSIX packaging limitations
-        // where ShellExecute with "runas user"/"runas" verbs doesn't work properly from packaged apps.
-        int nextArg = 2;
-
-        std::wstring_view target;
-        std::wstring_view workingDir;
-
-        while (nextArg < nArgs)
-        {
-            if (std::wstring_view(args[nextArg]) == L"-target" && nextArg + 1 < nArgs)
-            {
-                target = args[nextArg + 1];
-                nextArg += 2;
-            }
-            else if (std::wstring_view(args[nextArg]) == L"-workingDir" && nextArg + 1 < nArgs)
-            {
-                workingDir = args[nextArg + 1];
-                nextArg += 2;
-            }
-            else
-            {
-                nextArg++;
-            }
-        }
-
-        if (target.empty())
-        {
-            Logger::error(L"ActionRunner: {} called without -target argument", action);
-            return 1;
-        }
-
-        Logger::trace(L"ActionRunner: {} target='{}' workingDir='{}'", action, target, workingDir);
-
-        SHELLEXECUTEINFOW sei = { sizeof(sei) };
-        sei.fMask = SEE_MASK_FLAG_NO_UI;
-        sei.lpFile = target.data();
-        sei.lpDirectory = workingDir.empty() ? nullptr : workingDir.data();
-        sei.lpVerb = (action == RUN_AS_ADMIN) ? L"runas" : L"runasuser";
-        sei.nShow = SW_SHOWNORMAL;
-
-        if (!ShellExecuteExW(&sei))
-        {
-            DWORD error = GetLastError();
-            if (error == ERROR_CANCELLED)
-            {
-                // User cancelled the UAC/credential dialog - this is expected behavior
-                Logger::trace(L"ActionRunner: User cancelled {} dialog for '{}'", action, target);
-            }
-            else
-            {
-                Logger::error(L"ActionRunner: ShellExecuteEx failed for {} '{}': error {}", action, target, error);
-            }
-            return static_cast<int>(error);
-        }
-
-        Logger::trace(L"ActionRunner: Successfully launched '{}' with {}", target, action);
-    }
 
     return 0;
 }

src/ActionRunner/actionRunner.vcxproj

@@ -12,7 +12,7 @@
   </PropertyGroup>
   <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
   <PropertyGroup Label="Configuration">
-    <PlatformToolset>v143</PlatformToolset>
+    
   </PropertyGroup>
   <Import Project="..\..\deps\expected.props" />
   <PropertyGroup>

src/Common.Dotnet.FuzzTest.props

@@ -5,6 +5,6 @@
        As a temporary workaround, create a .NET 8 project and use file links 
        to include the code that needs testing. -->
   <PropertyGroup>
-    <TargetFramework>net8.0-windows10.0.19041.0</TargetFramework>
+    <TargetFramework>net8.0-windows10.0.26100.0</TargetFramework>
   </PropertyGroup>
 </Project>

src/PackageIdentity/PackageIdentity.vcxproj

@@ -55,26 +55,26 @@
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'" Label="Configuration">
     <ConfigurationType>Utility</ConfigurationType>
     <UseDebugLibraries>true</UseDebugLibraries>
-    <PlatformToolset>v143</PlatformToolset>
+    
   </PropertyGroup>
 
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'" Label="Configuration">
     <ConfigurationType>Utility</ConfigurationType>
     <UseDebugLibraries>false</UseDebugLibraries>
-    <PlatformToolset>v143</PlatformToolset>
+    
     <WholeProgramOptimization>true</WholeProgramOptimization>
   </PropertyGroup>
 
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|ARM64'" Label="Configuration">
     <ConfigurationType>Utility</ConfigurationType>
     <UseDebugLibraries>true</UseDebugLibraries>
-    <PlatformToolset>v143</PlatformToolset>
+    
   </PropertyGroup>
 
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|ARM64'" Label="Configuration">
     <ConfigurationType>Utility</ConfigurationType>
     <UseDebugLibraries>false</UseDebugLibraries>
-    <PlatformToolset>v143</PlatformToolset>
+    
     <WholeProgramOptimization>true</WholeProgramOptimization>
   </PropertyGroup>
 

src/Update/PowerToys.Update.vcxproj

@@ -12,7 +12,7 @@
   </PropertyGroup>
   <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
   <PropertyGroup Label="Configuration">
-    <PlatformToolset>v143</PlatformToolset>
+    
   </PropertyGroup>
   <Import Project="..\..\deps\expected.props" />
   <PropertyGroup>

src/common/COMUtils/COMUtils.vcxproj

@@ -10,7 +10,7 @@
   <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
   <PropertyGroup Label="Configuration">
     <ConfigurationType>StaticLibrary</ConfigurationType>
-    <PlatformToolset>v143</PlatformToolset>
+    
   </PropertyGroup>
   <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
   <ImportGroup Label="ExtensionSettings">

src/common/CalculatorEngineCommon/CalculatorEngineCommon.vcxproj

@@ -40,7 +40,7 @@
   <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
   <PropertyGroup Label="Configuration">
     <ConfigurationType>DynamicLibrary</ConfigurationType>
-    <PlatformToolset>v143</PlatformToolset>
+    
     <CharacterSet>Unicode</CharacterSet>
     <GenerateManifest>false</GenerateManifest>
   </PropertyGroup>

src/common/CalculatorEngineCommon/ExprtkEvaluator.cpp

@@ -3,9 +3,27 @@
 #include <iomanip>
 #include <iostream>
 #include <sstream>
+#include <cmath>
+#include <limits>
 
 namespace ExprtkCalculator::internal
 {
+    static double factorial(const double n)
+    {
+        // Only allow non-negative integers
+        if (n < 0.0 || std::floor(n) != n)
+        {
+            return std::numeric_limits<double>::quiet_NaN();
+        }
+        return std::tgamma(n + 1.0);
+    }
+
+    static double sign(const double n)
+    {
+        if (n > 0.0) return 1.0;
+        if (n < 0.0) return -1.0;
+        return 0.0;
+    }
 
     std::wstring ToWStringFullPrecision(double value)
     {
@@ -25,6 +43,9 @@ namespace ExprtkCalculator::internal
             symbol_table.add_constant(name, value);
         }
 
+        symbol_table.add_function("factorial", factorial);
+        symbol_table.add_function("sign", sign);
+
         exprtk::expression<double> expression;
         expression.register_symbol_table(symbol_table);
 

src/common/Display/Display.vcxproj

@@ -1,5 +1,6 @@
 <?xml version="1.0" encoding="utf-8"?>
 <Project DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <Import Project="..\..\..\packages\Microsoft.Windows.CppWinRT.2.0.240111.5\build\native\Microsoft.Windows.CppWinRT.props" Condition="Exists('..\..\..\packages\Microsoft.Windows.CppWinRT.2.0.240111.5\build\native\Microsoft.Windows.CppWinRT.props')" />
   <PropertyGroup Label="Globals">
     <VCProjectVersion>16.0</VCProjectVersion>
     <ProjectGuid>{CABA8DFB-823B-4BF2-93AC-3F31984150D9}</ProjectGuid>
@@ -10,7 +11,7 @@
   <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
   <PropertyGroup Label="Configuration">
     <ConfigurationType>StaticLibrary</ConfigurationType>
-    <PlatformToolset>v143</PlatformToolset>
+    
   </PropertyGroup>
   <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
   <ImportGroup Label="ExtensionSettings">
@@ -39,5 +40,18 @@
     <ClCompile Include="monitors.cpp" />
     <ClCompile Include="dpi_aware.cpp" />
   </ItemGroup>
+  <ItemGroup>
+    <None Include="packages.config" />
+  </ItemGroup>
   <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
+  <ImportGroup Label="ExtensionTargets">
+    <Import Project="..\..\..\packages\Microsoft.Windows.CppWinRT.2.0.240111.5\build\native\Microsoft.Windows.CppWinRT.targets" Condition="Exists('..\..\..\packages\Microsoft.Windows.CppWinRT.2.0.240111.5\build\native\Microsoft.Windows.CppWinRT.targets')" />
+  </ImportGroup>
+  <Target Name="EnsureNuGetPackageBuildImports" BeforeTargets="PrepareForBuild">
+    <PropertyGroup>
+      <ErrorText>This project references NuGet package(s) that are missing on this computer. Use NuGet Package Restore to download them.  For more information, see http://go.microsoft.com/fwlink/?LinkID=322105. The missing file is {0}.</ErrorText>
+    </PropertyGroup>
+    <Error Condition="!Exists('..\..\..\packages\Microsoft.Windows.CppWinRT.2.0.240111.5\build\native\Microsoft.Windows.CppWinRT.props')" Text="$([System.String]::Format('$(ErrorText)', '..\..\..\packages\Microsoft.Windows.CppWinRT.2.0.240111.5\build\native\Microsoft.Windows.CppWinRT.props'))" />
+    <Error Condition="!Exists('..\..\..\packages\Microsoft.Windows.CppWinRT.2.0.240111.5\build\native\Microsoft.Windows.CppWinRT.targets')" Text="$([System.String]::Format('$(ErrorText)', '..\..\..\packages\Microsoft.Windows.CppWinRT.2.0.240111.5\build\native\Microsoft.Windows.CppWinRT.targets'))" />
+  </Target>
 </Project>

src/common/Display/packages.config

@@ -0,0 +1,4 @@
+<?xml version="1.0" encoding="utf-8"?>
+<packages>
+  <package id="Microsoft.Windows.CppWinRT" version="2.0.240111.5" targetFramework="native" />
+</packages>

src/common/GPOWrapper/GPOWrapper.vcxproj

@@ -19,7 +19,7 @@
   <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
   <PropertyGroup Label="Configuration">
     <ConfigurationType>DynamicLibrary</ConfigurationType>
-    <PlatformToolset>v143</PlatformToolset>
+    
     <CharacterSet>Unicode</CharacterSet>
     <GenerateManifest>false</GenerateManifest>
     <DesktopCompatible>true</DesktopCompatible>

src/common/SettingsAPI/SettingsAPI.vcxproj

@@ -12,7 +12,7 @@
   <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
   <PropertyGroup Label="Configuration">
     <ConfigurationType>StaticLibrary</ConfigurationType>
-    <PlatformToolset>v143</PlatformToolset>
+    
   </PropertyGroup>
   <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
   <ImportGroup Label="ExtensionSettings">

src/common/Telemetry/EtwTrace/EtwTrace.vcxproj

@@ -11,7 +11,7 @@
   <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
   <PropertyGroup Label="Configuration">
     <ConfigurationType>StaticLibrary</ConfigurationType>
-    <PlatformToolset>v143</PlatformToolset>
+    
   </PropertyGroup>
   <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
   <ImportGroup Label="ExtensionSettings">

src/common/Themes/Themes.vcxproj

@@ -11,7 +11,7 @@
   <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
   <PropertyGroup Label="Configuration">
     <ConfigurationType>StaticLibrary</ConfigurationType>
-    <PlatformToolset>v143</PlatformToolset>
+    
   </PropertyGroup>
   <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
   <ImportGroup Label="ExtensionSettings">

src/common/UnitTests-CommonLib/UnitTests-CommonLib.vcxproj

@@ -13,7 +13,7 @@
   <PropertyGroup Label="Configuration">
     <ConfigurationType>DynamicLibrary</ConfigurationType>
     <UseOfMfc>false</UseOfMfc>
-    <PlatformToolset>v143</PlatformToolset>
+    
     <OutDir>$(SolutionDir)$(Platform)\$(Configuration)\tests\UnitTestsCommonLib\</OutDir>
   </PropertyGroup>
   <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />

src/common/UnitTests-CommonUtils/AppMutex.Tests.cpp

@@ -0,0 +1,120 @@
+#include "pch.h"
+#include "TestHelpers.h"
+#include <appMutex.h>
+
+using namespace Microsoft::VisualStudio::CppUnitTestFramework;
+
+namespace UnitTestsCommonUtils
+{
+    TEST_CLASS(AppMutexTests)
+    {
+    public:
+        TEST_METHOD(CreateAppMutex_ValidName_ReturnsHandle)
+        {
+            std::wstring mutexName = L"TestMutex_" + std::to_wstring(GetCurrentProcessId()) + L"_1";
+            auto handle = createAppMutex(mutexName);
+            Assert::IsNotNull(handle.get());
+        }
+
+        TEST_METHOD(CreateAppMutex_SameName_ReturnsExistingHandle)
+        {
+            std::wstring mutexName = L"TestMutex_" + std::to_wstring(GetCurrentProcessId()) + L"_2";
+
+            auto handle1 = createAppMutex(mutexName);
+            Assert::IsNotNull(handle1.get());
+
+            auto handle2 = createAppMutex(mutexName);
+            Assert::IsNull(handle2.get());
+        }
+
+        TEST_METHOD(CreateAppMutex_DifferentNames_ReturnsDifferentHandles)
+        {
+            std::wstring mutexName1 = L"TestMutex_" + std::to_wstring(GetCurrentProcessId()) + L"_A";
+            std::wstring mutexName2 = L"TestMutex_" + std::to_wstring(GetCurrentProcessId()) + L"_B";
+
+            auto handle1 = createAppMutex(mutexName1);
+            auto handle2 = createAppMutex(mutexName2);
+
+            Assert::IsNotNull(handle1.get());
+            Assert::IsNotNull(handle2.get());
+            Assert::AreNotEqual(handle1.get(), handle2.get());
+        }
+
+        TEST_METHOD(CreateAppMutex_EmptyName_ReturnsHandle)
+        {
+            // Empty name creates unnamed mutex
+            auto handle = createAppMutex(L"");
+            // CreateMutexW with empty string should still work
+            Assert::IsTrue(true);
+            // Test passes regardless - just checking it doesn't crash
+            Assert::IsTrue(true);
+        }
+
+        TEST_METHOD(CreateAppMutex_LongName_ReturnsHandle)
+        {
+            // Create a long mutex name
+            std::wstring mutexName = L"TestMutex_" + std::to_wstring(GetCurrentProcessId()) + L"_";
+            for (int i = 0; i < 50; ++i)
+            {
+                mutexName += L"LongNameSegment";
+            }
+
+            auto handle = createAppMutex(mutexName);
+            // Long names might fail, but shouldn't crash
+            Assert::IsTrue(true);
+        }
+
+        TEST_METHOD(CreateAppMutex_SpecialCharacters_ReturnsHandle)
+        {
+            std::wstring mutexName = L"TestMutex_" + std::to_wstring(GetCurrentProcessId()) + L"_Special!@#$%";
+
+            auto handle = createAppMutex(mutexName);
+            // Some special characters might not be valid in mutex names
+            Assert::IsTrue(true);
+        }
+
+        TEST_METHOD(CreateAppMutex_GlobalPrefix_ReturnsHandle)
+        {
+            // Global prefix for cross-session mutex
+            std::wstring mutexName = L"Global\\TestMutex_" + std::to_wstring(GetCurrentProcessId());
+
+            auto handle = createAppMutex(mutexName);
+            // Might require elevation, but shouldn't crash
+            Assert::IsTrue(true);
+        }
+
+        TEST_METHOD(CreateAppMutex_LocalPrefix_ReturnsHandle)
+        {
+            std::wstring mutexName = L"Local\\TestMutex_" + std::to_wstring(GetCurrentProcessId());
+
+            auto handle = createAppMutex(mutexName);
+            Assert::IsNotNull(handle.get());
+        }
+
+        TEST_METHOD(CreateAppMutex_MultipleCalls_AllSucceed)
+        {
+            std::vector<wil::unique_mutex_nothrow> handles;
+            for (int i = 0; i < 10; ++i)
+            {
+                std::wstring mutexName = L"TestMutex_" + std::to_wstring(GetCurrentProcessId()) +
+                                         L"_Multi_" + std::to_wstring(i);
+                auto handle = createAppMutex(mutexName);
+                Assert::IsNotNull(handle.get());
+                handles.push_back(std::move(handle));
+            }
+        }
+
+        TEST_METHOD(CreateAppMutex_ReleaseAndRecreate_Works)
+        {
+            std::wstring mutexName = L"TestMutex_" + std::to_wstring(GetCurrentProcessId()) + L"_Recreate";
+
+            auto handle1 = createAppMutex(mutexName);
+            Assert::IsNotNull(handle1.get());
+            handle1.reset();
+
+            // After closing, should be able to create again
+            auto handle2 = createAppMutex(mutexName);
+            Assert::IsNotNull(handle2.get());
+        }
+    };
+}

src/common/UnitTests-CommonUtils/ColorUtils.Tests.cpp

@@ -0,0 +1,220 @@
+#include "pch.h"
+#include "TestHelpers.h"
+#include <color.h>
+
+using namespace Microsoft::VisualStudio::CppUnitTestFramework;
+
+namespace UnitTestsCommonUtils
+{
+    TEST_CLASS(ColorUtilsTests)
+    {
+    public:
+        // checkValidRGB tests
+        TEST_METHOD(CheckValidRGB_ValidBlack_ReturnsTrue)
+        {
+            uint8_t r, g, b;
+            bool result = checkValidRGB(L"#000000", &r, &g, &b);
+            Assert::IsTrue(result);
+            Assert::AreEqual(static_cast<uint8_t>(0), r);
+            Assert::AreEqual(static_cast<uint8_t>(0), g);
+            Assert::AreEqual(static_cast<uint8_t>(0), b);
+        }
+
+        TEST_METHOD(CheckValidRGB_ValidWhite_ReturnsTrue)
+        {
+            uint8_t r, g, b;
+            bool result = checkValidRGB(L"#FFFFFF", &r, &g, &b);
+            Assert::IsTrue(result);
+            Assert::AreEqual(static_cast<uint8_t>(255), r);
+            Assert::AreEqual(static_cast<uint8_t>(255), g);
+            Assert::AreEqual(static_cast<uint8_t>(255), b);
+        }
+
+        TEST_METHOD(CheckValidRGB_ValidRed_ReturnsTrue)
+        {
+            uint8_t r, g, b;
+            bool result = checkValidRGB(L"#FF0000", &r, &g, &b);
+            Assert::IsTrue(result);
+            Assert::AreEqual(static_cast<uint8_t>(255), r);
+            Assert::AreEqual(static_cast<uint8_t>(0), g);
+            Assert::AreEqual(static_cast<uint8_t>(0), b);
+        }
+
+        TEST_METHOD(CheckValidRGB_ValidGreen_ReturnsTrue)
+        {
+            uint8_t r, g, b;
+            bool result = checkValidRGB(L"#00FF00", &r, &g, &b);
+            Assert::IsTrue(result);
+            Assert::AreEqual(static_cast<uint8_t>(0), r);
+            Assert::AreEqual(static_cast<uint8_t>(255), g);
+            Assert::AreEqual(static_cast<uint8_t>(0), b);
+        }
+
+        TEST_METHOD(CheckValidRGB_ValidBlue_ReturnsTrue)
+        {
+            uint8_t r, g, b;
+            bool result = checkValidRGB(L"#0000FF", &r, &g, &b);
+            Assert::IsTrue(result);
+            Assert::AreEqual(static_cast<uint8_t>(0), r);
+            Assert::AreEqual(static_cast<uint8_t>(0), g);
+            Assert::AreEqual(static_cast<uint8_t>(255), b);
+        }
+
+        TEST_METHOD(CheckValidRGB_ValidMixed_ReturnsTrue)
+        {
+            uint8_t r, g, b;
+            bool result = checkValidRGB(L"#AB12CD", &r, &g, &b);
+            Assert::IsTrue(result);
+            Assert::AreEqual(static_cast<uint8_t>(0xAB), r);
+            Assert::AreEqual(static_cast<uint8_t>(0x12), g);
+            Assert::AreEqual(static_cast<uint8_t>(0xCD), b);
+        }
+
+        TEST_METHOD(CheckValidRGB_MissingHash_ReturnsFalse)
+        {
+            uint8_t r, g, b;
+            bool result = checkValidRGB(L"FFFFFF", &r, &g, &b);
+            Assert::IsFalse(result);
+        }
+
+        TEST_METHOD(CheckValidRGB_TooShort_ReturnsFalse)
+        {
+            uint8_t r, g, b;
+            bool result = checkValidRGB(L"#FFF", &r, &g, &b);
+            Assert::IsFalse(result);
+        }
+
+        TEST_METHOD(CheckValidRGB_TooLong_ReturnsFalse)
+        {
+            uint8_t r, g, b;
+            bool result = checkValidRGB(L"#FFFFFFFF", &r, &g, &b);
+            Assert::IsFalse(result);
+        }
+
+        TEST_METHOD(CheckValidRGB_InvalidChars_ReturnsFalse)
+        {
+            uint8_t r, g, b;
+            bool result = checkValidRGB(L"#GGHHII", &r, &g, &b);
+            Assert::IsFalse(result);
+        }
+
+        TEST_METHOD(CheckValidRGB_LowercaseInvalid_ReturnsFalse)
+        {
+            uint8_t r, g, b;
+            bool result = checkValidRGB(L"#ffffff", &r, &g, &b);
+            Assert::IsFalse(result);
+        }
+
+        TEST_METHOD(CheckValidRGB_EmptyString_ReturnsFalse)
+        {
+            uint8_t r, g, b;
+            bool result = checkValidRGB(L"", &r, &g, &b);
+            Assert::IsFalse(result);
+        }
+
+        TEST_METHOD(CheckValidRGB_OnlyHash_ReturnsFalse)
+        {
+            uint8_t r, g, b;
+            bool result = checkValidRGB(L"#", &r, &g, &b);
+            Assert::IsFalse(result);
+        }
+
+        // checkValidARGB tests
+        TEST_METHOD(CheckValidARGB_ValidBlackOpaque_ReturnsTrue)
+        {
+            uint8_t a, r, g, b;
+            bool result = checkValidARGB(L"#FF000000", &a, &r, &g, &b);
+            Assert::IsTrue(result);
+            Assert::AreEqual(static_cast<uint8_t>(255), a);
+            Assert::AreEqual(static_cast<uint8_t>(0), r);
+            Assert::AreEqual(static_cast<uint8_t>(0), g);
+            Assert::AreEqual(static_cast<uint8_t>(0), b);
+        }
+
+        TEST_METHOD(CheckValidARGB_ValidWhiteOpaque_ReturnsTrue)
+        {
+            uint8_t a, r, g, b;
+            bool result = checkValidARGB(L"#FFFFFFFF", &a, &r, &g, &b);
+            Assert::IsTrue(result);
+            Assert::AreEqual(static_cast<uint8_t>(255), a);
+            Assert::AreEqual(static_cast<uint8_t>(255), r);
+            Assert::AreEqual(static_cast<uint8_t>(255), g);
+            Assert::AreEqual(static_cast<uint8_t>(255), b);
+        }
+
+        TEST_METHOD(CheckValidARGB_ValidTransparent_ReturnsTrue)
+        {
+            uint8_t a, r, g, b;
+            bool result = checkValidARGB(L"#00FFFFFF", &a, &r, &g, &b);
+            Assert::IsTrue(result);
+            Assert::AreEqual(static_cast<uint8_t>(0), a);
+            Assert::AreEqual(static_cast<uint8_t>(255), r);
+            Assert::AreEqual(static_cast<uint8_t>(255), g);
+            Assert::AreEqual(static_cast<uint8_t>(255), b);
+        }
+
+        TEST_METHOD(CheckValidARGB_ValidSemiTransparent_ReturnsTrue)
+        {
+            uint8_t a, r, g, b;
+            bool result = checkValidARGB(L"#80FF0000", &a, &r, &g, &b);
+            Assert::IsTrue(result);
+            Assert::AreEqual(static_cast<uint8_t>(0x80), a);
+            Assert::AreEqual(static_cast<uint8_t>(255), r);
+            Assert::AreEqual(static_cast<uint8_t>(0), g);
+            Assert::AreEqual(static_cast<uint8_t>(0), b);
+        }
+
+        TEST_METHOD(CheckValidARGB_ValidMixed_ReturnsTrue)
+        {
+            uint8_t a, r, g, b;
+            bool result = checkValidARGB(L"#12345678", &a, &r, &g, &b);
+            Assert::IsTrue(result);
+            Assert::AreEqual(static_cast<uint8_t>(0x12), a);
+            Assert::AreEqual(static_cast<uint8_t>(0x34), r);
+            Assert::AreEqual(static_cast<uint8_t>(0x56), g);
+            Assert::AreEqual(static_cast<uint8_t>(0x78), b);
+        }
+
+        TEST_METHOD(CheckValidARGB_MissingHash_ReturnsFalse)
+        {
+            uint8_t a, r, g, b;
+            bool result = checkValidARGB(L"FFFFFFFF", &a, &r, &g, &b);
+            Assert::IsFalse(result);
+        }
+
+        TEST_METHOD(CheckValidARGB_TooShort_ReturnsFalse)
+        {
+            uint8_t a, r, g, b;
+            bool result = checkValidARGB(L"#FFFFFF", &a, &r, &g, &b);
+            Assert::IsFalse(result);
+        }
+
+        TEST_METHOD(CheckValidARGB_TooLong_ReturnsFalse)
+        {
+            uint8_t a, r, g, b;
+            bool result = checkValidARGB(L"#FFFFFFFFFF", &a, &r, &g, &b);
+            Assert::IsFalse(result);
+        }
+
+        TEST_METHOD(CheckValidARGB_InvalidChars_ReturnsFalse)
+        {
+            uint8_t a, r, g, b;
+            bool result = checkValidARGB(L"#GGHHIIJJ", &a, &r, &g, &b);
+            Assert::IsFalse(result);
+        }
+
+        TEST_METHOD(CheckValidARGB_LowercaseInvalid_ReturnsFalse)
+        {
+            uint8_t a, r, g, b;
+            bool result = checkValidARGB(L"#ffffffff", &a, &r, &g, &b);
+            Assert::IsFalse(result);
+        }
+
+        TEST_METHOD(CheckValidARGB_EmptyString_ReturnsFalse)
+        {
+            uint8_t a, r, g, b;
+            bool result = checkValidARGB(L"", &a, &r, &g, &b);
+            Assert::IsFalse(result);
+        }
+    };
+}

src/common/UnitTests-CommonUtils/ComObjectFactory.Tests.cpp

@@ -0,0 +1,228 @@
+#include "pch.h"
+#include "TestHelpers.h"
+#include <com_object_factory.h>
+
+using namespace Microsoft::VisualStudio::CppUnitTestFramework;
+
+namespace UnitTestsCommonUtils
+{
+    // Test COM object for testing the factory
+    class TestComObject : public IUnknown
+    {
+    public:
+        TestComObject() : m_refCount(1) {}
+
+        HRESULT STDMETHODCALLTYPE QueryInterface(REFIID riid, void** ppvObject) override
+        {
+            if (riid == IID_IUnknown)
+            {
+                *ppvObject = static_cast<IUnknown*>(this);
+                AddRef();
+                return S_OK;
+            }
+            *ppvObject = nullptr;
+            return E_NOINTERFACE;
+        }
+
+        ULONG STDMETHODCALLTYPE AddRef() override
+        {
+            return InterlockedIncrement(&m_refCount);
+        }
+
+        ULONG STDMETHODCALLTYPE Release() override
+        {
+            ULONG count = InterlockedDecrement(&m_refCount);
+            if (count == 0)
+            {
+                delete this;
+            }
+            return count;
+        }
+
+    private:
+        LONG m_refCount;
+    };
+
+    TEST_CLASS(ComObjectFactoryTests)
+    {
+    public:
+        TEST_METHOD(ComObjectFactory_Construction_DoesNotCrash)
+        {
+            com_object_factory<TestComObject> factory;
+            Assert::IsTrue(true);
+        }
+
+        TEST_METHOD(ComObjectFactory_QueryInterface_IUnknown_Succeeds)
+        {
+            com_object_factory<TestComObject> factory;
+            IUnknown* pUnknown = nullptr;
+
+            HRESULT hr = factory.QueryInterface(IID_IUnknown, reinterpret_cast<void**>(&pUnknown));
+
+            Assert::AreEqual(S_OK, hr);
+            Assert::IsNotNull(pUnknown);
+
+            if (pUnknown)
+            {
+                pUnknown->Release();
+            }
+        }
+
+        TEST_METHOD(ComObjectFactory_QueryInterface_IClassFactory_Succeeds)
+        {
+            com_object_factory<TestComObject> factory;
+            IClassFactory* pFactory = nullptr;
+
+            HRESULT hr = factory.QueryInterface(IID_IClassFactory, reinterpret_cast<void**>(&pFactory));
+
+            Assert::AreEqual(S_OK, hr);
+            Assert::IsNotNull(pFactory);
+
+            if (pFactory)
+            {
+                pFactory->Release();
+            }
+        }
+
+        TEST_METHOD(ComObjectFactory_QueryInterface_InvalidInterface_Fails)
+        {
+            com_object_factory<TestComObject> factory;
+            void* pInterface = nullptr;
+
+            // Random GUID that we don't support
+            GUID randomGuid = { 0x12345678, 0x1234, 0x1234, { 0x12, 0x34, 0x56, 0x78, 0x9A, 0xBC, 0xDE, 0xF0 } };
+            HRESULT hr = factory.QueryInterface(randomGuid, &pInterface);
+
+            Assert::AreEqual(E_NOINTERFACE, hr);
+            Assert::IsNull(pInterface);
+        }
+
+        TEST_METHOD(ComObjectFactory_AddRef_IncreasesRefCount)
+        {
+            com_object_factory<TestComObject> factory;
+
+            ULONG count1 = factory.AddRef();
+            ULONG count2 = factory.AddRef();
+
+            Assert::IsTrue(count2 > count1);
+
+            // Clean up
+            factory.Release();
+            factory.Release();
+        }
+
+        TEST_METHOD(ComObjectFactory_Release_DecreasesRefCount)
+        {
+            com_object_factory<TestComObject> factory;
+
+            factory.AddRef();
+            factory.AddRef();
+            ULONG count1 = factory.Release();
+            ULONG count2 = factory.Release();
+
+            Assert::IsTrue(count2 < count1);
+        }
+
+        TEST_METHOD(ComObjectFactory_CreateInstance_NoAggregation_Succeeds)
+        {
+            com_object_factory<TestComObject> factory;
+            IUnknown* pObj = nullptr;
+
+            HRESULT hr = factory.CreateInstance(nullptr, IID_IUnknown, reinterpret_cast<void**>(&pObj));
+
+            Assert::AreEqual(S_OK, hr);
+            Assert::IsNotNull(pObj);
+
+            if (pObj)
+            {
+                pObj->Release();
+            }
+        }
+
+        TEST_METHOD(ComObjectFactory_CreateInstance_WithAggregation_Fails)
+        {
+            com_object_factory<TestComObject> factory;
+            TestComObject outer;
+            IUnknown* pObj = nullptr;
+
+            // Aggregation should fail for our simple test object
+            HRESULT hr = factory.CreateInstance(&outer, IID_IUnknown, reinterpret_cast<void**>(&pObj));
+
+            Assert::AreEqual(CLASS_E_NOAGGREGATION, hr);
+            Assert::IsNull(pObj);
+        }
+
+        TEST_METHOD(ComObjectFactory_CreateInstance_NullOutput_Fails)
+        {
+            com_object_factory<TestComObject> factory;
+
+            HRESULT hr = factory.CreateInstance(nullptr, IID_IUnknown, nullptr);
+
+            Assert::AreEqual(E_POINTER, hr);
+        }
+
+        TEST_METHOD(ComObjectFactory_LockServer_Lock_Succeeds)
+        {
+            com_object_factory<TestComObject> factory;
+
+            HRESULT hr = factory.LockServer(TRUE);
+            Assert::AreEqual(S_OK, hr);
+
+            // Unlock
+            factory.LockServer(FALSE);
+        }
+
+        TEST_METHOD(ComObjectFactory_LockServer_Unlock_Succeeds)
+        {
+            com_object_factory<TestComObject> factory;
+
+            factory.LockServer(TRUE);
+            HRESULT hr = factory.LockServer(FALSE);
+
+            Assert::AreEqual(S_OK, hr);
+        }
+
+        TEST_METHOD(ComObjectFactory_LockServer_MultipleLocks_Work)
+        {
+            com_object_factory<TestComObject> factory;
+
+            factory.LockServer(TRUE);
+            factory.LockServer(TRUE);
+            factory.LockServer(TRUE);
+
+            factory.LockServer(FALSE);
+            factory.LockServer(FALSE);
+            HRESULT hr = factory.LockServer(FALSE);
+
+            Assert::AreEqual(S_OK, hr);
+        }
+
+        // Thread safety tests
+        TEST_METHOD(ComObjectFactory_ConcurrentCreateInstance_Works)
+        {
+            com_object_factory<TestComObject> factory;
+            std::vector<std::thread> threads;
+            std::atomic<int> successCount{ 0 };
+
+            for (int i = 0; i < 10; ++i)
+            {
+                threads.emplace_back([&factory, &successCount]() {
+                    IUnknown* pObj = nullptr;
+                    HRESULT hr = factory.CreateInstance(nullptr, IID_IUnknown, reinterpret_cast<void**>(&pObj));
+                    if (SUCCEEDED(hr) && pObj)
+                    {
+                        successCount++;
+                        pObj->Release();
+                    }
+                });
+            }
+
+            for (auto& t : threads)
+            {
+                t.join();
+            }
+
+            Assert::AreEqual(10, successCount.load());
+        }
+    };
+}

src/common/UnitTests-CommonUtils/Elevation.Tests.cpp

@@ -0,0 +1,146 @@
+#include "pch.h"
+#include "TestHelpers.h"
+#include <elevation.h>
+
+using namespace Microsoft::VisualStudio::CppUnitTestFramework;
+
+namespace UnitTestsCommonUtils
+{
+    TEST_CLASS(ElevationTests)
+    {
+    public:
+        // is_process_elevated tests
+        TEST_METHOD(IsProcessElevated_ReturnsBoolean)
+        {
+            bool result = is_process_elevated(false);
+            Assert::IsTrue(result == true || result == false);
+        }
+
+        TEST_METHOD(IsProcessElevated_CachedValue_ReturnsSameResult)
+        {
+            bool result1 = is_process_elevated(true);
+            bool result2 = is_process_elevated(true);
+
+            // Cached value should be consistent
+            Assert::AreEqual(result1, result2);
+        }
+
+        TEST_METHOD(IsProcessElevated_UncachedValue_ReturnsBoolean)
+        {
+            bool result = is_process_elevated(false);
+            Assert::IsTrue(result == true || result == false);
+        }
+
+        TEST_METHOD(IsProcessElevated_CachedAndUncached_AreConsistent)
+        {
+            // Both should return the same value for the same process
+            bool cached = is_process_elevated(true);
+            bool uncached = is_process_elevated(false);
+
+            Assert::AreEqual(cached, uncached);
+        }
+
+        // check_user_is_admin tests
+        TEST_METHOD(CheckUserIsAdmin_ReturnsBoolean)
+        {
+            bool result = check_user_is_admin();
+            Assert::IsTrue(result == true || result == false);
+        }
+
+        TEST_METHOD(CheckUserIsAdmin_ConsistentResults)
+        {
+            bool result1 = check_user_is_admin();
+            bool result2 = check_user_is_admin();
+            bool result3 = check_user_is_admin();
+
+            Assert::AreEqual(result1, result2);
+            Assert::AreEqual(result2, result3);
+        }
+
+        // Relationship between elevation and admin
+        TEST_METHOD(ElevationAndAdmin_Relationship)
+        {
+            bool elevated = is_process_elevated(false);
+            bool admin = check_user_is_admin();
+            (void)admin;
+
+            // If elevated, user should typically be admin
+            // But user can be admin without process being elevated
+            if (elevated)
+            {
+                // Elevated process usually means admin user
+                // (though there are edge cases)
+            }
+            // Just verify both functions return without crashing
+            Assert::IsTrue(true);
+        }
+
+        // IsProcessOfWindowElevated tests
+        TEST_METHOD(IsProcessOfWindowElevated_DesktopWindow_ReturnsBoolean)
+        {
+            HWND desktop = GetDesktopWindow();
+            if (desktop)
+            {
+                bool result = IsProcessOfWindowElevated(desktop);
+                Assert::IsTrue(result == true || result == false);
+            }
+            Assert::IsTrue(true);
+        }
+
+        TEST_METHOD(IsProcessOfWindowElevated_InvalidHwnd_DoesNotCrash)
+        {
+            bool result = IsProcessOfWindowElevated(nullptr);
+            // Should handle null HWND gracefully
+            Assert::IsTrue(result == true || result == false);
+        }
+
+        // ProcessInfo struct tests
+        TEST_METHOD(ProcessInfo_DefaultConstruction)
+        {
+            ProcessInfo info{};
+            Assert::AreEqual(static_cast<DWORD>(0), info.processID);
+        }
+
+        // Thread safety tests
+        TEST_METHOD(IsProcessElevated_ThreadSafe)
+        {
+            std::vector<std::thread> threads;
+            std::atomic<int> successCount{ 0 };
+
+            for (int i = 0; i < 10; ++i)
+            {
+                threads.emplace_back([&successCount]() {
+                    for (int j = 0; j < 10; ++j)
+                    {
+                        is_process_elevated(j % 2 == 0);
+                        successCount++;
+                    }
+                });
+            }
+
+            for (auto& t : threads)
+            {
+                t.join();
+            }
+
+            Assert::AreEqual(100, successCount.load());
+        }
+
+        // Performance of cached value
+        TEST_METHOD(IsProcessElevated_CachedPerformance)
+        {
+            auto start = std::chrono::high_resolution_clock::now();
+
+            for (int i = 0; i < 10000; ++i)
+            {
+                is_process_elevated(true);
+            }
+
+            auto end = std::chrono::high_resolution_clock::now();
+            auto duration = std::chrono::duration_cast<std::chrono::milliseconds>(end - start);
+
+            // Cached calls should be very fast
+            Assert::IsTrue(duration.count() < 1000);
+        }
+    };
+}

src/common/UnitTests-CommonUtils/ExcludedApps.Tests.cpp

@@ -0,0 +1,182 @@
+#include "pch.h"
+#include "TestHelpers.h"
+#include <excluded_apps.h>
+
+using namespace Microsoft::VisualStudio::CppUnitTestFramework;
+
+namespace UnitTestsCommonUtils
+{
+    TEST_CLASS(ExcludedAppsTests)
+    {
+    public:
+        // find_app_name_in_path tests
+        TEST_METHOD(FindAppNameInPath_ExactMatch_ReturnsTrue)
+        {
+            std::wstring path = L"C:\\Program Files\\App\\notepad.exe";
+            std::vector<std::wstring> apps = { L"notepad.exe" };
+            Assert::IsTrue(find_app_name_in_path(path, apps));
+        }
+
+        TEST_METHOD(FindAppNameInPath_NoMatch_ReturnsFalse)
+        {
+            std::wstring path = L"C:\\Program Files\\App\\notepad.exe";
+            std::vector<std::wstring> apps = { L"calc.exe" };
+            Assert::IsFalse(find_app_name_in_path(path, apps));
+        }
+
+        TEST_METHOD(FindAppNameInPath_MultipleApps_FindsMatch)
+        {
+            std::wstring path = L"C:\\Program Files\\App\\notepad.exe";
+            std::vector<std::wstring> apps = { L"calc.exe", L"notepad.exe", L"word.exe" };
+            Assert::IsTrue(find_app_name_in_path(path, apps));
+        }
+
+        TEST_METHOD(FindAppNameInPath_EmptyPath_ReturnsFalse)
+        {
+            std::wstring path = L"";
+            std::vector<std::wstring> apps = { L"notepad.exe" };
+            Assert::IsFalse(find_app_name_in_path(path, apps));
+        }
+
+        TEST_METHOD(FindAppNameInPath_EmptyApps_ReturnsFalse)
+        {
+            std::wstring path = L"C:\\Program Files\\App\\notepad.exe";
+            std::vector<std::wstring> apps = {};
+            Assert::IsFalse(find_app_name_in_path(path, apps));
+        }
+
+        TEST_METHOD(FindAppNameInPath_PartialMatchInFolder_ReturnsFalse)
+        {
+            // "notepad" appears in folder name but not as the exe name
+            std::wstring path = L"C:\\notepad\\other.exe";
+            std::vector<std::wstring> apps = { L"notepad.exe" };
+            Assert::IsFalse(find_app_name_in_path(path, apps));
+        }
+
+        TEST_METHOD(FindAppNameInPath_CaseSensitive_ReturnsFalse)
+        {
+            std::wstring path = L"C:\\Program Files\\App\\NOTEPAD.EXE";
+            std::vector<std::wstring> apps = { L"notepad.exe" };
+            // The function does rfind which is case-sensitive
+            Assert::IsFalse(find_app_name_in_path(path, apps));
+        }
+
+        TEST_METHOD(FindAppNameInPath_MatchWithDifferentExtension_ReturnsFalse)
+        {
+            std::wstring path = L"C:\\Program Files\\App\\notepad.com";
+            std::vector<std::wstring> apps = { L"notepad.exe" };
+            Assert::IsFalse(find_app_name_in_path(path, apps));
+        }
+
+        TEST_METHOD(FindAppNameInPath_MatchAtEndOfPath_ReturnsTrue)
+        {
+            std::wstring path = L"C:\\Windows\\System32\\notepad.exe";
+            std::vector<std::wstring> apps = { L"notepad.exe" };
+            Assert::IsTrue(find_app_name_in_path(path, apps));
+        }
+
+        TEST_METHOD(FindAppNameInPath_UNCPath_Works)
+        {
+            std::wstring path = L"\\\\server\\share\\folder\\app.exe";
+            std::vector<std::wstring> apps = { L"app.exe" };
+            Assert::IsTrue(find_app_name_in_path(path, apps));
+        }
+
+        // find_folder_in_path tests
+        TEST_METHOD(FindFolderInPath_FolderExists_ReturnsTrue)
+        {
+            std::wstring path = L"C:\\Program Files\\MyApp\\app.exe";
+            std::vector<std::wstring> folders = { L"Program Files" };
+            Assert::IsTrue(find_folder_in_path(path, folders));
+        }
+
+        TEST_METHOD(FindFolderInPath_FolderNotExists_ReturnsFalse)
+        {
+            std::wstring path = L"C:\\Windows\\System32\\app.exe";
+            std::vector<std::wstring> folders = { L"Program Files" };
+            Assert::IsFalse(find_folder_in_path(path, folders));
+        }
+
+        TEST_METHOD(FindFolderInPath_MultipleFolders_FindsMatch)
+        {
+            std::wstring path = L"C:\\Windows\\System32\\app.exe";
+            std::vector<std::wstring> folders = { L"Program Files", L"System32", L"Users" };
+            Assert::IsTrue(find_folder_in_path(path, folders));
+        }
+
+        TEST_METHOD(FindFolderInPath_EmptyPath_ReturnsFalse)
+        {
+            std::wstring path = L"";
+            std::vector<std::wstring> folders = { L"Windows" };
+            Assert::IsFalse(find_folder_in_path(path, folders));
+        }
+
+        TEST_METHOD(FindFolderInPath_EmptyFolders_ReturnsFalse)
+        {
+            std::wstring path = L"C:\\Windows\\app.exe";
+            std::vector<std::wstring> folders = {};
+            Assert::IsFalse(find_folder_in_path(path, folders));
+        }
+
+        TEST_METHOD(FindFolderInPath_PartialMatch_ReturnsTrue)
+        {
+            // find_folder_in_path uses rfind which finds substrings
+            std::wstring path = L"C:\\Windows\\System32\\app.exe";
+            std::vector<std::wstring> folders = { L"System" };
+            Assert::IsTrue(find_folder_in_path(path, folders));
+        }
+
+        TEST_METHOD(FindFolderInPath_NestedFolder_ReturnsTrue)
+        {
+            std::wstring path = L"C:\\Program Files\\Company\\Product\\bin\\app.exe";
+            std::vector<std::wstring> folders = { L"Product" };
+            Assert::IsTrue(find_folder_in_path(path, folders));
+        }
+
+        TEST_METHOD(FindFolderInPath_RootDrive_ReturnsTrue)
+        {
+            std::wstring path = L"C:\\folder\\app.exe";
+            std::vector<std::wstring> folders = { L"C:\\" };
+            Assert::IsTrue(find_folder_in_path(path, folders));
+        }
+
+        TEST_METHOD(FindFolderInPath_UNCPath_Works)
+        {
+            std::wstring path = L"\\\\server\\share\\folder\\app.exe";
+            std::vector<std::wstring> folders = { L"share" };
+            Assert::IsTrue(find_folder_in_path(path, folders));
+        }
+
+        TEST_METHOD(FindFolderInPath_CaseSensitive_ReturnsFalse)
+        {
+            std::wstring path = L"C:\\WINDOWS\\app.exe";
+            std::vector<std::wstring> folders = { L"windows" };
+            // rfind is case-sensitive
+            Assert::IsFalse(find_folder_in_path(path, folders));
+        }
+
+        // Edge case tests
+        TEST_METHOD(FindAppNameInPath_AppNameInMiddleOfPath_HandlesCorrectly)
+        {
+            // The app name appears both in folder and as filename
+            std::wstring path = L"C:\\notepad\\bin\\notepad.exe";
+            std::vector<std::wstring> apps = { L"notepad.exe" };
+            Assert::IsTrue(find_app_name_in_path(path, apps));
+        }
+
+        TEST_METHOD(FindAppNameInPath_JustFilename_ReturnsFalse)
+        {
+            std::wstring path = L"notepad.exe";
+            std::vector<std::wstring> apps = { L"notepad.exe" };
+            // find_app_name_in_path expects a path separator to validate the executable segment
+            Assert::IsFalse(find_app_name_in_path(path, apps));
+        }
+
+        TEST_METHOD(FindFolderInPath_JustFilename_ReturnsFalse)
+        {
+            std::wstring path = L"app.exe";
+            std::vector<std::wstring> folders = { L"Windows" };
+            Assert::IsFalse(find_folder_in_path(path, folders));
+        }
+    };
+}

src/common/UnitTests-CommonUtils/Exec.Tests.cpp

@@ -0,0 +1,148 @@
+#include "pch.h"
+#include "TestHelpers.h"
+#include <exec.h>
+#include <cctype>
+
+using namespace Microsoft::VisualStudio::CppUnitTestFramework;
+
+namespace UnitTestsCommonUtils
+{
+    TEST_CLASS(ExecTests)
+    {
+    public:
+        TEST_METHOD(ExecAndReadOutput_EchoCommand_ReturnsOutput)
+        {
+            auto result = exec_and_read_output(L"cmd /c echo hello", 5000);
+
+            Assert::IsTrue(result.has_value());
+            Assert::IsFalse(result->empty());
+            // Output should contain "hello"
+            Assert::IsTrue(result->find("hello") != std::string::npos);
+        }
+
+        TEST_METHOD(ExecAndReadOutput_WhereCommand_ReturnsPath)
+        {
+            auto result = exec_and_read_output(L"where cmd", 5000);
+
+            Assert::IsTrue(result.has_value());
+            Assert::IsFalse(result->empty());
+            // Should contain path to cmd.exe
+            Assert::IsTrue(result->find("cmd") != std::string::npos);
+        }
+
+        TEST_METHOD(ExecAndReadOutput_DirCommand_ReturnsListing)
+        {
+            auto result = exec_and_read_output(L"cmd /c dir /b C:\\Windows", 5000);
+
+            Assert::IsTrue(result.has_value());
+            Assert::IsFalse(result->empty());
+            // Should contain some common Windows folder names
+            std::string output = *result;
+            std::transform(output.begin(), output.end(), output.begin(), [](unsigned char ch) { return static_cast<char>(std::tolower(ch)); });
+            Assert::IsTrue(output.find("system32") != std::string::npos ||
+                          output.find("system") != std::string::npos);
+        }
+
+        TEST_METHOD(ExecAndReadOutput_InvalidCommand_ReturnsEmptyOrError)
+        {
+            auto result = exec_and_read_output(L"nonexistentcommand12345", 5000);
+
+            // Invalid command should either return nullopt or an error message
+            Assert::IsTrue(!result.has_value() || result->empty() ||
+                          result->find("not recognized") != std::string::npos ||
+                          result->find("error") != std::string::npos);
+        }
+
+        TEST_METHOD(ExecAndReadOutput_EmptyCommand_DoesNotCrash)
+        {
+            auto result = exec_and_read_output(L"", 5000);
+            // Should handle empty command gracefully
+            Assert::IsTrue(true);
+        }
+
+        TEST_METHOD(ExecAndReadOutput_TimeoutExpires_ReturnsAvailableOutput)
+        {
+            // Use a command that produces output slowly
+            // ping localhost will run for a while
+            auto start = std::chrono::steady_clock::now();
+
+            // Very short timeout
+            auto result = exec_and_read_output(L"ping localhost -n 10", 100);
+
+            auto elapsed = std::chrono::duration_cast<std::chrono::milliseconds>(
+                std::chrono::steady_clock::now() - start);
+
+            // Should return within reasonable time
+            Assert::IsTrue(elapsed.count() < 5000);
+        }
+
+        TEST_METHOD(ExecAndReadOutput_MultilineOutput_PreservesLines)
+        {
+            auto result = exec_and_read_output(L"cmd /c \"echo line1 & echo line2 & echo line3\"", 5000);
+
+            Assert::IsTrue(result.has_value());
+            // Should contain multiple lines
+            Assert::IsTrue(result->find("line1") != std::string::npos);
+            Assert::IsTrue(result->find("line2") != std::string::npos);
+            Assert::IsTrue(result->find("line3") != std::string::npos);
+        }
+
+        TEST_METHOD(ExecAndReadOutput_UnicodeOutput_Works)
+        {
+            // Echo a simple ASCII string (Unicode test depends on system codepage)
+            auto result = exec_and_read_output(L"cmd /c echo test123", 5000);
+
+            Assert::IsTrue(result.has_value());
+            Assert::IsTrue(result->find("test123") != std::string::npos);
+        }
+
+        TEST_METHOD(ExecAndReadOutput_LongTimeout_Works)
+        {
+            auto result = exec_and_read_output(L"cmd /c echo test", 60000);
+
+            Assert::IsTrue(result.has_value());
+            Assert::IsTrue(result->find("test") != std::string::npos);
+        }
+
+        TEST_METHOD(ExecAndReadOutput_QuotedArguments_Work)
+        {
+            auto result = exec_and_read_output(L"cmd /c echo \"hello world\"", 5000);
+
+            Assert::IsTrue(result.has_value());
+            Assert::IsTrue(result->find("hello") != std::string::npos);
+        }
+
+        TEST_METHOD(ExecAndReadOutput_EnvironmentVariable_Expanded)
+        {
+            auto result = exec_and_read_output(L"cmd /c echo %USERNAME%", 5000);
+
+            Assert::IsTrue(result.has_value());
+            // Should not contain the literal %USERNAME% but the actual username
+            // Or if not expanded, still should not crash
+            Assert::IsFalse(result->empty());
+        }
+
+        TEST_METHOD(ExecAndReadOutput_ExitCode_CommandFails)
+        {
+            // Command that exits with error
+            auto result = exec_and_read_output(L"cmd /c exit 1", 5000);
+
+            // Should still return something (possibly empty)
+            // Just verify it doesn't crash
+            Assert::IsTrue(true);
+        }
+
+        TEST_METHOD(ExecAndReadOutput_ZeroTimeout_DoesNotHang)
+        {
+            auto start = std::chrono::steady_clock::now();
+
+            auto result = exec_and_read_output(L"cmd /c echo test", 0);
+
+            auto elapsed = std::chrono::duration_cast<std::chrono::milliseconds>(
+                std::chrono::steady_clock::now() - start);
+
+            // Should complete quickly with zero timeout
+            Assert::IsTrue(elapsed.count() < 5000);
+        }
+    };
+}

src/common/UnitTests-CommonUtils/GameMode.Tests.cpp

@@ -0,0 +1,68 @@
+#include "pch.h"
+#include "TestHelpers.h"
+#include <game_mode.h>
+
+using namespace Microsoft::VisualStudio::CppUnitTestFramework;
+
+namespace UnitTestsCommonUtils
+{
+    TEST_CLASS(GameModeTests)
+    {
+    public:
+        TEST_METHOD(DetectGameMode_ReturnsBoolean)
+        {
+            // This function queries Windows game mode status
+            bool result = detect_game_mode();
+
+            // Result depends on current system state, but should be a valid boolean
+            Assert::IsTrue(result == true || result == false);
+        }
+
+        TEST_METHOD(DetectGameMode_ConsistentResults)
+        {
+            // Multiple calls should return consistent results (unless game mode changes)
+            bool result1 = detect_game_mode();
+            bool result2 = detect_game_mode();
+            bool result3 = detect_game_mode();
+
+            // Results should be consistent across rapid calls
+            Assert::AreEqual(result1, result2);
+            Assert::AreEqual(result2, result3);
+        }
+
+        TEST_METHOD(DetectGameMode_DoesNotCrash)
+        {
+            // Call multiple times to ensure no crash or memory leak
+            for (int i = 0; i < 100; ++i)
+            {
+                detect_game_mode();
+            }
+            Assert::IsTrue(true);
+        }
+
+        TEST_METHOD(DetectGameMode_ThreadSafe)
+        {
+            // Test that calling from multiple threads is safe
+            std::vector<std::thread> threads;
+            std::atomic<int> successCount{ 0 };
+
+            for (int i = 0; i < 10; ++i)
+            {
+                threads.emplace_back([&successCount]() {
+                    for (int j = 0; j < 10; ++j)
+                    {
+                        detect_game_mode();
+                        successCount++;
+                    }
+                });
+            }
+
+            for (auto& t : threads)
+            {
+                t.join();
+            }
+
+            Assert::AreEqual(100, successCount.load());
+        }
+    };
+}

src/common/UnitTests-CommonUtils/Gpo.Tests.cpp

@@ -0,0 +1,218 @@
+#include "pch.h"
+#include "TestHelpers.h"
+#include <gpo.h>
+
+using namespace Microsoft::VisualStudio::CppUnitTestFramework;
+using namespace powertoys_gpo;
+
+namespace UnitTestsCommonUtils
+{
+    TEST_CLASS(GpoTests)
+    {
+    public:
+        // Helper to check if result is a valid gpo_rule_configured_t value
+        static constexpr bool IsValidGpoResult(gpo_rule_configured_t result)
+        {
+            return result == gpo_rule_configured_wrong_value ||
+                   result == gpo_rule_configured_unavailable ||
+                   result == gpo_rule_configured_not_configured ||
+                   result == gpo_rule_configured_disabled ||
+                   result == gpo_rule_configured_enabled;
+        }
+
+        // gpo_rule_configured_t enum tests
+        TEST_METHOD(GpoRuleConfigured_EnumValues_AreDistinct)
+        {
+            Assert::AreNotEqual(static_cast<int>(gpo_rule_configured_not_configured),
+                               static_cast<int>(gpo_rule_configured_enabled));
+            Assert::AreNotEqual(static_cast<int>(gpo_rule_configured_enabled),
+                               static_cast<int>(gpo_rule_configured_disabled));
+            Assert::AreNotEqual(static_cast<int>(gpo_rule_configured_not_configured),
+                               static_cast<int>(gpo_rule_configured_disabled));
+        }
+
+        // getConfiguredValue tests
+        TEST_METHOD(GetConfiguredValue_NonExistentKey_ReturnsNotConfigured)
+        {
+            auto result = getConfiguredValue(L"NonExistentPolicyValue12345");
+            Assert::IsTrue(result == gpo_rule_configured_not_configured ||
+                          result == gpo_rule_configured_unavailable);
+        }
+
+        // Utility enabled getters - these all follow the same pattern
+        TEST_METHOD(GetAllowExperimentationValue_ReturnsValidState)
+        {
+            auto result = getAllowExperimentationValue();
+            Assert::IsTrue(IsValidGpoResult(result));
+        }
+
+        TEST_METHOD(GetConfiguredAlwaysOnTopEnabledValue_ReturnsValidState)
+        {
+            auto result = getConfiguredAlwaysOnTopEnabledValue();
+            Assert::IsTrue(IsValidGpoResult(result));
+        }
+
+        TEST_METHOD(GetConfiguredAwakeEnabledValue_ReturnsValidState)
+        {
+            auto result = getConfiguredAwakeEnabledValue();
+            Assert::IsTrue(IsValidGpoResult(result));
+        }
+
+        TEST_METHOD(GetConfiguredColorPickerEnabledValue_ReturnsValidState)
+        {
+            auto result = getConfiguredColorPickerEnabledValue();
+            Assert::IsTrue(IsValidGpoResult(result));
+        }
+
+        TEST_METHOD(GetConfiguredFancyZonesEnabledValue_ReturnsValidState)
+        {
+            auto result = getConfiguredFancyZonesEnabledValue();
+            Assert::IsTrue(IsValidGpoResult(result));
+        }
+
+        TEST_METHOD(GetConfiguredFileLocksmithEnabledValue_ReturnsValidState)
+        {
+            auto result = getConfiguredFileLocksmithEnabledValue();
+            Assert::IsTrue(IsValidGpoResult(result));
+        }
+
+        TEST_METHOD(GetConfiguredImageResizerEnabledValue_ReturnsValidState)
+        {
+            auto result = getConfiguredImageResizerEnabledValue();
+            Assert::IsTrue(IsValidGpoResult(result));
+        }
+
+        TEST_METHOD(GetConfiguredKeyboardManagerEnabledValue_ReturnsValidState)
+        {
+            auto result = getConfiguredKeyboardManagerEnabledValue();
+            Assert::IsTrue(IsValidGpoResult(result));
+        }
+
+        TEST_METHOD(GetConfiguredPowerRenameEnabledValue_ReturnsValidState)
+        {
+            auto result = getConfiguredPowerRenameEnabledValue();
+            Assert::IsTrue(IsValidGpoResult(result));
+        }
+
+        TEST_METHOD(GetConfiguredPowerLauncherEnabledValue_ReturnsValidState)
+        {
+            auto result = getConfiguredPowerLauncherEnabledValue();
+            Assert::IsTrue(IsValidGpoResult(result));
+        }
+
+        TEST_METHOD(GetConfiguredShortcutGuideEnabledValue_ReturnsValidState)
+        {
+            auto result = getConfiguredShortcutGuideEnabledValue();
+            Assert::IsTrue(IsValidGpoResult(result));
+        }
+
+        TEST_METHOD(GetConfiguredTextExtractorEnabledValue_ReturnsValidState)
+        {
+            auto result = getConfiguredTextExtractorEnabledValue();
+            Assert::IsTrue(IsValidGpoResult(result));
+        }
+
+        TEST_METHOD(GetConfiguredHostsFileEditorEnabledValue_ReturnsValidState)
+        {
+            auto result = getConfiguredHostsFileEditorEnabledValue();
+            Assert::IsTrue(IsValidGpoResult(result));
+        }
+
+        TEST_METHOD(GetConfiguredMousePointerCrosshairsEnabledValue_ReturnsValidState)
+        {
+            auto result = getConfiguredMousePointerCrosshairsEnabledValue();
+            Assert::IsTrue(IsValidGpoResult(result));
+        }
+
+        TEST_METHOD(GetConfiguredMouseHighlighterEnabledValue_ReturnsValidState)
+        {
+            auto result = getConfiguredMouseHighlighterEnabledValue();
+            Assert::IsTrue(IsValidGpoResult(result));
+        }
+
+        TEST_METHOD(GetConfiguredMouseJumpEnabledValue_ReturnsValidState)
+        {
+            auto result = getConfiguredMouseJumpEnabledValue();
+            Assert::IsTrue(IsValidGpoResult(result));
+        }
+
+        TEST_METHOD(GetConfiguredFindMyMouseEnabledValue_ReturnsValidState)
+        {
+            auto result = getConfiguredFindMyMouseEnabledValue();
+            Assert::IsTrue(IsValidGpoResult(result));
+        }
+
+        TEST_METHOD(GetConfiguredMouseWithoutBordersEnabledValue_ReturnsValidState)
+        {
+            auto result = getConfiguredMouseWithoutBordersEnabledValue();
+            Assert::IsTrue(IsValidGpoResult(result));
+        }
+
+        TEST_METHOD(GetConfiguredAdvancedPasteEnabledValue_ReturnsValidState)
+        {
+            auto result = getConfiguredAdvancedPasteEnabledValue();
+            Assert::IsTrue(IsValidGpoResult(result));
+        }
+
+        TEST_METHOD(GetConfiguredPeekEnabledValue_ReturnsValidState)
+        {
+            auto result = getConfiguredPeekEnabledValue();
+            Assert::IsTrue(IsValidGpoResult(result));
+        }
+
+        TEST_METHOD(GetConfiguredRegistryPreviewEnabledValue_ReturnsValidState)
+        {
+            auto result = getConfiguredRegistryPreviewEnabledValue();
+            Assert::IsTrue(IsValidGpoResult(result));
+        }
+
+        TEST_METHOD(GetConfiguredScreenRulerEnabledValue_ReturnsValidState)
+        {
+            auto result = getConfiguredScreenRulerEnabledValue();
+            Assert::IsTrue(IsValidGpoResult(result));
+        }
+
+        TEST_METHOD(GetConfiguredCropAndLockEnabledValue_ReturnsValidState)
+        {
+            auto result = getConfiguredCropAndLockEnabledValue();
+            Assert::IsTrue(IsValidGpoResult(result));
+        }
+
+        TEST_METHOD(GetConfiguredEnvironmentVariablesEnabledValue_ReturnsValidState)
+        {
+            auto result = getConfiguredEnvironmentVariablesEnabledValue();
+            Assert::IsTrue(IsValidGpoResult(result));
+        }
+
+        // All GPO functions should not crash
+        TEST_METHOD(AllGpoFunctions_DoNotCrash)
+        {
+            getAllowExperimentationValue();
+            getConfiguredAlwaysOnTopEnabledValue();
+            getConfiguredAwakeEnabledValue();
+            getConfiguredColorPickerEnabledValue();
+            getConfiguredFancyZonesEnabledValue();
+            getConfiguredFileLocksmithEnabledValue();
+            getConfiguredImageResizerEnabledValue();
+            getConfiguredKeyboardManagerEnabledValue();
+            getConfiguredPowerRenameEnabledValue();
+            getConfiguredPowerLauncherEnabledValue();
+            getConfiguredShortcutGuideEnabledValue();
+            getConfiguredTextExtractorEnabledValue();
+            getConfiguredHostsFileEditorEnabledValue();
+            getConfiguredMousePointerCrosshairsEnabledValue();
+            getConfiguredMouseHighlighterEnabledValue();
+            getConfiguredMouseJumpEnabledValue();
+            getConfiguredFindMyMouseEnabledValue();
+            getConfiguredMouseWithoutBordersEnabledValue();
+            getConfiguredAdvancedPasteEnabledValue();
+            getConfiguredPeekEnabledValue();
+            getConfiguredRegistryPreviewEnabledValue();
+            getConfiguredScreenRulerEnabledValue();
+            getConfiguredCropAndLockEnabledValue();
+            getConfiguredEnvironmentVariablesEnabledValue();
+
+            Assert::IsTrue(true);
+        }
+    };
+}

src/common/UnitTests-CommonUtils/HDropIterator.Tests.cpp

@@ -0,0 +1,200 @@
+#include "pch.h"
+#include "TestHelpers.h"
+#include <HDropIterator.h>
+#include <shlobj.h>
+
+using namespace Microsoft::VisualStudio::CppUnitTestFramework;
+
+namespace UnitTestsCommonUtils
+{
+    TEST_CLASS(HDropIteratorTests)
+    {
+    public:
+        // Helper to create a test HDROP structure
+        static HGLOBAL CreateTestHDrop(const std::vector<std::wstring>& files)
+        {
+            // Calculate required size
+            size_t size = sizeof(DROPFILES);
+            for (const auto& file : files)
+            {
+                size += (file.length() + 1) * sizeof(wchar_t);
+            }
+            size += sizeof(wchar_t); // Double null terminator
+
+            HGLOBAL hGlobal = GlobalAlloc(GHND, size);
+            if (!hGlobal) return nullptr;
+
+            DROPFILES* pDropFiles = static_cast<DROPFILES*>(GlobalLock(hGlobal));
+            if (!pDropFiles)
+            {
+                GlobalFree(hGlobal);
+                return nullptr;
+            }
+
+            pDropFiles->pFiles = sizeof(DROPFILES);
+            pDropFiles->fWide = TRUE;
+
+            wchar_t* pData = reinterpret_cast<wchar_t*>(reinterpret_cast<BYTE*>(pDropFiles) + sizeof(DROPFILES));
+            for (const auto& file : files)
+            {
+                wcscpy_s(pData, file.length() + 1, file.c_str());
+                pData += file.length() + 1;
+            }
+            *pData = L'\0'; // Double null terminator
+
+            GlobalUnlock(hGlobal);
+            return hGlobal;
+        }
+
+        TEST_METHOD(HDropIterator_EmptyDrop_IsDoneImmediately)
+        {
+            HGLOBAL hGlobal = CreateTestHDrop({});
+            if (!hGlobal)
+            {
+                Assert::IsTrue(true); // Skip if allocation failed
+                return;
+            }
+
+            STGMEDIUM medium = {};
+            medium.tymed = TYMED_HGLOBAL;
+            medium.hGlobal = hGlobal;
+
+            // Without a proper IDataObject, we can't fully test
+            // Just verify the class can be instantiated conceptually
+            GlobalFree(hGlobal);
+            Assert::IsTrue(true);
+        }
+
+        TEST_METHOD(HDropIterator_Iteration_Conceptual)
+        {
+            // This test verifies the concept of iteration
+            // Full integration testing requires a proper IDataObject
+
+            std::vector<std::wstring> testFiles = {
+                L"C:\\test\\file1.txt",
+                L"C:\\test\\file2.txt",
+                L"C:\\test\\file3.txt"
+            };
+
+            HGLOBAL hGlobal = CreateTestHDrop(testFiles);
+            if (!hGlobal)
+            {
+                Assert::IsTrue(true);
+                return;
+            }
+
+            // Verify we can create the HDROP structure
+            DROPFILES* pDropFiles = static_cast<DROPFILES*>(GlobalLock(hGlobal));
+            Assert::IsNotNull(pDropFiles);
+            Assert::IsTrue(pDropFiles->fWide);
+
+            GlobalUnlock(hGlobal);
+            GlobalFree(hGlobal);
+            Assert::IsTrue(true);
+        }
+
+        TEST_METHOD(HDropIterator_SingleFile_Works)
+        {
+            std::vector<std::wstring> testFiles = { L"C:\\test\\single.txt" };
+
+            HGLOBAL hGlobal = CreateTestHDrop(testFiles);
+            if (!hGlobal)
+            {
+                Assert::IsTrue(true);
+                return;
+            }
+
+            // Verify structure
+            DROPFILES* pDropFiles = static_cast<DROPFILES*>(GlobalLock(hGlobal));
+            Assert::IsNotNull(pDropFiles);
+
+            // Read back the file name
+            wchar_t* pData = reinterpret_cast<wchar_t*>(reinterpret_cast<BYTE*>(pDropFiles) + pDropFiles->pFiles);
+            Assert::AreEqual(std::wstring(L"C:\\test\\single.txt"), std::wstring(pData));
+
+            GlobalUnlock(hGlobal);
+            GlobalFree(hGlobal);
+        }
+
+        TEST_METHOD(HDropIterator_MultipleFiles_Structure)
+        {
+            std::vector<std::wstring> testFiles = {
+                L"C:\\file1.txt",
+                L"C:\\file2.txt",
+                L"C:\\file3.txt"
+            };
+
+            HGLOBAL hGlobal = CreateTestHDrop(testFiles);
+            if (!hGlobal)
+            {
+                Assert::IsTrue(true);
+                return;
+            }
+
+            DROPFILES* pDropFiles = static_cast<DROPFILES*>(GlobalLock(hGlobal));
+            Assert::IsNotNull(pDropFiles);
+
+            // Count files by iterating through null-terminated strings
+            wchar_t* pData = reinterpret_cast<wchar_t*>(reinterpret_cast<BYTE*>(pDropFiles) + pDropFiles->pFiles);
+            int count = 0;
+            while (*pData)
+            {
+                count++;
+                pData += wcslen(pData) + 1;
+            }
+
+            Assert::AreEqual(3, count);
+
+            GlobalUnlock(hGlobal);
+            GlobalFree(hGlobal);
+        }
+
+        TEST_METHOD(HDropIterator_UnicodeFilenames_Work)
+        {
+            std::vector<std::wstring> testFiles = {
+                L"C:\\test\\file.txt"
+            };
+
+            HGLOBAL hGlobal = CreateTestHDrop(testFiles);
+            if (!hGlobal)
+            {
+                Assert::IsTrue(true);
+                return;
+            }
+
+            DROPFILES* pDropFiles = static_cast<DROPFILES*>(GlobalLock(hGlobal));
+            Assert::IsTrue(pDropFiles->fWide == TRUE);
+
+            GlobalUnlock(hGlobal);
+            GlobalFree(hGlobal);
+        }
+
+        TEST_METHOD(HDropIterator_LongFilenames_Work)
+        {
+            std::wstring longPath = L"C:\\";
+            for (int i = 0; i < 20; ++i)
+            {
+                longPath += L"LongFolderName\\";
+            }
+            longPath += L"file.txt";
+
+            std::vector<std::wstring> testFiles = { longPath };
+
+            HGLOBAL hGlobal = CreateTestHDrop(testFiles);
+            if (!hGlobal)
+            {
+                Assert::IsTrue(true);
+                return;
+            }
+
+            DROPFILES* pDropFiles = static_cast<DROPFILES*>(GlobalLock(hGlobal));
+            Assert::IsNotNull(pDropFiles);
+
+            wchar_t* pData = reinterpret_cast<wchar_t*>(reinterpret_cast<BYTE*>(pDropFiles) + pDropFiles->pFiles);
+            Assert::AreEqual(longPath, std::wstring(pData));
+
+            GlobalUnlock(hGlobal);
+            GlobalFree(hGlobal);
+        }
+    };
+}

src/common/UnitTests-CommonUtils/HttpClient.Tests.cpp

@@ -0,0 +1,152 @@
+#include "pch.h"
+#include "TestHelpers.h"
+#include <HttpClient.h>
+
+using namespace Microsoft::VisualStudio::CppUnitTestFramework;
+
+namespace UnitTestsCommonUtils
+{
+    TEST_CLASS(HttpClientTests)
+    {
+    public:
+        // Note: Network tests may fail in offline environments
+        // These tests are designed to verify the API doesn't crash
+
+        TEST_METHOD(HttpClient_DefaultConstruction)
+        {
+            http::HttpClient client;
+            // Should not crash
+            Assert::IsTrue(true);
+        }
+
+        TEST_METHOD(HttpClient_Request_InvalidUri_ReturnsEmpty)
+        {
+            http::HttpClient client;
+
+            try
+            {
+                // Invalid URI should not crash, may throw or return empty
+                auto result = client.request(winrt::Windows::Foundation::Uri(L"invalid://not-a-valid-uri"));
+                // If we get here, result may be empty or contain error
+            }
+            catch (...)
+            {
+                // Exception is acceptable for invalid URI
+            }
+            Assert::IsTrue(true);
+        }
+
+        TEST_METHOD(HttpClient_Download_InvalidUri_DoesNotCrash)
+        {
+            http::HttpClient client;
+            TestHelpers::TempFile tempFile;
+
+            try
+            {
+                auto result = client.download(
+                    winrt::Windows::Foundation::Uri(L"https://invalid.invalid.invalid"),
+                    tempFile.path());
+                // May return false or throw
+            }
+            catch (...)
+            {
+                // Exception is acceptable for invalid/unreachable URI
+            }
+            Assert::IsTrue(true);
+        }
+
+        TEST_METHOD(HttpClient_Download_WithCallback_DoesNotCrash)
+        {
+            http::HttpClient client;
+            TestHelpers::TempFile tempFile;
+            std::atomic<int> callbackCount{ 0 };
+
+            try
+            {
+                auto result = client.download(
+                    winrt::Windows::Foundation::Uri(L"https://invalid.invalid.invalid"),
+                    tempFile.path(),
+                    [&callbackCount]([[maybe_unused]] float progress) {
+                        callbackCount++;
+                    });
+            }
+            catch (...)
+            {
+                // Exception is acceptable
+            }
+            Assert::IsTrue(true);
+        }
+
+        TEST_METHOD(HttpClient_Download_EmptyPath_DoesNotCrash)
+        {
+            http::HttpClient client;
+
+            try
+            {
+                auto result = client.download(
+                    winrt::Windows::Foundation::Uri(L"https://example.com"),
+                    L"");
+            }
+            catch (...)
+            {
+                // Exception is acceptable for empty path
+            }
+            Assert::IsTrue(true);
+        }
+
+        // These tests require network access and may be skipped in offline environments
+        TEST_METHOD(HttpClient_Request_ValidUri_ReturnsResult)
+        {
+            // Skip this test in most CI environments
+            // Only run manually to verify network functionality
+            http::HttpClient client;
+
+            try
+            {
+                // Use a reliable, fast-responding URL
+                auto result = client.request(winrt::Windows::Foundation::Uri(L"https://www.microsoft.com"));
+                // Result may or may not be successful depending on network
+            }
+            catch (...)
+            {
+                // Network errors are acceptable in test environment
+            }
+            Assert::IsTrue(true);
+        }
+
+        // Thread safety test (doesn't require network)
+        TEST_METHOD(HttpClient_MultipleInstances_DoNotCrash)
+        {
+            std::vector<std::unique_ptr<http::HttpClient>> clients;
+
+            for (int i = 0; i < 10; ++i)
+            {
+                clients.push_back(std::make_unique<http::HttpClient>());
+            }
+
+            // All clients should coexist without crashing
+            Assert::AreEqual(static_cast<size_t>(10), clients.size());
+        }
+
+        TEST_METHOD(HttpClient_ConcurrentConstruction_DoesNotCrash)
+        {
+            std::vector<std::thread> threads;
+            std::atomic<int> successCount{ 0 };
+
+            for (int i = 0; i < 5; ++i)
+            {
+                threads.emplace_back([&successCount]() {
+                    http::HttpClient client;
+                    successCount++;
+                });
+            }
+
+            for (auto& t : threads)
+            {
+                t.join();
+            }
+
+            Assert::AreEqual(5, successCount.load());
+        }
+    };
+}

src/common/UnitTests-CommonUtils/Json.Tests.cpp

@@ -0,0 +1,283 @@
+#include "pch.h"
+#include "TestHelpers.h"
+#include <json.h>
+
+using namespace Microsoft::VisualStudio::CppUnitTestFramework;
+using namespace winrt::Windows::Data::Json;
+
+namespace UnitTestsCommonUtils
+{
+    TEST_CLASS(JsonTests)
+    {
+    public:
+        // from_file tests
+        TEST_METHOD(FromFile_NonExistentFile_ReturnsNullopt)
+        {
+            auto result = json::from_file(L"C:\\NonExistent\\File\\Path.json");
+            Assert::IsFalse(result.has_value());
+        }
+
+        TEST_METHOD(FromFile_ValidJsonFile_ReturnsJsonObject)
+        {
+            TestHelpers::TempFile tempFile(L"", L".json");
+            tempFile.write("{\"key\": \"value\"}");
+
+            auto result = json::from_file(tempFile.path());
+            Assert::IsTrue(result.has_value());
+        }
+
+        TEST_METHOD(FromFile_InvalidJson_ReturnsNullopt)
+        {
+            TestHelpers::TempFile tempFile(L"", L".json");
+            tempFile.write("not valid json {{{");
+
+            auto result = json::from_file(tempFile.path());
+            Assert::IsFalse(result.has_value());
+        }
+
+        TEST_METHOD(FromFile_EmptyFile_ReturnsNullopt)
+        {
+            TestHelpers::TempFile tempFile(L"", L".json");
+            // File is empty
+
+            auto result = json::from_file(tempFile.path());
+            Assert::IsFalse(result.has_value());
+        }
+
+        TEST_METHOD(FromFile_ValidComplexJson_ParsesCorrectly)
+        {
+            TestHelpers::TempFile tempFile(L"", L".json");
+            tempFile.write("{\"name\": \"test\", \"value\": 42, \"enabled\": true}");
+
+            auto result = json::from_file(tempFile.path());
+            Assert::IsTrue(result.has_value());
+
+            auto& obj = *result;
+            Assert::IsTrue(obj.HasKey(L"name"));
+            Assert::IsTrue(obj.HasKey(L"value"));
+            Assert::IsTrue(obj.HasKey(L"enabled"));
+        }
+
+        // to_file tests
+        TEST_METHOD(ToFile_ValidObject_WritesFile)
+        {
+            TestHelpers::TempFile tempFile(L"", L".json");
+
+            JsonObject obj;
+            obj.SetNamedValue(L"key", JsonValue::CreateStringValue(L"value"));
+            json::to_file(tempFile.path(), obj);
+
+            // Read back and verify
+            auto result = json::from_file(tempFile.path());
+            Assert::IsTrue(result.has_value());
+            Assert::IsTrue(result->HasKey(L"key"));
+        }
+
+        TEST_METHOD(ToFile_ComplexObject_WritesFile)
+        {
+            TestHelpers::TempFile tempFile(L"", L".json");
+
+            JsonObject obj;
+            obj.SetNamedValue(L"name", JsonValue::CreateStringValue(L"test"));
+            obj.SetNamedValue(L"value", JsonValue::CreateNumberValue(42));
+            obj.SetNamedValue(L"enabled", JsonValue::CreateBooleanValue(true));
+            json::to_file(tempFile.path(), obj);
+
+            auto result = json::from_file(tempFile.path());
+            Assert::IsTrue(result.has_value());
+            Assert::AreEqual(std::wstring(L"test"), std::wstring(result->GetNamedString(L"name")));
+            Assert::AreEqual(42.0, result->GetNamedNumber(L"value"));
+            Assert::IsTrue(result->GetNamedBoolean(L"enabled"));
+        }
+
+        // has tests
+        TEST_METHOD(Has_ExistingKey_ReturnsTrue)
+        {
+            JsonObject obj;
+            obj.SetNamedValue(L"key", JsonValue::CreateStringValue(L"value"));
+            Assert::IsTrue(json::has(obj, L"key", JsonValueType::String));
+        }
+
+        TEST_METHOD(Has_NonExistingKey_ReturnsFalse)
+        {
+            JsonObject obj;
+            Assert::IsFalse(json::has(obj, L"key", JsonValueType::String));
+        }
+
+        TEST_METHOD(Has_WrongType_ReturnsFalse)
+        {
+            JsonObject obj;
+            obj.SetNamedValue(L"key", JsonValue::CreateStringValue(L"value"));
+            Assert::IsFalse(json::has(obj, L"key", JsonValueType::Number));
+        }
+
+        TEST_METHOD(Has_NumberType_ReturnsTrue)
+        {
+            JsonObject obj;
+            obj.SetNamedValue(L"key", JsonValue::CreateNumberValue(42));
+            Assert::IsTrue(json::has(obj, L"key", JsonValueType::Number));
+        }
+
+        TEST_METHOD(Has_BooleanType_ReturnsTrue)
+        {
+            JsonObject obj;
+            obj.SetNamedValue(L"key", JsonValue::CreateBooleanValue(true));
+            Assert::IsTrue(json::has(obj, L"key", JsonValueType::Boolean));
+        }
+
+        TEST_METHOD(Has_ObjectType_ReturnsTrue)
+        {
+            JsonObject obj;
+            JsonObject nested;
+            obj.SetNamedValue(L"key", nested);
+            Assert::IsTrue(json::has(obj, L"key", JsonValueType::Object));
+        }
+
+        // value function tests
+        TEST_METHOD(Value_IntegerType_CreatesNumberValue)
+        {
+            auto val = json::value(42);
+            Assert::IsTrue(val.ValueType() == JsonValueType::Number);
+            Assert::AreEqual(42.0, val.GetNumber());
+        }
+
+        TEST_METHOD(Value_DoubleType_CreatesNumberValue)
+        {
+            auto val = json::value(3.14);
+            Assert::IsTrue(val.ValueType() == JsonValueType::Number);
+            Assert::AreEqual(3.14, val.GetNumber());
+        }
+
+        TEST_METHOD(Value_BooleanTrue_CreatesBooleanValue)
+        {
+            auto val = json::value(true);
+            Assert::IsTrue(val.ValueType() == JsonValueType::Boolean);
+            Assert::IsTrue(val.GetBoolean());
+        }
+
+        TEST_METHOD(Value_BooleanFalse_CreatesBooleanValue)
+        {
+            auto val = json::value(false);
+            Assert::IsTrue(val.ValueType() == JsonValueType::Boolean);
+            Assert::IsFalse(val.GetBoolean());
+        }
+
+        TEST_METHOD(Value_String_CreatesStringValue)
+        {
+            auto val = json::value(L"hello");
+            Assert::IsTrue(val.ValueType() == JsonValueType::String);
+            Assert::AreEqual(std::wstring(L"hello"), std::wstring(val.GetString()));
+        }
+
+        TEST_METHOD(Value_JsonObject_ReturnsJsonValue)
+        {
+            JsonObject obj;
+            obj.SetNamedValue(L"key", JsonValue::CreateStringValue(L"value"));
+            auto val = json::value(obj);
+            Assert::IsTrue(val.ValueType() == JsonValueType::Object);
+        }
+
+        TEST_METHOD(Value_JsonValue_ReturnsIdentity)
+        {
+            auto original = JsonValue::CreateStringValue(L"test");
+            auto result = json::value(original);
+            Assert::AreEqual(std::wstring(L"test"), std::wstring(result.GetString()));
+        }
+
+        // get function tests
+        TEST_METHOD(Get_BooleanValue_ReturnsValue)
+        {
+            JsonObject obj;
+            obj.SetNamedValue(L"enabled", JsonValue::CreateBooleanValue(true));
+
+            bool result = false;
+            json::get(obj, L"enabled", result);
+            Assert::IsTrue(result);
+        }
+
+        TEST_METHOD(Get_IntValue_ReturnsValue)
+        {
+            JsonObject obj;
+            obj.SetNamedValue(L"count", JsonValue::CreateNumberValue(42));
+
+            int result = 0;
+            json::get(obj, L"count", result);
+            Assert::AreEqual(42, result);
+        }
+
+        TEST_METHOD(Get_DoubleValue_ReturnsValue)
+        {
+            JsonObject obj;
+            obj.SetNamedValue(L"ratio", JsonValue::CreateNumberValue(3.14));
+
+            double result = 0.0;
+            json::get(obj, L"ratio", result);
+            Assert::AreEqual(3.14, result);
+        }
+
+        TEST_METHOD(Get_StringValue_ReturnsValue)
+        {
+            JsonObject obj;
+            obj.SetNamedValue(L"name", JsonValue::CreateStringValue(L"test"));
+
+            std::wstring result;
+            json::get(obj, L"name", result);
+            Assert::AreEqual(std::wstring(L"test"), result);
+        }
+
+        TEST_METHOD(Get_MissingKey_UsesDefault)
+        {
+            JsonObject obj;
+
+            int result = 0;
+            json::get(obj, L"missing", result, 99);
+            Assert::AreEqual(99, result);
+        }
+
+        TEST_METHOD(Get_MissingKeyNoDefault_PreservesOriginal)
+        {
+            JsonObject obj;
+
+            int result = 42;
+            json::get(obj, L"missing", result);
+            // When key is missing and no default, original value is preserved
+            Assert::AreEqual(42, result);
+        }
+
+        TEST_METHOD(Get_JsonObject_ReturnsObject)
+        {
+            JsonObject obj;
+            JsonObject nested;
+            nested.SetNamedValue(L"inner", JsonValue::CreateStringValue(L"value"));
+            obj.SetNamedValue(L"nested", nested);
+
+            JsonObject result;
+            json::get(obj, L"nested", result);
+            Assert::IsTrue(result.HasKey(L"inner"));
+        }
+
+        // Roundtrip tests
+        TEST_METHOD(Roundtrip_ComplexObject_PreservesData)
+        {
+            TestHelpers::TempFile tempFile(L"", L".json");
+
+            JsonObject original;
+            original.SetNamedValue(L"string", JsonValue::CreateStringValue(L"hello"));
+            original.SetNamedValue(L"number", JsonValue::CreateNumberValue(42));
+            original.SetNamedValue(L"boolean", JsonValue::CreateBooleanValue(true));
+
+            JsonObject nested;
+            nested.SetNamedValue(L"inner", JsonValue::CreateStringValue(L"world"));
+            original.SetNamedValue(L"object", nested);
+
+            json::to_file(tempFile.path(), original);
+            auto loaded = json::from_file(tempFile.path());
+
+            Assert::IsTrue(loaded.has_value());
+            Assert::AreEqual(std::wstring(L"hello"), std::wstring(loaded->GetNamedString(L"string")));
+            Assert::AreEqual(42.0, loaded->GetNamedNumber(L"number"));
+            Assert::IsTrue(loaded->GetNamedBoolean(L"boolean"));
+            Assert::AreEqual(std::wstring(L"world"), std::wstring(loaded->GetNamedObject(L"object").GetNamedString(L"inner")));
+        }
+    };
+}

src/common/UnitTests-CommonUtils/LoggerHelper.Tests.cpp

@@ -0,0 +1,180 @@
+#include "pch.h"
+#include "TestHelpers.h"
+#include <logger_helper.h>
+
+using namespace Microsoft::VisualStudio::CppUnitTestFramework;
+using namespace LoggerHelpers;
+
+namespace UnitTestsCommonUtils
+{
+    TEST_CLASS(LoggerHelperTests)
+    {
+    public:
+        // get_log_folder_path tests
+        TEST_METHOD(GetLogFolderPath_ValidAppPath_ReturnsPath)
+        {
+            auto result = get_log_folder_path(L"TestApp");
+
+            Assert::IsFalse(result.empty());
+            // Should contain the app name or be a valid path
+            auto pathStr = result.wstring();
+            Assert::IsTrue(pathStr.length() > 0);
+        }
+
+        TEST_METHOD(GetLogFolderPath_EmptyAppPath_ReturnsPath)
+        {
+            auto result = get_log_folder_path(L"");
+
+            // Should still return a base path
+            Assert::IsTrue(true); // Just verify no crash
+        }
+
+        TEST_METHOD(GetLogFolderPath_SpecialCharacters_Works)
+        {
+            auto result = get_log_folder_path(L"Test App With Spaces");
+
+            // Should handle spaces in path
+            Assert::IsTrue(true);
+        }
+
+        TEST_METHOD(GetLogFolderPath_ConsistentResults)
+        {
+            auto result1 = get_log_folder_path(L"TestApp");
+            auto result2 = get_log_folder_path(L"TestApp");
+
+            Assert::AreEqual(result1.wstring(), result2.wstring());
+        }
+
+        // dir_exists tests
+        TEST_METHOD(DirExists_WindowsDirectory_ReturnsTrue)
+        {
+            bool result = dir_exists(std::filesystem::path(L"C:\\Windows"));
+            Assert::IsTrue(result);
+        }
+
+        TEST_METHOD(DirExists_NonExistentDirectory_ReturnsFalse)
+        {
+            bool result = dir_exists(std::filesystem::path(L"C:\\NonExistentDir12345"));
+            Assert::IsFalse(result);
+        }
+
+        TEST_METHOD(DirExists_FileInsteadOfDir_ReturnsTrue)
+        {
+            // notepad.exe is a file, not a directory
+            bool result = dir_exists(std::filesystem::path(L"C:\\Windows\\notepad.exe"));
+            Assert::IsTrue(result);
+        }
+
+        TEST_METHOD(DirExists_EmptyPath_ReturnsFalse)
+        {
+            bool result = dir_exists(std::filesystem::path(L""));
+            Assert::IsFalse(result);
+        }
+
+        TEST_METHOD(DirExists_TempDirectory_ReturnsTrue)
+        {
+            wchar_t tempPath[MAX_PATH];
+            GetTempPathW(MAX_PATH, tempPath);
+
+            bool result = dir_exists(std::filesystem::path(tempPath));
+            Assert::IsTrue(result);
+        }
+
+        // delete_old_log_folder tests
+        TEST_METHOD(DeleteOldLogFolder_NonExistentFolder_DoesNotCrash)
+        {
+            delete_old_log_folder(std::filesystem::path(L"C:\\NonExistentLogFolder12345"));
+            Assert::IsTrue(true);
+        }
+
+        TEST_METHOD(DeleteOldLogFolder_ValidEmptyFolder_Works)
+        {
+            TestHelpers::TempDirectory tempDir;
+
+            // Create a subfolder structure
+            auto logFolder = std::filesystem::path(tempDir.path()) / L"logs";
+            std::filesystem::create_directories(logFolder);
+
+            Assert::IsTrue(std::filesystem::exists(logFolder));
+
+            delete_old_log_folder(logFolder);
+
+            // Folder may or may not be deleted depending on implementation
+            Assert::IsTrue(true);
+        }
+
+        // delete_other_versions_log_folders tests
+        TEST_METHOD(DeleteOtherVersionsLogFolders_NonExistentPath_DoesNotCrash)
+        {
+            delete_other_versions_log_folders(L"C:\\NonExistent\\Path", L"1.0.0");
+            Assert::IsTrue(true);
+        }
+
+        TEST_METHOD(DeleteOtherVersionsLogFolders_EmptyVersion_DoesNotCrash)
+        {
+            wchar_t tempPath[MAX_PATH];
+            GetTempPathW(MAX_PATH, tempPath);
+
+            delete_other_versions_log_folders(tempPath, L"");
+            Assert::IsTrue(true);
+        }
+
+        // Thread safety tests
+        TEST_METHOD(GetLogFolderPath_ThreadSafe)
+        {
+            std::vector<std::thread> threads;
+            std::atomic<int> successCount{ 0 };
+
+            for (int i = 0; i < 10; ++i)
+            {
+                threads.emplace_back([&successCount, i]() {
+                    auto path = get_log_folder_path(L"TestApp" + std::to_wstring(i));
+                    if (!path.empty())
+                    {
+                        successCount++;
+                    }
+                });
+            }
+
+            for (auto& t : threads)
+            {
+                t.join();
+            }
+
+            Assert::AreEqual(10, successCount.load());
+        }
+
+        TEST_METHOD(DirExists_ThreadSafe)
+        {
+            std::vector<std::thread> threads;
+            std::atomic<int> successCount{ 0 };
+
+            for (int i = 0; i < 10; ++i)
+            {
+                threads.emplace_back([&successCount]() {
+                    for (int j = 0; j < 10; ++j)
+                    {
+                        dir_exists(std::filesystem::path(L"C:\\Windows"));
+                        successCount++;
+                    }
+                });
+            }
+
+            for (auto& t : threads)
+            {
+                t.join();
+            }
+
+            Assert::AreEqual(100, successCount.load());
+        }
+
+        // Path construction tests
+        TEST_METHOD(GetLogFolderPath_ReturnsValidFilesystemPath)
+        {
+            auto result = get_log_folder_path(L"TestApp");
+
+            // Should be a valid path that we can use with filesystem operations
+            Assert::IsTrue(result.is_absolute() || result.has_root_name() || !result.empty());
+        }
+    };
+}

src/common/UnitTests-CommonUtils/ModulesRegistry.Tests.cpp

@@ -0,0 +1,173 @@
+#include "pch.h"
+#include "TestHelpers.h"
+#include <modulesRegistry.h>
+
+using namespace Microsoft::VisualStudio::CppUnitTestFramework;
+
+namespace UnitTestsCommonUtils
+{
+    static std::wstring GetInstallDir()
+    {
+        wchar_t path[MAX_PATH];
+        GetModuleFileNameW(nullptr, path, MAX_PATH);
+        return std::filesystem::path{ path }.parent_path().wstring();
+    }
+
+    TEST_CLASS(ModulesRegistryTests)
+    {
+    public:
+        // Test that all changeset generator functions return valid changesets
+        TEST_METHOD(GetSvgPreviewHandlerChangeSet_ReturnsChangeSet)
+        {
+            auto changeSet = getSvgPreviewHandlerChangeSet(GetInstallDir(), false);
+
+            Assert::IsFalse(changeSet.changes.empty());
+        }
+
+        TEST_METHOD(GetSvgThumbnailProviderChangeSet_ReturnsChangeSet)
+        {
+            auto changeSet = getSvgThumbnailHandlerChangeSet(GetInstallDir(), false);
+
+            Assert::IsFalse(changeSet.changes.empty());
+        }
+
+        TEST_METHOD(GetMarkdownPreviewHandlerChangeSet_ReturnsChangeSet)
+        {
+            auto changeSet = getMdPreviewHandlerChangeSet(GetInstallDir(), false);
+
+            Assert::IsFalse(changeSet.changes.empty());
+        }
+
+        TEST_METHOD(GetMonacoPreviewHandlerChangeSet_ReturnsChangeSet)
+        {
+            auto changeSet = getMonacoPreviewHandlerChangeSet(GetInstallDir(), false);
+
+            Assert::IsFalse(changeSet.changes.empty());
+        }
+
+        TEST_METHOD(GetPdfPreviewHandlerChangeSet_ReturnsChangeSet)
+        {
+            auto changeSet = getPdfPreviewHandlerChangeSet(GetInstallDir(), false);
+
+            Assert::IsFalse(changeSet.changes.empty());
+        }
+
+        TEST_METHOD(GetPdfThumbnailProviderChangeSet_ReturnsChangeSet)
+        {
+            auto changeSet = getPdfThumbnailHandlerChangeSet(GetInstallDir(), false);
+
+            Assert::IsFalse(changeSet.changes.empty());
+        }
+
+        TEST_METHOD(GetGcodePreviewHandlerChangeSet_ReturnsChangeSet)
+        {
+            auto changeSet = getGcodePreviewHandlerChangeSet(GetInstallDir(), false);
+
+            Assert::IsFalse(changeSet.changes.empty());
+        }
+
+        TEST_METHOD(GetGcodeThumbnailProviderChangeSet_ReturnsChangeSet)
+        {
+            auto changeSet = getGcodeThumbnailHandlerChangeSet(GetInstallDir(), false);
+
+            Assert::IsFalse(changeSet.changes.empty());
+        }
+
+        TEST_METHOD(GetStlThumbnailProviderChangeSet_ReturnsChangeSet)
+        {
+            auto changeSet = getStlThumbnailHandlerChangeSet(GetInstallDir(), false);
+
+            Assert::IsFalse(changeSet.changes.empty());
+        }
+
+        TEST_METHOD(GetQoiPreviewHandlerChangeSet_ReturnsChangeSet)
+        {
+            auto changeSet = getQoiPreviewHandlerChangeSet(GetInstallDir(), false);
+
+            Assert::IsFalse(changeSet.changes.empty());
+        }
+
+        TEST_METHOD(GetQoiThumbnailProviderChangeSet_ReturnsChangeSet)
+        {
+            auto changeSet = getQoiThumbnailHandlerChangeSet(GetInstallDir(), false);
+
+            Assert::IsFalse(changeSet.changes.empty());
+        }
+
+        // Test enabled vs disabled state
+        TEST_METHOD(ChangeSet_EnabledVsDisabled_MayDiffer)
+        {
+            auto enabledSet = getSvgPreviewHandlerChangeSet(GetInstallDir(), true);
+            auto disabledSet = getSvgPreviewHandlerChangeSet(GetInstallDir(), false);
+
+            // Both should be valid change sets
+            Assert::IsFalse(enabledSet.changes.empty());
+            Assert::IsFalse(disabledSet.changes.empty());
+        }
+
+        // Test getAllOnByDefaultModulesChangeSets
+        TEST_METHOD(GetAllOnByDefaultModulesChangeSets_ReturnsMultipleChangeSets)
+        {
+            auto changeSets = getAllOnByDefaultModulesChangeSets(GetInstallDir());
+
+            // Should return multiple changesets for all default-enabled modules
+            Assert::IsTrue(changeSets.size() > 0);
+        }
+
+        // Test getAllModulesChangeSets
+        TEST_METHOD(GetAllModulesChangeSets_ReturnsChangeSets)
+        {
+            auto changeSets = getAllModulesChangeSets(GetInstallDir());
+
+            // Should return changesets for all modules
+            Assert::IsTrue(changeSets.size() > 0);
+        }
+
+        TEST_METHOD(GetAllModulesChangeSets_ContainsMoreThanOnByDefault)
+        {
+            auto allSets = getAllModulesChangeSets(GetInstallDir());
+            auto defaultSets = getAllOnByDefaultModulesChangeSets(GetInstallDir());
+
+            // All modules should be >= on-by-default modules
+            Assert::IsTrue(allSets.size() >= defaultSets.size());
+        }
+
+        // Test that changesets have valid structure
+        TEST_METHOD(ChangeSet_HasValidKeyPath)
+        {
+            auto changeSet = getSvgPreviewHandlerChangeSet(GetInstallDir(), false);
+
+            Assert::IsFalse(changeSet.changes.empty());
+        }
+
+        // Test all changeset functions don't crash
+        TEST_METHOD(AllChangeSetFunctions_DoNotCrash)
+        {
+            auto installDir = GetInstallDir();
+            getSvgPreviewHandlerChangeSet(installDir, true);
+            getSvgPreviewHandlerChangeSet(installDir, false);
+            getSvgThumbnailHandlerChangeSet(installDir, true);
+            getSvgThumbnailHandlerChangeSet(installDir, false);
+            getMdPreviewHandlerChangeSet(installDir, true);
+            getMdPreviewHandlerChangeSet(installDir, false);
+            getMonacoPreviewHandlerChangeSet(installDir, true);
+            getMonacoPreviewHandlerChangeSet(installDir, false);
+            getPdfPreviewHandlerChangeSet(installDir, true);
+            getPdfPreviewHandlerChangeSet(installDir, false);
+            getPdfThumbnailHandlerChangeSet(installDir, true);
+            getPdfThumbnailHandlerChangeSet(installDir, false);
+            getGcodePreviewHandlerChangeSet(installDir, true);
+            getGcodePreviewHandlerChangeSet(installDir, false);
+            getGcodeThumbnailHandlerChangeSet(installDir, true);
+            getGcodeThumbnailHandlerChangeSet(installDir, false);
+            getStlThumbnailHandlerChangeSet(installDir, true);
+            getStlThumbnailHandlerChangeSet(installDir, false);
+            getQoiPreviewHandlerChangeSet(installDir, true);
+            getQoiPreviewHandlerChangeSet(installDir, false);
+            getQoiThumbnailHandlerChangeSet(installDir, true);
+            getQoiThumbnailHandlerChangeSet(installDir, false);
+
+            Assert::IsTrue(true);
+        }
+    };
+}

src/common/UnitTests-CommonUtils/MsWindowsSettings.Tests.cpp

@@ -0,0 +1,65 @@
+#include "pch.h"
+#include "TestHelpers.h"
+#include <MsWindowsSettings.h>
+
+using namespace Microsoft::VisualStudio::CppUnitTestFramework;
+
+namespace UnitTestsCommonUtils
+{
+    TEST_CLASS(MsWindowsSettingsTests)
+    {
+    public:
+        TEST_METHOD(GetAnimationsEnabled_ReturnsBoolean)
+        {
+            bool result = GetAnimationsEnabled();
+
+            // Should return a valid boolean
+            Assert::IsTrue(result == true || result == false);
+        }
+
+        TEST_METHOD(GetAnimationsEnabled_ConsistentResults)
+        {
+            // Multiple calls should return consistent results
+            bool result1 = GetAnimationsEnabled();
+            bool result2 = GetAnimationsEnabled();
+            bool result3 = GetAnimationsEnabled();
+
+            Assert::AreEqual(result1, result2);
+            Assert::AreEqual(result2, result3);
+        }
+
+        TEST_METHOD(GetAnimationsEnabled_DoesNotCrash)
+        {
+            // Call multiple times to ensure stability
+            for (int i = 0; i < 100; ++i)
+            {
+                GetAnimationsEnabled();
+            }
+            Assert::IsTrue(true);
+        }
+
+        TEST_METHOD(GetAnimationsEnabled_ThreadSafe)
+        {
+            std::vector<std::thread> threads;
+            std::atomic<int> successCount{ 0 };
+
+            for (int i = 0; i < 10; ++i)
+            {
+                threads.emplace_back([&successCount]() {
+                    for (int j = 0; j < 10; ++j)
+                    {
+                        GetAnimationsEnabled();
+                        successCount++;
+                    }
+                });
+            }
+
+            for (auto& t : threads)
+            {
+                t.join();
+            }
+
+            Assert::AreEqual(100, successCount.load());
+        }
+    };
+}

src/common/UnitTests-CommonUtils/MsiUtils.Tests.cpp

@@ -0,0 +1,146 @@
+#include "pch.h"
+#include "TestHelpers.h"
+#include <MsiUtils.h>
+
+using namespace Microsoft::VisualStudio::CppUnitTestFramework;
+
+namespace UnitTestsCommonUtils
+{
+    TEST_CLASS(MsiUtilsTests)
+    {
+    public:
+        // GetMsiPackageInstalledPath tests
+        TEST_METHOD(GetMsiPackageInstalledPath_PerUser_DoesNotCrash)
+        {
+            auto result = GetMsiPackageInstalledPath(true);
+            // Result depends on installation state, but should not crash
+            Assert::IsTrue(true);
+        }
+
+        TEST_METHOD(GetMsiPackageInstalledPath_PerMachine_DoesNotCrash)
+        {
+            auto result = GetMsiPackageInstalledPath(false);
+            // Result depends on installation state, but should not crash
+            Assert::IsTrue(true);
+        }
+
+        TEST_METHOD(GetMsiPackageInstalledPath_ConsistentResults)
+        {
+            auto result1 = GetMsiPackageInstalledPath(true);
+            auto result2 = GetMsiPackageInstalledPath(true);
+
+            // Results should be consistent
+            Assert::AreEqual(result1.has_value(), result2.has_value());
+            if (result1.has_value() && result2.has_value())
+            {
+                Assert::AreEqual(*result1, *result2);
+            }
+        }
+
+        TEST_METHOD(GetMsiPackageInstalledPath_PerUserVsPerMachine_MayDiffer)
+        {
+            auto perUser = GetMsiPackageInstalledPath(true);
+            auto perMachine = GetMsiPackageInstalledPath(false);
+
+            // These may or may not be equal depending on installation
+            // Just verify they don't crash
+            Assert::IsTrue(true);
+        }
+
+        // GetMsiPackagePath tests
+        TEST_METHOD(GetMsiPackagePath_DoesNotCrash)
+        {
+            auto result = GetMsiPackagePath();
+            // Result depends on installation state, but should not crash
+            Assert::IsTrue(true);
+        }
+
+        TEST_METHOD(GetMsiPackagePath_ConsistentResults)
+        {
+            auto result1 = GetMsiPackagePath();
+            auto result2 = GetMsiPackagePath();
+
+            // Results should be consistent
+            Assert::AreEqual(result1, result2);
+        }
+
+        // Thread safety tests
+        TEST_METHOD(GetMsiPackageInstalledPath_ThreadSafe)
+        {
+            std::vector<std::thread> threads;
+            std::atomic<int> successCount{ 0 };
+
+            for (int i = 0; i < 5; ++i)
+            {
+                threads.emplace_back([&successCount]() {
+                    for (int j = 0; j < 5; ++j)
+                    {
+                        GetMsiPackageInstalledPath(j % 2 == 0);
+                        successCount++;
+                    }
+                });
+            }
+
+            for (auto& t : threads)
+            {
+                t.join();
+            }
+
+            Assert::AreEqual(25, successCount.load());
+        }
+
+        TEST_METHOD(GetMsiPackagePath_ThreadSafe)
+        {
+            std::vector<std::thread> threads;
+            std::atomic<int> successCount{ 0 };
+
+            for (int i = 0; i < 5; ++i)
+            {
+                threads.emplace_back([&successCount]() {
+                    for (int j = 0; j < 5; ++j)
+                    {
+                        GetMsiPackagePath();
+                        successCount++;
+                    }
+                });
+            }
+
+            for (auto& t : threads)
+            {
+                t.join();
+            }
+
+            Assert::AreEqual(25, successCount.load());
+        }
+
+        // Return value format tests
+        TEST_METHOD(GetMsiPackageInstalledPath_ReturnsValidPathOrEmpty)
+        {
+            auto path = GetMsiPackageInstalledPath(true);
+
+            if (path.has_value() && !path->empty())
+            {
+                // If a path is returned, it should contain backslash or be a valid path format
+                Assert::IsTrue(path->find(L'\\') != std::wstring::npos ||
+                              path->find(L'/') != std::wstring::npos ||
+                              path->length() >= 2); // At minimum drive letter + colon
+            }
+            // No value or empty is also valid (not installed)
+            Assert::IsTrue(true);
+        }
+
+        TEST_METHOD(GetMsiPackagePath_ReturnsValidPathOrEmpty)
+        {
+            auto path = GetMsiPackagePath();
+
+            if (!path.empty())
+            {
+                // If a path is returned, it should be a valid path format
+                Assert::IsTrue(path.find(L'\\') != std::wstring::npos ||
+                              path.find(L'/') != std::wstring::npos ||
+                              path.length() >= 2);
+            }
+            Assert::IsTrue(true);
+        }
+    };
+}

src/common/UnitTests-CommonUtils/OsDetect.Tests.cpp

@@ -0,0 +1,107 @@
+#include "pch.h"
+#include "TestHelpers.h"
+#include <os-detect.h>
+
+using namespace Microsoft::VisualStudio::CppUnitTestFramework;
+
+namespace UnitTestsCommonUtils
+{
+    TEST_CLASS(OsDetectTests)
+    {
+    public:
+        // IsAPIContractVxAvailable tests
+        TEST_METHOD(IsAPIContractV8Available_ReturnsBoolean)
+        {
+            // This test verifies the function runs without crashing
+            // The actual result depends on the OS version
+            bool result = IsAPIContractV8Available();
+            // Result is either true or false, both are valid
+            Assert::IsTrue(result == true || result == false);
+        }
+
+        TEST_METHOD(IsAPIContractVxAvailable_V1_ReturnsTrue)
+        {
+            // API contract v1 should be available on any modern Windows
+            bool result = IsAPIContractVxAvailable<1>();
+            Assert::IsTrue(result);
+        }
+
+        TEST_METHOD(IsAPIContractVxAvailable_V5_ReturnsBooleanConsistently)
+        {
+            // Call multiple times to verify caching works correctly
+            bool result1 = IsAPIContractVxAvailable<5>();
+            bool result2 = IsAPIContractVxAvailable<5>();
+            bool result3 = IsAPIContractVxAvailable<5>();
+            Assert::AreEqual(result1, result2);
+            Assert::AreEqual(result2, result3);
+        }
+
+        TEST_METHOD(IsAPIContractVxAvailable_V10_ReturnsBoolean)
+        {
+            bool result = IsAPIContractVxAvailable<10>();
+            // Result depends on Windows version, but should not crash
+            Assert::IsTrue(result == true || result == false);
+        }
+
+        TEST_METHOD(IsAPIContractVxAvailable_V15_ReturnsBoolean)
+        {
+            bool result = IsAPIContractVxAvailable<15>();
+            // Higher API versions, may or may not be available
+            Assert::IsTrue(result == true || result == false);
+        }
+
+        // Is19H1OrHigher tests
+        TEST_METHOD(Is19H1OrHigher_ReturnsBoolean)
+        {
+            bool result = Is19H1OrHigher();
+            // Result depends on OS version, but should not crash
+            Assert::IsTrue(result == true || result == false);
+        }
+
+        TEST_METHOD(Is19H1OrHigher_ReturnsSameAsV8Contract)
+        {
+            // Is19H1OrHigher is implemented as IsAPIContractV8Available
+            bool is19H1 = Is19H1OrHigher();
+            bool isV8 = IsAPIContractV8Available();
+            Assert::AreEqual(is19H1, isV8);
+        }
+
+        TEST_METHOD(Is19H1OrHigher_ConsistentAcrossMultipleCalls)
+        {
+            bool result1 = Is19H1OrHigher();
+            bool result2 = Is19H1OrHigher();
+            bool result3 = Is19H1OrHigher();
+            Assert::AreEqual(result1, result2);
+            Assert::AreEqual(result2, result3);
+        }
+
+        // Static caching behavior tests
+        TEST_METHOD(StaticCaching_DifferentContractVersions_IndependentResults)
+        {
+            // Each template instantiation has its own static variable
+            bool v1 = IsAPIContractVxAvailable<1>();
+            (void)v1; // Suppress unused variable warning
+
+            // v1 should be true on any modern Windows
+            Assert::IsTrue(v1);
+        }
+
+        // Performance test (optional - verifies caching)
+        TEST_METHOD(Performance_MultipleCallsAreFast)
+        {
+            // The static caching should make subsequent calls very fast
+            auto start = std::chrono::high_resolution_clock::now();
+
+            for (int i = 0; i < 10000; ++i)
+            {
+                Is19H1OrHigher();
+            }
+
+            auto end = std::chrono::high_resolution_clock::now();
+            auto duration = std::chrono::duration_cast<std::chrono::milliseconds>(end - start);
+
+            // 10000 calls should complete in well under 1 second due to caching
+            Assert::IsTrue(duration.count() < 1000);
+        }
+    };
+}

src/common/UnitTests-CommonUtils/Package.Tests.cpp

@@ -0,0 +1,180 @@
+#include "pch.h"
+#include "TestHelpers.h"
+#include <package.h>
+
+using namespace Microsoft::VisualStudio::CppUnitTestFramework;
+using namespace package;
+
+namespace UnitTestsCommonUtils
+{
+    TEST_CLASS(PackageTests)
+    {
+    public:
+        // IsWin11OrGreater tests
+        TEST_METHOD(IsWin11OrGreater_ReturnsBoolean)
+        {
+            bool result = IsWin11OrGreater();
+            Assert::IsTrue(result == true || result == false);
+        }
+
+        TEST_METHOD(IsWin11OrGreater_ConsistentResults)
+        {
+            bool result1 = IsWin11OrGreater();
+            bool result2 = IsWin11OrGreater();
+            bool result3 = IsWin11OrGreater();
+
+            Assert::AreEqual(result1, result2);
+            Assert::AreEqual(result2, result3);
+        }
+
+        // PACKAGE_VERSION struct tests
+        TEST_METHOD(PackageVersion_DefaultConstruction)
+        {
+            PACKAGE_VERSION version{};
+            Assert::AreEqual(static_cast<UINT16>(0), version.Major);
+            Assert::AreEqual(static_cast<UINT16>(0), version.Minor);
+            Assert::AreEqual(static_cast<UINT16>(0), version.Build);
+            Assert::AreEqual(static_cast<UINT16>(0), version.Revision);
+        }
+
+        TEST_METHOD(PackageVersion_Assignment)
+        {
+            PACKAGE_VERSION version{};
+            version.Major = 1;
+            version.Minor = 2;
+            version.Build = 3;
+            version.Revision = 4;
+
+            Assert::AreEqual(static_cast<UINT16>(1), version.Major);
+            Assert::AreEqual(static_cast<UINT16>(2), version.Minor);
+            Assert::AreEqual(static_cast<UINT16>(3), version.Build);
+            Assert::AreEqual(static_cast<UINT16>(4), version.Revision);
+        }
+
+        // ComInitializer tests
+        TEST_METHOD(ComInitializer_InitializesAndUninitializesCom)
+        {
+            {
+                ComInitializer comInit;
+                // COM should be initialized within this scope
+            }
+            // COM should be uninitialized after scope
+
+            // Verify we can initialize again
+            {
+                ComInitializer comInit2;
+            }
+
+            Assert::IsTrue(true);
+        }
+
+        TEST_METHOD(ComInitializer_MultipleInstances)
+        {
+            ComInitializer init1;
+            ComInitializer init2;
+            ComInitializer init3;
+
+            // Multiple initializations should work (COM uses reference counting)
+            Assert::IsTrue(true);
+        }
+
+        // GetRegisteredPackage tests
+        TEST_METHOD(GetRegisteredPackage_NonExistentPackage_ReturnsEmpty)
+        {
+            auto result = GetRegisteredPackage(L"NonExistentPackage12345", false);
+
+            // Should return empty for non-existent package
+            Assert::IsFalse(result.has_value());
+        }
+
+        TEST_METHOD(GetRegisteredPackage_EmptyName_DoesNotCrash)
+        {
+            auto result = GetRegisteredPackage(L"", false);
+            // Behavior may vary based on package enumeration; just ensure it doesn't crash.
+            Assert::IsTrue(true);
+        }
+
+        // IsPackageRegisteredWithPowerToysVersion tests
+        TEST_METHOD(IsPackageRegisteredWithPowerToysVersion_NonExistentPackage_ReturnsFalse)
+        {
+            bool result = IsPackageRegisteredWithPowerToysVersion(L"NonExistentPackage12345");
+            Assert::IsFalse(result);
+        }
+
+        TEST_METHOD(IsPackageRegisteredWithPowerToysVersion_EmptyName_ReturnsFalse)
+        {
+            bool result = IsPackageRegisteredWithPowerToysVersion(L"");
+            Assert::IsFalse(result);
+        }
+
+        // FindMsixFile tests
+        TEST_METHOD(FindMsixFile_NonExistentDirectory_ReturnsEmpty)
+        {
+            auto result = FindMsixFile(L"C:\\NonExistentDirectory12345", false);
+            Assert::IsTrue(result.empty());
+        }
+
+        TEST_METHOD(FindMsixFile_SystemDirectory_DoesNotCrash)
+        {
+            // System32 probably doesn't have MSIX files, but shouldn't crash
+            auto result = FindMsixFile(L"C:\\Windows\\System32", false);
+            // May or may not find files, but should not crash
+            Assert::IsTrue(true);
+        }
+
+        TEST_METHOD(FindMsixFile_RecursiveSearch_DoesNotCrash)
+        {
+            // Use temp directory which should exist
+            wchar_t tempPath[MAX_PATH];
+            GetTempPathW(MAX_PATH, tempPath);
+
+            auto result = FindMsixFile(tempPath, true);
+            // May or may not find files, but should not crash
+            Assert::IsTrue(true);
+        }
+
+        // GetPackageNameAndVersionFromAppx tests
+        TEST_METHOD(GetPackageNameAndVersionFromAppx_NonExistentFile_ReturnsFalse)
+        {
+            std::wstring name;
+            PACKAGE_VERSION version{};
+
+            bool result = GetPackageNameAndVersionFromAppx(L"C:\\NonExistent\\file.msix", name, version);
+            Assert::IsFalse(result);
+        }
+
+        TEST_METHOD(GetPackageNameAndVersionFromAppx_EmptyPath_ReturnsFalse)
+        {
+            std::wstring name;
+            PACKAGE_VERSION version{};
+
+            bool result = GetPackageNameAndVersionFromAppx(L"", name, version);
+            Assert::IsFalse(result);
+        }
+
+        // Thread safety
+        TEST_METHOD(IsWin11OrGreater_ThreadSafe)
+        {
+            std::vector<std::thread> threads;
+            std::atomic<int> successCount{ 0 };
+
+            for (int i = 0; i < 10; ++i)
+            {
+                threads.emplace_back([&successCount]() {
+                    for (int j = 0; j < 10; ++j)
+                    {
+                        IsWin11OrGreater();
+                        successCount++;
+                    }
+                });
+            }
+
+            for (auto& t : threads)
+            {
+                t.join();
+            }
+
+            Assert::AreEqual(100, successCount.load());
+        }
+    };
+}

src/common/UnitTests-CommonUtils/ProcessApi.Tests.cpp

@@ -0,0 +1,136 @@
+#include "pch.h"
+#include "TestHelpers.h"
+#include <processApi.h>
+
+using namespace Microsoft::VisualStudio::CppUnitTestFramework;
+
+namespace UnitTestsCommonUtils
+{
+    TEST_CLASS(ProcessApiTests)
+    {
+    public:
+        TEST_METHOD(GetProcessHandlesByName_CurrentProcess_ReturnsHandles)
+        {
+            // Get current process executable name
+            wchar_t path[MAX_PATH];
+            GetModuleFileNameW(nullptr, path, MAX_PATH);
+
+            // Extract just the filename
+            std::wstring fullPath(path);
+            auto lastSlash = fullPath.rfind(L'\\');
+            std::wstring exeName = (lastSlash != std::wstring::npos) ?
+                fullPath.substr(lastSlash + 1) : fullPath;
+
+            auto handles = getProcessHandlesByName(exeName, PROCESS_QUERY_LIMITED_INFORMATION);
+
+            // Should find at least our own process
+            Assert::IsFalse(handles.empty());
+
+            // Handles are RAII-managed
+        }
+
+        TEST_METHOD(GetProcessHandlesByName_NonExistentProcess_ReturnsEmpty)
+        {
+            auto handles = getProcessHandlesByName(L"NonExistentProcess12345.exe", PROCESS_QUERY_LIMITED_INFORMATION);
+            Assert::IsTrue(handles.empty());
+        }
+
+        TEST_METHOD(GetProcessHandlesByName_EmptyName_ReturnsEmpty)
+        {
+            auto handles = getProcessHandlesByName(L"", PROCESS_QUERY_LIMITED_INFORMATION);
+            Assert::IsTrue(handles.empty());
+        }
+
+        TEST_METHOD(GetProcessHandlesByName_Explorer_ReturnsHandles)
+        {
+            // Explorer.exe should typically be running
+            auto handles = getProcessHandlesByName(L"explorer.exe", PROCESS_QUERY_LIMITED_INFORMATION);
+
+            // Handles are RAII-managed
+
+            // May or may not find explorer depending on system state
+            // Just verify it doesn't crash
+            Assert::IsTrue(true);
+        }
+
+        TEST_METHOD(GetProcessHandlesByName_CaseInsensitive_Works)
+        {
+            // Get current process name in uppercase
+            wchar_t path[MAX_PATH];
+            GetModuleFileNameW(nullptr, path, MAX_PATH);
+
+            std::wstring fullPath(path);
+            auto lastSlash = fullPath.rfind(L'\\');
+            std::wstring exeName = (lastSlash != std::wstring::npos) ?
+                fullPath.substr(lastSlash + 1) : fullPath;
+
+            // Convert to uppercase
+            std::wstring upperName = exeName;
+            std::transform(upperName.begin(), upperName.end(), upperName.begin(), ::towupper);
+
+            auto handles = getProcessHandlesByName(upperName, PROCESS_QUERY_LIMITED_INFORMATION);
+
+            // Handles are RAII-managed
+
+            // The function may or may not be case insensitive - just don't crash
+            Assert::IsTrue(true);
+        }
+
+        TEST_METHOD(GetProcessHandlesByName_DifferentAccessRights_Works)
+        {
+            wchar_t path[MAX_PATH];
+            GetModuleFileNameW(nullptr, path, MAX_PATH);
+
+            std::wstring fullPath(path);
+            auto lastSlash = fullPath.rfind(L'\\');
+            std::wstring exeName = (lastSlash != std::wstring::npos) ?
+                fullPath.substr(lastSlash + 1) : fullPath;
+
+            // Try with different access rights
+            auto handles1 = getProcessHandlesByName(exeName, PROCESS_QUERY_INFORMATION);
+            auto handles2 = getProcessHandlesByName(exeName, PROCESS_VM_READ);
+
+            // Handles are RAII-managed
+
+            // Just verify no crashes
+            Assert::IsTrue(true);
+        }
+
+        TEST_METHOD(GetProcessHandlesByName_SystemProcess_MayRequireElevation)
+        {
+            // System processes might require elevation
+            auto handles = getProcessHandlesByName(L"System", PROCESS_QUERY_LIMITED_INFORMATION);
+
+            // Handles are RAII-managed
+
+            // Just verify no crashes
+            Assert::IsTrue(true);
+        }
+
+        TEST_METHOD(GetProcessHandlesByName_ValidHandles_AreUsable)
+        {
+            wchar_t path[MAX_PATH];
+            GetModuleFileNameW(nullptr, path, MAX_PATH);
+
+            std::wstring fullPath(path);
+            auto lastSlash = fullPath.rfind(L'\\');
+            std::wstring exeName = (lastSlash != std::wstring::npos) ?
+                fullPath.substr(lastSlash + 1) : fullPath;
+
+            auto handles = getProcessHandlesByName(exeName, PROCESS_QUERY_LIMITED_INFORMATION);
+
+            bool foundValidHandle = false;
+            for (auto& handle : handles)
+            {
+                // Try to use the handle
+                DWORD exitCode;
+                if (GetExitCodeProcess(handle.get(), &exitCode))
+                {
+                    foundValidHandle = true;
+                }
+            }
+
+            Assert::IsTrue(foundValidHandle || handles.empty());
+        }
+    };
+}

src/common/UnitTests-CommonUtils/ProcessPath.Tests.cpp

@@ -0,0 +1,153 @@
+#include "pch.h"
+#include "TestHelpers.h"
+#include <process_path.h>
+
+using namespace Microsoft::VisualStudio::CppUnitTestFramework;
+
+namespace UnitTestsCommonUtils
+{
+    TEST_CLASS(ProcessPathTests)
+    {
+    public:
+        // get_process_path (by PID) tests
+        TEST_METHOD(GetProcessPath_CurrentProcess_ReturnsPath)
+        {
+            DWORD pid = GetCurrentProcessId();
+            auto path = get_process_path(pid);
+
+            Assert::IsFalse(path.empty());
+            Assert::IsTrue(path.find(L".exe") != std::wstring::npos ||
+                          path.find(L".dll") != std::wstring::npos);
+        }
+
+        TEST_METHOD(GetProcessPath_InvalidPid_ReturnsEmpty)
+        {
+            DWORD invalidPid = 0xFFFFFFFF;
+            auto path = get_process_path(invalidPid);
+
+            // Should return empty for invalid PID
+            Assert::IsTrue(path.empty());
+        }
+
+        TEST_METHOD(GetProcessPath_ZeroPid_ReturnsEmpty)
+        {
+            auto path = get_process_path(static_cast<DWORD>(0));
+            // PID 0 is the System Idle Process, might return empty or a path
+            // Just verify it doesn't crash
+            Assert::IsTrue(true);
+        }
+
+        TEST_METHOD(GetProcessPath_SystemPid_DoesNotCrash)
+        {
+            // PID 4 is typically the System process
+            auto path = get_process_path(static_cast<DWORD>(4));
+            // May return empty due to access rights, but shouldn't crash
+            Assert::IsTrue(true);
+        }
+
+        // get_module_filename tests
+        TEST_METHOD(GetModuleFilename_NullModule_ReturnsExePath)
+        {
+            auto path = get_module_filename(nullptr);
+
+            Assert::IsFalse(path.empty());
+            Assert::IsTrue(path.find(L".exe") != std::wstring::npos ||
+                          path.find(L".dll") != std::wstring::npos);
+        }
+
+        TEST_METHOD(GetModuleFilename_Kernel32_ReturnsPath)
+        {
+            HMODULE kernel32 = GetModuleHandleW(L"kernel32.dll");
+            Assert::IsNotNull(kernel32);
+
+            auto path = get_module_filename(kernel32);
+
+            Assert::IsFalse(path.empty());
+            // Should contain kernel32 (case insensitive check)
+            std::wstring lowerPath = path;
+            std::transform(lowerPath.begin(), lowerPath.end(), lowerPath.begin(), ::towlower);
+            Assert::IsTrue(lowerPath.find(L"kernel32") != std::wstring::npos);
+        }
+
+        TEST_METHOD(GetModuleFilename_InvalidModule_ReturnsEmpty)
+        {
+            auto path = get_module_filename(reinterpret_cast<HMODULE>(0x12345678));
+            // Invalid module should return empty
+            Assert::IsTrue(path.empty());
+        }
+
+        // get_module_folderpath tests
+        TEST_METHOD(GetModuleFolderpath_NullModule_ReturnsFolder)
+        {
+            auto folder = get_module_folderpath(nullptr, true);
+
+            Assert::IsFalse(folder.empty());
+            // Should not end with .exe when removeFilename is true
+            Assert::IsTrue(folder.find(L".exe") == std::wstring::npos);
+            // Should end with backslash or be a valid folder path
+            Assert::IsTrue(folder.back() == L'\\' || folder.find(L"\\") != std::wstring::npos);
+        }
+
+        TEST_METHOD(GetModuleFolderpath_KeepFilename_ReturnsFullPath)
+        {
+            auto fullPath = get_module_folderpath(nullptr, false);
+
+            Assert::IsFalse(fullPath.empty());
+            // Should contain .exe or .dll when not removing filename
+            Assert::IsTrue(fullPath.find(L".exe") != std::wstring::npos ||
+                          fullPath.find(L".dll") != std::wstring::npos);
+        }
+
+        TEST_METHOD(GetModuleFolderpath_Kernel32_ReturnsSystem32)
+        {
+            HMODULE kernel32 = GetModuleHandleW(L"kernel32.dll");
+            Assert::IsNotNull(kernel32);
+
+            auto folder = get_module_folderpath(kernel32, true);
+
+            Assert::IsFalse(folder.empty());
+            // Should be in system32 folder
+            std::wstring lowerPath = folder;
+            std::transform(lowerPath.begin(), lowerPath.end(), lowerPath.begin(), ::towlower);
+            Assert::IsTrue(lowerPath.find(L"system32") != std::wstring::npos ||
+                          lowerPath.find(L"syswow64") != std::wstring::npos);
+        }
+
+        // get_process_path (by HWND) tests
+        TEST_METHOD(GetProcessPath_DesktopWindow_ReturnsPath)
+        {
+            HWND desktop = GetDesktopWindow();
+            Assert::IsNotNull(desktop);
+
+            auto path = get_process_path(desktop);
+            // Desktop window should return a path
+            // (could be explorer.exe or empty depending on system)
+            Assert::IsTrue(true); // Just verify it doesn't crash
+        }
+
+        TEST_METHOD(GetProcessPath_InvalidHwnd_ReturnsEmpty)
+        {
+            auto path = get_process_path(reinterpret_cast<HWND>(0x12345678));
+            Assert::IsTrue(path.empty());
+        }
+
+        TEST_METHOD(GetProcessPath_NullHwnd_ReturnsEmpty)
+        {
+            auto path = get_process_path(static_cast<HWND>(nullptr));
+            Assert::IsTrue(path.empty());
+        }
+
+        // Consistency tests
+        TEST_METHOD(Consistency_ModuleFilenameAndFolderpath_AreRelated)
+        {
+            auto fullPath = get_module_filename(nullptr);
+            auto folder = get_module_folderpath(nullptr, true);
+
+            Assert::IsFalse(fullPath.empty());
+            Assert::IsFalse(folder.empty());
+
+            // Full path should start with the folder
+            Assert::IsTrue(fullPath.find(folder) == 0 || folder.find(fullPath.substr(0, folder.length())) == 0);
+        }
+    };
+}

src/common/UnitTests-CommonUtils/ProcessWaiter.Tests.cpp

@@ -0,0 +1,127 @@
+#include "pch.h"
+#include "TestHelpers.h"
+#include <ProcessWaiter.h>
+
+using namespace Microsoft::VisualStudio::CppUnitTestFramework;
+using namespace ProcessWaiter;
+
+namespace UnitTestsCommonUtils
+{
+    TEST_CLASS(ProcessWaiterTests)
+    {
+    public:
+        TEST_METHOD(OnProcessTerminate_InvalidPid_DoesNotCrash)
+        {
+            std::atomic<bool> called{ false };
+
+            // Use a very unlikely PID (negative value as string will fail conversion)
+            OnProcessTerminate(L"invalid", [&called](DWORD) {
+                called = true;
+            });
+
+            // Wait briefly
+            std::this_thread::sleep_for(std::chrono::milliseconds(100));
+
+            // Should not crash, callback may or may not be called depending on implementation
+            Assert::IsTrue(true);
+        }
+
+        TEST_METHOD(OnProcessTerminate_NonExistentPid_DoesNotCrash)
+        {
+            std::atomic<bool> called{ false };
+
+            // Use a PID that likely doesn't exist
+            OnProcessTerminate(L"999999999", [&called](DWORD) {
+                called = true;
+            });
+
+            // Wait briefly
+            std::this_thread::sleep_for(std::chrono::milliseconds(100));
+
+            // Should not crash
+            Assert::IsTrue(true);
+        }
+
+        TEST_METHOD(OnProcessTerminate_ZeroPid_DoesNotCrash)
+        {
+            std::atomic<bool> called{ false };
+
+            OnProcessTerminate(L"0", [&called](DWORD) {
+                called = true;
+            });
+
+            std::this_thread::sleep_for(std::chrono::milliseconds(100));
+            Assert::IsTrue(true);
+        }
+
+        TEST_METHOD(OnProcessTerminate_CurrentProcessPid_DoesNotTerminate)
+        {
+            std::atomic<bool> called{ false };
+
+            // Use current process PID - it shouldn't terminate during test
+            std::wstring pid = std::to_wstring(GetCurrentProcessId());
+
+            OnProcessTerminate(pid, [&called](DWORD) {
+                called = true;
+            });
+
+            // Wait briefly - current process should not terminate
+            std::this_thread::sleep_for(std::chrono::milliseconds(200));
+
+            // Callback should not have been called since process is still running
+            Assert::IsFalse(called);
+        }
+
+        TEST_METHOD(OnProcessTerminate_EmptyCallback_DoesNotCrash)
+        {
+            // Test with an empty function
+            OnProcessTerminate(L"999999999", std::function<void(DWORD)>());
+
+            std::this_thread::sleep_for(std::chrono::milliseconds(100));
+            Assert::IsTrue(true);
+        }
+
+        TEST_METHOD(OnProcessTerminate_MultipleCallsForSamePid_DoesNotCrash)
+        {
+            std::atomic<int> counter{ 0 };
+            std::wstring pid = std::to_wstring(GetCurrentProcessId());
+
+            // Multiple waits on same (running) process
+            for (int i = 0; i < 5; ++i)
+            {
+                OnProcessTerminate(pid, [&counter](DWORD) {
+                    counter++;
+                });
+            }
+
+            std::this_thread::sleep_for(std::chrono::milliseconds(200));
+
+            // None should have been called since process is running
+            Assert::AreEqual(0, counter.load());
+        }
+
+        TEST_METHOD(OnProcessTerminate_NegativeNumberString_DoesNotCrash)
+        {
+            std::atomic<bool> called{ false };
+
+            OnProcessTerminate(L"-1", [&called](DWORD) {
+                called = true;
+            });
+
+            std::this_thread::sleep_for(std::chrono::milliseconds(100));
+            Assert::IsTrue(true);
+        }
+
+        TEST_METHOD(OnProcessTerminate_LargeNumber_DoesNotCrash)
+        {
+            std::atomic<bool> called{ false };
+
+            OnProcessTerminate(L"18446744073709551615", [&called](DWORD) {
+                called = true;
+            });
+
+            std::this_thread::sleep_for(std::chrono::milliseconds(100));
+            Assert::IsTrue(true);
+        }
+    };
+}

src/common/UnitTests-CommonUtils/Registry.Tests.cpp

@@ -0,0 +1,61 @@
+#include "pch.h"
+#include "TestHelpers.h"
+#include <registry.h>
+
+using namespace Microsoft::VisualStudio::CppUnitTestFramework;
+
+namespace UnitTestsCommonUtils
+{
+    TEST_CLASS(RegistryTests)
+    {
+    public:
+        // Note: These tests use HKCU which doesn't require elevation
+
+        TEST_METHOD(InstallScope_Registry_CanReadAndWrite)
+        {
+            TestHelpers::TestRegistryKey testKey(L"RegistryTest");
+            Assert::IsTrue(testKey.isValid());
+
+            // Write a test value
+            Assert::IsTrue(testKey.setStringValue(L"TestValue", L"TestData"));
+            Assert::IsTrue(testKey.setDwordValue(L"TestDword", 42));
+        }
+
+        TEST_METHOD(Registry_ValueChange_StringValue)
+        {
+            registry::ValueChange change{ HKEY_CURRENT_USER, L"Software\\PowerToys\\Test", L"TestValue", std::wstring{ L"TestData" } };
+
+            Assert::AreEqual(std::wstring(L"Software\\PowerToys\\Test"), change.path);
+            Assert::IsTrue(change.name.has_value());
+            Assert::AreEqual(std::wstring(L"TestValue"), *change.name);
+            Assert::AreEqual(std::wstring(L"TestData"), std::get<std::wstring>(change.value));
+        }
+
+        TEST_METHOD(Registry_ValueChange_DwordValue)
+        {
+            registry::ValueChange change{ HKEY_CURRENT_USER, L"Software\\PowerToys\\Test", L"TestDword", static_cast<DWORD>(42) };
+
+            Assert::AreEqual(std::wstring(L"Software\\PowerToys\\Test"), change.path);
+            Assert::IsTrue(change.name.has_value());
+            Assert::AreEqual(std::wstring(L"TestDword"), *change.name);
+            Assert::AreEqual(static_cast<DWORD>(42), std::get<DWORD>(change.value));
+        }
+
+        TEST_METHOD(Registry_ChangeSet_AddChanges)
+        {
+            registry::ChangeSet changeSet;
+
+            changeSet.changes.push_back({ HKEY_CURRENT_USER, L"Software\\PowerToys\\Test", L"Value1", std::wstring{ L"Data1" } });
+            changeSet.changes.push_back({ HKEY_CURRENT_USER, L"Software\\PowerToys\\Test", L"Value2", static_cast<DWORD>(123) });
+
+            Assert::AreEqual(static_cast<size_t>(2), changeSet.changes.size());
+        }
+
+        TEST_METHOD(InstallScope_GetCurrentInstallScope_ReturnsValidValue)
+        {
+            auto scope = registry::install_scope::get_current_install_scope();
+            Assert::IsTrue(scope == registry::install_scope::InstallScope::PerMachine ||
+                          scope == registry::install_scope::InstallScope::PerUser);
+        }
+    };
+}

src/common/UnitTests-CommonUtils/Resources.Tests.cpp

@@ -0,0 +1,144 @@
+#include "pch.h"
+#include "TestHelpers.h"
+#include <resources.h>
+
+using namespace Microsoft::VisualStudio::CppUnitTestFramework;
+
+namespace UnitTestsCommonUtils
+{
+    TEST_CLASS(ResourcesTests)
+    {
+    public:
+        // get_resource_string tests with current module
+        TEST_METHOD(GetResourceString_NonExistentId_ReturnsFallback)
+        {
+            HINSTANCE instance = GetModuleHandleW(nullptr);
+
+            auto result = get_resource_string(99999, instance, L"fallback");
+            Assert::AreEqual(std::wstring(L"fallback"), result);
+        }
+
+        TEST_METHOD(GetResourceString_NullInstance_UsesFallback)
+        {
+            auto result = get_resource_string(99999, nullptr, L"fallback");
+            // Should return fallback or empty string
+            Assert::IsTrue(result == L"fallback" || result.empty());
+        }
+
+        TEST_METHOD(GetResourceString_EmptyFallback_ReturnsEmpty)
+        {
+            HINSTANCE instance = GetModuleHandleW(nullptr);
+
+            auto result = get_resource_string(99999, instance, L"");
+            Assert::IsTrue(result.empty());
+        }
+
+        // get_english_fallback_string tests
+        TEST_METHOD(GetEnglishFallbackString_NonExistentId_ReturnsEmpty)
+        {
+            HINSTANCE instance = GetModuleHandleW(nullptr);
+
+            auto result = get_english_fallback_string(99999, instance);
+            // Should return empty or the resource if it exists
+            Assert::IsTrue(true); // Just verify no crash
+        }
+
+        TEST_METHOD(GetEnglishFallbackString_NullInstance_DoesNotCrash)
+        {
+            auto result = get_english_fallback_string(99999, nullptr);
+            Assert::IsTrue(true); // Just verify no crash
+        }
+
+        // get_resource_string_language_override tests
+        TEST_METHOD(GetResourceStringLanguageOverride_NonExistentId_ReturnsEmpty)
+        {
+            HINSTANCE instance = GetModuleHandleW(nullptr);
+
+            auto result = get_resource_string_language_override(99999, instance);
+            // Should return empty for non-existent resource
+            Assert::IsTrue(result.empty() || !result.empty()); // Valid either way
+        }
+
+        TEST_METHOD(GetResourceStringLanguageOverride_NullInstance_DoesNotCrash)
+        {
+            auto result = get_resource_string_language_override(99999, nullptr);
+            Assert::IsTrue(true);
+        }
+
+        // Thread safety tests
+        TEST_METHOD(GetResourceString_ThreadSafe)
+        {
+            HINSTANCE instance = GetModuleHandleW(nullptr);
+            std::vector<std::thread> threads;
+            std::atomic<int> successCount{ 0 };
+
+            for (int i = 0; i < 10; ++i)
+            {
+                threads.emplace_back([&successCount, instance]() {
+                    for (int j = 0; j < 10; ++j)
+                    {
+                        get_resource_string(99999, instance, L"fallback");
+                        successCount++;
+                    }
+                });
+            }
+
+            for (auto& t : threads)
+            {
+                t.join();
+            }
+
+            Assert::AreEqual(100, successCount.load());
+        }
+
+        // Kernel32 resource tests (has known resources)
+        TEST_METHOD(GetResourceString_Kernel32_DoesNotCrash)
+        {
+            HMODULE kernel32 = GetModuleHandleW(L"kernel32.dll");
+            if (kernel32)
+            {
+                // Kernel32 has resources, but we don't know exact IDs
+                // Just verify it doesn't crash
+                get_resource_string(1, kernel32, L"fallback");
+                get_resource_string(100, kernel32, L"fallback");
+                get_resource_string(1000, kernel32, L"fallback");
+            }
+            Assert::IsTrue(true);
+        }
+
+        // Performance test
+        TEST_METHOD(GetResourceString_Performance_Acceptable)
+        {
+            HINSTANCE instance = GetModuleHandleW(nullptr);
+
+            auto start = std::chrono::high_resolution_clock::now();
+
+            for (int i = 0; i < 1000; ++i)
+            {
+                get_resource_string(99999, instance, L"fallback");
+            }
+
+            auto end = std::chrono::high_resolution_clock::now();
+            auto duration = std::chrono::duration_cast<std::chrono::milliseconds>(end - start);
+
+            // 1000 lookups should complete in under 1 second
+            Assert::IsTrue(duration.count() < 1000);
+        }
+
+        // Edge case tests
+        TEST_METHOD(GetResourceString_ZeroId_DoesNotCrash)
+        {
+            HINSTANCE instance = GetModuleHandleW(nullptr);
+            auto result = get_resource_string(0, instance, L"fallback");
+            Assert::IsTrue(true);
+        }
+
+        TEST_METHOD(GetResourceString_MaxUintId_DoesNotCrash)
+        {
+            HINSTANCE instance = GetModuleHandleW(nullptr);
+            auto result = get_resource_string(UINT_MAX, instance, L"fallback");
+            Assert::IsTrue(true);
+        }
+
+    };
+}

src/common/UnitTests-CommonUtils/Serialized.Tests.cpp

@@ -0,0 +1,286 @@
+#include "pch.h"
+#include "TestHelpers.h"
+#include <serialized.h>
+
+using namespace Microsoft::VisualStudio::CppUnitTestFramework;
+
+namespace UnitTestsCommonUtils
+{
+    TEST_CLASS(SerializedTests)
+    {
+    public:
+        // Basic Read tests
+        TEST_METHOD(Read_DefaultState_ReturnsDefaultValue)
+        {
+            Serialized<int> s;
+            int value = -1;
+            s.Read([&value](const int& v) {
+                value = v;
+            });
+            Assert::AreEqual(0, value); // Default constructed int is 0
+        }
+
+        TEST_METHOD(Read_StringType_ReturnsEmpty)
+        {
+            Serialized<std::string> s;
+            std::string value = "initial";
+            s.Read([&value](const std::string& v) {
+                value = v;
+            });
+            Assert::AreEqual(std::string(""), value);
+        }
+
+        // Basic Access tests
+        TEST_METHOD(Access_ModifyValue_ValueIsModified)
+        {
+            Serialized<int> s;
+            s.Access([](int& v) {
+                v = 42;
+            });
+
+            int value = 0;
+            s.Read([&value](const int& v) {
+                value = v;
+            });
+            Assert::AreEqual(42, value);
+        }
+
+        TEST_METHOD(Access_ModifyString_StringIsModified)
+        {
+            Serialized<std::string> s;
+            s.Access([](std::string& v) {
+                v = "hello";
+            });
+
+            std::string value;
+            s.Read([&value](const std::string& v) {
+                value = v;
+            });
+            Assert::AreEqual(std::string("hello"), value);
+        }
+
+        TEST_METHOD(Access_MultipleModifications_LastValuePersists)
+        {
+            Serialized<int> s;
+            s.Access([](int& v) { v = 1; });
+            s.Access([](int& v) { v = 2; });
+            s.Access([](int& v) { v = 3; });
+
+            int value = 0;
+            s.Read([&value](const int& v) {
+                value = v;
+            });
+            Assert::AreEqual(3, value);
+        }
+
+        // Reset tests
+        TEST_METHOD(Reset_AfterModification_ReturnsDefault)
+        {
+            Serialized<int> s;
+            s.Access([](int& v) { v = 42; });
+            s.Reset();
+
+            int value = -1;
+            s.Read([&value](const int& v) {
+                value = v;
+            });
+            Assert::AreEqual(0, value);
+        }
+
+        TEST_METHOD(Reset_String_ReturnsEmpty)
+        {
+            Serialized<std::string> s;
+            s.Access([](std::string& v) { v = "hello"; });
+            s.Reset();
+
+            std::string value = "initial";
+            s.Read([&value](const std::string& v) {
+                value = v;
+            });
+            Assert::AreEqual(std::string(""), value);
+        }
+
+        // Complex type tests
+        TEST_METHOD(Serialized_VectorType_Works)
+        {
+            Serialized<std::vector<int>> s;
+            s.Access([](std::vector<int>& v) {
+                v.push_back(1);
+                v.push_back(2);
+                v.push_back(3);
+            });
+
+            size_t size = 0;
+            int sum = 0;
+            s.Read([&size, &sum](const std::vector<int>& v) {
+                size = v.size();
+                for (int i : v) sum += i;
+            });
+
+            Assert::AreEqual(static_cast<size_t>(3), size);
+            Assert::AreEqual(6, sum);
+        }
+
+        TEST_METHOD(Serialized_MapType_Works)
+        {
+            Serialized<std::map<std::string, int>> s;
+            s.Access([](std::map<std::string, int>& v) {
+                v["one"] = 1;
+                v["two"] = 2;
+            });
+
+            int value = 0;
+            s.Read([&value](const std::map<std::string, int>& v) {
+                auto it = v.find("two");
+                if (it != v.end()) {
+                    value = it->second;
+                }
+            });
+
+            Assert::AreEqual(2, value);
+        }
+
+        // Thread safety tests
+        TEST_METHOD(ThreadSafety_ConcurrentReads_NoDataRace)
+        {
+            Serialized<int> s;
+            s.Access([](int& v) { v = 42; });
+
+            std::atomic<int> readCount{ 0 };
+            std::vector<std::thread> threads;
+
+            for (int i = 0; i < 10; ++i)
+            {
+                threads.emplace_back([&s, &readCount]() {
+                    for (int j = 0; j < 100; ++j)
+                    {
+                        s.Read([&readCount](const int& v) {
+                            if (v == 42) {
+                                readCount++;
+                            }
+                        });
+                    }
+                });
+            }
+
+            for (auto& t : threads)
+            {
+                t.join();
+            }
+
+            Assert::AreEqual(1000, readCount.load());
+        }
+
+        TEST_METHOD(ThreadSafety_ConcurrentAccessAndRead_NoDataRace)
+        {
+            Serialized<int> s;
+            std::atomic<bool> done{ false };
+            std::atomic<int> accessCount{ 0 };
+            std::atomic<int> readersReady{ 0 };
+            std::atomic<bool> start{ false };
+
+            // Writer thread
+            std::thread writer([&s, &done, &accessCount, &readersReady, &start]() {
+                while (readersReady.load() < 5)
+                {
+                    std::this_thread::yield();
+                }
+                start = true;
+                for (int i = 0; i < 100; ++i)
+                {
+                    s.Access([i](int& v) {
+                        v = i;
+                    });
+                    accessCount++;
+                }
+                done = true;
+            });
+
+            // Reader threads
+            std::vector<std::thread> readers;
+            std::atomic<int> readAttempts{ 0 };
+
+            for (int i = 0; i < 5; ++i)
+            {
+                readers.emplace_back([&s, &done, &readAttempts, &readersReady, &start]() {
+                    readersReady++;
+                    while (!start)
+                    {
+                        std::this_thread::yield();
+                    }
+                    while (!done)
+                    {
+                        s.Read([](const int& v) {
+                            // Just read the value
+                            (void)v;
+                        });
+                        readAttempts++;
+                    }
+                });
+            }
+
+            writer.join();
+            for (auto& t : readers)
+            {
+                t.join();
+            }
+
+            // Verify all access calls completed
+            Assert::AreEqual(100, accessCount.load());
+            // Verify reads happened
+            Assert::IsTrue(readAttempts > 0);
+        }
+
+        // Struct type test
+        TEST_METHOD(Serialized_StructType_Works)
+        {
+            struct TestStruct
+            {
+                int x = 0;
+                std::string name;
+            };
+
+            Serialized<TestStruct> s;
+            s.Access([](TestStruct& v) {
+                v.x = 10;
+                v.name = "test";
+            });
+
+            int x = 0;
+            std::string name;
+            s.Read([&x, &name](const TestStruct& v) {
+                x = v.x;
+                name = v.name;
+            });
+
+            Assert::AreEqual(10, x);
+            Assert::AreEqual(std::string("test"), name);
+        }
+
+        TEST_METHOD(Reset_StructType_ResetsToDefault)
+        {
+            struct TestStruct
+            {
+                int x = 0;
+                std::string name;
+            };
+
+            Serialized<TestStruct> s;
+            s.Access([](TestStruct& v) {
+                v.x = 10;
+                v.name = "test";
+            });
+            s.Reset();
+
+            int x = -1;
+            std::string name = "not empty";
+            s.Read([&x, &name](const TestStruct& v) {
+                x = v.x;
+                name = v.name;
+            });
+
+            Assert::AreEqual(0, x);
+            Assert::AreEqual(std::string(""), name);
+        }
+    };
+}

src/common/UnitTests-CommonUtils/StringUtils.Tests.cpp

@@ -0,0 +1,283 @@
+#include "pch.h"
+#include "TestHelpers.h"
+#include <string_utils.h>
+
+using namespace Microsoft::VisualStudio::CppUnitTestFramework;
+
+namespace UnitTestsCommonUtils
+{
+    TEST_CLASS(StringUtilsTests)
+    {
+    public:
+        // left_trim tests
+        TEST_METHOD(LeftTrim_EmptyString_ReturnsEmpty)
+        {
+            std::string_view input = "";
+            auto result = left_trim(input);
+            Assert::AreEqual(std::string_view(""), result);
+        }
+
+        TEST_METHOD(LeftTrim_NoWhitespace_ReturnsOriginal)
+        {
+            std::string_view input = "hello";
+            auto result = left_trim(input);
+            Assert::AreEqual(std::string_view("hello"), result);
+        }
+
+        TEST_METHOD(LeftTrim_LeadingSpaces_TrimsSpaces)
+        {
+            std::string_view input = "   hello";
+            auto result = left_trim(input);
+            Assert::AreEqual(std::string_view("hello"), result);
+        }
+
+        TEST_METHOD(LeftTrim_LeadingTabs_TrimsTabs)
+        {
+            std::string_view input = "\t\thello";
+            auto result = left_trim(input);
+            Assert::AreEqual(std::string_view("hello"), result);
+        }
+
+        TEST_METHOD(LeftTrim_LeadingNewlines_TrimsNewlines)
+        {
+            std::string_view input = "\r\n\nhello";
+            auto result = left_trim(input);
+            Assert::AreEqual(std::string_view("hello"), result);
+        }
+
+        TEST_METHOD(LeftTrim_MixedWhitespace_TrimsAll)
+        {
+            std::string_view input = " \t\r\nhello";
+            auto result = left_trim(input);
+            Assert::AreEqual(std::string_view("hello"), result);
+        }
+
+        TEST_METHOD(LeftTrim_TrailingWhitespace_PreservesTrailing)
+        {
+            std::string_view input = "   hello   ";
+            auto result = left_trim(input);
+            Assert::AreEqual(std::string_view("hello   "), result);
+        }
+
+        TEST_METHOD(LeftTrim_OnlyWhitespace_ReturnsEmpty)
+        {
+            std::string_view input = "   \t\r\n";
+            auto result = left_trim(input);
+            Assert::AreEqual(std::string_view(""), result);
+        }
+
+        TEST_METHOD(LeftTrim_CustomChars_TrimsSpecified)
+        {
+            std::string_view input = "xxxhello";
+            auto result = left_trim(input, std::string_view("x"));
+            Assert::AreEqual(std::string_view("hello"), result);
+        }
+
+        TEST_METHOD(LeftTrim_WideString_Works)
+        {
+            std::wstring_view input = L"   hello";
+            auto result = left_trim(input);
+            Assert::AreEqual(std::wstring_view(L"hello"), result);
+        }
+
+        // right_trim tests
+        TEST_METHOD(RightTrim_EmptyString_ReturnsEmpty)
+        {
+            std::string_view input = "";
+            auto result = right_trim(input);
+            Assert::AreEqual(std::string_view(""), result);
+        }
+
+        TEST_METHOD(RightTrim_NoWhitespace_ReturnsOriginal)
+        {
+            std::string_view input = "hello";
+            auto result = right_trim(input);
+            Assert::AreEqual(std::string_view("hello"), result);
+        }
+
+        TEST_METHOD(RightTrim_TrailingSpaces_TrimsSpaces)
+        {
+            std::string_view input = "hello   ";
+            auto result = right_trim(input);
+            Assert::AreEqual(std::string_view("hello"), result);
+        }
+
+        TEST_METHOD(RightTrim_TrailingTabs_TrimsTabs)
+        {
+            std::string_view input = "hello\t\t";
+            auto result = right_trim(input);
+            Assert::AreEqual(std::string_view("hello"), result);
+        }
+
+        TEST_METHOD(RightTrim_TrailingNewlines_TrimsNewlines)
+        {
+            std::string_view input = "hello\r\n\n";
+            auto result = right_trim(input);
+            Assert::AreEqual(std::string_view("hello"), result);
+        }
+
+        TEST_METHOD(RightTrim_LeadingWhitespace_PreservesLeading)
+        {
+            std::string_view input = "   hello   ";
+            auto result = right_trim(input);
+            Assert::AreEqual(std::string_view("   hello"), result);
+        }
+
+        TEST_METHOD(RightTrim_OnlyWhitespace_ReturnsEmpty)
+        {
+            std::string_view input = "   \t\r\n";
+            auto result = right_trim(input);
+            Assert::AreEqual(std::string_view(""), result);
+        }
+
+        TEST_METHOD(RightTrim_CustomChars_TrimsSpecified)
+        {
+            std::string_view input = "helloxxx";
+            auto result = right_trim(input, std::string_view("x"));
+            Assert::AreEqual(std::string_view("hello"), result);
+        }
+
+        TEST_METHOD(RightTrim_WideString_Works)
+        {
+            std::wstring_view input = L"hello   ";
+            auto result = right_trim(input);
+            Assert::AreEqual(std::wstring_view(L"hello"), result);
+        }
+
+        // trim tests
+        TEST_METHOD(Trim_EmptyString_ReturnsEmpty)
+        {
+            std::string_view input = "";
+            auto result = trim(input);
+            Assert::AreEqual(std::string_view(""), result);
+        }
+
+        TEST_METHOD(Trim_NoWhitespace_ReturnsOriginal)
+        {
+            std::string_view input = "hello";
+            auto result = trim(input);
+            Assert::AreEqual(std::string_view("hello"), result);
+        }
+
+        TEST_METHOD(Trim_BothSides_TrimsBoth)
+        {
+            std::string_view input = "   hello   ";
+            auto result = trim(input);
+            Assert::AreEqual(std::string_view("hello"), result);
+        }
+
+        TEST_METHOD(Trim_MixedWhitespace_TrimsAll)
+        {
+            std::string_view input = " \t\r\nhello \t\r\n";
+            auto result = trim(input);
+            Assert::AreEqual(std::string_view("hello"), result);
+        }
+
+        TEST_METHOD(Trim_InternalWhitespace_Preserved)
+        {
+            std::string_view input = "   hello world   ";
+            auto result = trim(input);
+            Assert::AreEqual(std::string_view("hello world"), result);
+        }
+
+        TEST_METHOD(Trim_OnlyWhitespace_ReturnsEmpty)
+        {
+            std::string_view input = "   \t\r\n   ";
+            auto result = trim(input);
+            Assert::AreEqual(std::string_view(""), result);
+        }
+
+        TEST_METHOD(Trim_CustomChars_TrimsSpecified)
+        {
+            std::string_view input = "xxxhelloxxx";
+            auto result = trim(input, std::string_view("x"));
+            Assert::AreEqual(std::string_view("hello"), result);
+        }
+
+        TEST_METHOD(Trim_WideString_Works)
+        {
+            std::wstring_view input = L"   hello   ";
+            auto result = trim(input);
+            Assert::AreEqual(std::wstring_view(L"hello"), result);
+        }
+
+        // replace_chars tests
+        TEST_METHOD(ReplaceChars_EmptyString_NoChange)
+        {
+            std::string s = "";
+            replace_chars(s, std::string_view("abc"), 'x');
+            Assert::AreEqual(std::string(""), s);
+        }
+
+        TEST_METHOD(ReplaceChars_NoMatchingChars_NoChange)
+        {
+            std::string s = "hello";
+            replace_chars(s, std::string_view("xyz"), '_');
+            Assert::AreEqual(std::string("hello"), s);
+        }
+
+        TEST_METHOD(ReplaceChars_SingleChar_Replaces)
+        {
+            std::string s = "hello";
+            replace_chars(s, std::string_view("l"), '_');
+            Assert::AreEqual(std::string("he__o"), s);
+        }
+
+        TEST_METHOD(ReplaceChars_MultipleChars_ReplacesAll)
+        {
+            std::string s = "hello world";
+            replace_chars(s, std::string_view("lo"), '_');
+            Assert::AreEqual(std::string("he___ w_r_d"), s);
+        }
+
+        TEST_METHOD(ReplaceChars_WideString_Works)
+        {
+            std::wstring s = L"hello";
+            replace_chars(s, std::wstring_view(L"l"), L'_');
+            Assert::AreEqual(std::wstring(L"he__o"), s);
+        }
+
+        // unwide tests
+        TEST_METHOD(Unwide_EmptyString_ReturnsEmpty)
+        {
+            std::wstring input = L"";
+            auto result = unwide(input);
+            Assert::AreEqual(std::string(""), result);
+        }
+
+        TEST_METHOD(Unwide_AsciiString_Converts)
+        {
+            std::wstring input = L"hello";
+            auto result = unwide(input);
+            Assert::AreEqual(std::string("hello"), result);
+        }
+
+        TEST_METHOD(Unwide_WithNumbers_Converts)
+        {
+            std::wstring input = L"test123";
+            auto result = unwide(input);
+            Assert::AreEqual(std::string("test123"), result);
+        }
+
+        TEST_METHOD(Unwide_WithSpecialChars_Converts)
+        {
+            std::wstring input = L"test!@#$%";
+            auto result = unwide(input);
+            Assert::AreEqual(std::string("test!@#$%"), result);
+        }
+
+        TEST_METHOD(Unwide_MixedCase_PreservesCase)
+        {
+            std::wstring input = L"HeLLo WoRLd";
+            auto result = unwide(input);
+            Assert::AreEqual(std::string("HeLLo WoRLd"), result);
+        }
+
+        TEST_METHOD(Unwide_LongString_Works)
+        {
+            std::wstring input = L"This is a longer string with multiple words and punctuation!";
+            auto result = unwide(input);
+            Assert::AreEqual(std::string("This is a longer string with multiple words and punctuation!"), result);
+        }
+    };
+}

src/common/UnitTests-CommonUtils/TestHelpers.h

@@ -0,0 +1,192 @@
+#pragma once
+
+#include "pch.h"
+#include <string>
+#include <filesystem>
+#include <fstream>
+#include <random>
+
+namespace TestHelpers
+{
+    // RAII helper for creating and cleaning up temporary files
+    class TempFile
+    {
+    public:
+        TempFile(const std::wstring& content = L"", const std::wstring& extension = L".txt")
+        {
+            wchar_t tempPath[MAX_PATH];
+            GetTempPathW(MAX_PATH, tempPath);
+
+            // Generate a unique filename
+            std::random_device rd;
+            std::mt19937 gen(rd());
+            std::uniform_int_distribution<> dis(10000, 99999);
+
+            m_path = std::wstring(tempPath) + L"test_" + std::to_wstring(dis(gen)) + extension;
+
+            if (!content.empty())
+            {
+                std::wofstream file(m_path);
+                file << content;
+            }
+        }
+
+        ~TempFile()
+        {
+            if (std::filesystem::exists(m_path))
+            {
+                std::filesystem::remove(m_path);
+            }
+        }
+
+        TempFile(const TempFile&) = delete;
+        TempFile& operator=(const TempFile&) = delete;
+
+        const std::wstring& path() const { return m_path; }
+
+        void write(const std::string& content)
+        {
+            std::ofstream file(m_path, std::ios::binary);
+            file << content;
+        }
+
+        void write(const std::wstring& content)
+        {
+            std::wofstream file(m_path);
+            file << content;
+        }
+
+        std::wstring read()
+        {
+            std::wifstream file(m_path);
+            return std::wstring((std::istreambuf_iterator<wchar_t>(file)),
+                               std::istreambuf_iterator<wchar_t>());
+        }
+
+    private:
+        std::wstring m_path;
+    };
+
+    // RAII helper for creating and cleaning up temporary directories
+    class TempDirectory
+    {
+    public:
+        TempDirectory()
+        {
+            wchar_t tempPath[MAX_PATH];
+            GetTempPathW(MAX_PATH, tempPath);
+
+            std::random_device rd;
+            std::mt19937 gen(rd());
+            std::uniform_int_distribution<> dis(10000, 99999);
+
+            m_path = std::wstring(tempPath) + L"testdir_" + std::to_wstring(dis(gen));
+            std::filesystem::create_directories(m_path);
+        }
+
+        ~TempDirectory()
+        {
+            if (std::filesystem::exists(m_path))
+            {
+                std::filesystem::remove_all(m_path);
+            }
+        }
+
+        TempDirectory(const TempDirectory&) = delete;
+        TempDirectory& operator=(const TempDirectory&) = delete;
+
+        const std::wstring& path() const { return m_path; }
+
+    private:
+        std::wstring m_path;
+    };
+
+    // Registry test key path - use HKCU for non-elevated tests
+    inline const std::wstring TestRegistryPath = L"Software\\PowerToys\\UnitTests";
+
+    // RAII helper for registry key creation/cleanup
+    class TestRegistryKey
+    {
+    public:
+        TestRegistryKey(const std::wstring& subKey = L"")
+        {
+            m_path = TestRegistryPath;
+            if (!subKey.empty())
+            {
+                m_path += L"\\" + subKey;
+            }
+
+            HKEY key;
+            if (RegCreateKeyExW(HKEY_CURRENT_USER, m_path.c_str(), 0, nullptr,
+                               REG_OPTION_NON_VOLATILE, KEY_ALL_ACCESS, nullptr,
+                               &key, nullptr) == ERROR_SUCCESS)
+            {
+                RegCloseKey(key);
+                m_created = true;
+            }
+        }
+
+        ~TestRegistryKey()
+        {
+            if (m_created)
+            {
+                RegDeleteTreeW(HKEY_CURRENT_USER, m_path.c_str());
+            }
+        }
+
+        TestRegistryKey(const TestRegistryKey&) = delete;
+        TestRegistryKey& operator=(const TestRegistryKey&) = delete;
+
+        bool isValid() const { return m_created; }
+        const std::wstring& path() const { return m_path; }
+
+        bool setStringValue(const std::wstring& name, const std::wstring& value)
+        {
+            HKEY key;
+            if (RegOpenKeyExW(HKEY_CURRENT_USER, m_path.c_str(), 0, KEY_SET_VALUE, &key) != ERROR_SUCCESS)
+            {
+                return false;
+            }
+
+            auto result = RegSetValueExW(key, name.c_str(), 0, REG_SZ,
+                                        reinterpret_cast<const BYTE*>(value.c_str()),
+                                        static_cast<DWORD>((value.length() + 1) * sizeof(wchar_t)));
+            RegCloseKey(key);
+            return result == ERROR_SUCCESS;
+        }
+
+        bool setDwordValue(const std::wstring& name, DWORD value)
+        {
+            HKEY key;
+            if (RegOpenKeyExW(HKEY_CURRENT_USER, m_path.c_str(), 0, KEY_SET_VALUE, &key) != ERROR_SUCCESS)
+            {
+                return false;
+            }
+
+            auto result = RegSetValueExW(key, name.c_str(), 0, REG_DWORD,
+                                        reinterpret_cast<const BYTE*>(&value), sizeof(DWORD));
+            RegCloseKey(key);
+            return result == ERROR_SUCCESS;
+        }
+
+    private:
+        std::wstring m_path;
+        bool m_created = false;
+    };
+
+    // Helper to wait for a condition with timeout
+    template<typename Predicate>
+    bool WaitFor(Predicate pred, std::chrono::milliseconds timeout = std::chrono::milliseconds(5000))
+    {
+        auto start = std::chrono::steady_clock::now();
+        while (!pred())
+        {
+            if (std::chrono::steady_clock::now() - start > timeout)
+            {
+                return false;
+            }
+            std::this_thread::sleep_for(std::chrono::milliseconds(10));
+        }
+        return true;
+    }
+}

src/common/UnitTests-CommonUtils/TestStubs.cpp

@@ -0,0 +1,14 @@
+#include "pch.h"
+#include <common/logger/logger.h>
+#include <common/SettingsAPI/settings_helpers.h>
+#include <spdlog/sinks/null_sink.h>
+
+std::shared_ptr<spdlog::logger> Logger::logger = spdlog::null_logger_mt("Common.Utils.UnitTests");
+
+namespace PTSettingsHelper
+{
+    std::wstring get_root_save_folder_location()
+    {
+        return L"";
+    }
+}

src/common/UnitTests-CommonUtils/Threading.Tests.cpp

@@ -0,0 +1,336 @@
+#include "pch.h"
+#include "TestHelpers.h"
+#include <OnThreadExecutor.h>
+#include <EventWaiter.h>
+#include <EventLocker.h>
+
+using namespace Microsoft::VisualStudio::CppUnitTestFramework;
+
+namespace UnitTestsCommonUtils
+{
+    TEST_CLASS(OnThreadExecutorTests)
+    {
+    public:
+        TEST_METHOD(Constructor_CreatesInstance)
+        {
+            OnThreadExecutor executor;
+            // Should not crash
+            Assert::IsTrue(true);
+        }
+
+        TEST_METHOD(Submit_SingleTask_Executes)
+        {
+            OnThreadExecutor executor;
+            std::atomic<bool> executed{ false };
+
+            auto future = executor.submit(OnThreadExecutor::task_t([&executed]() {
+                executed = true;
+            }));
+
+            future.wait();
+            Assert::IsTrue(executed);
+        }
+
+        TEST_METHOD(Submit_MultipleTasks_ExecutesAll)
+        {
+            OnThreadExecutor executor;
+            std::atomic<int> counter{ 0 };
+
+            std::vector<std::future<void>> futures;
+            for (int i = 0; i < 10; ++i)
+            {
+                futures.push_back(executor.submit(OnThreadExecutor::task_t([&counter]() {
+                    counter++;
+                })));
+            }
+
+            for (auto& f : futures)
+            {
+                f.wait();
+            }
+
+            Assert::AreEqual(10, counter.load());
+        }
+
+        TEST_METHOD(Submit_TasksExecuteInOrder)
+        {
+            OnThreadExecutor executor;
+            std::vector<int> order;
+            std::mutex orderMutex;
+
+            std::vector<std::future<void>> futures;
+            for (int i = 0; i < 5; ++i)
+            {
+                futures.push_back(executor.submit(OnThreadExecutor::task_t([&order, &orderMutex, i]() {
+                    std::lock_guard lock(orderMutex);
+                    order.push_back(i);
+                })));
+            }
+
+            for (auto& f : futures)
+            {
+                f.wait();
+            }
+
+            Assert::AreEqual(static_cast<size_t>(5), order.size());
+            for (int i = 0; i < 5; ++i)
+            {
+                Assert::AreEqual(i, order[i]);
+            }
+        }
+
+        TEST_METHOD(Submit_TaskReturnsResult)
+        {
+            OnThreadExecutor executor;
+            std::atomic<int> result{ 0 };
+
+            auto future = executor.submit(OnThreadExecutor::task_t([&result]() {
+                result = 42;
+            }));
+
+            future.wait();
+            Assert::AreEqual(42, result.load());
+        }
+
+        TEST_METHOD(Cancel_ClearsPendingTasks)
+        {
+            OnThreadExecutor executor;
+            std::atomic<int> counter{ 0 };
+
+            // Submit a slow task first
+            executor.submit(OnThreadExecutor::task_t([&counter]() {
+                std::this_thread::sleep_for(std::chrono::milliseconds(100));
+                counter++;
+            }));
+
+            // Submit more tasks
+            for (int i = 0; i < 5; ++i)
+            {
+                executor.submit(OnThreadExecutor::task_t([&counter]() {
+                    counter++;
+                }));
+            }
+
+            // Cancel pending tasks
+            executor.cancel();
+
+            // Wait a bit for any running task to complete
+            std::this_thread::sleep_for(std::chrono::milliseconds(200));
+
+            // Not all tasks should have executed
+            Assert::IsTrue(counter < 6);
+        }
+
+        TEST_METHOD(Destructor_WaitsForCompletion)
+        {
+            std::atomic<bool> completed{ false };
+            std::future<void> future;
+
+            {
+                OnThreadExecutor executor;
+                future = executor.submit(OnThreadExecutor::task_t([&completed]() {
+                    std::this_thread::sleep_for(std::chrono::milliseconds(50));
+                    completed = true;
+                }));
+                future.wait();
+            } // Destructor no longer required to wait for completion
+
+            Assert::IsTrue(completed);
+        }
+
+        TEST_METHOD(Submit_AfterCancel_StillWorks)
+        {
+            OnThreadExecutor executor;
+            std::atomic<int> counter{ 0 };
+
+            executor.submit(OnThreadExecutor::task_t([&counter]() {
+                counter++;
+            }));
+            executor.cancel();
+
+            auto future = executor.submit(OnThreadExecutor::task_t([&counter]() {
+                counter = 42;
+            }));
+            future.wait();
+
+            Assert::AreEqual(42, counter.load());
+        }
+    };
+
+    TEST_CLASS(EventWaiterTests)
+    {
+    public:
+        TEST_METHOD(Constructor_CreatesInstance)
+        {
+            EventWaiter waiter;
+            Assert::IsFalse(waiter.is_listening());
+        }
+
+        TEST_METHOD(Start_ValidEvent_ReturnsTrue)
+        {
+            EventWaiter waiter;
+            bool result = waiter.start(L"TestEvent_Start", [](DWORD) {});
+            Assert::IsTrue(result);
+            Assert::IsTrue(waiter.is_listening());
+            waiter.stop();
+        }
+
+        TEST_METHOD(Start_AlreadyListening_ReturnsFalse)
+        {
+            EventWaiter waiter;
+            waiter.start(L"TestEvent_Double1", [](DWORD) {});
+            bool result = waiter.start(L"TestEvent_Double2", [](DWORD) {});
+            Assert::IsFalse(result);
+            waiter.stop();
+        }
+
+        TEST_METHOD(Stop_WhileListening_StopsListening)
+        {
+            EventWaiter waiter;
+            waiter.start(L"TestEvent_Stop", [](DWORD) {});
+            Assert::IsTrue(waiter.is_listening());
+
+            waiter.stop();
+            Assert::IsFalse(waiter.is_listening());
+        }
+
+        TEST_METHOD(Stop_WhenNotListening_DoesNotCrash)
+        {
+            EventWaiter waiter;
+            waiter.stop(); // Should not crash
+            Assert::IsFalse(waiter.is_listening());
+        }
+
+        TEST_METHOD(Stop_CalledMultipleTimes_DoesNotCrash)
+        {
+            EventWaiter waiter;
+            waiter.start(L"TestEvent_MultiStop", [](DWORD) {});
+            waiter.stop();
+            waiter.stop();
+            waiter.stop();
+            Assert::IsFalse(waiter.is_listening());
+        }
+
+        TEST_METHOD(Callback_EventSignaled_CallsCallback)
+        {
+            EventWaiter waiter;
+            std::atomic<bool> called{ false };
+            std::atomic<DWORD> errorCode{ 0xFFFFFFFF };
+
+            // Create a named event we can signal
+            std::wstring eventName = L"TestEvent_Callback_" + std::to_wstring(GetCurrentProcessId());
+            HANDLE signalEvent = CreateEventW(nullptr, FALSE, FALSE, eventName.c_str());
+            Assert::IsNotNull(signalEvent);
+
+            waiter.start(eventName, [&called, &errorCode](DWORD err) {
+                errorCode = err;
+                called = true;
+            });
+
+            // Signal the event
+            SetEvent(signalEvent);
+
+            // Wait for callback
+            bool waitResult = TestHelpers::WaitFor([&called]() { return called.load(); }, std::chrono::milliseconds(1000));
+
+            waiter.stop();
+            CloseHandle(signalEvent);
+
+            Assert::IsTrue(waitResult);
+            Assert::AreEqual(static_cast<DWORD>(ERROR_SUCCESS), errorCode.load());
+        }
+
+        TEST_METHOD(Destructor_StopsListening)
+        {
+            std::atomic<bool> isListening{ false };
+            {
+                EventWaiter waiter;
+                waiter.start(L"TestEvent_Destructor", [](DWORD) {});
+                isListening = waiter.is_listening();
+            }
+            // After destruction, the waiter should have stopped
+            Assert::IsTrue(isListening);
+        }
+
+        TEST_METHOD(IsListening_InitialState_ReturnsFalse)
+        {
+            EventWaiter waiter;
+            Assert::IsFalse(waiter.is_listening());
+        }
+
+        TEST_METHOD(IsListening_AfterStart_ReturnsTrue)
+        {
+            EventWaiter waiter;
+            waiter.start(L"TestEvent_IsListening", [](DWORD) {});
+            Assert::IsTrue(waiter.is_listening());
+            waiter.stop();
+        }
+
+        TEST_METHOD(IsListening_AfterStop_ReturnsFalse)
+        {
+            EventWaiter waiter;
+            waiter.start(L"TestEvent_AfterStop", [](DWORD) {});
+            waiter.stop();
+            Assert::IsFalse(waiter.is_listening());
+        }
+    };
+
+    TEST_CLASS(EventLockerTests)
+    {
+    public:
+        TEST_METHOD(Get_ValidEventName_ReturnsLocker)
+        {
+            std::wstring eventName = L"TestEventLocker_" + std::to_wstring(GetCurrentProcessId());
+            auto locker = EventLocker::Get(eventName);
+            Assert::IsTrue(locker.has_value());
+        }
+
+        TEST_METHOD(Get_UniqueNames_CreatesSeparateLockers)
+        {
+            auto locker1 = EventLocker::Get(L"TestEventLocker1_" + std::to_wstring(GetCurrentProcessId()));
+            auto locker2 = EventLocker::Get(L"TestEventLocker2_" + std::to_wstring(GetCurrentProcessId()));
+            Assert::IsTrue(locker1.has_value());
+            Assert::IsTrue(locker2.has_value());
+        }
+
+        TEST_METHOD(Destructor_CleansUpHandle)
+        {
+            std::wstring eventName = L"TestEventLockerCleanup_" + std::to_wstring(GetCurrentProcessId());
+            {
+                auto locker = EventLocker::Get(eventName);
+                Assert::IsTrue(locker.has_value());
+            }
+            // After destruction, the event should be cleaned up
+            // Creating a new one should succeed
+            auto newLocker = EventLocker::Get(eventName);
+            Assert::IsTrue(newLocker.has_value());
+        }
+
+        TEST_METHOD(MoveConstructor_TransfersOwnership)
+        {
+            std::wstring eventName = L"TestEventLockerMove_" + std::to_wstring(GetCurrentProcessId());
+            auto locker1 = EventLocker::Get(eventName);
+            Assert::IsTrue(locker1.has_value());
+
+            EventLocker locker2 = std::move(*locker1);
+            // Move should transfer ownership without crash
+            Assert::IsTrue(true);
+        }
+
+        TEST_METHOD(MoveAssignment_TransfersOwnership)
+        {
+            std::wstring eventName1 = L"TestEventLockerMoveAssign1_" + std::to_wstring(GetCurrentProcessId());
+            std::wstring eventName2 = L"TestEventLockerMoveAssign2_" + std::to_wstring(GetCurrentProcessId());
+
+            auto locker1 = EventLocker::Get(eventName1);
+            auto locker2 = EventLocker::Get(eventName2);
+
+            Assert::IsTrue(locker1.has_value());
+            Assert::IsTrue(locker2.has_value());
+
+            *locker1 = std::move(*locker2);
+            // Should not crash
+            Assert::IsTrue(true);
+        }
+    };
+}

src/common/UnitTests-CommonUtils/TimeUtils.Tests.cpp

@@ -0,0 +1,248 @@
+#include "pch.h"
+#include "TestHelpers.h"
+#include <timeutil.h>
+
+using namespace Microsoft::VisualStudio::CppUnitTestFramework;
+
+namespace UnitTestsCommonUtils
+{
+    TEST_CLASS(TimeUtilsTests)
+    {
+    public:
+        // to_string tests
+        TEST_METHOD(ToString_ZeroTime_ReturnsZero)
+        {
+            time_t t = 0;
+            auto result = timeutil::to_string(t);
+            Assert::AreEqual(std::wstring(L"0"), result);
+        }
+
+        TEST_METHOD(ToString_PositiveTime_ReturnsString)
+        {
+            time_t t = 1234567890;
+            auto result = timeutil::to_string(t);
+            Assert::AreEqual(std::wstring(L"1234567890"), result);
+        }
+
+        TEST_METHOD(ToString_LargeTime_ReturnsString)
+        {
+            time_t t = 1700000000;
+            auto result = timeutil::to_string(t);
+            Assert::AreEqual(std::wstring(L"1700000000"), result);
+        }
+
+        // from_string tests
+        TEST_METHOD(FromString_ZeroString_ReturnsZero)
+        {
+            auto result = timeutil::from_string(L"0");
+            Assert::IsTrue(result.has_value());
+            Assert::AreEqual(static_cast<time_t>(0), result.value());
+        }
+
+        TEST_METHOD(FromString_ValidNumber_ReturnsTime)
+        {
+            auto result = timeutil::from_string(L"1234567890");
+            Assert::IsTrue(result.has_value());
+            Assert::AreEqual(static_cast<time_t>(1234567890), result.value());
+        }
+
+        TEST_METHOD(FromString_InvalidString_ReturnsNullopt)
+        {
+            auto result = timeutil::from_string(L"invalid");
+            Assert::IsFalse(result.has_value());
+        }
+
+        TEST_METHOD(FromString_EmptyString_ReturnsNullopt)
+        {
+            auto result = timeutil::from_string(L"");
+            Assert::IsFalse(result.has_value());
+        }
+
+        TEST_METHOD(FromString_MixedAlphaNumeric_ReturnsNullopt)
+        {
+            auto result = timeutil::from_string(L"123abc");
+            Assert::IsFalse(result.has_value());
+        }
+
+        TEST_METHOD(FromString_NegativeNumber_ReturnsNullopt)
+        {
+            auto result = timeutil::from_string(L"-1");
+            Assert::IsFalse(result.has_value());
+        }
+
+        // Roundtrip test
+        TEST_METHOD(ToStringFromString_Roundtrip_Works)
+        {
+            time_t original = 1609459200; // 2021-01-01 00:00:00 UTC
+            auto str = timeutil::to_string(original);
+            auto result = timeutil::from_string(str);
+            Assert::IsTrue(result.has_value());
+            Assert::AreEqual(original, result.value());
+        }
+
+        // now tests
+        TEST_METHOD(Now_ReturnsReasonableTime)
+        {
+            auto result = timeutil::now();
+            // Should be after 2020 and before 2100
+            Assert::IsTrue(result > 1577836800); // 2020-01-01
+            Assert::IsTrue(result < 4102444800); // 2100-01-01
+        }
+
+        TEST_METHOD(Now_TwoCallsAreCloseInTime)
+        {
+            auto first = timeutil::now();
+            std::this_thread::sleep_for(std::chrono::milliseconds(100));
+            auto second = timeutil::now();
+            // Difference should be less than 2 seconds
+            Assert::IsTrue(second >= first);
+            Assert::IsTrue(second - first < 2);
+        }
+
+        // diff::in_seconds tests
+        TEST_METHOD(DiffInSeconds_SameTime_ReturnsZero)
+        {
+            time_t t = 1000000;
+            auto result = timeutil::diff::in_seconds(t, t);
+            Assert::AreEqual(static_cast<int64_t>(0), result);
+        }
+
+        TEST_METHOD(DiffInSeconds_OneDifference_ReturnsOne)
+        {
+            time_t to = 1000001;
+            time_t from = 1000000;
+            auto result = timeutil::diff::in_seconds(to, from);
+            Assert::AreEqual(static_cast<int64_t>(1), result);
+        }
+
+        TEST_METHOD(DiffInSeconds_60Seconds_Returns60)
+        {
+            time_t to = 1000060;
+            time_t from = 1000000;
+            auto result = timeutil::diff::in_seconds(to, from);
+            Assert::AreEqual(static_cast<int64_t>(60), result);
+        }
+
+        TEST_METHOD(DiffInSeconds_NegativeDiff_ReturnsNegative)
+        {
+            time_t to = 1000000;
+            time_t from = 1000060;
+            auto result = timeutil::diff::in_seconds(to, from);
+            Assert::AreEqual(static_cast<int64_t>(-60), result);
+        }
+
+        // diff::in_minutes tests
+        TEST_METHOD(DiffInMinutes_SameTime_ReturnsZero)
+        {
+            time_t t = 1000000;
+            auto result = timeutil::diff::in_minutes(t, t);
+            Assert::AreEqual(static_cast<int64_t>(0), result);
+        }
+
+        TEST_METHOD(DiffInMinutes_OneMinute_ReturnsOne)
+        {
+            time_t to = 1000060;
+            time_t from = 1000000;
+            auto result = timeutil::diff::in_minutes(to, from);
+            Assert::AreEqual(static_cast<int64_t>(1), result);
+        }
+
+        TEST_METHOD(DiffInMinutes_60Minutes_Returns60)
+        {
+            time_t to = 1003600;
+            time_t from = 1000000;
+            auto result = timeutil::diff::in_minutes(to, from);
+            Assert::AreEqual(static_cast<int64_t>(60), result);
+        }
+
+        TEST_METHOD(DiffInMinutes_LessThanMinute_ReturnsZero)
+        {
+            time_t to = 1000059;
+            time_t from = 1000000;
+            auto result = timeutil::diff::in_minutes(to, from);
+            Assert::AreEqual(static_cast<int64_t>(0), result);
+        }
+
+        // diff::in_hours tests
+        TEST_METHOD(DiffInHours_SameTime_ReturnsZero)
+        {
+            time_t t = 1000000;
+            auto result = timeutil::diff::in_hours(t, t);
+            Assert::AreEqual(static_cast<int64_t>(0), result);
+        }
+
+        TEST_METHOD(DiffInHours_OneHour_ReturnsOne)
+        {
+            time_t to = 1003600;
+            time_t from = 1000000;
+            auto result = timeutil::diff::in_hours(to, from);
+            Assert::AreEqual(static_cast<int64_t>(1), result);
+        }
+
+        TEST_METHOD(DiffInHours_24Hours_Returns24)
+        {
+            time_t to = 1086400;
+            time_t from = 1000000;
+            auto result = timeutil::diff::in_hours(to, from);
+            Assert::AreEqual(static_cast<int64_t>(24), result);
+        }
+
+        TEST_METHOD(DiffInHours_LessThanHour_ReturnsZero)
+        {
+            time_t to = 1003599;
+            time_t from = 1000000;
+            auto result = timeutil::diff::in_hours(to, from);
+            Assert::AreEqual(static_cast<int64_t>(0), result);
+        }
+
+        // diff::in_days tests
+        TEST_METHOD(DiffInDays_SameTime_ReturnsZero)
+        {
+            time_t t = 1000000;
+            auto result = timeutil::diff::in_days(t, t);
+            Assert::AreEqual(static_cast<int64_t>(0), result);
+        }
+
+        TEST_METHOD(DiffInDays_OneDay_ReturnsOne)
+        {
+            time_t to = 1086400;
+            time_t from = 1000000;
+            auto result = timeutil::diff::in_days(to, from);
+            Assert::AreEqual(static_cast<int64_t>(1), result);
+        }
+
+        TEST_METHOD(DiffInDays_7Days_Returns7)
+        {
+            time_t to = 1604800;
+            time_t from = 1000000;
+            auto result = timeutil::diff::in_days(to, from);
+            Assert::AreEqual(static_cast<int64_t>(7), result);
+        }
+
+        TEST_METHOD(DiffInDays_LessThanDay_ReturnsZero)
+        {
+            time_t to = 1086399;
+            time_t from = 1000000;
+            auto result = timeutil::diff::in_days(to, from);
+            Assert::AreEqual(static_cast<int64_t>(0), result);
+        }
+
+        // format_as_local tests
+        TEST_METHOD(FormatAsLocal_YearFormat_ReturnsYear)
+        {
+            time_t t = 1609459200; // 2021-01-01 00:00:00 UTC
+            auto result = timeutil::format_as_local("%Y", t);
+            // Result depends on local timezone, but year should be 2020 or 2021
+            Assert::IsTrue(result == "2020" || result == "2021");
+        }
+
+        TEST_METHOD(FormatAsLocal_DateFormat_ReturnsDate)
+        {
+            time_t t = 0; // 1970-01-01 00:00:00 UTC
+            auto result = timeutil::format_as_local("%Y-%m-%d", t);
+            // Result should be a date around 1970-01-01 depending on timezone
+            Assert::IsTrue(result.length() == 10); // YYYY-MM-DD format
+            Assert::IsTrue(result.substr(0, 4) == "1969" || result.substr(0, 4) == "1970");
+        }
+    };
+}

src/common/UnitTests-CommonUtils/UnhandledException.Tests.cpp

@@ -0,0 +1,210 @@
+#include "pch.h"
+#include "TestHelpers.h"
+#include <UnhandledExceptionHandler.h>
+
+using namespace Microsoft::VisualStudio::CppUnitTestFramework;
+
+namespace UnitTestsCommonUtils
+{
+    TEST_CLASS(UnhandledExceptionTests)
+    {
+    public:
+        // exceptionDescription tests
+        TEST_METHOD(ExceptionDescription_AccessViolation_ReturnsDescription)
+        {
+            auto result = exceptionDescription(EXCEPTION_ACCESS_VIOLATION);
+            Assert::IsTrue(result && *result != '\0');
+            // Should contain meaningful description
+            std::string desc{ result };
+            Assert::IsTrue(desc.find("ACCESS") != std::string::npos ||
+                          desc.find("access") != std::string::npos ||
+                          desc.find("violation") != std::string::npos ||
+                          desc.length() > 0);
+        }
+
+        TEST_METHOD(ExceptionDescription_StackOverflow_ReturnsDescription)
+        {
+            auto result = exceptionDescription(EXCEPTION_STACK_OVERFLOW);
+            Assert::IsTrue(result && *result != '\0');
+        }
+
+        TEST_METHOD(ExceptionDescription_DivideByZero_ReturnsDescription)
+        {
+            auto result = exceptionDescription(EXCEPTION_INT_DIVIDE_BY_ZERO);
+            Assert::IsTrue(result && *result != '\0');
+        }
+
+        TEST_METHOD(ExceptionDescription_IllegalInstruction_ReturnsDescription)
+        {
+            auto result = exceptionDescription(EXCEPTION_ILLEGAL_INSTRUCTION);
+            Assert::IsTrue(result && *result != '\0');
+        }
+
+        TEST_METHOD(ExceptionDescription_ArrayBoundsExceeded_ReturnsDescription)
+        {
+            auto result = exceptionDescription(EXCEPTION_ARRAY_BOUNDS_EXCEEDED);
+            Assert::IsTrue(result && *result != '\0');
+        }
+
+        TEST_METHOD(ExceptionDescription_Breakpoint_ReturnsDescription)
+        {
+            auto result = exceptionDescription(EXCEPTION_BREAKPOINT);
+            Assert::IsTrue(result && *result != '\0');
+        }
+
+        TEST_METHOD(ExceptionDescription_SingleStep_ReturnsDescription)
+        {
+            auto result = exceptionDescription(EXCEPTION_SINGLE_STEP);
+            Assert::IsTrue(result && *result != '\0');
+        }
+
+        TEST_METHOD(ExceptionDescription_FloatDivideByZero_ReturnsDescription)
+        {
+            auto result = exceptionDescription(EXCEPTION_FLT_DIVIDE_BY_ZERO);
+            Assert::IsTrue(result && *result != '\0');
+        }
+
+        TEST_METHOD(ExceptionDescription_FloatOverflow_ReturnsDescription)
+        {
+            auto result = exceptionDescription(EXCEPTION_FLT_OVERFLOW);
+            Assert::IsTrue(result && *result != '\0');
+        }
+
+        TEST_METHOD(ExceptionDescription_FloatUnderflow_ReturnsDescription)
+        {
+            auto result = exceptionDescription(EXCEPTION_FLT_UNDERFLOW);
+            Assert::IsTrue(result && *result != '\0');
+        }
+
+        TEST_METHOD(ExceptionDescription_FloatInvalidOperation_ReturnsDescription)
+        {
+            auto result = exceptionDescription(EXCEPTION_FLT_INVALID_OPERATION);
+            Assert::IsTrue(result && *result != '\0');
+        }
+
+        TEST_METHOD(ExceptionDescription_PrivilegedInstruction_ReturnsDescription)
+        {
+            auto result = exceptionDescription(EXCEPTION_PRIV_INSTRUCTION);
+            Assert::IsTrue(result && *result != '\0');
+        }
+
+        TEST_METHOD(ExceptionDescription_InPageError_ReturnsDescription)
+        {
+            auto result = exceptionDescription(EXCEPTION_IN_PAGE_ERROR);
+            Assert::IsTrue(result && *result != '\0');
+        }
+
+        TEST_METHOD(ExceptionDescription_UnknownCode_ReturnsDescription)
+        {
+            auto result = exceptionDescription(0x12345678);
+            // Should return something (possibly "Unknown exception" or similar)
+            Assert::IsTrue(result && *result != '\0');
+        }
+
+        TEST_METHOD(ExceptionDescription_ZeroCode_ReturnsDescription)
+        {
+            auto result = exceptionDescription(0);
+            // Should handle zero gracefully
+            Assert::IsTrue(result && *result != '\0');
+        }
+
+        // GetFilenameStart tests (if accessible)
+        TEST_METHOD(GetFilenameStart_ValidPath_ReturnsFilename)
+        {
+            wchar_t path[] = L"C:\\folder\\subfolder\\file.exe";
+            int start = GetFilenameStart(path);
+
+            Assert::IsTrue(start >= 0);
+            Assert::AreEqual(std::wstring(L"file.exe"), std::wstring(path + start));
+        }
+
+        TEST_METHOD(GetFilenameStart_NoPath_ReturnsOriginal)
+        {
+            wchar_t path[] = L"file.exe";
+            int start = GetFilenameStart(path);
+
+            Assert::IsTrue(start >= 0);
+            Assert::AreEqual(std::wstring(L"file.exe"), std::wstring(path + start));
+        }
+
+        TEST_METHOD(GetFilenameStart_TrailingBackslash_ReturnsEmpty)
+        {
+            wchar_t path[] = L"C:\\folder\\";
+            int start = GetFilenameStart(path);
+
+            // Should point to empty string after last backslash
+            Assert::IsTrue(start >= 0);
+        }
+
+        TEST_METHOD(GetFilenameStart_NullPath_HandlesGracefully)
+        {
+            // This might crash or return null depending on implementation
+            // Just document the behavior
+            int start = GetFilenameStart(nullptr);
+            (void)start;
+            // Result is implementation-defined for null input
+            Assert::IsTrue(true);
+        }
+
+        // Thread safety tests
+        TEST_METHOD(ExceptionDescription_ThreadSafe)
+        {
+            std::vector<std::thread> threads;
+            std::atomic<int> successCount{ 0 };
+
+            for (int i = 0; i < 10; ++i)
+            {
+                threads.emplace_back([&successCount]() {
+                    for (int j = 0; j < 10; ++j)
+                    {
+                        auto desc = exceptionDescription(EXCEPTION_ACCESS_VIOLATION);
+                        if (desc && *desc != '\0')
+                        {
+                            successCount++;
+                        }
+                    }
+                });
+            }
+
+            for (auto& t : threads)
+            {
+                t.join();
+            }
+
+            Assert::AreEqual(100, successCount.load());
+        }
+
+        // All exception codes test
+        TEST_METHOD(ExceptionDescription_AllCommonCodes_ReturnDescriptions)
+        {
+            std::vector<DWORD> codes = {
+                EXCEPTION_ACCESS_VIOLATION,
+                EXCEPTION_ARRAY_BOUNDS_EXCEEDED,
+                EXCEPTION_BREAKPOINT,
+                EXCEPTION_DATATYPE_MISALIGNMENT,
+                EXCEPTION_FLT_DENORMAL_OPERAND,
+                EXCEPTION_FLT_DIVIDE_BY_ZERO,
+                EXCEPTION_FLT_INEXACT_RESULT,
+                EXCEPTION_FLT_INVALID_OPERATION,
+                EXCEPTION_FLT_OVERFLOW,
+                EXCEPTION_FLT_STACK_CHECK,
+                EXCEPTION_FLT_UNDERFLOW,
+                EXCEPTION_ILLEGAL_INSTRUCTION,
+                EXCEPTION_IN_PAGE_ERROR,
+                EXCEPTION_INT_DIVIDE_BY_ZERO,
+                EXCEPTION_INT_OVERFLOW,
+                EXCEPTION_INVALID_DISPOSITION,
+                EXCEPTION_NONCONTINUABLE_EXCEPTION,
+                EXCEPTION_PRIV_INSTRUCTION,
+                EXCEPTION_SINGLE_STEP,
+                EXCEPTION_STACK_OVERFLOW
+            };
+
+            for (DWORD code : codes)
+            {
+                auto desc = exceptionDescription(code);
+                Assert::IsTrue(desc && *desc != '\0', (L"Empty description for code: " + std::to_wstring(code)).c_str());
+            }
+        }
+    };
+}

src/common/UnitTests-CommonUtils/UnitTests-CommonUtils.rc

@@ -0,0 +1,36 @@
+#include <windows.h>
+#include "resource.h"
+#include "../version/version.h"
+
+1 VERSIONINFO
+FILEVERSION FILE_VERSION
+PRODUCTVERSION PRODUCT_VERSION
+FILEFLAGSMASK VS_FFI_FILEFLAGSMASK
+#ifdef _DEBUG
+FILEFLAGS VS_FF_DEBUG
+#else
+FILEFLAGS 0x0L
+#endif
+FILEOS VOS_NT_WINDOWS32
+FILETYPE VFT_DLL
+FILESUBTYPE VFT2_UNKNOWN
+BEGIN
+    BLOCK "StringFileInfo"
+    BEGIN
+        BLOCK "040904b0" // US English (0x0409), Unicode (0x04B0) charset
+        BEGIN
+            VALUE "CompanyName", COMPANY_NAME
+            VALUE "FileDescription", FILE_DESCRIPTION
+            VALUE "FileVersion", FILE_VERSION_STRING
+            VALUE "InternalName", INTERNAL_NAME
+            VALUE "LegalCopyright", COPYRIGHT_NOTE
+            VALUE "OriginalFilename", ORIGINAL_FILENAME
+            VALUE "ProductName", PRODUCT_NAME
+            VALUE "ProductVersion", PRODUCT_VERSION_STRING
+        END
+    END
+    BLOCK "VarFileInfo"
+    BEGIN
+        VALUE "Translation", 0x409, 1200 // US English (0x0409), Unicode (1200) charset
+    END
+END

src/common/UnitTests-CommonUtils/UnitTests-CommonUtils.vcxproj

@@ -0,0 +1,96 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <Import Project="..\..\..\packages\Microsoft.Windows.CppWinRT.2.0.240111.5\build\native\Microsoft.Windows.CppWinRT.props" Condition="Exists('..\..\..\packages\Microsoft.Windows.CppWinRT.2.0.240111.5\build\native\Microsoft.Windows.CppWinRT.props')" />
+  <PropertyGroup Label="Globals">
+    <VCProjectVersion>16.0</VCProjectVersion>
+    <ProjectGuid>{8B5CFB38-CCBA-40A8-AD7A-89C57B070884}</ProjectGuid>
+    <Keyword>Win32Proj</Keyword>
+    <RootNamespace>UnitTestsCommonUtils</RootNamespace>
+    <ProjectSubType>NativeUnitTestProject</ProjectSubType>
+    <ProjectName>Common.Utils.UnitTests</ProjectName>
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
+  <PropertyGroup Label="Configuration">
+    <ConfigurationType>DynamicLibrary</ConfigurationType>
+    <UseOfMfc>false</UseOfMfc>
+    <PlatformToolset>v143</PlatformToolset>
+    <OutDir>$(SolutionDir)$(Platform)\$(Configuration)\tests\UnitTestsCommonUtils\</OutDir>
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
+  <ImportGroup Label="ExtensionSettings">
+  </ImportGroup>
+  <ImportGroup Label="Shared">
+  </ImportGroup>
+  <ImportGroup Label="PropertySheets">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <PropertyGroup Label="UserMacros" />
+  <ItemDefinitionGroup>
+    <ClCompile>
+      <AdditionalIncludeDirectories>..\;..\utils;..\Telemetry;..\..\;..\..\..\deps\;..\..\..\deps\spdlog\include;..\..\..\packages\Microsoft.Windows.ImplementationLibrary.1.0.231216.1\include;$(VCInstallDir)UnitTest\include;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+      <LanguageStandard>stdcpp23</LanguageStandard>
+      <PreprocessorDefinitions>SPDLOG_WCHAR_TO_UTF8_SUPPORT;SPDLOG_HEADER_ONLY;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+    </ClCompile>
+    <Link>
+      <AdditionalLibraryDirectories>$(VCInstallDir)UnitTest\lib;%(AdditionalLibraryDirectories)</AdditionalLibraryDirectories>
+      <AdditionalDependencies>RuntimeObject.lib;Msi.lib;Shlwapi.lib;%(AdditionalDependencies)</AdditionalDependencies>
+    </Link>
+  </ItemDefinitionGroup>
+  <ItemGroup>
+    <ClCompile Include="pch.cpp">
+      <PrecompiledHeader Condition="'$(UsePrecompiledHeaders)' != 'false'">Create</PrecompiledHeader>
+    </ClCompile>
+    <ClCompile Include="StringUtils.Tests.cpp" />
+    <ClCompile Include="ColorUtils.Tests.cpp" />
+    <ClCompile Include="TimeUtils.Tests.cpp" />
+    <ClCompile Include="WinApiError.Tests.cpp" />
+    <ClCompile Include="Serialized.Tests.cpp" />
+    <ClCompile Include="Json.Tests.cpp" />
+    <ClCompile Include="OsDetect.Tests.cpp" />
+    <ClCompile Include="Threading.Tests.cpp" />
+    <ClCompile Include="ProcessPath.Tests.cpp" />
+    <ClCompile Include="Window.Tests.cpp" />
+    <ClCompile Include="GameMode.Tests.cpp" />
+    <ClCompile Include="Gpo.Tests.cpp" />
+    <ClCompile Include="MsiUtils.Tests.cpp" />
+    <ClCompile Include="HttpClient.Tests.cpp" />
+    <ClCompile Include="ComObjectFactory.Tests.cpp" />
+    <ClCompile Include="AppMutex.Tests.cpp" />
+    <ClCompile Include="Elevation.Tests.cpp" />
+    <ClCompile Include="Exec.Tests.cpp" />
+    <ClCompile Include="ExcludedApps.Tests.cpp" />
+    <ClCompile Include="HDropIterator.Tests.cpp" />
+    <ClCompile Include="LoggerHelper.Tests.cpp" />
+    <ClCompile Include="ModulesRegistry.Tests.cpp" />
+    <ClCompile Include="MsWindowsSettings.Tests.cpp" />
+    <ClCompile Include="Package.Tests.cpp" />
+    <ClCompile Include="ProcessApi.Tests.cpp" />
+    <ClCompile Include="ProcessWaiter.Tests.cpp" />
+    <ClCompile Include="Registry.Tests.cpp" />
+    <ClCompile Include="Resources.Tests.cpp" />
+    <ClCompile Include="TestStubs.cpp" />
+    <ClCompile Include="UnhandledException.Tests.cpp" />
+  </ItemGroup>
+  <ItemGroup>
+    <ClInclude Include="pch.h" />
+    <ClInclude Include="resource.h" />
+    <ClInclude Include="TestHelpers.h" />
+  </ItemGroup>
+  <ItemGroup>
+    <ResourceCompile Include="UnitTests-CommonUtils.rc" />
+  </ItemGroup>
+  <ItemGroup>
+    <None Include="packages.config" />
+  </ItemGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
+  <ImportGroup Label="ExtensionTargets">
+    <Import Project="..\..\..\packages\Microsoft.Windows.CppWinRT.2.0.240111.5\build\native\Microsoft.Windows.CppWinRT.targets" Condition="Exists('..\..\..\packages\Microsoft.Windows.CppWinRT.2.0.240111.5\build\native\Microsoft.Windows.CppWinRT.targets')" />
+  </ImportGroup>
+  <Target Name="EnsureNuGetPackageBuildImports" BeforeTargets="PrepareForBuild">
+    <PropertyGroup>
+      <ErrorText>This project references NuGet package(s) that are missing on this computer. Use NuGet Package Restore to download them.  For more information, see http://go.microsoft.com/fwlink/?LinkID=322105. The missing file is {0}.</ErrorText>
+    </PropertyGroup>
+    <Error Condition="!Exists('..\..\..\packages\Microsoft.Windows.CppWinRT.2.0.240111.5\build\native\Microsoft.Windows.CppWinRT.props')" Text="$([System.String]::Format('$(ErrorText)', '..\..\..\packages\Microsoft.Windows.CppWinRT.2.0.240111.5\build\native\Microsoft.Windows.CppWinRT.props'))" />
+    <Error Condition="!Exists('..\..\..\packages\Microsoft.Windows.CppWinRT.2.0.240111.5\build\native\Microsoft.Windows.CppWinRT.targets')" Text="$([System.String]::Format('$(ErrorText)', '..\..\..\packages\Microsoft.Windows.CppWinRT.2.0.240111.5\build\native\Microsoft.Windows.CppWinRT.targets'))" />
+  </Target>
+</Project>

src/common/UnitTests-CommonUtils/UnitTests-CommonUtils.vcxproj.filters

@@ -0,0 +1,143 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <ItemGroup>
+    <Filter Include="Source Files">
+      <UniqueIdentifier>{4FC737F1-C7A5-4376-A066-2A32D752A2FF}</UniqueIdentifier>
+      <Extensions>cpp;c;cc;cxx;def;odl;idl;hpj;bat;asm;asmx</Extensions>
+    </Filter>
+    <Filter Include="Header Files">
+      <UniqueIdentifier>{93995380-89BD-4b04-88EB-625FBE52EBFB}</UniqueIdentifier>
+      <Extensions>h;hh;hpp;hxx;hm;inl;inc;ipp;xsd</Extensions>
+    </Filter>
+    <Filter Include="Resource Files">
+      <UniqueIdentifier>{67DA6AB6-F800-4c08-8B7A-83BB121AAD01}</UniqueIdentifier>
+      <Extensions>rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe;resx;tiff;tif;png;wav;mfcribbon-ms</Extensions>
+    </Filter>
+    <Filter Include="Source Files\Pure Functions">
+      <UniqueIdentifier>{A1B2C3D4-E5F6-4A5B-8C9D-0E1F2A3B4C5D}</UniqueIdentifier>
+    </Filter>
+    <Filter Include="Source Files\Threading">
+      <UniqueIdentifier>{B2C3D4E5-F6A7-4B6C-9D0E-1F2A3B4C5D6E}</UniqueIdentifier>
+    </Filter>
+    <Filter Include="Source Files\Process">
+      <UniqueIdentifier>{C3D4E5F6-A7B8-4C7D-0E1F-2A3B4C5D6E7F}</UniqueIdentifier>
+    </Filter>
+    <Filter Include="Source Files\Registry">
+      <UniqueIdentifier>{D4E5F6A7-B8C9-4D8E-1F2A-3B4C5D6E7F8A}</UniqueIdentifier>
+    </Filter>
+    <Filter Include="Source Files\Integration">
+      <UniqueIdentifier>{E5F6A7B8-C9D0-4E9F-2A3B-4C5D6E7F8A9B}</UniqueIdentifier>
+    </Filter>
+  </ItemGroup>
+  <ItemGroup>
+    <ClCompile Include="pch.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="StringUtils.Tests.cpp">
+      <Filter>Source Files\Pure Functions</Filter>
+    </ClCompile>
+    <ClCompile Include="ColorUtils.Tests.cpp">
+      <Filter>Source Files\Pure Functions</Filter>
+    </ClCompile>
+    <ClCompile Include="TimeUtils.Tests.cpp">
+      <Filter>Source Files\Pure Functions</Filter>
+    </ClCompile>
+    <ClCompile Include="WinApiError.Tests.cpp">
+      <Filter>Source Files\Pure Functions</Filter>
+    </ClCompile>
+    <ClCompile Include="Serialized.Tests.cpp">
+      <Filter>Source Files\Pure Functions</Filter>
+    </ClCompile>
+    <ClCompile Include="Json.Tests.cpp">
+      <Filter>Source Files\Pure Functions</Filter>
+    </ClCompile>
+    <ClCompile Include="ExcludedApps.Tests.cpp">
+      <Filter>Source Files\Pure Functions</Filter>
+    </ClCompile>
+    <ClCompile Include="OsDetect.Tests.cpp">
+      <Filter>Source Files\Pure Functions</Filter>
+    </ClCompile>
+    <ClCompile Include="Threading.Tests.cpp">
+      <Filter>Source Files\Threading</Filter>
+    </ClCompile>
+    <ClCompile Include="AppMutex.Tests.cpp">
+      <Filter>Source Files\Threading</Filter>
+    </ClCompile>
+    <ClCompile Include="ProcessWaiter.Tests.cpp">
+      <Filter>Source Files\Threading</Filter>
+    </ClCompile>
+    <ClCompile Include="ProcessPath.Tests.cpp">
+      <Filter>Source Files\Process</Filter>
+    </ClCompile>
+    <ClCompile Include="ProcessApi.Tests.cpp">
+      <Filter>Source Files\Process</Filter>
+    </ClCompile>
+    <ClCompile Include="Window.Tests.cpp">
+      <Filter>Source Files\Process</Filter>
+    </ClCompile>
+    <ClCompile Include="Exec.Tests.cpp">
+      <Filter>Source Files\Process</Filter>
+    </ClCompile>
+    <ClCompile Include="GameMode.Tests.cpp">
+      <Filter>Source Files\Process</Filter>
+    </ClCompile>
+    <ClCompile Include="MsWindowsSettings.Tests.cpp">
+      <Filter>Source Files\Process</Filter>
+    </ClCompile>
+    <ClCompile Include="Registry.Tests.cpp">
+      <Filter>Source Files\Registry</Filter>
+    </ClCompile>
+    <ClCompile Include="Gpo.Tests.cpp">
+      <Filter>Source Files\Registry</Filter>
+    </ClCompile>
+    <ClCompile Include="ModulesRegistry.Tests.cpp">
+      <Filter>Source Files\Registry</Filter>
+    </ClCompile>
+    <ClCompile Include="Elevation.Tests.cpp">
+      <Filter>Source Files\Integration</Filter>
+    </ClCompile>
+    <ClCompile Include="Package.Tests.cpp">
+      <Filter>Source Files\Integration</Filter>
+    </ClCompile>
+    <ClCompile Include="MsiUtils.Tests.cpp">
+      <Filter>Source Files\Integration</Filter>
+    </ClCompile>
+    <ClCompile Include="HttpClient.Tests.cpp">
+      <Filter>Source Files\Integration</Filter>
+    </ClCompile>
+    <ClCompile Include="Resources.Tests.cpp">
+      <Filter>Source Files\Integration</Filter>
+    </ClCompile>
+    <ClCompile Include="LoggerHelper.Tests.cpp">
+      <Filter>Source Files\Integration</Filter>
+    </ClCompile>
+    <ClCompile Include="ComObjectFactory.Tests.cpp">
+      <Filter>Source Files\Integration</Filter>
+    </ClCompile>
+    <ClCompile Include="HDropIterator.Tests.cpp">
+      <Filter>Source Files\Integration</Filter>
+    </ClCompile>
+    <ClCompile Include="UnhandledException.Tests.cpp">
+      <Filter>Source Files\Integration</Filter>
+    </ClCompile>
+  </ItemGroup>
+  <ItemGroup>
+    <ClInclude Include="pch.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="resource.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="TestHelpers.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+  </ItemGroup>
+  <ItemGroup>
+    <ResourceCompile Include="UnitTests-CommonUtils.rc">
+      <Filter>Resource Files</Filter>
+    </ResourceCompile>
+  </ItemGroup>
+  <ItemGroup>
+    <None Include="packages.config" />
+  </ItemGroup>
+</Project>

src/common/UnitTests-CommonUtils/WinApiError.Tests.cpp

@@ -0,0 +1,130 @@
+#include "pch.h"
+#include "TestHelpers.h"
+#include <winapi_error.h>
+
+using namespace Microsoft::VisualStudio::CppUnitTestFramework;
+
+namespace UnitTestsCommonUtils
+{
+    TEST_CLASS(WinApiErrorTests)
+    {
+    public:
+        // get_last_error_message tests
+        TEST_METHOD(GetLastErrorMessage_Success_ReturnsMessage)
+        {
+            auto result = get_last_error_message(ERROR_SUCCESS);
+            Assert::IsTrue(result.has_value());
+            Assert::IsFalse(result->empty());
+        }
+
+        TEST_METHOD(GetLastErrorMessage_FileNotFound_ReturnsMessage)
+        {
+            auto result = get_last_error_message(ERROR_FILE_NOT_FOUND);
+            Assert::IsTrue(result.has_value());
+            Assert::IsFalse(result->empty());
+        }
+
+        TEST_METHOD(GetLastErrorMessage_AccessDenied_ReturnsMessage)
+        {
+            auto result = get_last_error_message(ERROR_ACCESS_DENIED);
+            Assert::IsTrue(result.has_value());
+            Assert::IsFalse(result->empty());
+        }
+
+        TEST_METHOD(GetLastErrorMessage_PathNotFound_ReturnsMessage)
+        {
+            auto result = get_last_error_message(ERROR_PATH_NOT_FOUND);
+            Assert::IsTrue(result.has_value());
+            Assert::IsFalse(result->empty());
+        }
+
+        TEST_METHOD(GetLastErrorMessage_InvalidHandle_ReturnsMessage)
+        {
+            auto result = get_last_error_message(ERROR_INVALID_HANDLE);
+            Assert::IsTrue(result.has_value());
+            Assert::IsFalse(result->empty());
+        }
+
+        TEST_METHOD(GetLastErrorMessage_NotEnoughMemory_ReturnsMessage)
+        {
+            auto result = get_last_error_message(ERROR_NOT_ENOUGH_MEMORY);
+            Assert::IsTrue(result.has_value());
+            Assert::IsFalse(result->empty());
+        }
+
+        TEST_METHOD(GetLastErrorMessage_InvalidParameter_ReturnsMessage)
+        {
+            auto result = get_last_error_message(ERROR_INVALID_PARAMETER);
+            Assert::IsTrue(result.has_value());
+            Assert::IsFalse(result->empty());
+        }
+
+        // get_last_error_or_default tests
+        TEST_METHOD(GetLastErrorOrDefault_Success_ReturnsMessage)
+        {
+            auto result = get_last_error_or_default(ERROR_SUCCESS);
+            Assert::IsFalse(result.empty());
+        }
+
+        TEST_METHOD(GetLastErrorOrDefault_FileNotFound_ReturnsMessage)
+        {
+            auto result = get_last_error_or_default(ERROR_FILE_NOT_FOUND);
+            Assert::IsFalse(result.empty());
+        }
+
+        TEST_METHOD(GetLastErrorOrDefault_AccessDenied_ReturnsMessage)
+        {
+            auto result = get_last_error_or_default(ERROR_ACCESS_DENIED);
+            Assert::IsFalse(result.empty());
+        }
+
+        TEST_METHOD(GetLastErrorOrDefault_UnknownError_ReturnsEmptyOrMessage)
+        {
+            // For an unknown error code, should return empty string or a default message
+            auto result = get_last_error_or_default(0xFFFFFFFF);
+            // Either empty or has content, both are valid
+            Assert::IsTrue(result.empty() || !result.empty());
+        }
+
+        // Comparison tests
+        TEST_METHOD(BothFunctions_SameError_ProduceSameContent)
+        {
+            auto message = get_last_error_message(ERROR_FILE_NOT_FOUND);
+            auto defaultMessage = get_last_error_or_default(ERROR_FILE_NOT_FOUND);
+
+            Assert::IsTrue(message.has_value());
+            Assert::AreEqual(*message, defaultMessage);
+        }
+
+        TEST_METHOD(BothFunctions_SuccessError_ProduceSameContent)
+        {
+            auto message = get_last_error_message(ERROR_SUCCESS);
+            auto defaultMessage = get_last_error_or_default(ERROR_SUCCESS);
+
+            Assert::IsTrue(message.has_value());
+            Assert::AreEqual(*message, defaultMessage);
+        }
+
+        // Error code specific tests
+        TEST_METHOD(GetLastErrorMessage_SharingViolation_ReturnsMessage)
+        {
+            auto result = get_last_error_message(ERROR_SHARING_VIOLATION);
+            Assert::IsTrue(result.has_value());
+            Assert::IsFalse(result->empty());
+        }
+
+        TEST_METHOD(GetLastErrorMessage_FileExists_ReturnsMessage)
+        {
+            auto result = get_last_error_message(ERROR_FILE_EXISTS);
+            Assert::IsTrue(result.has_value());
+            Assert::IsFalse(result->empty());
+        }
+
+        TEST_METHOD(GetLastErrorMessage_DirNotEmpty_ReturnsMessage)
+        {
+            auto result = get_last_error_message(ERROR_DIR_NOT_EMPTY);
+            Assert::IsTrue(result.has_value());
+            Assert::IsFalse(result->empty());
+        }
+    };
+}

src/common/UnitTests-CommonUtils/Window.Tests.cpp

@@ -0,0 +1,159 @@
+#include "pch.h"
+#include "TestHelpers.h"
+#include <window.h>
+
+using namespace Microsoft::VisualStudio::CppUnitTestFramework;
+
+namespace UnitTestsCommonUtils
+{
+    TEST_CLASS(WindowTests)
+    {
+    public:
+        // is_system_window tests
+        TEST_METHOD(IsSystemWindow_DesktopWindow_ReturnsResult)
+        {
+            HWND desktop = GetDesktopWindow();
+            Assert::IsNotNull(desktop);
+
+            // Get class name
+            char className[256] = {};
+            GetClassNameA(desktop, className, sizeof(className));
+
+            bool result = is_system_window(desktop, className);
+            // Just verify it doesn't crash and returns a boolean
+            Assert::IsTrue(result == true || result == false);
+        }
+
+        TEST_METHOD(IsSystemWindow_NullHwnd_ReturnsFalse)
+        {
+            auto shell = GetShellWindow();
+            auto desktop = GetDesktopWindow();
+            bool result = is_system_window(nullptr, "ClassName");
+            bool expected = (shell == nullptr) || (desktop == nullptr);
+            Assert::AreEqual(expected, result);
+        }
+
+        TEST_METHOD(IsSystemWindow_InvalidHwnd_ReturnsFalse)
+        {
+            bool result = is_system_window(reinterpret_cast<HWND>(0x12345678), "ClassName");
+            Assert::IsFalse(result);
+        }
+
+        TEST_METHOD(IsSystemWindow_EmptyClassName_DoesNotCrash)
+        {
+            HWND desktop = GetDesktopWindow();
+            bool result = is_system_window(desktop, "");
+            // Just verify it doesn't crash
+            Assert::IsTrue(result == true || result == false);
+        }
+
+        TEST_METHOD(IsSystemWindow_NullClassName_DoesNotCrash)
+        {
+            HWND desktop = GetDesktopWindow();
+            bool result = is_system_window(desktop, nullptr);
+            // Should handle null className gracefully
+            Assert::IsTrue(result == true || result == false);
+        }
+
+        // GetWindowCreateParam tests
+        TEST_METHOD(GetWindowCreateParam_ValidLparam_ReturnsValue)
+        {
+            struct TestData
+            {
+                int value;
+            };
+
+            TestData data{ 42 };
+            CREATESTRUCT cs{};
+            cs.lpCreateParams = &data;
+
+            auto result = GetWindowCreateParam<TestData*>(reinterpret_cast<LPARAM>(&cs));
+            Assert::IsNotNull(result);
+            Assert::AreEqual(42, result->value);
+        }
+
+        // Window data storage tests
+        TEST_METHOD(WindowData_StoreAndRetrieve_Works)
+        {
+            // Create a simple message-only window for testing
+            WNDCLASSW wc = {};
+            wc.lpfnWndProc = DefWindowProcW;
+            wc.hInstance = GetModuleHandleW(nullptr);
+            wc.lpszClassName = L"TestWindowClass_DataTest";
+            RegisterClassW(&wc);
+
+            HWND hwnd = CreateWindowExW(0, L"TestWindowClass_DataTest", L"Test",
+                                        0, 0, 0, 0, 0, HWND_MESSAGE, nullptr,
+                                        GetModuleHandleW(nullptr), nullptr);
+
+            if (hwnd)
+            {
+                int value = 42;
+                int* testValue = &value;
+                StoreWindowParam(hwnd, testValue);
+
+                auto retrieved = GetWindowParam<int*>(hwnd);
+                Assert::AreEqual(testValue, retrieved);
+
+                DestroyWindow(hwnd);
+            }
+
+            UnregisterClassW(L"TestWindowClass_DataTest", GetModuleHandleW(nullptr));
+            Assert::IsTrue(true); // Window creation might fail in test environment
+        }
+
+        // run_message_loop tests
+        TEST_METHOD(RunMessageLoop_UntilIdle_Completes)
+        {
+            // Run message loop until idle with a timeout
+            // This should complete quickly since there are no messages
+            auto start = std::chrono::steady_clock::now();
+
+            run_message_loop(true, 100);
+
+            auto elapsed = std::chrono::duration_cast<std::chrono::milliseconds>(
+                std::chrono::steady_clock::now() - start);
+
+            // Should complete within reasonable time
+            Assert::IsTrue(elapsed.count() < 500);
+        }
+
+        TEST_METHOD(RunMessageLoop_WithTimeout_RespectsTimeout)
+        {
+            auto start = std::chrono::steady_clock::now();
+
+            run_message_loop(false, 50);
+
+            auto elapsed = std::chrono::duration_cast<std::chrono::milliseconds>(
+                std::chrono::steady_clock::now() - start);
+
+            // Should take at least the timeout duration
+            // Allow some tolerance for timing
+            Assert::IsTrue(elapsed.count() >= 40 && elapsed.count() < 500);
+        }
+
+        TEST_METHOD(RunMessageLoop_ZeroTimeout_CompletesImmediately)
+        {
+            auto start = std::chrono::steady_clock::now();
+
+            run_message_loop(false, 0);
+
+            auto elapsed = std::chrono::duration_cast<std::chrono::milliseconds>(
+                std::chrono::steady_clock::now() - start);
+
+            // Should complete very quickly
+            Assert::IsTrue(elapsed.count() < 100);
+        }
+
+        TEST_METHOD(RunMessageLoop_NoTimeout_ProcessesMessages)
+        {
+            // Post a quit message before starting the loop
+            PostQuitMessage(0);
+
+            // Should process the quit message and exit
+            run_message_loop(false, std::nullopt);
+
+            Assert::IsTrue(true);
+        }
+    };
+}

src/common/UnitTests-CommonUtils/packages.config

@@ -0,0 +1,4 @@
+<?xml version="1.0" encoding="utf-8"?>
+<packages>
+  <package id="Microsoft.Windows.CppWinRT" version="2.0.240111.5" targetFramework="native" />
+</packages>

src/common/UnitTests-CommonUtils/pch.cpp

@@ -0,0 +1,5 @@
+// pch.cpp: source file corresponding to the pre-compiled header
+
+#include "pch.h"
+
+// When you are using pre-compiled headers, this source file is necessary for compilation to succeed.

src/common/UnitTests-CommonUtils/pch.h

@@ -0,0 +1,39 @@
+// pch.h: This is a precompiled header file.
+// Files listed below are compiled only once, improving build performance for future builds.
+// This also affects IntelliSense performance, including code completion and many code browsing features.
+// However, files listed here are ALL re-compiled if any one of them is updated between builds.
+// Do not add files here that you will be updating frequently as this negates the performance advantage.
+
+#ifndef PCH_H
+#define PCH_H
+
+// add headers that you want to pre-compile here
+#include <Windows.h>
+#include <winrt/base.h>
+#include <winrt/Windows.Foundation.h>
+#include <winrt/Windows.Foundation.Collections.h>
+#include <winrt/Windows.Foundation.Metadata.h>
+#include <winrt/Windows.Data.Json.h>
+
+#include <string>
+#include <vector>
+#include <optional>
+#include <functional>
+#include <thread>
+#include <atomic>
+#include <mutex>
+#include <shared_mutex>
+#include <future>
+#include <queue>
+#include <filesystem>
+#include <fstream>
+#include <chrono>
+#include <ctime>
+
+// Suppressing 26466 - Don't use static_cast downcasts - in CppUnitTest.h
+#pragma warning(push)
+#pragma warning(disable : 26466)
+#include "CppUnitTest.h"
+#pragma warning(pop)
+
+#endif //PCH_H

src/common/UnitTests-CommonUtils/resource.h

@@ -0,0 +1,13 @@
+//{{NO_DEPENDENCIES}}
+// Microsoft Visual C++ generated include file.
+// Used by UnitTests-CommonUtils.rc
+
+//////////////////////////////
+// Non-localizable
+
+#define FILE_DESCRIPTION "PowerToys UnitTests-CommonUtils"
+#define INTERNAL_NAME "UnitTests-CommonUtils"
+#define ORIGINAL_FILENAME "UnitTests-CommonUtils.dll"
+
+// Non-localizable
+//////////////////////////////

src/common/interop/PowerToys.Interop.vcxproj

@@ -41,7 +41,7 @@
   <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
   <PropertyGroup Label="Configuration">
     <ConfigurationType>DynamicLibrary</ConfigurationType>
-    <PlatformToolset>v143</PlatformToolset>
+    
     <CharacterSet>Unicode</CharacterSet>
     <GenerateManifest>false</GenerateManifest>
   </PropertyGroup>

src/common/interop/shared_constants.h

@@ -72,6 +72,10 @@ namespace CommonSharedConstants
 
     const wchar_t ALWAYS_ON_TOP_TERMINATE_EVENT[] = L"Local\\AlwaysOnTopTerminateEvent-cfdf1eae-791f-4953-8021-2f18f3837eae";
 
+    const wchar_t ALWAYS_ON_TOP_INCREASE_OPACITY_EVENT[] = L"Local\\AlwaysOnTopIncreaseOpacityEvent-a1b2c3d4-e5f6-7890-abcd-ef1234567890";
+
+    const wchar_t ALWAYS_ON_TOP_DECREASE_OPACITY_EVENT[] = L"Local\\AlwaysOnTopDecreaseOpacityEvent-b2c3d4e5-f6a7-8901-bcde-f12345678901";
+
     // Path to the event used by PowerAccent
     const wchar_t POWERACCENT_EXIT_EVENT[] = L"Local\\PowerToysPowerAccentExitEvent-53e93389-d19a-4fbb-9b36-1981c8965e17";
 

src/common/logger/logger.vcxproj

@@ -36,7 +36,7 @@
   <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
   <PropertyGroup Label="Configuration">
     <ConfigurationType>StaticLibrary</ConfigurationType>
-    <PlatformToolset>v143</PlatformToolset>
+    
     <OutDir>..\..\..\$(Platform)\$(Configuration)\</OutDir>
   </PropertyGroup>
   <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />

src/common/notifications/BackgroundActivator/BackgroundActivator.vcxproj

@@ -18,7 +18,7 @@
   <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
   <PropertyGroup Label="Configuration">
     <ConfigurationType>StaticLibrary</ConfigurationType>
-    <PlatformToolset>v143</PlatformToolset>
+    
     <CharacterSet>Unicode</CharacterSet>
     <GenerateManifest>false</GenerateManifest>
   </PropertyGroup>

src/common/notifications/BackgroundActivatorDLL/BackgroundActivatorDLL.vcxproj

@@ -10,7 +10,7 @@
   <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
   <PropertyGroup Label="Configuration">
     <ConfigurationType>DynamicLibrary</ConfigurationType>
-    <PlatformToolset>v143</PlatformToolset>
+    
   </PropertyGroup>
   <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
   <ImportGroup Label="ExtensionSettings">

src/common/notifications/notifications.vcxproj

@@ -11,7 +11,7 @@
   <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
   <PropertyGroup Label="Configuration">
     <ConfigurationType>StaticLibrary</ConfigurationType>
-    <PlatformToolset>v143</PlatformToolset>
+    
   </PropertyGroup>
   <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
   <ImportGroup Label="ExtensionSettings">

src/common/updating/updating.vcxproj

@@ -12,7 +12,7 @@
   <Import Project="..\..\..\deps\expected.props" />
   <PropertyGroup Label="Configuration">
     <ConfigurationType>StaticLibrary</ConfigurationType>
-    <PlatformToolset>v143</PlatformToolset>
+    
   </PropertyGroup>
   <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
   <Import Project="..\..\..\deps\spdlog.props" />

src/common/utils/EventLocker.h

@@ -34,6 +34,7 @@ public:
     {
         this->eventHandle = e.eventHandle;
         e.eventHandle = nullptr;
+        return *this;
     }
 
     ~EventLocker()

src/common/utils/MsWindowsSettings.h

@@ -1,5 +1,8 @@
 #pragma once
 
+#include <Windows.h>
+#include "../logger/logger.h"
+
 inline bool GetAnimationsEnabled()
 {
     BOOL enabled = 0;
@@ -10,4 +13,4 @@ inline bool GetAnimationsEnabled()
         Logger::error("SystemParametersInfo SPI_GETCLIENTAREAANIMATION failed.");
     }
     return enabled;
-}
+}

src/common/utils/ProcessWaiter.h

@@ -7,7 +7,19 @@ namespace ProcessWaiter
 {
     void OnProcessTerminate(std::wstring parent_pid, std::function<void(DWORD)> callback)
     {
-        DWORD pid = std::stol(parent_pid);
+        DWORD pid = 0;
+        try
+        {
+            pid = std::stol(parent_pid);
+        }
+        catch (...)
+        {
+            if (callback)
+            {
+                callback(ERROR_INVALID_PARAMETER);
+            }
+            return;
+        }
         std::thread([=]() {
             HANDLE process = OpenProcess(SYNCHRONIZE, FALSE, pid);
             if (process != nullptr)
@@ -15,17 +27,26 @@ namespace ProcessWaiter
                 if (WaitForSingleObject(process, INFINITE) == WAIT_OBJECT_0)
                 {
                     CloseHandle(process);
-                    callback(ERROR_SUCCESS);
+                    if (callback)
+                    {
+                        callback(ERROR_SUCCESS);
+                    }
                 }
                 else
                 {
                     CloseHandle(process);
-                    callback(GetLastError());
+                    if (callback)
+                    {
+                        callback(GetLastError());
+                    }
                 }
             }
             else
             {
-                callback(GetLastError());
+                if (callback)
+                {
+                    callback(GetLastError());
+                }
             }
         }).detach();
     }

src/common/utils/com_object_factory.h

@@ -31,6 +31,10 @@ public:
 
     HRESULT __stdcall CreateInstance(IUnknown* punkOuter, const IID& riid, void** ppv)
     {
+        if (!ppv)
+        {
+            return E_POINTER;
+        }
         *ppv = nullptr;
                 
         if (punkOuter)
@@ -55,4 +59,4 @@ public:
 
 private:
     std::atomic<long> _refCount;
-};
+};

src/common/utils/logger_helper.h

@@ -3,6 +3,7 @@
 #include <filesystem>
 #include <common/version/version.h>
 #include <common/SettingsAPI/settings_helpers.h>
+#include "../logger/logger.h"
 
 namespace LoggerHelpers
 {

src/common/utils/package.h

@@ -21,9 +21,16 @@
 
 namespace package
 {
-    using namespace winrt::Windows::Foundation;
-    using namespace winrt::Windows::ApplicationModel;
-    using namespace winrt::Windows::Management::Deployment;
+    using winrt::Windows::ApplicationModel::Package;
+    using winrt::Windows::Foundation::IAsyncOperationWithProgress;
+    using winrt::Windows::Foundation::AsyncStatus;
+    using winrt::Windows::Foundation::Uri;
+    using winrt::Windows::Foundation::Collections::IVector;
+    using winrt::Windows::Management::Deployment::AddPackageOptions;
+    using winrt::Windows::Management::Deployment::DeploymentOptions;
+    using winrt::Windows::Management::Deployment::DeploymentProgress;
+    using winrt::Windows::Management::Deployment::DeploymentResult;
+    using winrt::Windows::Management::Deployment::PackageManager;
     using Microsoft::WRL::ComPtr;
 
     inline BOOL IsWin11OrGreater()
@@ -435,7 +442,7 @@ namespace package
             // Declare use of an external location
             DeploymentOptions options = DeploymentOptions::ForceTargetApplicationShutdown;
 
-            Collections::IVector<Uri> uris = winrt::single_threaded_vector<Uri>();
+            IVector<Uri> uris = winrt::single_threaded_vector<Uri>();
             if (!dependencies.empty())
             {
                 for (const auto& dependency : dependencies)

src/common/utils/timeutil.h

@@ -4,6 +4,7 @@
 #include <cinttypes>
 #include <string>
 #include <optional>
+#include <cwctype>
 
 #include <winrt/base.h>
 
@@ -27,6 +28,17 @@ namespace timeutil
     {
         try
         {
+            if (s.empty())
+            {
+                return std::nullopt;
+            }
+            for (wchar_t ch : s)
+            {
+                if (!iswdigit(ch))
+                {
+                    return std::nullopt;
+                }
+            }
             uint64_t i = std::stoull(s);
             return static_cast<std::time_t>(i);
         }

src/common/version/version.vcxproj

@@ -47,7 +47,7 @@
   <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
   <PropertyGroup Label="Configuration">
     <ConfigurationType>StaticLibrary</ConfigurationType>
-    <PlatformToolset>v143</PlatformToolset>
+    
   </PropertyGroup>
   <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
   <ImportGroup Label="ExtensionSettings">

src/logging/logging.vcxproj

@@ -36,7 +36,7 @@
   <PropertyGroup Label="Configuration">
     <ConfigurationType>StaticLibrary</ConfigurationType>
     <CharacterSet>MultiByte</CharacterSet>
-    <PlatformToolset>v143</PlatformToolset>
+    
     <OutDir>..\..\$(Platform)\$(Configuration)\</OutDir>
   </PropertyGroup>
   <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />