From 0d83a2289892d75daac3372aca0ff9b1c624e9dc Mon Sep 17 00:00:00 2001
From: Matt Thalman <mthalman@microsoft.com>
Date: Tue, 14 Jul 2026 08:54:47 -0500
Subject: [PATCH 1/4] Fix dnx crash on Alpine/musl by locating hostfxr under
 the .NET root

When dnx runs via `dotnet exec dotnet.dll dnx`, the host treats it as an
app launch rather than a first-class SDK command and omits the HOSTFXR_PATH
runtime property. On musl the NativeWrapper hostfxr resolver then throws
HostFxrRuntimePropertyNotSetException. Add a fallback that locates the
hostfxr library under the .NET installation root.

The resolution logic is shared via source (src/Common/HostFxrPathResolver.cs)
between the NativeWrapper resolver and the Native AOT dn host so the two
cannot diverge. It parses the numeric core of prerelease version directory
names (e.g. 11.0.0-preview.6.26359.118), which System.Version cannot parse,
prefers stable over prerelease of the same core, and orders prerelease
segments numerically so preview.10 sorts after preview.6.

Co-authored-by: Copilot App <223556219+Copilot@users.noreply.github.com>
Copilot-Session: d75dbb68-3527-49b4-9af6-d64469b45708
---
 src/Cli/dn/DotnetRootResolver.cs              |  41 +--
 src/Cli/dn/dn.csproj                          |   4 +
 src/Common/HostFxrPathResolver.cs             | 140 ++++++++++
 .../HostFxrLocator.cs                         |  51 ++++
 .../Microsoft.DotNet.NativeWrapper/Interop.cs |  18 +-
 .../Microsoft.DotNet.NativeWrapper.csproj     |   5 +
 .../DotnetRootResolverTests.cs                |  71 ++++-
 test/dotnet-aot.Tests/HostFxrLocatorTests.cs  | 242 ++++++++++++++++++
 8 files changed, 531 insertions(+), 41 deletions(-)
 create mode 100644 src/Common/HostFxrPathResolver.cs
 create mode 100644 src/Resolvers/Microsoft.DotNet.NativeWrapper/HostFxrLocator.cs
 create mode 100644 test/dotnet-aot.Tests/HostFxrLocatorTests.cs

diff --git a/src/Cli/dn/DotnetRootResolver.cs b/src/Cli/dn/DotnetRootResolver.cs
index f09f90504233..ef0696bcb47d 100644
--- a/src/Cli/dn/DotnetRootResolver.cs
+++ b/src/Cli/dn/DotnetRootResolver.cs
@@ -2,6 +2,7 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 
 using System.Runtime.InteropServices;
+using Microsoft.DotNet.HostFxr;
 
 namespace Microsoft.DotNet.Cli;
 
@@ -84,37 +85,11 @@ internal static string ResolveHostfxrPath(
         Func<string, bool> directoryExists,
         Func<string, string[]> getDirectories,
         Func<string, bool> fileExists)
-    {
-        string fxrDir = Path.Combine(dotnetRoot, "host", "fxr");
-        if (!directoryExists(fxrDir))
-        {
-            return string.Empty;
-        }
-
-        // Pick the highest version directory by parsing version numbers
-        string? latestFxr = getDirectories(fxrDir)
-            .Select(path => new
-            {
-                Path = path,
-                Version = Version.TryParse(Path.GetFileName(path), out Version? version) ? version : null
-            })
-            .Where(candidate => candidate.Version is not null)
-            .OrderByDescending(candidate => candidate.Version)
-            .Select(candidate => candidate.Path)
-            .FirstOrDefault();
-
-        if (latestFxr is null)
-        {
-            return string.Empty;
-        }
-
-        string hostfxrName = isWindows
-            ? "hostfxr.dll"
-            : isMacOS
-                ? "libhostfxr.dylib"
-                : "libhostfxr.so";
-
-        string hostfxrPath = Path.Combine(latestFxr, hostfxrName);
-        return fileExists(hostfxrPath) ? hostfxrPath : string.Empty;
-    }
+        => HostFxrPathResolver.ResolveHostFxrPath(
+            dotnetRoot,
+            isWindows,
+            isMacOS,
+            directoryExists,
+            getDirectories,
+            fileExists);
 }
diff --git a/src/Cli/dn/dn.csproj b/src/Cli/dn/dn.csproj
index c969c489389e..c282de376b49 100644
--- a/src/Cli/dn/dn.csproj
+++ b/src/Cli/dn/dn.csproj
@@ -22,6 +22,10 @@
     </PackageReference>
   </ItemGroup>
 
+  <ItemGroup>
+    <Compile Include="$(RepoRoot)src\Common\HostFxrPathResolver.cs" LinkBase="Common" />
+  </ItemGroup>
+
   <!--
     When building inside Visual Studio, publish the AOT binaries and overlay managed dependencies
     so the "Debug dn (AOT native)" launch profile is ready to go.
