feat(PyRevit): implement assembly loading for extension DLLs

- Introduced PyRevitAssemblyLoader to load extension DLLs from pyRevit hierarchy.
- Added DllCandidate struct to represent potential DLLs for loading.
- Enhanced PyRevitExtensionPaths to enumerate DLL candidates from the extension hierarchy.
- Updated PyRevitScriptExecutor to ensure assemblies are loaded before script execution.
- Bumped Polyfill package version to 10.7.0.

Author: trgiangv

Directory.Packages.props

@@ -24,7 +24,7 @@
         <PackageVersion Include="System.Diagnostics.DiagnosticSource" Version="10.0.5"/>
         <PackageVersion Include="System.Reflection.MetadataLoadContext" Version="10.0.5"/>
         <PackageVersion Include="JetBrains.Annotations" Version="2025.2.4"/>
-        <GlobalPackageReference Include="Polyfill" Version="10.3.0"/>
+        <GlobalPackageReference Include="Polyfill" Version="10.7.0"/>
         <PackageVersion Include="Microsoft-WindowsAPICodePack-Shell" Version="1.1.5"/>
         <PackageVersion Include="System.Drawing.Common" Version="8.0.25"/>
         <PackageVersion Include="System.Net.Http" Version="4.3.4"/>

source/RevitDevTool/Execution/PyRevit/PyRevitAssemblyLoader.cs

