[Blazor] Update SDK to account for the crypto worker file (#26966)

* Updates the Blazor SDK to account for the new crypto-worker-js file during build and publish.
* Updates blazor.boot.json to include a new section with additional runtime assets that are consumed by the runtime directly at runtime.

Author: javiercn

src/BlazorWasmSdk/Targets/Microsoft.NET.Sdk.BlazorWebAssembly.6_0.targets

@@ -157,6 +157,9 @@ Copyright (c) .NET Foundation. All rights reserved.
       <!-- Remove dotnet.js/wasm from runtime pack, in favor of the relinked ones in @(WasmNativeAsset) -->
       <ReferenceCopyLocalPaths Remove="@(ReferenceCopyLocalPaths)"
                                Condition="@(WasmNativeAsset->Count()) > 0 and '%(FileName)' == 'dotnet' and ('%(Extension)' == '.wasm' or '%(Extension)' == '.js')" />
+
+      <ReferenceCopyLocalPaths Remove="@(ReferenceCopyLocalPaths)"
+                               Condition="@(WasmNativeAsset->Count()) > 0 and '%(FileName)' == 'dotnet-crypto-worker' and '%(Extension)' == '.js'" />
     </ItemGroup>
 
     <ComputeBlazorBuildAssets
@@ -403,6 +406,7 @@ Copyright (c) .NET Foundation. All rights reserved.
 
     <ItemGroup>
       <_DotNetJsItem Include="@(ResolvedFileToPublish)" Condition="'%(ResolvedFileToPublish.DestinationSubPath)' == 'dotnet.js' AND '%(ResolvedFileToPublish.AssetType)' == 'native'" />
+      <_DotNetJsItem Include="@(ResolvedFileToPublish)" Condition="'%(ResolvedFileToPublish.DestinationSubPath)' == 'dotnet-crypto-worker.js' AND '%(ResolvedFileToPublish.AssetType)' == 'native'" />
     </ItemGroup>
 
     <PropertyGroup>

src/BlazorWasmSdk/Tasks/BootJsonData.cs

@@ -98,6 +98,13 @@ public class ResourcesData
         /// </summary>
         [DataMember(EmitDefaultValue = false)]
         public Dictionary<string, ResourceHashesByNameDictionary> extensions { get; set; }
+
+        /// <summary>
+        /// Additional assets that the runtime consumes as part of the boot process.
+        /// </summary>
+        [DataMember(EmitDefaultValue = false)]
+        public Dictionary<string, AdditionalAsset> runtimeAssets { get; set; }
+
     }
 
     public enum ICUDataMode : int

src/BlazorWasmSdk/Tasks/ComputeBlazorBuildAssets.cs

@@ -118,6 +118,28 @@ public override bool Execute()
                         assetCandidates.Add(newDotNetJs);
                         continue;
                     }