diff --git a/src/Common/HostFxrPathResolver.cs b/src/Common/HostFxrPathResolver.cs
new file mode 100644
index 000000000000..0d631249dbcb
--- /dev/null
+++ b/src/Common/HostFxrPathResolver.cs
@@ -0,0 +1,140 @@
+// 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.HostFxr;
+
+/// <summary>
+///  Locates the native <c>hostfxr</c> library underneath a .NET installation root.
+///  This is used as a fallback when the host does not publish the <c>HOSTFXR_PATH</c>
+///  runtime property (for example when the SDK is launched via <c>dotnet exec dotnet.dll</c>
+///  rather than as a first-class SDK command, which is how the <c>dnx</c> script works).
+///  Dependencies are injected so the pure path-resolution logic can be unit tested.
+///  <para>
+///   This file is source-shared (via <c>&lt;Compile Include&gt;</c>) into both the
+///   <c>Microsoft.DotNet.NativeWrapper</c> resolver and the Native AOT <c>dn</c> host so
+///   the two stay in lockstep; a prior divergence between separate copies is what caused
+///   https://github.com/dotnet/sdk/issues/55238 to be fixed in only one place.
+///  </para>
+/// </summary>
+internal static class HostFxrPathResolver
+{
+    /// <summary>
+    ///  Finds the highest-versioned <c>hostfxr</c> library under
+    ///  <paramref name="dotnetRoot"/>/host/fxr, returning its full path or
+    ///  <see cref="string.Empty"/> if it cannot be found.
+    /// </summary>
+    internal static string ResolveHostFxrPath(
+        string? dotnetRoot,
+        bool isWindows,
+        bool isMacOS,
+        Func<string, bool> directoryExists,
+        Func<string, string[]> getDirectories,
+        Func<string, bool> fileExists)
+    {
+        if (string.IsNullOrEmpty(dotnetRoot))
+        {
+            return string.Empty;
+        }
+
+        string fxrDir = Path.Combine(dotnetRoot, "host", "fxr");
+        if (!directoryExists(fxrDir))
+        {
+            return string.Empty;
+        }
+
+        // Pick the highest version directory. Directory names frequently include
+        // prerelease/build suffixes (e.g. "11.0.0-preview.6.26359.118"), which
+        // Version.TryParse cannot handle, so parse the numeric core for comparison.
+        string? latestFxr = getDirectories(fxrDir)
+            .Select(path =>
+            {
+                string name = Path.GetFileName(path);
+                int suffix = name.IndexOfAny(new[] { '-', '+' });
+                bool isStable = suffix < 0;
+                string core = isStable ? name : name.Substring(0, suffix);
+                return new
+                {
+                    Path = path,
+                    Name = name,
+                    IsStable = isStable,
+                    Version = Version.TryParse(core, out Version? version) ? version : null
+                };
+            })
+            .Where(candidate => candidate.Version is not null)
+            .OrderByDescending(candidate => candidate.Version)
+            .ThenByDescending(candidate => candidate.IsStable)
+            .ThenByDescending(candidate => candidate.Name, s_versionNameComparer)
+            .Select(candidate => candidate.Path)
+            .FirstOrDefault();
+
+        if (latestFxr is null)
+        {
+            return string.Empty;
+        }
+
+        string hostfxrName = isWindows
+            ? "hostfxr.dll"
+            : isMacOS
+                ? "libhostfxr.dylib"
+                : "libhostfxr.so";
+
+        string hostfxrPath = Path.Combine(latestFxr, hostfxrName);
+        return fileExists(hostfxrPath) ? hostfxrPath : string.Empty;
+    }
+
+    /// <summary>
+    ///  Orders version directory names so that numeric segments compare numerically
+    ///  (e.g. <c>preview.10</c> sorts after <c>preview.6</c>). A plain ordinal compare
+    ///  would place <c>preview.6</c> after <c>preview.10</c> because <c>'6' &gt; '1'</c>.
+    /// </summary>
+    private static readonly IComparer<string> s_versionNameComparer =
+        Comparer<string>.Create(CompareVersionNamesNumerically);
+
+    private static int CompareVersionNamesNumerically(string a, string b)
+    {
+        int i = 0, j = 0;
+        while (i < a.Length && j < b.Length)
+        {
+            if (char.IsDigit(a[i]) && char.IsDigit(b[j]))
+            {
+                int startA = i, startB = j;
+                while (i < a.Length && char.IsDigit(a[i]))
+                {
+                    i++;
+                }
+                while (j < b.Length && char.IsDigit(b[j]))
+                {
+                    j++;
+                }
+
+                string numA = a.Substring(startA, i - startA).TrimStart('0');
+                string numB = b.Substring(startB, j - startB).TrimStart('0');
+
+                // Longer numeric run (ignoring leading zeros) is the larger number.
+                if (numA.Length != numB.Length)
+                {
+                    return numA.Length - numB.Length;
+                }
+
+                int ordinal = string.CompareOrdinal(numA, numB);
+                if (ordinal != 0)
+                {
+                    return ordinal;
+                }
+            }
+            else
+            {
+                int cmp = char.ToLowerInvariant(a[i]).CompareTo(char.ToLowerInvariant(b[j]));
+                if (cmp != 0)
+                {
+                    return cmp;
+                }
+                i++;
+                j++;
+            }
+        }
+
+        // Whichever string still has characters left is the greater one.
+        return (a.Length - i) - (b.Length - j);
+    }
+}
diff --git a/src/Resolvers/Microsoft.DotNet.NativeWrapper/HostFxrLocator.cs b/src/Resolvers/Microsoft.DotNet.NativeWrapper/HostFxrLocator.cs
new file mode 100644
index 000000000000..3c47a3ca7cb0
--- /dev/null
+++ b/src/Resolvers/Microsoft.DotNet.NativeWrapper/HostFxrLocator.cs
@@ -0,0 +1,51 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using Microsoft.DotNet.HostFxr;
+
+namespace Microsoft.DotNet.NativeWrapper
+{
+    /// <summary>
+    ///  NativeWrapper-facing entry point for locating the native <c>hostfxr</c> library.
+    ///  The actual path-resolution logic lives in the source-shared
+    ///  <see cref="HostFxrPathResolver"/> (under <c>src/Common</c>) so this resolver and the
+    ///  Native AOT <c>dn</c> host stay in lockstep.
+    /// </summary>
+    internal static class HostFxrLocator
+    {
+        /// <summary>
+        ///  Finds the highest-versioned <c>hostfxr</c> library under
+        ///  <paramref name="dotnetRoot"/>/host/fxr, returning its full path or
+        ///  <see cref="string.Empty"/> if it cannot be found.
+        /// </summary>
+        internal static string ResolveHostFxrPath(
+            string? dotnetRoot,
+            bool isWindows,
+            bool isMacOS,
+            Func<string, bool> directoryExists,
+            Func<string, string[]> getDirectories,
+            Func<string, bool> fileExists)
+            => HostFxrPathResolver.ResolveHostFxrPath(
+                dotnetRoot,
+                isWindows,
+                isMacOS,
+                directoryExists,
+                getDirectories,
+                fileExists);
+
+#if NET
+        /// <summary>
+        ///  Resolves the <c>hostfxr</c> path against the live filesystem, deriving the .NET
+        ///  installation root from the current process (the running <c>dotnet</c> host).
+        /// </summary>
+        internal static string ResolveHostFxrPath()
+            => ResolveHostFxrPath(
+                EnvironmentProvider.GetDotnetExeDirectory(),
+                isWindows: OperatingSystem.IsWindows(),
+                isMacOS: OperatingSystem.IsMacOS(),
+                directoryExists: Directory.Exists,
+                getDirectories: Directory.GetDirectories,
+                fileExists: File.Exists);
+#endif
+    }
+}
diff --git a/src/Resolvers/Microsoft.DotNet.NativeWrapper/Interop.cs b/src/Resolvers/Microsoft.DotNet.NativeWrapper/Interop.cs
index 40faa7278c20..6ff2dd1a83b7 100644
--- a/src/Resolvers/Microsoft.DotNet.NativeWrapper/Interop.cs
+++ b/src/Resolvers/Microsoft.DotNet.NativeWrapper/Interop.cs
@@ -68,14 +68,26 @@ private static IntPtr HostFxrResolver(Assembly assembly, string libraryName)
                 return IntPtr.Zero;
             }
 
-            if (string.IsNullOrEmpty(s_hostFxrPath))
+            string? hostFxrPath = s_hostFxrPath;
+
+            // The host only publishes the HOSTFXR_PATH runtime property for first-class SDK
+            // commands (e.g. `dotnet build`). When the SDK is launched via `dotnet exec dotnet.dll`
+            // (as the `dnx` script does), the property is absent. On glibc the bare `libhostfxr`
+            // load succeeds against the already-loaded library so this resolver never runs, but on
+            // musl it does not, so fall back to locating hostfxr under the running .NET root.
+            if (string.IsNullOrEmpty(hostFxrPath))
+            {
+                hostFxrPath = HostFxrLocator.ResolveHostFxrPath();
+            }
+
+            if (string.IsNullOrEmpty(hostFxrPath))
             {
                 throw new HostFxrRuntimePropertyNotSetException();
             }
 
-            if (!NativeLibrary.TryLoad(s_hostFxrPath, out var handle))
+            if (!NativeLibrary.TryLoad(hostFxrPath, out var handle))
             {
-                throw new HostFxrNotFoundException(s_hostFxrPath);
+                throw new HostFxrNotFoundException(hostFxrPath);
             }
 
             return handle;
diff --git a/src/Resolvers/Microsoft.DotNet.NativeWrapper/Microsoft.DotNet.NativeWrapper.csproj b/src/Resolvers/Microsoft.DotNet.NativeWrapper/Microsoft.DotNet.NativeWrapper.csproj
index c51d4499dee5..bb420c294e9f 100644
--- a/src/Resolvers/Microsoft.DotNet.NativeWrapper/Microsoft.DotNet.NativeWrapper.csproj
+++ b/src/Resolvers/Microsoft.DotNet.NativeWrapper/Microsoft.DotNet.NativeWrapper.csproj
@@ -17,8 +17,13 @@
     <PackageReference Include="Microsoft.Deployment.DotNet.Releases" />
   </ItemGroup>
 