@@ -0,0 +1,231 @@
+using System.Diagnostics;
+using System.IO;
+using System.Reflection;
+using System.Reflection.Metadata;
+using System.Reflection.PortableExecutable;
+using RevitDevTool.Core;
+
+namespace RevitDevTool.Execution.PyRevit;
+
+/// <summary>
+/// Loads extension DLLs from pyRevit hierarchy lib/bin folders into the current AppDomain
+/// so IronPython <c>clr.AddReference</c> can resolve them. Load is once per session, no file lock.
+/// </summary>
+internal static class PyRevitAssemblyLoader
+{
+    private static readonly Lock LoadLock = new();
+    private static readonly HashSet<string> LoadedNames = new(StringComparer.OrdinalIgnoreCase);
+    private static bool _initialized;
+
+    internal static void EnsureLoaded(string scriptPath)
+    {
+        if (_initialized) return;
+
+        lock (LoadLock)
+        {
+            if (_initialized) return;
+
+            var scriptDir = Path.GetDirectoryName(scriptPath);
+            var candidates = PyRevitExtensionPaths.EnumerateDllCandidates(scriptDir).ToList();
+            if (candidates.Count == 0)
+            {
+                _initialized = true;
+                return;
+            }
+
+            GetLoadedAssemblies();
+            var resolved = Resolve(candidates);
+            LoadAll(resolved);
+            _initialized = true;
+        }
+    }
+
+    private static void GetLoadedAssemblies()
+    {
+        foreach (var asm in AppDomain.CurrentDomain.GetAssemblies())
+        {
+            var name = asm.GetName().Name;
+            if (name is not null)
+                LoadedNames.Add(name);
+        }
+    }
+
+    private static List<string> Resolve(List<PyRevitExtensionPaths.DllCandidate> candidates)
+    {
+        var revitYear = RevitContext.Application.VersionNumber;
+
+        var grouped = candidates
+            .GroupBy(c => c.SimpleName, StringComparer.OrdinalIgnoreCase);
+
+        var result = new List<string>();
+
+        foreach (var group in grouped)
+        {
+            var items = group.ToList();
+
+            if (items.Count == 1)
+            {
+                if (IsValidAssembly(items[0].FilePath))
+                    result.Add(items[0].FilePath);
+                continue;
+            }
+
+            result.Add(ResolveConflict(items, revitYear));
+        }
+
+        return result;
+    }
+
+    private static string ResolveConflict(
+        List<PyRevitExtensionPaths.DllCandidate> items, string revitYear)
+    {
+        var yearMatches = items
+            .Where(c => PathContainsSegment(c.FilePath, revitYear))
+            .ToList();
+
+        if (yearMatches.Count > 0)
+            return PickBest(yearMatches);
+
+        var runtimeMajor = Environment.Version.Major;
+        var compatible = new List<(PyRevitExtensionPaths.DllCandidate Candidate, int Major)>();
+        foreach (var item in items)
+        {
+            if (!TryReadTfmMajor(item.FilePath, out var major))
+                continue;
+
+            if (major <= runtimeMajor)
+                compatible.Add((item, major));
+        }
+
+        if (compatible.Count == 0)
+            return PickBest(items);
+
+        var bestMajor = compatible.Max(r => r.Major);
+        var bestCandidates = compatible
+            .Where(r => r.Major == bestMajor)
+            .Select(r => r.Candidate)
+            .ToList();
+
+        return PickBest(bestCandidates);
+    }
+
+    private static string PickBest(List<PyRevitExtensionPaths.DllCandidate> items) =>
+        items
+            .OrderBy(c => c.IsLib ? 0 : 1)
+            .ThenBy(c => c.Depth)
+            .First()
+            .FilePath;
+
+    private static void LoadAll(List<string> dllPaths)
+    {
+        foreach (var dllPath in dllPaths)
+        {
+            var simpleName = Path.GetFileNameWithoutExtension(dllPath);
+            if (LoadedNames.Contains(simpleName))
+                continue;
+
+            try
+            {
+                var bytes = File.ReadAllBytes(dllPath);
+                Assembly.Load(bytes);
+                LoadedNames.Add(simpleName);
+                Trace.TraceInformation($"[PyRevit] Loaded extension DLL: {Path.GetFileName(dllPath)}");
+            }
+            catch (Exception ex)
+            {
+                Trace.TraceWarning($"[PyRevit] Failed to load '{Path.GetFileName(dllPath)}': {ex.Message}");
+            }
+        }
+    }
+
+    private static bool PathContainsSegment(string filePath, string segment)
+    {
+        var dir = Path.GetDirectoryName(filePath);
+        if (string.IsNullOrEmpty(dir)) return false;
+
+        foreach (var part in dir.Split(Path.DirectorySeparatorChar, Path.AltDirectorySeparatorChar))
+        {
+            if (string.Equals(part, segment, StringComparison.OrdinalIgnoreCase))
+                return true;
+        }
+        return false;
+    }
+
+    #region PE Metadata
+
+    /// <summary>
+    /// Returns true if the file has valid .NET PE metadata (is a managed assembly).
+    /// </summary>
+    private static bool IsValidAssembly(string dllPath)
+    {
+        try
+        {
+            using var stream = new FileStream(dllPath, FileMode.Open, FileAccess.Read, FileShare.Read);
+            using var peReader = new PEReader(stream);
+            return peReader.HasMetadata;
+        }
+        catch
+        {
+            return false;
+        }
+    }
+
+    /// <summary>
+    /// Reads TFM major version from PE metadata. Returns false if not a valid .NET assembly.
+    /// </summary>
+    private static bool TryReadTfmMajor(string dllPath, out int major)
+    {
+        major = 0;
+        try
+        {
+            using var stream = new FileStream(dllPath, FileMode.Open, FileAccess.Read, FileShare.Read);
+            using var peReader = new PEReader(stream);
+            if (!peReader.HasMetadata) return false;
+
+            var reader = peReader.GetMetadataReader();
+            var assemblyDef = reader.GetAssemblyDefinition();
+
+            foreach (var attrHandle in assemblyDef.GetCustomAttributes())
+            {
+                var attr = reader.GetCustomAttribute(attrHandle);
+                if (attr.Constructor.Kind != HandleKind.MemberReference) continue;
+
+                var ctor = reader.GetMemberReference((MemberReferenceHandle)attr.Constructor);
+                if (ctor.Parent.Kind != HandleKind.TypeReference) continue;
+
+                var typeRef = reader.GetTypeReference((TypeReferenceHandle)ctor.Parent);
+                if (reader.GetString(typeRef.Name) != "TargetFrameworkAttribute") continue;
+
+                var blob = reader.GetBlobReader(attr.Value);
+                blob.ReadUInt16();
+                var tfmString = blob.ReadSerializedString();
+                major = ParseTfmMajor(tfmString);
+                return true;
+            }
+
+            // Valid .NET assembly but no TargetFrameworkAttribute (old-style) — treat as net4
+            major = 4;
+            return true;
+        }
+        catch
+        {
+            return false;
+        }
+    }
+
+    private static int ParseTfmMajor(string? tfmString)
+    {
+        if (string.IsNullOrEmpty(tfmString)) return 4;
+
+        var vIndex = tfmString!.IndexOf("=v", StringComparison.OrdinalIgnoreCase);
+        if (vIndex < 0) return 4;
+
+        var versionSpan = tfmString.AsSpan(vIndex + 2);
+        var dotIndex = versionSpan.IndexOf('.');
+        var majorSpan = dotIndex > 0 ? versionSpan[..dotIndex] : versionSpan;
+
+        return int.TryParse(majorSpan.ToString(), out var major) ? major : 4;
+    }
+
+    #endregion
+}

