diff --git a/src/Controls/src/SourceGen/InitializeComponentCodeWriter.cs b/src/Controls/src/SourceGen/InitializeComponentCodeWriter.cs
index 1a8e2416e32c..bdb2b1932a0b 100644
--- a/src/Controls/src/SourceGen/InitializeComponentCodeWriter.cs
+++ b/src/Controls/src/SourceGen/InitializeComponentCodeWriter.cs
@@ -106,7 +106,7 @@ PrePost newblock() =>
 				var methodName = genSwitch ? "InitializeComponentSourceGen" : "InitializeComponent";
 				codeWriter.WriteLine($"private partial void {methodName}()");
 				root!.XmlType.TryResolveTypeSymbol(null, compilation, xmlnsCache, typeCache, out var baseType);
-				var sgcontext = new SourceGenContext(codeWriter, compilation, sourceProductionContext, xmlnsCache, typeCache, rootType!, baseType, xamlItem.ProjectItem);
+				var sgcontext = new SourceGenContext(codeWriter, compilation, sourceProductionContext, xmlnsCache, typeCache, rootType!, baseType, xamlItem.ProjectItem, sourceProductionContext.ReportDiagnostic);
 
 				// Compute stable node IDs before Visit() mutates the tree (markup expansion etc.)
 				// Use cached effective IDs (from state) if available, to stay consistent with UC patches.
diff --git a/src/Controls/src/SourceGen/SetPropertyHelpers.cs b/src/Controls/src/SourceGen/SetPropertyHelpers.cs
index 7c0cc148c6e4..c484140e87ce 100644
--- a/src/Controls/src/SourceGen/SetPropertyHelpers.cs
+++ b/src/Controls/src/SourceGen/SetPropertyHelpers.cs
@@ -229,7 +229,8 @@ public static void AddLazyResourceToResourceDictionary(IndentedTextWriter writer
 				context.TypeCache, 
 				context.RootType, 
 				null, 
-				context.ProjectItem)
+				context.ProjectItem,
+				context.ReportDiagnostic)
 			{
 				ParentContext = context
 			};
diff --git a/src/Controls/src/SourceGen/SourceGenContext.cs b/src/Controls/src/SourceGen/SourceGenContext.cs
index f79109e0cf45..636ebd9347d0 100644
--- a/src/Controls/src/SourceGen/SourceGenContext.cs
+++ b/src/Controls/src/SourceGen/SourceGenContext.cs
@@ -9,9 +9,12 @@
 
 namespace Microsoft.Maui.Controls.SourceGen;
 
-class SourceGenContext(IndentedTextWriter writer, Compilation compilation, SourceProductionContext sourceProductionContext, AssemblyAttributes assemblyCaches, IDictionary<XmlType, INamedTypeSymbol> typeCache, ITypeSymbol rootType, ITypeSymbol? baseType, ProjectItem projectItem)
+class SourceGenContext(IndentedTextWriter writer, Compilation compilation, SourceProductionContext sourceProductionContext, AssemblyAttributes assemblyCaches, IDictionary<XmlType, INamedTypeSymbol> typeCache, ITypeSymbol rootType, ITypeSymbol? baseType, ProjectItem projectItem, Action<Diagnostic> diagnosticReporter)
 {
-	internal static SourceGenContext CreateNewForTests() => new SourceGenContext(
+	static readonly Action<Diagnostic> s_noOpDiagnosticReporter = static _ => { };
+	List<Diagnostic>? _bufferedDiagnostics;
+
+	internal static SourceGenContext CreateNewForTests(Action<Diagnostic>? diagnosticReporter = null) => new SourceGenContext(
 		null!,
 		null!,
 		default,
@@ -19,7 +22,8 @@ class SourceGenContext(IndentedTextWriter writer, Compilation compilation, Sourc
 		new Dictionary<XmlType, INamedTypeSymbol>(),
 		null!,
 		null,
-		null!);
+		null!,
+		diagnosticReporter ?? s_noOpDiagnosticReporter);
 
 	public SourceProductionContext SourceProductionContext => sourceProductionContext;
 	public IndentedTextWriter Writer => writer;
@@ -34,6 +38,12 @@ class SourceGenContext(IndentedTextWriter writer, Compilation compilation, Sourc
 	public IDictionary<INode, ILocalValue> Variables { get; } = new Dictionary<INode, ILocalValue>();
 	public void ReportDiagnostic(Diagnostic diagnostic)
 	{
+		if (ParentContext is not null)
+		{
+			ParentContext.ReportDiagnostic(diagnostic);
+			return;
+		}
+
 		// Check if this diagnostic should be suppressed based on NoWarn
 		var noWarn = ProjectItem?.NoWarn;
 		if (!string.IsNullOrEmpty(noWarn))
@@ -51,8 +61,42 @@ public void ReportDiagnostic(Diagnostic diagnostic)
 				}
 			}
 		}
-		sourceProductionContext.ReportDiagnostic(diagnostic);
+
+		if (_bufferedDiagnostics is not null)
+		{
+			_bufferedDiagnostics.Add(diagnostic);
+			return;
+		}
+
+		ReportDiagnosticCore(diagnostic);
 	}
+
+	internal int BufferedDiagnosticCount => _bufferedDiagnostics?.Count ?? 0;
+
+	internal void BeginDiagnosticBuffering()
+	{
+		if (_bufferedDiagnostics is not null)
+			throw new InvalidOperationException("Diagnostic buffering is already active.");
+
+		_bufferedDiagnostics = [];
+	}
+
+	internal void FlushBufferedDiagnostics()
+	{
+		if (_bufferedDiagnostics is null)
+			throw new InvalidOperationException("Diagnostic buffering is not active.");
+
+		var diagnostics = _bufferedDiagnostics;
+		_bufferedDiagnostics = null;
+		foreach (var diagnostic in diagnostics)
+			ReportDiagnosticCore(diagnostic);
+	}
+
+	internal void DiscardBufferedDiagnostics() => _bufferedDiagnostics = null;
+
+	void ReportDiagnosticCore(Diagnostic diagnostic)
+		=> diagnosticReporter(diagnostic);
+
 	public IDictionary<INode, ILocalValue> ServiceProviders { get; } = new Dictionary<INode, ILocalValue>();
 	public IDictionary<INode, (ILocalValue namescope, IDictionary<string, ILocalValue> namesInScope)> Scopes = new Dictionary<INode, (ILocalValue, IDictionary<string, ILocalValue>)>();
 	public SourceGenContext? ParentContext { get; set; }
diff --git a/src/Controls/src/SourceGen/UpdateComponentCodeWriter.cs b/src/Controls/src/SourceGen/UpdateComponentCodeWriter.cs
index 5cea9bdcd739..96d4b28b1147 100644
--- a/src/Controls/src/SourceGen/UpdateComponentCodeWriter.cs
+++ b/src/Controls/src/SourceGen/UpdateComponentCodeWriter.cs
@@ -582,9 +582,218 @@ static void EmitNewElementProperties(
 				TryEmitMarkupNodeChange(codeWriter, syntheticDiff, typeSymbol, varName, isRoot: false,
 					compilation, xmlnsCache, typeCache, rootType, sourceProductionContext, projectItem);
 			}
+			else if (kvp.Value is ElementNode or ListNode)
+			{
+				if (!TryEmitNewElementComplexProperty(
+					codeWriter,
+					element,
+					kvp.Value,
+					varName,
+					typeSymbol,
+					compilation,
+					xmlnsCache,
+					typeCache,
+					rootType,
+					sourceProductionContext,
+					projectItem))
+				{
+					codeWriter.WriteLine($"// Complex property '{kvp.Key.LocalName}' ({kvp.Value.GetType().Name}) — skipped (not yet supported)");
+				}
+			}
+		}
+	}
+
+	/// <summary>
+	/// Emits an element-valued property while constructing a new element. This deliberately uses
+	/// the InitializeComponent visitor pipeline; mutations on existing elements continue through
+	/// <see cref="EmitPropertyChange"/> and retain their narrower supported surface.
+	/// </summary>
+	static bool TryEmitNewElementComplexProperty(
+		IndentedTextWriter codeWriter,
+		ElementNode element,
+		INode propertyNode,
+		string varName,
+		INamedTypeSymbol typeSymbol,
+		Compilation compilation,
+		AssemblyAttributes xmlnsCache,
+		IDictionary<XmlType, INamedTypeSymbol> typeCache,
+		INamedTypeSymbol rootType,
+		SourceProductionContext sourceProductionContext,
+		ProjectItem? projectItem)
+	{
+		// This speculative path does not run SetResourcesVisitor, so accepting resources here
+		// would emit an incomplete subtree.
+		if (ContainsInlineResources(propertyNode))
+			return false;
+
+		var preflightDiagnosticContext = CreateConversionContext(
+			compilation,
+			sourceProductionContext,
+			xmlnsCache,
+			typeCache,
+			rootType,
+			projectItem);
+		preflightDiagnosticContext.BeginDiagnosticBuffering();
+		bool containsStaticResource;
+		try
+		{
+			containsStaticResource = ContainsStaticResourceReference(propertyNode, markup => ExpandMarkupForUC(
+				markup,
+				compilation,
+				xmlnsCache,
+				typeCache,
+				rootType,
+				sourceProductionContext,
+				projectItem,
+				preflightDiagnosticContext.ReportDiagnostic));
+		}
+		finally
+		{
+			preflightDiagnosticContext.DiscardBufferedDiagnostics();
+		}
+
+		if (containsStaticResource)
+			return false;
+
+		using var captureStringWriter = new StringWriter(CultureInfo.InvariantCulture);
+		using var captureWriter = new IndentedTextWriter(captureStringWriter, "\t") { NewLine = NewLine };
+		var context = CreateConversionContext(
+			compilation,
+			sourceProductionContext,
+			xmlnsCache,
+			typeCache,
+			rootType,
+			projectItem,
+			captureWriter);
+		context.Variables[element] = new DirectValue(typeSymbol, varName);
+		context.BeginDiagnosticBuffering();
+
+		try
+		{
+			propertyNode.Accept(new CreateValuesVisitor(context), element);
+			propertyNode.Accept(new SetPropertiesVisitor(context, stopOnResourceDictionary: true), element);
+		}
+		catch (InvalidOperationException)
+		{
+			context.DiscardBufferedDiagnostics();
+			return false;
+		}
+
+		captureWriter.Flush();
+		var capturedCode = captureStringWriter.ToString();
+		if (string.IsNullOrWhiteSpace(capturedCode))
+		{
+			context.DiscardBufferedDiagnostics();
+			return false;
+		}
+
+		codeWriter.WriteLine("{");
+		codeWriter.Indent++;
+		foreach (var line in capturedCode.Split(new[] { "\r\n", "\n" }, StringSplitOptions.None))
+		{
+			if (!string.IsNullOrEmpty(line))
+				codeWriter.WriteLine(line);
+		}
+
+		foreach (var localMethod in context.LocalMethods)
+		{
+			codeWriter.WriteLine();
+			foreach (var line in localMethod.Split(new[] { "\r\n", "\n" }, StringSplitOptions.None))
+			{
+				if (string.IsNullOrWhiteSpace(line))
+					codeWriter.InnerWriter.WriteLine();
+				else
+					codeWriter.WriteLine(line);
+			}
 		}
+
+		codeWriter.Indent--;
+		codeWriter.WriteLine("}");
+		context.FlushBufferedDiagnostics();
+		return true;
+	}
+
+	static bool ContainsInlineResources(INode node)
+	{
+		if (node is ElementNode element)
+		{
+			if (element.XmlType.Name == "ResourceDictionary")
+				return true;
+
+			foreach (var property in element.Properties)
+			{
+				if (property.Key.LocalName == "Resources"
+					|| property.Key.LocalName.EndsWith(".Resources", StringComparison.Ordinal)
+					|| ContainsInlineResources(property.Value))
+				{
+					return true;
+				}
+			}
+
+			foreach (var child in element.CollectionItems)
+			{
+				if (ContainsInlineResources(child))
+					return true;
+			}
+
+			return false;
+		}
+
+		if (node is ListNode list)
+		{
+			foreach (var child in list.CollectionItems)
+			{
+				if (ContainsInlineResources(child))
+					return true;
+			}
+		}
+
+		return false;
 	}
 
+	static bool ContainsStaticResourceReference(INode node, Func<MarkupNode, INode?> expandMarkup)
+	{
+		if (node is MarkupNode markup)
+		{
+			var expanded = expandMarkup(markup);
+			return expanded is not null && ContainsStaticResourceReference(expanded, expandMarkup);
+		}
+
+		if (node is ElementNode element)
+		{
+			if (IsStaticResourceExtension(element.XmlType.Name))
+				return true;
+
+			foreach (var property in element.Properties.Values)
+			{
+				if (ContainsStaticResourceReference(property, expandMarkup))
+					return true;
+			}
+
+			foreach (var child in element.CollectionItems)
+			{
+				if (ContainsStaticResourceReference(child, expandMarkup))
+					return true;
+			}
+
+			return false;
+		}
+
+		if (node is ListNode list)
+		{
+			foreach (var child in list.CollectionItems)
+			{
+				if (ContainsStaticResourceReference(child, expandMarkup))
+					return true;
+			}
+		}
+
+		return false;
+	}
+
+	static bool IsStaticResourceExtension(string typeName) =>
+		typeName is "StaticResource" or "StaticResourceExtension";
+
 	/// <summary>
 	/// Recursively creates children for a newly created element, handling both
 	/// Layout containers (Children.Add) and Content containers (Content property).
@@ -1280,12 +1489,20 @@ static bool TryEmitMarkupNodeChange(
 		IDictionary<XmlType, INamedTypeSymbol> typeCache,
 		INamedTypeSymbol rootType,
 		SourceProductionContext sourceProductionContext,
-		ProjectItem? projectItem)
+		ProjectItem? projectItem,
+		Action<Diagnostic>? diagnosticReporter = null)
 	{
 		var markupString = markupNode.MarkupString;
 
 		// Build a minimal SourceGenContext for ExpandMarkupsVisitor's parser
-		var ctx = CreateConversionContext(compilation, sourceProductionContext, xmlnsCache, typeCache, rootType, projectItem);
+		var ctx = CreateConversionContext(
+			compilation,
+			sourceProductionContext,
+			xmlnsCache,
+			typeCache,
+			rootType,
+			projectItem,
+			diagnosticReporter: diagnosticReporter);
 
 		// Classification: expression or markup extension?
 		bool TryResolveMarkup(string name)
@@ -1775,12 +1992,14 @@ static SourceGenContext CreateConversionContext(
 		IDictionary<XmlType, INamedTypeSymbol> typeCache,
 		INamedTypeSymbol rootType,
 		ProjectItem? projectItem,
-		IndentedTextWriter? writer = null)
+		IndentedTextWriter? writer = null,
+		Action<Diagnostic>? diagnosticReporter = null)
 	{
 		var pi = projectItem ?? new ProjectItem(EmptyAdditionalText.Instance, EmptyConfigOptions.Instance);
+		diagnosticReporter ??= sourceProductionContext.ReportDiagnostic;
 		return new SourceGenContext(
 			writer ?? new IndentedTextWriter(new StringWriter()),
 			compilation, sourceProductionContext,
-			xmlnsCache, typeCache, rootType, rootType.BaseType, pi);
+			xmlnsCache, typeCache, rootType, rootType.BaseType, pi, diagnosticReporter);
 	}
 }
