Hot Reload agent improvements (#58333)

* Hot Reload agent improvements

Refactor agent code so that it can be shared with dotnet-watch implementation via a shared project.

Add new API applyHotReloadDeltas to apply updates.

* Feedback and cleanup

Author: tmat

src/Components/Web.JS/dist/Release/blazor.server.js

@@ -97,10 +97,15 @@ async function startCore(components: RootComponentManager<WebAssemblyComponentDe
     }
   });
 
+  // obsolete:
   Blazor._internal.applyHotReload = (id: string, metadataDelta: string, ilDelta: string, pdbDelta: string | undefined, updatedTypes?: number[]) => {
     dispatcher.invokeDotNetStaticMethod('Microsoft.AspNetCore.Components.WebAssembly', 'ApplyHotReloadDelta', id, metadataDelta, ilDelta, pdbDelta, updatedTypes ?? null);
   };
 
+  Blazor._internal.applyHotReloadDeltas = (deltas: { moduleId: string, metadataDelta: string, ilDelta: string, pdbDelta: string, updatedTypes: number[] }[], loggingLevel: number) => {
+    return dispatcher.invokeDotNetStaticMethod('Microsoft.AspNetCore.Components.WebAssembly', 'ApplyHotReloadDeltas', deltas, loggingLevel);
+  };
+
   Blazor._internal.getApplyUpdateCapabilities = () => dispatcher.invokeDotNetStaticMethod('Microsoft.AspNetCore.Components.WebAssembly', 'GetApplyUpdateCapabilities');
 
   // Configure JS interop

src/Components/Web.JS/dist/Release/blazor.web.js

@@ -89,7 +89,11 @@ export interface IBlazor {
     }
 
     // APIs invoked by hot reload
+
+    // obsolete:
     applyHotReload?: (id: string, metadataDelta: string, ilDelta: string, pdbDelta: string | undefined, updatedTypes?: number[]) => void;
+
+    applyHotReloadDeltas?: (deltas: { moduleId: string, metadataDelta: string, ilDelta: string, pdbDelta: string, updatedTypes: number[] }[], loggingLevel: number) => {message: string, severity: number}[];
     getApplyUpdateCapabilities?: () => string;
     hotReloadApplied?: () => void;
   }

src/Components/Web.JS/dist/Release/blazor.webassembly.js

@@ -0,0 +1,11 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+namespace Microsoft.DotNet.HotReload;
+
+internal enum AgentMessageSeverity : byte
+{
+    Verbose = 0,
+    Warning = 1,
+    Error = 2,
+}

src/Components/Web.JS/src/Boot.WebAssembly.Common.ts

@@ -0,0 +1,30 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using System.Linq;
+
+namespace Microsoft.DotNet.HotReload;
+
+internal sealed class AgentReporter
+{
+    private readonly List<(string message, AgentMessageSeverity severity)> _log = [];
+
+    public void Report(string message, AgentMessageSeverity severity)
+    {
+        _log.Add((message, severity));
+    }
+
+    public IReadOnlyCollection<(string message, AgentMessageSeverity severity)> GetAndClearLogEntries(ResponseLoggingLevel level)
+    {
+        lock (_log)
+        {
+            var filteredLog = (level != ResponseLoggingLevel.Verbose)
+                ? _log.Where(static entry => entry.severity != AgentMessageSeverity.Verbose)
+                : _log;
+
+            var log = filteredLog.ToArray();
+            _log.Clear();
+            return log;
+        }
+    }
+}

src/Components/Web.JS/src/GlobalExports.ts

