Add BlazorWebView.AppType to render the host page from an App.razor component

src/BlazorWebView/src/Maui/BlazorWebView.cs

@@ -1,7 +1,9 @@
 using System;
+using System.IO;
 using System.Runtime.Versioning;
 using System.Threading.Tasks;
 using Microsoft.AspNetCore.Components.Web;
+using Microsoft.Extensions.DependencyInjection;
 using Microsoft.Extensions.FileProviders;
 using Microsoft.Maui;
 using Microsoft.Maui.Controls;
@@ -50,6 +52,43 @@ public BlazorWebView()
 		/// </summary>
 		public string? HostPage { get; set; }
 
+		/// <summary>
+		/// The synthetic host page path used when <see cref="AppType"/> renders the host document.
+		/// </summary>
+		internal const string AppTypeHostPage = "wwwroot/index.html";
+
+		private Type? _appType;
+		private bool _appTypeRendered;
+		private string? _renderedHostPageHtml;
+
+		/// <summary>
+		/// Gets or sets the type of a root component that renders the entire host HTML document (the
+		/// hybrid equivalent of a Blazor Web App's <c>App.razor</c>).
+		/// <para>
+		/// When set, the component is statically rendered to produce the host page, so a physical
+		/// <see cref="HostPage"/> file (such as <c>wwwroot/index.html</c>) is not required. Interactive
+		/// components declared inside it with a render mode (for example
+		/// <c>&lt;Routes @rendermode="InteractiveAuto" /&gt;</c> or
+		/// <c>&lt;HeadOutlet @rendermode="InteractiveAuto" /&gt;</c>) are automatically attached to the
+		/// live document, so an explicit <see cref="RootComponents"/> entry is not required either.
+		/// </para>
+		/// </summary>
+		public Type? AppType
+		{
+			get => _appType;
+			set
+			{
+				_appType = value;
+
+				// Provide a synthetic host page so the existing startup and relative-path logic flows
+				// unchanged; the rendered document is overlaid onto the file provider at this path.
+				if (value is not null && string.IsNullOrEmpty(HostPage))
+				{
+					HostPage = AppTypeHostPage;
+				}
+			}
+		}
+
 		/// <summary>
 		/// Bindable property for <see cref="StartPath"/>.
 		/// </summary>
@@ -124,7 +163,56 @@ public string StartPath
 		public virtual IFileProvider CreateFileProvider(string contentRootDir)
 		{
 			// Call into the platform-specific code to get that platform's asset file provider
-			return GetBlazorWebViewHandler().CreateFileProvider(contentRootDir);
+			var platformFileProvider = GetBlazorWebViewHandler().CreateFileProvider(contentRootDir);
+
+			// Everything below is opt-in via AppType. For the legacy HostPage (index.html) path, return
+			// the platform provider unchanged so existing behaviour - including the handler's own file
+			// provider instance - is preserved exactly.
+			if (AppType is null)
+			{
+				return platformFileProvider;
+			}
+
+			// Load the bundled static web assets manifest (if present) so that @Assets fingerprinting
+			// and fingerprinted-route serving work. The manifest lives outside the web root and is read
+			// from the app package, so it is never served to the web view. Absent (or on platforms
+			// without app-package access), fingerprinting simply stays off.
+			var manifest = StaticWebAssetsManifest.TryLoad();
+
+			// Render the host document once. This also collects any interactive components declared with
+			// a render mode and registers them so they attach to the live document, and resolves @Assets
+			// using the manifest.
+			EnsureAppTypeRendered(manifest?.Assets);
+			var hostPageRelativePath = Path.GetRelativePath(contentRootDir, HostPage!);
+
+			return new BlazorWebViewFileProvider(platformFileProvider, hostPageRelativePath, _renderedHostPageHtml, manifest);
+		}
+
+		[System.Diagnostics.CodeAnalysis.UnconditionalSuppressMessage("Trimming", "IL2072",
+			Justification = "Blazor components referenced by AppType are preserved by the Razor SDK trimming roots, consistent with RootComponent.ComponentType.")]
+		private void EnsureAppTypeRendered(ResourceAssetCollection? assets)
+		{
+			if (_appTypeRendered || AppType is null)
+			{
+				return;
+			}
+
+			_appTypeRendered = true;
+
+			var services = Handler?.MauiContext?.Services
+				?? throw new InvalidOperationException($"Cannot render {nameof(AppType)} because no service provider is available.");
+
+			var result = HybridHostPageRenderer.Render(services, AppType, assets);
+			_renderedHostPageHtml = result.Html;
+
+			foreach (var registration in result.Registrations)
+			{
+				RootComponents.Add(new RootComponent
+				{
+					Selector = registration.Selector,
+					ComponentType = registration.ComponentType,
+				});
+			}
 		}
 
 		/// <summary>

src/BlazorWebView/src/Maui/BlazorWebViewFileProvider.cs

