From fe6e82bd975ac7d8c36b4667161de13ac97ede66 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Amaury=20Lev=C3=A9?= <amauryleve@microsoft.com>
Date: Sun, 28 Jun 2026 22:30:29 +0200
Subject: [PATCH 1/2] Refactor analyzer/report-engine duplication and MSBuild
 authoring (#9483, #9482, #9467, #9414)

- #9483: extract RegisterInstanceFixtureAnalyzer helper shared by TestInitialize/TestCleanup analyzers
- #9482: bundle report-engine dependencies into ReportEngineContext + CreateEngineContext factory
- #9467: reclassify MSTEST0067 to Category.Performance, document Category taxonomy, add governance tests
- #9414: declare Returns on GetMSTestV2CultureHierarchy; move _ValidateBundledSdkFeatureVersions target from Directory.Packages.props to Directory.Build.targets

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>
---
 Directory.Build.targets                       | 18 ++++++++++++
 Directory.Packages.props                      | 18 ++----------
 .../common/MSTest.TestAdapter.targets         |  2 +-
 .../uwp/MSTest.TestAdapter.targets            |  2 +-
 ...idThreadSleepAndTaskWaitInTestsAnalyzer.cs |  2 +-
 .../MSTest.Analyzers/Helpers/Category.cs      | 12 ++++++--
 .../Helpers/FixtureMethodAnalyzerHelper.cs    | 15 ++++++++++
 .../TestCleanupShouldBeValidAnalyzer.cs       |  4 +--
 .../TestInitializeShouldBeValidAnalyzer.cs    |  4 +--
 .../CtrfReportEngine.cs                       |  5 ++++
 .../CtrfReportGenerator.cs                    | 12 +-------
 ...osoft.Testing.Extensions.CtrfReport.csproj |  1 +
 .../HtmlReportEngine.cs                       |  5 ++++
 .../HtmlReportGenerator.cs                    | 12 +-------
 ...osoft.Testing.Extensions.HtmlReport.csproj |  1 +
 .../JUnitReportEngine.cs                      |  5 ++++
 .../JUnitReportGenerator.cs                   | 12 +-------
 ...soft.Testing.Extensions.JUnitReport.csproj |  1 +
 ...rosoft.Testing.Extensions.TrxReport.csproj |  1 +
 .../ReportEngineBase.cs                       | 15 ++++++++++
 .../ReportEngineContext.cs                    | 28 +++++++++++++++++++
 .../ReportGeneratorBase.cs                    | 18 ++++++++++++
 .../AnalyzerCategoryGovernanceTests.cs        | 25 +++++++++++++++++
 23 files changed, 160 insertions(+), 58 deletions(-)
 create mode 100644 src/Platform/SharedExtensionHelpers/ReportEngineContext.cs
 create mode 100644 test/UnitTests/MSTest.Analyzers.UnitTests/AnalyzerCategoryGovernanceTests.cs

diff --git a/Directory.Build.targets b/Directory.Build.targets
index d079454d8d..c3a33c3ba3 100644
--- a/Directory.Build.targets
+++ b/Directory.Build.targets
@@ -64,4 +64,22 @@
       <Compile Include="$(IntermediateOutputPath)BuildInfo.cs" />
     </ItemGroup>
   </Target>
+
+  <!-- Validates that the literal versions declared on the MSTest.Sdk-bundled feature PackageVersion items
+       in Directory.Packages.props stay in sync with the matching scalar *Version properties consumed by the
+       build. Authored here (rather than in Directory.Packages.props) because targets belong in .targets
+       files; the PackageVersion items it references are populated before this target executes regardless of
+       which file declares it. -->
+  <Target Name="_ValidateBundledSdkFeatureVersions"
+          BeforeTargets="CollectPackageReferences;GenerateNuspec;Build;Pack"
+          Condition=" '$(MSBuildProjectName)' == 'MSTest.Sdk' ">
+    <PropertyGroup>
+      <_AspireHostingTestingPackageVersion>@(PackageVersion->WithMetadataValue('Identity', 'Aspire.Hosting.Testing')->'%(Version)')</_AspireHostingTestingPackageVersion>
+      <_MicrosoftPlaywrightPackageVersion>@(PackageVersion->WithMetadataValue('Identity', 'Microsoft.Playwright.MSTest.v4')->'%(Version)')</_MicrosoftPlaywrightPackageVersion>
+    </PropertyGroup>
+    <Error Condition=" '$(AspireHostingTestingVersion)' != '$(_AspireHostingTestingPackageVersion)' "
+           Text="AspireHostingTestingVersion ('$(AspireHostingTestingVersion)') is out of sync with the 'Aspire.Hosting.Testing' PackageVersion ('$(_AspireHostingTestingPackageVersion)') in Directory.Packages.props. Update the AspireHostingTestingVersion property to match (Dependabot only updates the PackageVersion)." />
+    <Error Condition=" '$(MicrosoftPlaywrightVersion)' != '$(_MicrosoftPlaywrightPackageVersion)' "
+           Text="MicrosoftPlaywrightVersion ('$(MicrosoftPlaywrightVersion)') is out of sync with the 'Microsoft.Playwright.MSTest.v4' PackageVersion ('$(_MicrosoftPlaywrightPackageVersion)') in Directory.Packages.props. Update the MicrosoftPlaywrightVersion property to match (Dependabot only updates the PackageVersion)." />
+  </Target>
 </Project>
diff --git a/Directory.Packages.props b/Directory.Packages.props
index e211c40dc3..a7b98f913b 100644
--- a/Directory.Packages.props
+++ b/Directory.Packages.props
@@ -164,24 +164,12 @@
     template (see MSTest.Sdk.csproj). The two cannot be unified because the consuming property must
     be a plain scalar (an item transform such as @(PackageVersion->...) stored in a property is not
     expanded and breaks string concatenation, e.g. MSB4012), while Dependabot needs the literal on
-    the PackageVersion. The _ValidateBundledSdkFeatureVersions target below fails the build if the
-    property and the PackageVersion ever drift apart (e.g. after Dependabot bumps only the
-    PackageVersion), so the duplication can never ship out of sync.
+    the PackageVersion. The _ValidateBundledSdkFeatureVersions target (in Directory.Build.targets)
+    fails the build if the property and the PackageVersion ever drift apart (e.g. after Dependabot
+    bumps only the PackageVersion), so the duplication can never ship out of sync.
     -->
   <ItemGroup Label="Declared by MSTest.Sdk but not used directly">
     <PackageVersion Include="Aspire.Hosting.Testing" Version="13.4.6" />
     <PackageVersion Include="Microsoft.Playwright.MSTest.v4" Version="1.60.0" />
   </ItemGroup>
-  <Target Name="_ValidateBundledSdkFeatureVersions"
-          BeforeTargets="CollectPackageReferences;GenerateNuspec;Build;Pack"
-          Condition=" '$(MSBuildProjectName)' == 'MSTest.Sdk' ">
-    <PropertyGroup>
-      <_AspireHostingTestingPackageVersion>@(PackageVersion->WithMetadataValue('Identity', 'Aspire.Hosting.Testing')->'%(Version)')</_AspireHostingTestingPackageVersion>
-      <_MicrosoftPlaywrightPackageVersion>@(PackageVersion->WithMetadataValue('Identity', 'Microsoft.Playwright.MSTest.v4')->'%(Version)')</_MicrosoftPlaywrightPackageVersion>
-    </PropertyGroup>
-    <Error Condition=" '$(AspireHostingTestingVersion)' != '$(_AspireHostingTestingPackageVersion)' "
-           Text="AspireHostingTestingVersion ('$(AspireHostingTestingVersion)') is out of sync with the 'Aspire.Hosting.Testing' PackageVersion ('$(_AspireHostingTestingPackageVersion)') in Directory.Packages.props. Update the AspireHostingTestingVersion property to match (Dependabot only updates the PackageVersion)." />
-    <Error Condition=" '$(MicrosoftPlaywrightVersion)' != '$(_MicrosoftPlaywrightPackageVersion)' "
-           Text="MicrosoftPlaywrightVersion ('$(MicrosoftPlaywrightVersion)') is out of sync with the 'Microsoft.Playwright.MSTest.v4' PackageVersion ('$(_MicrosoftPlaywrightPackageVersion)') in Directory.Packages.props. Update the MicrosoftPlaywrightVersion property to match (Dependabot only updates the PackageVersion)." />
-  </Target>
 </Project>
diff --git a/src/Adapter/MSTest.TestAdapter/buildTransitive/common/MSTest.TestAdapter.targets b/src/Adapter/MSTest.TestAdapter/buildTransitive/common/MSTest.TestAdapter.targets
index e524698986..04cfa32158 100644
--- a/src/Adapter/MSTest.TestAdapter/buildTransitive/common/MSTest.TestAdapter.targets
+++ b/src/Adapter/MSTest.TestAdapter/buildTransitive/common/MSTest.TestAdapter.targets
@@ -46,7 +46,7 @@
     <MSTestSourceGenMode Condition=" '$(MSTestSourceGenMode)' == '' ">Rooting</MSTestSourceGenMode>
   </PropertyGroup>
 
-  <Target Name="GetMSTestV2CultureHierarchy">
+  <Target Name="GetMSTestV2CultureHierarchy" Returns="@(MSTestV2Files)">
     <!--
       Only traversing 5 levels in the culture hierarchy. This is the maximum length for all cultures and should be sufficient
       to get to a culture name that maps to a resource folder we package.
diff --git a/src/Adapter/MSTest.TestAdapter/buildTransitive/uwp/MSTest.TestAdapter.targets b/src/Adapter/MSTest.TestAdapter/buildTransitive/uwp/MSTest.TestAdapter.targets
index 54d6b2fe9c..00d48395f2 100644
--- a/src/Adapter/MSTest.TestAdapter/buildTransitive/uwp/MSTest.TestAdapter.targets
+++ b/src/Adapter/MSTest.TestAdapter/buildTransitive/uwp/MSTest.TestAdapter.targets
@@ -13,7 +13,7 @@
     <CompilerVisibleProperty Include="IsMSTestTestAdapterReferenced" />
   </ItemGroup>
 
-  <Target Name="GetMSTestV2CultureHierarchy">
+  <Target Name="GetMSTestV2CultureHierarchy" Returns="@(MSTestV2Files)">
     <!--
       Only traversing 5 levels in the culture hierarchy. This is the maximum length for all cultures and should be sufficient
       to get to a culture name that maps to a resource folder we package.
diff --git a/src/Analyzers/MSTest.Analyzers/AvoidThreadSleepAndTaskWaitInTestsAnalyzer.cs b/src/Analyzers/MSTest.Analyzers/AvoidThreadSleepAndTaskWaitInTestsAnalyzer.cs
index a68bb3099e..6ae85401b2 100644
--- a/src/Analyzers/MSTest.Analyzers/AvoidThreadSleepAndTaskWaitInTestsAnalyzer.cs
+++ b/src/Analyzers/MSTest.Analyzers/AvoidThreadSleepAndTaskWaitInTestsAnalyzer.cs
@@ -28,7 +28,7 @@ public sealed class AvoidThreadSleepAndTaskWaitInTestsAnalyzer : DiagnosticAnaly
         Title,
         MessageFormat,
         Description,
-        Category.Usage,
+        Category.Performance,
         DiagnosticSeverity.Info,
         isEnabledByDefault: false);
 