@@ -0,0 +1,244 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using System.Diagnostics.CodeAnalysis;
+using System.Reflection;
+
+namespace Microsoft.DotNet.HotReload;
+
+/// <summary>
+/// Finds and invokes metadata update handlers.
+/// </summary>
+#if NET
+[UnconditionalSuppressMessage("Trimming", "IL2026", Justification = "Hot reload is only expected to work when trimming is disabled.")]
+[UnconditionalSuppressMessage("Trimming", "IL2070", Justification = "Hot reload is only expected to work when trimming is disabled.")]
+#endif
+internal sealed class MetadataUpdateHandlerInvoker(AgentReporter reporter)
+{
+    internal sealed class RegisteredActions(IReadOnlyList<Action<Type[]?>> clearCache, IReadOnlyList<Action<Type[]?>> updateApplication)
+    {
+        public void Invoke(Type[] updatedTypes)
+        {
+            foreach (var action in clearCache)
+            {
+                action(updatedTypes);
+            }
+
+            foreach (var action in updateApplication)
+            {
+                action(updatedTypes);
+            }
+        }
+
+        /// <summary>
+        /// For testing.
+        /// </summary>
+        internal IEnumerable<Action<Type[]?>> ClearCache => clearCache;
+
+        /// <summary>
+        /// For testing.
+        /// </summary>
+        internal IEnumerable<Action<Type[]?>> UpdateApplication => updateApplication;
+    }
+
+    private const string ClearCacheHandlerName = "ClearCache";
+    private const string UpdateApplicationHandlerName = "UpdateApplication";
+
+    private RegisteredActions? _actions;
+
+    /// <summary>
+    /// Call when a new assembly is loaded.
+    /// </summary>
+    internal void Clear()
+        => Interlocked.Exchange(ref _actions, null);
+
+    /// <summary>
+    /// Invokes all registerd handlers.
+    /// </summary>
+    internal void Invoke(Type[] updatedTypes)
+    {
+        try
+        {
+            // Defer discovering metadata updata handlers until after hot reload deltas have been applied.
+            // This should give enough opportunity for AppDomain.GetAssemblies() to be sufficiently populated.
+            var actions = _actions;
+            if (actions == null)
+            {
+                Interlocked.CompareExchange(ref _actions, GetMetadataUpdateHandlerActions(), null);
+                actions = _actions;
+            }
+
+            reporter.Report($"Invoking metadata update handlers. {updatedTypes.Length} type(s) updated.", AgentMessageSeverity.Verbose);
+
+            actions.Invoke(updatedTypes);
+
+            reporter.Report("Deltas applied.", AgentMessageSeverity.Verbose);
+        }
+        catch (Exception e)
+        {
+            reporter.Report(e.ToString(), AgentMessageSeverity.Warning);
+        }
+    }
+
+    private IEnumerable<Type> GetHandlerTypes()
+    {
+        // We need to execute MetadataUpdateHandlers in a well-defined order. For v1, the strategy that is used is to topologically
+        // sort assemblies so that handlers in a dependency are executed before the dependent (e.g. the reflection cache action
+        // in System.Private.CoreLib is executed before System.Text.Json clears its own cache.)
+        // This would ensure that caches and updates more lower in the application stack are up to date
+        // before ones higher in the stack are recomputed.
+        var sortedAssemblies = TopologicalSort(AppDomain.CurrentDomain.GetAssemblies());
+
+        foreach (var assembly in sortedAssemblies)
+        {
+            foreach (var attr in TryGetCustomAttributesData(assembly))
+            {
+                // Look up the attribute by name rather than by type. This would allow netstandard targeting libraries to
+                // define their own copy without having to cross-compile.
+                if (attr.AttributeType.FullName != "System.Reflection.Metadata.MetadataUpdateHandlerAttribute")
+                {
+                    continue;
+                }
+
+                IList<CustomAttributeTypedArgument> ctorArgs = attr.ConstructorArguments;
+                if (ctorArgs.Count != 1 ||
+                    ctorArgs[0].Value is not Type handlerType)
+                {
+                    reporter.Report($"'{attr}' found with invalid arguments.", AgentMessageSeverity.Warning);
+                    continue;
+                }
+
+                yield return handlerType;
+            }
+        }
+    }
+
+    public RegisteredActions GetMetadataUpdateHandlerActions()
+        => GetMetadataUpdateHandlerActions(GetHandlerTypes());
+
+    /// <summary>
+    /// Internal for testing.
+    /// </summary>
+    internal RegisteredActions GetMetadataUpdateHandlerActions(IEnumerable<Type> handlerTypes)
+    {
+        var clearCacheActions = new List<Action<Type[]?>>();
+        var updateApplicationActions = new List<Action<Type[]?>>();
+
+        foreach (var handlerType in handlerTypes)
+        {
+            bool methodFound = false;
+
+            if (GetUpdateMethod(handlerType, ClearCacheHandlerName) is MethodInfo clearCache)
+            {
+                clearCacheActions.Add(CreateAction(clearCache));
+                methodFound = true;
+            }
+
+            if (GetUpdateMethod(handlerType, UpdateApplicationHandlerName) is MethodInfo updateApplication)
+            {
+                updateApplicationActions.Add(CreateAction(updateApplication));
+                methodFound = true;
+            }
+
+            if (!methodFound)
+            {
+                reporter.Report(
+                    $"Expected to find a static method '{ClearCacheHandlerName}' or '{UpdateApplicationHandlerName}' on type '{handlerType.AssemblyQualifiedName}' but neither exists.",
+                    AgentMessageSeverity.Warning);
+            }
+        }
+
+        return new RegisteredActions(clearCacheActions, updateApplicationActions);
+
+        Action<Type[]?> CreateAction(MethodInfo update)
+        {
+            var action = (Action<Type[]?>)update.CreateDelegate(typeof(Action<Type[]?>));
+            return types =>
+            {
+                try
+                {
+                    action(types);
+                }
+                catch (Exception ex)
+                {
+                    reporter.Report($"Exception from '{action}': {ex}", AgentMessageSeverity.Warning);
+                }
+            };
+        }
+
+        MethodInfo? GetUpdateMethod(Type handlerType, string name)
+        {
+            if (handlerType.GetMethod(name, BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static, binder: null, [typeof(Type[])], modifiers: null) is MethodInfo updateMethod &&
+                updateMethod.ReturnType == typeof(void))
+            {
+                return updateMethod;
+            }
+
+            foreach (MethodInfo method in handlerType.GetMethods(BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static | BindingFlags.Instance))
+            {
+                if (method.Name == name)
+                {
+                    reporter.Report($"Type '{handlerType}' has method '{method}' that does not match the required signature.", AgentMessageSeverity.Warning);
+                    break;
+                }
+            }
+
+            return null;
+        }
+    }
+
+    private IList<CustomAttributeData> TryGetCustomAttributesData(Assembly assembly)
+    {
+        try
+        {
+            return assembly.GetCustomAttributesData();
+        }
+        catch (Exception e)
+        {
+            // In cross-platform scenarios, such as debugging in VS through WSL, Roslyn
+            // runs on Windows, and the agent runs on Linux. Assemblies accessible to Windows
+            // may not be available or loaded on linux (such as WPF's assemblies).
+            // In such case, we can ignore the assemblies and continue enumerating handlers for
+            // the rest of the assemblies of current domain.
+            reporter.Report($"'{assembly.FullName}' is not loaded ({e.Message})", AgentMessageSeverity.Verbose);
+            return [];
+        }
+    }
+
+    /// <summary>
+    /// Internal for testing.
+    /// </summary>
+    internal static List<Assembly> TopologicalSort(Assembly[] assemblies)
+    {
+        var sortedAssemblies = new List<Assembly>(assemblies.Length);
+
+        var visited = new HashSet<string>(StringComparer.Ordinal);
+
+        foreach (var assembly in assemblies)
+        {
+            Visit(assemblies, assembly, sortedAssemblies, visited);
+        }
+
+        static void Visit(Assembly[] assemblies, Assembly assembly, List<Assembly> sortedAssemblies, HashSet<string> visited)
+        {
+            var assemblyIdentifier = assembly.GetName().Name!;
+            if (!visited.Add(assemblyIdentifier))
+            {
+                return;
+            }
+
+            foreach (var dependencyName in assembly.GetReferencedAssemblies())
+            {
+                var dependency = Array.Find(assemblies, a => a.GetName().Name == dependencyName.Name);
+                if (dependency is not null)
+                {
+                    Visit(assemblies, dependency, sortedAssemblies, visited);
+                }
+            }
+
+            sortedAssemblies.Add(assembly);
+        }
+
+        return sortedAssemblies;
+    }
+}