+  <ItemGroup>
+    <Compile Include="$(RepoRoot)src\Common\HostFxrPathResolver.cs" LinkBase="Common" />
+  </ItemGroup>
+
   <ItemGroup>
     <InternalsVisibleTo Include="dotnet-aot" PublicKey="0024000004800000940000000602000000240000525341310004000001000100F33A29044FA9D740C9B3213A93E57C84B472C84E0B8A0E1AE48E67A9F8F6DE9D5F7F3D52AC23E48AC51801F1DC950ABE901DA34D2A9E3BAADB141A17C77EF3C565DD5EE5054B91CF63BB3C6AB83F72AB3AAFE93D0FC3C2348B764FAFB0B1C0733DE51459AEAB46580384BF9D74C4E28164B7CDE247F891BA07891C9D872AD2BB" />
+    <InternalsVisibleTo Include="dotnet-aot.Tests" PublicKey="0024000004800000940000000602000000240000525341310004000001000100F33A29044FA9D740C9B3213A93E57C84B472C84E0B8A0E1AE48E67A9F8F6DE9D5F7F3D52AC23E48AC51801F1DC950ABE901DA34D2A9E3BAADB141A17C77EF3C565DD5EE5054B91CF63BB3C6AB83F72AB3AAFE93D0FC3C2348B764FAFB0B1C0733DE51459AEAB46580384BF9D74C4E28164B7CDE247F891BA07891C9D872AD2BB" />
   </ItemGroup>
 
 </Project>
diff --git a/test/dotnet-aot.Tests/DotnetRootResolverTests.cs b/test/dotnet-aot.Tests/DotnetRootResolverTests.cs
index 0474dae866e6..73304442254a 100644
--- a/test/dotnet-aot.Tests/DotnetRootResolverTests.cs
+++ b/test/dotnet-aot.Tests/DotnetRootResolverTests.cs
@@ -180,24 +180,85 @@ public void ResolveHostfxrPath_PicksHighestVersion()
     }
 
     [TestMethod]
-    public void ResolveHostfxrPath_SkipsPrereleaseDirectories()
+    public void ResolveHostfxrPath_FindsPrereleaseVersionDirectory()
     {
+        // On a preview-only install, host/fxr contains a single prerelease-named
+        // directory (e.g. "10.0.0-preview.5"). Version.TryParse can't parse that string,
+        // so the numeric core must be used instead of skipping the directory.
         string dotnetRoot = BuildPath(true, "dotnet");
         string fxrDir = Path.Combine(dotnetRoot, "host", "fxr");
         string preview = Path.Combine(fxrDir, "10.0.0-preview.5");
+        string expectedPath = Path.Combine(preview, "hostfxr.dll");
+
+        string result = DotnetRootResolver.ResolveHostfxrPath(
+            dotnetRoot: dotnetRoot,
+            isWindows: true,
+            isMacOS: false,
+            directoryExists: _ => true,
+            getDirectories: _ => new[] { preview },
+            fileExists: _ => true);
+
+        Assert.AreEqual(expectedPath, result);
+    }
+
+    [TestMethod]
+    public void ResolveHostfxrPath_PicksHighestVersion_IncludingPrerelease()
+    {
+        string dotnetRoot = BuildPath(true, "dotnet");
+        string fxrDir = Path.Combine(dotnetRoot, "host", "fxr");
         string v900 = Path.Combine(fxrDir, "9.0.0");
-        string expectedPath = Path.Combine(v900, "hostfxr.dll");
+        string preview = Path.Combine(fxrDir, "10.0.0-preview.5");
+        string expectedPath = Path.Combine(preview, "hostfxr.dll");
+
+        string result = DotnetRootResolver.ResolveHostfxrPath(
+            dotnetRoot: dotnetRoot,
+            isWindows: true,
+            isMacOS: false,
+            directoryExists: _ => true,
+            getDirectories: _ => new[] { v900, preview },
+            fileExists: _ => true);
+
+        Assert.AreEqual(expectedPath, result);
+    }
+
+    [TestMethod]
+    public void ResolveHostfxrPath_PrefersStableOverPrereleaseOfSameCore()
+    {
+        string dotnetRoot = BuildPath(true, "dotnet");
+        string fxrDir = Path.Combine(dotnetRoot, "host", "fxr");
+        string stable = Path.Combine(fxrDir, "10.0.0");
+        string preview = Path.Combine(fxrDir, "10.0.0-preview.5");
+        string expectedPath = Path.Combine(stable, "hostfxr.dll");
+
+        string result = DotnetRootResolver.ResolveHostfxrPath(
+            dotnetRoot: dotnetRoot,
+            isWindows: true,
+            isMacOS: false,
+            directoryExists: _ => true,
+            getDirectories: _ => new[] { preview, stable },
+            fileExists: _ => true);
+
+        Assert.AreEqual(expectedPath, result);
+    }
+
+    [TestMethod]
+    public void ResolveHostfxrPath_OrdersPrereleaseSegmentsNumerically()
+    {
+        // "preview.10" must sort after "preview.6"; a plain ordinal compare gets this wrong.
+        string dotnetRoot = BuildPath(true, "dotnet");
+        string fxrDir = Path.Combine(dotnetRoot, "host", "fxr");
+        string preview6 = Path.Combine(fxrDir, "10.0.0-preview.6");
+        string preview10 = Path.Combine(fxrDir, "10.0.0-preview.10");
+        string expectedPath = Path.Combine(preview10, "hostfxr.dll");
 
-        // Version.TryParse fails for prerelease strings like "10.0.0-preview.5"
         string result = DotnetRootResolver.ResolveHostfxrPath(
             dotnetRoot: dotnetRoot,
             isWindows: true,
             isMacOS: false,
             directoryExists: _ => true,
-            getDirectories: _ => new[] { preview, v900 },
+            getDirectories: _ => new[] { preview6, preview10 },
             fileExists: _ => true);
 
-        // Should pick 9.0.0 since the preview dir is skipped
         Assert.AreEqual(expectedPath, result);
     }
 