diff --git a/src/Analyzers/MSTest.Analyzers/Helpers/Category.cs b/src/Analyzers/MSTest.Analyzers/Helpers/Category.cs
index 24103a30f0..c06a1f3d4d 100644
--- a/src/Analyzers/MSTest.Analyzers/Helpers/Category.cs
+++ b/src/Analyzers/MSTest.Analyzers/Helpers/Category.cs
@@ -6,17 +6,23 @@ namespace MSTest.Analyzers.Helpers;
 internal enum Category
 {
     /// <summary>
-    /// Rules that support designing test suites.
+    /// Rules that support designing test suites — structural and organizational patterns such as how test
+    /// classes, fixtures, and data sources are shaped. Use this for guidance that improves the maintainability
+    /// or correctness of the test design rather than raw API usage or runtime cost.
     /// </summary>
     Design,
 
     /// <summary>
-    /// Rules that support high-performance testing.
+    /// Rules that support high-performance testing — patterns that measurably affect test-suite execution time
+    /// or resource usage. Use this for blocking calls (e.g. <c>Thread.Sleep</c>/<c>Task.Wait</c>), missing
+    /// parallelism, or non-cooperative timeouts that keep threads busy after a test has timed out.
     /// </summary>
     Performance,
 
     /// <summary>
-    /// Rules that support proper usage of MSTest.
+    /// Rules that support proper usage of MSTest — correct API usage such as valid method signatures, required
+    /// attributes, and avoiding misused APIs. Use this when the diagnostic is about using the framework
+    /// correctly rather than test design or runtime performance.
     /// </summary>
     Usage,
 }
diff --git a/src/Analyzers/MSTest.Analyzers/Helpers/FixtureMethodAnalyzerHelper.cs b/src/Analyzers/MSTest.Analyzers/Helpers/FixtureMethodAnalyzerHelper.cs
index 93ad23eabd..96ac4ce00f 100644
--- a/src/Analyzers/MSTest.Analyzers/Helpers/FixtureMethodAnalyzerHelper.cs
+++ b/src/Analyzers/MSTest.Analyzers/Helpers/FixtureMethodAnalyzerHelper.cs
@@ -37,6 +37,21 @@ internal static bool TryGetFixtureMethodSymbols(
         return true;
     }
 
+    /// <summary>
+    /// Registers the standard symbol analysis for an instance fixture method (e.g. <c>[TestInitialize]</c> or
+    /// <c>[TestCleanup]</c>): reports <paramref name="rule"/> for methods that do not have a valid instance
+    /// fixture signature. Callers remain responsible for <c>ConfigureGeneratedCodeAnalysis</c> /
+    /// <c>EnableConcurrentExecution</c> as required by the RS1025/RS1026 analyzers.
+    /// </summary>
+    internal static void RegisterInstanceFixtureAnalyzer(
+        AnalysisContext context,
+        string fixtureAttributeMetadataName,
+        DiagnosticDescriptor rule)
+        => RegisterFixtureMethodSymbolAction(
+            context,
+            fixtureAttributeMetadataName,
+            (symbolContext, symbols) => AnalyzeInstanceFixtureMethod(symbolContext, symbols, rule));
+
     internal static void RegisterFixtureMethodSymbolAction(
         AnalysisContext context,
         string fixtureAttributeMetadataName,
diff --git a/src/Analyzers/MSTest.Analyzers/TestCleanupShouldBeValidAnalyzer.cs b/src/Analyzers/MSTest.Analyzers/TestCleanupShouldBeValidAnalyzer.cs
index d230df4ca3..dac3fdc2dd 100644
--- a/src/Analyzers/MSTest.Analyzers/TestCleanupShouldBeValidAnalyzer.cs
+++ b/src/Analyzers/MSTest.Analyzers/TestCleanupShouldBeValidAnalyzer.cs
@@ -34,9 +34,9 @@ public override void Initialize(AnalysisContext context)
     {
         context.ConfigureGeneratedCodeAnalysis(GeneratedCodeAnalysisFlags.None);
         context.EnableConcurrentExecution();
-        FixtureMethodAnalyzerHelper.RegisterFixtureMethodSymbolAction(
+        FixtureMethodAnalyzerHelper.RegisterInstanceFixtureAnalyzer(
             context,
             WellKnownTypeNames.MicrosoftVisualStudioTestToolsUnitTestingTestCleanupAttribute,
-            static (symbolContext, symbols) => FixtureMethodAnalyzerHelper.AnalyzeInstanceFixtureMethod(symbolContext, symbols, Rule));
+            Rule);
     }
 }
diff --git a/src/Analyzers/MSTest.Analyzers/TestInitializeShouldBeValidAnalyzer.cs b/src/Analyzers/MSTest.Analyzers/TestInitializeShouldBeValidAnalyzer.cs
index 8341c9d51f..9eb2a76bd2 100644
--- a/src/Analyzers/MSTest.Analyzers/TestInitializeShouldBeValidAnalyzer.cs
+++ b/src/Analyzers/MSTest.Analyzers/TestInitializeShouldBeValidAnalyzer.cs
@@ -34,9 +34,9 @@ public override void Initialize(AnalysisContext context)
     {
         context.ConfigureGeneratedCodeAnalysis(GeneratedCodeAnalysisFlags.None);
         context.EnableConcurrentExecution();
-        FixtureMethodAnalyzerHelper.RegisterFixtureMethodSymbolAction(
+        FixtureMethodAnalyzerHelper.RegisterInstanceFixtureAnalyzer(
             context,
             WellKnownTypeNames.MicrosoftVisualStudioTestToolsUnitTestingTestInitializeAttribute,
-            static (symbolContext, symbols) => FixtureMethodAnalyzerHelper.AnalyzeInstanceFixtureMethod(symbolContext, symbols, Rule));
+            Rule);
     }
 }