src/Components/WebAssembly/WebAssembly/src/HotReload/AgentMessageSeverity.cs

@@ -0,0 +1,10 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+namespace Microsoft.DotNet.HotReload;
+
+internal enum ResponseLoggingLevel : byte
+{
+    WarningsAndErrors = 0,
+    Verbose = 1,
+}

src/Components/WebAssembly/WebAssembly/src/HotReload/AgentReporter.cs

@@ -1,17 +1,13 @@
 // Licensed to the .NET Foundation under one or more agreements.
 // The .NET Foundation licenses this file to you under the MIT license.
 
-namespace Microsoft.Extensions.HotReload;
+namespace Microsoft.DotNet.HotReload;
 
-internal sealed class UpdateDelta
+internal readonly struct UpdateDelta(Guid moduleId, byte[] metadataDelta, byte[] ilDelta, byte[] pdbDelta, int[] updatedTypes)
 {
-    public Guid ModuleId { get; set; }
-
-    public byte[] MetadataDelta { get; set; } = default!;
-
-    public byte[] ILDelta { get; set; } = default!;
-
-    public byte[]? PdbBytes { get; set; }
-
-    public int[]? UpdatedTypes { get; set; }
+    public Guid ModuleId { get; } = moduleId;
+    public byte[] MetadataDelta { get; } = metadataDelta;
+    public byte[] ILDelta { get; } = ilDelta;
+    public byte[] PdbDelta { get; } = pdbDelta;
+    public int[] UpdatedTypes { get; } = updatedTypes;
 }

