up

src/__Libraries/StellaOps.Plugin/Hosting/PluginAssembly.cs

@@ -1,21 +1,21 @@
-using System.Reflection;
-
-namespace StellaOps.Plugin.Hosting;
-
-public sealed class PluginAssembly
-{
-    internal PluginAssembly(string assemblyPath, Assembly assembly, PluginLoadContext loadContext)
-    {
-        AssemblyPath = assemblyPath;
-        Assembly = assembly;
-        LoadContext = loadContext;
-    }
-
-    public string AssemblyPath { get; }
-
-    public Assembly Assembly { get; }
-
-    internal PluginLoadContext LoadContext { get; }
-
-    public override string ToString() => Assembly.FullName ?? AssemblyPath;
+using System.Reflection;
+
+namespace StellaOps.Plugin.Hosting;
+
+public sealed class PluginAssembly
+{
+    internal PluginAssembly(string assemblyPath, Assembly assembly, PluginLoadContext loadContext)
+    {
+        AssemblyPath = assemblyPath;
+        Assembly = assembly;
+        LoadContext = loadContext;
+    }
+
+    public string AssemblyPath { get; }
+
+    public Assembly Assembly { get; }
+
+    internal PluginLoadContext LoadContext { get; }
+
+    public override string ToString() => Assembly.FullName ?? AssemblyPath;
 }

src/__Libraries/StellaOps.Plugin/Hosting/PluginHost.cs

@@ -1,76 +1,76 @@
-using Microsoft.Extensions.Logging;
-using System;
-using System.Collections.Generic;
-using System.Collections.ObjectModel;
-using System.IO;
-using System.Linq;
-
-namespace StellaOps.Plugin.Hosting;
-
-public static class PluginHost
-{
-    private static readonly object Sync = new();
-    private static readonly Dictionary<string, PluginAssembly> LoadedPlugins = new(StringComparer.OrdinalIgnoreCase);
-
-    public static PluginHostResult LoadPlugins(PluginHostOptions options, ILogger? logger = null)
-    {
-        if (options == null)
-        {
-            throw new ArgumentNullException(nameof(options));
-        }
-
-        var baseDirectory = options.ResolveBaseDirectory();
-        var pluginDirectory = ResolvePluginDirectory(options, baseDirectory);
-
-        if (options.EnsureDirectoryExists && !Directory.Exists(pluginDirectory))
-        {
-            Directory.CreateDirectory(pluginDirectory);
-        }
-
-        if (!Directory.Exists(pluginDirectory))
-        {
-            logger?.LogWarning("Plugin directory '{PluginDirectory}' does not exist; no plugins will be loaded.", pluginDirectory);
-            return new PluginHostResult(pluginDirectory, Array.Empty<string>(), Array.Empty<PluginAssembly>(), Array.Empty<string>());
-        }
-
-        var searchPatterns = BuildSearchPatterns(options, pluginDirectory);
-        var discovered = DiscoverPluginFiles(pluginDirectory, searchPatterns, options.RecursiveSearch, logger);
-        var orderedFiles = ApplyExplicitOrdering(discovered, options.PluginOrder, out var missingOrderedNames);
-
-        var loaded = new List<PluginAssembly>(orderedFiles.Count);
-
-        lock (Sync)
-        {
-            foreach (var file in orderedFiles)
-            {
-                if (LoadedPlugins.TryGetValue(file, out var existing))
-                {
-                    loaded.Add(existing);
-                    continue;
-                }
-
-                try
-                {
-                    var loadContext = new PluginLoadContext(file);
-                    var assembly = loadContext.LoadFromAssemblyPath(file);
-                    var descriptor = new PluginAssembly(file, assembly, loadContext);
-                    LoadedPlugins[file] = descriptor;
-                    loaded.Add(descriptor);
-                    logger?.LogInformation("Loaded plugin assembly '{Assembly}' from '{Path}'.", assembly.FullName, file);
-                }
-                catch (Exception ex)
-                {
-                    logger?.LogError(ex, "Failed to load plugin assembly from '{Path}'.", file);
-                }
-            }
-        }
-
-        var missingOrdered = new ReadOnlyCollection<string>(missingOrderedNames);
-        return new PluginHostResult(pluginDirectory, searchPatterns, new ReadOnlyCollection<PluginAssembly>(loaded), missingOrdered);
-    }
-
-    private static string ResolvePluginDirectory(PluginHostOptions options, string baseDirectory)
-    {
+using Microsoft.Extensions.Logging;
+using System;
+using System.Collections.Generic;
+using System.Collections.ObjectModel;
+using System.IO;
+using System.Linq;
+
+namespace StellaOps.Plugin.Hosting;
+
+public static class PluginHost
+{
+    private static readonly object Sync = new();
+    private static readonly Dictionary<string, PluginAssembly> LoadedPlugins = new(StringComparer.OrdinalIgnoreCase);
+
+    public static PluginHostResult LoadPlugins(PluginHostOptions options, ILogger? logger = null)
+    {
+        if (options == null)
+        {
+            throw new ArgumentNullException(nameof(options));
+        }
+
+        var baseDirectory = options.ResolveBaseDirectory();
+        var pluginDirectory = ResolvePluginDirectory(options, baseDirectory);
+
+        if (options.EnsureDirectoryExists && !Directory.Exists(pluginDirectory))
+        {
+            Directory.CreateDirectory(pluginDirectory);
+        }
+
+        if (!Directory.Exists(pluginDirectory))
+        {
+            logger?.LogWarning("Plugin directory '{PluginDirectory}' does not exist; no plugins will be loaded.", pluginDirectory);
+            return new PluginHostResult(pluginDirectory, Array.Empty<string>(), Array.Empty<PluginAssembly>(), Array.Empty<string>());
+        }
+
+        var searchPatterns = BuildSearchPatterns(options, pluginDirectory);
+        var discovered = DiscoverPluginFiles(pluginDirectory, searchPatterns, options.RecursiveSearch, logger);
+        var orderedFiles = ApplyExplicitOrdering(discovered, options.PluginOrder, out var missingOrderedNames);
+
+        var loaded = new List<PluginAssembly>(orderedFiles.Count);
+
+        lock (Sync)
+        {
+            foreach (var file in orderedFiles)
+            {
+                if (LoadedPlugins.TryGetValue(file, out var existing))
+                {
+                    loaded.Add(existing);
+                    continue;
+                }
+
+                try
+                {
+                    var loadContext = new PluginLoadContext(file);
+                    var assembly = loadContext.LoadFromAssemblyPath(file);
+                    var descriptor = new PluginAssembly(file, assembly, loadContext);
+                    LoadedPlugins[file] = descriptor;
+                    loaded.Add(descriptor);
+                    logger?.LogInformation("Loaded plugin assembly '{Assembly}' from '{Path}'.", assembly.FullName, file);
+                }
+                catch (Exception ex)
+                {
+                    logger?.LogError(ex, "Failed to load plugin assembly from '{Path}'.", file);
+                }
+            }
+        }
+
+        var missingOrdered = new ReadOnlyCollection<string>(missingOrderedNames);
+        return new PluginHostResult(pluginDirectory, searchPatterns, new ReadOnlyCollection<PluginAssembly>(loaded), missingOrdered);
+    }
+
+    private static string ResolvePluginDirectory(PluginHostOptions options, string baseDirectory)
+    {
         if (string.IsNullOrWhiteSpace(options.PluginsDirectory))
         {
             var defaultDirectory = !string.IsNullOrWhiteSpace(options.PrimaryPrefix)
@@ -78,142 +78,142 @@ public static class PluginHost
                 : "PluginBinaries";
             return Path.Combine(baseDirectory, defaultDirectory);
         }
-
-        if (Path.IsPathRooted(options.PluginsDirectory))
-        {
-            return options.PluginsDirectory;
-        }
-
-        return Path.Combine(baseDirectory, options.PluginsDirectory);
-    }
-
-    private static IReadOnlyList<string> BuildSearchPatterns(PluginHostOptions options, string pluginDirectory)
-    {
-        var patterns = new List<string>();
-        if (options.SearchPatterns.Count > 0)
-        {
-            patterns.AddRange(options.SearchPatterns);
-        }
-        else
-        {
-            var prefixes = new List<string>();
-            if (!string.IsNullOrWhiteSpace(options.PrimaryPrefix))
-            {
-                prefixes.Add(options.PrimaryPrefix);
-            }
-            else if (System.Reflection.Assembly.GetEntryAssembly()?.GetName().Name is { } entryName)
-            {
-                prefixes.Add(entryName);
-            }
-
-            prefixes.AddRange(options.AdditionalPrefixes);
-
-            if (prefixes.Count == 0)
-            {
-                // Fallback to directory name
-                prefixes.Add(Path.GetFileName(pluginDirectory));
-            }
-
-            foreach (var prefix in prefixes.Where(p => !string.IsNullOrWhiteSpace(p)))
-            {
-                patterns.Add($"{prefix}.Plugin.*.dll");
-            }
-        }
-
-        return new ReadOnlyCollection<string>(patterns.Distinct(StringComparer.OrdinalIgnoreCase).ToList());
-    }
-
-    private static List<string> DiscoverPluginFiles(
-        string pluginDirectory,
-        IReadOnlyList<string> searchPatterns,
-        bool recurse,
-        ILogger? logger)
-    {
-        var files = new List<string>();
-        var seen = new HashSet<string>(StringComparer.OrdinalIgnoreCase);
-        var searchOption = recurse ? SearchOption.AllDirectories : SearchOption.TopDirectoryOnly;
-
-        foreach (var pattern in searchPatterns)
-        {
-            try
-            {
-                foreach (var file in Directory.EnumerateFiles(pluginDirectory, pattern, searchOption))
-                {
-                    if (IsHiddenPath(file))
-                    {
-                        continue;
-                    }
-
-                    if (seen.Add(file))
-                    {
-                        files.Add(file);
-                    }
-                }
-            }
-            catch (DirectoryNotFoundException)
-            {
-                // Directory could be removed between the existence check and enumeration.
-                logger?.LogDebug("Plugin directory '{PluginDirectory}' disappeared before enumeration.", pluginDirectory);
-            }
-        }
-
-        return files;
-    }
-
-    private static List<string> ApplyExplicitOrdering(
-        List<string> discoveredFiles,
-        IList<string> pluginOrder,
-        out List<string> missingNames)
-    {
-        if (pluginOrder.Count == 0 || discoveredFiles.Count == 0)
-        {
-            missingNames = new List<string>();
-            discoveredFiles.Sort(StringComparer.OrdinalIgnoreCase);
-            return discoveredFiles;
-        }
-
-        var configuredSet = new HashSet<string>(pluginOrder, StringComparer.OrdinalIgnoreCase);
-        var fileLookup = discoveredFiles.ToDictionary(
-            k => Path.GetFileNameWithoutExtension(k),
-            StringComparer.OrdinalIgnoreCase);
-
-        var specified = new List<string>();
-        foreach (var name in pluginOrder)
-        {
-            if (fileLookup.TryGetValue(name, out var file))
-            {
-                specified.Add(file);
-            }
-        }
-
-        var unspecified = discoveredFiles
-            .Where(f => !configuredSet.Contains(Path.GetFileNameWithoutExtension(f)))
-            .OrderBy(f => f, StringComparer.OrdinalIgnoreCase)
-            .ToList();
-
-        missingNames = pluginOrder
-            .Where(name => !fileLookup.ContainsKey(name))
-            .Distinct(StringComparer.OrdinalIgnoreCase)
-            .ToList();
-
-        specified.AddRange(unspecified);
-        return specified;
-    }
-
-    private static bool IsHiddenPath(string filePath)
-    {
-        var directory = Path.GetDirectoryName(filePath);
-        while (!string.IsNullOrEmpty(directory))
-        {
-            var name = Path.GetFileName(directory);
-            if (name.StartsWith(".", StringComparison.Ordinal))
-            {
-                return true;
-            }
-
-            directory = Path.GetDirectoryName(directory);
-        }
-
-        return false;
-    }
+
+        if (Path.IsPathRooted(options.PluginsDirectory))
+        {
+            return options.PluginsDirectory;
+        }
+
+        return Path.Combine(baseDirectory, options.PluginsDirectory);
+    }
+
+    private static IReadOnlyList<string> BuildSearchPatterns(PluginHostOptions options, string pluginDirectory)
+    {
+        var patterns = new List<string>();
+        if (options.SearchPatterns.Count > 0)
+        {
+            patterns.AddRange(options.SearchPatterns);
+        }
+        else
+        {
+            var prefixes = new List<string>();
+            if (!string.IsNullOrWhiteSpace(options.PrimaryPrefix))
+            {
+                prefixes.Add(options.PrimaryPrefix);
+            }
+            else if (System.Reflection.Assembly.GetEntryAssembly()?.GetName().Name is { } entryName)
+            {
+                prefixes.Add(entryName);
+            }
+
+            prefixes.AddRange(options.AdditionalPrefixes);
+
+            if (prefixes.Count == 0)
+            {
+                // Fallback to directory name
+                prefixes.Add(Path.GetFileName(pluginDirectory));
+            }
+
+            foreach (var prefix in prefixes.Where(p => !string.IsNullOrWhiteSpace(p)))
+            {
+                patterns.Add($"{prefix}.Plugin.*.dll");
+            }
+        }
+
+        return new ReadOnlyCollection<string>(patterns.Distinct(StringComparer.OrdinalIgnoreCase).ToList());
+    }
+
+    private static List<string> DiscoverPluginFiles(
+        string pluginDirectory,
+        IReadOnlyList<string> searchPatterns,
+        bool recurse,
+        ILogger? logger)
+    {
+        var files = new List<string>();
+        var seen = new HashSet<string>(StringComparer.OrdinalIgnoreCase);
+        var searchOption = recurse ? SearchOption.AllDirectories : SearchOption.TopDirectoryOnly;
+
+        foreach (var pattern in searchPatterns)
+        {
+            try
+            {
+                foreach (var file in Directory.EnumerateFiles(pluginDirectory, pattern, searchOption))
+                {
+                    if (IsHiddenPath(file))
+                    {
+                        continue;
+                    }
+
+                    if (seen.Add(file))
+                    {
+                        files.Add(file);
+                    }
+                }
+            }
+            catch (DirectoryNotFoundException)
+            {
+                // Directory could be removed between the existence check and enumeration.
+                logger?.LogDebug("Plugin directory '{PluginDirectory}' disappeared before enumeration.", pluginDirectory);
+            }
+        }
+
+        return files;
+    }
+
+    private static List<string> ApplyExplicitOrdering(
+        List<string> discoveredFiles,
+        IList<string> pluginOrder,
+        out List<string> missingNames)
+    {
+        if (pluginOrder.Count == 0 || discoveredFiles.Count == 0)
+        {
+            missingNames = new List<string>();
+            discoveredFiles.Sort(StringComparer.OrdinalIgnoreCase);
+            return discoveredFiles;
+        }
+
+        var configuredSet = new HashSet<string>(pluginOrder, StringComparer.OrdinalIgnoreCase);
+        var fileLookup = discoveredFiles.ToDictionary(
+            k => Path.GetFileNameWithoutExtension(k),
+            StringComparer.OrdinalIgnoreCase);
+
+        var specified = new List<string>();
+        foreach (var name in pluginOrder)
+        {
+            if (fileLookup.TryGetValue(name, out var file))
+            {
+                specified.Add(file);
+            }
+        }
+
+        var unspecified = discoveredFiles
+            .Where(f => !configuredSet.Contains(Path.GetFileNameWithoutExtension(f)))
+            .OrderBy(f => f, StringComparer.OrdinalIgnoreCase)
+            .ToList();
+
+        missingNames = pluginOrder
+            .Where(name => !fileLookup.ContainsKey(name))
+            .Distinct(StringComparer.OrdinalIgnoreCase)
+            .ToList();
+
+        specified.AddRange(unspecified);
+        return specified;
+    }
+
+    private static bool IsHiddenPath(string filePath)
+    {
+        var directory = Path.GetDirectoryName(filePath);
+        while (!string.IsNullOrEmpty(directory))
+        {
+            var name = Path.GetFileName(directory);
+            if (name.StartsWith(".", StringComparison.Ordinal))
+            {
+                return true;
+            }
+
+            directory = Path.GetDirectoryName(directory);
+        }
+
+        return false;
+    }
 }

src/__Libraries/StellaOps.Plugin/Hosting/PluginHostOptions.cs

@@ -1,59 +1,59 @@
-using System;
-using System.Collections.Generic;
-using System.IO;
-
-namespace StellaOps.Plugin.Hosting;
-
-public sealed class PluginHostOptions
-{
-    private readonly List<string> additionalPrefixes = new();
-    private readonly List<string> pluginOrder = new();
-    private readonly List<string> searchPatterns = new();
-
-    /// <summary>
-    /// Optional base directory used for resolving relative plugin paths. Defaults to <see cref="AppContext.BaseDirectory" />.
-    /// </summary>
-    public string? BaseDirectory { get; set; }
-
-    /// <summary>
+using System;
+using System.Collections.Generic;
+using System.IO;
+
+namespace StellaOps.Plugin.Hosting;
+
+public sealed class PluginHostOptions
+{
+    private readonly List<string> additionalPrefixes = new();
+    private readonly List<string> pluginOrder = new();
+    private readonly List<string> searchPatterns = new();
+
+    /// <summary>
+    /// Optional base directory used for resolving relative plugin paths. Defaults to <see cref="AppContext.BaseDirectory" />.
+    /// </summary>
+    public string? BaseDirectory { get; set; }
+
+    /// <summary>
     /// Directory that contains plugin assemblies. Relative values are resolved against <see cref="BaseDirectory" />.
     /// Defaults to <c>{PrimaryPrefix}.PluginBinaries</c> when a primary prefix is provided, otherwise <c>PluginBinaries</c>.
-    /// </summary>
-    public string? PluginsDirectory { get; set; }
-
-    /// <summary>
-    /// Primary prefix used to discover plugin assemblies. If not supplied, the entry assembly name is used.
-    /// </summary>
-    public string? PrimaryPrefix { get; set; }
-
-    /// <summary>
-    /// Additional prefixes that should be considered when building search patterns.
-    /// </summary>
-    public IList<string> AdditionalPrefixes => additionalPrefixes;
-
-    /// <summary>
-    /// Explicit plugin ordering expressed as assembly names without extension.
-    /// Entries that are not discovered will be reported in <see cref="PluginHostResult.MissingOrderedPlugins" />.
-    /// </summary>
-    public IList<string> PluginOrder => pluginOrder;
-
-    /// <summary>
-    /// Optional explicit search patterns. When empty, they are derived from prefix settings.
-    /// </summary>
-    public IList<string> SearchPatterns => searchPatterns;
-
-    /// <summary>
-    /// When true (default) the plugin directory will be created if it does not exist.
-    /// </summary>
-    public bool EnsureDirectoryExists { get; set; } = true;
-
-    /// <summary>
-    /// Controls whether sub-directories should be scanned. Defaults to true.
-    /// </summary>
-    public bool RecursiveSearch { get; set; } = true;
-
-    internal string ResolveBaseDirectory()
-        => string.IsNullOrWhiteSpace(BaseDirectory)
-            ? AppContext.BaseDirectory
-            : Path.GetFullPath(BaseDirectory);
+    /// </summary>
+    public string? PluginsDirectory { get; set; }
+
+    /// <summary>
+    /// Primary prefix used to discover plugin assemblies. If not supplied, the entry assembly name is used.
+    /// </summary>
+    public string? PrimaryPrefix { get; set; }
+
+    /// <summary>
+    /// Additional prefixes that should be considered when building search patterns.
+    /// </summary>
+    public IList<string> AdditionalPrefixes => additionalPrefixes;
+
+    /// <summary>
+    /// Explicit plugin ordering expressed as assembly names without extension.
+    /// Entries that are not discovered will be reported in <see cref="PluginHostResult.MissingOrderedPlugins" />.
+    /// </summary>
+    public IList<string> PluginOrder => pluginOrder;
+
+    /// <summary>
+    /// Optional explicit search patterns. When empty, they are derived from prefix settings.
+    /// </summary>
+    public IList<string> SearchPatterns => searchPatterns;
+
+    /// <summary>
+    /// When true (default) the plugin directory will be created if it does not exist.
+    /// </summary>
+    public bool EnsureDirectoryExists { get; set; } = true;
+
+    /// <summary>
+    /// Controls whether sub-directories should be scanned. Defaults to true.
+    /// </summary>
+    public bool RecursiveSearch { get; set; } = true;
+
+    internal string ResolveBaseDirectory()
+        => string.IsNullOrWhiteSpace(BaseDirectory)
+            ? AppContext.BaseDirectory
+            : Path.GetFullPath(BaseDirectory);
 }

src/__Libraries/StellaOps.Plugin/Hosting/PluginHostResult.cs

@@ -1,26 +1,26 @@
-using System.Collections.Generic;
-
-namespace StellaOps.Plugin.Hosting;
-
-public sealed class PluginHostResult
-{
-    internal PluginHostResult(
-        string pluginDirectory,
-        IReadOnlyList<string> searchPatterns,
-        IReadOnlyList<PluginAssembly> plugins,
-        IReadOnlyList<string> missingOrderedPlugins)
-    {
-        PluginDirectory = pluginDirectory;
-        SearchPatterns = searchPatterns;
-        Plugins = plugins;
-        MissingOrderedPlugins = missingOrderedPlugins;
-    }
-
-    public string PluginDirectory { get; }
-
-    public IReadOnlyList<string> SearchPatterns { get; }
-
-    public IReadOnlyList<PluginAssembly> Plugins { get; }
-
-    public IReadOnlyList<string> MissingOrderedPlugins { get; }
+using System.Collections.Generic;
+
+namespace StellaOps.Plugin.Hosting;
+
+public sealed class PluginHostResult
+{
+    internal PluginHostResult(
+        string pluginDirectory,
+        IReadOnlyList<string> searchPatterns,
+        IReadOnlyList<PluginAssembly> plugins,
+        IReadOnlyList<string> missingOrderedPlugins)
+    {
+        PluginDirectory = pluginDirectory;
+        SearchPatterns = searchPatterns;
+        Plugins = plugins;
+        MissingOrderedPlugins = missingOrderedPlugins;
+    }
+
+    public string PluginDirectory { get; }
+
+    public IReadOnlyList<string> SearchPatterns { get; }
+
+    public IReadOnlyList<PluginAssembly> Plugins { get; }
+
+    public IReadOnlyList<string> MissingOrderedPlugins { get; }
 }

src/__Libraries/StellaOps.Plugin/Hosting/PluginLoadContext.cs

@@ -1,79 +1,79 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Reflection;
-using System.Runtime.Loader;
-
-namespace StellaOps.Plugin.Hosting;
-
-internal sealed class PluginLoadContext : AssemblyLoadContext
-{
-    private readonly AssemblyDependencyResolver resolver;
-    private readonly IEnumerable<Assembly> hostAssemblies;
-
-    public PluginLoadContext(string pluginPath)
-        : base(isCollectible: false)
-    {
-        resolver = new AssemblyDependencyResolver(pluginPath);
-        hostAssemblies = AssemblyLoadContext.Default.Assemblies;
-    }
-
-    protected override Assembly? Load(AssemblyName assemblyName)
-    {
-        // Attempt to reuse assemblies that already exist in the default context when versions are compatible.
-        var existing = hostAssemblies.FirstOrDefault(a => string.Equals(
-            a.GetName().Name,
-            assemblyName.Name,
-            StringComparison.OrdinalIgnoreCase));
-
-        if (existing != null && IsCompatible(existing.GetName(), assemblyName))
-        {
-            return existing;
-        }
-
-        var assemblyPath = resolver.ResolveAssemblyToPath(assemblyName);
-        if (!string.IsNullOrEmpty(assemblyPath))
-        {
-            return LoadFromAssemblyPath(assemblyPath);
-        }
-
-        return null;
-    }
-
-    protected override IntPtr LoadUnmanagedDll(string unmanagedDllName)
-    {
-        var libraryPath = resolver.ResolveUnmanagedDllToPath(unmanagedDllName);
-        if (!string.IsNullOrEmpty(libraryPath))
-        {
-            return LoadUnmanagedDllFromPath(libraryPath);
-        }
-
-        return IntPtr.Zero;
-    }
-
-    private static bool IsCompatible(AssemblyName hostAssembly, AssemblyName pluginAssembly)
-    {
-        if (hostAssembly.Version == pluginAssembly.Version)
-        {
-            return true;
-        }
-
-        if (hostAssembly.Version is null || pluginAssembly.Version is null)
-        {
-            return false;
-        }
-
-        if (hostAssembly.Version.Major == pluginAssembly.Version.Major &&
-            hostAssembly.Version.Minor >= pluginAssembly.Version.Minor)
-        {
-            return true;
-        }
-
-        if (hostAssembly.Version.Major >= pluginAssembly.Version.Major)
-        {
-            return true;
-        }
-
-        return false;
-    }
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Reflection;
+using System.Runtime.Loader;
+
+namespace StellaOps.Plugin.Hosting;
+
+internal sealed class PluginLoadContext : AssemblyLoadContext
+{
+    private readonly AssemblyDependencyResolver resolver;
+    private readonly IEnumerable<Assembly> hostAssemblies;
+
+    public PluginLoadContext(string pluginPath)
+        : base(isCollectible: false)
+    {
+        resolver = new AssemblyDependencyResolver(pluginPath);
+        hostAssemblies = AssemblyLoadContext.Default.Assemblies;
+    }
+
+    protected override Assembly? Load(AssemblyName assemblyName)
+    {
+        // Attempt to reuse assemblies that already exist in the default context when versions are compatible.
+        var existing = hostAssemblies.FirstOrDefault(a => string.Equals(
+            a.GetName().Name,
+            assemblyName.Name,
+            StringComparison.OrdinalIgnoreCase));
+
+        if (existing != null && IsCompatible(existing.GetName(), assemblyName))
+        {
+            return existing;
+        }
+
+        var assemblyPath = resolver.ResolveAssemblyToPath(assemblyName);
+        if (!string.IsNullOrEmpty(assemblyPath))
+        {
+            return LoadFromAssemblyPath(assemblyPath);
+        }
+
+        return null;
+    }
+
+    protected override IntPtr LoadUnmanagedDll(string unmanagedDllName)
+    {
+        var libraryPath = resolver.ResolveUnmanagedDllToPath(unmanagedDllName);
+        if (!string.IsNullOrEmpty(libraryPath))
+        {
+            return LoadUnmanagedDllFromPath(libraryPath);
+        }
+
+        return IntPtr.Zero;
+    }
+
+    private static bool IsCompatible(AssemblyName hostAssembly, AssemblyName pluginAssembly)
+    {
+        if (hostAssembly.Version == pluginAssembly.Version)
+        {
+            return true;
+        }
+
+        if (hostAssembly.Version is null || pluginAssembly.Version is null)
+        {
+            return false;
+        }
+
+        if (hostAssembly.Version.Major == pluginAssembly.Version.Major &&
+            hostAssembly.Version.Minor >= pluginAssembly.Version.Minor)
+        {
+            return true;
+        }
+
+        if (hostAssembly.Version.Major >= pluginAssembly.Version.Major)
+        {
+            return true;
+        }
+
+        return false;
+    }
 }