diff --git a/src/Platform/Microsoft.Testing.Extensions.CtrfReport/CtrfReportEngine.cs b/src/Platform/Microsoft.Testing.Extensions.CtrfReport/CtrfReportEngine.cs
index 12312e67d1..f4f7ce52b6 100644
--- a/src/Platform/Microsoft.Testing.Extensions.CtrfReport/CtrfReportEngine.cs
+++ b/src/Platform/Microsoft.Testing.Extensions.CtrfReport/CtrfReportEngine.cs
@@ -40,6 +40,11 @@ public CtrfReportEngine(
     {
     }
 
+    public CtrfReportEngine(ReportEngineContext context)
+        : base(context)
+    {
+    }
+
     public Task<(string FileName, string? Warning)> GenerateReportAsync(CapturedTestResult[] results)
         => GenerateReportCoreAsync(results, _clock.UtcNow);
 
diff --git a/src/Platform/Microsoft.Testing.Extensions.CtrfReport/CtrfReportGenerator.cs b/src/Platform/Microsoft.Testing.Extensions.CtrfReport/CtrfReportGenerator.cs
index d752d3d565..beb162dfcf 100644
--- a/src/Platform/Microsoft.Testing.Extensions.CtrfReport/CtrfReportGenerator.cs
+++ b/src/Platform/Microsoft.Testing.Extensions.CtrfReport/CtrfReportGenerator.cs
@@ -38,17 +38,7 @@ protected override string GetGenerationLogMessage(int testResultCount)
         int exitCode,
         CancellationToken cancellationToken)
     {
-        var engine = new CtrfReportEngine(
-            FileSystem,
-            TestApplicationModuleInfo,
-            Environment,
-            CommandLineOptions,
-            Configuration,
-            Clock,
-            TestFramework,
-            testStartTime,
-            exitCode,
-            cancellationToken);
+        var engine = new CtrfReportEngine(CreateEngineContext(testStartTime, exitCode, cancellationToken));
         return engine.GenerateReportAsync(tests);
     }
 }
diff --git a/src/Platform/Microsoft.Testing.Extensions.CtrfReport/Microsoft.Testing.Extensions.CtrfReport.csproj b/src/Platform/Microsoft.Testing.Extensions.CtrfReport/Microsoft.Testing.Extensions.CtrfReport.csproj
index 72375be302..8416060575 100644
--- a/src/Platform/Microsoft.Testing.Extensions.CtrfReport/Microsoft.Testing.Extensions.CtrfReport.csproj
+++ b/src/Platform/Microsoft.Testing.Extensions.CtrfReport/Microsoft.Testing.Extensions.CtrfReport.csproj
@@ -57,6 +57,7 @@ This package extends Microsoft Testing Platform to produce test reports in the C
     <Compile Include="$(RepoRoot)src\Platform\SharedExtensionHelpers\ReportFileNameHelper.cs" Link="Helpers\ReportFileNameHelper.cs" />
     <Compile Include="$(RepoRoot)src\Platform\SharedExtensionHelpers\ReportFileNameSanitizer.cs" Link="Helpers\ReportFileNameSanitizer.cs" />
     <Compile Include="$(RepoRoot)src\Platform\SharedExtensionHelpers\ReportEngineBase.cs" Link="Helpers\ReportEngineBase.cs" />
+    <Compile Include="$(RepoRoot)src\Platform\SharedExtensionHelpers\ReportEngineContext.cs" Link="Helpers\ReportEngineContext.cs" />
     <Compile Include="$(RepoRoot)src\Platform\SharedExtensionHelpers\ReportGeneratorBase.cs" Link="Helpers\ReportGeneratorBase.cs" />
     <Compile Include="$(RepoRoot)src\Platform\SharedExtensionHelpers\ReportProviderRegistration.cs" Link="Helpers\ReportProviderRegistration.cs" />
     <Compile Include="$(RepoRoot)src\Platform\SharedExtensionHelpers\ReportGeneratorCommandLineBase.cs" Link="Helpers\ReportGeneratorCommandLineBase.cs" />
diff --git a/src/Platform/Microsoft.Testing.Extensions.HtmlReport/HtmlReportEngine.cs b/src/Platform/Microsoft.Testing.Extensions.HtmlReport/HtmlReportEngine.cs
index b6f3f95cdc..8b27c20d3e 100644
--- a/src/Platform/Microsoft.Testing.Extensions.HtmlReport/HtmlReportEngine.cs
+++ b/src/Platform/Microsoft.Testing.Extensions.HtmlReport/HtmlReportEngine.cs
@@ -41,6 +41,11 @@ public HtmlReportEngine(
     {
     }
 
+    public HtmlReportEngine(ReportEngineContext context)
+        : base(context)
+    {
+    }
+
     public Task<(string FileName, string? Warning)> GenerateReportAsync(CapturedTestResult[] results)
         => GenerateReportCoreAsync(results, _clock.UtcNow);
 
diff --git a/src/Platform/Microsoft.Testing.Extensions.HtmlReport/HtmlReportGenerator.cs b/src/Platform/Microsoft.Testing.Extensions.HtmlReport/HtmlReportGenerator.cs
index c4b2ba7d79..6f62e79388 100644
--- a/src/Platform/Microsoft.Testing.Extensions.HtmlReport/HtmlReportGenerator.cs
+++ b/src/Platform/Microsoft.Testing.Extensions.HtmlReport/HtmlReportGenerator.cs
@@ -38,17 +38,7 @@ protected override string GetGenerationLogMessage(int testResultCount)
         int exitCode,
         CancellationToken cancellationToken)
     {
-        var engine = new HtmlReportEngine(
-            FileSystem,
-            TestApplicationModuleInfo,
-            Environment,
-            CommandLineOptions,
-            Configuration,
-            Clock,
-            TestFramework,
-            testStartTime,
-            exitCode,
-            cancellationToken);
+        var engine = new HtmlReportEngine(CreateEngineContext(testStartTime, exitCode, cancellationToken));
         return engine.GenerateReportAsync(tests);
     }
 }
diff --git a/src/Platform/Microsoft.Testing.Extensions.HtmlReport/Microsoft.Testing.Extensions.HtmlReport.csproj b/src/Platform/Microsoft.Testing.Extensions.HtmlReport/Microsoft.Testing.Extensions.HtmlReport.csproj
index 357ff803b4..548e6d6da9 100644
--- a/src/Platform/Microsoft.Testing.Extensions.HtmlReport/Microsoft.Testing.Extensions.HtmlReport.csproj
+++ b/src/Platform/Microsoft.Testing.Extensions.HtmlReport/Microsoft.Testing.Extensions.HtmlReport.csproj
@@ -54,6 +54,7 @@ This package extends Microsoft Testing Platform to produce self-contained HTML t
     <Compile Include="$(RepoRoot)src\Platform\Microsoft.Testing.Platform\Resources\PlatformResources.cs" Link="Resources\PlatformResources.cs" />
     <Compile Include="$(RepoRoot)src\Platform\SharedExtensionHelpers\ReportFileNameValidator.cs" Link="Helpers\ReportFileNameValidator.cs" />
     <Compile Include="$(RepoRoot)src\Platform\SharedExtensionHelpers\ReportEngineBase.cs" Link="Helpers\ReportEngineBase.cs" />
+    <Compile Include="$(RepoRoot)src\Platform\SharedExtensionHelpers\ReportEngineContext.cs" Link="Helpers\ReportEngineContext.cs" />
     <Compile Include="$(RepoRoot)src\Platform\SharedExtensionHelpers\ReportGeneratorBase.cs" Link="Helpers\ReportGeneratorBase.cs" />
     <Compile Include="$(RepoRoot)src\Platform\SharedExtensionHelpers\ReportProviderRegistration.cs" Link="Helpers\ReportProviderRegistration.cs" />
     <Compile Include="$(RepoRoot)src\Platform\SharedExtensionHelpers\ReportGeneratorCommandLineBase.cs" Link="Helpers\ReportGeneratorCommandLineBase.cs" />