src/Components/WebAssembly/WebAssembly/src/HotReload/HotReloadAgent.cs

@@ -2,79 +2,167 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 
 using System.ComponentModel;
-using System.Diagnostics;
+using System.Diagnostics.CodeAnalysis;
 using System.Globalization;
-using System.Reflection;
-using System.Runtime.InteropServices.JavaScript;
-using Microsoft.Extensions.HotReload;
+using System.Linq;
+using System.Net.Http;
+using System.Text.Json;
+using Microsoft.AspNetCore.Components.WebAssembly.Services;
+using Microsoft.DotNet.HotReload;
 using Microsoft.JSInterop;
 
+#pragma warning disable CS1591 // Missing XML comment for publicly visible type or member
+
 namespace Microsoft.AspNetCore.Components.WebAssembly.HotReload;
 
 /// <summary>
 /// Contains methods called by interop. Intended for framework use only, not supported for use in application
 /// code.
 /// </summary>
 [EditorBrowsable(EditorBrowsableState.Never)]
+[UnconditionalSuppressMessage(
+    "Trimming",
+    "IL2026:Members annotated with 'RequiresUnreferencedCodeAttribute' require dynamic access otherwise can break functionality when trimming application code",
+    Justification = "Hot Reload does not support trimming")]
 public static partial class WebAssemblyHotReload
 {
-    private const string BlazorHotReloadModuleName = "blazor-hotreload";
+    /// <summary>
+    /// For framework use only.
+    /// </summary>
+    public readonly struct LogEntry
+    {
+        public string Message { get; init; }
+        public int Severity { get; init; }
+    }
+
+    /// <summary>
+    /// For framework use only.
+    /// </summary>
+    internal sealed class Update
+    {
+        public int Id { get; set; }
+        public Delta[] Deltas { get; set; } = default!;
+    }
 
-    private static HotReloadAgent? _hotReloadAgent;
-    private static readonly UpdateDelta[] _updateDeltas = new[]
+    /// <summary>
+    /// For framework use only.
+    /// </summary>
+    public readonly struct Delta
     {
-        new UpdateDelta(),
-    };
+        public string ModuleId { get; init; }
+        public byte[] MetadataDelta { get; init; }
+        public byte[] ILDelta { get; init; }
+        public byte[] PdbDelta { get; init; }
+        public int[] UpdatedTypes { get; init; }
+    }
+
+    private static readonly AgentReporter s_reporter = new();
+    private static readonly JsonSerializerOptions s_jsonSerializerOptions = new(JsonSerializerDefaults.Web);
+
+    private static bool s_initialized;
+    private static HotReloadAgent? s_hotReloadAgent;
 
     internal static async Task InitializeAsync()
     {
         if (Environment.GetEnvironmentVariable("__ASPNETCORE_BROWSER_TOOLS") == "true" &&
             OperatingSystem.IsBrowser())
         {
-            // Attempt to read previously applied hot reload deltas if the ASP.NET Core browser tools are available (indicated by the presence of the Environment variable).
-            // The agent is injected in to the hosted app and can serve this script that can provide results from local-storage.
-            // See https://github.com/dotnet/aspnetcore/issues/37357#issuecomment-941237000
-            await JSHost.ImportAsync(BlazorHotReloadModuleName, "/_framework/blazor-hotreload.js");
-            await ReceiveHotReloadAsync();
+            s_initialized = true;
+
+            if (!HotReloadAgent.TryCreate(s_reporter, out var agent))
+            {
+                return;
+            }
+
+            var existingAgent = Interlocked.CompareExchange(ref s_hotReloadAgent, agent, null);
+            if (existingAgent != null)
+            {
+                throw new InvalidOperationException("Hot Reload agent already initialized");
+            }
+
+            await ApplyPreviousDeltasAsync(agent);
+        }
+    }
+
+    private static async ValueTask ApplyPreviousDeltasAsync(HotReloadAgent agent)
+    {
+        string errorMessage;
+
+        using var client = new HttpClient()
+        {
+            BaseAddress = new Uri(WebAssemblyNavigationManager.Instance.BaseUri, UriKind.Absolute)
+        };
+
+        try
+        {
+            var response = await client.GetAsync("/_framework/blazor-hotreload");
+            if (response.IsSuccessStatusCode)
+            {
+                var deltasJson = await response.Content.ReadAsStringAsync();
+                var updates = deltasJson != "" ? JsonSerializer.Deserialize<Update[]>(deltasJson, s_jsonSerializerOptions) : null;
+                if (updates == null)
+                {
+                    s_reporter.Report($"No previous updates to apply.", AgentMessageSeverity.Verbose);
+                    return;
+                }
+
+                var i = 1;
+                foreach (var update in updates)
+                {
+                    s_reporter.Report($"Reapplying update {i}/{updates.Length}.", AgentMessageSeverity.Verbose);
+
+                    agent.ApplyDeltas(
+                        update.Deltas.Select(d => new UpdateDelta(Guid.Parse(d.ModuleId, CultureInfo.InvariantCulture), d.MetadataDelta, d.ILDelta, d.PdbDelta, d.UpdatedTypes)));
+
+                    i++;
+                }
+
+                return;
+            }
+
+            errorMessage = $"HTTP GET '/_framework/blazor-hotreload' returned {response.StatusCode}";
+        }
+        catch (Exception e)
+        {
+            errorMessage = e.ToString();
         }
+
+        s_reporter.Report($"Failed to retrieve and apply previous deltas from the server: ${errorMessage}", AgentMessageSeverity.Error);
     }
 