diff --git a/test/dotnet-aot.Tests/HostFxrLocatorTests.cs b/test/dotnet-aot.Tests/HostFxrLocatorTests.cs
new file mode 100644
index 000000000000..4569cf2f3cd7
--- /dev/null
+++ b/test/dotnet-aot.Tests/HostFxrLocatorTests.cs
@@ -0,0 +1,242 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using Microsoft.DotNet.NativeWrapper;
+
+namespace Microsoft.DotNet.Cli.Tests;
+
+/// <summary>
+///  Tests for <see cref="HostFxrLocator"/>, the fallback used by the SDK's hostfxr
+///  resolver when the host does not publish the <c>HOSTFXR_PATH</c> runtime property
+///  (e.g. <c>dnx</c> launching the SDK via <c>dotnet exec dotnet.dll</c> on musl).
+///  Uses injected filesystem dependencies so the pure path logic is testable.
+/// </summary>
+[TestClass]
+public class HostFxrLocatorTests
+{
+    private static string BuildPath(bool isWindows, params string[] segments)
+    {
+        string root = isWindows ? @"C:\" : "/";
+        return segments.Length == 0 ? root : Path.Combine(root, Path.Combine(segments));
+    }
+
+    [TestMethod]
+    public void ResolveHostFxrPath_WithValidFxrDir_ReturnsPath()
+    {
+        string dotnetRoot = BuildPath(true, "dotnet");
+        string fxrDir = Path.Combine(dotnetRoot, "host", "fxr");
+        string fxrVersion = Path.Combine(fxrDir, "11.0.0");
+        string expectedPath = Path.Combine(fxrVersion, "hostfxr.dll");
+
+        string result = HostFxrLocator.ResolveHostFxrPath(
+            dotnetRoot: dotnetRoot,
+            isWindows: true,
+            isMacOS: false,
+            directoryExists: path => path == fxrDir,
+            getDirectories: _ => new[] { fxrVersion },
+            fileExists: path => path == expectedPath);
+
+        Assert.AreEqual(expectedPath, result);
+    }
+
+    [TestMethod]
+    public void ResolveHostFxrPath_PicksHighestVersion()
+    {
+        string dotnetRoot = BuildPath(true, "dotnet");
+        string fxrDir = Path.Combine(dotnetRoot, "host", "fxr");
+        string v800 = Path.Combine(fxrDir, "8.0.0");
+        string v901 = Path.Combine(fxrDir, "9.0.1");
+        string v900 = Path.Combine(fxrDir, "9.0.0");
+        string expectedPath = Path.Combine(v901, "hostfxr.dll");
+
+        string result = HostFxrLocator.ResolveHostFxrPath(
+            dotnetRoot: dotnetRoot,
+            isWindows: true,
+            isMacOS: false,
+            directoryExists: _ => true,
+            getDirectories: _ => new[] { v800, v901, v900 },
+            fileExists: _ => true);
+
+        Assert.AreEqual(expectedPath, result);
+    }
+
+    [TestMethod]
+    public void ResolveHostFxrPath_NullOrEmptyDotnetRoot_ReturnsEmpty()
+    {
+        string resultNull = HostFxrLocator.ResolveHostFxrPath(
+            dotnetRoot: null,
+            isWindows: true,
+            isMacOS: false,
+            directoryExists: _ => true,
+            getDirectories: _ => Array.Empty<string>(),
+            fileExists: _ => true);
+
+        string resultEmpty = HostFxrLocator.ResolveHostFxrPath(
+            dotnetRoot: string.Empty,
+            isWindows: true,
+            isMacOS: false,
+            directoryExists: _ => true,
+            getDirectories: _ => Array.Empty<string>(),
+            fileExists: _ => true);
+
+        Assert.AreEqual(string.Empty, resultNull);
+        Assert.AreEqual(string.Empty, resultEmpty);
+    }
+
+    [TestMethod]
+    public void ResolveHostFxrPath_MissingFxrDirectory_ReturnsEmpty()
+    {
+        string dotnetRoot = BuildPath(true, "dotnet");
+
+        string result = HostFxrLocator.ResolveHostFxrPath(
+            dotnetRoot: dotnetRoot,
+            isWindows: true,
+            isMacOS: false,
+            directoryExists: _ => false,
+            getDirectories: _ => Array.Empty<string>(),
+            fileExists: _ => false);
+
+        Assert.AreEqual(string.Empty, result);
+    }
+
+    [TestMethod]
+    public void ResolveHostFxrPath_FxrDirExistsButNoHostfxrFile_ReturnsEmpty()
+    {
+        string dotnetRoot = BuildPath(true, "dotnet");
+        string fxrDir = Path.Combine(dotnetRoot, "host", "fxr");
+        string fxrVersion = Path.Combine(fxrDir, "9.0.0");
+
+        string result = HostFxrLocator.ResolveHostFxrPath(
+            dotnetRoot: dotnetRoot,
+            isWindows: true,
+            isMacOS: false,
+            directoryExists: _ => true,
+            getDirectories: _ => new[] { fxrVersion },
+            fileExists: _ => false);
+
+        Assert.AreEqual(string.Empty, result);
+    }
+
+    [TestMethod]
+    public void ResolveHostFxrPath_OnMacOS_LooksForDylib()
+    {
+        string dotnetRoot = Path.Combine("/", "usr", "local", "share", "dotnet");
+        string fxrDir = Path.Combine(dotnetRoot, "host", "fxr");
+        string fxrVersion = Path.Combine(fxrDir, "9.0.0");
+        string expectedPath = Path.Combine(fxrVersion, "libhostfxr.dylib");
+
+        string result = HostFxrLocator.ResolveHostFxrPath(
+            dotnetRoot: dotnetRoot,
+            isWindows: false,
+            isMacOS: true,
+            directoryExists: path => path == fxrDir,
+            getDirectories: _ => new[] { fxrVersion },
+            fileExists: path => path == expectedPath);
+
+        Assert.AreEqual(expectedPath, result);
+    }
+
+    [TestMethod]
+    public void ResolveHostFxrPath_OnLinux_LooksForSo()
+    {
+        // Mirrors the musl/Alpine scenario from https://github.com/dotnet/sdk/issues/55238
+        // where HOSTFXR_PATH is unset and we must locate libhostfxr.so ourselves.
+        string dotnetRoot = Path.Combine("/", "usr", "share", "dotnet");
+        string fxrDir = Path.Combine(dotnetRoot, "host", "fxr");
+        string fxrVersion = Path.Combine(fxrDir, "9.0.0");
+        string expectedPath = Path.Combine(fxrVersion, "libhostfxr.so");
+
+        string result = HostFxrLocator.ResolveHostFxrPath(
+            dotnetRoot: dotnetRoot,
+            isWindows: false,
+            isMacOS: false,
+            directoryExists: path => path == fxrDir,
+            getDirectories: _ => new[] { fxrVersion },
+            fileExists: path => path == expectedPath);
+
+        Assert.AreEqual(expectedPath, result);
+    }
+
+    [TestMethod]
+    public void ResolveHostFxrPath_FindsPrereleaseVersionDirectory()
+    {
+        // The real Alpine/musl repro: host/fxr contains a single prerelease-named
+        // directory (e.g. "11.0.0-preview.6.26359.118"). Version.TryParse can't parse
+        // that string, so the numeric core must be used instead.
+        string dotnetRoot = Path.Combine("/", "dotnet");
+        string fxrDir = Path.Combine(dotnetRoot, "host", "fxr");
+        string fxrVersion = Path.Combine(fxrDir, "11.0.0-preview.6.26359.118");
+        string expectedPath = Path.Combine(fxrVersion, "libhostfxr.so");
+
+        string result = HostFxrLocator.ResolveHostFxrPath(
+            dotnetRoot: dotnetRoot,
+            isWindows: false,
+            isMacOS: false,
+            directoryExists: path => path == fxrDir,
+            getDirectories: _ => new[] { fxrVersion },
+            fileExists: path => path == expectedPath);
+
+        Assert.AreEqual(expectedPath, result);
+    }
+
+    [TestMethod]
+    public void ResolveHostFxrPath_PicksHighestVersion_IncludingPrerelease()
+    {
+        string dotnetRoot = BuildPath(true, "dotnet");
+        string fxrDir = Path.Combine(dotnetRoot, "host", "fxr");
+        string v900 = Path.Combine(fxrDir, "9.0.0");
+        string v11Preview = Path.Combine(fxrDir, "11.0.0-preview.6.26359.118");
+        string expectedPath = Path.Combine(v11Preview, "hostfxr.dll");
+
+        string result = HostFxrLocator.ResolveHostFxrPath(
+            dotnetRoot: dotnetRoot,
+            isWindows: true,
+            isMacOS: false,
+            directoryExists: _ => true,
+            getDirectories: _ => new[] { v900, v11Preview },
+            fileExists: _ => true);
+
+        Assert.AreEqual(expectedPath, result);
+    }
+
+    [TestMethod]
+    public void ResolveHostFxrPath_PrefersStableOverPrereleaseOfSameCore()
+    {
+        string dotnetRoot = BuildPath(true, "dotnet");
+        string fxrDir = Path.Combine(dotnetRoot, "host", "fxr");
+        string stable = Path.Combine(fxrDir, "11.0.0");
+        string preview = Path.Combine(fxrDir, "11.0.0-preview.6.26359.118");
+        string expectedPath = Path.Combine(stable, "hostfxr.dll");
+
+        string result = HostFxrLocator.ResolveHostFxrPath(
+            dotnetRoot: dotnetRoot,
+            isWindows: true,
+            isMacOS: false,
+            directoryExists: _ => true,
+            getDirectories: _ => new[] { preview, stable },
+            fileExists: _ => true);
+
+        Assert.AreEqual(expectedPath, result);
+    }
+
+    [TestMethod]
+    public void ResolveHostFxrPath_OrdersPrereleaseSegmentsNumerically()
+    {
+        // "preview.10" must sort after "preview.6"; a plain ordinal compare gets this wrong.
+        string dotnetRoot = BuildPath(true, "dotnet");
+        string fxrDir = Path.Combine(dotnetRoot, "host", "fxr");
+        string preview6 = Path.Combine(fxrDir, "11.0.0-preview.6.26359.118");
+        string preview10 = Path.Combine(fxrDir, "11.0.0-preview.10.26400.1");
+        string expectedPath = Path.Combine(preview10, "hostfxr.dll");
+
+        string result = HostFxrLocator.ResolveHostFxrPath(
+            dotnetRoot: dotnetRoot,
+            isWindows: true,
+            isMacOS: false,
+            directoryExists: _ => true,
+            getDirectories: _ => new[] { preview6, preview10 },
+            fileExists: _ => true);
+
+        Assert.AreEqual(expectedPath, result);
+    }
+}