diff --git a/src/Platform/Microsoft.Testing.Extensions.JUnitReport/JUnitReportEngine.cs b/src/Platform/Microsoft.Testing.Extensions.JUnitReport/JUnitReportEngine.cs
index 2aaa236ae2..8846cc975d 100644
--- a/src/Platform/Microsoft.Testing.Extensions.JUnitReport/JUnitReportEngine.cs
+++ b/src/Platform/Microsoft.Testing.Extensions.JUnitReport/JUnitReportEngine.cs
@@ -42,6 +42,11 @@ public JUnitReportEngine(
     {
     }
 
+    public JUnitReportEngine(ReportEngineContext context)
+        : base(context)
+    {
+    }
+
     public Task<(string FileName, string? Warning)> GenerateReportAsync(
         CapturedTestResult[] results,
         IReadOnlyDictionary<string, TestResultCapture.ParentChainEntry> parentChain)
diff --git a/src/Platform/Microsoft.Testing.Extensions.JUnitReport/JUnitReportGenerator.cs b/src/Platform/Microsoft.Testing.Extensions.JUnitReport/JUnitReportGenerator.cs
index 7b4b7356c7..fb5f7710a8 100644
--- a/src/Platform/Microsoft.Testing.Extensions.JUnitReport/JUnitReportGenerator.cs
+++ b/src/Platform/Microsoft.Testing.Extensions.JUnitReport/JUnitReportGenerator.cs
@@ -63,17 +63,7 @@ protected override void OnTestNodeUpdate(TestNodeUpdateMessage update)
         int exitCode,
         CancellationToken cancellationToken)
     {
-        var engine = new JUnitReportEngine(
-            FileSystem,
-            TestApplicationModuleInfo,
-            Environment,
-            CommandLineOptions,
-            Configuration,
-            Clock,
-            TestFramework,
-            testStartTime,
-            exitCode,
-            cancellationToken);
+        var engine = new JUnitReportEngine(CreateEngineContext(testStartTime, exitCode, cancellationToken));
         return engine.GenerateReportAsync(tests, _parentChain);
     }
 }
diff --git a/src/Platform/Microsoft.Testing.Extensions.JUnitReport/Microsoft.Testing.Extensions.JUnitReport.csproj b/src/Platform/Microsoft.Testing.Extensions.JUnitReport/Microsoft.Testing.Extensions.JUnitReport.csproj
index 2ba7134f53..a1e5a60fee 100644
--- a/src/Platform/Microsoft.Testing.Extensions.JUnitReport/Microsoft.Testing.Extensions.JUnitReport.csproj
+++ b/src/Platform/Microsoft.Testing.Extensions.JUnitReport/Microsoft.Testing.Extensions.JUnitReport.csproj
@@ -52,6 +52,7 @@ This package extends Microsoft Testing Platform to produce JUnit XML test report
     <Compile Include="$(RepoRoot)src\Platform\SharedExtensionHelpers\CapturedTestResultBase.cs" Link="Helpers\CapturedTestResultBase.cs" />
     <Compile Include="$(RepoRoot)src\Platform\SharedExtensionHelpers\ReportFileNameValidator.cs" Link="Helpers\ReportFileNameValidator.cs" />
     <Compile Include="$(RepoRoot)src\Platform\SharedExtensionHelpers\ReportEngineBase.cs" Link="Helpers\ReportEngineBase.cs" />
+    <Compile Include="$(RepoRoot)src\Platform\SharedExtensionHelpers\ReportEngineContext.cs" Link="Helpers\ReportEngineContext.cs" />
     <Compile Include="$(RepoRoot)src\Platform\SharedExtensionHelpers\ReportGeneratorBase.cs" Link="Helpers\ReportGeneratorBase.cs" />
     <Compile Include="$(RepoRoot)src\Platform\SharedExtensionHelpers\ReportProviderRegistration.cs" Link="Helpers\ReportProviderRegistration.cs" />
     <Compile Include="$(RepoRoot)src\Platform\SharedExtensionHelpers\ReportGeneratorCommandLineBase.cs" Link="Helpers\ReportGeneratorCommandLineBase.cs" />
diff --git a/src/Platform/Microsoft.Testing.Extensions.TrxReport/Microsoft.Testing.Extensions.TrxReport.csproj b/src/Platform/Microsoft.Testing.Extensions.TrxReport/Microsoft.Testing.Extensions.TrxReport.csproj
index 2c5dfc5157..58f231f1d1 100644
--- a/src/Platform/Microsoft.Testing.Extensions.TrxReport/Microsoft.Testing.Extensions.TrxReport.csproj
+++ b/src/Platform/Microsoft.Testing.Extensions.TrxReport/Microsoft.Testing.Extensions.TrxReport.csproj
@@ -32,6 +32,7 @@
     <Compile Include="$(RepoRoot)src\Platform\SharedExtensionHelpers\ReportFileNameSanitizer.cs" Link="Helpers\ReportFileNameSanitizer.cs" />
     <Compile Include="$(RepoRoot)src\Platform\SharedExtensionHelpers\ReportGeneratorCommandLineBase.cs" Link="Helpers\ReportGeneratorCommandLineBase.cs" />
     <Compile Include="$(RepoRoot)src\Platform\SharedExtensionHelpers\ReportEngineBase.cs" Link="Helpers\ReportEngineBase.cs" />
+    <Compile Include="$(RepoRoot)src\Platform\SharedExtensionHelpers\ReportEngineContext.cs" Link="Helpers\ReportEngineContext.cs" />
     <Compile Include="$(RepoRoot)src\Platform\SharedExtensionHelpers\ReportFileNameValidator.cs" Link="Helpers\ReportFileNameValidator.cs" />
     <Compile Include="$(RepoRoot)src\Platform\SharedExtensionHelpers\ReportFileWriterHelper.cs" Link="Helpers\ReportFileWriterHelper.cs" />
     <Compile Include="$(RepoRoot)src\Platform\SharedExtensionHelpers\TargetFrameworkMonikerHelper.cs" Link="Helpers\TargetFrameworkMonikerHelper.cs" />
diff --git a/src/Platform/SharedExtensionHelpers/ReportEngineBase.cs b/src/Platform/SharedExtensionHelpers/ReportEngineBase.cs
index f705f66cfa..04c6a4da64 100644
--- a/src/Platform/SharedExtensionHelpers/ReportEngineBase.cs
+++ b/src/Platform/SharedExtensionHelpers/ReportEngineBase.cs
@@ -54,6 +54,21 @@ protected ReportEngineBase(
         _cancellationToken = cancellationToken;
     }
 
+    protected ReportEngineBase(ReportEngineContext context)
+        : this(
+            context.FileSystem,
+            context.TestApplicationModuleInfo,
+            context.Environment,
+            context.CommandLineOptions,
+            context.Configuration,
+            context.Clock,
+            context.TestFramework,
+            context.TestStartTime,
+            context.ExitCode,
+            context.CancellationToken)
+    {
+    }
+
     internal static string GetProvidedFileName(string[]? providedFileName)
         => providedFileName is { Length: > 0 }
             ? providedFileName[0]