+    private static HotReloadAgent? GetAgent()
+        => s_hotReloadAgent ?? (s_initialized ? throw new InvalidOperationException("Hot Reload agent not initialized") : null);
+
     /// <summary>
     /// For framework use only.
     /// </summary>
+    [Obsolete("Use ApplyHotReloadDeltas instead")]
     [JSInvokable(nameof(ApplyHotReloadDelta))]
     public static void ApplyHotReloadDelta(string moduleIdString, byte[] metadataDelta, byte[] ilDelta, byte[] pdbBytes, int[]? updatedTypes)
     {
-        // Analyzer has a bug where it doesn't handle ConditionalAttribute: https://github.com/dotnet/roslyn/issues/63464
-#pragma warning disable IDE0200 // Remove unnecessary lambda expression
-        Interlocked.CompareExchange(ref _hotReloadAgent, new HotReloadAgent(m => Debug.WriteLine(m)), null);
-#pragma warning restore IDE0200 // Remove unnecessary lambda expression
+        GetAgent()?.ApplyDeltas(
+            [new UpdateDelta(Guid.Parse(moduleIdString, CultureInfo.InvariantCulture), metadataDelta, ilDelta, pdbBytes, updatedTypes ?? [])]);
+    }
 
-        var moduleId = Guid.Parse(moduleIdString, CultureInfo.InvariantCulture);
+    /// <summary>
+    /// For framework use only.
+    /// </summary>
+    [JSInvokable(nameof(ApplyHotReloadDeltas))]
+    public static LogEntry[] ApplyHotReloadDeltas(Delta[] deltas, int loggingLevel)
+    {
+        var agent = GetAgent();
 
-        _updateDeltas[0].ModuleId = moduleId;
-        _updateDeltas[0].MetadataDelta = metadataDelta;
-        _updateDeltas[0].ILDelta = ilDelta;
-        _updateDeltas[0].PdbBytes = pdbBytes;
-        _updateDeltas[0].UpdatedTypes = updatedTypes;
+        agent?.ApplyDeltas(
+            deltas.Select(d => new UpdateDelta(Guid.Parse(d.ModuleId, CultureInfo.InvariantCulture), d.MetadataDelta, d.ILDelta, d.PdbDelta, d.UpdatedTypes)));
 
-        _hotReloadAgent.ApplyDeltas(_updateDeltas);
+        return s_reporter.GetAndClearLogEntries((ResponseLoggingLevel)loggingLevel)
+            .Select(log => new LogEntry() { Message = log.message, Severity = (int)log.severity }).ToArray();
     }
 
     /// <summary>
     /// For framework use only.
     /// </summary>
     [JSInvokable(nameof(GetApplyUpdateCapabilities))]
     public static string GetApplyUpdateCapabilities()