@@ -0,0 +1,98 @@
+using System;
+using System.IO;
+using System.Text;
+using Microsoft.Extensions.FileProviders;
+using Microsoft.Extensions.Primitives;
+
+namespace Microsoft.AspNetCore.Components.WebView.Maui
+{
+	/// <summary>
+	/// Wraps the platform's physical file provider to add hybrid host-page and static web asset
+	/// behaviour on top of it:
+	/// <list type="bullet">
+	/// <item><description>serves the in-memory rendered host page (the <see cref="BlazorWebView.AppType"/>
+	/// document) at the host page path, when provided; and</description></item>
+	/// <item><description>resolves fingerprinted request routes (for example <c>app.abc123.css</c>) to
+	/// their physical asset files, when a manifest is provided.</description></item>
+	/// </list>
+	/// All other requests are delegated unchanged, so existing behaviour is preserved.
+	/// </summary>
+	internal sealed class BlazorWebViewFileProvider : IFileProvider
+	{
+		private readonly IFileProvider _inner;
+		private readonly string? _hostPageRelativePath;
+		private readonly byte[]? _hostPageContents;
+		private readonly StaticWebAssetsManifest? _manifest;
+
+		public BlazorWebViewFileProvider(
+			IFileProvider inner,
+			string? hostPageRelativePath,
+			string? hostPageHtml,
+			StaticWebAssetsManifest? manifest)
+		{
+			_inner = inner ?? throw new ArgumentNullException(nameof(inner));
+			_manifest = manifest;
+
+			if (hostPageRelativePath is not null && hostPageHtml is not null)
+			{
+				_hostPageRelativePath = NormalizePath(hostPageRelativePath);
+				_hostPageContents = Encoding.UTF8.GetBytes(hostPageHtml);
+			}
+		}
+
+		public IFileInfo GetFileInfo(string subpath)
+		{
+			var normalized = NormalizePath(subpath);
+
+			// Serve the rendered host page from memory.
+			if (_hostPageContents is not null &&
+				string.Equals(normalized, _hostPageRelativePath, StringComparison.Ordinal))
+			{
+				return new InMemoryFileInfo(Path.GetFileName(_hostPageRelativePath!), _hostPageContents);
+			}
+
+			// If the file exists as requested, serve it directly (preserves existing behaviour).
+			var fileInfo = _inner.GetFileInfo(subpath);
+			if (fileInfo.Exists)
+			{
+				return fileInfo;
+			}
+
+			// Otherwise, if the request targets a fingerprinted route, serve the physical asset.
+			if (_manifest is not null &&
+				_manifest.TryResolvePhysicalPath(normalized, out var physicalPath))
+			{
+				return _inner.GetFileInfo(physicalPath);
+			}
+
+			return fileInfo;
+		}
+
+		public IDirectoryContents GetDirectoryContents(string subpath) => _inner.GetDirectoryContents(subpath);
+
+		public IChangeToken Watch(string filter) => _inner.Watch(filter);
+
+		private static string NormalizePath(string path) =>
+			(path ?? string.Empty).Replace('\\', '/').TrimStart('/');
+
+		private sealed class InMemoryFileInfo : IFileInfo
+		{
+			private readonly byte[] _contents;
+
+			public InMemoryFileInfo(string name, byte[] contents)
+			{
+				Name = name;
+				_contents = contents;
+			}
+
+			public bool Exists => true;
+			public long Length => _contents.Length;
+			public string? PhysicalPath => null;
+			public string Name { get; }
+			public DateTimeOffset LastModified => DateTimeOffset.UtcNow;
+			public bool IsDirectory => false;
+
+			public Stream CreateReadStream() => new MemoryStream(_contents, writable: false);
+		}
+	}
+}

src/BlazorWebView/src/Maui/BlazorWebViewHandler.cs

@@ -30,6 +30,7 @@ public partial class BlazorWebViewHandler : IBlazorWebViewHandler
 		public static PropertyMapper<IBlazorWebView, BlazorWebViewHandler> BlazorWebViewMapper = new(ViewMapper)
 		{
 			[nameof(IBlazorWebView.HostPage)] = MapHostPage,
+			[nameof(IBlazorWebView.AppType)] = MapAppType,
 			[nameof(IBlazorWebView.RootComponents)] = MapRootComponents,
 #if WINDOWS
             [nameof(IView.FlowDirection)] = MapFlowDirection,
@@ -73,6 +74,27 @@ public static void MapHostPage(BlazorWebViewHandler handler, IBlazorWebView webV
 #endif
 		}
 
+		/// <summary>
+		/// Maps the <see cref="IBlazorWebView.AppType"/> property to the specified handler.
+		/// </summary>
+		/// <param name="handler">The <see cref="BlazorWebViewHandler"/>.</param>
+		/// <param name="webView">The <see cref="IBlazorWebView"/>.</param>
+		public static void MapAppType(BlazorWebViewHandler handler, IBlazorWebView webView)
+		{
+#if !(NETSTANDARD || !PLATFORM)
+			// Only views that opt into AppType need this mapper. When AppType is null the legacy
+			// HostPage startup path is left completely untouched (MapHostPage already handled it).
+			if (webView.AppType is null)
+			{
+				return;
+			}
+
+			// AppType provides a synthetic HostPage, so ensure the handler picks it up and attempts startup.
+			handler.HostPage = webView.HostPage;
+			handler.StartWebViewCoreIfPossible();
+#endif
+		}
+
 		/// <summary>
 		/// Maps the <see cref="IBlazorWebView.RootComponents"/> property to the specified handler.
 		/// </summary>