Remove SkipRunTime parameter, modify runtime id filtering to match powershell dep resolution, add warning when filtering libs

Author: Justin Chung

src/code/InstallHelper.cs

@@ -49,7 +49,6 @@ internal class InstallHelper
         private bool _noClobber;
         private bool _authenticodeCheck;
         private bool _savePkg;
-        private bool _skipRuntimeFiltering;
         private string _runtimeIdentifier;
         private string _targetFramework;
         List<string> _pathsToSearch;
@@ -96,7 +95,6 @@ public IEnumerable<PSResourceInfo> BeginInstallPackages(
             ScopeType? scope,
             string tmpPath,
             HashSet<string> pkgsInstalled,
-            bool skipRuntimeFiltering = false,
             string runtimeIdentifier = null,
             string targetFramework = null)
         {
@@ -140,7 +138,6 @@ public IEnumerable<PSResourceInfo> BeginInstallPackages(
             _asNupkg = asNupkg;
             _includeXml = includeXml;
             _savePkg = savePkg;
-            _skipRuntimeFiltering = skipRuntimeFiltering;
             _runtimeIdentifier = runtimeIdentifier;
             _targetFramework = targetFramework;
             _pathsToInstallPkg = pathsToInstallPkg;
@@ -1175,7 +1172,7 @@ private bool TrySaveNupkgToTempPath(
         /// Similar functionality as System.IO.Compression.ZipFile.ExtractToDirectory,
         /// but while ExtractToDirectory cannot overwrite files, this method can.
         /// Additionally filters:
-        /// - runtimes/{rid}/ entries based on the current platform's RID (unless _skipRuntimeFiltering is true)
+        /// - Root-level RID folder entries (e.g., win-x64/) based on the current platform's RID
         /// - lib/{tfm}/ entries to only extract the best matching Target Framework Moniker
         /// </summary>
         private bool TryExtractToDirectory(string zipPath, string extractPath, out ErrorRecord error)
@@ -1216,10 +1213,16 @@ private bool TryExtractToDirectory(string zipPath, string extractPath, out Error
                         bestLibFramework = GetBestLibFramework(archive);
                     }
 
+                    // Warn if TFM filtering is skipping assemblies for a different .NET lineage
+                    // (e.g., installing on PS7/.NET 8 but package also has net472 for WinPS 5.1)
+                    if (bestLibFramework != null)
+                    {
+                        WarnIfCrossLineageTfmSkipped(archive, bestLibFramework);
+                    }
+
                     foreach (ZipArchiveEntry entry in archive.Entries.Where(entry => entry.CompressedLength > 0))
                     {
-                        // RID filtering: skip runtimes/ entries for incompatible platforms
-                        if (!_skipRuntimeFiltering)
+                        // RID filtering: skip entries under incompatible platform RID folders
                         {
                             bool includeEntry = !string.IsNullOrEmpty(_runtimeIdentifier)
                                 ? RuntimePackageHelper.ShouldIncludeEntry(entry.FullName, _runtimeIdentifier)
@@ -1435,6 +1438,67 @@ private static NuGetFramework GetCurrentFramework()
             return NuGetFramework.ParseFolder("netstandard2.0");
         }
 
+        /// <summary>
+        /// Emits a warning if TFM filtering will skip assemblies for a different .NET lineage.
+        /// For example, when installing on PowerShell 7 (.NET Core), if the package also contains
+        /// .NET Framework assemblies (net472), those will be skipped — which means the module
+        /// won't work if later used on Windows PowerShell 5.1.
+        /// </summary>
+        private void WarnIfCrossLineageTfmSkipped(ZipArchive archive, NuGetFramework bestFramework)
+        {
+            try
+            {
+                bool bestIsNetCore = bestFramework.Framework.Equals(".NETCoreApp", StringComparison.OrdinalIgnoreCase);
+                bool bestIsNetFramework = bestFramework.Framework.Equals(".NETFramework", StringComparison.OrdinalIgnoreCase);
+
+                // Only warn when we're on one lineage and skipping the other
+                if (!bestIsNetCore && !bestIsNetFramework)
+                {
+                    return;
+                }
+
+                // Scan lib/ folders for a TFM from the other lineage
+                var skippedLineageTfms = new HashSet<string>(StringComparer.OrdinalIgnoreCase);
+                foreach (ZipArchiveEntry entry in archive.Entries)
+                {
+                    string normalizedName = entry.FullName.Replace('\\', '/');
+                    if (normalizedName.StartsWith("lib/", StringComparison.OrdinalIgnoreCase))
+                    {
+                        string[] segments = normalizedName.Split('/');
+                        if (segments.Length >= 3 && !string.IsNullOrEmpty(segments[1]))
+                        {
+                            NuGetFramework entryFw = NuGetFramework.ParseFolder(segments[1]);
+                            if (entryFw != null && !entryFw.IsUnsupported && !entryFw.Equals(bestFramework))
+                            {
+                                bool entryIsNetCore = entryFw.Framework.Equals(".NETCoreApp", StringComparison.OrdinalIgnoreCase);
+                                bool entryIsNetFramework = entryFw.Framework.Equals(".NETFramework", StringComparison.OrdinalIgnoreCase);
+
+                                // Detect cross-lineage: we're on Core and skipping Framework, or vice versa
+                                if ((bestIsNetCore && entryIsNetFramework) || (bestIsNetFramework && entryIsNetCore))
+                                {
+                                    skippedLineageTfms.Add(segments[1]);
+                                }
+                            }
+                        }
+                    }
+                }
+
+                if (skippedLineageTfms.Count > 0)
+                {
+                    string skippedList = string.Join(", ", skippedLineageTfms);
+                    string otherHost = bestIsNetCore ? "Windows PowerShell 5.1" : "PowerShell 7+";
+                    _cmdletPassedIn.WriteWarning(
+                        $"This package contains assemblies for {skippedList} which were not installed because " +
+                        $"the current runtime selected {bestFramework.GetShortFolderName()}. " +
+                        $"If you also use this module on {otherHost}, install it separately from that host.");
+                }
+            }
+            catch
+            {
+                // Non-critical warning — don't let it fail the install
+            }
+        }
+
         /// <summary>
         /// Moves package files/directories from the temp install path into the final install path location.
         /// </summary>

src/code/InstallPSResource.cs

@@ -138,14 +138,6 @@ public string TemporaryPath
         [Parameter]
         public SwitchParameter AuthenticodeCheck { get; set; }
 
-        /// <summary>
-        /// Skips platform-specific runtime asset filtering during installation.
-        /// When specified, all runtime assets for all platforms will be installed (original behavior).
-        /// By default, only runtime assets compatible with the current platform are installed.
-        /// </summary>
-        [Parameter]
-        public SwitchParameter SkipRuntimeFiltering { get; set; }
-
         /// <summary>
         /// Specifies the Runtime Identifier (RID) to filter platform-specific assets for.
         /// When specified, only runtime assets matching this RID are installed instead of the auto-detected platform.
@@ -626,7 +618,6 @@ private void ProcessInstallHelper(string[] pkgNames, string pkgVersion, bool pkg
                 scope: scope,
                 tmpPath: _tmpPath,
                 pkgsInstalled: _packagesOnMachine,
-                skipRuntimeFiltering: SkipRuntimeFiltering,
                 runtimeIdentifier: RuntimeIdentifier,
                 targetFramework: TargetFramework);
 

src/code/InternalHooks.cs

@@ -71,7 +71,15 @@ public static bool IsCompatibleRid(string rid)
         #region RuntimePackageHelper Test Hooks
 
         /// <summary>
-        /// Checks if a zip entry path is in the runtimes folder.
+        /// Checks if a folder name looks like a .NET Runtime Identifier.
+        /// </summary>
+        public static bool IsRidFolder(string folderName)
+        {
+            return RuntimePackageHelper.IsRidFolder(folderName);
+        }
+
+        /// <summary>
+        /// Checks if a zip entry path contains runtime-specific assets.
         /// </summary>
         public static bool IsRuntimesEntry(string entryFullName)
         {

src/code/RuntimePackageHelper.cs

@@ -12,64 +12,119 @@ namespace Microsoft.PowerShell.PSResourceGet.UtilClasses
     /// <summary>
     /// Helper class for parsing package runtime assets and filtering during extraction.
     /// Provides functionality to filter runtime-specific assets based on the current platform's RID.
+    /// Detects root-level RID folders (e.g., win-x64/native.dll) used by PowerShell modules
+    /// with platform-specific native dependencies.
     /// </summary>
     internal static class RuntimePackageHelper
     {
         #region Constants
 
         /// <summary>
-        /// The name of the runtimes folder in NuGet packages.
+        /// Path separator used in zip archives.
         /// </summary>
-        private const string RuntimesFolderName = "runtimes";
+        private const char ZipPathSeparator = '/';
 
         /// <summary>
-        /// Path separator used in zip archives.
+        /// Known OS prefixes used in .NET Runtime Identifiers.
         /// </summary>
-        private const char ZipPathSeparator = '/';
+        private static readonly string[] s_knownOsPrefixes = new[]
+        {
+            "win", "linux", "osx", "unix", "maccatalyst", "browser"
+        };
+
+        /// <summary>
+        /// Known architectures used in .NET Runtime Identifiers.
+        /// </summary>
+        private static readonly string[] s_knownArchitectures = new[]
+        {
+            "loongarch64", "ppc64le", "mips64", "s390x", "arm64", "armel", "wasm", "arm", "x64", "x86"
+        };
 
         #endregion
 
         #region Public Methods
 
         /// <summary>
-        /// Checks if a zip entry path is within the runtimes folder.
+        /// Checks if a folder name looks like a .NET Runtime Identifier.
+        /// Matches patterns like: win-x64, linux-arm64, osx-arm64, linux-musl-x64, etc.
+        /// </summary>
+        /// <param name="folderName">The folder name to check.</param>
+        /// <returns>True if the folder name matches a RID pattern; otherwise, false.</returns>
+        public static bool IsRidFolder(string folderName)
+        {
+            if (string.IsNullOrEmpty(folderName) || !folderName.Contains("-"))
+            {
+                return false;
+            }
+
+            // Must start with a known OS prefix
+            bool startsWithKnownOs = false;
+            foreach (string prefix in s_knownOsPrefixes)
+            {
+                if (folderName.StartsWith(prefix, StringComparison.OrdinalIgnoreCase))
+                {
+                    startsWithKnownOs = true;
+                    break;
+                }
+            }
+
+            if (!startsWithKnownOs)
+            {
+                return false;
+            }
+
+            // Must end with a known architecture
+            string[] parts = folderName.Split('-');
+            string lastPart = parts[parts.Length - 1];
+            foreach (string arch in s_knownArchitectures)
+            {
+                if (string.Equals(lastPart, arch, StringComparison.OrdinalIgnoreCase))
+                {
+                    return true;
+                }
+            }
+
+            return false;
+        }
+
+        /// <summary>
+        /// Checks if a zip entry path is under a root-level RID folder.
+        /// Detects entries like win-x64/native.dll, linux-arm64/libfoo.so, etc.
         /// </summary>
         /// <param name="entryFullName">The full path of the zip entry.</param>
-        /// <returns>True if the entry is in the runtimes folder; otherwise, false.</returns>
+        /// <returns>True if the entry is under a RID folder; otherwise, false.</returns>
         public static bool IsRuntimesEntry(string entryFullName)
         {
             if (string.IsNullOrEmpty(entryFullName))
             {
                 return false;
             }
 
-            // Normalize path separators for comparison
             string normalizedPath = entryFullName.Replace('\\', ZipPathSeparator);
-            
-            return normalizedPath.StartsWith(RuntimesFolderName + ZipPathSeparator, StringComparison.OrdinalIgnoreCase);
+            string[] segments = normalizedPath.Split(ZipPathSeparator);
+
+            // Pattern: {rid}/... (root-level RID folders like win-x64/native.dll)
+            return segments.Length >= 2 && IsRidFolder(segments[0]);
         }
 
         /// <summary>
-        /// Extracts the RID from a runtimes folder entry path.
+        /// Extracts the RID from a root-level RID folder entry path.
         /// </summary>
-        /// <param name="entryFullName">The full path of the zip entry (e.g., "runtimes/win-x64/native/file.dll").</param>
-        /// <returns>The RID (e.g., "win-x64"), or null if not a runtimes entry.</returns>
+        /// <param name="entryFullName">The full path of the zip entry (e.g., "win-x64/native.dll").</param>
+        /// <returns>The RID (e.g., "win-x64"), or null if not under a RID folder.</returns>
         public static string GetRidFromRuntimesEntry(string entryFullName)
         {
-            if (!IsRuntimesEntry(entryFullName))
+            if (string.IsNullOrEmpty(entryFullName))
             {
                 return null;
             }
 
-            // Normalize path separators
             string normalizedPath = entryFullName.Replace('\\', ZipPathSeparator);
-            
-            // Path format: runtimes/{rid}/...
             string[] parts = normalizedPath.Split(ZipPathSeparator);
-            
-            if (parts.Length >= 2)
+
+            if (parts.Length >= 2 && IsRidFolder(parts[0]))
             {
-                return parts[1]; // The RID is the second segment
+                return parts[0];
             }
 
             return null;
@@ -82,21 +137,18 @@ public static string GetRidFromRuntimesEntry(string entryFullName)
         /// <returns>True if the entry should be included; otherwise, false.</returns>
         public static bool ShouldIncludeEntry(string entryFullName)
         {
-            // Non-runtimes entries are always included
             if (!IsRuntimesEntry(entryFullName))
             {
                 return true;
             }
 
             string entryRid = GetRidFromRuntimesEntry(entryFullName);
-            
+
             if (string.IsNullOrEmpty(entryRid))
             {
-                // If we can't determine the RID, include the entry to be safe
                 return true;
             }
 
-            // Check if this RID is compatible with the current platform
             return RuntimeIdentifierHelper.IsCompatibleRid(entryRid);
         }
 
@@ -109,25 +161,24 @@ public static bool ShouldIncludeEntry(string entryFullName)
         /// <returns>True if the entry should be included; otherwise, false.</returns>
         public static bool ShouldIncludeEntry(string entryFullName, string targetRid)
         {
-            // Non-runtimes entries are always included
             if (!IsRuntimesEntry(entryFullName))
             {
                 return true;
             }
 
             string entryRid = GetRidFromRuntimesEntry(entryFullName);
-            
+
             if (string.IsNullOrEmpty(entryRid))
             {
                 return true;
             }
 
-            // Check if this RID is compatible with the specified target
             return RuntimeIdentifierHelper.IsCompatibleRid(entryRid, targetRid);
         }
 
         /// <summary>
-        /// Gets a list of all unique RIDs present in a zip archive's runtimes folder.
+        /// Gets a list of all unique RIDs present in a zip archive.
+        /// Detects both runtimes/{rid}/ and root-level {rid}/ patterns.
         /// </summary>
         /// <param name="archive">The zip archive to scan.</param>
         /// <returns>A list of unique RIDs found in the archive.</returns>
@@ -153,7 +204,7 @@ public static IReadOnlyList<string> GetAvailableRidsFromArchive(ZipArchive archi
         }
 
         /// <summary>
-        /// Gets a list of all unique RIDs present in a zip file's runtimes folder.
+        /// Gets a list of all unique RIDs present in a zip file.
         /// </summary>
         /// <param name="zipPath">The path to the zip file.</param>
         /// <returns>A list of unique RIDs found in the archive.</returns>