From 9238c3f46e4b650542eb9ffb2da9b047cbcf51d1 Mon Sep 17 00:00:00 2001
From: Matt Thalman <mthalman@microsoft.com>
Date: Tue, 14 Jul 2026 12:37:05 -0500
Subject: [PATCH 2/4] Include shared HostFxrPathResolver.cs in
 MSBuildSdkResolver

MSBuildSdkResolver source-globs the entire NativeWrapper tree, which now
references the shared HostFxrPathResolver type in src/Common. That file is
outside the glob, so add it to the project's existing src/Common includes to
fix the net472 CS0234 compile break.

Co-authored-by: Copilot App <223556219+Copilot@users.noreply.github.com>
Copilot-Session: d75dbb68-3527-49b4-9af6-d64469b45708
---
 .../Microsoft.DotNet.MSBuildSdkResolver.csproj                   | 1 +
 1 file changed, 1 insertion(+)

diff --git a/src/Resolvers/Microsoft.DotNet.MSBuildSdkResolver/Microsoft.DotNet.MSBuildSdkResolver.csproj b/src/Resolvers/Microsoft.DotNet.MSBuildSdkResolver/Microsoft.DotNet.MSBuildSdkResolver.csproj
index 38f8cdcd467b..e2cf2a3e87c6 100644
--- a/src/Resolvers/Microsoft.DotNet.MSBuildSdkResolver/Microsoft.DotNet.MSBuildSdkResolver.csproj
+++ b/src/Resolvers/Microsoft.DotNet.MSBuildSdkResolver/Microsoft.DotNet.MSBuildSdkResolver.csproj
@@ -67,6 +67,7 @@
 
     <Compile Include="$(RepoRoot)src\Common\EnvironmentVariableNames.cs" LinkBase="Common" />
     <Compile Include="$(RepoRoot)src\Common\CliFolderPathCalculatorCore.cs" LinkBase="Common" />
+    <Compile Include="$(RepoRoot)src\Common\HostFxrPathResolver.cs" LinkBase="Common" />
     <Compile Include="$(RepoRoot)src\Common\Polyfills.cs" LinkBase="Common" />
     <Compile Include="$(RepoRoot)src\Common\WorkloadFileBasedInstall.cs" LinkBase="Common" />
     <Compile Include="$(RepoRoot)src\Common\WorkloadSetVersion.cs" LinkBase="Common" />

From 8345a548044cea89e3688f909e515c98d2d8f8b2 Mon Sep 17 00:00:00 2001
From: Matt Thalman <mthalman@microsoft.com>
Date: Tue, 14 Jul 2026 13:12:50 -0500
Subject: [PATCH 3/4] Align hostfxr fallback with runtime SemVer rules

Mirror the native host's version parsing and precedence when selecting the latest hostfxr directory. Valid prerelease versions remain eligible, build metadata does not affect precedence, and malformed SemVer directories are ignored.

Co-authored-by: Copilot App <223556219+Copilot@users.noreply.github.com>

Copilot-Session: d75dbb68-3527-49b4-9af6-d64469b45708
---
 src/Common/HostFxrPathResolver.cs             | 216 ++++++++++++++----
 .../DotnetRootResolverTests.cs                |  61 +++++
 2 files changed, 232 insertions(+), 45 deletions(-)

diff --git a/src/Common/HostFxrPathResolver.cs b/src/Common/HostFxrPathResolver.cs
index 0d631249dbcb..e00316d657d5 100644
--- a/src/Common/HostFxrPathResolver.cs
+++ b/src/Common/HostFxrPathResolver.cs
@@ -42,28 +42,22 @@ internal static string ResolveHostFxrPath(
             return string.Empty;
         }
 
-        // Pick the highest version directory. Directory names frequently include
-        // prerelease/build suffixes (e.g. "11.0.0-preview.6.26359.118"), which
-        // Version.TryParse cannot handle, so parse the numeric core for comparison.
+        // Match the native host's get_latest_fxr behavior: consider every valid
+        // semantic version, including prerelease versions, and select the highest.
+        // SDK and runtime roll-forward settings apply after hostfxr is loaded and
+        // do not affect hostfxr selection.
         string? latestFxr = getDirectories(fxrDir)
             .Select(path =>
             {
-                string name = Path.GetFileName(path);
-                int suffix = name.IndexOfAny(new[] { '-', '+' });
-                bool isStable = suffix < 0;
-                string core = isStable ? name : name.Substring(0, suffix);
+                HostFxrVersion.TryParse(Path.GetFileName(path), out HostFxrVersion? version);
                 return new
                 {
                     Path = path,
-                    Name = name,
-                    IsStable = isStable,
-                    Version = Version.TryParse(core, out Version? version) ? version : null
+                    Version = version
                 };
             })
             .Where(candidate => candidate.Version is not null)
             .OrderByDescending(candidate => candidate.Version)
-            .ThenByDescending(candidate => candidate.IsStable)
-            .ThenByDescending(candidate => candidate.Name, s_versionNameComparer)
             .Select(candidate => candidate.Path)
             .FirstOrDefault();
 
@@ -82,59 +76,191 @@ internal static string ResolveHostFxrPath(
         return fileExists(hostfxrPath) ? hostfxrPath : string.Empty;
     }
 