source/RevitDevTool/Execution/PyRevit/PyRevitExtensionPaths.cs

@@ -13,20 +13,47 @@ internal static class PyRevitExtensionPaths
     private const string ExtensionSuffix = ".extension";
     private const int MaxExtensionAncestorDepth = 12;
 
+    internal readonly record struct DllCandidate(string FilePath, string SimpleName, bool IsLib, int Depth);
+
     /// <summary>
     /// Yields component folders from extension root down to the script directory
     /// (libs first, then bins — matches pyRevit <c>CollectLibraryPaths</c> / <c>CollectBinaryPaths</c>).
     /// </summary>
     internal static IEnumerable<string> EnumerateHierarchyPaths(string? scriptDirectory)
     {
         var chain = BuildAncestorChain(scriptDirectory);
-        foreach (var path in EnumerateComponentPaths(chain, LibDir))
+        foreach (var (path, _) in EnumerateComponentPaths(chain, LibDir))
             yield return path;
 
-        foreach (var path in EnumerateComponentPaths(chain, BinDir))
+        foreach (var (path, _) in EnumerateComponentPaths(chain, BinDir))
             yield return path;
     }
 
+    /// <summary>
+    /// Enumerates DLL candidates from the hierarchy.
+    /// <list type="bullet">
+    /// <item><c>lib/</c> — all <c>*.dll</c> at any depth (root + subfolders)</item>
+    /// <item><c>bin/</c> — only <c>*.dll</c> in subfolders (skip DLLs directly in bin root)</item>
+    /// </list>
+    /// Depth 0 = closest to script (extension root is highest depth).
+    /// </summary>
+    internal static IEnumerable<DllCandidate> EnumerateDllCandidates(string? scriptDirectory)
+    {
+        var chain = BuildAncestorChain(scriptDirectory);
+
+        foreach (var (folderPath, depth) in EnumerateComponentPaths(chain, LibDir))
+        {
+            foreach (var dll in EnumerateAllDlls(folderPath))
+                yield return new DllCandidate(dll, Path.GetFileNameWithoutExtension(dll), IsLib: true, depth);
+        }
+
+        foreach (var (folderPath, depth) in EnumerateComponentPaths(chain, BinDir))
+        {
+            foreach (var dll in EnumerateAllDlls(folderPath))
+                yield return new DllCandidate(dll, Path.GetFileNameWithoutExtension(dll), IsLib: false, depth);
+        }
+    }
+
     /// <summary>Script directory first, then parents until <c>*.extension</c> (inclusive).</summary>
     private static List<string> BuildAncestorChain(string? startDirectory)
     {
@@ -61,16 +88,20 @@ private static bool TryAppendAncestor(List<string> chain, ref string? dir)
         return true;
     }
 
-    private static IEnumerable<string> EnumerateComponentPaths(List<string> chain, string componentDir)
+    private static IEnumerable<(string Path, int Depth)> EnumerateComponentPaths(
+        List<string> chain, string componentDir)
     {
         for (var i = chain.Count - 1; i >= 0; i--)
         {
             var path = Path.Combine(chain[i], componentDir);
             if (Directory.Exists(path))
-                yield return path;
+                yield return (path, i);
         }
     }
 
+    private static IEnumerable<string> EnumerateAllDlls(string directory) =>
+        Directory.EnumerateFiles(directory, "*.dll", SearchOption.AllDirectories);
+
     private static bool IsExtensionRoot(string dir) =>
         dir.EndsWith(ExtensionSuffix, StringComparison.OrdinalIgnoreCase);
 

source/RevitDevTool/Execution/PyRevit/PyRevitScriptExecutor.cs

@@ -12,6 +12,7 @@ internal static ExecutionResult Execute(string scriptPath, string rootPath)
         var uiApplication = RevitContext.UiApplication;
         try
         {
+            PyRevitAssemblyLoader.EnsureLoaded(scriptPath);
             var reflection = PyRevitReflectionCache.Instance;
 
             if (reflection.HasRuntime)