-    {
-        var method = typeof(System.Reflection.Metadata.MetadataUpdater).GetMethod("GetCapabilities", BindingFlags.NonPublic | BindingFlags.Static, Type.EmptyTypes);
-        if (method is null)
-        {
-            return string.Empty;
-        }
-        return (string)method.Invoke(obj: null, parameters: null)!;
-    }
-
-    [JSImport("receiveHotReloadAsync", BlazorHotReloadModuleName)]
-    private static partial Task ReceiveHotReloadAsync();
+        => GetAgent()?.Capabilities ?? "";
 }

src/Components/WebAssembly/WebAssembly/src/HotReload/MetadataUpdateHandlerInvoker.cs

@@ -81,6 +81,24 @@ Microsoft.AspNetCore.Components.WebAssembly.Hosting.WebAssemblyHostConfiguration
 Microsoft.AspNetCore.Components.WebAssembly.Hosting.WebAssemblyHostConfiguration.WebAssemblyHostConfiguration() -> void
 Microsoft.AspNetCore.Components.WebAssembly.Hosting.WebAssemblyHostEnvironmentExtensions
 Microsoft.AspNetCore.Components.WebAssembly.HotReload.WebAssemblyHotReload
+Microsoft.AspNetCore.Components.WebAssembly.HotReload.WebAssemblyHotReload.Delta
+Microsoft.AspNetCore.Components.WebAssembly.HotReload.WebAssemblyHotReload.Delta.Delta() -> void
+Microsoft.AspNetCore.Components.WebAssembly.HotReload.WebAssemblyHotReload.Delta.ILDelta.get -> byte[]!
+Microsoft.AspNetCore.Components.WebAssembly.HotReload.WebAssemblyHotReload.Delta.ILDelta.init -> void
+Microsoft.AspNetCore.Components.WebAssembly.HotReload.WebAssemblyHotReload.Delta.MetadataDelta.get -> byte[]!
+Microsoft.AspNetCore.Components.WebAssembly.HotReload.WebAssemblyHotReload.Delta.MetadataDelta.init -> void
+Microsoft.AspNetCore.Components.WebAssembly.HotReload.WebAssemblyHotReload.Delta.ModuleId.get -> string!
+Microsoft.AspNetCore.Components.WebAssembly.HotReload.WebAssemblyHotReload.Delta.ModuleId.init -> void
+Microsoft.AspNetCore.Components.WebAssembly.HotReload.WebAssemblyHotReload.Delta.PdbDelta.get -> byte[]!
+Microsoft.AspNetCore.Components.WebAssembly.HotReload.WebAssemblyHotReload.Delta.PdbDelta.init -> void
+Microsoft.AspNetCore.Components.WebAssembly.HotReload.WebAssemblyHotReload.Delta.UpdatedTypes.get -> int[]!
+Microsoft.AspNetCore.Components.WebAssembly.HotReload.WebAssemblyHotReload.Delta.UpdatedTypes.init -> void
+Microsoft.AspNetCore.Components.WebAssembly.HotReload.WebAssemblyHotReload.LogEntry
+Microsoft.AspNetCore.Components.WebAssembly.HotReload.WebAssemblyHotReload.LogEntry.LogEntry() -> void
+Microsoft.AspNetCore.Components.WebAssembly.HotReload.WebAssemblyHotReload.LogEntry.Message.get -> string!
+Microsoft.AspNetCore.Components.WebAssembly.HotReload.WebAssemblyHotReload.LogEntry.Message.init -> void
+Microsoft.AspNetCore.Components.WebAssembly.HotReload.WebAssemblyHotReload.LogEntry.Severity.get -> int
+Microsoft.AspNetCore.Components.WebAssembly.HotReload.WebAssemblyHotReload.LogEntry.Severity.init -> void
 Microsoft.AspNetCore.Components.WebAssembly.Http.BrowserRequestCache
 Microsoft.AspNetCore.Components.WebAssembly.Http.BrowserRequestCache.Default = 0 -> Microsoft.AspNetCore.Components.WebAssembly.Http.BrowserRequestCache
 Microsoft.AspNetCore.Components.WebAssembly.Http.BrowserRequestCache.ForceCache = 4 -> Microsoft.AspNetCore.Components.WebAssembly.Http.BrowserRequestCache