-    /// <summary>
-    ///  Orders version directory names so that numeric segments compare numerically
-    ///  (e.g. <c>preview.10</c> sorts after <c>preview.6</c>). A plain ordinal compare
-    ///  would place <c>preview.6</c> after <c>preview.10</c> because <c>'6' &gt; '1'</c>.
-    /// </summary>
-    private static readonly IComparer<string> s_versionNameComparer =
-        Comparer<string>.Create(CompareVersionNamesNumerically);
-
-    private static int CompareVersionNamesNumerically(string a, string b)
+    // Mirrors the SemVer parsing and precedence used by the native host's
+    // c_fx_ver_parse and c_fx_ver_compare functions.
+    private sealed class HostFxrVersion : IComparable<HostFxrVersion>
     {
-        int i = 0, j = 0;
-        while (i < a.Length && j < b.Length)
+        private readonly uint _major;
+        private readonly uint _minor;
+        private readonly uint _patch;
+        private readonly string[] _prereleaseIdentifiers;
+
+        private HostFxrVersion(uint major, uint minor, uint patch, string[] prereleaseIdentifiers)
+        {
+            _major = major;
+            _minor = minor;
+            _patch = patch;
+            _prereleaseIdentifiers = prereleaseIdentifiers;
+        }
+
+        public int CompareTo(HostFxrVersion? other)
+        {
+            if (other is null)
+            {
+                return 1;
+            }
+
+            int comparison = _major.CompareTo(other._major);
+            if (comparison != 0)
+            {
+                return comparison;
+            }
+
+            comparison = _minor.CompareTo(other._minor);
+            if (comparison != 0)
+            {
+                return comparison;
+            }
+
+            comparison = _patch.CompareTo(other._patch);
+            if (comparison != 0)
+            {
+                return comparison;
+            }
+
+            bool isPrerelease = _prereleaseIdentifiers.Length > 0;
+            bool otherIsPrerelease = other._prereleaseIdentifiers.Length > 0;
+            if (isPrerelease != otherIsPrerelease)
+            {
+                return isPrerelease ? -1 : 1;
+            }
+
+            int identifierCount = Math.Min(_prereleaseIdentifiers.Length, other._prereleaseIdentifiers.Length);
+            for (int i = 0; i < identifierCount; i++)
+            {
+                comparison = ComparePrereleaseIdentifiers(
+                    _prereleaseIdentifiers[i],
+                    other._prereleaseIdentifiers[i]);
+                if (comparison != 0)
+                {
+                    return comparison;
+                }
+            }
+
+            return _prereleaseIdentifiers.Length.CompareTo(other._prereleaseIdentifiers.Length);
+        }
+
+        internal static bool TryParse(string value, out HostFxrVersion? version)
         {
-            if (char.IsDigit(a[i]) && char.IsDigit(b[j]))
+            version = null;
+
+            int buildSeparator = value.IndexOf('+');
+            if (buildSeparator >= 0)
             {
-                int startA = i, startB = j;
-                while (i < a.Length && char.IsDigit(a[i]))
+                if (!AreValidIdentifiers(value.Substring(buildSeparator + 1), allowLeadingZeros: true))
                 {
-                    i++;
+                    return false;
                 }
-                while (j < b.Length && char.IsDigit(b[j]))
+
+                value = value.Substring(0, buildSeparator);
+            }
+
+            string[] prereleaseIdentifiers = Array.Empty<string>();
+            int prereleaseSeparator = value.IndexOf('-');
+            if (prereleaseSeparator >= 0)
+            {
+                string prerelease = value.Substring(prereleaseSeparator + 1);
+                if (!AreValidIdentifiers(prerelease, allowLeadingZeros: false))
                 {
-                    j++;
+                    return false;
                 }
 
-                string numA = a.Substring(startA, i - startA).TrimStart('0');
-                string numB = b.Substring(startB, j - startB).TrimStart('0');
+                prereleaseIdentifiers = prerelease.Split('.');
+                value = value.Substring(0, prereleaseSeparator);
+            }
+
+            string[] coreIdentifiers = value.Split('.');
+            if (coreIdentifiers.Length != 3
+                || !TryParseCoreIdentifier(coreIdentifiers[0], out uint major)
+                || !TryParseCoreIdentifier(coreIdentifiers[1], out uint minor)
+                || !TryParseCoreIdentifier(coreIdentifiers[2], out uint patch))
+            {
+                return false;
+            }
 
-                // Longer numeric run (ignoring leading zeros) is the larger number.
-                if (numA.Length != numB.Length)
+            version = new HostFxrVersion(major, minor, patch, prereleaseIdentifiers);
+            return true;
+        }
+
+        private static bool TryParseCoreIdentifier(string value, out uint result)
+        {
+            result = 0;
+            return IsNumericIdentifier(value)
+                && (value.Length == 1 || value[0] != '0')
+                && uint.TryParse(value, out result);
+        }
+
+        private static bool AreValidIdentifiers(string value, bool allowLeadingZeros)
+        {
+            string[] identifiers = value.Split('.');
+            foreach (string identifier in identifiers)
+            {
+                if (identifier.Length == 0)
+                {
+                    return false;
+                }
+
+                bool isNumeric = true;
+                foreach (char character in identifier)
                 {
-                    return numA.Length - numB.Length;
+                    if (!IsValidIdentifierCharacter(character))
+                    {
+                        return false;
+                    }
+
+                    isNumeric &= character is >= '0' and <= '9';
                 }
 
-                int ordinal = string.CompareOrdinal(numA, numB);
-                if (ordinal != 0)
+                if (!allowLeadingZeros && isNumeric && identifier.Length > 1 && identifier[0] == '0')
                 {
-                    return ordinal;
+                    return false;
                 }
             }
-            else
+
+            return true;
+        }
+
+        private static bool IsValidIdentifierCharacter(char character) =>
+            character is >= '0' and <= '9'
+                or >= 'A' and <= 'Z'
+                or >= 'a' and <= 'z'
+                or '-';
+
+        private static bool IsNumericIdentifier(string value)
+        {
+            if (value.Length == 0)
+            {
+                return false;
+            }
+
+            foreach (char character in value)
             {
-                int cmp = char.ToLowerInvariant(a[i]).CompareTo(char.ToLowerInvariant(b[j]));
-                if (cmp != 0)
+                if (character is < '0' or > '9')
                 {
-                    return cmp;
+                    return false;
                 }
-                i++;
-                j++;
             }
+
+            return true;
         }
 
-        // Whichever string still has characters left is the greater one.
-        return (a.Length - i) - (b.Length - j);
+        private static int ComparePrereleaseIdentifiers(string left, string right)
+        {
+            bool leftIsNumeric = IsNumericIdentifier(left);
+            bool rightIsNumeric = IsNumericIdentifier(right);
+
+            if (leftIsNumeric && rightIsNumeric)
+            {
+                int comparison = left.Length.CompareTo(right.Length);
+                return comparison != 0 ? comparison : string.CompareOrdinal(left, right);
+            }
+
+            if (leftIsNumeric != rightIsNumeric)
+            {
+                return leftIsNumeric ? -1 : 1;
+            }
+
+            return string.CompareOrdinal(left, right);
+        }
     }
 }
diff --git a/test/dotnet-aot.Tests/DotnetRootResolverTests.cs b/test/dotnet-aot.Tests/DotnetRootResolverTests.cs
index 73304442254a..84f127137309 100644
--- a/test/dotnet-aot.Tests/DotnetRootResolverTests.cs
+++ b/test/dotnet-aot.Tests/DotnetRootResolverTests.cs
@@ -241,6 +241,26 @@ public void ResolveHostfxrPath_PrefersStableOverPrereleaseOfSameCore()
         Assert.AreEqual(expectedPath, result);
     }
 
+    [TestMethod]
+    public void ResolveHostfxrPath_TreatsBuildMetadataAsStable()
+    {
+        string dotnetRoot = BuildPath(true, "dotnet");
+        string fxrDir = Path.Combine(dotnetRoot, "host", "fxr");
+        string stable = Path.Combine(fxrDir, "10.0.0+build.1");
+        string preview = Path.Combine(fxrDir, "10.0.0-preview.5");
+        string expectedPath = Path.Combine(stable, "hostfxr.dll");
+
+        string result = DotnetRootResolver.ResolveHostfxrPath(
+            dotnetRoot: dotnetRoot,
+            isWindows: true,
+            isMacOS: false,
+            directoryExists: _ => true,
+            getDirectories: _ => new[] { preview, stable },
+            fileExists: _ => true);
+
+        Assert.AreEqual(expectedPath, result);
+    }
+
     [TestMethod]
     public void ResolveHostfxrPath_OrdersPrereleaseSegmentsNumerically()
     {
@@ -262,6 +282,47 @@ public void ResolveHostfxrPath_OrdersPrereleaseSegmentsNumerically()
         Assert.AreEqual(expectedPath, result);
     }
 