diff --git a/src/Platform/SharedExtensionHelpers/ReportEngineContext.cs b/src/Platform/SharedExtensionHelpers/ReportEngineContext.cs
new file mode 100644
index 0000000000..c14f92106a
--- /dev/null
+++ b/src/Platform/SharedExtensionHelpers/ReportEngineContext.cs
@@ -0,0 +1,28 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+using Microsoft.Testing.Platform.CommandLine;
+using Microsoft.Testing.Platform.Configurations;
+using Microsoft.Testing.Platform.Extensions.TestFramework;
+using Microsoft.Testing.Platform.Helpers;
+using Microsoft.Testing.Platform.Services;
+
+namespace Microsoft.Testing.Extensions;
+
+/// <summary>
+/// Bundles the full set of platform services and call-time arguments that every report engine
+/// (<c>HtmlReportEngine</c>, <c>JUnitReportEngine</c>, <c>CtrfReportEngine</c>, ...) needs. Centralizing
+/// this list means a new <see cref="ReportEngineBase"/> dependency only has to be threaded through one
+/// place instead of being copied into every <c>ReportGeneratorBase</c>-derived generator.
+/// </summary>
+internal sealed record ReportEngineContext(
+    IFileSystem FileSystem,
+    ITestApplicationModuleInfo TestApplicationModuleInfo,
+    IEnvironment Environment,
+    ICommandLineOptions CommandLineOptions,
+    IConfiguration Configuration,
+    IClock Clock,
+    ITestFramework TestFramework,
+    DateTimeOffset TestStartTime,
+    int ExitCode,
+    CancellationToken CancellationToken);
diff --git a/src/Platform/SharedExtensionHelpers/ReportGeneratorBase.cs b/src/Platform/SharedExtensionHelpers/ReportGeneratorBase.cs
index f6abf9176a..0cd86c7746 100644
--- a/src/Platform/SharedExtensionHelpers/ReportGeneratorBase.cs
+++ b/src/Platform/SharedExtensionHelpers/ReportGeneratorBase.cs
@@ -113,6 +113,24 @@ protected ReportGeneratorBase(
 
     protected ITestFramework TestFramework { get; }
 
+    /// <summary>
+    /// Bundles the shared platform services together with the per-session call-time arguments into a
+    /// single <see cref="ReportEngineContext"/> so derived generators can construct their report engine
+    /// without repeating the full dependency list.
+    /// </summary>
+    protected ReportEngineContext CreateEngineContext(DateTimeOffset testStartTime, int exitCode, CancellationToken cancellationToken)
+        => new(
+            FileSystem,
+            TestApplicationModuleInfo,
+            Environment,
+            CommandLineOptions,
+            Configuration,
+            Clock,
+            TestFramework,
+            testStartTime,
+            exitCode,
+            cancellationToken);
+
     /// <inheritdoc />
     public Task<bool> IsEnabledAsync() => Task.FromResult(_isEnabled);
 
diff --git a/test/UnitTests/MSTest.Analyzers.UnitTests/AnalyzerCategoryGovernanceTests.cs b/test/UnitTests/MSTest.Analyzers.UnitTests/AnalyzerCategoryGovernanceTests.cs
new file mode 100644
index 0000000000..5e7b2e263f
--- /dev/null
+++ b/test/UnitTests/MSTest.Analyzers.UnitTests/AnalyzerCategoryGovernanceTests.cs
@@ -0,0 +1,25 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+using System.Linq;
+
+namespace MSTest.Analyzers.Test;
+
+/// <summary>
+/// Lightweight governance tests that pin the diagnostic <c>Category</c> taxonomy for performance-impacting
+/// analyzers so misclassifications are caught at build time without any Roslyn workspace overhead.
+/// See https://github.com/microsoft/testfx/issues/9467.
+/// </summary>
+[TestClass]
+public sealed class AnalyzerCategoryGovernanceTests
+{
+    private const string PerformanceCategory = "Performance";
+
+    [TestMethod]
+    public void UseParallelizeAttribute_MainRule_UsesPerformanceCategory()
+        => Assert.AreEqual(PerformanceCategory, UseParallelizeAttributeAnalyzer.Rule.Category);
+
+    [TestMethod]
+    public void AvoidThreadSleepAndTaskWaitInTests_UsesPerformanceCategory()
+        => Assert.AreEqual(PerformanceCategory, new AvoidThreadSleepAndTaskWaitInTestsAnalyzer().SupportedDiagnostics.Single().Category);
+}

From 6573fc6473f06d2e868a40d2867d5148c8912ba9 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Amaury=20Lev=C3=A9?= <amauryleve@microsoft.com>
Date: Sun, 28 Jun 2026 22:38:16 +0200
Subject: [PATCH 2/2] Split FfmpegVideoRecorder.cs into focused partial files
 (#9464)

Extract VideoSegment into its own file and split the recorder across partial files for process management and Windows window-capture, keeping each file well under 300 lines. No behavioral or API changes.

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>
---
 .../FfmpegVideoRecorder.ProcessManagement.cs  | 224 +++++++++++
 .../FfmpegVideoRecorder.WindowCapture.cs      | 152 +++++++
 .../FfmpegVideoRecorder.cs                    | 376 +-----------------
 .../VideoSegment.cs                           |  27 ++
 4 files changed, 404 insertions(+), 375 deletions(-)
 create mode 100644 src/Platform/Microsoft.Testing.Extensions.VideoRecorder/FfmpegVideoRecorder.ProcessManagement.cs
 create mode 100644 src/Platform/Microsoft.Testing.Extensions.VideoRecorder/FfmpegVideoRecorder.WindowCapture.cs
 create mode 100644 src/Platform/Microsoft.Testing.Extensions.VideoRecorder/VideoSegment.cs

diff --git a/src/Platform/Microsoft.Testing.Extensions.VideoRecorder/FfmpegVideoRecorder.ProcessManagement.cs b/src/Platform/Microsoft.Testing.Extensions.VideoRecorder/FfmpegVideoRecorder.ProcessManagement.cs
new file mode 100644
index 0000000000..99c21b26ad
--- /dev/null
+++ b/src/Platform/Microsoft.Testing.Extensions.VideoRecorder/FfmpegVideoRecorder.ProcessManagement.cs
@@ -0,0 +1,224 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+using Microsoft.Testing.Extensions.VideoRecorder.Resources;
+using Microsoft.Testing.Platform;
+
+#if !NETCOREAPP
+using Polyfills;
+#endif
+
+namespace Microsoft.Testing.Extensions.VideoRecorder;
+
+/// <summary>
+/// ffmpeg process lifecycle (launch, monitor, tear down), output capture, command-line argument
+/// construction, and executable discovery for <see cref="FfmpegVideoRecorder"/>.
+/// </summary>
+internal sealed partial class FfmpegVideoRecorder
+{
+    private async Task<bool> RunFfmpegAsync(string arguments, CancellationToken cancellationToken)
+    {
+        var startInfo = new ProcessStartInfo(FfmpegPath!, arguments)
+        {
+            RedirectStandardOutput = true,
+            RedirectStandardError = true,
+            UseShellExecute = false,
+            CreateNoWindow = true,
+        };
+
+        _log?.Invoke($"Running ffmpeg: \"{FfmpegPath}\" {arguments}");
+
+        using var process = new Process { StartInfo = startInfo };
+        process.OutputDataReceived += OnFfmpegOutput;
+        process.ErrorDataReceived += OnFfmpegOutput;
+        try
+        {
+            process.Start();
+            process.BeginOutputReadLine();
+            process.BeginErrorReadLine();
+            if (!await WaitForExitAsync(process, StopTimeout, cancellationToken).ConfigureAwait(false))
+            {
+                // ffmpeg didn't finish within the timeout (or the run was cancelled). Disposing the
+                // Process below does not terminate the underlying OS process, so kill it explicitly
+                // to avoid leaving an orphaned ffmpeg behind on slow machines or long sessions.
+                TryKill(process);
+                return false;
+            }
+
+            return process.HasExited && process.ExitCode == 0;
+        }
+        catch (Exception ex)
+        {
+            _log?.Invoke($"ffmpeg invocation failed: {ex.Message}");
+            return false;
+        }
+        finally
+        {
+            process.OutputDataReceived -= OnFfmpegOutput;
+            process.ErrorDataReceived -= OnFfmpegOutput;
+        }
+    }
+
+#if NETCOREAPP
+    private void ClearRecentFfmpegOutput() => _recentFfmpegOutput.Clear();
+#else
+    private void ClearRecentFfmpegOutput()
+    {
+        while (_recentFfmpegOutput.TryDequeue(out _))
+        {
+        }
+    }
+#endif
+
+    private void DetachAndDispose(Process process)
+    {
+        process.OutputDataReceived -= OnFfmpegOutput;
+        process.ErrorDataReceived -= OnFfmpegOutput;
+        process.Dispose();
+    }
+
+    private void OnFfmpegOutput(object sender, DataReceivedEventArgs e)
+    {
+        if (e.Data is null)
+        {
+            return;
+        }
+
+        _log?.Invoke($"[ffmpeg] {e.Data}");
+
+        // Keep a small tail of ffmpeg output so capture failures can be reported with context.
+        _recentFfmpegOutput.Enqueue(e.Data);
+        while (_recentFfmpegOutput.Count > 8 && _recentFfmpegOutput.TryDequeue(out _))
+        {
+        }
+    }
+
+    private string BuildSegmentArguments(string segmentDirectory, string segmentListPath)
+    {
+        int segmentSeconds = Math.Max(1, _options.SegmentLengthSeconds);
+        string input = _options.InputArgumentsOverride ?? BuildDefaultInput();
+        string encoder = _options.Format == VideoRecorderFormat.WebMVp9
+            ? "-c:v libvpx-vp9 -b:v 0 -crf 32 -deadline realtime -cpu-used 5"
+            : "-c:v libx264 -preset veryfast -crf 28";
+        string segmentFormat = _options.Format == VideoRecorderFormat.WebMVp9 ? "webm" : "mp4";
+
+        string extra = RoslynString.IsNullOrWhiteSpace(_options.ExtraRecorderArguments)
+            ? string.Empty
+            : $"{_options.ExtraRecorderArguments!.Trim()} ";
+
+        string segmentPattern = Path.Combine(segmentDirectory, $"seg_%05d.{SegmentExtension}");
+
+        // gdigrab (and some grabbers) can capture an odd width/height, but yuv420p requires both to
+        // be even. Crop to the nearest even dimensions so the encoder's format conversion can't fail
+        // with "width/height not divisible by 2". Skipped when the caller fully overrides the input.
+        string evenCrop = _options.InputArgumentsOverride is null
+            ? "-vf \"crop=trunc(iw/2)*2:trunc(ih/2)*2\" "
+            : string.Empty;
+
+        // Force a keyframe at every segment boundary so each segment starts on an IDR frame; that
+        // makes the segments independently decodable and lets us concatenate them later with
+        // stream copy (-c copy) instead of a slow, lossy re-encode.
+        return $"-y {input} {evenCrop}{encoder} -pix_fmt yuv420p -force_key_frames \"expr:gte(t,n_forced*{segmentSeconds})\" "
+            + $"-f segment -segment_time {segmentSeconds} -segment_format {segmentFormat} -reset_timestamps 1 "
+            + $"-segment_list \"{segmentListPath}\" -segment_list_type csv {extra}\"{segmentPattern}\"";
+    }
+
+    private string BuildDefaultInput()
+    {
+        int fps = _options.FrameRate;
+
+        if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows))
+        {
+            if (_options.Source == VideoCaptureSource.Window)
+            {
+                if (TryGetCurrentProcessWindowRegion(out int x, out int y, out int width, out int height))
+                {
+                    return $"-f gdigrab -framerate {fps} -offset_x {x} -offset_y {y} -video_size {width}x{height} -i desktop";
+                }
+
+                _log?.Invoke(VideoRecorderResources.WindowCaptureFallback);
+            }
+
+            return $"-f gdigrab -framerate {fps} -i desktop";
+        }
+
+        if (RuntimeInformation.IsOSPlatform(OSPlatform.OSX))
+        {
+            // The avfoundation screen device index can vary; override via InputArgumentsOverride if needed.
+            return $"-f avfoundation -capture_cursor 1 -framerate {fps} -i \"Capture screen 0\"";
+        }
+
+        // Assume Linux/X11.
+        string display = Environment.GetEnvironmentVariable("DISPLAY") is { Length: > 0 } d ? d : ":0.0";
+        return $"-f x11grab -framerate {fps} -video_size {_options.X11CaptureSize} -i {display}";
+    }
+
+    private static void TryKill(Process process)
+    {
+        try
+        {
+            process.Kill();
+        }
+        catch (Exception)
+        {
+            // Best effort.
+        }
+    }
+
+    private static async Task<bool> WaitForExitAsync(Process process, TimeSpan timeout, CancellationToken cancellationToken)
+    {
+        // Process.WaitForExitAsync(CancellationToken) is available on modern .NET and provided by a
+        // polyfill on netstandard2.0, so a single token-based implementation works on every target.
+        // A linked CTS bounds the wait by the timeout; an already-cancelled token simply means we
+        // report whether the process happened to have exited (best-effort stop on a cancelled run).
+        using var cts = CancellationTokenSource.CreateLinkedTokenSource(cancellationToken);
+        cts.CancelAfter(timeout);
+        try
+        {
+            await process.WaitForExitAsync(cts.Token).ConfigureAwait(false);
+            return true;
+        }
+        catch (OperationCanceledException)
+        {
+            return process.HasExited;
+        }
+    }
+
+    private static string? FindFfmpeg(string? configuredPath)
+    {
+        if (!RoslynString.IsNullOrEmpty(configuredPath))
+        {
+            return File.Exists(configuredPath) ? configuredPath : null;
+        }
+
+        string executable = RuntimeInformation.IsOSPlatform(OSPlatform.Windows) ? "ffmpeg.exe" : "ffmpeg";
+        string? pathVariable = Environment.GetEnvironmentVariable("PATH");
+        if (pathVariable is null)
+        {
+            return null;
+        }
+
+        foreach (string directory in pathVariable.Split(Path.PathSeparator))
+        {
+            if (RoslynString.IsNullOrWhiteSpace(directory))
+            {
+                continue;
+            }
+
+            try
+            {
+                string candidate = Path.Combine(directory.Trim(), executable);
+                if (File.Exists(candidate))
+                {
+                    return candidate;
+                }
+            }
+            catch (Exception)
+            {
+                // Ignore malformed PATH entries.
+            }
+        }
+
+        return null;
+    }
+}
diff --git a/src/Platform/Microsoft.Testing.Extensions.VideoRecorder/FfmpegVideoRecorder.WindowCapture.cs b/src/Platform/Microsoft.Testing.Extensions.VideoRecorder/FfmpegVideoRecorder.WindowCapture.cs
new file mode 100644
index 0000000000..3f298e7af2
--- /dev/null
+++ b/src/Platform/Microsoft.Testing.Extensions.VideoRecorder/FfmpegVideoRecorder.WindowCapture.cs
@@ -0,0 +1,152 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+namespace Microsoft.Testing.Extensions.VideoRecorder;
+
+/// <summary>
+/// Windows-specific, DPI-aware window-region detection and the P/Invoke surface it relies on. Split
+/// out of the main <see cref="FfmpegVideoRecorder"/> file because it is platform-specific and self
+/// contained.
+/// </summary>
+internal sealed partial class FfmpegVideoRecorder
+{
+    // Resolves the screen rectangle of the window to capture so gdigrab can record just that
+    // region. Candidates are tried in order: the process main window (a GUI app under test owns
+    // it), then the foreground window (the terminal you launched from — this is what makes
+    // Windows Terminal work, since its window isn't owned by the test process), then the console
+    // window (classic conhost). Returns false when none is a usable visible window, in which case
+    // the caller falls back to full-screen capture.
+    private static bool TryGetCurrentProcessWindowRegion(out int x, out int y, out int width, out int height)
+    {
+        x = y = width = height = 0;
+
+#if NETCOREAPP
+        if (!OperatingSystem.IsWindows())
+        {
+            return false;
+        }
+#endif
+
+        // gdigrab captures physical pixels, so we must read window rectangles in physical
+        // coordinates too. Make this thread Per-Monitor-V2 DPI aware while querying; otherwise a
+        // DPI-unaware process gets virtualized (logical) coordinates and the region is wrong on
+        // any scaled display. Restore the previous context afterwards.
+        IntPtr previousDpiContext = TrySetPerMonitorDpiAwareThread();
+        try
+        {
+            int screenWidth = NativeMethods.GetSystemMetrics(NativeMethods.SM_CXSCREEN);
+            int screenHeight = NativeMethods.GetSystemMetrics(NativeMethods.SM_CYSCREEN);
+
+            foreach (IntPtr handle in EnumerateCandidateWindows())
+            {
+                if (handle == IntPtr.Zero
+                    || !NativeMethods.IsWindowVisible(handle)
+                    || !NativeMethods.GetWindowRect(handle, out NativeMethods.RECT rect))
+                {
+                    continue;
+                }
+
+                int left = Math.Max(0, rect.Left);
+                int top = Math.Max(0, rect.Top);
+                int right = screenWidth > 0 ? Math.Min(rect.Right, screenWidth) : rect.Right;
+                int bottom = screenHeight > 0 ? Math.Min(rect.Bottom, screenHeight) : rect.Bottom;
+
+                // gdigrab requires even dimensions for the yuv420p pixel format.
+                int candidateWidth = (right - left) & ~1;
+                int candidateHeight = (bottom - top) & ~1;
+                if (candidateWidth <= 0 || candidateHeight <= 0)
+                {
+                    continue;
+                }
+
+                x = left;
+                y = top;
+                width = candidateWidth;
+                height = candidateHeight;
+                return true;
+            }
+        }
+        finally
+        {
+            if (previousDpiContext != IntPtr.Zero)
+            {
+                try
+                {
+                    NativeMethods.SetThreadDpiAwarenessContext(previousDpiContext);
+                }
+                catch (Exception)
+                {
+                    // Best effort; the override is per-thread and short-lived.
+                }
+            }
+        }
+
+        return false;
+    }
+
+    private static IntPtr TrySetPerMonitorDpiAwareThread()
+    {
+        try
+        {
+            return NativeMethods.SetThreadDpiAwarenessContext(NativeMethods.DPI_AWARENESS_CONTEXT_PER_MONITOR_AWARE_V2);
+        }
+        catch (Exception)
+        {
+            // SetThreadDpiAwarenessContext is unavailable before Windows 10 1607; proceed without it.
+            return IntPtr.Zero;
+        }
+    }
+
+    private static IEnumerable<IntPtr> EnumerateCandidateWindows()
+    {
+        // A GUI app under test owns its main window.
+        using (var current = Process.GetCurrentProcess())
+        {
+            yield return current.MainWindowHandle;
+        }
+
+        // The window you launched from (e.g. Windows Terminal), whose window is not owned by the
+        // test process. Captured at record time.
+        yield return NativeMethods.GetForegroundWindow();
+
+        // A classic console (conhost) window owned by the console host.
+        yield return NativeMethods.GetConsoleWindow();
+    }
+
+    private static class NativeMethods
+    {
+        public const int SM_CXSCREEN = 0;
+        public const int SM_CYSCREEN = 1;
+
+        public static readonly IntPtr DPI_AWARENESS_CONTEXT_PER_MONITOR_AWARE_V2 = new(-4);
+
+        [DllImport("kernel32.dll")]
+        public static extern IntPtr GetConsoleWindow();
+
+        [DllImport("user32.dll")]
+        public static extern IntPtr GetForegroundWindow();
+
+        [DllImport("user32.dll")]
+        public static extern int GetSystemMetrics(int nIndex);
+
+        [DllImport("user32.dll")]
+        public static extern IntPtr SetThreadDpiAwarenessContext(IntPtr dpiContext);
+
+        [DllImport("user32.dll")]
+        [return: MarshalAs(UnmanagedType.Bool)]
+        public static extern bool IsWindowVisible(IntPtr hWnd);
+
+        [DllImport("user32.dll", SetLastError = true)]
+        [return: MarshalAs(UnmanagedType.Bool)]
+        public static extern bool GetWindowRect(IntPtr hWnd, out RECT lpRect);
+
+        [StructLayout(LayoutKind.Sequential)]
+        public struct RECT
+        {
+            public int Left;
+            public int Top;
+            public int Right;
+            public int Bottom;
+        }
+    }
+}
diff --git a/src/Platform/Microsoft.Testing.Extensions.VideoRecorder/FfmpegVideoRecorder.cs b/src/Platform/Microsoft.Testing.Extensions.VideoRecorder/FfmpegVideoRecorder.cs
index ba0d5f053f..555730d254 100644
--- a/src/Platform/Microsoft.Testing.Extensions.VideoRecorder/FfmpegVideoRecorder.cs
+++ b/src/Platform/Microsoft.Testing.Extensions.VideoRecorder/FfmpegVideoRecorder.cs
@@ -2,38 +2,10 @@
 // Licensed under the MIT license. See LICENSE file in the project root for full license information.
 
 using Microsoft.Testing.Extensions.VideoRecorder.Resources;