diff --git a/src/Controls/src/SourceGen/Visitors/SetPropertiesVisitor.cs b/src/Controls/src/SourceGen/Visitors/SetPropertiesVisitor.cs
index 4e4ddbd74f28..46da5f237a73 100644
--- a/src/Controls/src/SourceGen/Visitors/SetPropertiesVisitor.cs
+++ b/src/Controls/src/SourceGen/Visitors/SetPropertiesVisitor.cs
@@ -278,7 +278,7 @@ public void Visit(ElementNode node, INode parentNode)
 					Writer.WriteLine($"object {methodName}()");
 					using (PrePost.NewBlock(Writer, begin: "{", end: "}"))
 					{
-						var templateContext = new SourceGenContext(Writer, context.Compilation, context.SourceProductionContext, context.XmlnsCache, context.TypeCache, context.RootType!, null, context.ProjectItem)
+						var templateContext = new SourceGenContext(Writer, context.Compilation, context.SourceProductionContext, context.XmlnsCache, context.TypeCache, context.RootType!, null, context.ProjectItem, context.ReportDiagnostic)
 						{
 							ParentContext = context,
 						};
@@ -298,7 +298,7 @@ public void Visit(ElementNode node, INode parentNode)
 			Writer.WriteLine($"{variable.ValueAccessor}.LoadTemplate = () =>");
 			using (PrePost.NewBlock(Writer, begin: "{", end: "};"))
 			{
-				var templateContext = new SourceGenContext(Writer, context.Compilation, context.SourceProductionContext, context.XmlnsCache, context.TypeCache, context.RootType!, null, context.ProjectItem)
+				var templateContext = new SourceGenContext(Writer, context.Compilation, context.SourceProductionContext, context.XmlnsCache, context.TypeCache, context.RootType!, null, context.ProjectItem, context.ReportDiagnostic)
 				{
 					ParentContext = context,
 				};
diff --git a/src/Controls/tests/SourceGen.UnitTests/HotReload/AiAssisted/BindingAndMarkupHotReloadTests.Bindings.cs b/src/Controls/tests/SourceGen.UnitTests/HotReload/AiAssisted/BindingAndMarkupHotReloadTests.Bindings.cs
new file mode 100644
index 000000000000..f28ae7dfd2a7
--- /dev/null
+++ b/src/Controls/tests/SourceGen.UnitTests/HotReload/AiAssisted/BindingAndMarkupHotReloadTests.Bindings.cs
@@ -0,0 +1,93 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+#nullable enable
+
+using System;
+using System.Collections;
+using System.ComponentModel;
+using System.Globalization;
+using System.Reflection;
+using System.Runtime.CompilerServices;
+using Microsoft.Maui.Controls.SourceGen.UnitTests.HotReload;
+using Xunit;
+
+namespace Microsoft.Maui.Controls.SourceGen.UnitTests.HotReload.AiAssisted;
+
+public partial class BindingAndMarkupHotReloadTests
+{
+	// Wave2 · Binding & Markup · P0-01 · BM-01
+	// Provenance: MAUI §3.4 | portfolio P0-01
+	// Faithfulness: reaches writer L1548 for DynamicResource and Binding markup nodes; fails-for-bug: markup swap does not replace the prior value source.
+	// Issue: https://github.com/dotnet/maui/issues/36732
+	[MetadataUpdateFact]
+	public void DynamicResourceToBinding_SwapAndReverse_UpdatesVisibleValue()
+	{
+		const string xamlV1 = """
+			<ContentPage xmlns="http://schemas.microsoft.com/dotnet/2021/maui"
+			             xmlns:x="http://schemas.microsoft.com/winfx/2009/xaml"
+			             xmlns:local="clr-namespace:TestAiAssisted"
+			             x:Class="TestAiAssisted.MainPage">
+			  <ContentPage.Resources>
+			    <ResourceDictionary>
+			      <x:String x:Key="K1">Resource-V1</x:String>
+			    </ResourceDictionary>
+			  </ContentPage.Resources>
+			  <ContentPage.BindingContext>
+			    <local:TestViewModel Text="VM" />
+			  </ContentPage.BindingContext>
+			  <Label Text="{DynamicResource K1}" />
+			</ContentPage>
+			""";
+		const string xamlV2 = """
+			<ContentPage xmlns="http://schemas.microsoft.com/dotnet/2021/maui"
+			             xmlns:x="http://schemas.microsoft.com/winfx/2009/xaml"
+			             xmlns:local="clr-namespace:TestAiAssisted"
+			             x:Class="TestAiAssisted.MainPage">
+			  <ContentPage.Resources>
+			    <ResourceDictionary>
+			      <x:String x:Key="K1">Resource-V1</x:String>
+			    </ResourceDictionary>
+			  </ContentPage.Resources>
+			  <ContentPage.BindingContext>
+			    <local:TestViewModel Text="VM" />
+			  </ContentPage.BindingContext>
+			  <Label Text="{Binding Text}" />
+			</ContentPage>
+			""";
+		const string xamlV3 = """
+			<ContentPage xmlns="http://schemas.microsoft.com/dotnet/2021/maui"
+			             xmlns:x="http://schemas.microsoft.com/winfx/2009/xaml"
+			             xmlns:local="clr-namespace:TestAiAssisted"
+			             x:Class="TestAiAssisted.MainPage">
+			  <ContentPage.Resources>
+			    <ResourceDictionary>
+			      <x:String x:Key="K1">Resource-V3</x:String>
+			    </ResourceDictionary>
+			  </ContentPage.Resources>
+			  <ContentPage.BindingContext>
+			    <local:TestViewModel Text="VM" />
+			  </ContentPage.BindingContext>
+			  <Label Text="{Binding Text}" />
+			</ContentPage>
+			""";
+
+		using var harness = CreateHarness();
+		var generation = harness.Generate(xamlV1, xamlV2, xamlV3);
+
+		harness.RunLive(generation, live =>
+		{
+			var page = live.GetInstance<ContentPage>();
+			var label = Assert.IsType<Label>(page.Content);
+			Assert.Equal("Resource-V1", label.Text);
+
+			Assert.Same(page, live.ApplyUpdate<ContentPage>(1));
+			Assert.Same(label, page.Content);
+			Assert.Equal("VM", label.Text);
+
+			Assert.Same(page, live.ApplyUpdate<ContentPage>(2));
+			Assert.Same(label, page.Content);
+			Assert.Equal("VM", label.Text);
+		});
+	}
+}
diff --git a/src/Controls/tests/SourceGen.UnitTests/HotReload/AiAssisted/BindingAndMarkupHotReloadTests.MarkupExtensions.cs b/src/Controls/tests/SourceGen.UnitTests/HotReload/AiAssisted/BindingAndMarkupHotReloadTests.MarkupExtensions.cs
new file mode 100644
index 000000000000..8bf94537ad1b
--- /dev/null
+++ b/src/Controls/tests/SourceGen.UnitTests/HotReload/AiAssisted/BindingAndMarkupHotReloadTests.MarkupExtensions.cs
@@ -0,0 +1,69 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+#nullable enable
+
+using System;
+using System.Collections;
+using System.ComponentModel;
+using System.Globalization;
+using System.Reflection;
+using System.Runtime.CompilerServices;
+using Microsoft.Maui.Controls.SourceGen.UnitTests.HotReload;
+using Xunit;
+
+namespace Microsoft.Maui.Controls.SourceGen.UnitTests.HotReload.AiAssisted;
+
+public partial class BindingAndMarkupHotReloadTests
+{
+	// Wave2 · Binding & Markup · family-7 · BM-02
+	// Provenance: MAUI §3.4 | family 7 custom markup
+	// Faithfulness: reaches the IC ProvideValue pipeline for a same-compilation IMarkupExtension<string>; fails-for-bug: custom markup edits are not re-provided on the retained element.
+	// Issue: https://github.com/dotnet/maui/issues/36732
+	[MetadataUpdateFact]
+	public void CustomMarkupExtension_EditAndReverse_ReprovidesValue()
+	{
+		const string xamlV1 = """
+			<ContentPage xmlns="http://schemas.microsoft.com/dotnet/2021/maui"
+			             xmlns:x="http://schemas.microsoft.com/winfx/2009/xaml"
+			             xmlns:local="clr-namespace:TestAiAssisted"
+			             x:Class="TestAiAssisted.MainPage">
+			  <Label Text="{local:Shout Text=hi}" />
+			</ContentPage>
+			""";
+		const string xamlV2 = """
+			<ContentPage xmlns="http://schemas.microsoft.com/dotnet/2021/maui"
+			             xmlns:x="http://schemas.microsoft.com/winfx/2009/xaml"
+			             xmlns:local="clr-namespace:TestAiAssisted"
+			             x:Class="TestAiAssisted.MainPage">
+			  <Label Text="{local:Shout Text=bye}" />
+			</ContentPage>
+			""";
+		const string xamlV3 = """
+			<ContentPage xmlns="http://schemas.microsoft.com/dotnet/2021/maui"
+			             xmlns:x="http://schemas.microsoft.com/winfx/2009/xaml"
+			             xmlns:local="clr-namespace:TestAiAssisted"
+			             x:Class="TestAiAssisted.MainPage">
+			  <Label Text="{local:Shout Text=hi}" />
+			</ContentPage>
+			""";
+
+		using var harness = CreateHarness();
+		var generation = harness.Generate(xamlV1, xamlV2, xamlV3);
+
+		harness.RunLive(generation, live =>
+		{
+			var page = live.GetInstance<ContentPage>();
+			var label = Assert.IsType<Label>(page.Content);
+			Assert.Equal("HI", label.Text);
+
+			Assert.Same(page, live.ApplyUpdate<ContentPage>(1));
+			Assert.Same(label, page.Content);
+			Assert.Equal("BYE", label.Text);
+
+			Assert.Same(page, live.ApplyUpdate<ContentPage>(2));
+			Assert.Same(label, page.Content);
+			Assert.Equal("HI", label.Text);
+		});
+	}
+}
diff --git a/src/Controls/tests/SourceGen.UnitTests/HotReload/AiAssisted/BindingAndMarkupHotReloadTests.MultiBinding.cs b/src/Controls/tests/SourceGen.UnitTests/HotReload/AiAssisted/BindingAndMarkupHotReloadTests.MultiBinding.cs
new file mode 100644
index 000000000000..4587da643b0e
--- /dev/null
+++ b/src/Controls/tests/SourceGen.UnitTests/HotReload/AiAssisted/BindingAndMarkupHotReloadTests.MultiBinding.cs
@@ -0,0 +1,67 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+#nullable enable
+
+using System;
+using System.Collections;
+using System.ComponentModel;
+using System.Globalization;
+using System.Reflection;
+using System.Runtime.CompilerServices;
+using Microsoft.Maui.Controls.SourceGen.UnitTests.HotReload;
+using Xunit;
+
+namespace Microsoft.Maui.Controls.SourceGen.UnitTests.HotReload.AiAssisted;
+
+public partial class BindingAndMarkupHotReloadTests
+{
+	// Wave2 · Binding & Markup · P0-02 · BM-03
+	// Provenance: MAUI §3.4 | portfolio P0-02
+	// Faithfulness: reaches writer L1194 for MultiBinding's ElementNode mutation; fails-for-bug: the documented unsupported complex-property path changes without a paired live probe.
+	// Expected: DOC-SKIP-GUARD
+	// Issue: https://github.com/dotnet/maui/issues/36732
+	[Fact]
+	public void MultiBinding_ComplexProperty_EmitsSkipMarker()
+	{
+		const string xamlV1 = """
+			<ContentPage xmlns="http://schemas.microsoft.com/dotnet/2021/maui"
+			             xmlns:x="http://schemas.microsoft.com/winfx/2009/xaml"
+			             xmlns:local="clr-namespace:TestAiAssisted"
+			             x:Class="TestAiAssisted.MainPage">
+			  <ContentPage.Resources>
+			    <local:JoinConverter x:Key="JoinConverter" />
+			  </ContentPage.Resources>
+			  <Label Text="Before" />
+			</ContentPage>
+			""";
+		const string xamlV2 = """
+			<ContentPage xmlns="http://schemas.microsoft.com/dotnet/2021/maui"
+			             xmlns:x="http://schemas.microsoft.com/winfx/2009/xaml"
+			             xmlns:local="clr-namespace:TestAiAssisted"
+			             x:Class="TestAiAssisted.MainPage">
+			  <ContentPage.Resources>
+			    <local:JoinConverter x:Key="JoinConverter" />
+			  </ContentPage.Resources>
+			  <Label>
+			    <Label.Text>
+			      <MultiBinding Converter="{StaticResource JoinConverter}">
+			        <Binding Path="A" />
+			        <Binding Path="B" />
+			      </MultiBinding>
+			    </Label.Text>
+			  </Label>
+			</ContentPage>
+			""";
+
+		using var harness = CreateHarness();
+		var generation = harness.Generate(xamlV1, xamlV2);
+		var updateComponentSource = generation[1].UpdateComponentSource;
+
+		Assert.NotNull(updateComponentSource);
+		Assert.Contains(
+			"Complex property 'Text' (ElementNode) — skipped (not yet supported)",
+			updateComponentSource!,
+			StringComparison.Ordinal);
+	}
+}
diff --git a/src/Controls/tests/SourceGen.UnitTests/HotReload/AiAssisted/BindingAndMarkupHotReloadTests.cs b/src/Controls/tests/SourceGen.UnitTests/HotReload/AiAssisted/BindingAndMarkupHotReloadTests.cs
new file mode 100644
index 000000000000..0f1af67fa237
--- /dev/null
+++ b/src/Controls/tests/SourceGen.UnitTests/HotReload/AiAssisted/BindingAndMarkupHotReloadTests.cs
@@ -0,0 +1,146 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+#nullable enable
+
+using System;
+using System.Collections;
+using System.ComponentModel;
+using System.Globalization;
+using System.Reflection;
+using System.Runtime.CompilerServices;
+using Microsoft.Maui.Controls.SourceGen.UnitTests.HotReload;
+using Xunit;
+
+namespace Microsoft.Maui.Controls.SourceGen.UnitTests.HotReload.AiAssisted;
+
+[Collection("XamlHotReloadTests")]
+public partial class BindingAndMarkupHotReloadTests
+{
+	const string PageClass = "TestAiAssisted.MainPage";
+
+	const string PageStub = """
+		namespace TestAiAssisted;
+
+		public partial class MainPage : global::Microsoft.Maui.Controls.ContentPage
+		{
+			private partial void InitializeComponent();
+
+			public MainPage()
+			{
+				InitializeComponent();
+			}
+		}
+		""";
+
+	const string BindingAndMarkupSource = """
+		using System;
+		using System.ComponentModel;
+		using System.Globalization;
+		using Microsoft.Maui.Controls;
+		using Microsoft.Maui.Controls.Xaml;
+
+		namespace TestAiAssisted;
+
+		public sealed class TestViewModel
+		{
+			public string Text { get; set; } = "VM";
+		}
+
+		public sealed class Row : INotifyPropertyChanged
+		{
+			string _a = string.Empty;
+			string _b = string.Empty;
+
+			public string A
+			{
+				get => _a;
+				set
+				{
+					if (_a == value)
+						return;
+					_a = value;
+					PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(nameof(A)));
+				}
+			}
+
+			public string B
+			{
+				get => _b;
+				set
+				{
+					if (_b == value)
+						return;
+					_b = value;
+					PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(nameof(B)));
+				}
+			}
+
+			public event PropertyChangedEventHandler? PropertyChanged;
+		}
+
+		public sealed class JoinConverter : IMultiValueConverter
+		{
+			public int ConvertCount { get; private set; }
+
+			public object Convert(object[] values, Type targetType, object parameter, CultureInfo culture)
+			{
+				ConvertCount++;
+				var result = $"{values.Length}:";
+				for (var index = 0; index < values.Length; index++)
+				{
+					if (index > 0)
+						result += "|";
+					result += values[index]?.ToString() ?? "<null>";
+				}
+				return result;
+			}
+
+			public object[] ConvertBack(object value, Type[] targetTypes, object parameter, CultureInfo culture) =>
+				new object[targetTypes.Length];
+		}
+
+		public sealed class ShoutExtension : IMarkupExtension<string>
+		{
+			public string Text { get; set; } = string.Empty;
+
+			public string ProvideValue(IServiceProvider serviceProvider) => Text.ToUpperInvariant();
+
+			object IMarkupExtension.ProvideValue(IServiceProvider serviceProvider) => ProvideValue(serviceProvider);
+		}
+		""";
+
+	static XamlHotReloadTestHarness CreateHarness([CallerMemberName] string scenarioName = "") =>
+		new(scenarioName, PageClass, PageStub, BindingAndMarkupSource);
+
+	static TextRegistration GetTextRegistration(Label label)
+	{
+		var propertiesField = typeof(BindableObject).GetField("_properties", BindingFlags.Instance | BindingFlags.NonPublic);
+		Assert.NotNull(propertiesField);
+
+		var properties = Assert.IsAssignableFrom<IDictionary>(propertiesField!.GetValue(label));
+		foreach (DictionaryEntry entry in properties)
+		{
+			var context = entry.Value;
+			if (context is null)
+				continue;
+
+			var contextType = context.GetType();
+			var property = contextType.GetField("Property")?.GetValue(context);
+			if (!ReferenceEquals(property, Label.TextProperty))
+				continue;
+
+			var attributes = contextType.GetField("Attributes")?.GetValue(context)?.ToString() ?? string.Empty;
+			var bindings = contextType.GetField("Bindings")?.GetValue(context);
+			Assert.NotNull(bindings);
+
+			var bindingCount = (int)bindings!.GetType().GetProperty("Count")!.GetValue(bindings)!;
+			var binding = bindings.GetType().GetMethod("GetValue")!.Invoke(bindings, null) as BindingBase;
+			return new TextRegistration(binding, bindingCount, attributes.Contains("IsDynamicResource", StringComparison.Ordinal));
+		}
+
+		throw new Xunit.Sdk.XunitException("The Label.Text property had no bindable-property context.");
+	}
+
+	readonly record struct TextRegistration(BindingBase? Binding, int BindingCount, bool IsDynamicResource);
+}
diff --git a/src/Controls/tests/SourceGen.UnitTests/HotReload/AiAssisted/CrossAssemblyHotReloadTests.cs b/src/Controls/tests/SourceGen.UnitTests/HotReload/AiAssisted/CrossAssemblyHotReloadTests.cs
new file mode 100644
index 000000000000..5881d5ac7f9f
--- /dev/null
+++ b/src/Controls/tests/SourceGen.UnitTests/HotReload/AiAssisted/CrossAssemblyHotReloadTests.cs
@@ -0,0 +1,269 @@
+#nullable enable
+
+using System;
+using System.Collections.Generic;
+using System.Collections.Immutable;
+using System.IO;
+using System.Linq;
+using System.Runtime.CompilerServices;
+using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.CSharp;
+using Microsoft.CodeAnalysis.Emit;
+using Microsoft.Maui.Controls.SourceGen;
+using Microsoft.Maui.Controls.Xaml.UnitTests.SourceGen;
+using Xunit;
+
+namespace Microsoft.Maui.Controls.SourceGen.UnitTests.HotReload.AiAssisted;
+
+/// <summary>
+/// Wave-2 cross-assembly incremental-generator probes.
+///
+/// These tests only exercise Roslyn's incremental driver by emitting a referenced library to PE
+/// bytes, turning that image into a <see cref="MetadataReference"/>, and swapping references inside
+/// one app-compilation lineage. They do not load the referenced assembly, apply runtime deltas, or
+/// claim coverage for the deferred cross-assembly runtime scenarios from wave2-final-test-plan §5.
+///
+/// XA-03 is intentionally omitted here. Own-compilation method-body-vs-signature invalidation is
+/// already covered by <c>SourceGenXamlCodeBehindTests.TestCodeBehindGenerator_ImplementationChangeDoesNotTriggerRegeneration</c>
+/// and <c>SourceGenXamlCodeBehindTests.TestCodeBehindGenerator_SignatureChangeTriggersRegeneration</c>,
+/// so re-authoring it in this file would duplicate existing coverage rather than add a
+/// cross-assembly invariant.
+/// </summary>
+[Collection("XamlHotReloadTests")]
+public class CrossAssemblyHotReloadTests
+{
+	const string AppAssemblyName = "TestCrossAssembly.App";
+	const string LibraryAssemblyName = "TestCrossAssembly.Lib";
+
+	const string PageStub = """
+		namespace TestCrossAssembly;
+
+		public partial class MainPage : global::Microsoft.Maui.Controls.ContentPage
+		{
+			private partial void InitializeComponent();
+
+			public MainPage()
+			{
+				InitializeComponent();
+			}
+		}
+		""";
+
+	const string PageXaml = """
+		<?xml version="1.0" encoding="utf-8" ?>
+		<ContentPage xmlns="http://schemas.microsoft.com/dotnet/2021/maui"
+		             xmlns:x="http://schemas.microsoft.com/winfx/2009/xaml"
+		             xmlns:lib="clr-namespace:TestCrossAssembly.Lib;assembly=TestCrossAssembly.Lib"
+		             x:Class="TestCrossAssembly.MainPage">
+		    <VerticalStackLayout x:DataType="lib:PersonViewModel">
+		        <lib:ProbeView />
+		        <Label Text="{Binding Name}" />
+		    </VerticalStackLayout>
+		</ContentPage>
+		""";
+
+	const string LibrarySourceV1 = """
+		namespace TestCrossAssembly.Lib;
+
+		public class PersonViewModel
+		{
+			public string Name => FormatName();
+
+			public string FormatName()
+			{
+				return "Ada";
+			}
+		}
+
+		public class ProbeView : global::Microsoft.Maui.Controls.ContentView
+		{
+			public string Version => DescribeVersion();
+
+			public string DescribeVersion()
+			{
+				return "v1";
+			}
+		}
+		""";
+
+	const string LibrarySourceV2 = """
+		namespace TestCrossAssembly.Lib;
+
+		public class PersonViewModel
+		{
+			public string Name => FormatName();
+
+			public string FormatName()
+			{
+				return "Grace";
+			}
+		}
+
+		public class ProbeView : global::Microsoft.Maui.Controls.ContentView
+		{
+			public string Version => DescribeVersion();
+
+			public string DescribeVersion()
+			{
+				return "v2";
+			}
+		}
+		""";
+
+	static SourceGeneratorDriver.AdditionalFile CreateXamlFile([CallerMemberName] string scenarioName = "") =>
+		new(
+			SourceGeneratorDriver.ToAdditionalText($"/CrossAssembly/{scenarioName}/MainPage.xaml", PageXaml),
+			"Xaml",
+			"MainPage.xaml",
+			$"/CrossAssembly/{scenarioName}/MainPage.xaml",
+			null,
+			"net11.0",
+			null,
+			EnableIncrementalHotReload: true);
+
+	static CSharpCompilation CreateAppCompilation(params MetadataReference[] references) =>
+		(CSharpCompilation)SourceGeneratorDriver.CreateMauiCompilation(AppAssemblyName)
+			.AddSyntaxTrees(ParseSource(PageStub, "MainPage.cs"))
+			.AddReferences(references);
+
+	static CSharpCompilation CreateLibraryCompilation(string source) =>
+		(CSharpCompilation)SourceGeneratorDriver.CreateMauiCompilation(LibraryAssemblyName)
+			.AddSyntaxTrees(ParseSource(source, "Library.cs"));
+
+	static PortableExecutableReference EmitLibraryReference(string source)
+	{
+		var compilation = CreateLibraryCompilation(source);
+		using var peStream = new MemoryStream();
+		EmitResult emitResult = compilation.Emit(peStream);
+		Assert.True(emitResult.Success, $"Referenced library emit failed:{Environment.NewLine}{FormatDiagnostics(emitResult.Diagnostics)}");
+
+		return MetadataReference.CreateFromImage(ImmutableArray.CreateRange(peStream.ToArray()));
+	}
+
+	static Compilation AddReference(Compilation compilation, MetadataReference reference) =>
+		compilation.AddReferences(reference);
+
+	static Compilation RemoveReference(Compilation compilation, MetadataReference reference) =>
+		compilation.RemoveReferences(reference);
+
+	static Compilation ReplaceReference(Compilation compilation, MetadataReference oldReference, MetadataReference newReference) =>
+		AddReference(RemoveReference(compilation, oldReference), newReference);
+
+	static SyntaxTree ParseSource(string source, string path) =>
+		CSharpSyntaxTree.ParseText(source, path: path);
+
+	static GeneratorRunResult GetGeneratorResult(GeneratorDriverRunResult runResult) =>
+		Assert.Single(runResult.Results);
+
+	static string? FindGeneratedSource(GeneratorRunResult result, string hintSuffix)
+	{
+		var generatedSource = result.GeneratedSources.SingleOrDefault(source =>
+			source.HintName.EndsWith(hintSuffix, StringComparison.OrdinalIgnoreCase)
+			&& !source.HintName.Contains("uc.xsg", StringComparison.OrdinalIgnoreCase));
+		return generatedSource.SourceText?.ToString();
+	}
+
+	static IncrementalStepRunReason GetTrackedStepReason(GeneratorRunResult result, string trackingName)
+	{
+		var step = Assert.Single(result.TrackedSteps[trackingName]);
+		var output = Assert.Single(step.Outputs);
+		return output.Reason;
+	}
+
+	static void AssertTrackedStepReasons(GeneratorRunResult result, Dictionary<string, IncrementalStepRunReason> expectedReasons)
+	{
+		foreach (var (trackingName, expectedReason) in expectedReasons)
+		{
+			var actualReason = GetTrackedStepReason(result, trackingName);
+			Assert.True(
+				actualReason == expectedReason,
+				$"{trackingName} expected {expectedReason} but was {actualReason}.");
+		}
+	}
+
+	static string FormatDiagnostics(IEnumerable<Diagnostic> diagnostics) =>
+		string.Join(Environment.NewLine, diagnostics.Select(static diagnostic =>
+			$"{diagnostic.Id}: {diagnostic.GetMessage()} at {diagnostic.Location}"));
+
+	// Wave2 · CrossAssembly · cap-cross-asm-MC · XA-01
+	// Provenance: wave2-final-test-plan §3.6/§4/§6/§10 | wave2-cross-assembly-patterns #30
+	// Faithfulness: reaches CompilationSignaturesComparer external-reference identity invalidation and XamlSourceProviderForIC; fails-for-bug: swapped referenced PE is treated as unchanged so Lib-backed XAML state stays cached.
+	// Issue: https://github.com/dotnet/maui/pull/36730
+	[Fact]
+	public void ReferencedAssemblySwap_InvalidatesXamlPipeline()
+	{
+		XamlHotReloadState.Reset();
+
+		var xamlFile = CreateXamlFile();
+		var libraryReferenceV1 = EmitLibraryReference(LibrarySourceV1);
+		var libraryReferenceV2 = EmitLibraryReference(LibrarySourceV2);
+		var compilation = CreateAppCompilation(libraryReferenceV1);
+
+		var (run1, run2) = SourceGeneratorDriver.RunGeneratorWithChanges<XamlGenerator>(
+			compilation,
+			applyChanges: (driver, currentCompilation) => (driver, ReplaceReference(currentCompilation, libraryReferenceV1, libraryReferenceV2)),
+			xamlFile);
+
+		var result1 = GetGeneratorResult(run1);
+		var result2 = GetGeneratorResult(run2);
+		var initialInitializeComponent = FindGeneratedSource(result1, ".xsg.cs");
+		var updatedInitializeComponent = FindGeneratedSource(result2, ".xsg.cs");
+
+		Assert.NotNull(initialInitializeComponent);
+		Assert.NotNull(updatedInitializeComponent);
+		Assert.Contains("global::TestCrossAssembly.Lib.PersonViewModel", initialInitializeComponent!, StringComparison.Ordinal);
+		Assert.Contains("global::TestCrossAssembly.Lib.ProbeView", initialInitializeComponent!, StringComparison.Ordinal);
+		Assert.Equal(initialInitializeComponent, updatedInitializeComponent);
+
+		AssertTrackedStepReasons(result2, new Dictionary<string, IncrementalStepRunReason>
+		{
+			{ TrackingNames.ProjectItemProvider, IncrementalStepRunReason.Cached },
+			{ TrackingNames.CompilationProvider, IncrementalStepRunReason.Modified },
+			{ TrackingNames.ReferenceTypeCacheProvider, IncrementalStepRunReason.Modified },
+			{ TrackingNames.XmlnsDefinitionsProvider, IncrementalStepRunReason.Modified },
+			{ TrackingNames.XamlProjectItemProviderForIC, IncrementalStepRunReason.Modified },
+			{ TrackingNames.CompilationWithCodeBehindProvider, IncrementalStepRunReason.Modified },
+			{ TrackingNames.XmlnsDefinitionsProviderForIC, IncrementalStepRunReason.Modified },
+		});
+
+		Assert.Contains(
+			GetTrackedStepReason(result2, TrackingNames.XamlSourceProviderForIC),
+			new[] { IncrementalStepRunReason.Modified, IncrementalStepRunReason.New });
+	}
+
+	// Wave2 · CrossAssembly · cap-cross-asm-MC · XA-02
+	// Provenance: wave2-final-test-plan §3.6/§4/§6/§10 | wave2-cross-assembly-patterns §0 inventory
+	// Faithfulness: reaches the no-op branch of CompilationSignaturesComparer and keeps the same MetadataReference instance; fails-for-bug: unchanged references still fan out through the IC pipeline.
+	// Issue: https://github.com/dotnet/maui/pull/36730
+	[Fact]
+	public void UnchangedReferences_XamlPipelineCached()
+	{
+		XamlHotReloadState.Reset();
+
+		var xamlFile = CreateXamlFile();
+		var libraryReference = EmitLibraryReference(LibrarySourceV1);
+		var compilation = CreateAppCompilation(libraryReference);
+
+		var (run1, run2) = SourceGeneratorDriver.RunGeneratorWithChanges<XamlGenerator>(
+			compilation,
+			applyChanges: static (driver, currentCompilation) => (driver, currentCompilation),
+			xamlFile);
+
+		var result1 = GetGeneratorResult(run1);
+		var result2 = GetGeneratorResult(run2);
+		var initialInitializeComponent = FindGeneratedSource(result1, ".xsg.cs");
+		var updatedInitializeComponent = FindGeneratedSource(result2, ".xsg.cs");
+
+		Assert.NotNull(initialInitializeComponent);
+		Assert.Equal(initialInitializeComponent, updatedInitializeComponent);
+
+		AssertTrackedStepReasons(result2, new Dictionary<string, IncrementalStepRunReason>
+		{
+			{ TrackingNames.ProjectItemProvider, IncrementalStepRunReason.Cached },
+			{ TrackingNames.CompilationProvider, IncrementalStepRunReason.Unchanged },
+			{ TrackingNames.ReferenceTypeCacheProvider, IncrementalStepRunReason.Cached },
+			{ TrackingNames.XmlnsDefinitionsProvider, IncrementalStepRunReason.Cached },
+			{ TrackingNames.XamlProjectItemProviderForIC, IncrementalStepRunReason.Cached },
+		});
+	}
+}
diff --git a/src/Controls/tests/SourceGen.UnitTests/HotReload/AiAssisted/GeneratorRecoveryHotReloadTests.cs b/src/Controls/tests/SourceGen.UnitTests/HotReload/AiAssisted/GeneratorRecoveryHotReloadTests.cs
new file mode 100644
index 000000000000..8324cec34fec
--- /dev/null
+++ b/src/Controls/tests/SourceGen.UnitTests/HotReload/AiAssisted/GeneratorRecoveryHotReloadTests.cs
@@ -0,0 +1,104 @@
+#nullable enable
+
+using System;
+using System.Linq;
+using System.Runtime.CompilerServices;
+using Microsoft.Maui.Controls.SourceGen.UnitTests.HotReload;
+using Xunit;
+
+namespace Microsoft.Maui.Controls.SourceGen.UnitTests.HotReload.AiAssisted;
+
+/// <summary>
+/// XIHR-02 generator-boundary diagnostic recomputation probe. Each test in this class drives the
+/// incremental generator directly through <see cref="XamlHotReloadTestHarness"/>
+/// (<c>GeneratorDriver</c> -&gt; diagnostics/UpdateComponent source -&gt; Roslyn compile). It does
+/// <b>not</b> exercise the IDE, <c>dotnet watch</c>, Roslyn's real edit classifier, MUH dispatch, a
+/// device, native handlers, or rendered output.
+/// </summary>
+[Collection("XamlHotReloadTests")]
+public class GeneratorRecoveryHotReloadTests
+{
+	const string PageClass = "TestAiAssisted.MainPage";
+
+	const string PageStub = """
+		namespace TestAiAssisted;
+
+		public partial class MainPage : global::Microsoft.Maui.Controls.ContentPage
+		{
+			private partial void InitializeComponent();
+
+			public bool IsActive { get; } = true;
+
+			public MainPage()
+			{
+				InitializeComponent();
+			}
+		}
+		""";
+
+	static XamlHotReloadTestHarness CreateHarness([CallerMemberName] string scenarioName = "") =>
+		new(scenarioName, PageClass, PageStub);
+
+	[Fact]
+	public void MalformedExpression_ThenRepair_RecomputesGeneratorDiagnostics()
+	{
+		// Issue: https://github.com/dotnet/maui/issues/36157
+		// This generator-boundary probe drives valid -> malformed -> repaired GeneratorDriver
+		// runs and verifies that each run recomputes its own diagnostics and output. It does not
+		// exercise or make claims about IDE Error List or dotnet-watch recovery.
+		const string xamlV1 = """
+			<?xml version="1.0" encoding="utf-8" ?>
+			<ContentPage xmlns="http://schemas.microsoft.com/dotnet/2021/maui"
+			             xmlns:x="http://schemas.microsoft.com/winfx/2009/xaml"
+			             x:Class="TestAiAssisted.MainPage">
+			    <VerticalStackLayout>
+			        <Label Text="{IsActive ? 'Status: Active' : 'Status: Idle'}" />
+			        <Label Text="Before" />
+			    </VerticalStackLayout>
+			</ContentPage>
+			""";
+		const string xamlV2 = """
+			<?xml version="1.0" encoding="utf-8" ?>
+			<ContentPage xmlns="http://schemas.microsoft.com/dotnet/2021/maui"
+			             xmlns:x="http://schemas.microsoft.com/winfx/2009/xaml"
+			             x:Class="TestAiAssisted.MainPage">
+			    <VerticalStackLayout>
+			        <Label Text="{IsActive ? 'Status: Active' : 'Status: Idle'" />
+			        <Label Text="Before" />
+			    </VerticalStackLayout>
+			</ContentPage>
+			""";
+		const string xamlV3 = """
+			<?xml version="1.0" encoding="utf-8" ?>
+			<ContentPage xmlns="http://schemas.microsoft.com/dotnet/2021/maui"
+			             xmlns:x="http://schemas.microsoft.com/winfx/2009/xaml"
+			             x:Class="TestAiAssisted.MainPage">
+			    <VerticalStackLayout>
+			        <Label Text="{IsActive ? 'Status: Active' : 'Status: Idle'}" />
+			        <Label Text="AfterRepair" />
+			    </VerticalStackLayout>
+			</ContentPage>
+			""";
+
+		using var harness = CreateHarness();
+		var generation = harness.GenerateAllowingDiagnostics(xamlV1, xamlV2, xamlV3);
+
+		// V2 (malformed): exactly one MAUIG1003; the property change is gracefully skipped
+		// (not silently mis-applied) rather than the UpdateComponent source being suppressed.
+		Assert.Single(generation[1].GeneratorResult.Diagnostics.Where(static d => d.Id == "MAUIG1003"));
+		var malformedUpdateComponentSource = generation[1].UpdateComponentSource;
+		Assert.NotNull(malformedUpdateComponentSource);
+		Assert.Contains("skipped", malformedUpdateComponentSource!, StringComparison.Ordinal);
+		Assert.DoesNotContain("AfterRepair", malformedUpdateComponentSource!, StringComparison.Ordinal);
+
+		// V3 (repaired): the generator recomputes a clean diagnostic set and emits repaired text.
+		Assert.DoesNotContain(generation[2].GeneratorResult.Diagnostics, static d => d.Id == "MAUIG1003");
+		var updateComponentSource = generation[2].UpdateComponentSource;
+		Assert.NotNull(updateComponentSource);
+		Assert.Contains("AfterRepair", updateComponentSource!, StringComparison.Ordinal);
+
+		// V3 generated code must compile cleanly.
+		var compiled = harness.Compile(generation[2]);
+		Assert.True(compiled.PeImage.Length > 0, "Repaired version should compile to a non-empty assembly");
+	}
+}
diff --git a/src/Controls/tests/SourceGen.UnitTests/HotReload/AiAssisted/HarnessCapabilityTests.cs b/src/Controls/tests/SourceGen.UnitTests/HotReload/AiAssisted/HarnessCapabilityTests.cs
new file mode 100644
index 000000000000..c515bf948aa5
--- /dev/null
+++ b/src/Controls/tests/SourceGen.UnitTests/HotReload/AiAssisted/HarnessCapabilityTests.cs
@@ -0,0 +1,181 @@
+#nullable enable
+
+using System;
+using System.Collections.Generic;
+using System.Runtime.CompilerServices;
+using Microsoft.Maui.ApplicationModel;
+using Microsoft.Maui.Controls.SourceGen.UnitTests.HotReload;
+using Xunit;
+
+namespace Microsoft.Maui.Controls.SourceGen.UnitTests.HotReload.AiAssisted;
+
+[Collection("XamlHotReloadTests")]
+public class HarnessCapabilityTests
+{
+	const string PageClass = "HarnessCapabilityApp.MainPage";
+
+	const string PageStub = """
+		namespace HarnessCapabilityApp;
+
+		public partial class MainPage : global::Microsoft.Maui.Controls.ContentPage
+		{
+			private partial void InitializeComponent();
+
+			public void InitializeComponentRuntime() { }
+
+			public MainPage()
+			{
+				InitializeComponent();
+			}
+		}
+		""";
+
+	static XamlHotReloadTestHarness CreateHarness([CallerMemberName] string scenarioName = "") =>
+		new(scenarioName, PageClass, PageStub);
+
+	static XamlHotReloadTestHarness CreateHostedHarness(
+		XamlHotReloadApplicationOptions options,
+		[CallerMemberName] string scenarioName = "") =>
+		new(scenarioName, PageClass, PageStub, options);
+
+	[Fact]
+	public void ApplicationHost_ResolvesAppResources_AndRestoresPreviousApplication()
+	{
+		const string xaml = """
+			<ContentPage xmlns="http://schemas.microsoft.com/dotnet/2021/maui"
+			             xmlns:x="http://schemas.microsoft.com/winfx/2009/xaml"
+			             x:Class="HarnessCapabilityApp.MainPage">
+			  <Label Text="{DynamicResource AppKey}" />
+			</ContentPage>
+			""";
+		var previousApplication = Application.Current;
+		var options = new XamlHotReloadApplicationOptions(
+			new Dictionary<string, object>
+			{
+				["AppKey"] = "FromApplication",
+			});
+
+		using (var harness = CreateHostedHarness(options))
+		{
+			Assert.NotSame(previousApplication, Application.Current);
+			var generation = harness.Generate(xaml);
+
+			harness.RunLive(generation, live =>
+			{
+				var page = live.GetInstance<ContentPage>();
+				Assert.Equal("FromApplication", Assert.IsType<Label>(page.Content).Text);
+			});
+		}
+
+		Assert.Same(previousApplication, Application.Current);
+	}
+
+	[MetadataUpdateFact]
+	public void ApplicationHost_ThemeFlipIsSynchronous()
+	{
+		const string xaml = """
+			<ContentPage xmlns="http://schemas.microsoft.com/dotnet/2021/maui"
+			             xmlns:x="http://schemas.microsoft.com/winfx/2009/xaml"
+			             x:Class="HarnessCapabilityApp.MainPage">
+			  <Label Text="{AppThemeBinding Light=LightBranch, Dark=DarkBranch}" />
+			</ContentPage>
+			""";
+		var options = new XamlHotReloadApplicationOptions(InitialTheme: AppTheme.Light);
+
+		using var harness = CreateHostedHarness(options);
+		var generation = harness.Generate(xaml);
+
+		harness.RunLive(generation, live =>
+		{
+			var page = live.GetInstance<ContentPage>();
+			var label = Assert.IsType<Label>(page.Content);
+			Assert.Equal("LightBranch", label.Text);
+
+			harness.ApplicationHost!.SetAppTheme(AppTheme.Dark);
+
+			Assert.Equal("DarkBranch", label.Text);
+		});
+	}
+
+	[Fact]
+	public void MultiDocument_DictionaryOnlyEdit_TracksAllDocumentsAndCompilesPage()
+	{
+		const string page = """
+			<ContentPage xmlns="http://schemas.microsoft.com/dotnet/2021/maui"
+			             xmlns:x="http://schemas.microsoft.com/winfx/2009/xaml"
+			             x:Class="HarnessCapabilityApp.MainPage">
+			  <ContentPage.Resources>
+			    <ResourceDictionary Source="Theme.xaml" />
+			  </ContentPage.Resources>
+			  <Label Text="Page" />
+			</ContentPage>
+			""";
+		const string themeV1 = """
+			<ResourceDictionary xmlns="http://schemas.microsoft.com/dotnet/2021/maui"
+			                    xmlns:x="http://schemas.microsoft.com/winfx/2009/xaml">
+			  <x:String x:Key="ThemeText">Before</x:String>
+			</ResourceDictionary>
+			""";
+		const string themeV2 = """
+			<ResourceDictionary xmlns="http://schemas.microsoft.com/dotnet/2021/maui"
+			                    xmlns:x="http://schemas.microsoft.com/winfx/2009/xaml">
+			  <x:String x:Key="ThemeText">After</x:String>
+			</ResourceDictionary>
+			""";
+
+		using var harness = CreateHarness();
+		var generation = harness.GenerateDocuments(
+			CreateDocumentSnapshot(page, themeV1),
+			CreateDocumentSnapshot(page, themeV2));
+
+		Assert.Equal(themeV2, generation[1].Documents["Theme.xaml"].Text);
+		Assert.Single(generation[1].GeneratedRoots);
+		Assert.Equal(PageClass, generation[1].GeneratedRoots[0].TypeName);
+		Assert.True(harness.Compile(generation[1]).PeImage.Length > 0);
+	}
+	[MetadataUpdateFact]
+	public void MultipleInstances_RetainedRootsUpdateAndFreshRootStartsLatest()
+	{
+		const string xamlV1 = """
+			<ContentPage xmlns="http://schemas.microsoft.com/dotnet/2021/maui"
+			             xmlns:x="http://schemas.microsoft.com/winfx/2009/xaml"
+			             x:Class="HarnessCapabilityApp.MainPage">
+			  <Label Text="Before" />
+			</ContentPage>
+			""";
+		const string xamlV2 = """
+			<ContentPage xmlns="http://schemas.microsoft.com/dotnet/2021/maui"
+			             xmlns:x="http://schemas.microsoft.com/winfx/2009/xaml"
+			             x:Class="HarnessCapabilityApp.MainPage">
+			  <Label Text="After" />
+			</ContentPage>
+			""";
+
+		using var harness = CreateHarness();
+		var generation = harness.Generate(xamlV1, xamlV2);
+
+		harness.RunLive(generation, live =>
+		{
+			var first = live.GetInstance<ContentPage>();
+			var second = live.CreateInstance<ContentPage>();
+			Assert.Equal("Before", Assert.IsType<Label>(first.Content).Text);
+			Assert.Equal("Before", Assert.IsType<Label>(second.Content).Text);
+
+			Assert.Same(first, live.ApplyUpdate<ContentPage>(1));
+			Assert.Equal("After", Assert.IsType<Label>(first.Content).Text);
+			Assert.Equal("After", Assert.IsType<Label>(second.Content).Text);
+
+			var third = live.CreateInstance<ContentPage>();
+			Assert.Equal("After", Assert.IsType<Label>(third.Content).Text);
+		});
+	}
+
+	static IReadOnlyDictionary<string, XamlHotReloadDocument> CreateDocumentSnapshot(
+		string page,
+		string theme) =>
+		new Dictionary<string, XamlHotReloadDocument>(StringComparer.Ordinal)
+		{
+			["MainPage.xaml"] = new XamlHotReloadDocument(page),
+			["Theme.xaml"] = new XamlHotReloadDocument(theme),
+		};
+}
diff --git a/src/Controls/tests/SourceGen.UnitTests/HotReload/AiAssisted/NestedControlHotReloadTests.GeneratedRoots.cs b/src/Controls/tests/SourceGen.UnitTests/HotReload/AiAssisted/NestedControlHotReloadTests.GeneratedRoots.cs
new file mode 100644
index 000000000000..ff564d4f5be3
--- /dev/null
+++ b/src/Controls/tests/SourceGen.UnitTests/HotReload/AiAssisted/NestedControlHotReloadTests.GeneratedRoots.cs
@@ -0,0 +1,32 @@
+#nullable enable
+
+using System;
+using System.Collections.Generic;
+using System.Reflection;
+using Microsoft.Maui.Controls.SourceGen.UnitTests.HotReload;
+using Microsoft.Maui.Dispatching;
+using Xunit;
+
+namespace Microsoft.Maui.Controls.SourceGen.UnitTests.HotReload.AiAssisted;
+
+public partial class NestedControlHotReloadTests
+{
+	// Wave2 · Nested Controls · P0-07 · NC-04
+	// Provenance: MAUI Wave2 plan §3.5 NC-04 (P0-07)
+	[Fact]
+	public void NestedGeneratedRoots_LocalResources_EmitsDocumentedResourceDecline()
+	{
+		using var harness = new XamlHotReloadTestHarness(
+			nameof(NestedGeneratedRoots_LocalResources_EmitsDocumentedResourceDecline),
+			PageClass,
+			PageStub,
+			GeneratedProbeCardStub,
+			ProbeConverterStubs);
+		var generation = harness.GenerateDocuments(
+			Documents(Nc04Page("A1", "B1"), Nc04ProbeCard("ProbeConverterOriginal")),
+			Documents(Nc04Page("A2", "B2"), Nc04ProbeCard("ProbeConverterUpdated")));
+
+		AssertProbeCardResourceDecline(GetProbeCardUpdateV2(generation));
+		Assert.True(harness.Compile(generation[1]).PeImage.Length > 0);
+	}
+}
diff --git a/src/Controls/tests/SourceGen.UnitTests/HotReload/AiAssisted/NestedControlHotReloadTests.SameCompilation.cs b/src/Controls/tests/SourceGen.UnitTests/HotReload/AiAssisted/NestedControlHotReloadTests.SameCompilation.cs
new file mode 100644
index 000000000000..8e1fa6bc56dd
--- /dev/null
+++ b/src/Controls/tests/SourceGen.UnitTests/HotReload/AiAssisted/NestedControlHotReloadTests.SameCompilation.cs
@@ -0,0 +1,200 @@
+#nullable enable
+
+using System;
+using System.Collections.Generic;
+using System.Reflection;
+using Microsoft.Maui.Controls.SourceGen.UnitTests.HotReload;
+using Microsoft.Maui.Dispatching;
+using Xunit;
+
+namespace Microsoft.Maui.Controls.SourceGen.UnitTests.HotReload.AiAssisted;
+
+public partial class NestedControlHotReloadTests
+{
+	// Wave2 · Nested Controls · P0-07 (V1 slice) · NC-01
+	// Provenance: MAUI Wave2 plan §3.5 NC-01 (P0-07) | anonymized "reusable card with per-instance local resources" pattern
+	// Faithfulness: construction-only — two same-compilation ProbeCard instances, each with its own
+	//   x:Name, nested <ProbeCard.Resources> keyed converter, and an x:Reference-bound Label. No writer
+	//   mutation/skip path is involved; this is the supported-construction GREEN anchor that NC-02/NC-03
+	//   (below) diff against.
+	// Issue: https://github.com/dotnet/maui/issues/36732   (writer-roadmap tracking; NC-01 is the green anchor, not a probe)
+	[MetadataUpdateFact]
+	public void NestedCustomControls_Construct_HaveIndependentIdentityAndNamescope()
+	{
+		var xamlV1 = Xaml("A1", "ProbeConverterOriginal", "B1", "ProbeConverterOriginal");
+
+		using var harness = new XamlHotReloadTestHarness(
+			nameof(NestedCustomControls_Construct_HaveIndependentIdentityAndNamescope), PageClass, PageStub, ProbeCardStub, ProbeConverterStubs);
+		var generation = harness.Generate(xamlV1);
+
+		harness.RunLive(generation, live =>
+		{
+			var page = live.GetInstance<global::Microsoft.Maui.Controls.ContentPage>();
+
+			var cardA = GetNamedField<global::Microsoft.Maui.Controls.VisualElement>(page, "CardA");
+			var cardB = GetNamedField<global::Microsoft.Maui.Controls.VisualElement>(page, "CardB");
+			var labelA = GetNamedField<global::Microsoft.Maui.Controls.Label>(page, "CardALabel");
+			var labelB = GetNamedField<global::Microsoft.Maui.Controls.Label>(page, "CardBLabel");
+
+			// Independent identities: separate x:Name'd fields resolve to their own distinct instance.
+			Assert.NotSame(cardA, cardB);
+
+			// x:Reference behavior: each Label's binding resolved to its OWN card, via its own local converter.
+			Assert.Equal("Original:A1", labelA.Text);
+			Assert.Equal("Original:B1", labelB.Text);
+
+			// Independent local resources: distinct dictionaries, distinct converter instances
+			// (even though both cards use the same converter TYPE here).
+			Assert.NotSame(cardA.Resources, cardB.Resources);
+			var fmtA = cardA.Resources["Fmt"];
+			var fmtB = cardB.Resources["Fmt"];
+			Assert.NotSame(fmtA, fmtB);
+
+			// Independent runtime state: mutating one card's Value never updates the other's Label.
+			((dynamic)cardA).Value = "A9";
+			Assert.Equal("Original:A9", labelA.Text);
+			Assert.Equal("Original:B1", labelB.Text);
+		});
+	}
+
+	// Wave2 · Nested Controls · P0-07 · NC-02
+	// Provenance: MAUI Wave2 plan §3.5 NC-02 (P0-07) | anonymized "reusable card with per-instance local resources" pattern
+	// Faithfulness: reaches the non-root complex-property skip at
+	//   UpdateComponentCodeWriter.cs:1194 (EmitPropertyChange, isRoot: false). The plan's original
+	//   citation (L929, TryEmitResourceDictionaryChange's "left untouched" marker) was verified against
+	//   this generator and found to be ROOT-ONLY: TryEmitResourceDictionaryChange has exactly one
+	//   caller, EmitRootPropertyChange (L1096), which only ever runs for the page/root element's own
+	//   `this.Resources`. A nested (non-root) ProbeCard's <ProbeCard.Resources> edit falls through
+	//   TryEmitMarkupNodeChange and hits the generic complex-property decline at L1194 instead —
+	//   confirmed empirically via generated-source inspection below.
+	// Expected: DOC-SKIP-GUARD
+	// Issue: https://github.com/dotnet/maui/issues/36732   (writer-roadmap tracking for non-root Resources support)
+	[Fact]
+	public void NestedLocalResources_CustomConverter_EmitsSkipMarker()
+	{
+		var xamlV1 = Xaml("A1", "ProbeConverterOriginal", "B1", "ProbeConverterOriginal");
+		// Only CardA's nested Resources (converter type) changes; CardB and both Values are untouched.
+		var xamlV2 = Xaml("A1", "ProbeConverterUpdated", "B1", "ProbeConverterOriginal");
+
+		using var harness = new XamlHotReloadTestHarness(
+			nameof(NestedLocalResources_CustomConverter_EmitsSkipMarker), PageClass, PageStub, ProbeCardStub, ProbeConverterStubs);
+		var generation = harness.Generate(xamlV1, xamlV2);
+		var updateComponentSource = generation[1].UpdateComponentSource;
+
+		Assert.NotNull(updateComponentSource);
+		Assert.Contains(
+			"Complex property 'Resources' (ElementNode) — skipped (not yet supported)",
+			updateComponentSource!,
+			StringComparison.Ordinal);
+
+		var compilation = harness.Compile(generation[1]);
+		Assert.True(compilation.PeImage.Length > 0, "Generated V2 UpdateComponent (with the nested-Resources skip) should still compile.");
+	}
+
+	// Wave2 · Nested Controls · P0-07 · NC-03
+	// Provenance: MAUI Wave2 plan §3.5 NC-03 (P0-07) | anonymized "reusable card with per-instance local resources" pattern
+	// Faithfulness: exercises the same nested-Resources skip as NC-02 (UpdateComponentCodeWriter.cs:1194)
+	//   together with a live x:Reference rebind, on the SAME retained page/ProbeCard/Label instances,
+	//   across three versions (V1 A1/B1 -> V2 A2/B2 -> V3=V1 A1/B1). Confirmed by inspecting the actual
+	//   generated V2 UpdateComponent below: each ProbeCard is retrieved via
+	//   `XamlComponentRegistry.TryGet(this, id, ...)` (never `new ProbeCard(...)`) in the exact same
+	//   diff block that emits the Resources skip comment for that element — i.e. this reaches the
+	//   intended retained nested-resource + x:Reference path, not a whole-subtree/root replacement.
+	//   Because the skip only declines the Resources-dictionary diff, the sibling Value diff on the
+	//   same retained element is still applied directly; the pre-existing Label Binding (built once at
+	//   construction, referencing its own card via x:Reference) observes that Value's PropertyChanged and
+	//   re-invokes its ORIGINAL (never-replaced) converter with the new value, independently per card.
+	//   Empirically this is a well-defined, side-effect-free fallback, not a hang/crash/bleed bug:
+	//   page/cardA/cardB/labelA/labelB identities are all retained (ReferenceEquals) across every
+	//   version; ProbeConverterUpdated.InvocationCount stays 0 for the whole scenario;
+	//   ProbeConverterOriginal.InvocationCount increases by exactly 2 (one per card) per version with no
+	//   multiplication and no cross-card bleed; and each card's local converter/Resources dictionary
+	//   object is untouched (same reference) throughout, proving left/right independence never
+	//   degrades. No incorrect/multiplied/cross-bled behavior was found — classified GREEN.
+	[MetadataUpdateFact]
+	public void NestedControls_LocalResources_XReference_RebindIndependently()
+	{
+		// Prefixes V1/V2/V1 per-card: CardA A1→A2→A1, CardB B1→B2→B1; converter swapped and reverted alongside.
+		var xamlV1 = Xaml("A1", "ProbeConverterOriginal", "B1", "ProbeConverterOriginal");
+		var xamlV2 = Xaml("A2", "ProbeConverterUpdated", "B2", "ProbeConverterUpdated");
+		var xamlV3 = Xaml("A1", "ProbeConverterOriginal", "B1", "ProbeConverterOriginal");
+
+		using var harness = new XamlHotReloadTestHarness(
+			nameof(NestedControls_LocalResources_XReference_RebindIndependently), PageClass, PageStub, ProbeCardStub, ProbeConverterStubs);
+		var generation = harness.Generate(xamlV1, xamlV2, xamlV3);
+
+		// Faithfulness guard on the generated source itself: the V2 diff must retrieve the EXISTING
+		// ProbeCard from the component registry (never reconstruct it) in the same block that declines
+		// the nested Resources edit — this is what proves the test below reaches the intended retained
+		// nested-resource skip + x:Reference rebind path rather than passing for an unrelated reason.
+		var updateComponentSourceV2 = generation[1].UpdateComponentSource;
+		Assert.NotNull(updateComponentSourceV2);
+		Assert.Contains("XamlComponentRegistry.TryGet", updateComponentSourceV2!, StringComparison.Ordinal);
+		Assert.Contains(
+			"Complex property 'Resources' (ElementNode) — skipped (not yet supported)",
+			updateComponentSourceV2!,
+			StringComparison.Ordinal);
+		Assert.DoesNotContain("new global::TestAiAssisted.ProbeCard(", updateComponentSourceV2!, StringComparison.Ordinal);
+
+		harness.RunLive(generation, live =>
+		{
+			var page = live.GetInstance<global::Microsoft.Maui.Controls.ContentPage>();
+			var cardA = GetNamedField<global::Microsoft.Maui.Controls.VisualElement>(page, "CardA");
+			var cardB = GetNamedField<global::Microsoft.Maui.Controls.VisualElement>(page, "CardB");
+			var labelA = GetNamedField<global::Microsoft.Maui.Controls.Label>(page, "CardALabel");
+			var labelB = GetNamedField<global::Microsoft.Maui.Controls.Label>(page, "CardBLabel");
+
+			// Distinct converter instances per card from the start (independent local resources).
+			var fmtA = cardA.Resources["Fmt"];
+			var fmtB = cardB.Resources["Fmt"];
+			Assert.NotSame(fmtA, fmtB);
+
+			// V1: both cards use ProbeConverterOriginal, exactly once each — no cross-card bleed.
+			Assert.Equal("Original:A1", labelA.Text);
+			Assert.Equal("Original:B1", labelB.Text);
+			Assert.Equal(2, GetStaticInvocationCount(cardA, "TestAiAssisted.ProbeConverterOriginal"));
+			Assert.Equal(0, GetStaticInvocationCount(cardA, "TestAiAssisted.ProbeConverterUpdated"));
+
+			live.ApplyUpdate<global::Microsoft.Maui.Controls.ContentPage>(1);
+
+			// Retained-identity guard: same page and the SAME nested ProbeCard/Label objects after V2 —
+			// nothing was reconstructed, only mutated in place.
+			Assert.Same(page, live.GetInstance<global::Microsoft.Maui.Controls.ContentPage>());
+			Assert.Same(cardA, GetNamedField<global::Microsoft.Maui.Controls.VisualElement>(page, "CardA"));
+			Assert.Same(cardB, GetNamedField<global::Microsoft.Maui.Controls.VisualElement>(page, "CardB"));
+			Assert.Same(labelA, GetNamedField<global::Microsoft.Maui.Controls.Label>(page, "CardALabel"));
+			Assert.Same(labelB, GetNamedField<global::Microsoft.Maui.Controls.Label>(page, "CardBLabel"));
+			// Each card's local converter/Resources dictionary is untouched by the skip (still the SAME
+			// object) — left/right independence holds, and no swap occurred.
+			Assert.Same(fmtA, cardA.Resources["Fmt"]);
+			Assert.Same(fmtB, cardB.Resources["Fmt"]);
+
+			// V2: prefixes actually change (A1/B1 -> A2/B2). The XAML now declares ProbeConverterUpdated,
+			// but the nested-Resources skip means the converter swap never applies. The still-live Value
+			// update re-invokes the ORIGINAL converter with the new value on each card, independently and
+			// exactly once (no multiplication, no cross-card bleed).
+			Assert.Equal("Original:A2", labelA.Text);
+			Assert.Equal("Original:B2", labelB.Text);
+			Assert.Equal(4, GetStaticInvocationCount(cardA, "TestAiAssisted.ProbeConverterOriginal"));
+			Assert.Equal(0, GetStaticInvocationCount(cardA, "TestAiAssisted.ProbeConverterUpdated"));
+
+			live.ApplyUpdate<global::Microsoft.Maui.Controls.ContentPage>(2);
+
+			// Retained-identity guard: same objects again after V3 (revert) — still never reconstructed.
+			Assert.Same(page, live.GetInstance<global::Microsoft.Maui.Controls.ContentPage>());
+			Assert.Same(cardA, GetNamedField<global::Microsoft.Maui.Controls.VisualElement>(page, "CardA"));
+			Assert.Same(cardB, GetNamedField<global::Microsoft.Maui.Controls.VisualElement>(page, "CardB"));
+			Assert.Same(labelA, GetNamedField<global::Microsoft.Maui.Controls.Label>(page, "CardALabel"));
+			Assert.Same(labelB, GetNamedField<global::Microsoft.Maui.Controls.Label>(page, "CardBLabel"));
+			Assert.Same(fmtA, cardA.Resources["Fmt"]);
+			Assert.Same(fmtB, cardB.Resources["Fmt"]);
+
+			// V3: prefixes revert (A2/B2 -> A1/B1), matching V1 exactly. ProbeConverterUpdated was never
+			// constructed/invoked at any point across the whole V1->V2->V1 sequence.
+			Assert.Equal("Original:A1", labelA.Text);
+			Assert.Equal("Original:B1", labelB.Text);
+			Assert.Equal(6, GetStaticInvocationCount(cardA, "TestAiAssisted.ProbeConverterOriginal"));
+			Assert.Equal(0, GetStaticInvocationCount(cardA, "TestAiAssisted.ProbeConverterUpdated"));
+		});
+	}
+}
diff --git a/src/Controls/tests/SourceGen.UnitTests/HotReload/AiAssisted/NestedControlHotReloadTests.cs b/src/Controls/tests/SourceGen.UnitTests/HotReload/AiAssisted/NestedControlHotReloadTests.cs
new file mode 100644
index 000000000000..9cacde2f2eb5
--- /dev/null
+++ b/src/Controls/tests/SourceGen.UnitTests/HotReload/AiAssisted/NestedControlHotReloadTests.cs
@@ -0,0 +1,268 @@
+#nullable enable
+
+using System;
+using System.Collections.Generic;
+using System.Reflection;
+using Microsoft.Maui.Controls.SourceGen.UnitTests.HotReload;
+using Microsoft.Maui.Dispatching;
+using Xunit;
+
+namespace Microsoft.Maui.Controls.SourceGen.UnitTests.HotReload.AiAssisted;
+
+/// <summary>
+/// Wave-2 Phase-1 nested/custom-control hot reload coverage (NC-01..NC-03).
+/// Fixture: a same-compilation "ProbeCard" (<see cref="global::Microsoft.Maui.Controls.ContentView"/>)
+/// used twice per page, each instance carrying its own nested
+/// <c>&lt;ProbeCard.Resources&gt;</c> keyed converter and a child <c>Label</c> bound via
+/// <c>x:Reference</c> back to its own card. This is a generic, anonymized stand-in for the common
+/// "reusable card control with per-instance local resources" shape — no proprietary names or text
+/// are used or copied from any specific application.
+/// </summary>
+[Collection("XamlHotReloadTests")]
+public partial class NestedControlHotReloadTests : IDisposable
+{
+	public NestedControlHotReloadTests() => DispatcherProvider.SetCurrent(new StubDispatcherProvider());
+
+	public void Dispose() => DispatcherProvider.SetCurrent(null);
+
+	const string PageClass = "TestAiAssisted.MainPage";
+
+	const string PageStub = """
+		namespace TestAiAssisted;
+
+		public partial class MainPage : global::Microsoft.Maui.Controls.ContentPage
+		{
+			private partial void InitializeComponent();
+
+			public void InitializeComponentRuntime() { }
+
+			public MainPage()
+			{
+				InitializeComponent();
+			}
+
+			// x:Name'd elements below need a matching field for the generator's InitializeComponent
+			// to assign into (the harness only wires XamlGenerator, not the separate code-behind
+			// field-declaration generator that normally supplies these in a real build).
+			private global::TestAiAssisted.ProbeCard CardA = default!;
+			private global::TestAiAssisted.ProbeCard CardB = default!;
+			private global::Microsoft.Maui.Controls.Label CardALabel = default!;
+			private global::Microsoft.Maui.Controls.Label CardBLabel = default!;
+		}
+		""";
+
+	const string ProbeCardStub = """
+		namespace TestAiAssisted;
+
+		// Generic same-compilation custom control: a reusable "card" with its own bindable Value.
+		public class ProbeCard : global::Microsoft.Maui.Controls.ContentView
+		{
+			public static readonly global::Microsoft.Maui.Controls.BindableProperty ValueProperty =
+				global::Microsoft.Maui.Controls.BindableProperty.Create(nameof(Value), typeof(string), typeof(ProbeCard), default(string));
+
+			public string? Value
+			{
+				get => (string?)GetValue(ValueProperty);
+				set => SetValue(ValueProperty, value);
+			}
+		}
+		""";
+
+	const string GeneratedProbeCardStub = """
+		namespace TestAiAssisted;
+
+		public partial class ProbeCard : global::Microsoft.Maui.Controls.ContentView
+		{
+			public static readonly global::Microsoft.Maui.Controls.BindableProperty ValueProperty =
+				global::Microsoft.Maui.Controls.BindableProperty.Create(nameof(Value), typeof(string), typeof(ProbeCard), default(string));
+
+			public string? Value
+			{
+				get => (string?)GetValue(ValueProperty);
+				set => SetValue(ValueProperty, value);
+			}
+
+			private partial void InitializeComponent();
+
+			private global::TestAiAssisted.ProbeCard Root = default!;
+			private global::Microsoft.Maui.Controls.Label CardLabel = default!;
+
+			public ProbeCard()
+			{
+				InitializeComponent();
+			}
+		}
+		""";
+
+	const string ProbeConverterStubs = """
+		namespace TestAiAssisted;
+
+		public sealed class ProbeConverterOriginal : global::Microsoft.Maui.Controls.IValueConverter
+		{
+			public static int InvocationCount;
+
+			public object? Convert(object? value, global::System.Type targetType, object? parameter, global::System.Globalization.CultureInfo culture)
+			{
+				InvocationCount++;
+				return $"Original:{value}";
+			}
+
+			public object? ConvertBack(object? value, global::System.Type targetType, object? parameter, global::System.Globalization.CultureInfo culture) => value;
+		}
+
+		public sealed class ProbeConverterUpdated : global::Microsoft.Maui.Controls.IValueConverter
+		{
+			public static int InvocationCount;
+
+			public object? Convert(object? value, global::System.Type targetType, object? parameter, global::System.Globalization.CultureInfo culture)
+			{
+				InvocationCount++;
+				return $"Updated:{value}";
+			}
+
+			public object? ConvertBack(object? value, global::System.Type targetType, object? parameter, global::System.Globalization.CultureInfo culture) => value;
+		}
+		""";
+
+	const string XamlTemplate = """
+		<ContentPage xmlns="http://schemas.microsoft.com/dotnet/2021/maui"
+		             xmlns:x="http://schemas.microsoft.com/winfx/2009/xaml"
+		             xmlns:local="clr-namespace:TestAiAssisted"
+		             x:Class="TestAiAssisted.MainPage">
+		  <VerticalStackLayout>
+		    <local:ProbeCard x:Name="CardA" Value="__CARD_A_VALUE__">
+		      <local:ProbeCard.Resources>
+		        <ResourceDictionary>
+		          <local:__CARD_A_CONVERTER__ x:Key="Fmt" />
+		        </ResourceDictionary>
+		      </local:ProbeCard.Resources>
+		      <Label x:Name="CardALabel" Text="{Binding Source={x:Reference CardA}, Path=Value, Converter={StaticResource Fmt}}" />
+		    </local:ProbeCard>
+		    <local:ProbeCard x:Name="CardB" Value="__CARD_B_VALUE__">
+		      <local:ProbeCard.Resources>
+		        <ResourceDictionary>
+		          <local:__CARD_B_CONVERTER__ x:Key="Fmt" />
+		        </ResourceDictionary>
+		      </local:ProbeCard.Resources>
+		      <Label x:Name="CardBLabel" Text="{Binding Source={x:Reference CardB}, Path=Value, Converter={StaticResource Fmt}}" />
+		    </local:ProbeCard>
+		  </VerticalStackLayout>
+		</ContentPage>
+		""";
+
+	static string Xaml(string cardAValue, string cardAConverter, string cardBValue, string cardBConverter) =>
+		XamlTemplate
+			.Replace("__CARD_A_VALUE__", cardAValue, StringComparison.Ordinal)
+			.Replace("__CARD_A_CONVERTER__", cardAConverter, StringComparison.Ordinal)
+			.Replace("__CARD_B_VALUE__", cardBValue, StringComparison.Ordinal)
+			.Replace("__CARD_B_CONVERTER__", cardBConverter, StringComparison.Ordinal);
+
+	static int GetStaticInvocationCount(object anyInstanceFromGeneratedAssembly, string fullyQualifiedTypeName)
+	{
+		var assembly = anyInstanceFromGeneratedAssembly.GetType().Assembly;
+		var type = assembly.GetType(fullyQualifiedTypeName) ?? throw new InvalidOperationException($"Type '{fullyQualifiedTypeName}' not found in generated assembly.");
+		var field = type.GetField("InvocationCount", BindingFlags.Public | BindingFlags.Static) ?? throw new InvalidOperationException("InvocationCount field not found.");
+		return (int)field.GetValue(null)!;
+	}
+
+	// PageStub's x:Name'd fields are declared `private` (matching the real code-behind field
+	// modifier default) — the harness does not run the code-behind field-declaration generator
+	// that would normally expose a public accessor, so tests reach them via reflection.
+	static T GetNamedField<T>(object page, string fieldName) where T : class
+	{
+		var field = page.GetType().GetField(fieldName, BindingFlags.NonPublic | BindingFlags.Instance)
+			?? throw new InvalidOperationException($"Field '{fieldName}' not found on '{page.GetType()}'.");
+		return (T)field.GetValue(page)!;
+	}
+
+	static void ApplyGeneratedUpdate(object root)
+	{
+		var updateMethod = root.GetType().GetMethod(
+			"UpdateComponent",
+			BindingFlags.Instance | BindingFlags.NonPublic | BindingFlags.Public)
+			?? throw new InvalidOperationException($"UpdateComponent not found on '{root.GetType()}'.");
+		updateMethod.Invoke(root, null);
+	}
+
+	static IReadOnlyDictionary<string, XamlHotReloadDocument> Documents(string page, string probeCard) =>
+		new Dictionary<string, XamlHotReloadDocument>(StringComparer.Ordinal)
+		{
+			["MainPage.xaml"] = new XamlHotReloadDocument(page),
+			["ProbeCard.xaml"] = new XamlHotReloadDocument(probeCard),
+		};
+
+	const string Nc04PageTemplate = """
+		<ContentPage xmlns="http://schemas.microsoft.com/dotnet/2021/maui"
+		             xmlns:x="http://schemas.microsoft.com/winfx/2009/xaml"
+		             xmlns:local="clr-namespace:TestAiAssisted"
+		             x:Class="TestAiAssisted.MainPage">
+		  <VerticalStackLayout>
+		    <local:ProbeCard x:Name="CardA" Value="__CARD_A_VALUE__" />
+		    <local:ProbeCard x:Name="CardB" Value="__CARD_B_VALUE__" />
+		  </VerticalStackLayout>
+		</ContentPage>
+		""";
+
+	const string Nc04ProbeCardTemplate = """
+		<ContentView xmlns="http://schemas.microsoft.com/dotnet/2021/maui"
+		             xmlns:x="http://schemas.microsoft.com/winfx/2009/xaml"
+		             xmlns:local="clr-namespace:TestAiAssisted"
+		             x:Class="TestAiAssisted.ProbeCard"
+		             x:Name="Root">
+		  <ContentView.Resources>
+		    <ResourceDictionary>
+		      <local:__CONVERTER__ x:Key="Fmt" />
+		    </ResourceDictionary>
+		  </ContentView.Resources>
+		  <Label x:Name="CardLabel"
+		         Text="{Binding Source={x:Reference Root}, Path=Value, Converter={StaticResource Fmt}}" />
+		</ContentView>
+		""";
+
+	static string Nc04Page(string cardAValue, string cardBValue) =>
+		Nc04PageTemplate
+			.Replace("__CARD_A_VALUE__", cardAValue, StringComparison.Ordinal)
+			.Replace("__CARD_B_VALUE__", cardBValue, StringComparison.Ordinal);
+
+	static string Nc04ProbeCard(string converter) =>
+		Nc04ProbeCardTemplate.Replace("__CONVERTER__", converter, StringComparison.Ordinal);
+
+	static string GetProbeCardUpdateV2(XamlHotReloadGeneration generation)
+	{
+		var updateComponentSource = Assert.Single(generation[1].GeneratedRoots,
+			static root => root.TypeName == "TestAiAssisted.ProbeCard").UpdateComponentSource;
+		Assert.NotNull(updateComponentSource);
+		return updateComponentSource!;
+	}
+
+	static void AssertProbeCardResourceDecline(string updateComponentSource)
+	{
+		Assert.Contains("XamlComponentRegistry.GetResourceKeys(this)", updateComponentSource, StringComparison.Ordinal);
+		Assert.Contains("XamlComponentRegistry.RegisterResourceKeys(this, global::System.Array.Empty<string>())", updateComponentSource, StringComparison.Ordinal);
+		Assert.DoesNotContain("ProbeConverterUpdated", updateComponentSource, StringComparison.Ordinal);
+	}
+
+	sealed class StubDispatcher : IDispatcher
+	{
+		public bool IsDispatchRequired => false;
+
+		public bool Dispatch(Action action)
+		{
+			action();
+			return true;
+		}
+
+		public bool DispatchDelayed(TimeSpan delay, Action action)
+		{
+			action();
+			return true;
+		}
+
+		public IDispatcherTimer CreateTimer() => throw new NotSupportedException();
+	}
+
+	sealed class StubDispatcherProvider : IDispatcherProvider
+	{
+		public IDispatcher GetForCurrentThread() => new StubDispatcher();
+	}
+}
diff --git a/src/Controls/tests/SourceGen.UnitTests/HotReload/AiAssisted/README.md b/src/Controls/tests/SourceGen.UnitTests/HotReload/AiAssisted/README.md
new file mode 100644
index 000000000000..3068a7d78e2c
--- /dev/null
+++ b/src/Controls/tests/SourceGen.UnitTests/HotReload/AiAssisted/README.md
@@ -0,0 +1,162 @@
+# AI-Assisted Hot Reload Test Harness
+
+## Purpose and scope
+
+This directory contains issue-derived XAML Incremental Hot Reload (XIHR) source-generator tests and focused in-process metadata-update probes. Tests generate and compile incremental output, inspect diagnostics or `UpdateComponent`, and, where supported, apply Roslyn deltas to collectible test assemblies.
+
+They do not exercise the IDE, `dotnet watch`, Roslyn's live edit classifier, a physical device, native rendering, or handler lifecycle. A generated-source marker proves only the documented generator branch; it does not prove runtime behavior.
+
+## Canonical local result
+
+With metadata updates enabled on the canonical integration branch:
+
+| Filter | Passed | Skipped | Failed |
+|---|---:|---:|---:|
+| `FullyQualifiedName~HotReload.AiAssisted` | 41 | 0 | 0 |
+| `FullyQualifiedName~XamlIncrementalHotReloadE2ETests` | 13 | 0 | 0 |
+
+These are local `net11.0` Debug results with `DOTNET_MODIFIABLE_ASSEMBLIES=debug`. Theory data contributes test cases: RT-01 has three passing rows and TS-03 has two.
+
+```bash
+DOTNET_MODIFIABLE_ASSEMBLIES=debug dotnet test src/Controls/tests/SourceGen.UnitTests/SourceGen.UnitTests.csproj -c Debug --filter "FullyQualifiedName~HotReload.AiAssisted"
+DOTNET_MODIFIABLE_ASSEMBLIES=debug dotnet test src/Controls/tests/SourceGen.UnitTests/SourceGen.UnitTests.csproj -c Debug --filter "FullyQualifiedName~XamlIncrementalHotReloadE2ETests"
+```
+
+## Classification
+
+| Classification | Meaning |
+|---|---|
+| **GREEN live** | Passing retained-object metadata-update behavior. |
+| **GREEN construction** | Passing initial construction or realization behavior; no post-update runtime claim. |
+| **GREEN generator guard** | Passing generation, diagnostic, source-shape, or compile assertion only. |
+| **DOC-SKIP-GUARD** | Passing assertion that an unsupported writer path is explicitly skipped and still compiles. |
+| **Integration/host deferred** | Requires a real runtime assembly boundary, IDE/watch host, device, native handler, or lifecycle. |
+
+## Wave-1 retained coverage
+
+| Area | Classification | Exact method |
+|---|---|---|
+| #36256 complex root property | GREEN generator guard | `StructuralHotReloadTests.RootComplexElementProperty_IsNotSilentlyDropped` |
+| #36256 live root replacement | GREEN live | `StructuralHotReloadTests.RootComplexElementProperty_AppliesToExistingPage` |
+| Inline resources | DOC-SKIP-GUARD | `StructuralHotReloadTests.ComplexPropertyWithNestedResources_IsExplicitlySkipped` |
+| Ancestor `StaticResource` | DOC-SKIP-GUARD | `StructuralHotReloadTests.ComplexPropertyWithAncestorStaticResource_IsExplicitlySkipped` |
+| Nested and element-form `StaticResource` | DOC-SKIP-GUARD, two theory rows | `StructuralHotReloadTests.ComplexPropertyWithNestedStaticResourceShape_IsExplicitlySkipped` |
+| Preflight diagnostics | GREEN generator guard | `StructuralHotReloadTests.StaticResourcePreflight_DiscardsParserDiagnostics` |
+| #36157 recovery boundary | GREEN generator guard | `GeneratorRecoveryHotReloadTests.MalformedExpression_ThenRepair_RecomputesGeneratorDiagnostics` |
+
+# Wave-2 living index
+
+## Harness capabilities
+
+| ID | Classification | Exact method and boundary |
+|---|---|---|
+| `cap-app-host` | GREEN construction | `HarnessCapabilityTests.ApplicationHost_ResolvesAppResources_AndRestoresPreviousApplication` |
+| `cap-theme-flip` | GREEN live | `HarnessCapabilityTests.ApplicationHost_ThemeFlipIsSynchronous` |
+| `cap-multi-doc` | GREEN generator guard | `HarnessCapabilityTests.MultiDocument_DictionaryOnlyEdit_TracksAllDocumentsAndCompilesPage`; live `Source=` reload remains harness-deferred. |
+| `cap-multi-instance` | GREEN live | `HarnessCapabilityTests.MultipleInstances_RetainedRootsUpdateAndFreshRootStartsLatest` |
+
+## Resources and themes
+
+| ID | Classification | Exact method, guard, and issue |
+|---|---|---|
+| RT-01 | GREEN live, three theory rows | `ResourceAndThemeHotReloadTests.DynamicResourceKey_RenameAndReverse_UpdatesVisibleValue` |
+| RT-02 | DOC-SKIP-GUARD | `ResourceAndThemeHotReloadTests.MergedDictionaries_ComplexProperty_EmitsSkipMarker` |
+| RT-04 | DOC-SKIP-GUARD | `ResourceAndThemeHotReloadTests.BasedOnStyle_ComplexResource_EmitsSkipMarker` |
+| RT-06 | DOC-SKIP-GUARD | `ResourceAndThemeHotReloadTests.TriggeredStyle_ComplexProperty_EmitsSkipMarker` |
+| RT-08 | GREEN generator guard | `ResourceAndThemeHotReloadTests.AppThemeBinding_BranchEdit_IsCapturedInGeneratedComponent`; live re-provision remains deferred under #36732. |
+| RT-09 | GREEN live | `ResourceAndThemeHotReloadTests.ApplicationDynamicResource_FansOutAndFreshRootsStartLatest` |
+| RT-10 | GREEN generator guard | `ResourceAndThemeHotReloadTests.SourceMergedDictionaries_ReorderThenRemove_TracksDocumentsAndCompiles`; live `Source=` reload remains harness-deferred. |
+| RT-11 | GREEN generator guard | `ResourceAndThemeHotReloadTests.MultiDocumentMalformedThenRepair_IsAtomicAcrossPageAndDictionary` |
+
+## Visual states and behaviors
+
+| ID | Classification | Exact method, guard, and issue |
+|---|---|---|
+| VS-01 | DOC-SKIP-GUARD | `VisualStateHotReloadTests.ActiveVsmSetter_ComplexAttachedProperty_EmitsSkipMarker` |
+| VS-03 | DOC-SKIP-GUARD | `VisualStateHotReloadTests.Behavior_ClearAndComplexProperty_EmitsSkipMarker` |
+| VS-05 | DOC-SKIP-GUARD | `VisualStateHotReloadTests.VsmState_AddRemoveReAdd_ComplexAttachedProperty_EmitsSkipMarker` |
+| VS-06 | DOC-SKIP-GUARD | `VisualStateHotReloadTests.ActiveVsmThemeResourceSetter_ComplexAttachedProperty_EmitsSkipMarker` |
+
+## Templates and selectors
+
+| ID | Classification | Exact method, guard, and issue |
+|---|---|---|
+| TS-01 | GREEN construction/generator | `TemplateAndSelectorHotReloadTests.KeyedDataTemplate_EditBody_ConstructionStableAndSourceReflectsEdit`; future realization remains deferred under #36482. |
+| TS-02 | GREEN construction/generator | `TemplateAndSelectorHotReloadTests.Selector_ConstructionDistinguishesBranchesAndIsStableAcrossUpdate`; future realization remains deferred under #36482. |
+| TS-03 | GREEN construction/generator, two theory rows | `TemplateAndSelectorHotReloadTests.CompiledTemplate_RetypeAndReverse_GeneratedSourceTracksCurrentType`; future realization remains deferred under #36482. |
+| TS-04 | GREEN construction | `TemplateAndSelectorHotReloadTests.ControlTemplate_Construction_NamescopeXReferenceAndVsmAreIsolated`; future realization remains deferred under #36482. |
+| TS-05 | DOC-SKIP-GUARD | `TemplateAndSelectorHotReloadTests.BindableLayoutTemplate_AttachedComplex_EmitsSkipMarker`; live BindableLayout reconciliation remains deferred under #36732. |
+
+## Bindings and markup
+
+| ID | Classification | Exact method, guard, and issue |
+|---|---|---|
+| BM-01 | GREEN live | `BindingAndMarkupHotReloadTests.DynamicResourceToBinding_SwapAndReverse_UpdatesVisibleValue` |
+| BM-02 | GREEN live | `BindingAndMarkupHotReloadTests.CustomMarkupExtension_EditAndReverse_ReprovidesValue` |
+| BM-03 | DOC-SKIP-GUARD | `BindingAndMarkupHotReloadTests.MultiBinding_ComplexProperty_EmitsSkipMarker`; live MultiBinding child reconciliation remains deferred under #36732. |
+
+## Nested controls
+
+All NC provenance is an anonymized production pattern; no application-specific names or text are retained.
+
+| ID | Classification | Exact method, guard, and issue |
+|---|---|---|
+| NC-01 | GREEN construction/live | `NestedControlHotReloadTests.NestedCustomControls_Construct_HaveIndependentIdentityAndNamescope` |
+| NC-02 | DOC-SKIP-GUARD | `NestedControlHotReloadTests.NestedLocalResources_CustomConverter_EmitsSkipMarker` |
+| NC-03 | GREEN live | `NestedControlHotReloadTests.NestedControls_LocalResources_XReference_RebindIndependently` |
+| NC-04 | GREEN generator guard | `NestedControlHotReloadTests.NestedGeneratedRoots_LocalResources_EmitsDocumentedResourceDecline`; generated-root live resource swaps remain deferred under #36732. |
+
+## Cross-assembly invalidation
+
+`cap-cross-asm-MC` is limited to incremental-generator reference invalidation and caching.
+
+| ID | Classification | Exact method and boundary |
+|---|---|---|
+| XA-01 | GREEN generator guard | `CrossAssemblyHotReloadTests.ReferencedAssemblySwap_InvalidatesXamlPipeline` |
+| XA-02 | GREEN generator guard | `CrossAssemblyHotReloadTests.UnchangedReferences_XamlPipelineCached` |
+
+XA-01/02 cover incremental-generator invalidation and caching only. XA-03 is intentionally represented by the existing `SourceGenXamlCodeBehindTests.TestCodeBehindGenerator_ImplementationChangeDoesNotTriggerRegeneration` and `SourceGenXamlCodeBehindTests.TestCodeBehindGenerator_SignatureChangeTriggersRegeneration`. Loading a separate runtime assembly and applying deltas across that boundary remains integration/host deferred.
+
+## Honest limitations and deferred lanes
+
+- A compiled `ResourceDictionary Source=` payload is unavailable in the in-memory collectible ALC; `cap-multi-doc` and RT-10 therefore stop at document tracking/generation/compile.
+- Cross-assembly tests cover generator invalidation only. Separate-runtime-assembly deltas, IDE/Hot Reload host behavior, `dotnet watch`, device lifecycle, native handlers, and rendered output remain integration lanes.
+- Generated `x:Name` fields require manual C# stubs because `CodeBehindCodeWriter` is outside this harness.
+- The AppThemeBinding path still finds a null `IProvideValueTarget.TargetProperty`; RT-08's passing generator guard does not prove live re-provisioning.
+- Keyed template and selector future factories remain the #36482 gap; passing construction/source guards do not prove post-update future realization.
+- Complex property and collection reconciliation remains #36732; the skipped live probes were intentionally left out of this PR to keep the passing surface reviewable. DOC-SKIP-GUARD rows prove explicit decline and compilability, not successful live reconciliation.
+
+## Wave-1 research disposition ledger
+
+This 28-row issue-research ledger predates the Wave-2 test IDs. Its legacy `RT-*` labels are research rows, not the Wave-2 RT-01..11 coverage identifiers above.
+
+| ID | Issue | Disposition | Target/evidence | Assertion and current net11 expectation |
+|---|---|---|---|---|
+| XIHR-01 | [#36256](https://github.com/dotnet/maui/issues/36256) | New generator/live tests | `StructuralHotReloadTests.RootComplexElementProperty_*` | Compile/shape plus in-process metadata update; verifies complex `ItemTemplate` emission and assignment to the same live page instance. |
+| XIHR-02 | [#36157](https://github.com/dotnet/maui/issues/36157) | New AI-assisted SG test | `GeneratorRecoveryHotReloadTests.MalformedExpression_ThenRepair_RecomputesGeneratorDiagnostics` | Generator diagnostics recomputation + compile only; no IDE Error List or dotnet-watch recovery claim. |
+| XIHR-03 | [#36156](https://github.com/dotnet/maui/issues/36156) | Deferred IDE-host-only | IDE/Roslyn rude-edit session integration test | No generator unit test: must reproduce a compile-failing rude edit and verify a later valid edit applies in the same host session. |
+| XIHR-04 | [#36155](https://github.com/dotnet/maui/issues/36155) | Existing adequate | `CSharpExpressionInterpolationTests` + `CSharpExpressionDiagnosticsTests` ternary tests | Shape/compile pass. |
+| XIHR-05 | [#36158](https://github.com/dotnet/maui/issues/36158) | Existing adequate | `Maui36158Tests` | Exact diagnostic location pass. |
+| XIHR-06 | [#36482](https://github.com/dotnet/maui/issues/36482) | Existing baseline + Wave-2 guards | Four baseline `DataTemplate_HotReload_*` pipeline tests plus TS-01..04 | Construction/source guards pass; future template/selector realization remains deferred under #36482. |
+| XIHR-07 | [#34027](https://github.com/dotnet/maui/issues/34027) | Rejected/non-HR | MSBuild/IDE contract | No edit-derived SG test. |
+| XIHR-08 | [#35931](https://github.com/dotnet/maui/issues/35931) | Deferred integration/device | Android `dotnet watch` test | Must assert rendered Label changes after watch dispatch. |
+| XIHR-09 | [#21083](https://github.com/dotnet/maui/issues/21083) | Rejected/non-HR | XamlC/VisualDiagnostics suite | Debug XamlC SourceInfo is not XIHR UC behavior. |
+| SPEC-01 | [#35404](https://github.com/dotnet/maui/issues/35404) | Rejected/non-HR | Cross-tool gauntlet | Checklist only; no single SG test. |
+| RT-01 | [#618](https://github.com/dotnet/maui/issues/618) | Existing adequate | `StyleTests.InvalidateStyleReapplies*` | Framework object-model assertions pass. |
+| RT-02 | [#34722](https://github.com/dotnet/maui/issues/34722) | Existing adequate | `VisualStateManagerTests.InvalidateVisualStates*` | Framework object-model assertions pass. |
+| RT-03 | [#619](https://github.com/dotnet/maui/issues/619) | Deferred framework/API | Resource refresh API + consumer tests | Existing `StaticResource` consumers must update; API absent. |
+| RT-04 | [#24218](https://github.com/dotnet/maui/issues/24218) | Deferred runtime/Windows | DynamicResource reapplication integration test | Re-add resource, mutate key, assert existing target follows it. |
+| RT-05 | [#35018](https://github.com/dotnet/maui/issues/35018) | Existing adequate | `Maui35018` + `HotReloadStaticResourceException` | Exception delivery/degraded reinflation pass. |
+| RT-06 | [#24638](https://github.com/dotnet/maui/issues/24638) | Deferred Windows handler/layout | Windows minimum-size device test | Native effective minimum clears immediately. |
+| RT-07 | [#24725](https://github.com/dotnet/maui/issues/24725) | Deferred Android/iOS handler | Native background-clear device test | Native brush becomes null/transparent; issue is `not_planned`. |
+| RT-08 | [#22324](https://github.com/dotnet/maui/issues/22324) | Deferred Windows Shell/layout | Shell flyout device test | Default labels visible immediately after custom content removal. |
+| RT-09 | [#17678](https://github.com/dotnet/maui/issues/17678) | Deferred layout/device | Repeated add/remove layout test | Parent height remains constant across cycles. |
+| RT-10 | [#20404](https://github.com/dotnet/maui/issues/20404) | Deferred Windows layout | Grid-row device test | Arranged position changes without resize; issue is `not_planned`. |
+| RT-11 | [#19075](https://github.com/dotnet/maui/issues/19075) | Deferred handler/device | Nested Brush Android/Windows test | Property notification and native repaint both required. |
+| RT-12 | [#10915](https://github.com/dotnet/maui/issues/10915) | Deferred namescope/device/integration | Realized ControlTemplate/VSM test | Targeted setter remains valid and later text reload still applies. |
+| RT-13 | [#15659](https://github.com/dotnet/maui/issues/15659) | Deferred Shell/device | Native tab-title test | Title updates without navigation. |
+| RT-14 | [#17550](https://github.com/dotnet/maui/issues/17550) | Deferred iOS/MacCatalyst handler | Native nav-bar test | Visibility toggles immediately. |
+| RT-15 | [#14377](https://github.com/dotnet/maui/issues/14377) | Deferred Windows layout | WinUI ScrollView device test | Unchanged-size child is rearranged after property change. |
+| RT-16 | [#2153](https://github.com/dotnet/maui/issues/2153) | Deferred image handler/device | Native Image rerender test | Visual source/property change renders without size/Aspect nudge. |
+| INFRA-01 | [#20669](https://github.com/dotnet/maui/issues/20669) | Deferred project integration | Blazor Hybrid template/watch test | XAML edit applies with `BlazorWebView` present. |
+| REJECT-01 | [#21387](https://github.com/dotnet/maui/issues/21387) | Rejected/non-HR | ResourceDictionary framework backlog | Code-behind-only repro; no HR edit. |
diff --git a/src/Controls/tests/SourceGen.UnitTests/HotReload/AiAssisted/ResourceAndThemeHotReloadTests.AppThemeBinding.cs b/src/Controls/tests/SourceGen.UnitTests/HotReload/AiAssisted/ResourceAndThemeHotReloadTests.AppThemeBinding.cs
new file mode 100644
index 000000000000..1f8d15ec40bf
--- /dev/null
+++ b/src/Controls/tests/SourceGen.UnitTests/HotReload/AiAssisted/ResourceAndThemeHotReloadTests.AppThemeBinding.cs
@@ -0,0 +1,53 @@
+#nullable enable
+
+using System;
+using System.Collections.Generic;
+using System.Globalization;
+using System.Linq;
+using Microsoft.CodeAnalysis;
+using Microsoft.Maui.ApplicationModel;
+using Microsoft.Maui.Controls.SourceGen.UnitTests.HotReload;
+using Microsoft.Maui.Graphics;
+using Xunit;
+
+namespace Microsoft.Maui.Controls.SourceGen.UnitTests.HotReload.AiAssisted;
+
+public partial class ResourceAndThemeHotReloadTests
+{
+	// Wave2 · Resources · family-4 · RT-08 (generation-atomic anchor)
+	// Provenance: MAUI §3.4 (AppThemeBinding); public-app T18
+	// Faithfulness: strongest faithful level the harness supports for an AppThemeBinding branch edit.
+	// It proves the edit and its exact revert are captured in the generated component and that every
+	// version compiles: the Light branch literal moves Light1→Light2→Light1 across versions while the
+	// Dark branch is left untouched. Live re-provision of the edited AppThemeBinding remains deferred
+	// under #36732 because the current UpdateComponent path supplies an IProvideValueTarget whose
+	// TargetProperty is null, so product code cannot run it faithfully in this harness.
+	[Fact]
+	public void AppThemeBinding_BranchEdit_IsCapturedInGeneratedComponent()
+	{
+		string Xaml(string lightBranch) => $$"""
+			<ContentPage xmlns="http://schemas.microsoft.com/dotnet/2021/maui"
+			             xmlns:x="http://schemas.microsoft.com/winfx/2009/xaml"
+			             x:Class="TestAiAssisted.MainPage">
+			  <Label Text="{AppThemeBinding Light={{lightBranch}}, Dark=DarkText}" />
+			</ContentPage>
+			""";
+
+		using var harness = CreateHarness(nameof(AppThemeBinding_BranchEdit_IsCapturedInGeneratedComponent));
+		// V1: Light=Light1. V2: only the Light branch is edited to Light2. V3: exact revert of V1.
+		var generation = harness.Generate(Xaml("Light1"), Xaml("Light2"), Xaml("Light1"));
+
+		for (var index = 0; index < 3; index++)
+		{
+			Assert.NotNull(generation[index].InitializeComponentSource);
+			Assert.Contains("\"DarkText\"", generation[index].InitializeComponentSource!, StringComparison.Ordinal);
+			Assert.True(harness.Compile(generation[index]).PeImage.Length > 0);
+		}
+
+		// The edited Light branch is captured in V2 and exactly reverted in V3; Dark stays untouched.
+		Assert.Contains("Light = \"Light1\"", generation[0].InitializeComponentSource!, StringComparison.Ordinal);
+		Assert.Contains("Light = \"Light2\"", generation[1].InitializeComponentSource!, StringComparison.Ordinal);
+		Assert.Contains("Light = \"Light1\"", generation[2].InitializeComponentSource!, StringComparison.Ordinal);
+		Assert.DoesNotContain("Light = \"Light2\"", generation[2].InitializeComponentSource!, StringComparison.Ordinal);
+	}
+}
diff --git a/src/Controls/tests/SourceGen.UnitTests/HotReload/AiAssisted/ResourceAndThemeHotReloadTests.DynamicResources.cs b/src/Controls/tests/SourceGen.UnitTests/HotReload/AiAssisted/ResourceAndThemeHotReloadTests.DynamicResources.cs
new file mode 100644
index 000000000000..da6ce99eb2f1
--- /dev/null
+++ b/src/Controls/tests/SourceGen.UnitTests/HotReload/AiAssisted/ResourceAndThemeHotReloadTests.DynamicResources.cs
@@ -0,0 +1,150 @@
+#nullable enable
+
+using System;
+using System.Collections.Generic;
+using System.Globalization;
+using System.Linq;
+using Microsoft.CodeAnalysis;
+using Microsoft.Maui.ApplicationModel;
+using Microsoft.Maui.Controls.SourceGen.UnitTests.HotReload;
+using Microsoft.Maui.Graphics;
+using Xunit;
+
+namespace Microsoft.Maui.Controls.SourceGen.UnitTests.HotReload.AiAssisted;
+
+public partial class ResourceAndThemeHotReloadTests
+{
+	// Wave2 · Resources · P0-10 · RT-01
+	// Provenance: MAUI §1.4; public-app T6
+	// Faithfulness: reaches DynamicResource markup path (UpdateComponentCodeWriter ~L1548,
+	// TryEmitExpandedMarkupExtension) + keyed-scalar resource patch; fails if the value is not
+	// re-resolved against the renamed key on live update.
+	[MetadataUpdateTheory]
+	[InlineData("TextColor", "Color", "Color", "Red", "Blue")]
+	[InlineData("FontSize", "x:Double", "Double", "20", "30")]
+	[InlineData("Text", "x:String", "String", "Hello", "World")]
+	public void DynamicResourceKey_RenameAndReverse_UpdatesVisibleValue(
+		string propertyName, string resourceTag, string clrKind, string valueA, string valueB)
+	{
+		string Xaml(string resourceKey, string resourceValue, string consumerKey) => $$"""
+			<ContentPage xmlns="http://schemas.microsoft.com/dotnet/2021/maui"
+			             xmlns:x="http://schemas.microsoft.com/winfx/2009/xaml"
+			             x:Class="TestAiAssisted.MainPage">
+			  <ContentPage.Resources>
+			    <{{resourceTag}} x:Key="{{resourceKey}}">{{resourceValue}}</{{resourceTag}}>
+			  </ContentPage.Resources>
+			  <Label {{propertyName}}="{DynamicResource {{consumerKey}}}" />
+			</ContentPage>
+			""";
+
+		// V1: K1 = A, consumer binds to K1.
+		var xamlV1 = Xaml("K1", valueA, "K1");
+		// V2: resource renamed to K2 = B, consumer follows the rename.
+		var xamlV2 = Xaml("K2", valueB, "K2");
+		// V3: exact revert of V1 (K1 = A again).
+		var xamlV3 = Xaml("K1", valueA, "K1");
+
+		object Parse(string raw) => clrKind switch
+		{
+			"Color" => Color.Parse(raw),
+			"Double" => double.Parse(raw, CultureInfo.InvariantCulture),
+			"String" => raw,
+			_ => throw new NotSupportedException(clrKind),
+		};
+
+		object? GetPropertyValue(Label label) =>
+			typeof(Label).GetProperty(propertyName)!.GetValue(label);
+
+		using var harness = CreateHarness(nameof(DynamicResourceKey_RenameAndReverse_UpdatesVisibleValue) + "_" + propertyName);
+		var generation = harness.Generate(xamlV1, xamlV2, xamlV3);
+
+		harness.RunLive(generation, live =>
+		{
+			var page = live.GetInstance<ContentPage>();
+			var label = Assert.IsType<Label>(page.Content);
+
+			Assert.Equal(Parse(valueA), GetPropertyValue(label));
+			Assert.True(page.Resources.ContainsKey("K1"));
+			Assert.False(page.Resources.ContainsKey("K2"));
+
+			live.ApplyUpdate<ContentPage>(1);
+			Assert.Equal(Parse(valueB), GetPropertyValue(label));
+			Assert.False(page.Resources.ContainsKey("K1"));
+			Assert.True(page.Resources.ContainsKey("K2"));
+
+			live.ApplyUpdate<ContentPage>(2);
+			Assert.Equal(Parse(valueA), GetPropertyValue(label));
+			Assert.True(page.Resources.ContainsKey("K1"));
+			Assert.False(page.Resources.ContainsKey("K2"));
+		});
+	}
+
+	// Wave2 · Resources · P1-04 · RT-09
+	// Provenance: MAUI §3.1 (App.xaml DynamicResource); public-app T16
+	// Faithfulness: application-scope DynamicResource fanout across two retained roots plus one fresh
+	// post-update root, under a live Application host (cap-app-host + cap-multi-instance). The harness
+	// regenerates the page (not App.xaml), so the visible Red→Blue→Red transition is realized by hot-
+	// reloading the consumer's DynamicResource *key* across two application-scoped keys (AccentA=Red,
+	// AccentB=Blue). This exercises app-scope resolution (ResourcesExtensions.TryGetResource, including
+	// the Application.Current fallback for not-yet-attached roots), multi-instance UpdateComponent
+	// fanout to every retained root, and fresh-root-starts-latest without replay. The application
+	// ResourceDictionary object identity is asserted stable across the page updates. Fails if a
+	// retained root is not re-resolved, a fresh root replays history, or the app dictionary is swapped.
+	[MetadataUpdateFact]
+	public void ApplicationDynamicResource_FansOutAndFreshRootsStartLatest()
+	{
+		string Xaml(string key) => $$"""
+			<ContentPage xmlns="http://schemas.microsoft.com/dotnet/2021/maui"
+			             xmlns:x="http://schemas.microsoft.com/winfx/2009/xaml"
+			             x:Class="TestAiAssisted.MainPage">
+			  <Label TextColor="{DynamicResource {{key}}}" />
+			</ContentPage>
+			""";
+
+		var xamlV1 = Xaml("AccentA"); // resolves app AccentA = Red
+		var xamlV2 = Xaml("AccentB"); // resolves app AccentB = Blue
+		var xamlV3 = Xaml("AccentA"); // reverts to Red
+
+		var options = new XamlHotReloadApplicationOptions(new Dictionary<string, object>
+		{
+			["AccentA"] = Colors.Red,
+			["AccentB"] = Colors.Blue,
+		});
+
+		using var harness = CreateHostedHarness(
+			options, nameof(ApplicationDynamicResource_FansOutAndFreshRootsStartLatest));
+		var generation = harness.Generate(xamlV1, xamlV2, xamlV3);
+
+		harness.RunLive(generation, live =>
+		{
+			var appResources = harness.ApplicationHost!.Application.Resources;
+
+			var first = live.GetInstance<ContentPage>();       // attached as the single MainPage
+			var second = live.CreateInstance<ContentPage>();   // retained, not attached
+			var firstLabel = Assert.IsType<Label>(first.Content);
+			var secondLabel = Assert.IsType<Label>(second.Content);
+			Assert.Equal(Colors.Red, firstLabel.TextColor);
+			Assert.Equal(Colors.Red, secondLabel.TextColor);
+
+			// V2: both retained roots re-resolve to the application AccentB (Blue) value, once each.
+			live.ApplyUpdate<ContentPage>(1);
+			Assert.Equal(Colors.Blue, firstLabel.TextColor);
+			Assert.Equal(Colors.Blue, secondLabel.TextColor);
+
+			// A fresh root created after V2 starts at the latest version (Blue), without replaying V1.
+			var third = live.CreateInstance<ContentPage>();
+			Assert.Equal(Colors.Blue, Assert.IsType<Label>(third.Content).TextColor);
+
+			// V3: reverse; every retained root — including the fresh one — tracks back to Red.
+			live.ApplyUpdate<ContentPage>(2);
+			Assert.Equal(Colors.Red, firstLabel.TextColor);
+			Assert.Equal(Colors.Red, secondLabel.TextColor);
+			Assert.Equal(Colors.Red, Assert.IsType<Label>(third.Content).TextColor);
+
+			// The application dictionary was never mutated or swapped by the page updates.
+			Assert.Same(appResources, harness.ApplicationHost!.Application.Resources);
+			Assert.Equal(Colors.Red, (Color)appResources["AccentA"]);
+			Assert.Equal(Colors.Blue, (Color)appResources["AccentB"]);
+		});
+	}
+}
diff --git a/src/Controls/tests/SourceGen.UnitTests/HotReload/AiAssisted/ResourceAndThemeHotReloadTests.MergedDictionaries.cs b/src/Controls/tests/SourceGen.UnitTests/HotReload/AiAssisted/ResourceAndThemeHotReloadTests.MergedDictionaries.cs
new file mode 100644
index 000000000000..91b923874099
--- /dev/null
+++ b/src/Controls/tests/SourceGen.UnitTests/HotReload/AiAssisted/ResourceAndThemeHotReloadTests.MergedDictionaries.cs
@@ -0,0 +1,243 @@
+#nullable enable
+
+using System;
+using System.Collections.Generic;
+using System.Globalization;
+using System.Linq;
+using Microsoft.CodeAnalysis;
+using Microsoft.Maui.ApplicationModel;
+using Microsoft.Maui.Controls.SourceGen.UnitTests.HotReload;
+using Microsoft.Maui.Graphics;
+using Xunit;
+
+namespace Microsoft.Maui.Controls.SourceGen.UnitTests.HotReload.AiAssisted;
+
+public partial class ResourceAndThemeHotReloadTests
+{
+	// Wave2 · Resources · P0-09 · RT-02
+	// Provenance: MAUI §1.1; public-app T1/T3
+	// Faithfulness: reaches the generic complex-property skip path (UpdateComponentCodeWriter
+	// ~L1194) for a non-root element's Resources property; fails (i.e. reclassify to GREEN) if the
+	// writer ever starts emitting real merged-dictionary patch code for this shape.
+	// Expected: DOC-SKIP-GUARD
+	[Fact]
+	public void MergedDictionaries_ComplexProperty_EmitsSkipMarker()
+	{
+		// Root ContentPage.Resources is special-cased by the writer (it always resolves via
+		// TryEmitResourceDictionaryChange and never falls through to the generic marker below),
+		// so this guard targets a non-root element's Resources — the shape that is empirically
+		// declined via the generic complex-property path.
+		const string xamlV1 = """
+			<ContentPage xmlns="http://schemas.microsoft.com/dotnet/2021/maui"
+			             xmlns:x="http://schemas.microsoft.com/winfx/2009/xaml"
+			             x:Class="TestAiAssisted.MainPage">
+			  <VerticalStackLayout>
+			    <VerticalStackLayout.Resources>
+			      <ResourceDictionary>
+			        <ResourceDictionary.MergedDictionaries>
+			          <ResourceDictionary>
+			            <Color x:Key="Accent">Red</Color>
+			          </ResourceDictionary>
+			          <ResourceDictionary>
+			            <Color x:Key="Accent">Blue</Color>
+			          </ResourceDictionary>
+			        </ResourceDictionary.MergedDictionaries>
+			      </ResourceDictionary>
+			    </VerticalStackLayout.Resources>
+			    <Label TextColor="{DynamicResource Accent}" />
+			  </VerticalStackLayout>
+			</ContentPage>
+			""";
+		const string xamlV2 = """
+			<ContentPage xmlns="http://schemas.microsoft.com/dotnet/2021/maui"
+			             xmlns:x="http://schemas.microsoft.com/winfx/2009/xaml"
+			             x:Class="TestAiAssisted.MainPage">
+			  <VerticalStackLayout>
+			    <VerticalStackLayout.Resources>
+			      <ResourceDictionary>
+			        <ResourceDictionary.MergedDictionaries>
+			          <ResourceDictionary>
+			            <Color x:Key="Accent">Blue</Color>
+			          </ResourceDictionary>
+			          <ResourceDictionary>
+			            <Color x:Key="Accent">Red</Color>
+			          </ResourceDictionary>
+			        </ResourceDictionary.MergedDictionaries>
+			      </ResourceDictionary>
+			    </VerticalStackLayout.Resources>
+			    <Label TextColor="{DynamicResource Accent}" />
+			  </VerticalStackLayout>
+			</ContentPage>
+			""";
+
+		using var harness = CreateHarness(nameof(MergedDictionaries_ComplexProperty_EmitsSkipMarker));
+		var generation = harness.Generate(xamlV1, xamlV2);
+		var updateComponentSource = generation[1].UpdateComponentSource;
+
+		Assert.NotNull(updateComponentSource);
+		Assert.Contains("// Complex property 'Resources' (ElementNode) \u2014 skipped (not yet supported)", updateComponentSource!, StringComparison.Ordinal);
+	}
+
+	// Wave2 · Resources · P1-01 · RT-10 (generator/compile-atomic anchor)
+	// Provenance: MAUI §3.1 (Source= merged dictionaries); public-app T13
+	// Faithfulness: strongest faithful level the harness supports for Source= merged dictionaries.
+	// It tracks the reorder then removal of the Source= sibling documents and recompiles the page in
+	// every version (mirrors HarnessCapabilityTests.MultiDocument_DictionaryOnlyEdit_TracksAllDocuments
+	// AndCompilesPage). The live runtime cannot reload a Source= dictionary into a retained page in this
+	// in-memory generator/ALC harness, so this PR intentionally stops at document-tracking/compile coverage.
+	[Fact]
+	public void SourceMergedDictionaries_ReorderThenRemove_TracksDocumentsAndCompiles()
+	{
+		string Page(string mergedBody) => $$"""
+			<ContentPage xmlns="http://schemas.microsoft.com/dotnet/2021/maui"
+			             xmlns:x="http://schemas.microsoft.com/winfx/2009/xaml"
+			             x:Class="TestAiAssisted.MainPage">
+			  <ContentPage.Resources>
+			    <ResourceDictionary>
+			      <ResourceDictionary.MergedDictionaries>
+			{{mergedBody}}
+			      </ResourceDictionary.MergedDictionaries>
+			    </ResourceDictionary>
+			  </ContentPage.Resources>
+			  <Label TextColor="{DynamicResource Accent}" />
+			</ContentPage>
+			""";
+
+		const string sourceA = "        <ResourceDictionary Source=\"A.xaml\" />";
+		const string sourceB = "        <ResourceDictionary Source=\"B.xaml\" />";
+		const string dictA = """
+			<ResourceDictionary xmlns="http://schemas.microsoft.com/dotnet/2021/maui"
+			                    xmlns:x="http://schemas.microsoft.com/winfx/2009/xaml">
+			  <Color x:Key="Accent">Red</Color>
+			</ResourceDictionary>
+			""";
+		const string dictB = """
+			<ResourceDictionary xmlns="http://schemas.microsoft.com/dotnet/2021/maui"
+			                    xmlns:x="http://schemas.microsoft.com/winfx/2009/xaml">
+			  <Color x:Key="Accent">Blue</Color>
+			</ResourceDictionary>
+			""";
+
+		IReadOnlyDictionary<string, XamlHotReloadDocument> Snapshot(string mergedBody, bool includeA)
+		{
+			var snapshot = new Dictionary<string, XamlHotReloadDocument>(StringComparer.Ordinal)
+			{
+				["MainPage.xaml"] = new XamlHotReloadDocument(Page(mergedBody)),
+				["B.xaml"] = new XamlHotReloadDocument(dictB),
+			};
+			if (includeA)
+				snapshot["A.xaml"] = new XamlHotReloadDocument(dictA);
+			return snapshot;
+		}
+
+		using var harness = CreateHarness(nameof(SourceMergedDictionaries_ReorderThenRemove_TracksDocumentsAndCompiles));
+		var generation = harness.GenerateDocuments(
+			Snapshot(sourceA + "\n" + sourceB, includeA: true),   // V1: A;B
+			Snapshot(sourceB + "\n" + sourceA, includeA: true),   // V2: B;A (reorder)
+			Snapshot(sourceB, includeA: false));                  // V3: B only (A removed)
+
+		// Reorder and removal of the Source= sibling documents are visible to the harness.
+		Assert.True(generation[0].Documents.ContainsKey("A.xaml"));
+		Assert.True(generation[1].Documents.ContainsKey("A.xaml"));
+		Assert.False(generation[2].Documents.ContainsKey("A.xaml"));
+
+		// The page owns exactly one generated root and compiles in every version.
+		for (var index = 0; index < 3; index++)
+		{
+			Assert.Single(generation[index].GeneratedRoots);
+			Assert.Equal(PageClass, generation[index].GeneratedRoots[0].TypeName);
+			Assert.True(harness.Compile(generation[index]).PeImage.Length > 0);
+		}
+	}
+
+	// Wave2 · Resources · P1-05 · RT-11
+	// Provenance: MAUI §3.1/§3.5 (multi-document malformed→repair); public-app T14
+	// Faithfulness: multi-document malformed→repair atomicity at the strongest faithful level the
+	// harness supports — GENERATOR-ATOMIC, NOT live-resource atomic. The batch carries two
+	// AdditionalTexts (MainPage.xaml + a sibling Theme.xaml resource dictionary). Source= cannot be
+	// used to wire the page to the dictionary in this in-memory generator/ALC harness (it emits an
+	// unconditional MAUIG1001 "not a valid resource path" — the same boundary proven by RT-10), so the
+	// malformed edit is applied to the generator-parsed document (MainPage.xaml) while the sibling
+	// dictionary is carried unchanged through the whole batch. The atomicity invariant asserted here:
+	// a malformed intermediate version surfaces a parser error and does NOT phantom-advance to a valid
+	// compiled page, and the repaired version fully recovers (generates the repaired content and
+	// compiles), with the sibling document tracked across every version. The LIVE retained-object
+	// atomic reload of a Source= dictionary is out of harness scope, hence generator-atomic labeling.
+	// Fails if a malformed batch silently produces a compilable page, if the repaired batch does not
+	// generate/compile, or if the sibling document is dropped.
+	[Fact]
+	public void MultiDocumentMalformedThenRepair_IsAtomicAcrossPageAndDictionary()
+	{
+		const string pageValidBefore = """
+			<ContentPage xmlns="http://schemas.microsoft.com/dotnet/2021/maui"
+			             xmlns:x="http://schemas.microsoft.com/winfx/2009/xaml"
+			             x:Class="TestAiAssisted.MainPage">
+			  <Label Text="Before" />
+			</ContentPage>
+			""";
+		// V2: the <Label> element is never closed — a parser error in the page document.
+		const string pageMalformed = """
+			<ContentPage xmlns="http://schemas.microsoft.com/dotnet/2021/maui"
+			             xmlns:x="http://schemas.microsoft.com/winfx/2009/xaml"
+			             x:Class="TestAiAssisted.MainPage">
+			  <Label Text="AfterRepair"
+			</ContentPage>
+			""";
+		const string pageRepaired = """
+			<ContentPage xmlns="http://schemas.microsoft.com/dotnet/2021/maui"
+			             xmlns:x="http://schemas.microsoft.com/winfx/2009/xaml"
+			             x:Class="TestAiAssisted.MainPage">
+			  <Label Text="AfterRepair" />
+			</ContentPage>
+			""";
+
+		// The sibling dictionary is a valid resource document carried unchanged across every version.
+		const string theme = """
+			<ResourceDictionary xmlns="http://schemas.microsoft.com/dotnet/2021/maui"
+			                    xmlns:x="http://schemas.microsoft.com/winfx/2009/xaml">
+			  <Color x:Key="Accent">Blue</Color>
+			</ResourceDictionary>
+			""";
+
+		IReadOnlyDictionary<string, XamlHotReloadDocument> Snapshot(string page) =>
+			new Dictionary<string, XamlHotReloadDocument>(StringComparer.Ordinal)
+			{
+				["MainPage.xaml"] = new XamlHotReloadDocument(page),
+				["Theme.xaml"] = new XamlHotReloadDocument(theme),
+			};
+
+		using var harness = CreateHarness(nameof(MultiDocumentMalformedThenRepair_IsAtomicAcrossPageAndDictionary));
+		var generation = harness.GenerateDocumentsAllowingDiagnostics(
+			Snapshot(pageValidBefore),
+			Snapshot(pageMalformed),
+			Snapshot(pageRepaired));
+
+		// The sibling dictionary document is tracked through the malformed→repair batch, unchanged.
+		Assert.True(generation[0].Documents.ContainsKey("Theme.xaml"));
+		Assert.True(generation[1].Documents.ContainsKey("Theme.xaml"));
+		Assert.True(generation[2].Documents.ContainsKey("Theme.xaml"));
+		Assert.Equal(theme, generation[2].Documents["Theme.xaml"].Text);
+
+		// V1: both documents valid — the page generates and compiles.
+		Assert.DoesNotContain(
+			generation[0].GeneratorResult.Diagnostics,
+			diagnostic => diagnostic.Severity == DiagnosticSeverity.Error);
+		Assert.NotNull(generation[0].InitializeComponentSource);
+		Assert.True(harness.Compile(generation[0]).PeImage.Length > 0);
+
+		// V2: the malformed page surfaces at least one parser error diagnostic and does NOT
+		// phantom-advance to a valid compiled page.
+		Assert.Contains(
+			generation[1].GeneratorResult.Diagnostics,
+			diagnostic => diagnostic.Severity == DiagnosticSeverity.Error);
+		Assert.Null(generation[1].InitializeComponentSource);
+
+		// V3: the page is repaired — it generates the repaired content and compiles cleanly.
+		Assert.DoesNotContain(
+			generation[2].GeneratorResult.Diagnostics,
+			diagnostic => diagnostic.Severity == DiagnosticSeverity.Error);
+		Assert.NotNull(generation[2].InitializeComponentSource);
+		Assert.Contains("AfterRepair", generation[2].InitializeComponentSource!, StringComparison.Ordinal);
+		Assert.True(harness.Compile(generation[2]).PeImage.Length > 0);
+	}
+}
diff --git a/src/Controls/tests/SourceGen.UnitTests/HotReload/AiAssisted/ResourceAndThemeHotReloadTests.Styles.cs b/src/Controls/tests/SourceGen.UnitTests/HotReload/AiAssisted/ResourceAndThemeHotReloadTests.Styles.cs
new file mode 100644
index 000000000000..85f14ba1f104
--- /dev/null
+++ b/src/Controls/tests/SourceGen.UnitTests/HotReload/AiAssisted/ResourceAndThemeHotReloadTests.Styles.cs
@@ -0,0 +1,118 @@
+#nullable enable
+
+using System;
+using System.Collections.Generic;
+using System.Globalization;
+using System.Linq;
+using Microsoft.CodeAnalysis;
+using Microsoft.Maui.ApplicationModel;
+using Microsoft.Maui.Controls.SourceGen.UnitTests.HotReload;
+using Microsoft.Maui.Graphics;
+using Xunit;
+
+namespace Microsoft.Maui.Controls.SourceGen.UnitTests.HotReload.AiAssisted;
+
+public partial class ResourceAndThemeHotReloadTests
+{
+	// Wave2 · Resources · P0-13 · RT-04
+	// Provenance: toolkit T31/T32; public-app T10/T11
+	// Faithfulness: reaches the resource-dictionary keyed-encode path (UpdateComponentCodeWriter
+	// ~L929, BuildResourceValueExpression); Style has no public parameterless constructor so it
+	// always fails encoding and is left untouched. Fails (i.e. reclassify to GREEN) if the writer
+	// ever gains a Style-aware resource-value builder.
+	// Expected: DOC-SKIP-GUARD
+	[Fact]
+	public void BasedOnStyle_ComplexResource_EmitsSkipMarker()
+	{
+		const string xamlV1 = """
+			<ContentPage xmlns="http://schemas.microsoft.com/dotnet/2021/maui"
+			             xmlns:x="http://schemas.microsoft.com/winfx/2009/xaml"
+			             x:Class="TestAiAssisted.MainPage">
+			  <ContentPage.Resources>
+			      <Style x:Key="BaseA" TargetType="Label">
+			        <Setter Property="TextColor" Value="Red" />
+			      </Style>
+			      <Style x:Key="BaseB" TargetType="Label">
+			        <Setter Property="TextColor" Value="Blue" />
+			      </Style>
+			      <Style x:Key="Derived" TargetType="Label" BasedOn="{StaticResource BaseA}" />
+			  </ContentPage.Resources>
+			  <Label Style="{StaticResource Derived}" />
+			</ContentPage>
+			""";
+		const string xamlV2 = """
+			<ContentPage xmlns="http://schemas.microsoft.com/dotnet/2021/maui"
+			             xmlns:x="http://schemas.microsoft.com/winfx/2009/xaml"
+			             x:Class="TestAiAssisted.MainPage">
+			  <ContentPage.Resources>
+			      <Style x:Key="BaseA" TargetType="Label">
+			        <Setter Property="TextColor" Value="Red" />
+			      </Style>
+			      <Style x:Key="BaseB" TargetType="Label">
+			        <Setter Property="TextColor" Value="Blue" />
+			      </Style>
+			      <Style x:Key="Derived" TargetType="Label" BasedOn="{StaticResource BaseB}" />
+			  </ContentPage.Resources>
+			  <Label Style="{StaticResource Derived}" />
+			</ContentPage>
+			""";
+
+		using var harness = CreateHarness(nameof(BasedOnStyle_ComplexResource_EmitsSkipMarker));
+		var generation = harness.Generate(xamlV1, xamlV2);
+		var updateComponentSource = generation[1].UpdateComponentSource;
+
+		Assert.NotNull(updateComponentSource);
+		Assert.Contains("// Cannot encode resource 'Derived' \u2014 left untouched", updateComponentSource!, StringComparison.Ordinal);
+	}
+	// Wave2 · Resources · P0-05 · RT-06
+	// Provenance: MAUI §3.2/3.3; public-app T15
+	// Faithfulness: reaches the generic complex-property skip path (UpdateComponentCodeWriter
+	// ~L1194) for an inline Label.Style replacement; fails (i.e. reclassify to GREEN) if the
+	// writer ever starts emitting real inline-Style patch code.
+	// Expected: DOC-SKIP-GUARD
+	[Fact]
+	public void TriggeredStyle_ComplexProperty_EmitsSkipMarker()
+	{
+		const string xamlV1 = """
+			<ContentPage xmlns="http://schemas.microsoft.com/dotnet/2021/maui"
+			             xmlns:x="http://schemas.microsoft.com/winfx/2009/xaml"
+			             x:Class="TestAiAssisted.MainPage">
+			  <Label Text="Fallback" IsEnabled="False">
+			    <Label.Style>
+			      <Style TargetType="Label">
+			        <Style.Triggers>
+			          <Trigger TargetType="Label" Property="IsEnabled" Value="False">
+			            <Setter Property="Text" Value="V1Active" />
+			          </Trigger>
+			        </Style.Triggers>
+			      </Style>
+			    </Label.Style>
+			  </Label>
+			</ContentPage>
+			""";
+		const string xamlV2 = """
+			<ContentPage xmlns="http://schemas.microsoft.com/dotnet/2021/maui"
+			             xmlns:x="http://schemas.microsoft.com/winfx/2009/xaml"
+			             x:Class="TestAiAssisted.MainPage">
+			  <Label Text="Fallback" IsEnabled="False">
+			    <Label.Style>
+			      <Style TargetType="Label">
+			        <Style.Triggers>
+			          <Trigger TargetType="Label" Property="IsEnabled" Value="False">
+			            <Setter Property="Text" Value="V3Active" />
+			          </Trigger>
+			        </Style.Triggers>
+			      </Style>
+			    </Label.Style>
+			  </Label>
+			</ContentPage>
+			""";
+
+		using var harness = CreateHarness(nameof(TriggeredStyle_ComplexProperty_EmitsSkipMarker));
+		var generation = harness.Generate(xamlV1, xamlV2);
+		var updateComponentSource = generation[1].UpdateComponentSource;
+
+		Assert.NotNull(updateComponentSource);
+		Assert.Contains("// Complex property 'Style' (ElementNode) \u2014 skipped (not yet supported)", updateComponentSource!, StringComparison.Ordinal);
+	}
+}
diff --git a/src/Controls/tests/SourceGen.UnitTests/HotReload/AiAssisted/ResourceAndThemeHotReloadTests.cs b/src/Controls/tests/SourceGen.UnitTests/HotReload/AiAssisted/ResourceAndThemeHotReloadTests.cs
new file mode 100644
index 000000000000..5b96b55d19f9
--- /dev/null
+++ b/src/Controls/tests/SourceGen.UnitTests/HotReload/AiAssisted/ResourceAndThemeHotReloadTests.cs
@@ -0,0 +1,49 @@
+#nullable enable
+
+using System;
+using System.Collections.Generic;
+using System.Globalization;
+using System.Linq;
+using Microsoft.CodeAnalysis;
+using Microsoft.Maui.ApplicationModel;
+using Microsoft.Maui.Controls.SourceGen.UnitTests.HotReload;
+using Microsoft.Maui.Graphics;
+using Xunit;
+
+namespace Microsoft.Maui.Controls.SourceGen.UnitTests.HotReload.AiAssisted;
+
+// Wave2 scope note: this file owns RT-01..RT-11 for the resources/theme portfolio.
+// RT-01..RT-07 cover resource dictionaries, keyed styles, BasedOn styles and triggered styles.
+// RT-08..RT-11 (Phase-2) cover AppThemeBinding branch edits, application-scope DynamicResource
+// fanout, and multi-document (Source= merged dictionary / malformed->repair) scenarios; they rely
+// on the Phase-0/1 harness capabilities cap-app-host, cap-theme-flip, cap-multi-instance and
+// cap-multi-doc. Where the harness cannot faithfully reach a live invariant (for example Source=
+// dictionaries in this in-memory generator/ALC harness), this PR stops at the strongest faithful
+// passing level and records the deferred follow-up in the README/issue ledger instead of checking in
+// skip-gated probes.
+[Collection("XamlHotReloadTests")]
+public partial class ResourceAndThemeHotReloadTests
+{
+	const string PageClass = "TestAiAssisted.MainPage";
+
+	const string PageStub = """
+		namespace TestAiAssisted;
+
+		public partial class MainPage : global::Microsoft.Maui.Controls.ContentPage
+		{
+			private partial void InitializeComponent();
+
+			public MainPage()
+			{
+				InitializeComponent();
+			}
+		}
+		""";
+
+	static XamlHotReloadTestHarness CreateHarness(string scenarioName) =>
+		new(scenarioName, PageClass, PageStub);
+
+	static XamlHotReloadTestHarness CreateHostedHarness(
+		XamlHotReloadApplicationOptions options, string scenarioName) =>
+		new(scenarioName, PageClass, PageStub, options);
+}
diff --git a/src/Controls/tests/SourceGen.UnitTests/HotReload/AiAssisted/StructuralHotReloadTests.cs b/src/Controls/tests/SourceGen.UnitTests/HotReload/AiAssisted/StructuralHotReloadTests.cs
new file mode 100644
index 000000000000..19f27bbfefa9
--- /dev/null
+++ b/src/Controls/tests/SourceGen.UnitTests/HotReload/AiAssisted/StructuralHotReloadTests.cs
@@ -0,0 +1,331 @@
+#nullable enable
+
+using System;
+using System.Linq;
+using System.Runtime.CompilerServices;
+using Microsoft.Maui.Controls.SourceGen.UnitTests.HotReload;
+using Xunit;
+
+namespace Microsoft.Maui.Controls.SourceGen.UnitTests.HotReload.AiAssisted;
+
+[Collection("XamlHotReloadTests")]
+public class StructuralHotReloadTests
+{
+	const string PageClass = "TestAiAssisted.MainPage";
+
+	const string PageStub = """
+		namespace TestAiAssisted;
+
+		public partial class MainPage : global::Microsoft.Maui.Controls.ContentPage
+		{
+			private partial void InitializeComponent();
+
+			public void InitializeComponentRuntime() { }
+
+			public MainPage()
+			{
+				InitializeComponent();
+			}
+		}
+		""";
+
+	const string ConverterStub = """
+		namespace TestAiAssisted;
+
+		public sealed class TestConverter : global::Microsoft.Maui.Controls.IValueConverter
+		{
+			public object? Convert(object? value, global::System.Type targetType, object? parameter, global::System.Globalization.CultureInfo culture) => value;
+
+			public object? ConvertBack(object? value, global::System.Type targetType, object? parameter, global::System.Globalization.CultureInfo culture) => value;
+		}
+		""";
+
+	static XamlHotReloadTestHarness CreateHarness([CallerMemberName] string scenarioName = "") =>
+		new(scenarioName, PageClass, PageStub);
+
+	[Fact]
+	public void RootComplexElementProperty_IsNotSilentlyDropped()
+	{
+		const string xamlV1 = """
+			<ContentPage xmlns="http://schemas.microsoft.com/dotnet/2021/maui"
+			             xmlns:x="http://schemas.microsoft.com/winfx/2009/xaml"
+			             x:Class="TestAiAssisted.MainPage">
+			  <Label Text="Before" />
+			</ContentPage>
+			""";
+		const string xamlV2 = """
+			<ContentPage xmlns="http://schemas.microsoft.com/dotnet/2021/maui"
+			             xmlns:x="http://schemas.microsoft.com/winfx/2009/xaml"
+			             x:Class="TestAiAssisted.MainPage">
+			  <CollectionView>
+			    <CollectionView.ItemTemplate>
+			      <DataTemplate>
+			        <Label Text="After" />
+			      </DataTemplate>
+			    </CollectionView.ItemTemplate>
+			  </CollectionView>
+			</ContentPage>
+			""";
+
+		// https://github.com/dotnet/maui/issues/36256 originally emitted an invalid root-content cast;
+		// its replacement-root path also skipped the complex ItemTemplate property, so assert its generated shape.
+		using var harness = CreateHarness();
+		var generation = harness.Generate(xamlV1, xamlV2);
+		var updateComponentSource = generation[1].UpdateComponentSource;
+
+		Assert.NotNull(updateComponentSource);
+		Assert.DoesNotContain("skipped (not yet supported)", updateComponentSource!, StringComparison.Ordinal);
+		Assert.Contains("new global::Microsoft.Maui.Controls.DataTemplate", updateComponentSource!, StringComparison.Ordinal);
+		Assert.Contains(".ItemTemplateProperty", updateComponentSource!, StringComparison.Ordinal);
+
+		var compilation = harness.Compile(generation[1]);
+		Assert.True(compilation.PeImage.Length > 0, "Generated V2 UpdateComponent should compile.");
+	}
+
+	[MetadataUpdateFact]
+	public void RootComplexElementProperty_AppliesToExistingPage()
+	{
+		const string xamlV1 = """
+			<ContentPage xmlns="http://schemas.microsoft.com/dotnet/2021/maui"
+			             xmlns:x="http://schemas.microsoft.com/winfx/2009/xaml"
+			             x:Class="TestAiAssisted.MainPage">
+			  <Label Text="Before" />
+			</ContentPage>
+			""";
+		const string xamlV2 = """
+			<ContentPage xmlns="http://schemas.microsoft.com/dotnet/2021/maui"
+			             xmlns:x="http://schemas.microsoft.com/winfx/2009/xaml"
+			             x:Class="TestAiAssisted.MainPage">
+			  <CollectionView>
+			    <CollectionView.ItemTemplate>
+			      <DataTemplate>
+			        <Label Text="After" />
+			      </DataTemplate>
+			    </CollectionView.ItemTemplate>
+			  </CollectionView>
+			</ContentPage>
+			""";
+
+		using var harness = CreateHarness();
+		var generation = harness.Generate(xamlV1, xamlV2);
+
+		harness.RunLive(generation, live =>
+		{
+			var page = live.GetInstance<ContentPage>();
+			Assert.Equal("Before", Assert.IsType<Label>(page.Content).Text);
+
+			Assert.Same(page, live.ApplyUpdate<ContentPage>(1));
+			var collectionView = Assert.IsType<CollectionView>(page.Content);
+			Assert.NotNull(collectionView.ItemTemplate);
+			Assert.Equal("After", Assert.IsType<Label>(collectionView.ItemTemplate!.CreateContent()).Text);
+		});
+	}
+
+	[Fact]
+	public void ComplexPropertyWithNestedResources_IsExplicitlySkipped()
+	{
+		const string xamlV1 = """
+			<ContentPage xmlns="http://schemas.microsoft.com/dotnet/2021/maui"
+			             xmlns:x="http://schemas.microsoft.com/winfx/2009/xaml"
+			             x:Class="TestAiAssisted.MainPage">
+			  <Label Text="Before" />
+			</ContentPage>
+			""";
+		const string xamlV2 = """
+			<ContentPage xmlns="http://schemas.microsoft.com/dotnet/2021/maui"
+			             xmlns:x="http://schemas.microsoft.com/winfx/2009/xaml"
+			             x:Class="TestAiAssisted.MainPage">
+			  <CollectionView>
+			    <CollectionView.ItemTemplate>
+			      <DataTemplate>
+			        <VerticalStackLayout>
+			          <VerticalStackLayout.Resources>
+			            <ResourceDictionary>
+			              <Style x:Key="AfterStyle" TargetType="Label">
+			                <Setter Property="Text" Value="After" />
+			              </Style>
+			            </ResourceDictionary>
+			          </VerticalStackLayout.Resources>
+			          <Label Style="{StaticResource AfterStyle}" />
+			        </VerticalStackLayout>
+			      </DataTemplate>
+			    </CollectionView.ItemTemplate>
+			  </CollectionView>
+			</ContentPage>
+			""";
+
+		using var harness = CreateHarness();
+		var generation = harness.Generate(xamlV1, xamlV2);
+		var updateComponentSource = generation[1].UpdateComponentSource;
+
+		Assert.NotNull(updateComponentSource);
+		Assert.Contains(
+			"Complex property 'ItemTemplate' (ElementNode) — skipped (not yet supported)",
+			updateComponentSource!,
+			StringComparison.Ordinal);
+
+		var compilation = harness.Compile(generation[1]);
+		Assert.True(compilation.PeImage.Length > 0, "Generated fallback UpdateComponent should compile.");
+	}
+
+	[Fact]
+	public void ComplexPropertyWithAncestorStaticResource_IsExplicitlySkipped()
+	{
+		const string xamlV1 = """
+			<ContentPage xmlns="http://schemas.microsoft.com/dotnet/2021/maui"
+			             xmlns:x="http://schemas.microsoft.com/winfx/2009/xaml"
+			             x:Class="TestAiAssisted.MainPage">
+			  <ContentPage.Resources>
+			    <Style x:Key="PageLabelStyle" TargetType="Label">
+			      <Setter Property="Text" Value="After" />
+			    </Style>
+			  </ContentPage.Resources>
+			  <Label Text="Before" />
+			</ContentPage>
+			""";
+		const string xamlV2 = """
+			<ContentPage xmlns="http://schemas.microsoft.com/dotnet/2021/maui"
+			             xmlns:x="http://schemas.microsoft.com/winfx/2009/xaml"
+			             x:Class="TestAiAssisted.MainPage">
+			  <ContentPage.Resources>
+			    <Style x:Key="PageLabelStyle" TargetType="Label">
+			      <Setter Property="Text" Value="After" />
+			    </Style>
+			  </ContentPage.Resources>
+			  <CollectionView>
+			    <CollectionView.ItemTemplate>
+			      <DataTemplate>
+			        <Label Style="{StaticResource PageLabelStyle}" />
+			      </DataTemplate>
+			    </CollectionView.ItemTemplate>
+			  </CollectionView>
+			</ContentPage>
+			""";
+
+		using var harness = CreateHarness();
+		var generation = harness.Generate(xamlV1, xamlV2);
+		var updateComponentSource = generation[1].UpdateComponentSource;
+
+		Assert.NotNull(updateComponentSource);
+		Assert.Contains("new global::Microsoft.Maui.Controls.CollectionView", updateComponentSource!, StringComparison.Ordinal);
+		Assert.Contains(
+			"Complex property 'ItemTemplate' (ElementNode) — skipped (not yet supported)",
+			updateComponentSource!,
+			StringComparison.Ordinal);
+		Assert.DoesNotContain(".ItemTemplateProperty", updateComponentSource!, StringComparison.Ordinal);
+
+		var compilation = harness.Compile(generation[1]);
+		Assert.True(compilation.PeImage.Length > 0, "Root replacement with skipped ItemTemplate should compile.");
+	}
+
+	[Theory]
+	[InlineData("""<Label Text="{Binding Converter={StaticResource TestResource}}" />""")]
+	[InlineData("""
+		<Label>
+		  <Label.BindingContext>
+		    <StaticResource Key="TestResource" />
+		  </Label.BindingContext>
+		</Label>
+		""")]
+	public void ComplexPropertyWithNestedStaticResourceShape_IsExplicitlySkipped(string templateContent)
+	{
+		const string xamlV1 = """
+			<ContentPage xmlns="http://schemas.microsoft.com/dotnet/2021/maui"
+			             xmlns:x="http://schemas.microsoft.com/winfx/2009/xaml"
+			             xmlns:local="clr-namespace:TestAiAssisted"
+			             x:Class="TestAiAssisted.MainPage">
+			  <ContentPage.Resources>
+			    <local:TestConverter x:Key="TestResource" />
+			  </ContentPage.Resources>
+			  <Label Text="Before" />
+			</ContentPage>
+			""";
+		var xamlV2 = $$"""
+			<ContentPage xmlns="http://schemas.microsoft.com/dotnet/2021/maui"
+			             xmlns:x="http://schemas.microsoft.com/winfx/2009/xaml"
+			             xmlns:local="clr-namespace:TestAiAssisted"
+			             x:Class="TestAiAssisted.MainPage">
+			  <ContentPage.Resources>
+			    <local:TestConverter x:Key="TestResource" />
+			  </ContentPage.Resources>
+			  <CollectionView>
+			    <CollectionView.ItemTemplate>
+			      <DataTemplate>
+			        {{templateContent}}
+			      </DataTemplate>
+			    </CollectionView.ItemTemplate>
+			  </CollectionView>
+			</ContentPage>
+			""";
+
+		using var harness = new XamlHotReloadTestHarness(
+			nameof(ComplexPropertyWithNestedStaticResourceShape_IsExplicitlySkipped),
+			PageClass,
+			PageStub,
+			ConverterStub);
+		var generation = harness.Generate(xamlV1, xamlV2);
+		var updateComponentSource = generation[1].UpdateComponentSource;
+
+		Assert.NotNull(updateComponentSource);
+		Assert.Contains("new global::Microsoft.Maui.Controls.CollectionView", updateComponentSource!, StringComparison.Ordinal);
+		Assert.Contains(
+			"Complex property 'ItemTemplate' (ElementNode) — skipped (not yet supported)",
+			updateComponentSource!,
+			StringComparison.Ordinal);
+		Assert.DoesNotContain(".ItemTemplateProperty", updateComponentSource!, StringComparison.Ordinal);
+
+		var compilation = harness.Compile(generation[1]);
+		Assert.True(compilation.PeImage.Length > 0, "Root replacement with skipped ItemTemplate should compile.");
+	}
+
+	[Fact]
+	public void StaticResourcePreflight_DiscardsParserDiagnostics()
+	{
+		const string xamlV1 = """
+			<ContentPage xmlns="http://schemas.microsoft.com/dotnet/2021/maui"
+			             xmlns:x="http://schemas.microsoft.com/winfx/2009/xaml"
+			             x:Class="TestAiAssisted.MainPage">
+			  <ContentPage.Resources>
+			    <Style x:Key="PageLabelStyle" TargetType="Label" />
+			  </ContentPage.Resources>
+			  <Label Text="Before" />
+			</ContentPage>
+			""";
+		const string xamlV2 = """
+			<ContentPage xmlns="http://schemas.microsoft.com/dotnet/2021/maui"
+			             xmlns:x="http://schemas.microsoft.com/winfx/2009/xaml"
+			             x:Class="TestAiAssisted.MainPage">
+			  <ContentPage.Resources>
+			    <Style x:Key="PageLabelStyle" TargetType="Label" />
+			  </ContentPage.Resources>
+			  <CollectionView>
+			    <CollectionView.ItemTemplate>
+			      <DataTemplate>
+			        <VerticalStackLayout>
+			          <Label Text="{Binding Converter={StaticResource Key=}}" />
+			          <Label Style="{StaticResource PageLabelStyle}" />
+			        </VerticalStackLayout>
+			      </DataTemplate>
+			    </CollectionView.ItemTemplate>
+			  </CollectionView>
+			</ContentPage>
+			""";
+
+		using var harness = CreateHarness();
+		var generation = harness.GenerateAllowingDiagnostics(xamlV1, xamlV2);
+		var updateComponentSource = generation[1].UpdateComponentSource;
+
+		// InitializeComponent reports the malformed markup once. The discarded preflight must
+		// not add a duplicate before the later StaticResource causes ItemTemplate to be skipped.
+		Assert.Single(generation[1].GeneratorResult.Diagnostics.Where(static diagnostic => diagnostic.Id == "MAUIG1001"));
+		Assert.NotNull(updateComponentSource);
+		Assert.Contains(
+			"Complex property 'ItemTemplate' (ElementNode) — skipped (not yet supported)",
+			updateComponentSource!,
+			StringComparison.Ordinal);
+		Assert.DoesNotContain(".ItemTemplateProperty", updateComponentSource!, StringComparison.Ordinal);
+
+		var compilation = harness.Compile(generation[1]);
+		Assert.True(compilation.PeImage.Length > 0, "Skipped malformed ItemTemplate should compile.");
+	}
+}
diff --git a/src/Controls/tests/SourceGen.UnitTests/HotReload/AiAssisted/TemplateAndSelectorHotReloadTests.BindableLayout.cs b/src/Controls/tests/SourceGen.UnitTests/HotReload/AiAssisted/TemplateAndSelectorHotReloadTests.BindableLayout.cs
new file mode 100644
index 000000000000..47c7f9f3137d
--- /dev/null
+++ b/src/Controls/tests/SourceGen.UnitTests/HotReload/AiAssisted/TemplateAndSelectorHotReloadTests.BindableLayout.cs
@@ -0,0 +1,36 @@
+#nullable enable
+
+using System;
+using System.Collections.Generic;
+using System.Collections.ObjectModel;
+using System.Linq;
+using System.Runtime.CompilerServices;
+using Microsoft.Maui.Controls.SourceGen.UnitTests.HotReload;
+using Xunit;
+
+namespace Microsoft.Maui.Controls.SourceGen.UnitTests.HotReload.AiAssisted;
+
+public partial class TemplateAndSelectorHotReloadTests
+{
+	// Wave-2 · Templates · TS-05 (GREEN guard)
+	// Provenance: MAUI §hot-reload complex/attached-property gap; UpdateComponentCodeWriter.cs L1319.
+	// Faithfulness: reaches the writer's attached-complex branch (L1319) and pins the exact skip marker plus a
+	//               successful compile of the emitted V2 UpdateComponent.
+	// Expected: DOC-SKIP-GUARD
+	// Issue: https://github.com/dotnet/maui/issues/36732
+	[Fact]
+	public void BindableLayoutTemplate_AttachedComplex_EmitsSkipMarker()
+	{
+		using var harness = CreateHarness();
+		var generation = harness.Generate(BindableLayoutXaml("V1"), BindableLayoutXaml("V2"));
+		var updateComponentSource = generation[1].UpdateComponentSource;
+
+		Assert.NotNull(updateComponentSource);
+		// Exact marker text (em-dash U+2014) from UpdateComponentCodeWriter.cs L1319, with the attached
+		// property's dotted LocalName (propDiff.PropertyName.LocalName, L1132).
+		Assert.Contains("Complex attached property 'BindableLayout.ItemTemplate' — skipped", updateComponentSource!, StringComparison.Ordinal);
+
+		var compilation = harness.Compile(generation[1]);
+		Assert.True(compilation.PeImage.Length > 0, "Generated V2 UpdateComponent should still compile.");
+	}
+}
diff --git a/src/Controls/tests/SourceGen.UnitTests/HotReload/AiAssisted/TemplateAndSelectorHotReloadTests.ControlTemplates.cs b/src/Controls/tests/SourceGen.UnitTests/HotReload/AiAssisted/TemplateAndSelectorHotReloadTests.ControlTemplates.cs
new file mode 100644
index 000000000000..69ac07c6be7a
--- /dev/null
+++ b/src/Controls/tests/SourceGen.UnitTests/HotReload/AiAssisted/TemplateAndSelectorHotReloadTests.ControlTemplates.cs
@@ -0,0 +1,73 @@
+#nullable enable
+
+using System;
+using System.Collections.Generic;
+using System.Collections.ObjectModel;
+using System.Linq;
+using System.Runtime.CompilerServices;
+using Microsoft.Maui.Controls.SourceGen.UnitTests.HotReload;
+using Xunit;
+
+namespace Microsoft.Maui.Controls.SourceGen.UnitTests.HotReload.AiAssisted;
+
+public partial class TemplateAndSelectorHotReloadTests
+{
+	// Wave-2 · Templates · TS-04 (GREEN anchor)
+	// Provenance: MAUI §hot-reload ControlTemplate construction (namescope / x:Reference / VSM TargetName);
+	//             SetNamescopesAndRegisterNamesVisitor via LoadTemplate (#36482).
+	// Faithfulness: reaches ControlTemplate.CreateContent() and drives GoToState headlessly (pure BindableObject
+	//               logic, per VisualStateManagerTests.TargetedVisualElementGoesToCorrectState); asserts each
+	//               realization owns its namescope, x:Reference resolves to that realization's own Target, and a
+	//               VSM TargetName setter mutates only its own realization; fails-for-bug: realizations share a
+	//               namescope, x:Reference leaks across realizations, or a VSM setter escapes its root.
+	//                   source needs a dispatcher headlessly), and the VSM setter targets an UNBOUND label so
+	//                   GoToState never triggers a binding proxy.
+	// Issue: https://github.com/dotnet/maui/issues/36482
+	[MetadataUpdateFact]
+	public void ControlTemplate_Construction_NamescopeXReferenceAndVsmAreIsolated()
+	{
+		using var harness = CreateHarness();
+		var generation = harness.Generate(ControlTemplateXaml("V1", "V1-Active"), ControlTemplateXaml("V2", "V2-Active"));
+
+		harness.RunLive(generation, live =>
+		{
+			var page = live.GetInstance<ContentPage>();
+			var template = Assert.IsType<ControlTemplate>(page.Resources["Ct"]);
+
+			// Two realizations from the SAME (V1) template.
+			var rootA = Assert.IsType<VerticalStackLayout>(template.CreateContent());
+			var rootB = Assert.IsType<VerticalStackLayout>(template.CreateContent());
+			Assert.NotSame(rootA, rootB);
+
+			var targetA = rootA.FindByName<Label>("Target");
+			var targetB = rootB.FindByName<Label>("Target");
+			var mirrorA = rootA.FindByName<Label>("Mirror");
+			var mirrorB = rootB.FindByName<Label>("Mirror");
+			var vsmTargetA = rootA.FindByName<Label>("VsmTarget");
+			var vsmTargetB = rootB.FindByName<Label>("VsmTarget");
+			Assert.NotNull(targetA);
+			Assert.NotNull(targetB);
+			Assert.NotNull(mirrorA);
+			Assert.NotNull(mirrorB);
+			Assert.NotNull(vsmTargetA);
+			Assert.NotNull(vsmTargetB);
+
+			// Per-realization namescope: the same name resolves to distinct elements.
+			Assert.NotSame(targetA, targetB);
+			Assert.NotSame(vsmTargetA, vsmTargetB);
+			Assert.Equal("V1", targetA!.Text);
+
+			// x:Reference resolved (at construction) to each realization's OWN Target.
+			Assert.Equal("V1", mirrorA!.Text);
+			Assert.Equal("V1", mirrorB!.Text);
+
+			// VSM TargetName isolation: activating A mutates only A's (unbound) VsmTarget.
+			Assert.Equal("idle", vsmTargetA!.Text);
+			Assert.True(VisualStateManager.GoToState(rootA, "Active"));
+			Assert.Equal("V1-Active", vsmTargetA.Text);
+			Assert.Equal("idle", vsmTargetB!.Text);
+			Assert.True(VisualStateManager.GoToState(rootA, "Normal"));
+			Assert.Equal("idle", vsmTargetA.Text); // Active setters unapplied
+		});
+	}
+}
diff --git a/src/Controls/tests/SourceGen.UnitTests/HotReload/AiAssisted/TemplateAndSelectorHotReloadTests.DataTemplates.cs b/src/Controls/tests/SourceGen.UnitTests/HotReload/AiAssisted/TemplateAndSelectorHotReloadTests.DataTemplates.cs
new file mode 100644
index 000000000000..ce19f252a822
--- /dev/null
+++ b/src/Controls/tests/SourceGen.UnitTests/HotReload/AiAssisted/TemplateAndSelectorHotReloadTests.DataTemplates.cs
@@ -0,0 +1,139 @@
+#nullable enable
+
+using System;
+using System.Collections.Generic;
+using System.Collections.ObjectModel;
+using System.Linq;
+using System.Runtime.CompilerServices;
+using Microsoft.Maui.Controls.SourceGen.UnitTests.HotReload;
+using Xunit;
+
+namespace Microsoft.Maui.Controls.SourceGen.UnitTests.HotReload.AiAssisted;
+
+public partial class TemplateAndSelectorHotReloadTests
+{
+	// Wave-2 · Templates · TS-01 (GREEN anchor)
+	// Provenance: MAUI §hot-reload DataTemplate realization; SetPropertiesVisitor.cs L245-296 (#36482);
+	//             UpdateComponent resource-replacement verified by dumping the generated V2 source.
+	// Faithfulness: reaches CreateContent (construction) + the live update; asserts construction correctness,
+	//               already-realized stability, and that the generated source carries the edit; fails-for-bug:
+	//               a body edit corrupts an already-realized subtree, or the writer stops emitting the new
+	//               factory / stops replacing the keyed entry.
+	// Issue: https://github.com/dotnet/maui/issues/36482
+	[MetadataUpdateFact]
+	public void KeyedDataTemplate_EditBody_ConstructionStableAndSourceReflectsEdit()
+	{
+		using var harness = CreateHarness();
+		var generation = harness.Generate(KeyedDataTemplateXaml("Alpha"), KeyedDataTemplateXaml("Bravo"));
+
+		// Generated-source oracle: the new factory lands in InitializeComponent, and UpdateComponent replaces
+		// the keyed entry with a bare template (the reason future realization stays deferred under #36482).
+		Assert.NotNull(generation[1].InitializeComponentSource);
+		Assert.Contains("Bravo", generation[1].InitializeComponentSource!, StringComparison.Ordinal);
+		Assert.NotNull(generation[1].UpdateComponentSource);
+		Assert.Contains(
+			"this.Resources[\"Row\"] = new global::Microsoft.Maui.Controls.DataTemplate();",
+			generation[1].UpdateComponentSource!,
+			StringComparison.Ordinal);
+
+		harness.RunLive(generation, live =>
+		{
+			var page = live.GetInstance<ContentPage>();
+			var template = Assert.IsType<DataTemplate>(page.Resources["Row"]);
+
+			// Construction realization is correct.
+			var r1 = Assert.IsType<Label>(template.CreateContent());
+			Assert.Equal("Alpha", r1.Text);
+
+			// The update applies cleanly and the already-realized subtree is left intact.
+			Assert.Same(page, live.ApplyUpdate<ContentPage>(1));
+			Assert.Equal("Alpha", r1.Text);
+		});
+	}
+
+	// Wave-2 · Selectors · TS-02 (GREEN anchor)
+	// Provenance: MAUI §hot-reload DataTemplateSelector realization; SetPropertiesVisitor.cs L245-296 (#36482)
+	// Faithfulness: reaches SelectTemplate(...).CreateContent(); asserts the selector routes odd/even to
+	//               distinct branch templates, existing realizations stay put across an update, and the edit
+	//               reaches the generated source; fails-for-bug: a branch returns null/bare, both branches
+	//               collapse to one template, or the writer drops the new odd-branch factory.
+	// Issue: https://github.com/dotnet/maui/issues/36482
+	[MetadataUpdateFact]
+	public void Selector_ConstructionDistinguishesBranchesAndIsStableAcrossUpdate()
+	{
+		using var harness = CreateHarness(additionalSources: SelectorSource);
+		var generation = harness.Generate(SelectorXaml("OddB1"), SelectorXaml("OddB2"));
+
+		Assert.NotNull(generation[1].InitializeComponentSource);
+		Assert.Contains("OddB2", generation[1].InitializeComponentSource!, StringComparison.Ordinal);
+
+		harness.RunLive(generation, live =>
+		{
+			var page = live.GetInstance<ContentPage>();
+			var selector = Assert.IsAssignableFrom<DataTemplateSelector>(page.Resources["Sel"]);
+
+			// Odd vs even resolve to DISTINCT branch templates, each producing its own leaf.
+			var oddTemplate = selector.SelectTemplate(1, page);
+			var evenTemplate = selector.SelectTemplate(2, page);
+			Assert.NotNull(oddTemplate);
+			Assert.NotNull(evenTemplate);
+			Assert.NotSame(oddTemplate, evenTemplate);
+
+			var odd = Assert.IsType<Label>(oddTemplate!.CreateContent());
+			var even = Assert.IsType<Label>(evenTemplate!.CreateContent());
+			Assert.Equal("OddB1", odd.Text);
+			Assert.Equal("EvenA", even.Text);
+
+			// The update applies cleanly; the already-realized odd subtree is unchanged.
+			Assert.Same(page, live.ApplyUpdate<ContentPage>(1));
+			Assert.Equal("OddB1", odd.Text);
+		});
+	}
+	// Wave-2 · Templates · TS-03 (GREEN anchor)
+	// Provenance: MAUI §hot-reload compiled-binding retype; SetPropertiesVisitor.cs L245-296 + compiled-binding
+	//             getter (CreateTypedBindingFrom_*, #36482).
+	// Faithfulness: reaches the generated InitializeComponent source across a retype+reverse AND the V1
+	//               compiled-binding realization; asserts the emitted accessor tracks the current x:DataType
+	//               (retype and reverse) and construction binds correctly; fails-for-bug: a retyped x:DataType
+	//               keeps emitting the stale accessor, or the compiled binding fails at construction.
+	// Issue: https://github.com/dotnet/maui/issues/36482
+	[MetadataUpdateTheory]
+	[InlineData("local:ItemA", "local:ItemB")]
+	[InlineData("{x:Type local:ItemA}", "{x:Type local:ItemB}")]
+	public void CompiledTemplate_RetypeAndReverse_GeneratedSourceTracksCurrentType(string dataTypeA, string dataTypeB)
+	{
+		var xamlV1 = CompiledTemplateXaml(dataTypeA, "Caption");
+		var xamlV2 = CompiledTemplateXaml(dataTypeB, "Heading");
+		var xamlV3 = CompiledTemplateXaml(dataTypeA, "Caption");
+
+		using var harness = CreateHarness(additionalSources: ItemTypesSource);
+		var generation = harness.Generate(xamlV1, xamlV2, xamlV3);
+
+		// V2 emits the new type's accessor and not the stale one; V3 reverses it back.
+		var v2 = generation[1].InitializeComponentSource;
+		var v3 = generation[2].InitializeComponentSource;
+		Assert.NotNull(v2);
+		Assert.NotNull(v3);
+		Assert.Contains("Heading", v2!, StringComparison.Ordinal);
+		Assert.Contains("ItemB", v2!, StringComparison.Ordinal);
+		Assert.DoesNotContain("Caption", v2!, StringComparison.Ordinal);
+		Assert.Contains("Caption", v3!, StringComparison.Ordinal);
+		Assert.Contains("ItemA", v3!, StringComparison.Ordinal);
+		Assert.DoesNotContain("Heading", v3!, StringComparison.Ordinal);
+
+		harness.RunLive(generation, live =>
+		{
+			var page = live.GetInstance<ContentPage>();
+			var template = Assert.IsType<DataTemplate>(page.Resources["Row"]);
+
+			// V1 compiled binding realizes and binds against ItemA.Caption.
+			var r1 = Assert.IsType<Label>(template.CreateContent());
+			r1.BindingContext = MakeLiveItem(page, "TestTemplates.ItemA", "Caption", "alpha");
+			Assert.Equal("alpha", r1.Text);
+
+			// The update applies cleanly; the already-realized binding is unchanged.
+			Assert.Same(page, live.ApplyUpdate<ContentPage>(1));
+			Assert.Equal("alpha", r1.Text);
+		});
+	}
+}
diff --git a/src/Controls/tests/SourceGen.UnitTests/HotReload/AiAssisted/TemplateAndSelectorHotReloadTests.cs b/src/Controls/tests/SourceGen.UnitTests/HotReload/AiAssisted/TemplateAndSelectorHotReloadTests.cs
new file mode 100644
index 000000000000..8b9ab1e22829
--- /dev/null
+++ b/src/Controls/tests/SourceGen.UnitTests/HotReload/AiAssisted/TemplateAndSelectorHotReloadTests.cs
@@ -0,0 +1,190 @@
+#nullable enable
+
+using System;
+using System.Collections.Generic;
+using System.Collections.ObjectModel;
+using System.Linq;
+using System.Runtime.CompilerServices;
+using Microsoft.Maui.Controls.SourceGen.UnitTests.HotReload;
+using Xunit;
+
+namespace Microsoft.Maui.Controls.SourceGen.UnitTests.HotReload.AiAssisted;
+
+// Wave-2 · Templates & Selectors · TS-01..TS-05 (PR #36730)
+//
+// Mechanism — established empirically against this harness by inspecting the generated sources:
+//   * keyed DataTemplate/ControlTemplate/DataTemplateSelector resources are emitted as lazy factories whose
+//     LoadTemplate delegates live inside the generated AddFactory lambda (SetPropertiesVisitor.cs L245-296,
+//     #36482).
+//   * the IHR apply path runs UpdateComponent (it does not re-run InitializeComponent). For keyed template
+//     resources, the current writer replaces the keyed entry with a bare template in UpdateComponent.
+//
+// Net result: this PR keeps only the construction/source guards that are faithful on the current harness.
+// They prove construction-time realization, already-realized stability, and generated-source shape.
+// Future-realization follow-ups remain tracked under #36482, while complex/attached-property reconciliation
+// scenarios remain tracked under #36732 and are intentionally left out of this PR.
+//
+// Item/selector types (TS-02/TS-03) compile into the collectible test ALC as additional sources, so host
+// code reaches them through base types (DataTemplateSelector) + reflection (Assembly.GetType + Activator).
+[Collection("XamlHotReloadTests")]
+public partial class TemplateAndSelectorHotReloadTests
+{
+	const string PageClass = "TestTemplates.MainPage";
+
+	const string PageStub = """
+		namespace TestTemplates;
+
+		public partial class MainPage : global::Microsoft.Maui.Controls.ContentPage
+		{
+			private partial void InitializeComponent();
+
+			public void InitializeComponentRuntime() { }
+
+			public MainPage()
+			{
+				InitializeComponent();
+			}
+		}
+		""";
+
+	// Odd/even DataTemplateSelector for TS-02. Odd items -> OddTemplate, even items -> EvenTemplate.
+	const string SelectorSource = """
+		namespace TestTemplates;
+
+		public sealed class OddEvenSelector : global::Microsoft.Maui.Controls.DataTemplateSelector
+		{
+			public global::Microsoft.Maui.Controls.DataTemplate? OddTemplate { get; set; }
+			public global::Microsoft.Maui.Controls.DataTemplate? EvenTemplate { get; set; }
+
+			protected override global::Microsoft.Maui.Controls.DataTemplate OnSelectTemplate(object item, global::Microsoft.Maui.Controls.BindableObject container)
+				=> (item is int i && (i % 2 != 0)) ? OddTemplate! : EvenTemplate!;
+		}
+		""";
+
+	// TS-03 item types. Property names are deliberately collision-free (Caption/Heading, not Name/Title)
+	// so the generated-source assertions can distinguish "new referenced type's member" from "stale member"
+	// without matching incidental substrings (x:Name, TypeName, ...). This is a faithful stand-in for the
+	// plan's `ItemB.Title` / `ItemA.Name` intent (see TS-03 provenance).
+	const string ItemTypesSource = """
+		namespace TestTemplates;
+
+		public sealed class ItemA { public string? Caption { get; set; } }
+		public sealed class ItemB { public string? Heading { get; set; } }
+		""";
+
+	static XamlHotReloadTestHarness CreateHarness([CallerMemberName] string scenarioName = "", params string[] additionalSources) =>
+		new(scenarioName, PageClass, PageStub, additionalSources);
+
+	// Reflectively build a BindingContext instance of a type that only exists inside the live ALC.
+	static object MakeLiveItem(object anyLiveInstance, string typeName, string property, string value)
+	{
+		var type = anyLiveInstance.GetType().Assembly.GetType(typeName)
+			?? throw new InvalidOperationException($"Type '{typeName}' not found in the live assembly.");
+		var instance = Activator.CreateInstance(type)!;
+		type.GetProperty(property)!.SetValue(instance, value);
+		return instance;
+	}
+
+	static string KeyedDataTemplateXaml(string leaf) => $$"""
+		<ContentPage xmlns="http://schemas.microsoft.com/dotnet/2021/maui"
+		             xmlns:x="http://schemas.microsoft.com/winfx/2009/xaml"
+		             x:Class="TestTemplates.MainPage">
+		  <ContentPage.Resources>
+		    <DataTemplate x:Key="Row">
+		      <Label Text="{{leaf}}" />
+		    </DataTemplate>
+		  </ContentPage.Resources>
+		  <VerticalStackLayout>
+		    <Label Text="Host" />
+		  </VerticalStackLayout>
+		</ContentPage>
+		""";
+
+	static string SelectorXaml(string oddText) => $$"""
+		<ContentPage xmlns="http://schemas.microsoft.com/dotnet/2021/maui"
+		             xmlns:x="http://schemas.microsoft.com/winfx/2009/xaml"
+		             xmlns:local="clr-namespace:TestTemplates"
+		             x:Class="TestTemplates.MainPage">
+		  <ContentPage.Resources>
+		    <local:OddEvenSelector x:Key="Sel">
+		      <local:OddEvenSelector.OddTemplate>
+		        <DataTemplate>
+		          <Label Text="{{oddText}}" />
+		        </DataTemplate>
+		      </local:OddEvenSelector.OddTemplate>
+		      <local:OddEvenSelector.EvenTemplate>
+		        <DataTemplate>
+		          <Label Text="EvenA" />
+		        </DataTemplate>
+		      </local:OddEvenSelector.EvenTemplate>
+		    </local:OddEvenSelector>
+		  </ContentPage.Resources>
+		  <VerticalStackLayout>
+		    <Label Text="Host" />
+		  </VerticalStackLayout>
+		</ContentPage>
+		""";
+
+	const string CompiledTemplateShape = """
+		<ContentPage xmlns="http://schemas.microsoft.com/dotnet/2021/maui"
+		             xmlns:x="http://schemas.microsoft.com/winfx/2009/xaml"
+		             xmlns:local="clr-namespace:TestTemplates"
+		             x:Class="TestTemplates.MainPage">
+		  <ContentPage.Resources>
+		    <DataTemplate x:Key="Row" x:DataType="__DT__">
+		      <Label Text="{Binding __PROP__}" />
+		    </DataTemplate>
+		  </ContentPage.Resources>
+		  <VerticalStackLayout>
+		    <Label Text="Host" />
+		  </VerticalStackLayout>
+		</ContentPage>
+		""";
+
+	static string CompiledTemplateXaml(string dataType, string prop) => CompiledTemplateShape
+		.Replace("__DT__", dataType, StringComparison.Ordinal)
+		.Replace("__PROP__", prop, StringComparison.Ordinal);
+
+	static string ControlTemplateXaml(string baseText, string activeText) => $$"""
+		<ContentPage xmlns="http://schemas.microsoft.com/dotnet/2021/maui"
+		             xmlns:x="http://schemas.microsoft.com/winfx/2009/xaml"
+		             x:Class="TestTemplates.MainPage">
+		  <ContentPage.Resources>
+		    <ControlTemplate x:Key="Ct">
+		      <VerticalStackLayout>
+		        <Label x:Name="Target" Text="{{baseText}}" />
+		        <Label x:Name="Mirror" Text="{Binding Source={x:Reference Target}, Path=Text}" />
+		        <Label x:Name="VsmTarget" Text="idle" />
+		        <VisualStateManager.VisualStateGroups>
+		          <VisualStateGroup x:Name="CommonStates">
+		            <VisualState x:Name="Normal" />
+		            <VisualState x:Name="Active">
+		              <VisualState.Setters>
+		                <Setter TargetName="VsmTarget" Property="Label.Text" Value="{{activeText}}" />
+		              </VisualState.Setters>
+		            </VisualState>
+		          </VisualStateGroup>
+		        </VisualStateManager.VisualStateGroups>
+		      </VerticalStackLayout>
+		    </ControlTemplate>
+		  </ContentPage.Resources>
+		  <VerticalStackLayout>
+		    <Label Text="Host" />
+		  </VerticalStackLayout>
+		</ContentPage>
+		""";
+
+	static string BindableLayoutXaml(string text) => $$"""
+		<ContentPage xmlns="http://schemas.microsoft.com/dotnet/2021/maui"
+		             xmlns:x="http://schemas.microsoft.com/winfx/2009/xaml"
+		             x:Class="TestTemplates.MainPage">
+		  <VerticalStackLayout>
+		    <BindableLayout.ItemTemplate>
+		      <DataTemplate>
+		        <Label Text="{{text}}" />
+		      </DataTemplate>
+		    </BindableLayout.ItemTemplate>
+		  </VerticalStackLayout>
+		</ContentPage>
+		""";
+}
diff --git a/src/Controls/tests/SourceGen.UnitTests/HotReload/AiAssisted/VisualStateHotReloadTests.Behaviors.cs b/src/Controls/tests/SourceGen.UnitTests/HotReload/AiAssisted/VisualStateHotReloadTests.Behaviors.cs
new file mode 100644
index 000000000000..c338ba90c4c5
--- /dev/null
+++ b/src/Controls/tests/SourceGen.UnitTests/HotReload/AiAssisted/VisualStateHotReloadTests.Behaviors.cs
@@ -0,0 +1,51 @@
+#nullable enable
+
+using System;
+using System.Collections.Generic;
+using System.Globalization;
+using System.Reflection;
+using System.Runtime.CompilerServices;
+using Microsoft.Maui.ApplicationModel;
+using Microsoft.Maui.Controls.SourceGen.UnitTests.HotReload;
+using Microsoft.Maui.Graphics;
+using Xunit;
+
+namespace Microsoft.Maui.Controls.SourceGen.UnitTests.HotReload.AiAssisted;
+
+public partial class VisualStateHotReloadTests
+{
+	// Wave2 · Behavior · P0-04 · VS-03
+	// Provenance: MAUI §3.4; toolkit T13/T15/T17; public-app T17
+	// Faithfulness: reaches writer L1167/L1194; fails-for-bug: Behavior re-add is explicitly declined.
+	// Expected: DOC-SKIP-GUARD
+	// Issue: https://github.com/dotnet/maui/issues/36732
+	[Fact]
+	public void Behavior_ClearAndComplexProperty_EmitsSkipMarker()
+	{
+		using var harness = CreateBehaviorHarness();
+		var generation = harness.Generate(
+			CreateBehaviorXaml("V1", includeBehavior: true),
+			CreateBehaviorXaml("V2", includeBehavior: false),
+			CreateBehaviorXaml("V3", includeBehavior: true));
+		var removalSource = generation[1].UpdateComponentSource;
+		var reAddSource = generation[2].UpdateComponentSource;
+
+		Assert.NotNull(removalSource);
+		Assert.Contains(
+			"RemoveBinding(global::Microsoft.Maui.Controls.Entry.BehaviorsProperty)",
+			removalSource!,
+			StringComparison.Ordinal);
+		Assert.Contains(
+			"ClearValue(global::Microsoft.Maui.Controls.Entry.BehaviorsProperty)",
+			removalSource!,
+			StringComparison.Ordinal);
+		Assert.NotNull(reAddSource);
+		Assert.Contains(
+			"Complex property 'Behaviors' (ElementNode) — skipped (not yet supported)",
+			reAddSource!,
+			StringComparison.Ordinal);
+
+		Assert.True(harness.Compile(generation[1]).PeImage.Length > 0, "Generated Behavior clear path should compile.");
+		Assert.True(harness.Compile(generation[2]).PeImage.Length > 0, "Generated Behavior re-add skip path should compile.");
+	}
+}
diff --git a/src/Controls/tests/SourceGen.UnitTests/HotReload/AiAssisted/VisualStateHotReloadTests.VisualStates.cs b/src/Controls/tests/SourceGen.UnitTests/HotReload/AiAssisted/VisualStateHotReloadTests.VisualStates.cs
new file mode 100644
index 000000000000..e7940b831f3f
--- /dev/null
+++ b/src/Controls/tests/SourceGen.UnitTests/HotReload/AiAssisted/VisualStateHotReloadTests.VisualStates.cs
@@ -0,0 +1,99 @@
+#nullable enable
+
+using System;
+using System.Collections.Generic;
+using System.Globalization;
+using System.Reflection;
+using System.Runtime.CompilerServices;
+using Microsoft.Maui.ApplicationModel;
+using Microsoft.Maui.Controls.SourceGen.UnitTests.HotReload;
+using Microsoft.Maui.Graphics;
+using Xunit;
+
+namespace Microsoft.Maui.Controls.SourceGen.UnitTests.HotReload.AiAssisted;
+
+public partial class VisualStateHotReloadTests
+{
+	// Wave2 · Visual State · P0-03 · VS-01
+	// Provenance: MAUI §2.1; public-app T13/T14; PoolMath CAT-02
+	// Faithfulness: reaches writer L1319; fails-for-bug: active VSM setter edits are explicitly declined.
+	// Expected: DOC-SKIP-GUARD
+	// Issue: https://github.com/dotnet/maui/issues/36732
+	[Fact]
+	public void ActiveVsmSetter_ComplexAttachedProperty_EmitsSkipMarker()
+	{
+		using var harness = CreateHarness();
+		var generation = harness.Generate(
+			CreateActiveStateXaml("BackgroundColor", "Red"),
+			CreateActiveStateXaml("BackgroundColor", "Blue"));
+		var updateComponentSource = generation[1].UpdateComponentSource;
+
+		Assert.NotNull(updateComponentSource);
+		Assert.Contains(
+			"Complex attached property 'VisualStateManager.VisualStateGroups' — skipped",
+			updateComponentSource!,
+			StringComparison.Ordinal);
+
+		var compilation = harness.Compile(generation[1]);
+		Assert.True(compilation.PeImage.Length > 0, "Generated VSM skip path should compile.");
+	}
+
+	static string[] CreateVs05StateGraphVersions() =>
+	[
+		CreateStateGraphXaml(includeActive: true, activeColor: "Red"),
+		CreateStateGraphXaml(includeActive: false, activeColor: null),
+		CreateStateGraphXaml(includeActive: true, activeColor: "Green"),
+	];
+
+	// Wave2 · Visual State · family 2 core · VS-05
+	// Provenance: MAUI §2.1; public-app T13/T14; minimal add/remove/re-add extension
+	// Faithfulness: reaches writer L1319 with the exact state-graph versions used by the live probe.
+	// Expected: DOC-SKIP-GUARD
+	// Issue: https://github.com/dotnet/maui/issues/36732
+	[Fact]
+	public void VsmState_AddRemoveReAdd_ComplexAttachedProperty_EmitsSkipMarker()
+	{
+		using var harness = CreateHarness();
+		var generation = harness.Generate(CreateVs05StateGraphVersions());
+
+		for (var index = 0; index < generation.Versions.Length; index++)
+		{
+			var compilation = harness.Compile(generation[index]);
+			Assert.True(compilation.PeImage.Length > 0, $"Generated VS-05 version {index} should compile.");
+
+			if (index == 0)
+				continue;
+
+			var updateComponentSource = generation[index].UpdateComponentSource;
+			Assert.NotNull(updateComponentSource);
+			Assert.Contains(
+				"Complex attached property 'VisualStateManager.VisualStateGroups' — skipped",
+				updateComponentSource!,
+				StringComparison.Ordinal);
+		}
+	}
+	// Wave2 · Visual State · family 2 combined · VS-06
+	// Provenance: MAUI §2.1; public-app T13/T14; cap-app-host/theme extension
+	// Faithfulness: reaches writer L1319 with nested AppThemeBinding/StaticResource values;
+	// fails-for-bug: generated VisualStateGroups replacement is explicitly declined.
+	// Expected: DOC-SKIP-GUARD
+	// Issue: https://github.com/dotnet/maui/issues/36732
+	[Fact]
+	public void ActiveVsmThemeResourceSetter_ComplexAttachedProperty_EmitsSkipMarker()
+	{
+		using var harness = CreateHostedHarness(CreateThemeOptions());
+		var generation = harness.Generate(
+			CreateThemeResourceStateXaml("V1"),
+			CreateThemeResourceStateXaml("V2"));
+		var updateComponentSource = generation[1].UpdateComponentSource;
+
+		Assert.NotNull(updateComponentSource);
+		Assert.Contains(
+			"Complex attached property 'VisualStateManager.VisualStateGroups' — skipped",
+			updateComponentSource!,
+			StringComparison.Ordinal);
+		Assert.True(
+			harness.Compile(generation[1]).PeImage.Length > 0,
+			"Generated VSM theme/resource skip path should compile.");
+	}
+}
diff --git a/src/Controls/tests/SourceGen.UnitTests/HotReload/AiAssisted/VisualStateHotReloadTests.cs b/src/Controls/tests/SourceGen.UnitTests/HotReload/AiAssisted/VisualStateHotReloadTests.cs
new file mode 100644
index 000000000000..3e151adecf59
--- /dev/null
+++ b/src/Controls/tests/SourceGen.UnitTests/HotReload/AiAssisted/VisualStateHotReloadTests.cs
@@ -0,0 +1,241 @@
+#nullable enable
+
+using System;
+using System.Collections.Generic;
+using System.Globalization;
+using System.Reflection;
+using System.Runtime.CompilerServices;
+using Microsoft.Maui.ApplicationModel;
+using Microsoft.Maui.Controls.SourceGen.UnitTests.HotReload;
+using Microsoft.Maui.Graphics;
+using Xunit;
+
+namespace Microsoft.Maui.Controls.SourceGen.UnitTests.HotReload.AiAssisted;
+
+[Collection("XamlHotReloadTests")]
+public partial class VisualStateHotReloadTests
+{
+	const string PageClass = "TestAiAssisted.MainPage";
+
+	const string PageStub = """
+		namespace TestAiAssisted;
+
+		public partial class MainPage : global::Microsoft.Maui.Controls.ContentPage
+		{
+			private partial void InitializeComponent();
+
+			public MainPage()
+			{
+				InitializeComponent();
+			}
+		}
+		""";
+
+	const string CountingBehaviorStub = """
+		namespace TestAiAssisted;
+
+		public sealed class CountingBehavior : global::Microsoft.Maui.Controls.Behavior<global::Microsoft.Maui.Controls.VisualElement>
+		{
+			public static int AttachCount { get; private set; }
+
+			public static int DetachCount { get; private set; }
+
+			public static int CallbackCount { get; private set; }
+
+			protected override void OnAttachedTo(global::Microsoft.Maui.Controls.VisualElement bindable)
+			{
+				base.OnAttachedTo(bindable);
+				AttachCount++;
+				bindable.PropertyChanged += OnPropertyChanged;
+			}
+
+			protected override void OnDetachingFrom(global::Microsoft.Maui.Controls.VisualElement bindable)
+			{
+				bindable.PropertyChanged -= OnPropertyChanged;
+				DetachCount++;
+				base.OnDetachingFrom(bindable);
+			}
+
+			static void OnPropertyChanged(object? sender, global::System.ComponentModel.PropertyChangedEventArgs args)
+			{
+				if (args.PropertyName == nameof(global::Microsoft.Maui.Controls.VisualElement.IsEnabled))
+					CallbackCount++;
+			}
+		}
+		""";
+
+	static XamlHotReloadTestHarness CreateHarness([CallerMemberName] string scenarioName = "") =>
+		new(scenarioName, PageClass, PageStub);
+
+	static XamlHotReloadTestHarness CreateBehaviorHarness([CallerMemberName] string scenarioName = "") =>
+		new(scenarioName, PageClass, PageStub, CountingBehaviorStub);
+
+	static XamlHotReloadTestHarness CreateHostedHarness(
+		XamlHotReloadApplicationOptions options,
+		[CallerMemberName] string scenarioName = "") =>
+		new(scenarioName, PageClass, PageStub, options);
+
+	static string CreateActiveStateXaml(string propertyName, string value) => $$"""
+		<ContentPage xmlns="http://schemas.microsoft.com/dotnet/2021/maui"
+		             xmlns:x="http://schemas.microsoft.com/winfx/2009/xaml"
+		             x:Class="TestAiAssisted.MainPage">
+		  <Label Text="Target">
+		    <VisualStateManager.VisualStateGroups>
+		      <VisualStateGroup Name="CommonStates">
+		        <VisualState Name="Active">
+		          <VisualState.Setters>
+		            <Setter Property="{{propertyName}}" Value="{{value}}" />
+		          </VisualState.Setters>
+		        </VisualState>
+		      </VisualStateGroup>
+		    </VisualStateManager.VisualStateGroups>
+		  </Label>
+		</ContentPage>
+		""";
+
+	static string CreateBehaviorXaml(string text, bool includeBehavior)
+	{
+		var behavior = includeBehavior
+			? """
+				  <Entry.Behaviors>
+				    <local:CountingBehavior />
+				  </Entry.Behaviors>
+				"""
+			: string.Empty;
+
+		return $$"""
+			<ContentPage xmlns="http://schemas.microsoft.com/dotnet/2021/maui"
+			             xmlns:x="http://schemas.microsoft.com/winfx/2009/xaml"
+			             xmlns:local="clr-namespace:TestAiAssisted"
+			             x:Class="TestAiAssisted.MainPage">
+			  <Entry Text="{{text}}">
+			{{behavior}}
+			  </Entry>
+			</ContentPage>
+			""";
+	}
+
+	static string CreateStateGraphXaml(bool includeActive, string? activeColor)
+	{
+		var activeState = includeActive
+			? $$"""
+				        <VisualState Name="Active">
+				          <VisualState.Setters>
+				            <Setter Property="BackgroundColor" Value="{{activeColor}}" />
+				          </VisualState.Setters>
+				        </VisualState>
+				"""
+			: string.Empty;
+
+		return $$"""
+			<ContentPage xmlns="http://schemas.microsoft.com/dotnet/2021/maui"
+			             xmlns:x="http://schemas.microsoft.com/winfx/2009/xaml"
+			             x:Class="TestAiAssisted.MainPage">
+			  <Label Text="Target">
+			    <VisualStateManager.VisualStateGroups>
+			      <VisualStateGroup Name="CommonStates">
+			        <VisualState Name="Normal">
+			          <VisualState.Setters>
+			            <Setter Property="BackgroundColor" Value="Blue" />
+			          </VisualState.Setters>
+			        </VisualState>
+			{{activeState}}
+			      </VisualStateGroup>
+			    </VisualStateManager.VisualStateGroups>
+			  </Label>
+			</ContentPage>
+			""";
+	}
+
+	static string CreateThemeResourceStateXaml(string version)
+	{
+		var setterValue =
+			$"{{AppThemeBinding Light={{StaticResource ActiveLight{version}}}, Dark={{StaticResource ActiveDark{version}}}}}";
+
+		return $$"""
+			<ContentPage xmlns="http://schemas.microsoft.com/dotnet/2021/maui"
+			             xmlns:x="http://schemas.microsoft.com/winfx/2009/xaml"
+			             x:Class="TestAiAssisted.MainPage">
+			  <Label Text="Target">
+			    <VisualStateManager.VisualStateGroups>
+			      <VisualStateGroup Name="CommonStates">
+			        <VisualState Name="Active">
+			          <VisualState.Setters>
+			            <Setter Property="BackgroundColor" Value="{{setterValue}}" />
+			          </VisualState.Setters>
+			        </VisualState>
+			      </VisualStateGroup>
+			    </VisualStateManager.VisualStateGroups>
+			  </Label>
+			</ContentPage>
+			""";
+	}
+
+	static XamlHotReloadApplicationOptions CreateThemeOptions() =>
+		new(
+			new Dictionary<string, object>
+			{
+				["ActiveLightV1"] = Colors.Red,
+				["ActiveDarkV1"] = Colors.Maroon,
+				["ActiveLightV2"] = Colors.Green,
+				["ActiveDarkV2"] = Colors.Blue,
+			},
+			AppTheme.Light);
+
+	static void AssertActiveState(Label label)
+	{
+		var groups = VisualStateManager.GetVisualStateGroups(label);
+		var group = Assert.Single(groups);
+		Assert.Equal("Active", group.CurrentState.Name);
+		var state = Assert.Single(group.States);
+		Assert.Equal("Active", state.Name);
+		Assert.Single(state.Setters);
+	}
+
+	static void AssertActiveThemeState(
+		Label label,
+		XamlHotReloadTestHarness harness,
+		AppTheme theme,
+		Color expectedColor)
+	{
+		AssertActiveState(label);
+		Assert.Equal(theme, harness.ApplicationHost!.Application.UserAppTheme);
+		Assert.Equal(expectedColor, label.BackgroundColor);
+	}
+
+	static void AssertVisualProperty(Label label, string propertyName, string value)
+	{
+		switch (propertyName)
+		{
+			case "BackgroundColor":
+				Assert.Equal(value == "Red" ? Colors.Red : Colors.Blue, label.BackgroundColor);
+				break;
+			case "Opacity":
+				Assert.Equal(double.Parse(value, CultureInfo.InvariantCulture), label.Opacity);
+				break;
+			case "Scale":
+				Assert.Equal(double.Parse(value, CultureInfo.InvariantCulture), label.Scale);
+				break;
+			default:
+				throw new ArgumentOutOfRangeException(nameof(propertyName), propertyName, "Unknown VSM property.");
+		}
+	}
+
+	static void AssertBehaviorCounts(
+		Behavior behavior,
+		int attach,
+		int detach,
+		int callbacks)
+	{
+		Assert.Equal(attach, GetStaticCounter(behavior, "AttachCount"));
+		Assert.Equal(detach, GetStaticCounter(behavior, "DetachCount"));
+		Assert.Equal(callbacks, GetStaticCounter(behavior, "CallbackCount"));
+	}
+
+	static int GetStaticCounter(Behavior behavior, string propertyName)
+	{
+		var property = behavior.GetType().GetProperty(propertyName, BindingFlags.Public | BindingFlags.Static);
+		Assert.NotNull(property);
+		return Assert.IsType<int>(property!.GetValue(null));
+	}
+}
diff --git a/src/Controls/tests/SourceGen.UnitTests/HotReload/XamlHotReloadHostFixture.cs b/src/Controls/tests/SourceGen.UnitTests/HotReload/XamlHotReloadHostFixture.cs
new file mode 100644
index 000000000000..6cbede1651b9
--- /dev/null
+++ b/src/Controls/tests/SourceGen.UnitTests/HotReload/XamlHotReloadHostFixture.cs
@@ -0,0 +1,83 @@
+#nullable enable
+
+using System;
+using System.Collections.Generic;
+using Microsoft.Maui.ApplicationModel;
+using Microsoft.Maui.Controls;
+
+namespace Microsoft.Maui.Controls.SourceGen.UnitTests.HotReload;
+
+internal sealed record XamlHotReloadApplicationOptions(
+	IReadOnlyDictionary<string, object>? Resources = null,
+	AppTheme InitialTheme = AppTheme.Unspecified);
+
+internal sealed class XamlHotReloadHostFixture : IDisposable
+{
+	readonly Application? _previousApplication;
+	readonly Application _application;
+	bool _disposed;
+
+	public XamlHotReloadHostFixture(XamlHotReloadApplicationOptions options)
+	{
+		ArgumentNullException.ThrowIfNull(options);
+
+		_previousApplication = Application.Current;
+		_application = new Application();
+
+		if (options.Resources is not null)
+		{
+			foreach (var resource in options.Resources)
+				_application.Resources.Add(resource.Key, resource.Value);
+		}
+
+		Application.Current = _application;
+		SetAppTheme(options.InitialTheme);
+	}
+
+	public Application Application => _application;
+
+	public void SetAppTheme(AppTheme theme)
+	{
+		ObjectDisposedException.ThrowIf(_disposed, this);
+		_application.UserAppTheme = theme;
+	}
+
+	public void Dispatch(Action action)
+	{
+		ObjectDisposedException.ThrowIf(_disposed, this);
+		ArgumentNullException.ThrowIfNull(action);
+
+		// The unit-test host has no platform run loop; dispatching directly keeps metadata updates
+		// deterministic while preserving the synchronous UI-thread contract of the harness API.
+		action();
+	}
+
+	public void Attach(Page page)
+	{
+		ObjectDisposedException.ThrowIf(_disposed, this);
+		ArgumentNullException.ThrowIfNull(page);
+
+#pragma warning disable CS0618
+		_application.MainPage = page;
+#pragma warning restore CS0618
+	}
+
+	public void Detach(Page page)
+	{
+		ArgumentNullException.ThrowIfNull(page);
+
+#pragma warning disable CS0618
+		if (ReferenceEquals(_application.MainPage, page))
+			_application.MainPage = null;
+#pragma warning restore CS0618
+	}
+
+	public void Dispose()
+	{
+		if (_disposed)
+			return;
+
+		_disposed = true;
+		Application.Current = _previousApplication;
+	}
+}
diff --git a/src/Controls/tests/SourceGen.UnitTests/HotReload/XamlHotReloadTestHarness.cs b/src/Controls/tests/SourceGen.UnitTests/HotReload/XamlHotReloadTestHarness.cs
new file mode 100644
index 000000000000..3fbd24e85b0b
--- /dev/null
+++ b/src/Controls/tests/SourceGen.UnitTests/HotReload/XamlHotReloadTestHarness.cs
@@ -0,0 +1,669 @@
+#nullable enable
+
+using System;
+using System.Collections.Generic;
+using System.Collections.Immutable;
+using System.IO;
+using System.Linq;
+using System.Reflection;
+using System.Reflection.Metadata;
+using System.Runtime.Loader;
+using System.Text;
+using System.Text.RegularExpressions;
+using System.Threading;
+using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.CSharp;
+using Microsoft.CodeAnalysis.Emit;
+using Microsoft.Maui.Controls.SourceGen;
+using Microsoft.Maui.Controls.Xaml.UnitTests.SourceGen;
+using Xunit;
+
+namespace Microsoft.Maui.Controls.SourceGen.UnitTests.HotReload;
+
+/// <summary>
+/// End-to-end generator harness that owns <see cref="XamlHotReloadState"/> lifecycle so each
+/// scenario starts clean and also leaves no cached state behind for the next test.
+/// </summary>
+internal sealed class XamlHotReloadTestHarness : IDisposable
+{
+	static readonly Regex GeneratedCodeAttributeRegex = new(
+		@"\[global::System\.CodeDom\.Compiler\.GeneratedCodeAttribute\([^\]]+\)\]\s*\n",
+		RegexOptions.CultureInvariant);
+
+	static int s_scenarioSequence;
+
+	readonly ImmutableArray<string> _additionalSources;
+	readonly string _pageSource;
+	readonly XamlHotReloadHostFixture? _applicationHost;
+	bool _disposed;
+	bool _generated;
+
+	public XamlHotReloadTestHarness(
+		string scenarioName,
+		string pageClass,
+		string pageSource,
+		params string[] additionalSources)
+	{
+		ArgumentException.ThrowIfNullOrWhiteSpace(scenarioName);
+		ArgumentException.ThrowIfNullOrWhiteSpace(pageClass);
+		ArgumentException.ThrowIfNullOrWhiteSpace(pageSource);
+		ArgumentNullException.ThrowIfNull(additionalSources);
+
+		var sequence = Interlocked.Increment(ref s_scenarioSequence);
+		ScenarioIdentity = $"{SanitizeIdentifier(scenarioName)}_{sequence}";
+		AssemblyName = $"XamlHotReload_{ScenarioIdentity}";
+		PageClass = pageClass;
+		XamlPath = Path.Combine(Path.GetTempPath(), "MauiSourceGenHotReload", ScenarioIdentity, "MainPage.xaml");
+		_pageSource = pageSource;
+		_additionalSources = [.. additionalSources];
+
+		XamlHotReloadState.Reset();
+	}
+
+	public XamlHotReloadTestHarness(
+		string scenarioName,
+		string pageClass,
+		string pageSource,
+		XamlHotReloadApplicationOptions applicationOptions,
+		params string[] additionalSources)
+		: this(scenarioName, pageClass, pageSource, additionalSources)
+	{
+		_applicationHost = new XamlHotReloadHostFixture(applicationOptions);
+	}
+
+	public string AssemblyName { get; }
+
+	public XamlHotReloadHostFixture? ApplicationHost => _applicationHost;
+
+	public string PageClass { get; }
+
+	public string ScenarioIdentity { get; }
+
+	public string XamlPath { get; }
+
+	public XamlHotReloadGeneration Generate(params string[] xamlVersions)
+		=> Generate(CreateMainPageSnapshots(xamlVersions), allowDiagnostics: false);
+
+	public XamlHotReloadGeneration GenerateAllowingDiagnostics(params string[] xamlVersions)
+		=> Generate(CreateMainPageSnapshots(xamlVersions), allowDiagnostics: true);
+
+	public XamlHotReloadGeneration GenerateDocuments(
+		params IReadOnlyDictionary<string, XamlHotReloadDocument>[] documentVersions)
+		=> Generate(documentVersions, allowDiagnostics: false);
+
+	public XamlHotReloadGeneration GenerateDocumentsAllowingDiagnostics(
+		params IReadOnlyDictionary<string, XamlHotReloadDocument>[] documentVersions)
+		=> Generate(documentVersions, allowDiagnostics: true);
+
+	XamlHotReloadGeneration Generate(
+		IReadOnlyDictionary<string, XamlHotReloadDocument>[] documentVersions,
+		bool allowDiagnostics)
+	{
+		ObjectDisposedException.ThrowIf(_disposed, this);
+		ArgumentNullException.ThrowIfNull(documentVersions);
+
+		if (_generated)
+			throw new InvalidOperationException("A hot reload harness can generate only one scenario.");
+		if (documentVersions.Length == 0)
+			throw new ArgumentException("At least one document version is required.", nameof(documentVersions));
+
+		_generated = true;
+
+		var compilation = CreateCompilation(includeGeneratedSources: false);
+		var driverOptions = new GeneratorDriverOptions(
+			disabledOutputs: IncrementalGeneratorOutputKind.None,
+			trackIncrementalGeneratorSteps: true);
+		GeneratorDriver driver = CSharpGeneratorDriver.Create(
+			[new XamlGenerator().AsSourceGenerator()],
+			driverOptions: driverOptions);
+
+		var versions = ImmutableArray.CreateBuilder<XamlHotReloadGeneratedVersion>(documentVersions.Length);
+		var previousFiles = ImmutableDictionary<string, XamlHotReloadAdditionalFile>.Empty;
+
+		for (var index = 0; index < documentVersions.Length; index++)
+		{
+			var files = CreateAdditionalFiles(documentVersions[index]);
+			driver = UpdateAdditionalTexts(driver, previousFiles, files);
+			driver = driver
+				.WithUpdatedAnalyzerConfigOptions(SourceGeneratorDriver.CreateAnalyzerConfigOptionsProvider(
+					[.. files.Values.Select(static file => file.File)]))
+				.RunGenerators(compilation);
+
+			var result = driver.GetRunResult();
+			var generatedRoots = FindGeneratedRoots(result);
+			var initializeComponentSource = generatedRoots
+				.FirstOrDefault(root => string.Equals(root.TypeName, PageClass, StringComparison.Ordinal))
+				?.InitializeComponentSource;
+			if (!allowDiagnostics)
+				Assert.NotNull(initializeComponentSource);
+
+			versions.Add(new XamlHotReloadGeneratedVersion(
+				ScenarioIdentity,
+				index,
+				files["MainPage.xaml"].Document.Text,
+				initializeComponentSource,
+				generatedRoots
+					.FirstOrDefault(root => string.Equals(root.TypeName, PageClass, StringComparison.Ordinal))
+					?.UpdateComponentSource,
+				result,
+				generatedRoots,
+				files.ToImmutableDictionary(
+					static pair => pair.Key,
+					static pair => pair.Value.Document)));
+			previousFiles = files;
+		}
+
+		return new XamlHotReloadGeneration(ScenarioIdentity, versions.MoveToImmutable());
+	}
+
+	public XamlHotReloadCompiledVersion Compile(XamlHotReloadGeneratedVersion version)
+	{
+		ObjectDisposedException.ThrowIf(_disposed, this);
+		ArgumentNullException.ThrowIfNull(version);
+
+		if (!string.Equals(version.ScenarioIdentity, ScenarioIdentity, StringComparison.Ordinal))
+			throw new ArgumentException("The generated version belongs to a different harness.", nameof(version));
+
+		Assert.True(
+			version.InitializeComponentSource is not null,
+			$"Cannot compile generated version {version.Index} because it has no InitializeComponent source.");
+
+		var compilation = CreateCompilation(includeGeneratedSources: true, version);
+		var errors = compilation.GetDiagnostics()
+			.Where(static diagnostic => diagnostic.Severity == DiagnosticSeverity.Error)
+			.ToArray();
+		Assert.True(errors.Length == 0, $"Compilation failed:{Environment.NewLine}{FormatDiagnostics(errors)}");
+
+		using var peStream = new MemoryStream();
+		using var pdbStream = new MemoryStream();
+		var emitResult = compilation.Emit(
+			peStream,
+			pdbStream,
+			options: new EmitOptions(debugInformationFormat: DebugInformationFormat.PortablePdb));
+		Assert.True(emitResult.Success, $"Emit failed:{Environment.NewLine}{FormatDiagnostics(emitResult.Diagnostics)}");
+
+		return new XamlHotReloadCompiledVersion(
+			version,
+			compilation,
+			ImmutableArray.CreateRange(peStream.ToArray()),
+			ImmutableArray.CreateRange(pdbStream.ToArray()));
+	}
+
+	public void RunLive(XamlHotReloadGeneration generation, Action<XamlHotReloadLiveSession> exercise)
+	{
+		ObjectDisposedException.ThrowIf(_disposed, this);
+		ArgumentNullException.ThrowIfNull(exercise);
+
+		if (!string.Equals(generation.ScenarioIdentity, ScenarioIdentity, StringComparison.Ordinal))
+			throw new ArgumentException("The generated scenario belongs to a different harness.", nameof(generation));
+
+		using var session = new XamlHotReloadLiveSession(this, generation);
+		exercise(session);
+	}
+
+	public void Dispose()
+	{
+		if (_disposed)
+			return;
+
+		_disposed = true;
+		try
+		{
+			XamlHotReloadState.Reset();
+		}
+		finally
+		{
+			_applicationHost?.Dispose();
+		}
+	}
+
+	CSharpCompilation CreateCompilation(
+		bool includeGeneratedSources,
+		XamlHotReloadGeneratedVersion? generatedVersion = null)
+	{
+		var compilation = (CSharpCompilation)SourceGeneratorDriver.CreateMauiCompilation(AssemblyName);
+		var trees = ImmutableArray.CreateBuilder<SyntaxTree>();
+		trees.Add(ParseSource(_pageSource, "Page.cs"));
+
+		for (var index = 0; index < _additionalSources.Length; index++)
+			trees.Add(ParseSource(_additionalSources[index], $"Additional{index}.cs"));
+
+		if (includeGeneratedSources)
+		{
+			ArgumentNullException.ThrowIfNull(generatedVersion);
+			var sourceCompilation = compilation.AddSyntaxTrees(trees);
+
+			foreach (var root in generatedVersion.GeneratedRoots)
+			{
+				if (sourceCompilation.GetTypeByMetadataName(root.TypeName) is null)
+					continue;
+
+				if (root.InitializeComponentSource is not null)
+					trees.Add(ParseSource(root.InitializeComponentSource, $"{root.TypeName}.InitializeComponent.xsg.cs"));
+				if (root.UpdateComponentSource is not null)
+					trees.Add(ParseSource(StripGeneratedCodeAttribute(root.UpdateComponentSource), $"{root.TypeName}.UpdateComponent.uc.xsg.cs"));
+			}
+		}
+
+		return compilation.AddSyntaxTrees(trees);
+	}
+
+	IReadOnlyDictionary<string, XamlHotReloadDocument>[] CreateMainPageSnapshots(string[] xamlVersions)
+	{
+		ArgumentNullException.ThrowIfNull(xamlVersions);
+		return xamlVersions
+			.Select(static xaml => (IReadOnlyDictionary<string, XamlHotReloadDocument>)
+				new Dictionary<string, XamlHotReloadDocument>(StringComparer.Ordinal)
+				{
+					["MainPage.xaml"] = new XamlHotReloadDocument(xaml),
+				})
+			.ToArray();
+	}
+
+	ImmutableDictionary<string, XamlHotReloadAdditionalFile> CreateAdditionalFiles(
+		IReadOnlyDictionary<string, XamlHotReloadDocument> documents)
+	{
+		ArgumentNullException.ThrowIfNull(documents);
+		if (!documents.ContainsKey("MainPage.xaml"))
+			throw new ArgumentException("Each document snapshot must include MainPage.xaml.", nameof(documents));
+
+		var files = ImmutableDictionary.CreateBuilder<string, XamlHotReloadAdditionalFile>(StringComparer.Ordinal);
+		foreach (var document in documents)
+		{
+			ArgumentException.ThrowIfNullOrWhiteSpace(document.Key);
+			ArgumentNullException.ThrowIfNull(document.Value);
+			ArgumentNullException.ThrowIfNull(document.Value.Text);
+
+			var relativePath = document.Key.Replace('\\', '/');
+			if (Path.IsPathRooted(relativePath) || relativePath.Split('/').Any(static segment => segment == ".."))
+				throw new ArgumentException("Document paths must be relative to the test project.", nameof(documents));
+
+			var xamlPath = Path.Combine(Path.GetDirectoryName(XamlPath)!, relativePath);
+			var options = document.Value;
+			var file = new SourceGeneratorDriver.AdditionalFile(
+				SourceGeneratorDriver.ToAdditionalText(xamlPath, options.Text),
+				options.Kind,
+				relativePath,
+				options.TargetPath ?? $"{AssemblyName}/{relativePath}",
+				options.ManifestResourceName,
+				options.TargetFramework,
+				options.NoWarn,
+				EnableIncrementalHotReload: true);
+			files.Add(document.Key, new XamlHotReloadAdditionalFile(options, file));
+		}
+
+		return files.ToImmutable();
+	}
+
+	static GeneratorDriver UpdateAdditionalTexts(
+		GeneratorDriver driver,
+		ImmutableDictionary<string, XamlHotReloadAdditionalFile> previousFiles,
+		ImmutableDictionary<string, XamlHotReloadAdditionalFile> currentFiles)
+	{
+		foreach (var previousFile in previousFiles)
+		{
+			if (!currentFiles.ContainsKey(previousFile.Key))
+				driver = driver.RemoveAdditionalTexts([previousFile.Value.File.Text]);
+		}
+
+		foreach (var currentFile in currentFiles)
+		{
+			if (!previousFiles.TryGetValue(currentFile.Key, out var previousFile))
+				driver = driver.AddAdditionalTexts([currentFile.Value.File.Text]);
+			else if (previousFile.Document != currentFile.Value.Document)
+				driver = driver.ReplaceAdditionalText(previousFile.File.Text, currentFile.Value.File.Text);
+		}
+
+		return driver;
+	}
+
+	static SyntaxTree ParseSource(string source, string path) =>
+		CSharpSyntaxTree.ParseText(source, path: path, encoding: Encoding.UTF8);
+
+	static ImmutableArray<XamlHotReloadGeneratedRoot> FindGeneratedRoots(GeneratorDriverRunResult result)
+	{
+		var roots = new Dictionary<string, XamlHotReloadGeneratedRootBuilder>(StringComparer.Ordinal);
+		foreach (var generatorResult in result.Results)
+		{
+			foreach (var source in generatorResult.GeneratedSources)
+			{
+				var hintName = source.HintName;
+				if (!hintName.EndsWith(".xsg.cs", StringComparison.OrdinalIgnoreCase))
+					continue;
+
+				var sourceText = source.SourceText.ToString();
+				var typeName = FindGeneratedRootTypeName(sourceText);
+				if (typeName is null)
+					continue;
+
+				if (!roots.TryGetValue(typeName, out var root))
+				{
+					root = new XamlHotReloadGeneratedRootBuilder(typeName);
+					roots.Add(typeName, root);
+				}
+
+				if (hintName.Contains("uc.xsg", StringComparison.OrdinalIgnoreCase))
+					root.UpdateComponentSource = sourceText;
+				else
+					root.InitializeComponentSource = sourceText;
+			}
+		}
+
+		return [.. roots.Values
+			.OrderBy(static root => root.TypeName, StringComparer.Ordinal)
+			.Select(static root => new XamlHotReloadGeneratedRoot(
+				root.TypeName,
+				root.InitializeComponentSource,
+				root.UpdateComponentSource))];
+	}
+
+	static string? FindGeneratedRootTypeName(string source)
+	{
+		var root = CSharpSyntaxTree.ParseText(source).GetRoot();
+		var type = root.DescendantNodes()
+			.OfType<Microsoft.CodeAnalysis.CSharp.Syntax.TypeDeclarationSyntax>()
+			.FirstOrDefault(static candidate => candidate.Members
+				.OfType<Microsoft.CodeAnalysis.CSharp.Syntax.MethodDeclarationSyntax>()
+				.Any(static method => method.Identifier.ValueText is "InitializeComponent" or "UpdateComponent"));
+		if (type is null)
+			return null;
+
+		var namespaces = new Stack<string>();
+		var types = new Stack<string>();
+		for (SyntaxNode? current = type; current is not null; current = current.Parent)
+		{
+			switch (current)
+			{
+				case Microsoft.CodeAnalysis.CSharp.Syntax.BaseNamespaceDeclarationSyntax @namespace:
+					namespaces.Push(@namespace.Name.ToString());
+					break;
+				case Microsoft.CodeAnalysis.CSharp.Syntax.TypeDeclarationSyntax nestedType:
+					types.Push(nestedType.Identifier.ValueText);
+					break;
+			}
+		}
+
+		return string.Join(".", namespaces.Concat(types));
+	}
+
+	static string StripGeneratedCodeAttribute(string source) =>
+		GeneratedCodeAttributeRegex.Replace(source, "");
+
+	static string FormatDiagnostics(IEnumerable<Diagnostic> diagnostics) =>
+		string.Join(Environment.NewLine, diagnostics.Select(static diagnostic =>
+			$"{diagnostic.Id}: {diagnostic.GetMessage()} at {diagnostic.Location}"));
+
+	static string SanitizeIdentifier(string value)
+	{
+		var characters = value
+			.Select(static character => char.IsLetterOrDigit(character) ? character : '_')
+			.ToArray();
+		return new string(characters);
+	}
+}
+
+internal sealed record XamlHotReloadGeneration(
+	string ScenarioIdentity,
+	ImmutableArray<XamlHotReloadGeneratedVersion> Versions)
+{
+	public XamlHotReloadGeneratedVersion this[int index] => Versions[index];
+}
+
+internal sealed record XamlHotReloadDocument(
+	string Text,
+	string Kind = "Xaml",
+	string? TargetPath = null,
+	string? ManifestResourceName = null,
+	string? TargetFramework = "net11.0",
+	string? NoWarn = null);
+
+internal sealed record XamlHotReloadGeneratedVersion(
+	string ScenarioIdentity,
+	int Index,
+	string Xaml,
+	string? InitializeComponentSource,
+	string? UpdateComponentSource,
+	GeneratorDriverRunResult GeneratorResult,
+	ImmutableArray<XamlHotReloadGeneratedRoot> GeneratedRoots,
+	ImmutableDictionary<string, XamlHotReloadDocument> Documents);
+
+internal sealed record XamlHotReloadGeneratedRoot(
+	string TypeName,
+	string? InitializeComponentSource,
+	string? UpdateComponentSource);
+
+internal sealed record XamlHotReloadCompiledVersion(
+	XamlHotReloadGeneratedVersion GeneratedVersion,
+	CSharpCompilation Compilation,
+	ImmutableArray<byte> PeImage,
+	ImmutableArray<byte> PdbImage);
+
+sealed record XamlHotReloadAdditionalFile(
+	XamlHotReloadDocument Document,
+	SourceGeneratorDriver.AdditionalFile File);
+
+sealed class XamlHotReloadGeneratedRootBuilder(string typeName)
+{
+	public string TypeName { get; } = typeName;
+	public string? InitializeComponentSource { get; set; }
+	public string? UpdateComponentSource { get; set; }
+}
+
+internal sealed class XamlHotReloadLiveSession : IDisposable
+{
+	readonly XamlHotReloadTestHarness _harness;
+	readonly XamlHotReloadGeneration _generation;
+	Assembly? _assembly;
+	EmitBaseline? _baseline;
+	XamlHotReloadCompiledVersion? _compiledVersion;
+	readonly List<object> _instances = [];
+	AssemblyLoadContext? _loadContext;
+	ModuleMetadata? _moduleMetadata;
+	Type? _pageType;
+	bool _disposed;
+	int _versionIndex;
+
+	public XamlHotReloadLiveSession(
+		XamlHotReloadTestHarness harness,
+		XamlHotReloadGeneration generation)
+	{
+		_harness = harness;
+		_generation = generation;
+		_compiledVersion = harness.Compile(generation[0]);
+		_moduleMetadata = ModuleMetadata.CreateFromImage(_compiledVersion.PeImage);
+		_baseline = EmitBaseline.CreateInitialBaseline(
+			_compiledVersion.Compilation,
+			_moduleMetadata,
+			debugInformationProvider: static _ => default,
+			localSignatureProvider: static _ => default,
+			hasPortableDebugInformation: true);
+
+		_loadContext = new AssemblyLoadContext(
+			$"XamlHotReload_{harness.ScenarioIdentity}",
+			isCollectible: true);
+		Assert.True(_loadContext.IsCollectible);
+
+		using var peStream = new MemoryStream(_compiledVersion.PeImage.ToArray(), writable: false);
+		using var pdbStream = new MemoryStream(_compiledVersion.PdbImage.ToArray(), writable: false);
+		_assembly = _loadContext.LoadFromStream(peStream, pdbStream);
+		_pageType = _assembly.GetType(harness.PageClass);
+		Assert.NotNull(_pageType);
+		CreateInstance();
+	}
+
+	public object Instance =>
+		_instances.FirstOrDefault() ?? throw new ObjectDisposedException(nameof(XamlHotReloadLiveSession));
+
+	public T GetInstance<T>() where T : class =>
+		Assert.IsAssignableFrom<T>(Instance);
+
+	public T CreateInstance<T>() where T : class =>
+		Assert.IsAssignableFrom<T>(CreateInstance());
+
+	public T ApplyUpdate<T>(int versionIndex) where T : class
+	{
+		ObjectDisposedException.ThrowIf(_disposed, this);
+
+		if (versionIndex != _versionIndex + 1)
+			throw new ArgumentOutOfRangeException(nameof(versionIndex), "Updates must be applied sequentially.");
+
+		var nextVersion = _harness.Compile(_generation[versionIndex]);
+		var semanticEdits = CreateSemanticEdits(
+			_compiledVersion!.Compilation,
+			nextVersion.Compilation,
+			_compiledVersion.GeneratedVersion,
+			nextVersion.GeneratedVersion);
+
+		_harness.ApplicationHost?.Dispatch(() => ApplyUpdate(nextVersion, semanticEdits));
+		if (_harness.ApplicationHost is null)
+			ApplyUpdate(nextVersion, semanticEdits);
+
+		return Assert.IsAssignableFrom<T>(Instance);
+	}
+
+	public void Dispose()
+	{
+		if (_disposed)
+			return;
+
+		_disposed = true;
+		foreach (var instance in _instances)
+		{
+			if (instance is global::Microsoft.Maui.Controls.Page page)
+				_harness.ApplicationHost?.Detach(page);
+			global::Microsoft.Maui.Controls.Xaml.XamlComponentRegistry.Unregister(instance);
+		}
+		_instances.Clear();
+		_pageType = null;
+		_assembly = null;
+		_compiledVersion = null;
+		_baseline = null;
+		_moduleMetadata?.Dispose();
+		_moduleMetadata = null;
+
+		var loadContext = _loadContext;
+		_loadContext = null;
+		loadContext?.Unload();
+	}
+
+	object CreateInstance()
+	{
+		ObjectDisposedException.ThrowIf(_disposed, this);
+
+		var instance = Activator.CreateInstance(_pageType!);
+		Assert.NotNull(instance);
+		if (_instances.Count == 0 && instance is global::Microsoft.Maui.Controls.Page page)
+			_harness.ApplicationHost?.Attach(page);
+		_instances.Add(instance!);
+		return instance;
+	}
+
+	void ApplyUpdate(
+		XamlHotReloadCompiledVersion nextVersion,
+		XamlHotReloadSemanticEdits semanticEdits)
+	{
+		Assert.NotEmpty(semanticEdits.Edits);
+
+		using var metadataDelta = new MemoryStream();
+		using var ilDelta = new MemoryStream();
+		using var pdbDelta = new MemoryStream();
+		var difference = nextVersion.Compilation.EmitDifference(
+			_baseline!,
+			semanticEdits.Edits,
+			isAddedSymbol: symbol => semanticEdits.InsertedSymbols.Contains(symbol, SymbolEqualityComparer.Default),
+			metadataDelta,
+			ilDelta,
+			pdbDelta,
+			CancellationToken.None);
+		Assert.True(
+			difference.Success,
+			$"EmitDifference failed:{Environment.NewLine}{string.Join(Environment.NewLine, difference.Diagnostics)}");
+
+		MetadataUpdater.ApplyUpdate(
+			_assembly!,
+			metadataDelta.ToArray(),
+			ilDelta.ToArray(),
+			pdbDelta.ToArray());
+
+		foreach (var instance in _instances)
+		{
+			if (!semanticEdits.AffectedTypes.Contains(instance.GetType().FullName!, StringComparer.Ordinal))
+				continue;
+
+			var updateMethod = instance.GetType().GetMethod(
+				"UpdateComponent",
+				BindingFlags.Instance | BindingFlags.NonPublic | BindingFlags.Public);
+			Assert.NotNull(updateMethod);
+			updateMethod!.Invoke(instance, null);
+		}
+
+		_baseline = difference.Baseline;
+		_compiledVersion = nextVersion;
+		_versionIndex = nextVersion.GeneratedVersion.Index;
+	}
+
+	static XamlHotReloadSemanticEdits CreateSemanticEdits(
+		CSharpCompilation previousCompilation,
+		CSharpCompilation nextCompilation,
+		XamlHotReloadGeneratedVersion previousVersion,
+		XamlHotReloadGeneratedVersion nextVersion)
+	{
+		var edits = ImmutableArray.CreateBuilder<SemanticEdit>();
+		var insertedSymbols = ImmutableArray.CreateBuilder<ISymbol>();
+		var affectedTypes = ImmutableArray.CreateBuilder<string>();
+		foreach (var nextRoot in nextVersion.GeneratedRoots)
+		{
+			if (nextRoot.UpdateComponentSource is null)
+				continue;
+
+			var previousType = previousCompilation.GetTypeByMetadataName(nextRoot.TypeName);
+			var nextType = nextCompilation.GetTypeByMetadataName(nextRoot.TypeName);
+			if (previousType is null || nextType is null)
+				continue;
+
+			var previousInitializeComponent = GetPartialImplementation(previousType, "InitializeComponent");
+			var nextInitializeComponent = GetPartialImplementation(nextType, "InitializeComponent");
+			edits.Add(new SemanticEdit(
+				SemanticEditKind.Update,
+				previousInitializeComponent,
+				nextInitializeComponent));
+
+			var previousUpdateComponent = previousType
+				.GetMembers("UpdateComponent")
+				.OfType<IMethodSymbol>()
+				.SingleOrDefault();
+			var nextUpdateComponent = nextType
+				.GetMembers("UpdateComponent")
+				.OfType<IMethodSymbol>()
+				.SingleOrDefault();
+			Assert.NotNull(nextUpdateComponent);
+			if (previousUpdateComponent is null)
+			{
+				edits.Add(new SemanticEdit(SemanticEditKind.Insert, null, nextUpdateComponent));
+				insertedSymbols.Add(nextUpdateComponent!);
+			}
+			else
+			{
+				edits.Add(new SemanticEdit(SemanticEditKind.Update, previousUpdateComponent, nextUpdateComponent));
+			}
+
+			affectedTypes.Add(nextRoot.TypeName);
+		}
+
+		return new XamlHotReloadSemanticEdits(
+			edits.ToImmutable(),
+			insertedSymbols.ToImmutable(),
+			affectedTypes.ToImmutable());
+	}
+
+	static IMethodSymbol GetPartialImplementation(INamedTypeSymbol type, string methodName)
+	{
+		var method = type.GetMembers(methodName).OfType<IMethodSymbol>().First();
+		return method.PartialImplementationPart ?? method;
+	}
+}
+
+sealed record XamlHotReloadSemanticEdits(
+	ImmutableArray<SemanticEdit> Edits,
+	ImmutableArray<ISymbol> InsertedSymbols,
+	ImmutableArray<string> AffectedTypes);
diff --git a/src/Controls/tests/SourceGen.UnitTests/MetadataUpdateFactAttribute.cs b/src/Controls/tests/SourceGen.UnitTests/MetadataUpdateFactAttribute.cs
index 8c27ffb29070..6a1b81c12b08 100644
--- a/src/Controls/tests/SourceGen.UnitTests/MetadataUpdateFactAttribute.cs
+++ b/src/Controls/tests/SourceGen.UnitTests/MetadataUpdateFactAttribute.cs
@@ -1,10 +1,39 @@
 #nullable enable
 
+using System;
 using System.Reflection.Metadata;
 using Xunit;
 
 namespace Microsoft.Maui.Controls.SourceGen.UnitTests;
 
+internal static class MetadataUpdateRequirements
+{
+	internal const string EnableVariable = "DOTNET_MODIFIABLE_ASSEMBLIES";
+	internal const string SkipMessage = "Requires runtime support for applying metadata updates. " +
+		"Set DOTNET_MODIFIABLE_ASSEMBLIES=debug in the environment to run these tests.";
+
+	internal static string? GetSkipReasonOrThrowIfMisconfigured()
+		=> GetSkipReasonOrThrowIfMisconfigured(
+			MetadataUpdater.IsSupported,
+			Environment.GetEnvironmentVariable(EnableVariable));
+
+	internal static string? GetSkipReasonOrThrowIfMisconfigured(bool isSupported, string? modifiableAssemblies)
+	{
+		if (isSupported)
+			return null;
+
+		if (!string.IsNullOrWhiteSpace(modifiableAssemblies))
+		{
+			throw new InvalidOperationException(
+				$"Metadata update support was explicitly requested via {EnableVariable}={modifiableAssemblies}, " +
+				"but MetadataUpdater.IsSupported is false. Fix the test host/runtime configuration rather than " +
+				"silently skipping the hot reload tests.");
+		}
+
+		return SkipMessage;
+	}
+}
+
 /// <summary>
 /// A <see cref="FactAttribute"/> that skips the test when the runtime does not support applying
 /// metadata updates (<see cref="MetadataUpdater.IsSupported"/> is <see langword="false"/>).
@@ -14,17 +43,28 @@ namespace Microsoft.Maui.Controls.SourceGen.UnitTests;
 /// with <c>DOTNET_MODIFIABLE_ASSEMBLIES=debug</c> (Visual Studio sets it automatically when
 /// debugging; <c>dotnet test</c> honors it when set in the environment). When it is not set,
 /// <see cref="MetadataUpdater.IsSupported"/> is <see langword="false"/> and the tests cannot run,
-/// so they are skipped rather than failed. This mirrors how dotnet/runtime gates its own
-/// <c>ApplyUpdate</c> tests.
+/// so they are skipped rather than failed. If metadata updates were explicitly requested via
+/// <c>DOTNET_MODIFIABLE_ASSEMBLIES</c> but the runtime still reports
+/// <see cref="MetadataUpdater.IsSupported"/> as <see langword="false"/>, test discovery throws so
+/// the configuration issue cannot silently go green. This mirrors how dotnet/runtime gates its own
+/// <c>ApplyUpdate</c> tests while still surfacing misconfiguration.
 /// </summary>
 public sealed class MetadataUpdateFactAttribute : FactAttribute
 {
 	public MetadataUpdateFactAttribute()
 	{
-		if (!MetadataUpdater.IsSupported)
-		{
-			Skip = "Requires runtime support for applying metadata updates. " +
-				"Set DOTNET_MODIFIABLE_ASSEMBLIES=debug in the environment to run these tests.";
-		}
+		Skip = MetadataUpdateRequirements.GetSkipReasonOrThrowIfMisconfigured();
+	}
+}
+
+/// <summary>
+/// A <see cref="TheoryAttribute"/> that skips the test when the runtime does not support applying
+/// metadata updates (<see cref="MetadataUpdater.IsSupported"/> is <see langword="false"/>).
+/// </summary>
+public sealed class MetadataUpdateTheoryAttribute : TheoryAttribute
+{
+	public MetadataUpdateTheoryAttribute()
+	{
+		Skip = MetadataUpdateRequirements.GetSkipReasonOrThrowIfMisconfigured();
 	}
 }
diff --git a/src/Controls/tests/SourceGen.UnitTests/MetadataUpdateFactAttributeTests.cs b/src/Controls/tests/SourceGen.UnitTests/MetadataUpdateFactAttributeTests.cs
new file mode 100644
index 000000000000..96fc9f5b5354
--- /dev/null
+++ b/src/Controls/tests/SourceGen.UnitTests/MetadataUpdateFactAttributeTests.cs
@@ -0,0 +1,38 @@
+#nullable enable
+
+using System;
+using Xunit;
+
+namespace Microsoft.Maui.Controls.SourceGen.UnitTests;
+
+public class MetadataUpdateFactAttributeTests
+{
+	[Theory]
+	[InlineData(true, null)]
+	[InlineData(false, MetadataUpdateRequirements.SkipMessage)]
+	public void FactAttribute_ReflectsRuntimeSupport(bool isSupported, string? expectedSkip)
+	{
+		var attribute = new TestMetadataUpdateFactAttribute(isSupported, modifiableAssemblies: null);
+		Assert.Equal(expectedSkip, attribute.Skip);
+	}
+
+	[Theory]
+	[InlineData("debug")]
+	[InlineData("DEBUG")]
+	[InlineData("not-debug")]
+	public void FactAttribute_ThrowsWhenMetadataUpdatesWereExplicitlyRequestedButUnavailable(string modifiableAssemblies)
+	{
+		var exception = Assert.Throws<InvalidOperationException>(
+			() => new TestMetadataUpdateFactAttribute(isSupported: false, modifiableAssemblies));
+		Assert.Contains(MetadataUpdateRequirements.EnableVariable, exception.Message, StringComparison.Ordinal);
+		Assert.Contains(modifiableAssemblies, exception.Message, StringComparison.Ordinal);
+	}
+
+	sealed class TestMetadataUpdateFactAttribute : FactAttribute
+	{
+		public TestMetadataUpdateFactAttribute(bool isSupported, string? modifiableAssemblies)
+		{
+			Skip = MetadataUpdateRequirements.GetSkipReasonOrThrowIfMisconfigured(isSupported, modifiableAssemblies);
+		}
+	}
+}
diff --git a/src/Controls/tests/SourceGen.UnitTests/SourceGenContextTests.cs b/src/Controls/tests/SourceGen.UnitTests/SourceGenContextTests.cs
new file mode 100644
index 000000000000..e4c9cf0344a5
--- /dev/null
+++ b/src/Controls/tests/SourceGen.UnitTests/SourceGenContextTests.cs
@@ -0,0 +1,38 @@
+#nullable enable
+
+using System.Collections.Generic;
+using Microsoft.CodeAnalysis;
+using Xunit;
+
+namespace Microsoft.Maui.Controls.SourceGen.UnitTests;
+
+public class SourceGenContextTests
+{
+	[Fact]
+	public void BufferedDiagnostics_AreForwardedOnlyWhenFlushed()
+	{
+		var forwardedDiagnostics = new List<Diagnostic>();
+		var context = SourceGenContext.CreateNewForTests(forwardedDiagnostics.Add);
+		var childContext = SourceGenContext.CreateNewForTests();
+		childContext.ParentContext = context;
+		var discardedDiagnostic = Diagnostic.Create(Descriptors.XamlParserError, Location.None, "discarded");
+
+		context.BeginDiagnosticBuffering();
+		childContext.ReportDiagnostic(discardedDiagnostic);
+
+		Assert.Empty(forwardedDiagnostics);
+		Assert.Equal(1, context.BufferedDiagnosticCount);
+
+		context.DiscardBufferedDiagnostics();
+		Assert.Empty(forwardedDiagnostics);
+		Assert.Equal(0, context.BufferedDiagnosticCount);
+
+		var flushedDiagnostic = Diagnostic.Create(Descriptors.XamlParserError, Location.None, "flushed");
+		context.BeginDiagnosticBuffering();
+		context.ReportDiagnostic(flushedDiagnostic);
+		context.FlushBufferedDiagnostics();
+
+		Assert.Equal([flushedDiagnostic], forwardedDiagnostics);
+		Assert.Equal(0, context.BufferedDiagnosticCount);
+	}
+}
diff --git a/src/Controls/tests/SourceGen.UnitTests/SourceGeneratorDriver.cs b/src/Controls/tests/SourceGen.UnitTests/SourceGeneratorDriver.cs
index 7c74dfc1bb6a..d90d357b1b63 100644
--- a/src/Controls/tests/SourceGen.UnitTests/SourceGeneratorDriver.cs
+++ b/src/Controls/tests/SourceGen.UnitTests/SourceGeneratorDriver.cs
@@ -18,7 +18,7 @@ public static class SourceGeneratorDriver
 {
 	private static MetadataReference[]? MauiReferences;
 
-	public record AdditionalFile(AdditionalText Text, string Kind, string RelativePath, string? TargetPath, string? ManifestResourceName, string? TargetFramework, string? NoWarn, string LineInfo="enable", bool EnablePreviewFeatures = true, bool EnableIncrementalHotReload = false);
+	public record AdditionalFile(AdditionalText Text, string Kind, string RelativePath, string? TargetPath, string? ManifestResourceName, string? TargetFramework, string? NoWarn, string LineInfo = "enable", bool EnablePreviewFeatures = true, bool EnableIncrementalHotReload = false);
 	public static GeneratorDriverRunResult RunGenerator<T>(Compilation compilation, AdditionalFile additionalFile, bool assertNoCompilationErrors = true)
 		where T : IIncrementalGenerator, new()
 		=> RunGenerator<T>(compilation, additionalFiles: [additionalFile], assertNoCompilationErrors);
@@ -98,6 +98,9 @@ public static Compilation CreateMauiCompilation(string name = $"{nameof(SourceGe
 
 	public static AdditionalText ToAdditionalText(string path, string text) => CustomAdditionalText.From(path, text);
 
+	internal static AnalyzerConfigOptionsProvider CreateAnalyzerConfigOptionsProvider(params AdditionalFile[] additionalFiles) =>
+		new CustomAnalyzerConfigOptionsProvider(additionalFiles);
+
 	private static MetadataReference[] GetMauiReferences()
 	{
 		string dotNetAssemblyPath = Path.GetDirectoryName(typeof(object).Assembly.Location)!;
@@ -184,7 +187,7 @@ public override bool TryGetValue(string key, [NotNullWhen(true)] out string? val
 #endif
 					"build_property.EnableMauiXamlDiagnostics" => "true",
 					"build_property.EnableMauiIncrementalHotReload" => _additionalFile.EnableIncrementalHotReload ? "true" : "false",
-					"build_property.MauiXamlLineInfo" => _additionalFile.LineInfo != "default" ?  _additionalFile.LineInfo : null,
+					"build_property.MauiXamlLineInfo" => _additionalFile.LineInfo != "default" ? _additionalFile.LineInfo : null,
 					"build_property.MauiXamlNoWarn" => _additionalFile.NoWarn,
 					"build_property.EnablePreviewFeatures" => _additionalFile.EnablePreviewFeatures ? "true" : null,
 
diff --git a/src/Controls/tests/SourceGen.UnitTests/XamlIncrementalHotReloadE2ETests.cs b/src/Controls/tests/SourceGen.UnitTests/XamlIncrementalHotReloadE2ETests.cs
index 7479701c37f1..7161c919628b 100644
--- a/src/Controls/tests/SourceGen.UnitTests/XamlIncrementalHotReloadE2ETests.cs
+++ b/src/Controls/tests/SourceGen.UnitTests/XamlIncrementalHotReloadE2ETests.cs
@@ -1,221 +1,36 @@
-// End-to-end tests for XAML Incremental Hot Reload.
-//
-// These tests exercise the full pipeline, from XAML → SourceGen → Compile → Load → ApplyUpdate:
-//   1. Run the XamlGenerator on XAML V1 → get generated InitializeComponent C# source.
-//   2. Compile that C# into an in-memory assembly, load it, create an instance.
-//   3. Run the XamlGenerator on XAML V2 → get generated UpdateComponent C# source.
-//   4. Compile V2, EmitDifference from V1→V2, MetadataUpdater.ApplyUpdate.
-//   5. Call UpdateComponent() on the live instance via reflection.
-//   6. Assert that properties changed on the live MAUI object tree.
-//
-// Follows the pattern from: https://gist.github.com/StephaneDelcroix/2ed08a8ff3632ce7341c3c2c16d338b2
-
 #nullable enable
 
 using System;
 using System.Collections.Generic;
-using System.Collections.Immutable;
-using System.IO;
 using System.Linq;
-using System.Reflection;
 using System.Reflection.Metadata;
-using System.Runtime.Loader;
-using Microsoft.CodeAnalysis;
-using Microsoft.CodeAnalysis.CSharp;
-using Microsoft.CodeAnalysis.Emit;
+using System.Runtime.CompilerServices;
 using Microsoft.Maui.Controls.SourceGen;
+using Microsoft.Maui.Controls.SourceGen.UnitTests.HotReload;
 using Microsoft.Maui.Controls.Xaml;
 using Microsoft.Maui.Controls.Xaml.Diagnostics;
-using Microsoft.Maui.Controls.Xaml.UnitTests.SourceGen;
 using Xunit;
 
 namespace Microsoft.Maui.Controls.SourceGen.UnitTests;
 
 /// <summary>
-/// True end-to-end tests: XAML → SourceGen → Compile → Load → Hot Reload → Verify.
+/// True end-to-end tests: XAML -> SourceGen -> Compile -> Load -> Hot Reload -> Verify.
 /// Uses <see cref="MetadataUpdater.ApplyUpdate"/> to apply deltas to a live assembly.
 /// </summary>
 [Collection("XamlHotReloadTests")]
-public class XamlIncrementalHotReloadE2ETests : IDisposable
+public class XamlIncrementalHotReloadE2ETests
 {
-	public void Dispose() => XamlHotReloadState.Reset();
-
-	const string PageRelativePath = "MainPage.xaml";
 	const string PageClass = "TestE2EApp.MainPage";
-	const string AssemblyName = "TestE2EApp";
-
-	static SourceGeneratorDriver.AdditionalFile MakeFile(string xaml) =>
-		new(
-			SourceGeneratorDriver.ToAdditionalText(PageRelativePath, xaml),
-			Kind: "Xaml",
-			RelativePath: PageRelativePath,
-			TargetPath: "TestE2EApp/MainPage.xaml",
-			ManifestResourceName: null,
-			TargetFramework: "net11.0",
-			NoWarn: null,
-			EnableIncrementalHotReload: true);
-
-	/// <summary>
-	/// Creates a Roslyn compilation with MAUI references, suitable for compiling
-	/// source-generated code that uses MAUI controls, XamlComponentRegistry, etc.
-	/// </summary>
-	static CSharpCompilation CreateMauiCompilation(params SyntaxTree[] trees)
-	{
-		var refs = GetCompilationReferences();
-		return CSharpCompilation.Create(
-			AssemblyName,
-			trees,
-			refs,
-			new CSharpCompilationOptions(OutputKind.DynamicallyLinkedLibrary));
-	}
-
-	/// <summary>
-	/// Gets metadata references for MAUI runtime assemblies + BCL.
-	/// </summary>
-	static MetadataReference[] GetCompilationReferences()
-	{
-		string dotNetAssemblyPath = Path.GetDirectoryName(typeof(object).Assembly.Location)!;
-		return
-		[
-			MetadataReference.CreateFromFile(typeof(System.Runtime.CompilerServices.InternalsVisibleToAttribute).Assembly.Location),
-			MetadataReference.CreateFromFile(Path.Combine(dotNetAssemblyPath, "mscorlib.dll")),
-			MetadataReference.CreateFromFile(Path.Combine(dotNetAssemblyPath, "System.dll")),
-			MetadataReference.CreateFromFile(Path.Combine(dotNetAssemblyPath, "System.Core.dll")),
-			MetadataReference.CreateFromFile(Path.Combine(dotNetAssemblyPath, "System.Private.CoreLib.dll")),
-			MetadataReference.CreateFromFile(Path.Combine(dotNetAssemblyPath, "System.Runtime.dll")),
-			MetadataReference.CreateFromFile(Path.Combine(dotNetAssemblyPath, "System.ObjectModel.dll")),
-			MetadataReference.CreateFromFile(typeof(Uri).Assembly.Location),
-			MetadataReference.CreateFromFile(typeof(Microsoft.Maui.Graphics.Color).Assembly.Location),
-			MetadataReference.CreateFromFile(typeof(Button).Assembly.Location),
-			MetadataReference.CreateFromFile(typeof(BindingExtension).Assembly.Location),
-			MetadataReference.CreateFromFile(typeof(Thickness).Assembly.Location),
-			MetadataReference.CreateFromFile(Assembly.Load("System.Private.Xml").Location),
-			MetadataReference.CreateFromFile(Assembly.Load("System.Xml.ReaderWriter").Location),
-			MetadataReference.CreateFromFile(typeof(IServiceProvider).Assembly.Location),
-			MetadataReference.CreateFromFile(typeof(System.ComponentModel.TypeConverter).Assembly.Location),
-			MetadataReference.CreateFromFile(typeof(System.ComponentModel.TypeDescriptor).Assembly.Location),
-		];
-	}
-
-	/// <summary>
-	/// Runs the XamlGenerator source generator to produce IC/UC code from XAML.
-	/// Returns the generated source file contents keyed by hint name suffix.
-	/// </summary>
-	(string? icSource, string? ucSource) RunSourceGen(string xaml)
-	{
-		var compilation = SourceGeneratorDriver.CreateMauiCompilation(AssemblyName);
-		var file = MakeFile(xaml);
-
-		var result = SourceGeneratorDriver.RunGenerator<XamlGenerator>(
-			compilation, file, assertNoCompilationErrors: false);
-
-		string? icSource = null, ucSource = null;
-		foreach (var gen in result.Results)
-		{
-			foreach (var src in gen.GeneratedSources)
-			{
-				if (src.HintName.EndsWith(".xsg.cs", StringComparison.OrdinalIgnoreCase)
-					&& !src.HintName.Contains("uc.xsg", StringComparison.OrdinalIgnoreCase))
-					icSource = src.SourceText.ToString();
-				if (src.HintName.Contains("uc.xsg", StringComparison.OrdinalIgnoreCase))
-					ucSource = src.SourceText.ToString();
-			}
-		}
-		return (icSource, ucSource);
-	}
-
-	/// <summary>
-	/// Runs the source generator for V1, then for V2 (with V1 cached in state),
-	/// returning both IC sources and the UC source from V2.
-	/// </summary>
-	(string icV1, string icV2, string? ucV2) RunSourceGenTwoPhase(string xamlV1, string xamlV2)
-	{
-		// Phase 1: V1 seeds state
-		var (icV1, _) = RunSourceGen(xamlV1);
-		Assert.NotNull(icV1);
-
-		// Phase 2: V2 produces UC (state now has V1 cached)
-		var compilation = SourceGeneratorDriver.CreateMauiCompilation(AssemblyName);
-		var fileV1 = MakeFile(xamlV1);
-		var fileV2 = MakeFile(xamlV2);
-
-		var (run1, run2) = SourceGeneratorDriver.RunGeneratorWithChanges<XamlGenerator>(
-			compilation,
-			applyChanges: (driver, comp) =>
-			{
-				var updatedDriver = driver
-					.ReplaceAdditionalText(fileV1.Text, fileV2.Text)
-					.WithUpdatedAnalyzerConfigOptions(new OptionsProvider([fileV2]));
-				return (updatedDriver, comp);
-			},
-			fileV1);
-
-		// Get IC from run2 (V2's InitializeComponent)
-		string? icV2 = null, ucV2 = null;
-		foreach (var gen in run2.Results)
-		{
-			foreach (var src in gen.GeneratedSources)
-			{
-				if (src.HintName.EndsWith(".xsg.cs", StringComparison.OrdinalIgnoreCase)
-					&& !src.HintName.Contains("uc.xsg", StringComparison.OrdinalIgnoreCase))
-					icV2 = src.SourceText.ToString();
-				if (src.HintName.Contains("uc.xsg", StringComparison.OrdinalIgnoreCase))
-					ucV2 = src.SourceText.ToString();
-			}
-		}
-
-		Assert.NotNull(icV2);
-		return (icV1!, icV2!, ucV2);
-	}
-
-	/// <summary>
-	/// Compiles C# sources into a PE+PDB byte pair, asserting compilation success.
-	/// </summary>
-	/// <summary>
-	/// Strips the <c>[GeneratedCode]</c> attribute from UC source to avoid CS0579 duplicate
-	/// when compiling IC + UC together (both emit it on the same partial class).
-	/// </summary>
-	static string StripGeneratedCodeAttribute(string source) =>
-		System.Text.RegularExpressions.Regex.Replace(source,
-			@"\[global::System\.CodeDom\.Compiler\.GeneratedCodeAttribute\([^\]]+\)\]\s*\n",
-			"");
-
-	static (byte[] pe, byte[] pdb, CSharpCompilation compilation) CompileSources(params string[] sources)
-	{
-		var trees = sources.Select((s, i) =>
-			CSharpSyntaxTree.ParseText(s, path: $"Source{i}.cs", encoding: System.Text.Encoding.UTF8)).ToArray();
-
-		var compilation = CreateMauiCompilation(trees);
 
-		using var peStream = new MemoryStream();
-		using var pdbStream = new MemoryStream();
-		var emitResult = compilation.Emit(peStream, pdbStream,
-			options: new EmitOptions(debugInformationFormat: DebugInformationFormat.PortablePdb));
-
-		if (!emitResult.Success)
-		{
-			var errors = string.Join("\n", emitResult.Diagnostics.Where(d => d.Severity == DiagnosticSeverity.Error));
-			Assert.Fail($"Compilation failed:\n{errors}");
-		}
-
-		return (peStream.ToArray(), pdbStream.ToArray(), compilation);
-	}
-
-	/// <summary>
-	/// Minimal partial class stub with InitializeComponentRuntime() to satisfy the generated code.
-	/// </summary>
-	const string PageStub = $$"""
+	const string PageStub = """
 		namespace TestE2EApp;
 
 		public partial class MainPage : global::Microsoft.Maui.Controls.ContentPage
 		{
-			// Declaring partial method (the source generator provides the implementing declaration)
 			private partial void InitializeComponent();
 
-			// Runtime fallback used by UC fallback path
 			public void InitializeComponentRuntime() { }
 
-			// Constructor calls IC
 			public MainPage()
 			{
 				InitializeComponent();
@@ -223,12 +38,12 @@ public MainPage()
 		}
 		""";
 
+	static XamlHotReloadTestHarness CreateHarness([CallerMemberName] string scenarioName = "") =>
+		new(scenarioName, PageClass, PageStub);
+
 	[MetadataUpdateFact]
 	public void PropertyChange_AppliedViaHotReload()
 	{
-		XamlHotReloadState.Reset();
-
-		// --- XAML V1: Label says "Hello" ---
 		const string xamlV1 = """
 			<?xml version="1.0" encoding="utf-8" ?>
 			<ContentPage xmlns="http://schemas.microsoft.com/dotnet/2021/maui"
@@ -239,8 +54,6 @@ public void PropertyChange_AppliedViaHotReload()
 			    </VerticalStackLayout>
 			</ContentPage>
 			""";
-
-		// --- XAML V2: Label says "World" ---
 		const string xamlV2 = """
 			<?xml version="1.0" encoding="utf-8" ?>
 			<ContentPage xmlns="http://schemas.microsoft.com/dotnet/2021/maui"
@@ -252,115 +65,31 @@ public void PropertyChange_AppliedViaHotReload()
 			</ContentPage>
 			""";
 
-		// Step 1: Source-gen both versions
-		var (icV1, icV2, ucV2) = RunSourceGenTwoPhase(xamlV1, xamlV2);
-		Assert.NotNull(ucV2); // UC must be generated for a property change
+		using var harness = CreateHarness();
+		var generation = harness.Generate(xamlV1, xamlV2);
+		Assert.NotNull(generation[1].UpdateComponentSource);
 
-		// Step 2: Compile V1 (IC only, no UC)
-		var (peV1, pdbV1, compilationV1) = CompileSources(PageStub, icV1);
-
-		// Step 3: Load V1, create instance
-		var alc = new AssemblyLoadContext("E2EHotReloadTest", isCollectible: true);
-		try
+		harness.RunLive(generation, live =>
 		{
-			var assembly = alc.LoadFromStream(new MemoryStream(peV1), new MemoryStream(pdbV1));
-			var pageType = assembly.GetType(PageClass)!;
-			var instance = Activator.CreateInstance(pageType)!;
-
-			// Verify V1: find the Label in the Content tree
-			var page = (ContentPage)instance;
+			var page = live.GetInstance<ContentPage>();
 			var layout = page.Content as Layout;
 			Assert.NotNull(layout);
 			var label = layout!.Children.OfType<Label>().FirstOrDefault();
 			Assert.NotNull(label);
 			Assert.Equal("Hello", label!.Text);
 
-			// Step 4: Compile V2 (IC + UC)
-			var treesV2 = new[]
-			{
-				CSharpSyntaxTree.ParseText(PageStub, path: "PageStub.cs", encoding: System.Text.Encoding.UTF8),
-				CSharpSyntaxTree.ParseText(icV2, path: "IC.cs", encoding: System.Text.Encoding.UTF8),
-				CSharpSyntaxTree.ParseText(StripGeneratedCodeAttribute(ucV2), path: "UC.cs", encoding: System.Text.Encoding.UTF8),
-			};
-			var compilationV2 = CreateMauiCompilation(treesV2);
-
-			var v2Errors = compilationV2.GetDiagnostics().Where(d => d.Severity == DiagnosticSeverity.Error).ToArray();
-			if (v2Errors.Length > 0)
-				Assert.Fail($"V2 compilation failed:\n{string.Join("\n", v2Errors.Select(e => $"{e.Id}: {e.GetMessage()}"))}");
-
-			// Step 5: Create baseline from V1
-			var moduleMetadata = ModuleMetadata.CreateFromImage(peV1);
-			var baseline = EmitBaseline.CreateInitialBaseline(
-				compilationV1,
-				moduleMetadata,
-				debugInformationProvider: handle => default,
-				localSignatureProvider: handle => default,
-				hasPortableDebugInformation: true);
-
-			// Step 6: Compute semantic edits
-			// The UpdateComponent method was added in V2 — it's a new member
-			var oldPageType = compilationV1.GetTypeByMetadataName(PageClass)!;
-			var newPageType = compilationV2.GetTypeByMetadataName(PageClass)!;
-
-			var edits = new List<SemanticEdit>();
-
-			// IC was updated (version bump)
-			// InitializeComponent is a partial method — EnC needs the implementing declaration
-			var oldICDef = oldPageType.GetMembers("InitializeComponent").OfType<IMethodSymbol>().First();
-			var newICDef = newPageType.GetMembers("InitializeComponent").OfType<IMethodSymbol>().First();
-			// PartialImplementationPart gives us the implementation; use it if available
-			var oldIC = oldICDef.PartialImplementationPart ?? oldICDef;
-			var newIC = newICDef.PartialImplementationPart ?? newICDef;
-			edits.Add(new SemanticEdit(SemanticEditKind.Update, oldIC, newIC));
-
-			// UC is new in V2
-			var newUC = newPageType.GetMembers("UpdateComponent").Single();
-			edits.Add(new SemanticEdit(SemanticEditKind.Insert, null, newUC));
-
-			// __version field syntax changed (initializer may differ) — but fields cannot be updated via EnC.
-			// The __version field was already emitted in V1 as `private int __version = 0;`.
-			// In V2, it's still `private int __version = 0;` in the generated code.
-
-			// Step 7: Emit delta
-			using var mdDelta = new MemoryStream();
-			using var ilDelta = new MemoryStream();
-			using var pdbDelta = new MemoryStream();
-
-			var diffResult = compilationV2.EmitDifference(
-				baseline, edits,
-				isAddedSymbol: s => s.Name == "UpdateComponent",
-				mdDelta, ilDelta, pdbDelta,
-				System.Threading.CancellationToken.None);
-
-			Assert.True(diffResult.Success,
-				$"EmitDifference failed:\n{string.Join("\n", diffResult.Diagnostics)}");
-
-			// Step 8: Apply the delta
-			MetadataUpdater.ApplyUpdate(assembly,
-				mdDelta.ToArray(), ilDelta.ToArray(), pdbDelta.ToArray());
-
-			// Step 9: Call UpdateComponent() on the SAME instance
-			var updateMethod = pageType.GetMethod("UpdateComponent",
-				BindingFlags.Instance | BindingFlags.NonPublic | BindingFlags.Public);
-			Assert.NotNull(updateMethod);
-			updateMethod!.Invoke(instance, null);
-
-			// Step 10: Verify the Label's Text changed to "World"
+			var updatedPage = live.ApplyUpdate<ContentPage>(1);
+			Assert.Same(page, updatedPage);
 			var updatedLabel = ((Layout)page.Content!).Children.OfType<Label>().FirstOrDefault();
 			Assert.NotNull(updatedLabel);
+			Assert.Same(label, updatedLabel);
 			Assert.Equal("World", updatedLabel!.Text);
-		}
-		finally
-		{
-			alc.Unload();
-		}
+		});
 	}
 
 	[MetadataUpdateFact]
 	public void MultiplePropertyChanges_ChainedPatches()
 	{
-		XamlHotReloadState.Reset();
-
 		const string xamlV1 = """
 			<?xml version="1.0" encoding="utf-8" ?>
 			<ContentPage xmlns="http://schemas.microsoft.com/dotnet/2021/maui"
@@ -380,65 +109,61 @@ public void MultiplePropertyChanges_ChainedPatches()
 			</ContentPage>
 			""";
 
-		// Run source gen: V1 seeds, V2 produces UC with the single V1->V2 patch (no version chain)
-		var (icV1, icV2, ucV2) = RunSourceGenTwoPhase(xamlV1, xamlV2);
-		Assert.NotNull(ucV2);
-
-		// New design: a single unconditional patch — no accumulated `if (__version == N)` version guard.
-		Assert.DoesNotContain("if (__version ==", ucV2!, StringComparison.Ordinal);
-
-		// Verify UC contains the new property values
-		Assert.Contains("\"World\"", ucV2!, StringComparison.Ordinal);
-		Assert.Contains("\"V2\"", ucV2!, StringComparison.Ordinal);
+		using var harness = CreateHarness();
+		var generation = harness.Generate(xamlV1, xamlV2);
+		var updateComponentSource = generation[1].UpdateComponentSource;
+		Assert.NotNull(updateComponentSource);
+		Assert.DoesNotContain("if (__version ==", updateComponentSource!, StringComparison.Ordinal);
+		Assert.Contains("\"World\"", updateComponentSource!, StringComparison.Ordinal);
+		Assert.Contains("\"V2\"", updateComponentSource!, StringComparison.Ordinal);
 	}
 
-	/// <summary>
-	/// Runs the generator over three successive XAML versions against the same compilation, so
-	/// <see cref="XamlHotReloadState"/> accumulates exactly as it would across live edits, and
-	/// returns the final (V3) IC + UC sources.
-	/// </summary>
-	(string icV3, string? ucV3) RunSourceGenThreePhase(string xamlV1, string xamlV2, string xamlV3)
+	[MetadataUpdateFact]
+	public void SuccessiveUpdates_AppliedToSameLiveInstance()
 	{
-		var compilation = SourceGeneratorDriver.CreateMauiCompilation(AssemblyName);
-		var fileV1 = MakeFile(xamlV1);
-		var fileV2 = MakeFile(xamlV2);
-		var fileV3 = MakeFile(xamlV3);
-
-		Microsoft.CodeAnalysis.ISourceGenerator generator = new XamlGenerator().AsSourceGenerator();
-		var options = new Microsoft.CodeAnalysis.GeneratorDriverOptions(
-			disabledOutputs: Microsoft.CodeAnalysis.IncrementalGeneratorOutputKind.None,
-			trackIncrementalGeneratorSteps: true);
-
-		Microsoft.CodeAnalysis.GeneratorDriver driver = CSharpGeneratorDriver.Create([generator], driverOptions: options)
-			.AddAdditionalTexts(System.Collections.Immutable.ImmutableArray.Create<Microsoft.CodeAnalysis.AdditionalText>(fileV1.Text))
-			.WithUpdatedAnalyzerConfigOptions(new OptionsProvider([fileV1]));
-
-		driver = driver.RunGenerators(compilation);
-		driver = driver
-			.ReplaceAdditionalText(fileV1.Text, fileV2.Text)
-			.WithUpdatedAnalyzerConfigOptions(new OptionsProvider([fileV2]))
-			.RunGenerators(compilation);
-		driver = driver
-			.ReplaceAdditionalText(fileV2.Text, fileV3.Text)
-			.WithUpdatedAnalyzerConfigOptions(new OptionsProvider([fileV3]))
-			.RunGenerators(compilation);
-
-		var run3 = driver.GetRunResult();
-		string? icV3 = null, ucV3 = null;
-		foreach (var gen in run3.Results)
-		{
-			foreach (var src in gen.GeneratedSources)
-			{
-				if (src.HintName.EndsWith(".xsg.cs", StringComparison.OrdinalIgnoreCase)
-					&& !src.HintName.Contains("uc.xsg", StringComparison.OrdinalIgnoreCase))
-					icV3 = src.SourceText.ToString();
-				if (src.HintName.Contains("uc.xsg", StringComparison.OrdinalIgnoreCase))
-					ucV3 = src.SourceText.ToString();
-			}
-		}
+		const string xamlV1 = """
+			<?xml version="1.0" encoding="utf-8" ?>
+			<ContentPage xmlns="http://schemas.microsoft.com/dotnet/2021/maui"
+			             xmlns:x="http://schemas.microsoft.com/winfx/2009/xaml"
+			             x:Class="TestE2EApp.MainPage">
+			    <Label Text="First" />
+			</ContentPage>
+			""";
+		const string xamlV2 = """
+			<?xml version="1.0" encoding="utf-8" ?>
+			<ContentPage xmlns="http://schemas.microsoft.com/dotnet/2021/maui"
+			             xmlns:x="http://schemas.microsoft.com/winfx/2009/xaml"
+			             x:Class="TestE2EApp.MainPage">
+			    <Label Text="Second" />
+			</ContentPage>
+			""";
+		const string xamlV3 = """
+			<?xml version="1.0" encoding="utf-8" ?>
+			<ContentPage xmlns="http://schemas.microsoft.com/dotnet/2021/maui"
+			             xmlns:x="http://schemas.microsoft.com/winfx/2009/xaml"
+			             x:Class="TestE2EApp.MainPage">
+			    <Label Text="Third" />
+			</ContentPage>
+			""";
+		using var harness = CreateHarness();
+		var generation = harness.Generate(xamlV1, xamlV2, xamlV3);
+		Assert.All(generation.Versions, version => Assert.NotNull(version.UpdateComponentSource));
+		Assert.DoesNotContain("if (__version ==", generation[2].UpdateComponentSource!, StringComparison.Ordinal);
 
-		Assert.NotNull(icV3);
-		return (icV3!, ucV3);
+		harness.RunLive(generation, live =>
+		{
+			var page = live.GetInstance<ContentPage>();
+			var label = Assert.IsType<Label>(page.Content);
+			Assert.Equal("First", label.Text);
+
+			Assert.Same(page, live.ApplyUpdate<ContentPage>(1));
+			Assert.Same(label, page.Content);
+			Assert.Equal("Second", label.Text);
+
+			Assert.Same(page, live.ApplyUpdate<ContentPage>(2));
+			Assert.Same(label, page.Content);
+			Assert.Equal("Third", label.Text);
+		});
 	}
 
 	/// <summary>
@@ -451,8 +176,6 @@ public void MultiplePropertyChanges_ChainedPatches()
 	[Fact]
 	public void RevertToOriginal_ProducesCompilableOutput_WithoutStalePatch()
 	{
-		XamlHotReloadState.Reset();
-
 		string Page(string headingLevel) => $$"""
 			<?xml version="1.0" encoding="utf-8" ?>
 			<ContentPage xmlns="http://schemas.microsoft.com/dotnet/2021/maui"
@@ -462,83 +185,16 @@ string Page(string headingLevel) => $$"""
 			</ContentPage>
 			""";
 
-		// V1 (valid) -> V2 (invalid enum member 'Level22') -> V3 (revert, identical to V1).
-		var (icV3, ucV3) = RunSourceGenThreePhase(Page("Level2"), Page("Level22"), Page("Level2"));
-
-		// The invalid intermediate value must NOT survive into the reverted generation.
-		if (ucV3 is not null)
-			Assert.DoesNotContain("Level22", ucV3, StringComparison.Ordinal);
-		Assert.DoesNotContain("Level22", icV3, StringComparison.Ordinal);
-
-		// And the final generated code (IC + UC) must compile — the whole point of reverting.
-		var sources = new List<string> { PageStub, icV3 };
-		if (ucV3 is not null)
-			sources.Add(StripGeneratedCodeAttribute(ucV3));
-
-		var trees = sources.Select((s, i) =>
-			CSharpSyntaxTree.ParseText(s, path: $"Source{i}.cs", encoding: System.Text.Encoding.UTF8)).ToArray();
-		var comp = CreateMauiCompilation(trees);
-		var errors = comp.GetDiagnostics().Where(d => d.Severity == DiagnosticSeverity.Error).ToArray();
-		Assert.True(errors.Length == 0,
-			$"Reverted generation should compile, but got:\n{string.Join("\n", errors.Select(e => $"{e.Id}: {e.GetMessage()}"))}");
-	}
+		using var harness = CreateHarness();
+		var generation = harness.Generate(Page("Level2"), Page("Level22"), Page("Level2"));
+		var reverted = generation[2];
 
-	/// <summary>
-	/// Runs the generator over three successive XAML versions against the same compilation and
-	/// returns the IC + UC source for EVERY phase, so a test can reason about how the generated
-	/// content identity (<c>__version</c>) and patches evolve across edits — including reverts.
-	/// </summary>
-	(string icV1, string? ucV1, string icV2, string? ucV2, string icV3, string? ucV3)
-		RunSourceGenAllPhases(string xamlV1, string xamlV2, string xamlV3)
-	{
-		var compilation = SourceGeneratorDriver.CreateMauiCompilation(AssemblyName);
-		var fileV1 = MakeFile(xamlV1);
-		var fileV2 = MakeFile(xamlV2);
-		var fileV3 = MakeFile(xamlV3);
-
-		Microsoft.CodeAnalysis.ISourceGenerator generator = new XamlGenerator().AsSourceGenerator();
-		var options = new Microsoft.CodeAnalysis.GeneratorDriverOptions(
-			disabledOutputs: Microsoft.CodeAnalysis.IncrementalGeneratorOutputKind.None,
-			trackIncrementalGeneratorSteps: true);
-
-		Microsoft.CodeAnalysis.GeneratorDriver driver = CSharpGeneratorDriver.Create([generator], driverOptions: options)
-			.AddAdditionalTexts(System.Collections.Immutable.ImmutableArray.Create<Microsoft.CodeAnalysis.AdditionalText>(fileV1.Text))
-			.WithUpdatedAnalyzerConfigOptions(new OptionsProvider([fileV1]));
-
-		driver = driver.RunGenerators(compilation);
-		var (icV1, ucV1) = ExtractICUC(driver.GetRunResult());
-
-		driver = driver
-			.ReplaceAdditionalText(fileV1.Text, fileV2.Text)
-			.WithUpdatedAnalyzerConfigOptions(new OptionsProvider([fileV2]))
-			.RunGenerators(compilation);
-		var (icV2, ucV2) = ExtractICUC(driver.GetRunResult());
-
-		driver = driver
-			.ReplaceAdditionalText(fileV2.Text, fileV3.Text)
-			.WithUpdatedAnalyzerConfigOptions(new OptionsProvider([fileV3]))
-			.RunGenerators(compilation);
-		var (icV3, ucV3) = ExtractICUC(driver.GetRunResult());
-
-		return (icV1, ucV1, icV2, ucV2, icV3, ucV3);
-	}
+		Assert.DoesNotContain("Level22", reverted.InitializeComponentSource!, StringComparison.Ordinal);
+		Assert.NotNull(reverted.UpdateComponentSource);
+		Assert.DoesNotContain("Level22", reverted.UpdateComponentSource!, StringComparison.Ordinal);
 
-	static (string ic, string? uc) ExtractICUC(Microsoft.CodeAnalysis.GeneratorDriverRunResult run)
-	{
-		string? ic = null, uc = null;
-		foreach (var gen in run.Results)
-		{
-			foreach (var src in gen.GeneratedSources)
-			{
-				if (src.HintName.EndsWith(".xsg.cs", StringComparison.OrdinalIgnoreCase)
-					&& !src.HintName.Contains("uc.xsg", StringComparison.OrdinalIgnoreCase))
-					ic = src.SourceText.ToString();
-				if (src.HintName.Contains("uc.xsg", StringComparison.OrdinalIgnoreCase))
-					uc = src.SourceText.ToString();
-			}
-		}
-		Assert.NotNull(ic);
-		return (ic!, uc);
+		var compilation = harness.Compile(reverted);
+		Assert.True(compilation.PeImage.Length > 0, "Compiled assembly should not be empty");
 	}
 
 	/// <summary>
@@ -551,8 +207,6 @@ string Page(string headingLevel) => $$"""
 	[Fact]
 	public void ContentHash_IsDeterministic_And_RevertRestoresIdentity()
 	{
-		XamlHotReloadState.Reset();
-
 		string Page(string text) => $$"""
 			<?xml version="1.0" encoding="utf-8" ?>
 			<ContentPage xmlns="http://schemas.microsoft.com/dotnet/2021/maui"
@@ -568,8 +222,13 @@ string Page(string text) => $$"""
 		int h2 = GeneratorHelpers.StableContentHash(v2);
 		Assert.NotEqual(h1, h2); // different content => different identity
 
-		// V1 -> V2 -> V1 (revert). Reverting to identical content must restore the identical identity.
-		var (icV1, _, icV2, ucV2, icV3, ucV3) = RunSourceGenAllPhases(v1, v2, v1);
+		using var harness = CreateHarness();
+		var generation = harness.Generate(v1, v2, v1);
+		var icV1 = generation[0].InitializeComponentSource!;
+		var icV2 = generation[1].InitializeComponentSource!;
+		var ucV2 = generation[1].UpdateComponentSource;
+		var icV3 = generation[2].InitializeComponentSource!;
+		var ucV3 = generation[2].UpdateComponentSource;
 
 		// Fresh instances stamp the content hash of their own generation.
 		Assert.Contains($"__version = {h1};", icV1, StringComparison.Ordinal);
@@ -618,12 +277,12 @@ string Page(string body) => $$"""
 		var v1 = Page(bodyV1);
 		var v2 = Page(bodyV2);
 
-		XamlHotReloadState.Reset();
-		var (icV1, _, _, _, icV3, _) = RunSourceGenAllPhases(v1, v2, v1);
+		using var harness = CreateHarness();
+		var generation = harness.Generate(v1, v2, v1);
 
 		// InitializeComponent for identical content must be identical regardless of edit history —
 		// every value it embeds is a pure function of the current content, not of the path taken.
-		Assert.Equal(icV1, icV3);
+		Assert.Equal(generation[0].InitializeComponentSource, generation[2].InitializeComponentSource);
 	}
 
 	/// <summary>
@@ -636,8 +295,6 @@ string Page(string body) => $$"""
 	[Fact]
 	public void UpdateComponent_OnInheritedXamlClass_CompilesWithoutHidingWarning()
 	{
-		XamlHotReloadState.Reset();
-
 		const string xaml = """
 			<?xml version="1.0" encoding="utf-8" ?>
 			<ContentPage xmlns="http://schemas.microsoft.com/dotnet/2021/maui"
@@ -647,10 +304,6 @@ public void UpdateComponent_OnInheritedXamlClass_CompilesWithoutHidingWarning()
 			</ContentPage>
 			""";
 
-		var (ic, uc) = RunSourceGen(xaml);
-		Assert.NotNull(ic);
-		Assert.NotNull(uc); // always-emit: UC present even without an edit
-
 		// Code-behind: MainPage derives from a base that ALSO declares an internal UpdateComponent().
 		const string stub = """
 			namespace TestE2EApp;
@@ -668,23 +321,19 @@ public void InitializeComponentRuntime() { }
 			}
 			""";
 
-		var trees = new[]
-		{
-			CSharpSyntaxTree.ParseText(stub, path: "Stub.cs", encoding: System.Text.Encoding.UTF8),
-			CSharpSyntaxTree.ParseText(ic!, path: "IC.cs", encoding: System.Text.Encoding.UTF8),
-			CSharpSyntaxTree.ParseText(StripGeneratedCodeAttribute(uc!), path: "UC.cs", encoding: System.Text.Encoding.UTF8),
-		};
-		var comp = CreateMauiCompilation(trees);
+		using var harness = new XamlHotReloadTestHarness(
+			nameof(UpdateComponent_OnInheritedXamlClass_CompilesWithoutHidingWarning),
+			PageClass,
+			stub);
+		var generation = harness.Generate(xaml);
+		Assert.NotNull(generation[0].UpdateComponentSource);
+		var compilation = harness.Compile(generation[0]).Compilation;
 
 		// CS0108 (member hides inherited member) must NOT appear at ANY severity — the pragma in the
 		// generated UC file must suppress it. (Checked independently of general errors so the test
 		// would fail if the pragma were missing, regardless of warnings-as-errors configuration.)
-		var cs0108 = comp.GetDiagnostics().Where(d => d.Id == "CS0108").ToArray();
+		var cs0108 = compilation.GetDiagnostics().Where(d => d.Id == "CS0108").ToArray();
 		Assert.Empty(cs0108);
-
-		var errors = comp.GetDiagnostics().Where(d => d.Severity == DiagnosticSeverity.Error).ToArray();
-		Assert.True(errors.Length == 0,
-			$"Inherited-XAML generation should compile, but got:\n{string.Join("\n", errors.Select(e => $"{e.Id}: {e.GetMessage()}"))}");
 	}
 
 	/// <summary>
@@ -700,8 +349,6 @@ public void InitializeComponentRuntime() { }
 	[MetadataUpdateFact]
 	public void UpdateRequested_ReportsXamlChange_WhenUpdateComponentBodyIsNonEmpty()
 	{
-		XamlHotReloadState.Reset();
-
 		const string switchName = "Microsoft.Maui.RuntimeFeature.IsIncrementalHotReloadEnabled";
 		AppContext.TryGetSwitch(switchName, out var previousSwitch);
 		AppContext.SetSwitch(switchName, true);
@@ -720,101 +367,42 @@ string Page(string text) => $$"""
 		var xamlV1 = Page("Hello");
 		var xamlV2 = Page("World");
 
-		var (icV1, ucV1, icV2, ucV2, _, _) = RunSourceGenAllPhases(xamlV1, xamlV2, xamlV2);
-		Assert.NotNull(ucV1); // v1: UpdateComponent() present but EMPTY (first generation, no XAML change)
-		Assert.NotNull(ucV2); // v2: UpdateComponent() carries a patch (non-empty)
+		using var harness = CreateHarness();
+		var generation = harness.Generate(xamlV1, xamlV2);
+		Assert.NotNull(generation[0].UpdateComponentSource);
+		Assert.NotNull(generation[1].UpdateComponentSource);
 
-		var (peV1, pdbV1, compilationV1) = CompileSources(PageStub, icV1, StripGeneratedCodeAttribute(ucV1!));
-
-		var alc = new AssemblyLoadContext("E2EClassifyTest", isCollectible: true);
 		IReadOnlyList<Type>? lastHandled = null;
 		EventHandler<HotReloadRequestedEventArgs> capture = (_, e) => lastHandled = e.HandledTypes;
 		HotReloadDiagnostics.UpdateRequested += capture;
 		try
 		{
-			var assembly = alc.LoadFromStream(new MemoryStream(peV1), new MemoryStream(pdbV1));
-			var pageType = assembly.GetType(PageClass)!;
-
-			// The loaded type's UpdateComponent() is EMPTY → the update is NOT a XAML change.
-			XamlIncrementalHotReloadHandler.UpdateApplication(new[] { pageType });
-			Assert.NotNull(lastHandled);
-			Assert.DoesNotContain(pageType, lastHandled!);
-
-			// Apply the V1→V2 delta: UpdateComponent()'s body becomes non-empty. The same notification now
-			// classifies the type as a XAML change.
-			var compilationV2 = CreateMauiCompilation(new[]
+			harness.RunLive(generation, live =>
 			{
-				CSharpSyntaxTree.ParseText(PageStub, path: "PageStub.cs", encoding: System.Text.Encoding.UTF8),
-				CSharpSyntaxTree.ParseText(icV2, path: "IC.cs", encoding: System.Text.Encoding.UTF8),
-				CSharpSyntaxTree.ParseText(StripGeneratedCodeAttribute(ucV2!), path: "UC.cs", encoding: System.Text.Encoding.UTF8),
+				var page = live.GetInstance<ContentPage>();
+				var pageType = page.GetType();
+				XamlComponentRegistry.Unregister(page);
+
+				// The loaded type's UpdateComponent() is EMPTY → the update is NOT a XAML change.
+				XamlIncrementalHotReloadHandler.UpdateApplication([pageType]);
+				Assert.NotNull(lastHandled);
+				Assert.DoesNotContain(pageType, lastHandled!);
+
+				// Apply the V1→V2 delta: UpdateComponent()'s body becomes non-empty. The same notification
+				// now classifies the type as a XAML change.
+				live.ApplyUpdate<ContentPage>(1);
+				XamlIncrementalHotReloadHandler.UpdateApplication([pageType]);
+				Assert.NotNull(lastHandled);
+				Assert.Contains(pageType, lastHandled!);
 			});
-			AssertNoCompileErrors(compilationV2, "V2");
-
-			var baseline = EmitBaseline.CreateInitialBaseline(
-				compilationV1, ModuleMetadata.CreateFromImage(peV1),
-				debugInformationProvider: handle => default,
-				localSignatureProvider: handle => default,
-				hasPortableDebugInformation: true);
-
-			ApplyMethodBodyDelta(assembly, compilationV1, compilationV2, baseline);
-			XamlIncrementalHotReloadHandler.UpdateApplication(new[] { pageType });
-			Assert.NotNull(lastHandled);
-			Assert.Contains(pageType, lastHandled!);
 		}
 		finally
 		{
 			HotReloadDiagnostics.UpdateRequested -= capture;
-			alc.Unload();
 			AppContext.SetSwitch(switchName, previousSwitch);
 		}
 	}
 
-	static void AssertNoCompileErrors(CSharpCompilation comp, string label)
-	{
-		var errors = comp.GetDiagnostics().Where(d => d.Severity == DiagnosticSeverity.Error).ToArray();
-		if (errors.Length > 0)
-			Assert.Fail($"{label} compilation failed:\n{string.Join("\n", errors.Select(e => $"{e.Id}: {e.GetMessage()}"))}");
-	}
-
-	/// <summary>
-	/// Emits an EnC delta updating both <c>InitializeComponent</c> and <c>UpdateComponent</c> from
-	/// <paramref name="oldComp"/> to <paramref name="newComp"/>, applies it to the live
-	/// <paramref name="assembly"/>, and returns the updated baseline for the next delta. Every edit is
-	/// an UPDATE (never Insert/Delete) because UpdateComponent() exists from the first generation.
-	/// </summary>
-	static EmitBaseline ApplyMethodBodyDelta(
-		Assembly assembly, CSharpCompilation oldComp, CSharpCompilation newComp, EmitBaseline baseline)
-	{
-		var oldType = oldComp.GetTypeByMetadataName(PageClass)!;
-		var newType = newComp.GetTypeByMetadataName(PageClass)!;
-
-		var oldICDef = oldType.GetMembers("InitializeComponent").OfType<IMethodSymbol>().First();
-		var newICDef = newType.GetMembers("InitializeComponent").OfType<IMethodSymbol>().First();
-
-		var edits = new List<SemanticEdit>
-		{
-			new SemanticEdit(SemanticEditKind.Update,
-				oldICDef.PartialImplementationPart ?? oldICDef,
-				newICDef.PartialImplementationPart ?? newICDef),
-			new SemanticEdit(SemanticEditKind.Update,
-				oldType.GetMembers("UpdateComponent").Single(),
-				newType.GetMembers("UpdateComponent").Single()),
-		};
-
-		using var mdDelta = new MemoryStream();
-		using var ilDelta = new MemoryStream();
-		using var pdbDelta = new MemoryStream();
-		var result = newComp.EmitDifference(
-			baseline, edits,
-			isAddedSymbol: _ => false,
-			mdDelta, ilDelta, pdbDelta,
-			System.Threading.CancellationToken.None);
-		Assert.True(result.Success, $"EmitDifference failed:\n{string.Join("\n", result.Diagnostics)}");
-
-		MetadataUpdater.ApplyUpdate(assembly, mdDelta.ToArray(), ilDelta.ToArray(), pdbDelta.ToArray());
-		return result.Baseline!;
-	}
-
 	/// <summary>
 	/// The crown-jewel runtime proof of reverse version transitions (Kirill's requirement): a live
 	/// instance created at V1 (Text="Hello"), hot-reloaded forward to V2 (Text="World"), then
@@ -826,8 +414,6 @@ static EmitBaseline ApplyMethodBodyDelta(
 	[MetadataUpdateFact]
 	public void PropertyRevert_AppliedViaHotReload_ReturnsToBaseline()
 	{
-		XamlHotReloadState.Reset();
-
 		string Page(string text) => $$"""
 			<?xml version="1.0" encoding="utf-8" ?>
 			<ContentPage xmlns="http://schemas.microsoft.com/dotnet/2021/maui"
@@ -843,68 +429,29 @@ string Page(string text) => $$"""
 		var xamlV2 = Page("World");
 		var xamlV3 = Page("Hello"); // revert — byte-identical to V1
 
-		var (icV1, ucV1, icV2, ucV2, icV3, ucV3) = RunSourceGenAllPhases(xamlV1, xamlV2, xamlV3);
-		Assert.NotNull(ucV1); // always-emit: UpdateComponent() is present from the first generation
-		Assert.NotNull(ucV2);
-		Assert.NotNull(ucV3);
-
-		// Baseline V1 = IC + (empty) UC. Compiling UC into the baseline means every transition below
-		// is an UPDATE of UpdateComponent(), never an Insert — the member never churns.
-		var (peV1, pdbV1, compilationV1) = CompileSources(PageStub, icV1, StripGeneratedCodeAttribute(ucV1!));
-
-		var alc = new AssemblyLoadContext("E2ERevertTest", isCollectible: true);
-		try
-		{
-			var assembly = alc.LoadFromStream(new MemoryStream(peV1), new MemoryStream(pdbV1));
-			var pageType = assembly.GetType(PageClass)!;
-			var instance = Activator.CreateInstance(pageType)!;
-			var page = (ContentPage)instance;
-
-			string CurrentText() => ((Layout)page.Content!).Children.OfType<Label>().First().Text;
-			Assert.Equal("Hello", CurrentText());
-
-			var updateMethod = pageType.GetMethod("UpdateComponent",
-				BindingFlags.Instance | BindingFlags.NonPublic | BindingFlags.Public)!;
+		using var harness = CreateHarness();
+		var generation = harness.Generate(xamlV1, xamlV2, xamlV3);
+		Assert.All(generation.Versions, version => Assert.NotNull(version.UpdateComponentSource));
 
-			CSharpCompilation Compile(string ic, string uc) => CreateMauiCompilation(new[]
-			{
-				CSharpSyntaxTree.ParseText(PageStub, path: "PageStub.cs", encoding: System.Text.Encoding.UTF8),
-				CSharpSyntaxTree.ParseText(ic, path: "IC.cs", encoding: System.Text.Encoding.UTF8),
-				CSharpSyntaxTree.ParseText(StripGeneratedCodeAttribute(uc), path: "UC.cs", encoding: System.Text.Encoding.UTF8),
-			});
-
-			var compilationV2 = Compile(icV2, ucV2!);
-			var compilationV3 = Compile(icV3, ucV3!);
-			AssertNoCompileErrors(compilationV2, "V2");
-			AssertNoCompileErrors(compilationV3, "V3");
-
-			var baseline = EmitBaseline.CreateInitialBaseline(
-				compilationV1, ModuleMetadata.CreateFromImage(peV1),
-				debugInformationProvider: handle => default,
-				localSignatureProvider: handle => default,
-				hasPortableDebugInformation: true);
-
-			// --- Forward: V1 -> V2 (Hello -> World) ---
-			baseline = ApplyMethodBodyDelta(assembly, compilationV1, compilationV2, baseline);
-			updateMethod.Invoke(instance, null);
-			Assert.Equal("World", CurrentText());
-
-			// --- Reverse: V2 -> V3 (World -> Hello). The live instance must return to the baseline. ---
-			baseline = ApplyMethodBodyDelta(assembly, compilationV2, compilationV3, baseline);
-			updateMethod.Invoke(instance, null);
-			Assert.Equal("Hello", CurrentText());
-		}
-		finally
+		harness.RunLive(generation, live =>
 		{
-			alc.Unload();
-		}
+			var page = live.GetInstance<ContentPage>();
+			var label = ((Layout)page.Content!).Children.OfType<Label>().First();
+			Assert.Equal("Hello", label.Text);
+
+			Assert.Same(page, live.ApplyUpdate<ContentPage>(1));
+			Assert.Same(label, ((Layout)page.Content!).Children.OfType<Label>().First());
+			Assert.Equal("World", label.Text);
+
+			Assert.Same(page, live.ApplyUpdate<ContentPage>(2));
+			Assert.Same(label, ((Layout)page.Content!).Children.OfType<Label>().First());
+			Assert.Equal("Hello", label.Text);
+		});
 	}
 
 	[Fact]
 	public void IdenticalXaml_EmitsEmptyUC()
 	{
-		XamlHotReloadState.Reset();
-
 		const string xaml = """
 			<?xml version="1.0" encoding="utf-8" ?>
 			<ContentPage xmlns="http://schemas.microsoft.com/dotnet/2021/maui"
@@ -914,19 +461,17 @@ public void IdenticalXaml_EmitsEmptyUC()
 			</ContentPage>
 			""";
 
-		var (_, _, ucV2) = RunSourceGenTwoPhase(xaml, xaml);
-		// UC is always emitted (present-but-empty for unchanged XAML) so the method never disappears
-		// across generations. No content change → no patch statements in the body.
-		Assert.NotNull(ucV2);
-		Assert.Contains("internal void UpdateComponent()", ucV2!, StringComparison.Ordinal);
-		Assert.DoesNotContain("XamlComponentRegistry", ucV2!, StringComparison.Ordinal);
+		using var harness = CreateHarness();
+		var generation = harness.Generate(xaml, xaml);
+		var updateComponentSource = generation[1].UpdateComponentSource;
+		Assert.NotNull(updateComponentSource);
+		Assert.Contains("internal void UpdateComponent()", updateComponentSource!, StringComparison.Ordinal);
+		Assert.DoesNotContain("XamlComponentRegistry", updateComponentSource!, StringComparison.Ordinal);
 	}
 
 	[Fact]
 	public void GeneratedIC_CompilesCleanly()
 	{
-		XamlHotReloadState.Reset();
-
 		const string xaml = """
 			<?xml version="1.0" encoding="utf-8" ?>
 			<ContentPage xmlns="http://schemas.microsoft.com/dotnet/2021/maui"
@@ -939,19 +484,15 @@ public void GeneratedIC_CompilesCleanly()
 			</ContentPage>
 			""";
 
-		var (ic, _) = RunSourceGen(xaml);
-		Assert.NotNull(ic);
-
-		// This should compile without errors
-		var (pe, _, _) = CompileSources(PageStub, ic!);
-		Assert.True(pe.Length > 0, "Compiled assembly should not be empty");
+		using var harness = CreateHarness();
+		var generation = harness.Generate(xaml);
+		var compilation = harness.Compile(generation[0]);
+		Assert.True(compilation.PeImage.Length > 0, "Compiled assembly should not be empty");
 	}
 
 	[Fact]
 	public void GeneratedUC_CompilesCleanly()
 	{
-		XamlHotReloadState.Reset();
-
 		const string xamlV1 = """
 			<?xml version="1.0" encoding="utf-8" ?>
 			<ContentPage xmlns="http://schemas.microsoft.com/dotnet/2021/maui"
@@ -969,23 +510,46 @@ public void GeneratedUC_CompilesCleanly()
 			</ContentPage>
 			""";
 
-		var (_, icV2, ucV2) = RunSourceGenTwoPhase(xamlV1, xamlV2);
-		Assert.NotNull(ucV2);
+		using var harness = CreateHarness();
+		var generation = harness.Generate(xamlV1, xamlV2);
+		Assert.NotNull(generation[1].UpdateComponentSource);
+		var compilation = harness.Compile(generation[1]);
+		Assert.True(compilation.PeImage.Length > 0, "Compiled assembly should not be empty");
+	}
 
-		// IC + UC + stub should compile together without errors
-		var (pe, _, _) = CompileSources(PageStub, icV2, StripGeneratedCodeAttribute(ucV2!));
-		Assert.True(pe.Length > 0, "Compiled assembly should not be empty");
+	[Fact]
+	public void AdditionalCSharpSource_CompilesWithGeneratedXaml()
+	{
+		const string customControlSource = """
+			namespace TestE2EApp;
+
+			public class CustomLabel : global::Microsoft.Maui.Controls.Label
+			{
+			}
+			""";
+		const string xaml = """
+			<?xml version="1.0" encoding="utf-8" ?>
+			<ContentPage xmlns="http://schemas.microsoft.com/dotnet/2021/maui"
+			             xmlns:x="http://schemas.microsoft.com/winfx/2009/xaml"
+			             xmlns:local="clr-namespace:TestE2EApp"
+			             x:Class="TestE2EApp.MainPage">
+			    <local:CustomLabel Text="Hello" />
+			</ContentPage>
+			""";
+
+		using var harness = new XamlHotReloadTestHarness(
+			nameof(AdditionalCSharpSource_CompilesWithGeneratedXaml),
+			PageClass,
+			PageStub,
+			customControlSource);
+		var generation = harness.Generate(xaml);
+		var compilation = harness.Compile(generation[0]);
+		Assert.True(compilation.PeImage.Length > 0, "Compiled assembly should not be empty");
 	}
 
-	// Regression test for https://github.com/dotnet/maui/issues/36256:
-	// replacing the page's root content with a different control made UpdateComponent emit
-	// `this.Content = (IView)__na_0;`, which fails to compile (CS0266) because ContentPage.Content
-	// is typed View, not IView. The generated content-property assignment must not cast to IView.
 	[Fact]
 	public void RootContentReplaced_CompilesCleanly()
 	{
-		XamlHotReloadState.Reset();
-
 		const string xamlV1 = """
 			<?xml version="1.0" encoding="utf-8" ?>
 			<ContentPage xmlns="http://schemas.microsoft.com/dotnet/2021/maui"
@@ -1003,20 +567,21 @@ public void RootContentReplaced_CompilesCleanly()
 			</ContentPage>
 			""";
 
-		var (_, icV2, ucV2) = RunSourceGenTwoPhase(xamlV1, xamlV2);
-		Assert.NotNull(ucV2);
-
-		// The generated content assignment must be type-correct; CompileSources fails on CS0266.
-		Assert.DoesNotContain(".Content = (global::Microsoft.Maui.IView)", ucV2!, StringComparison.Ordinal);
-		var (pe, _, _) = CompileSources(PageStub, icV2, StripGeneratedCodeAttribute(ucV2!));
-		Assert.True(pe.Length > 0, "Compiled assembly should not be empty");
+		using var harness = CreateHarness();
+		var generation = harness.Generate(xamlV1, xamlV2);
+		var updateComponentSource = generation[1].UpdateComponentSource;
+		Assert.NotNull(updateComponentSource);
+		Assert.DoesNotContain(
+			".Content = (global::Microsoft.Maui.IView)",
+			updateComponentSource!,
+			StringComparison.Ordinal);
+		var compilation = harness.Compile(generation[1]);
+		Assert.True(compilation.PeImage.Length > 0, "Compiled assembly should not be empty");
 	}
 
 	[Fact]
 	public void ResourceAdded_CompilesCleanly()
 	{
-		XamlHotReloadState.Reset();
-
 		const string xamlV1 = """
 			<?xml version="1.0" encoding="utf-8" ?>
 			<ContentPage xmlns="http://schemas.microsoft.com/dotnet/2021/maui"
@@ -1041,19 +606,16 @@ public void ResourceAdded_CompilesCleanly()
 			</ContentPage>
 			""";
 
-		var (_, icV2, ucV2) = RunSourceGenTwoPhase(xamlV1, xamlV2);
-		Assert.NotNull(ucV2);
-
-		// IC + UC + stub should compile together without errors
-		var (pe, _, _) = CompileSources(PageStub, icV2, StripGeneratedCodeAttribute(ucV2!));
-		Assert.True(pe.Length > 0, "Compiled assembly should not be empty");
+		using var harness = CreateHarness();
+		var generation = harness.Generate(xamlV1, xamlV2);
+		Assert.NotNull(generation[1].UpdateComponentSource);
+		var compilation = harness.Compile(generation[1]);
+		Assert.True(compilation.PeImage.Length > 0, "Compiled assembly should not be empty");
 	}
 
 	[Fact]
 	public void ResourceRemoved_CompilesCleanly()
 	{
-		XamlHotReloadState.Reset();
-
 		const string xamlV1 = """
 			<?xml version="1.0" encoding="utf-8" ?>
 			<ContentPage xmlns="http://schemas.microsoft.com/dotnet/2021/maui"
@@ -1078,18 +640,16 @@ public void ResourceRemoved_CompilesCleanly()
 			</ContentPage>
 			""";
 
-		var (_, icV2, ucV2) = RunSourceGenTwoPhase(xamlV1, xamlV2);
-		Assert.NotNull(ucV2);
-
-		var (pe, _, _) = CompileSources(PageStub, icV2, StripGeneratedCodeAttribute(ucV2!));
-		Assert.True(pe.Length > 0, "Compiled assembly should not be empty");
+		using var harness = CreateHarness();
+		var generation = harness.Generate(xamlV1, xamlV2);
+		Assert.NotNull(generation[1].UpdateComponentSource);
+		var compilation = harness.Compile(generation[1]);
+		Assert.True(compilation.PeImage.Length > 0, "Compiled assembly should not be empty");
 	}
 
 	[MetadataUpdateFact]
 	public void ResourceAdded_AppliedViaHotReload()
 	{
-		XamlHotReloadState.Reset();
-
 		const string xamlV1 = """
 			<?xml version="1.0" encoding="utf-8" ?>
 			<ContentPage xmlns="http://schemas.microsoft.com/dotnet/2021/maui"
@@ -1114,80 +674,27 @@ public void ResourceAdded_AppliedViaHotReload()
 			</ContentPage>
 			""";
 
-		var (icV1, icV2, ucV2) = RunSourceGenTwoPhase(xamlV1, xamlV2);
-		Assert.NotNull(ucV2);
-
-		var (peV1, pdbV1, compilationV1) = CompileSources(PageStub, icV1);
+		using var harness = CreateHarness();
+		var generation = harness.Generate(xamlV1, xamlV2);
+		Assert.NotNull(generation[1].UpdateComponentSource);
 
-		var alc = new AssemblyLoadContext("E2EResourceAdd", isCollectible: true);
-		try
+		harness.RunLive(generation, live =>
 		{
-			var assembly = alc.LoadFromStream(new MemoryStream(peV1), new MemoryStream(pdbV1));
-			var pageType = assembly.GetType(PageClass)!;
-			var instance = Activator.CreateInstance(pageType)!;
-			var page = (ContentPage)instance;
-
-			// V1: only AccentColor
+			var page = live.GetInstance<ContentPage>();
 			Assert.True(page.Resources.ContainsKey("AccentColor"));
 			Assert.False(page.Resources.ContainsKey("SecondaryColor"));
 
-			// Compile V2 and apply delta
-			var treesV2 = new[]
-			{
-				CSharpSyntaxTree.ParseText(PageStub, path: "PageStub.cs", encoding: System.Text.Encoding.UTF8),
-				CSharpSyntaxTree.ParseText(icV2, path: "IC.cs", encoding: System.Text.Encoding.UTF8),
-				CSharpSyntaxTree.ParseText(StripGeneratedCodeAttribute(ucV2), path: "UC.cs", encoding: System.Text.Encoding.UTF8),
-			};
-			var compilationV2 = CreateMauiCompilation(treesV2);
-			var v2Errors = compilationV2.GetDiagnostics().Where(d => d.Severity == DiagnosticSeverity.Error).ToArray();
-			if (v2Errors.Length > 0)
-				Assert.Fail($"V2 compilation failed:\n{string.Join("\n", v2Errors.Select(e => $"{e.Id}: {e.GetMessage()}"))}");
-
-			var baseline = EmitBaseline.CreateInitialBaseline(
-				compilationV1,
-				ModuleMetadata.CreateFromImage(peV1),
-				debugInformationProvider: handle => default,
-				localSignatureProvider: handle => default,
-				hasPortableDebugInformation: true);
-
-			var oldPageType = compilationV1.GetTypeByMetadataName(PageClass)!;
-			var newPageType = compilationV2.GetTypeByMetadataName(PageClass)!;
-			var edits = new List<SemanticEdit>();
-			var oldIC = oldPageType.GetMembers("InitializeComponent").OfType<IMethodSymbol>().First();
-			var newIC = newPageType.GetMembers("InitializeComponent").OfType<IMethodSymbol>().First();
-			edits.Add(new SemanticEdit(SemanticEditKind.Update, oldIC.PartialImplementationPart ?? oldIC, newIC.PartialImplementationPart ?? newIC));
-			edits.Add(new SemanticEdit(SemanticEditKind.Insert, null, newPageType.GetMembers("UpdateComponent").Single()));
-
-			using var mdDelta = new MemoryStream();
-			using var ilDelta = new MemoryStream();
-			using var pdbDelta = new MemoryStream();
-			var diffResult = compilationV2.EmitDifference(baseline, edits,
-				isAddedSymbol: s => s.Name == "UpdateComponent",
-				mdDelta, ilDelta, pdbDelta, System.Threading.CancellationToken.None);
-			Assert.True(diffResult.Success, $"EmitDifference failed:\n{string.Join("\n", diffResult.Diagnostics)}");
-
-			MetadataUpdater.ApplyUpdate(assembly, mdDelta.ToArray(), ilDelta.ToArray(), pdbDelta.ToArray());
-
-			var updateMethod = pageType.GetMethod("UpdateComponent", BindingFlags.Instance | BindingFlags.NonPublic | BindingFlags.Public);
-			Assert.NotNull(updateMethod);
-			updateMethod!.Invoke(instance, null);
-
-			// V2: both resources exist
+			var updatedPage = live.ApplyUpdate<ContentPage>(1);
+			Assert.Same(page, updatedPage);
 			Assert.True(page.Resources.ContainsKey("AccentColor"), "AccentColor should still exist");
 			Assert.True(page.Resources.ContainsKey("SecondaryColor"), "SecondaryColor should be added");
 			Assert.Equal(Microsoft.Maui.Graphics.Colors.Red, page.Resources["SecondaryColor"]);
-		}
-		finally
-		{
-			alc.Unload();
-		}
+		});
 	}
 
 	[MetadataUpdateFact]
 	public void ResourceRemoved_AppliedViaHotReload()
 	{
-		XamlHotReloadState.Reset();
-
 		const string xamlV1 = """
 			<?xml version="1.0" encoding="utf-8" ?>
 			<ContentPage xmlns="http://schemas.microsoft.com/dotnet/2021/maui"
@@ -1212,79 +719,26 @@ public void ResourceRemoved_AppliedViaHotReload()
 			</ContentPage>
 			""";
 
-		var (icV1, icV2, ucV2) = RunSourceGenTwoPhase(xamlV1, xamlV2);
-		Assert.NotNull(ucV2);
-
-		var (peV1, pdbV1, compilationV1) = CompileSources(PageStub, icV1);
+		using var harness = CreateHarness();
+		var generation = harness.Generate(xamlV1, xamlV2);
+		Assert.NotNull(generation[1].UpdateComponentSource);
 
-		var alc = new AssemblyLoadContext("E2EResourceRemove", isCollectible: true);
-		try
+		harness.RunLive(generation, live =>
 		{
-			var assembly = alc.LoadFromStream(new MemoryStream(peV1), new MemoryStream(pdbV1));
-			var pageType = assembly.GetType(PageClass)!;
-			var instance = Activator.CreateInstance(pageType)!;
-			var page = (ContentPage)instance;
-
-			// V1: both resources
+			var page = live.GetInstance<ContentPage>();
 			Assert.True(page.Resources.ContainsKey("AccentColor"));
 			Assert.True(page.Resources.ContainsKey("SecondaryColor"));
 
-			// Compile V2 and apply delta
-			var treesV2 = new[]
-			{
-				CSharpSyntaxTree.ParseText(PageStub, path: "PageStub.cs", encoding: System.Text.Encoding.UTF8),
-				CSharpSyntaxTree.ParseText(icV2, path: "IC.cs", encoding: System.Text.Encoding.UTF8),
-				CSharpSyntaxTree.ParseText(StripGeneratedCodeAttribute(ucV2), path: "UC.cs", encoding: System.Text.Encoding.UTF8),
-			};
-			var compilationV2 = CreateMauiCompilation(treesV2);
-			var v2Errors = compilationV2.GetDiagnostics().Where(d => d.Severity == DiagnosticSeverity.Error).ToArray();
-			if (v2Errors.Length > 0)
-				Assert.Fail($"V2 compilation failed:\n{string.Join("\n", v2Errors.Select(e => $"{e.Id}: {e.GetMessage()}"))}");
-
-			var baseline = EmitBaseline.CreateInitialBaseline(
-				compilationV1,
-				ModuleMetadata.CreateFromImage(peV1),
-				debugInformationProvider: handle => default,
-				localSignatureProvider: handle => default,
-				hasPortableDebugInformation: true);
-
-			var oldPageType = compilationV1.GetTypeByMetadataName(PageClass)!;
-			var newPageType = compilationV2.GetTypeByMetadataName(PageClass)!;
-			var edits = new List<SemanticEdit>();
-			var oldIC = oldPageType.GetMembers("InitializeComponent").OfType<IMethodSymbol>().First();
-			var newIC = newPageType.GetMembers("InitializeComponent").OfType<IMethodSymbol>().First();
-			edits.Add(new SemanticEdit(SemanticEditKind.Update, oldIC.PartialImplementationPart ?? oldIC, newIC.PartialImplementationPart ?? newIC));
-			edits.Add(new SemanticEdit(SemanticEditKind.Insert, null, newPageType.GetMembers("UpdateComponent").Single()));
-
-			using var mdDelta = new MemoryStream();
-			using var ilDelta = new MemoryStream();
-			using var pdbDelta = new MemoryStream();
-			var diffResult = compilationV2.EmitDifference(baseline, edits,
-				isAddedSymbol: s => s.Name == "UpdateComponent",
-				mdDelta, ilDelta, pdbDelta, System.Threading.CancellationToken.None);
-			Assert.True(diffResult.Success, $"EmitDifference failed:\n{string.Join("\n", diffResult.Diagnostics)}");
-
-			MetadataUpdater.ApplyUpdate(assembly, mdDelta.ToArray(), ilDelta.ToArray(), pdbDelta.ToArray());
-
-			var updateMethod = pageType.GetMethod("UpdateComponent", BindingFlags.Instance | BindingFlags.NonPublic | BindingFlags.Public);
-			Assert.NotNull(updateMethod);
-			updateMethod!.Invoke(instance, null);
-
-			// V2: SecondaryColor removed, AccentColor remains
+			var updatedPage = live.ApplyUpdate<ContentPage>(1);
+			Assert.Same(page, updatedPage);
 			Assert.True(page.Resources.ContainsKey("AccentColor"), "AccentColor should still exist");
 			Assert.False(page.Resources.ContainsKey("SecondaryColor"), "SecondaryColor should be removed");
-		}
-		finally
-		{
-			alc.Unload();
-		}
+		});
 	}
 
 	[MetadataUpdateFact]
 	public void ResourceValueChanged_AppliedViaHotReload()
 	{
-		XamlHotReloadState.Reset();
-
 		const string xamlV1 = """
 			<?xml version="1.0" encoding="utf-8" ?>
 			<ContentPage xmlns="http://schemas.microsoft.com/dotnet/2021/maui"
@@ -1308,122 +762,18 @@ public void ResourceValueChanged_AppliedViaHotReload()
 			</ContentPage>
 			""";
 
-		var (icV1, icV2, ucV2) = RunSourceGenTwoPhase(xamlV1, xamlV2);
-		Assert.NotNull(ucV2);
-
-		var (peV1, pdbV1, compilationV1) = CompileSources(PageStub, icV1);
+		using var harness = CreateHarness();
+		var generation = harness.Generate(xamlV1, xamlV2);
+		Assert.NotNull(generation[1].UpdateComponentSource);
 
-		var alc = new AssemblyLoadContext("E2EResourceChange", isCollectible: true);
-		try
+		harness.RunLive(generation, live =>
 		{
-			var assembly = alc.LoadFromStream(new MemoryStream(peV1), new MemoryStream(pdbV1));
-			var pageType = assembly.GetType(PageClass)!;
-			var instance = Activator.CreateInstance(pageType)!;
-			var page = (ContentPage)instance;
-
-			// V1: AccentColor is DarkBlue
+			var page = live.GetInstance<ContentPage>();
 			Assert.Equal(Microsoft.Maui.Graphics.Colors.DarkBlue, page.Resources["AccentColor"]);
 
-			// Compile V2 and apply delta
-			var treesV2 = new[]
-			{
-				CSharpSyntaxTree.ParseText(PageStub, path: "PageStub.cs", encoding: System.Text.Encoding.UTF8),
-				CSharpSyntaxTree.ParseText(icV2, path: "IC.cs", encoding: System.Text.Encoding.UTF8),
-				CSharpSyntaxTree.ParseText(StripGeneratedCodeAttribute(ucV2), path: "UC.cs", encoding: System.Text.Encoding.UTF8),
-			};
-			var compilationV2 = CreateMauiCompilation(treesV2);
-			var v2Errors = compilationV2.GetDiagnostics().Where(d => d.Severity == DiagnosticSeverity.Error).ToArray();
-			if (v2Errors.Length > 0)
-				Assert.Fail($"V2 compilation failed:\n{string.Join("\n", v2Errors.Select(e => $"{e.Id}: {e.GetMessage()}"))}");
-
-			var baseline = EmitBaseline.CreateInitialBaseline(
-				compilationV1,
-				ModuleMetadata.CreateFromImage(peV1),
-				debugInformationProvider: handle => default,
-				localSignatureProvider: handle => default,
-				hasPortableDebugInformation: true);
-
-			var oldPageType = compilationV1.GetTypeByMetadataName(PageClass)!;
-			var newPageType = compilationV2.GetTypeByMetadataName(PageClass)!;
-			var edits = new List<SemanticEdit>();
-			var oldIC = oldPageType.GetMembers("InitializeComponent").OfType<IMethodSymbol>().First();
-			var newIC = newPageType.GetMembers("InitializeComponent").OfType<IMethodSymbol>().First();
-			edits.Add(new SemanticEdit(SemanticEditKind.Update, oldIC.PartialImplementationPart ?? oldIC, newIC.PartialImplementationPart ?? newIC));
-			edits.Add(new SemanticEdit(SemanticEditKind.Insert, null, newPageType.GetMembers("UpdateComponent").Single()));
-
-			using var mdDelta = new MemoryStream();
-			using var ilDelta = new MemoryStream();
-			using var pdbDelta = new MemoryStream();
-			var diffResult = compilationV2.EmitDifference(baseline, edits,
-				isAddedSymbol: s => s.Name == "UpdateComponent",
-				mdDelta, ilDelta, pdbDelta, System.Threading.CancellationToken.None);
-			Assert.True(diffResult.Success, $"EmitDifference failed:\n{string.Join("\n", diffResult.Diagnostics)}");
-
-			MetadataUpdater.ApplyUpdate(assembly, mdDelta.ToArray(), ilDelta.ToArray(), pdbDelta.ToArray());
-
-			var updateMethod = pageType.GetMethod("UpdateComponent", BindingFlags.Instance | BindingFlags.NonPublic | BindingFlags.Public);
-			Assert.NotNull(updateMethod);
-			updateMethod!.Invoke(instance, null);
-
-			// V2: AccentColor changed to Red
+			var updatedPage = live.ApplyUpdate<ContentPage>(1);
+			Assert.Same(page, updatedPage);
 			Assert.Equal(Microsoft.Maui.Graphics.Colors.Red, page.Resources["AccentColor"]);
-		}
-		finally
-		{
-			alc.Unload();
-		}
-	}
-
-	sealed class OptionsProvider : Microsoft.CodeAnalysis.Diagnostics.AnalyzerConfigOptionsProvider
-	{
-		readonly SourceGeneratorDriver.AdditionalFile[] _files;
-		public OptionsProvider(SourceGeneratorDriver.AdditionalFile[] files) => _files = files;
-
-		public override Microsoft.CodeAnalysis.Diagnostics.AnalyzerConfigOptions GlobalOptions =>
-			throw new NotImplementedException();
-
-		public override Microsoft.CodeAnalysis.Diagnostics.AnalyzerConfigOptions GetOptions(SyntaxTree tree) =>
-			throw new NotImplementedException();
-
-		public override Microsoft.CodeAnalysis.Diagnostics.AnalyzerConfigOptions GetOptions(AdditionalText textFile)
-		{
-			foreach (var f in _files)
-			{
-				if (f.Text.Path == textFile.Path)
-					return new SimpleOptions(f);
-			}
-			return EmptyOptions.Instance;
-		}
-	}
-
-	sealed class SimpleOptions : Microsoft.CodeAnalysis.Diagnostics.AnalyzerConfigOptions
-	{
-		readonly SourceGeneratorDriver.AdditionalFile _file;
-		public SimpleOptions(SourceGeneratorDriver.AdditionalFile file) => _file = file;
-
-		public override bool TryGetValue(string key, [System.Diagnostics.CodeAnalysis.NotNullWhen(true)] out string? value)
-		{
-			value = key switch
-			{
-				"build_metadata.additionalfiles.GenKind" => _file.Kind,
-				"build_metadata.additionalfiles.TargetPath" => _file.TargetPath,
-				"build_metadata.additionalfiles.ManifestResourceName" => _file.ManifestResourceName,
-				"build_metadata.additionalfiles.RelativePath" => _file.RelativePath,
-				"build_metadata.additionalfiles.Inflator" => "SourceGen",
-				"build_property.targetFramework" => _file.TargetFramework,
-				"build_property.Configuration" => "Debug",
-				"build_property.EnableMauiXamlDiagnostics" => "true",
-				"build_property.EnableMauiIncrementalHotReload" => _file.EnableIncrementalHotReload ? "true" : "false",
-				_ => null
-			};
-			return value is not null;
-		}
-	}
-
-	sealed class EmptyOptions : Microsoft.CodeAnalysis.Diagnostics.AnalyzerConfigOptions
-	{
-		public static readonly EmptyOptions Instance = new();
-		public override bool TryGetValue(string key, [System.Diagnostics.CodeAnalysis.NotNullWhen(true)] out string? value)
-		{ value = null; return false; }
+		});
 	}
 }