+    [TestMethod]
+    public void ResolveHostfxrPath_OrdersPrereleaseIdentifiersUsingAscii()
+    {
+        string dotnetRoot = BuildPath(true, "dotnet");
+        string fxrDir = Path.Combine(dotnetRoot, "host", "fxr");
+        string upper = Path.Combine(fxrDir, "10.0.0-preview.A");
+        string lower = Path.Combine(fxrDir, "10.0.0-preview.a");
+        string expectedPath = Path.Combine(lower, "hostfxr.dll");
+
+        string result = DotnetRootResolver.ResolveHostfxrPath(
+            dotnetRoot: dotnetRoot,
+            isWindows: true,
+            isMacOS: false,
+            directoryExists: _ => true,
+            getDirectories: _ => new[] { upper, lower },
+            fileExists: _ => true);
+
+        Assert.AreEqual(expectedPath, result);
+    }
+
+    [TestMethod]
+    public void ResolveHostfxrPath_SkipsInvalidSemanticVersions()
+    {
+        string dotnetRoot = BuildPath(true, "dotnet");
+        string fxrDir = Path.Combine(dotnetRoot, "host", "fxr");
+        string twoPartVersion = Path.Combine(fxrDir, "99.0");
+        string leadingZero = Path.Combine(fxrDir, "98.0.0-preview.01");
+        string valid = Path.Combine(fxrDir, "10.0.0");
+        string expectedPath = Path.Combine(valid, "hostfxr.dll");
+
+        string result = DotnetRootResolver.ResolveHostfxrPath(
+            dotnetRoot: dotnetRoot,
+            isWindows: true,
+            isMacOS: false,
+            directoryExists: _ => true,
+            getDirectories: _ => new[] { twoPartVersion, leadingZero, valid },
+            fileExists: _ => true);
+
+        Assert.AreEqual(expectedPath, result);
+    }
+
     [TestMethod]
     public void ResolveHostfxrPath_MissingFxrDirectory_ReturnsEmpty()
     {

From c38bdd34679780e719730f9be46c17013917f844 Mon Sep 17 00:00:00 2001
From: Matt Thalman <mthalman@microsoft.com>
Date: Wed, 15 Jul 2026 13:38:57 -0500
Subject: [PATCH 4/4] Use NuGet SemanticVersion for hostfxr selection

Replace the custom hostfxr version parser with NuGet's strict SemanticVersion implementation. Keep the fallback and dependency on modern .NET targets because the net472 resolver does not execute this code path.

Co-authored-by: Copilot App <223556219+Copilot@users.noreply.github.com>

Copilot-Session: d75dbb68-3527-49b4-9af6-d64469b45708
---
 src/Cli/dn/dn.csproj                          |   4 +
 src/Common/HostFxrPathResolver.cs             | 192 +-----------------
 ...Microsoft.DotNet.MSBuildSdkResolver.csproj |   1 -
 .../HostFxrLocator.cs                         |   4 +-
 .../Microsoft.DotNet.NativeWrapper.csproj     |   3 +-
 .../DotnetRootResolverTests.cs                |  20 --
 6 files changed, 11 insertions(+), 213 deletions(-)

diff --git a/src/Cli/dn/dn.csproj b/src/Cli/dn/dn.csproj
index c282de376b49..c1134d561c6d 100644
--- a/src/Cli/dn/dn.csproj
+++ b/src/Cli/dn/dn.csproj
@@ -22,6 +22,10 @@
     </PackageReference>
   </ItemGroup>
 
+  <ItemGroup>
+    <PackageReference Include="NuGet.Versioning" />
+  </ItemGroup>
+
   <ItemGroup>
     <Compile Include="$(RepoRoot)src\Common\HostFxrPathResolver.cs" LinkBase="Common" />
   </ItemGroup>
diff --git a/src/Common/HostFxrPathResolver.cs b/src/Common/HostFxrPathResolver.cs
index e00316d657d5..f4cbe5e084ad 100644
--- a/src/Common/HostFxrPathResolver.cs
+++ b/src/Common/HostFxrPathResolver.cs
@@ -1,6 +1,8 @@
 // Licensed to the .NET Foundation under one or more agreements.
 // The .NET Foundation licenses this file to you under the MIT license.
 
+using NuGet.Versioning;
+
 namespace Microsoft.DotNet.HostFxr;
 
 /// <summary>
@@ -49,7 +51,7 @@ internal static string ResolveHostFxrPath(
         string? latestFxr = getDirectories(fxrDir)
             .Select(path =>
             {
-                HostFxrVersion.TryParse(Path.GetFileName(path), out HostFxrVersion? version);
+                SemanticVersion.TryParse(Path.GetFileName(path), out SemanticVersion? version);
                 return new
                 {
                     Path = path,
@@ -75,192 +77,4 @@ internal static string ResolveHostFxrPath(
         string hostfxrPath = Path.Combine(latestFxr, hostfxrName);
         return fileExists(hostfxrPath) ? hostfxrPath : string.Empty;
     }
-
-    // Mirrors the SemVer parsing and precedence used by the native host's
-    // c_fx_ver_parse and c_fx_ver_compare functions.
-    private sealed class HostFxrVersion : IComparable<HostFxrVersion>
-    {
-        private readonly uint _major;
-        private readonly uint _minor;
-        private readonly uint _patch;
-        private readonly string[] _prereleaseIdentifiers;
-
-        private HostFxrVersion(uint major, uint minor, uint patch, string[] prereleaseIdentifiers)
-        {
-            _major = major;
-            _minor = minor;
-            _patch = patch;
-            _prereleaseIdentifiers = prereleaseIdentifiers;
-        }
-
-        public int CompareTo(HostFxrVersion? other)
-        {
-            if (other is null)
-            {
-                return 1;
-            }
-
-            int comparison = _major.CompareTo(other._major);
-            if (comparison != 0)
-            {
-                return comparison;
-            }
-
-            comparison = _minor.CompareTo(other._minor);
-            if (comparison != 0)
-            {
-                return comparison;
-            }
-
-            comparison = _patch.CompareTo(other._patch);
-            if (comparison != 0)
-            {
-                return comparison;
-            }
-
-            bool isPrerelease = _prereleaseIdentifiers.Length > 0;
-            bool otherIsPrerelease = other._prereleaseIdentifiers.Length > 0;
-            if (isPrerelease != otherIsPrerelease)
-            {
-                return isPrerelease ? -1 : 1;
-            }
-
-            int identifierCount = Math.Min(_prereleaseIdentifiers.Length, other._prereleaseIdentifiers.Length);
-            for (int i = 0; i < identifierCount; i++)
-            {
-                comparison = ComparePrereleaseIdentifiers(
-                    _prereleaseIdentifiers[i],
-                    other._prereleaseIdentifiers[i]);
-                if (comparison != 0)
-                {
-                    return comparison;
-                }
-            }
-
-            return _prereleaseIdentifiers.Length.CompareTo(other._prereleaseIdentifiers.Length);
-        }
-
-        internal static bool TryParse(string value, out HostFxrVersion? version)
-        {
-            version = null;
-
-            int buildSeparator = value.IndexOf('+');
-            if (buildSeparator >= 0)
-            {
-                if (!AreValidIdentifiers(value.Substring(buildSeparator + 1), allowLeadingZeros: true))
-                {
-                    return false;
-                }
-
-                value = value.Substring(0, buildSeparator);
-            }
-
-            string[] prereleaseIdentifiers = Array.Empty<string>();
-            int prereleaseSeparator = value.IndexOf('-');
-            if (prereleaseSeparator >= 0)
-            {
-                string prerelease = value.Substring(prereleaseSeparator + 1);
-                if (!AreValidIdentifiers(prerelease, allowLeadingZeros: false))
-                {
-                    return false;
-                }
-
-                prereleaseIdentifiers = prerelease.Split('.');
-                value = value.Substring(0, prereleaseSeparator);
-            }
-
-            string[] coreIdentifiers = value.Split('.');
-            if (coreIdentifiers.Length != 3
-                || !TryParseCoreIdentifier(coreIdentifiers[0], out uint major)
-                || !TryParseCoreIdentifier(coreIdentifiers[1], out uint minor)
-                || !TryParseCoreIdentifier(coreIdentifiers[2], out uint patch))
-            {
-                return false;
-            }
-
-            version = new HostFxrVersion(major, minor, patch, prereleaseIdentifiers);
-            return true;
-        }
-
-        private static bool TryParseCoreIdentifier(string value, out uint result)
-        {
-            result = 0;
-            return IsNumericIdentifier(value)
-                && (value.Length == 1 || value[0] != '0')
-                && uint.TryParse(value, out result);
-        }
-
-        private static bool AreValidIdentifiers(string value, bool allowLeadingZeros)
-        {
-            string[] identifiers = value.Split('.');
-            foreach (string identifier in identifiers)
-            {
-                if (identifier.Length == 0)
-                {
-                    return false;
-                }
-
-                bool isNumeric = true;
-                foreach (char character in identifier)
-                {
-                    if (!IsValidIdentifierCharacter(character))
-                    {
-                        return false;
-                    }
-
-                    isNumeric &= character is >= '0' and <= '9';
-                }
-
-                if (!allowLeadingZeros && isNumeric && identifier.Length > 1 && identifier[0] == '0')
-                {
-                    return false;
-                }
-            }
-
-            return true;
-        }
-
-        private static bool IsValidIdentifierCharacter(char character) =>
-            character is >= '0' and <= '9'
-                or >= 'A' and <= 'Z'
-                or >= 'a' and <= 'z'
-                or '-';
-
-        private static bool IsNumericIdentifier(string value)
-        {
-            if (value.Length == 0)
-            {
-                return false;
-            }
-
-            foreach (char character in value)
-            {
-                if (character is < '0' or > '9')
-                {
-                    return false;
-                }
-            }
-
-            return true;
-        }
-
-        private static int ComparePrereleaseIdentifiers(string left, string right)
-        {
-            bool leftIsNumeric = IsNumericIdentifier(left);
-            bool rightIsNumeric = IsNumericIdentifier(right);
-
-            if (leftIsNumeric && rightIsNumeric)
-            {
-                int comparison = left.Length.CompareTo(right.Length);
-                return comparison != 0 ? comparison : string.CompareOrdinal(left, right);
-            }
-
-            if (leftIsNumeric != rightIsNumeric)
-            {
-                return leftIsNumeric ? -1 : 1;
-            }
-
-            return string.CompareOrdinal(left, right);
-        }
-    }
 }
diff --git a/src/Resolvers/Microsoft.DotNet.MSBuildSdkResolver/Microsoft.DotNet.MSBuildSdkResolver.csproj b/src/Resolvers/Microsoft.DotNet.MSBuildSdkResolver/Microsoft.DotNet.MSBuildSdkResolver.csproj
index e2cf2a3e87c6..38f8cdcd467b 100644
--- a/src/Resolvers/Microsoft.DotNet.MSBuildSdkResolver/Microsoft.DotNet.MSBuildSdkResolver.csproj
+++ b/src/Resolvers/Microsoft.DotNet.MSBuildSdkResolver/Microsoft.DotNet.MSBuildSdkResolver.csproj
@@ -67,7 +67,6 @@
 
     <Compile Include="$(RepoRoot)src\Common\EnvironmentVariableNames.cs" LinkBase="Common" />
     <Compile Include="$(RepoRoot)src\Common\CliFolderPathCalculatorCore.cs" LinkBase="Common" />
-    <Compile Include="$(RepoRoot)src\Common\HostFxrPathResolver.cs" LinkBase="Common" />
     <Compile Include="$(RepoRoot)src\Common\Polyfills.cs" LinkBase="Common" />
     <Compile Include="$(RepoRoot)src\Common\WorkloadFileBasedInstall.cs" LinkBase="Common" />
     <Compile Include="$(RepoRoot)src\Common\WorkloadSetVersion.cs" LinkBase="Common" />
diff --git a/src/Resolvers/Microsoft.DotNet.NativeWrapper/HostFxrLocator.cs b/src/Resolvers/Microsoft.DotNet.NativeWrapper/HostFxrLocator.cs
index 3c47a3ca7cb0..3a4c28b0443b 100644
--- a/src/Resolvers/Microsoft.DotNet.NativeWrapper/HostFxrLocator.cs
+++ b/src/Resolvers/Microsoft.DotNet.NativeWrapper/HostFxrLocator.cs
@@ -1,6 +1,7 @@
 // Licensed to the .NET Foundation under one or more agreements.
 // The .NET Foundation licenses this file to you under the MIT license.
 
+#if NET
 using Microsoft.DotNet.HostFxr;
 
 namespace Microsoft.DotNet.NativeWrapper
@@ -33,7 +34,6 @@ internal static string ResolveHostFxrPath(
                 getDirectories,
                 fileExists);
 
-#if NET
         /// <summary>
         ///  Resolves the <c>hostfxr</c> path against the live filesystem, deriving the .NET
         ///  installation root from the current process (the running <c>dotnet</c> host).
@@ -46,6 +46,6 @@ internal static string ResolveHostFxrPath()
                 directoryExists: Directory.Exists,
                 getDirectories: Directory.GetDirectories,
                 fileExists: File.Exists);
-#endif
     }
 }
+#endif
diff --git a/src/Resolvers/Microsoft.DotNet.NativeWrapper/Microsoft.DotNet.NativeWrapper.csproj b/src/Resolvers/Microsoft.DotNet.NativeWrapper/Microsoft.DotNet.NativeWrapper.csproj
index bb420c294e9f..7328fed5ab40 100644
--- a/src/Resolvers/Microsoft.DotNet.NativeWrapper/Microsoft.DotNet.NativeWrapper.csproj
+++ b/src/Resolvers/Microsoft.DotNet.NativeWrapper/Microsoft.DotNet.NativeWrapper.csproj
@@ -15,10 +15,11 @@
 
   <ItemGroup>
     <PackageReference Include="Microsoft.Deployment.DotNet.Releases" />
+    <PackageReference Include="NuGet.Versioning" Condition="'$(TargetFramework)' != 'net472'" />
   </ItemGroup>
 
   <ItemGroup>
-    <Compile Include="$(RepoRoot)src\Common\HostFxrPathResolver.cs" LinkBase="Common" />
+    <Compile Include="$(RepoRoot)src\Common\HostFxrPathResolver.cs" LinkBase="Common" Condition="'$(TargetFramework)' != 'net472'" />
   </ItemGroup>
 
   <ItemGroup>
diff --git a/test/dotnet-aot.Tests/DotnetRootResolverTests.cs b/test/dotnet-aot.Tests/DotnetRootResolverTests.cs
index 84f127137309..6cce9d2aac99 100644
--- a/test/dotnet-aot.Tests/DotnetRootResolverTests.cs
+++ b/test/dotnet-aot.Tests/DotnetRootResolverTests.cs
@@ -282,26 +282,6 @@ public void ResolveHostfxrPath_OrdersPrereleaseSegmentsNumerically()
         Assert.AreEqual(expectedPath, result);
     }
 
-    [TestMethod]
-    public void ResolveHostfxrPath_OrdersPrereleaseIdentifiersUsingAscii()
-    {
-        string dotnetRoot = BuildPath(true, "dotnet");
-        string fxrDir = Path.Combine(dotnetRoot, "host", "fxr");
-        string upper = Path.Combine(fxrDir, "10.0.0-preview.A");
-        string lower = Path.Combine(fxrDir, "10.0.0-preview.a");
-        string expectedPath = Path.Combine(lower, "hostfxr.dll");
-
-        string result = DotnetRootResolver.ResolveHostfxrPath(
-            dotnetRoot: dotnetRoot,
-            isWindows: true,
-            isMacOS: false,
-            directoryExists: _ => true,
-            getDirectories: _ => new[] { upper, lower },
-            fileExists: _ => true);
-
-        Assert.AreEqual(expectedPath, result);
-    }
-
     [TestMethod]
     public void ResolveHostfxrPath_SkipsInvalidSemanticVersions()
     {