-using Microsoft.Testing.Platform;
 using Microsoft.Testing.Platform.Helpers;
 
-#if !NETCOREAPP
-using Polyfills;
-#endif
-
 namespace Microsoft.Testing.Extensions.VideoRecorder;
 
-/// <summary>
-/// A single finalized recording segment and the time range (in seconds, relative to the start of
-/// the recording) that it covers.
-/// </summary>
-internal readonly struct VideoSegment
-{
-    public VideoSegment(string path, double startSeconds, double endSeconds)
-    {
-        Path = path;
-        StartSeconds = startSeconds;
-        EndSeconds = endSeconds;
-    }
-
-    public string Path { get; }
-
-    public double StartSeconds { get; }
-
-    public double EndSeconds { get; }
-
-    public bool Overlaps(double fromSeconds, double toSeconds)
-        => EndSeconds > fromSeconds && StartSeconds < toSeconds;
-}
-
 /// <summary>
 /// Captures the screen by driving a single long-lived ffmpeg process that writes the recording as a
 /// rolling sequence of short, independently playable segments (the ffmpeg <c>segment</c> muxer).
@@ -50,7 +22,7 @@ public bool Overlaps(double fromSeconds, double toSeconds)
 [UnsupportedOSPlatform("ios")]
 [UnsupportedOSPlatform("tvos")]
 [UnsupportedOSPlatform("wasi")]