+                    else if (candidate.GetMetadata("FileName") == "dotnet-crypto-worker" && candidate.GetMetadata("Extension") == ".js")
+                    {
+                        var itemHash = FileHasher.GetFileHash(candidate.ItemSpec);
+                        var cacheBustedDotNetCryptoWorkerJSFileName = $"dotnet-crypto-worker.{candidate.GetMetadata("NuGetPackageVersion")}.{itemHash}.js";
+
+                        var originalFileFullPath = Path.GetFullPath(candidate.ItemSpec);
+                        var originalFileDirectory = Path.GetDirectoryName(originalFileFullPath);
+
+                        var cacheBustedDotNetCryptoWorkerJSFullPath = Path.Combine(originalFileDirectory, cacheBustedDotNetCryptoWorkerJSFileName);
+
+                        var newDotnetCryptoWorkerJs = new TaskItem(cacheBustedDotNetCryptoWorkerJSFullPath, candidate.CloneCustomMetadata());
+                        newDotnetCryptoWorkerJs.SetMetadata("OriginalItemSpec", candidate.ItemSpec);
+
+                        var newRelativePath = $"_framework/{cacheBustedDotNetCryptoWorkerJSFileName}";
+                        newDotnetCryptoWorkerJs.SetMetadata("RelativePath", newRelativePath);
+
+                        newDotnetCryptoWorkerJs.SetMetadata("AssetTraitName", "BlazorWebAssemblyResource");
+                        newDotnetCryptoWorkerJs.SetMetadata("AssetTraitValue", "js-module-crypto");
+
+                        assetCandidates.Add(newDotnetCryptoWorkerJs);
+                        continue;
+                    }
                     else if (string.IsNullOrEmpty(destinationSubPath))
                     {
                         var relativePath = candidate.GetMetadata("FileName") + candidate.GetMetadata("Extension");
@@ -280,7 +302,8 @@ public static bool ShouldFilterCandidate(
                 ".dat" when invariantGlobalization && fileName.StartsWith("icudt") => "invariant globalization is enabled",
                 ".json" when fromMonoPackage && (fileName == "emcc-props" || fileName == "package") => $"{fileName}{extension} is not used by Blazor",
                 ".ts" when fromMonoPackage && fileName == "dotnet.d" => "dotnet type definition is not used by Blazor",
-                ".js" when assetType == "native" && fileName != "dotnet" => $"{fileName}{extension} is not used by Blazor",
+                ".ts" when fromMonoPackage && fileName == "dotnet-legacy.d" => "dotnet type definition is not used by Blazor",
+                ".js" when assetType == "native" && fileName != "dotnet" && fileName != "dotnet-crypto-worker" => $"{fileName}{extension} is not used by Blazor",
                 ".pdb" when !copySymbols => "copying symbols is disabled",
                 ".symbols" when fromMonoPackage => "extension .symbols is not required.",
                 _ => null

src/BlazorWasmSdk/Tasks/ComputeBlazorPublishAssets.cs

@@ -157,8 +157,9 @@ private List<ITaskItem> ProcessNativeAssets(
                 var key = kvp.Key;
                 var asset = kvp.Value;
                 var isDotNetJs = IsDotNetJs(key);
+                var isDotNetCryptoJs = IsDotNetCryptoJs(key);
                 var isDotNetWasm = IsDotNetWasm(key);
-                if (!isDotNetJs && !isDotNetWasm)
+                if (!isDotNetJs && !isDotNetWasm && !isDotNetCryptoJs)
                 {
                     if (resolvedNativeAssetToPublish.TryGetValue(Path.GetFileName(asset.GetMetadata("OriginalItemSpec")), out var existing))
                     {
@@ -175,6 +176,7 @@ private List<ITaskItem> ProcessNativeAssets(
                         }
                         else
                         {
+                            Log.LogMessage(MessageImportance.Low, "Removing asset '{0}'.", existing.ItemSpec);
                             // This was a file that was filtered, so just remove it, we don't need to add any publish static web asset
                             filesToRemove.Add(removed);
 
@@ -214,6 +216,34 @@ private List<ITaskItem> ProcessNativeAssets(
                     continue;
                 }
 
+                if (isDotNetCryptoJs)
+                {
+                    var aotDotNetCryptoJs = WasmAotAssets.SingleOrDefault(a => $"{a.GetMetadata("FileName")}{a.GetMetadata("Extension")}" == "dotnet-crypto-worker.js");
+                    ITaskItem newDotNetCryptoJs = null;
+                    if (aotDotNetCryptoJs != null)
+                    {
+                        newDotNetCryptoJs = new TaskItem(Path.GetFullPath(aotDotNetCryptoJs.ItemSpec), asset.CloneCustomMetadata());
+                        newDotNetCryptoJs.SetMetadata("OriginalItemSpec", aotDotNetCryptoJs.ItemSpec);
+                        newDotNetCryptoJs.SetMetadata("RelativePath", $"_framework/{$"dotnet-crypto-worker.{DotNetJsVersion}.{FileHasher.GetFileHash(aotDotNetCryptoJs.ItemSpec)}.js"}");
+
+                        updateMap.Add(asset.ItemSpec, newDotNetCryptoJs);
+                        Log.LogMessage(MessageImportance.Low, "Replacing asset '{0}' with AoT version '{1}'", asset.ItemSpec, newDotNetCryptoJs.ItemSpec);
+                    }
+                    else
+                    {
+                        newDotNetCryptoJs = new TaskItem(asset);
+                        Log.LogMessage(MessageImportance.Low, "Promoting asset '{0}' to Publish asset.", asset.ItemSpec);
+                    }
+
+                    ApplyPublishProperties(newDotNetCryptoJs);
+                    nativeStaticWebAssets.Add(newDotNetCryptoJs);
+                    if (resolvedNativeAssetToPublish.TryGetValue("dotnet-crypto-worker.js", out var resolved))
+                    {
+                        filesToRemove.Add(resolved);
+                    }
+                    continue;
+                }
+
                 if (isDotNetWasm)
                 {
                     var aotDotNetWasm = WasmAotAssets.SingleOrDefault(a => $"{a.GetMetadata("FileName")}{a.GetMetadata("Extension")}" == "dotnet.wasm");
@@ -252,9 +282,14 @@ private List<ITaskItem> ProcessNativeAssets(
             static bool IsDotNetJs(string key)
             {
                 var fileName = Path.GetFileName(key);
-                return fileName.StartsWith("dotnet.", StringComparison.Ordinal) && fileName.EndsWith(".js", StringComparison.Ordinal);
+                return fileName.StartsWith("dotnet.", StringComparison.Ordinal) && fileName.EndsWith(".js", StringComparison.Ordinal) && !fileName.Contains("worker");
             }
 
+            static bool IsDotNetCryptoJs(string key)
+            {
+                var fileName = Path.GetFileName(key);
+                return fileName.StartsWith("dotnet-crypto-worker.", StringComparison.Ordinal) && fileName.EndsWith(".js", StringComparison.Ordinal);
+            }
             static bool IsDotNetWasm(string key) => string.Equals("dotnet.wasm", Path.GetFileName(key), StringComparison.Ordinal);
         }
 
@@ -411,7 +446,7 @@ private List<ITaskItem> ProcessCompressedAssets(
             Dictionary<string, ITaskItem> updatedAssets)
         {
             var processed = new List<string>();
-            var additionalAssetsToUpdate = new List<ITaskItem>();
+            var runtimeAssetsToUpdate = new List<ITaskItem>();
             foreach (var kvp in compressedRepresentations)
             {
                 var compressedAsset = kvp.Value;
@@ -423,7 +458,7 @@ private List<ITaskItem> ProcessCompressedAssets(
                         Log.LogMessage(MessageImportance.Low, "Related assembly for '{0}' was not updated and the compressed asset can be reused.", relatedAsset);
                         var newCompressedAsset = new TaskItem(compressedAsset);
                         ApplyPublishProperties(newCompressedAsset);
-                        additionalAssetsToUpdate.Add(newCompressedAsset);
+                        runtimeAssetsToUpdate.Add(newCompressedAsset);
                     }
                     else
                     {
@@ -440,7 +475,7 @@ private List<ITaskItem> ProcessCompressedAssets(
                 compressedRepresentations.Remove(element);
             }
 
-            return additionalAssetsToUpdate;
+            return runtimeAssetsToUpdate;
         }
 
         private static void UpdateRelatedAssetProperty(ITaskItem asset, TaskItem newAsset, Dictionary<string, ITaskItem> updatedAssetsMap)
@@ -603,10 +638,9 @@ private void GroupResolvedFilesToPublish(
             }
         }
 
-        private static bool IsNativeAsset(string traitValue) => string.Equals(traitValue, "native", StringComparison.Ordinal);
+        private static bool IsNativeAsset(string traitValue) => string.Equals(traitValue, "native", StringComparison.Ordinal) || string.Equals(traitValue, "js-module-crypto", StringComparison.Ordinal);
 
         private static bool IsRuntimeAsset(string traitValue) => string.Equals(traitValue, "runtime", StringComparison.Ordinal);
-
         private static bool IsSymbolAsset(string traitValue) => string.Equals(traitValue, "symbol", StringComparison.Ordinal);
 
         private static bool IsAlternative(ITaskItem asset) => string.Equals(asset.GetMetadata("AssetRole"), "Alternative", StringComparison.Ordinal);

src/BlazorWasmSdk/Tasks/GenerateBlazorWebAssemblyBootJson.cs

@@ -8,6 +8,7 @@
 using System.IO;
 using System.Linq;
 using System.Reflection;
+using System.Runtime.Serialization;
 using System.Runtime.Serialization.Json;
 using System.Text;
 using Microsoft.Build.Framework;
@@ -99,9 +100,11 @@ public void WriteBootJson(Stream output, string entryAssemblyName)
                 var resourceData = result.resources;
                 foreach (var resource in Resources)
                 {
-                    ResourceHashesByNameDictionary resourceList;
+                    ResourceHashesByNameDictionary resourceList = null;
 
+                    string behavior = null;
                     var fileName = resource.GetMetadata("FileName");
+                    var fileExtension = resource.GetMetadata("Extension");
                     var assetTraitName = resource.GetMetadata("AssetTraitName");
                     var assetTraitValue = resource.GetMetadata("AssetTraitValue");
                     var resourceName = Path.GetFileName(resource.GetMetadata("RelativePath"));
@@ -113,7 +116,7 @@ public void WriteBootJson(Stream output, string entryAssemblyName)
                         resourceData.lazyAssembly ??= new ResourceHashesByNameDictionary();
                         resourceList = resourceData.lazyAssembly;
                     }
-                    else if (string.Equals("Culture", assetTraitName))
+                    else if (string.Equals("Culture", assetTraitName, StringComparison.OrdinalIgnoreCase))
                     {
                         Log.LogMessage(MessageImportance.Low, "Candidate '{0}' is defined as satellite assembly with culture '{1}'.", resource.ItemSpec, assetTraitValue);
                         resourceData.satelliteResources ??= new Dictionary<string, ResourceHashesByNameDictionary>(StringComparer.OrdinalIgnoreCase);
@@ -149,6 +152,12 @@ public void WriteBootJson(Stream output, string entryAssemblyName)
                             string.Equals(assetTraitValue, "native", StringComparison.OrdinalIgnoreCase))
                     {
                         Log.LogMessage(MessageImportance.Low, "Candidate '{0}' is defined as a native application resource.", resource.ItemSpec);
+                        if (string.Equals(fileName, "dotnet", StringComparison.OrdinalIgnoreCase) &&
+                            string.Equals(fileExtension, ".wasm", StringComparison.OrdinalIgnoreCase))
+                        {
+                            behavior = "dotnetwasm";
+                        }
+
                         resourceList = resourceData.runtime;
                     }
                     else if (string.Equals("JSModule", assetTraitName, StringComparison.OrdinalIgnoreCase) &&
@@ -161,6 +170,11 @@ public void WriteBootJson(Stream output, string entryAssemblyName)
                         Debug.Assert(!string.IsNullOrEmpty(targetPath), "Target path for '{0}' must exist.", resource.ItemSpec);
                         AddResourceToList(resource, resourceList, targetPath);
                         continue;
+                    } 
+                    else if(string.Equals(assetTraitName, "BlazorWebAssemblyResource", StringComparison.OrdinalIgnoreCase) &&
+                            string.Equals(assetTraitValue, "js-module-crypto", StringComparison.OrdinalIgnoreCase))
+                    {
+                        behavior = assetTraitValue;
                     }
                     else if (string.Equals("BlazorWebAssemblyResource", assetTraitName, StringComparison.OrdinalIgnoreCase) &&
                              assetTraitValue.StartsWith("extension:", StringComparison.OrdinalIgnoreCase))
@@ -185,7 +199,16 @@ public void WriteBootJson(Stream output, string entryAssemblyName)
                         continue;
                     }
 
-                    AddResourceToList(resource, resourceList, resourceName);
+                    if (resourceList != null)
+                    {
+                        AddResourceToList(resource, resourceList, resourceName);
+                    }
+
+                    if (!string.IsNullOrEmpty(behavior))
+                    {
+                        resourceData.runtimeAssets ??= new Dictionary<string, AdditionalAsset>();
+                        AddToAdditionalResources(resource, resourceData.runtimeAssets, resourceName, behavior);
+                    }
                 }
 
                 if (remainingLazyLoadAssemblies.Count > 0)
@@ -235,9 +258,32 @@ void AddResourceToList(ITaskItem resource, ResourceHashesByNameDictionary resour
             }
         }
 
+        private void AddToAdditionalResources(ITaskItem resource, Dictionary<string, AdditionalAsset> additionalResources, string resourceName, string behavior)
+        {
+            if (!additionalResources.ContainsKey(resourceName))
+            {
+                Log.LogMessage(MessageImportance.Low, "Added resource '{0}' to the list of additional assets in the manifest.", resource.ItemSpec);
+                additionalResources.Add(resourceName, new AdditionalAsset
+                {
+                    Hash = $"sha256-{resource.GetMetadata("FileHash")}",
+                    Behavior = behavior
+                });
+            }
+        }
+
         private bool TryGetLazyLoadedAssembly(string fileName, out ITaskItem lazyLoadedAssembly)
         {
             return (lazyLoadedAssembly = LazyLoadedAssemblies?.SingleOrDefault(a => a.ItemSpec == fileName)) != null;
         }
     }
+
+    [DataContract]
+    public class AdditionalAsset
+    {
+        [DataMember(Name = "hash")]
+        public string Hash { get; set; }
+
+        [DataMember(Name = "behavior")]
+        public string Behavior { get; set; }
+    }
 }