@@ -108,6 +126,7 @@ static Microsoft.AspNetCore.Components.WebAssembly.Hosting.WebAssemblyHostEnviro
 static Microsoft.AspNetCore.Components.WebAssembly.Hosting.WebAssemblyHostEnvironmentExtensions.IsProduction(this Microsoft.AspNetCore.Components.WebAssembly.Hosting.IWebAssemblyHostEnvironment! hostingEnvironment) -> bool
 static Microsoft.AspNetCore.Components.WebAssembly.Hosting.WebAssemblyHostEnvironmentExtensions.IsStaging(this Microsoft.AspNetCore.Components.WebAssembly.Hosting.IWebAssemblyHostEnvironment! hostingEnvironment) -> bool
 static Microsoft.AspNetCore.Components.WebAssembly.HotReload.WebAssemblyHotReload.ApplyHotReloadDelta(string! moduleIdString, byte[]! metadataDelta, byte[]! ilDelta, byte[]! pdbBytes, int[]? updatedTypes) -> void
+static Microsoft.AspNetCore.Components.WebAssembly.HotReload.WebAssemblyHotReload.ApplyHotReloadDeltas(Microsoft.AspNetCore.Components.WebAssembly.HotReload.WebAssemblyHotReload.Delta[]! deltas, int loggingLevel) -> Microsoft.AspNetCore.Components.WebAssembly.HotReload.WebAssemblyHotReload.LogEntry[]!
 static Microsoft.AspNetCore.Components.WebAssembly.HotReload.WebAssemblyHotReload.GetApplyUpdateCapabilities() -> string!
 static Microsoft.AspNetCore.Components.WebAssembly.Http.WebAssemblyHttpRequestMessageExtensions.SetBrowserRequestCache(this System.Net.Http.HttpRequestMessage! requestMessage, Microsoft.AspNetCore.Components.WebAssembly.Http.BrowserRequestCache requestCache) -> System.Net.Http.HttpRequestMessage!
 static Microsoft.AspNetCore.Components.WebAssembly.Http.WebAssemblyHttpRequestMessageExtensions.SetBrowserRequestCredentials(this System.Net.Http.HttpRequestMessage! requestMessage, Microsoft.AspNetCore.Components.WebAssembly.Http.BrowserRequestCredentials requestCredentials) -> System.Net.Http.HttpRequestMessage!