-internal sealed class FfmpegVideoRecorder
+internal sealed partial class FfmpegVideoRecorder
 {
     private static readonly TimeSpan StopTimeout = TimeSpan.FromSeconds(15);
 
@@ -374,350 +346,4 @@ public string DescribeLastFfmpegError()
 
         return errors.Length > 0 ? string.Join(" | ", errors) : lines[lines.Length - 1];
     }
-
-    private async Task<bool> RunFfmpegAsync(string arguments, CancellationToken cancellationToken)
-    {
-        var startInfo = new ProcessStartInfo(FfmpegPath!, arguments)
-        {
-            RedirectStandardOutput = true,
-            RedirectStandardError = true,
-            UseShellExecute = false,
-            CreateNoWindow = true,
-        };
-
-        _log?.Invoke($"Running ffmpeg: \"{FfmpegPath}\" {arguments}");
-
-        using var process = new Process { StartInfo = startInfo };
-        process.OutputDataReceived += OnFfmpegOutput;
-        process.ErrorDataReceived += OnFfmpegOutput;
-        try
-        {
-            process.Start();
-            process.BeginOutputReadLine();
-            process.BeginErrorReadLine();
-            if (!await WaitForExitAsync(process, StopTimeout, cancellationToken).ConfigureAwait(false))
-            {
-                // ffmpeg didn't finish within the timeout (or the run was cancelled). Disposing the
-                // Process below does not terminate the underlying OS process, so kill it explicitly
-                // to avoid leaving an orphaned ffmpeg behind on slow machines or long sessions.
-                TryKill(process);
-                return false;
-            }
-
-            return process.HasExited && process.ExitCode == 0;
-        }
-        catch (Exception ex)
-        {
-            _log?.Invoke($"ffmpeg invocation failed: {ex.Message}");
-            return false;
-        }
-        finally
-        {
-            process.OutputDataReceived -= OnFfmpegOutput;
-            process.ErrorDataReceived -= OnFfmpegOutput;
-        }
-    }
-
-#if NETCOREAPP
-    private void ClearRecentFfmpegOutput() => _recentFfmpegOutput.Clear();
-#else
-    private void ClearRecentFfmpegOutput()
-    {
-        while (_recentFfmpegOutput.TryDequeue(out _))
-        {
-        }
-    }
-#endif
-
-    private void DetachAndDispose(Process process)
-    {
-        process.OutputDataReceived -= OnFfmpegOutput;
-        process.ErrorDataReceived -= OnFfmpegOutput;
-        process.Dispose();
-    }
-
-    private void OnFfmpegOutput(object sender, DataReceivedEventArgs e)
-    {
-        if (e.Data is null)
-        {
-            return;
-        }
-
-        _log?.Invoke($"[ffmpeg] {e.Data}");
-
-        // Keep a small tail of ffmpeg output so capture failures can be reported with context.
-        _recentFfmpegOutput.Enqueue(e.Data);
-        while (_recentFfmpegOutput.Count > 8 && _recentFfmpegOutput.TryDequeue(out _))
-        {
-        }
-    }
-
-    private string BuildSegmentArguments(string segmentDirectory, string segmentListPath)
-    {
-        int segmentSeconds = Math.Max(1, _options.SegmentLengthSeconds);
-        string input = _options.InputArgumentsOverride ?? BuildDefaultInput();
-        string encoder = _options.Format == VideoRecorderFormat.WebMVp9
-            ? "-c:v libvpx-vp9 -b:v 0 -crf 32 -deadline realtime -cpu-used 5"
-            : "-c:v libx264 -preset veryfast -crf 28";
-        string segmentFormat = _options.Format == VideoRecorderFormat.WebMVp9 ? "webm" : "mp4";
-
-        string extra = RoslynString.IsNullOrWhiteSpace(_options.ExtraRecorderArguments)
-            ? string.Empty
-            : $"{_options.ExtraRecorderArguments!.Trim()} ";
-
-        string segmentPattern = Path.Combine(segmentDirectory, $"seg_%05d.{SegmentExtension}");
-
-        // gdigrab (and some grabbers) can capture an odd width/height, but yuv420p requires both to
-        // be even. Crop to the nearest even dimensions so the encoder's format conversion can't fail
-        // with "width/height not divisible by 2". Skipped when the caller fully overrides the input.
-        string evenCrop = _options.InputArgumentsOverride is null
-            ? "-vf \"crop=trunc(iw/2)*2:trunc(ih/2)*2\" "
-            : string.Empty;
-
-        // Force a keyframe at every segment boundary so each segment starts on an IDR frame; that
-        // makes the segments independently decodable and lets us concatenate them later with
-        // stream copy (-c copy) instead of a slow, lossy re-encode.
-        return $"-y {input} {evenCrop}{encoder} -pix_fmt yuv420p -force_key_frames \"expr:gte(t,n_forced*{segmentSeconds})\" "
-            + $"-f segment -segment_time {segmentSeconds} -segment_format {segmentFormat} -reset_timestamps 1 "
-            + $"-segment_list \"{segmentListPath}\" -segment_list_type csv {extra}\"{segmentPattern}\"";
-    }
-
-    private string BuildDefaultInput()
-    {
-        int fps = _options.FrameRate;
-
-        if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows))
-        {
-            if (_options.Source == VideoCaptureSource.Window)
-            {
-                if (TryGetCurrentProcessWindowRegion(out int x, out int y, out int width, out int height))
-                {
-                    return $"-f gdigrab -framerate {fps} -offset_x {x} -offset_y {y} -video_size {width}x{height} -i desktop";
-                }
-
-                _log?.Invoke(VideoRecorderResources.WindowCaptureFallback);
-            }
-
-            return $"-f gdigrab -framerate {fps} -i desktop";
-        }
-
-        if (RuntimeInformation.IsOSPlatform(OSPlatform.OSX))
-        {
-            // The avfoundation screen device index can vary; override via InputArgumentsOverride if needed.
-            return $"-f avfoundation -capture_cursor 1 -framerate {fps} -i \"Capture screen 0\"";
-        }
-
-        // Assume Linux/X11.
-        string display = Environment.GetEnvironmentVariable("DISPLAY") is { Length: > 0 } d ? d : ":0.0";
-        return $"-f x11grab -framerate {fps} -video_size {_options.X11CaptureSize} -i {display}";
-    }
-
-    // Resolves the screen rectangle of the window to capture so gdigrab can record just that
-    // region. Candidates are tried in order: the process main window (a GUI app under test owns
-    // it), then the foreground window (the terminal you launched from — this is what makes
-    // Windows Terminal work, since its window isn't owned by the test process), then the console
-    // window (classic conhost). Returns false when none is a usable visible window, in which case
-    // the caller falls back to full-screen capture.
-    private static bool TryGetCurrentProcessWindowRegion(out int x, out int y, out int width, out int height)
-    {
-        x = y = width = height = 0;
-
-#if NETCOREAPP
-        if (!OperatingSystem.IsWindows())
-        {
-            return false;
-        }
-#endif
-
-        // gdigrab captures physical pixels, so we must read window rectangles in physical
-        // coordinates too. Make this thread Per-Monitor-V2 DPI aware while querying; otherwise a
-        // DPI-unaware process gets virtualized (logical) coordinates and the region is wrong on
-        // any scaled display. Restore the previous context afterwards.
-        IntPtr previousDpiContext = TrySetPerMonitorDpiAwareThread();
-        try
-        {
-            int screenWidth = NativeMethods.GetSystemMetrics(NativeMethods.SM_CXSCREEN);
-            int screenHeight = NativeMethods.GetSystemMetrics(NativeMethods.SM_CYSCREEN);
-
-            foreach (IntPtr handle in EnumerateCandidateWindows())
-            {
-                if (handle == IntPtr.Zero
-                    || !NativeMethods.IsWindowVisible(handle)
-                    || !NativeMethods.GetWindowRect(handle, out NativeMethods.RECT rect))
-                {
-                    continue;
-                }
-
-                int left = Math.Max(0, rect.Left);
-                int top = Math.Max(0, rect.Top);
-                int right = screenWidth > 0 ? Math.Min(rect.Right, screenWidth) : rect.Right;
-                int bottom = screenHeight > 0 ? Math.Min(rect.Bottom, screenHeight) : rect.Bottom;
-
-                // gdigrab requires even dimensions for the yuv420p pixel format.
-                int candidateWidth = (right - left) & ~1;
-                int candidateHeight = (bottom - top) & ~1;
-                if (candidateWidth <= 0 || candidateHeight <= 0)
-                {
-                    continue;
-                }
-
-                x = left;
-                y = top;
-                width = candidateWidth;
-                height = candidateHeight;
-                return true;
-            }
-        }
-        finally
-        {
-            if (previousDpiContext != IntPtr.Zero)
-            {
-                try
-                {
-                    NativeMethods.SetThreadDpiAwarenessContext(previousDpiContext);
-                }
-                catch (Exception)
-                {
-                    // Best effort; the override is per-thread and short-lived.
-                }
-            }
-        }
-
-        return false;
-    }
-
-    private static IntPtr TrySetPerMonitorDpiAwareThread()
-    {
-        try
-        {
-            return NativeMethods.SetThreadDpiAwarenessContext(NativeMethods.DPI_AWARENESS_CONTEXT_PER_MONITOR_AWARE_V2);
-        }
-        catch (Exception)
-        {
-            // SetThreadDpiAwarenessContext is unavailable before Windows 10 1607; proceed without it.
-            return IntPtr.Zero;
-        }
-    }
-
-    private static IEnumerable<IntPtr> EnumerateCandidateWindows()
-    {
-        // A GUI app under test owns its main window.
-        using (var current = Process.GetCurrentProcess())
-        {
-            yield return current.MainWindowHandle;
-        }
-
-        // The window you launched from (e.g. Windows Terminal), whose window is not owned by the
-        // test process. Captured at record time.
-        yield return NativeMethods.GetForegroundWindow();
-
-        // A classic console (conhost) window owned by the console host.
-        yield return NativeMethods.GetConsoleWindow();
-    }
-
-    private static void TryKill(Process process)
-    {
-        try
-        {
-            process.Kill();
-        }
-        catch (Exception)
-        {
-            // Best effort.
-        }
-    }
-
-    private static async Task<bool> WaitForExitAsync(Process process, TimeSpan timeout, CancellationToken cancellationToken)
-    {
-        // Process.WaitForExitAsync(CancellationToken) is available on modern .NET and provided by a
-        // polyfill on netstandard2.0, so a single token-based implementation works on every target.
-        // A linked CTS bounds the wait by the timeout; an already-cancelled token simply means we
-        // report whether the process happened to have exited (best-effort stop on a cancelled run).
-        using var cts = CancellationTokenSource.CreateLinkedTokenSource(cancellationToken);
-        cts.CancelAfter(timeout);
-        try
-        {
-            await process.WaitForExitAsync(cts.Token).ConfigureAwait(false);
-            return true;
-        }
-        catch (OperationCanceledException)
-        {
-            return process.HasExited;
-        }
-    }
-
-    private static string? FindFfmpeg(string? configuredPath)
-    {
-        if (!RoslynString.IsNullOrEmpty(configuredPath))
-        {
-            return File.Exists(configuredPath) ? configuredPath : null;
-        }
-
-        string executable = RuntimeInformation.IsOSPlatform(OSPlatform.Windows) ? "ffmpeg.exe" : "ffmpeg";
-        string? pathVariable = Environment.GetEnvironmentVariable("PATH");
-        if (pathVariable is null)
-        {
-            return null;
-        }
-
-        foreach (string directory in pathVariable.Split(Path.PathSeparator))
-        {
-            if (RoslynString.IsNullOrWhiteSpace(directory))
-            {
-                continue;
-            }
-
-            try
-            {
-                string candidate = Path.Combine(directory.Trim(), executable);
-                if (File.Exists(candidate))
-                {
-                    return candidate;
-                }
-            }
-            catch (Exception)
-            {
-                // Ignore malformed PATH entries.
-            }
-        }
-
-        return null;
-    }
-
-    private static class NativeMethods
-    {
-        public const int SM_CXSCREEN = 0;
-        public const int SM_CYSCREEN = 1;
-
-        public static readonly IntPtr DPI_AWARENESS_CONTEXT_PER_MONITOR_AWARE_V2 = new(-4);
-
-        [DllImport("kernel32.dll")]
-        public static extern IntPtr GetConsoleWindow();
-
-        [DllImport("user32.dll")]
-        public static extern IntPtr GetForegroundWindow();
-
-        [DllImport("user32.dll")]
-        public static extern int GetSystemMetrics(int nIndex);
-
-        [DllImport("user32.dll")]
-        public static extern IntPtr SetThreadDpiAwarenessContext(IntPtr dpiContext);
-
-        [DllImport("user32.dll")]
-        [return: MarshalAs(UnmanagedType.Bool)]
-        public static extern bool IsWindowVisible(IntPtr hWnd);
-
-        [DllImport("user32.dll", SetLastError = true)]
-        [return: MarshalAs(UnmanagedType.Bool)]
-        public static extern bool GetWindowRect(IntPtr hWnd, out RECT lpRect);
-
-        [StructLayout(LayoutKind.Sequential)]
-        public struct RECT
-        {
-            public int Left;
-            public int Top;
-            public int Right;
-            public int Bottom;
-        }
-    }
 }
diff --git a/src/Platform/Microsoft.Testing.Extensions.VideoRecorder/VideoSegment.cs b/src/Platform/Microsoft.Testing.Extensions.VideoRecorder/VideoSegment.cs
new file mode 100644
index 0000000000..8c47e91afb
--- /dev/null
+++ b/src/Platform/Microsoft.Testing.Extensions.VideoRecorder/VideoSegment.cs
@@ -0,0 +1,27 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+namespace Microsoft.Testing.Extensions.VideoRecorder;
+
+/// <summary>
+/// A single finalized recording segment and the time range (in seconds, relative to the start of
+/// the recording) that it covers.
+/// </summary>
+internal readonly struct VideoSegment
+{
+    public VideoSegment(string path, double startSeconds, double endSeconds)
+    {
+        Path = path;
+        StartSeconds = startSeconds;
+        EndSeconds = endSeconds;
+    }
+
+    public string Path { get; }
+
+    public double StartSeconds { get; }
+
+    public double EndSeconds { get; }
+
+    public bool Overlaps(double fromSeconds, double toSeconds)
+        => EndSeconds > fromSeconds && StartSeconds < toSeconds;
+}