Merge/upstream 2026 08

CompactGUI.Core/Analyser.cs

@@ -14,6 +14,7 @@ public sealed class Analyser : IDisposable
     private readonly FolderChangeMonitor _folderMonitor;
     public bool HasFolderChanged => _folderMonitor.HasChanged;
     public DateTime LastFolderChanged => _folderMonitor.LastChanged;
+    public bool IsDirectStorage { get; private set; }
 
 
     public Analyser(string folder, ILogger<Analyser> logger)
@@ -65,12 +66,18 @@ private static bool GetContainsCompressedFiles(List<AnalysedFileDetails> fileCom
     {
 
         List<AnalysedFileDetails>? AnalysedFileDetails;
+        IsDirectStorage = false;
 
         AnalyserLog.StartingAnalysis(_logger, FolderName);
         Stopwatch sw = Stopwatch.StartNew();
         try
         {
-            var allFiles = await Task.Run(() => Directory.EnumerateFiles(FolderName, "*", new EnumerationOptions { RecurseSubdirectories = true, IgnoreInaccessible = true, AttributesToSkip = FileAttributes.ReparsePoint }).AsShortPathNames(), cancellationToken).ConfigureAwait(false);
+            var allFiles = (await Task.Run(() => Directory.EnumerateFiles(FolderName, "*", new EnumerationOptions { RecurseSubdirectories = true, IgnoreInaccessible = true, AttributesToSkip = FileAttributes.ReparsePoint }), cancellationToken).ConfigureAwait(false))
+                .AsShortPathNames()
+                .ToList();
+
+            IsDirectStorage = allFiles.Any(f => Path.GetFileName(f).Equals("dstorage.dll", StringComparison.OrdinalIgnoreCase));
+
             var fileDetails = allFiles
                 .AsParallel()
                 .WithCancellation(cancellationToken)

CompactGUI.Core/CompactGUI.Core.csproj

@@ -14,6 +14,7 @@
   <ItemGroup>
     <PackageReference Include="CommunityToolkit.Mvvm" Version="8.4.0" />
     <PackageReference Include="K4os.Compression.LZ4.Streams" Version="1.3.8" />
+    <PackageReference Include="Microsoft.Extensions.FileSystemGlobbing" Version="10.0.11" />
     <PackageReference Include="Microsoft.Windows.CsWin32" Version="0.3.321">
       <PrivateAssets>all</PrivateAssets>
       <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>

CompactGUI.Core/Compactor.cs

@@ -308,15 +308,18 @@ public async Task<IEnumerable<FileDetails>> BuildWorkingFilesList(IReadOnlyColle
         uint clusterSize = SharedMethods.GetClusterSize(workingDirectory);
 
         var analysedFiles = await _analyser.GetAnalysedFilesAsync(cancellationTokenSource.Token) ?? [];
+        var excludedFiles = SkipListMatcher.GetExcludedFiles(
+            workingDirectory,
+            analysedFiles.Select(fl => fl.FileName),
+            excludedFilesAndExtensions);
 
         return analysedFiles
             .Where(fl =>
                 fl.CompressionMode != wofCompressionAlgorithm
                 && !resumeExcludedFiles.Contains(fl.FileName)
                 && !notBeneficialCache.ShouldSkip(fl.FileName, wofCompressionAlgorithm)
                 && fl.UncompressedSize > clusterSize
-                && (fl.FileInfo == null || !excludedFilesAndExtensions.Contains(fl.FileInfo.Extension))
-                && !excludedFilesAndExtensions.Contains(fl.FileName)
+                && !excludedFiles.Contains(fl.FileName)
             )
             .Select(fl => new FileDetails(fl.FileName, fl.UncompressedSize, fl.CompressionMode))
             .ToList();

CompactGUI.Core/SkipListMatcher.cs

@@ -0,0 +1,75 @@
+using Microsoft.Extensions.FileSystemGlobbing;
+
+namespace CompactGUI.Core;
+
+public static class SkipListMatcher
+{
+    public static HashSet<string> GetExcludedFiles(string rootDirectory, IEnumerable<string> allFiles, IEnumerable<string> patterns)
+    {
+        var excluded = new HashSet<string>(StringComparer.OrdinalIgnoreCase);
+        if (!patterns.Any()) return excluded;
+
+        var matcher = new Matcher(StringComparison.OrdinalIgnoreCase);
+        foreach (string glob in NormalisePatterns(patterns, rootDirectory))
+        {
+            matcher.AddInclude(glob);
+        }
+
+        var relativeFiles = allFiles.Select(f => Path.GetRelativePath(rootDirectory, f).Replace('\\', '/'));
+
+        foreach (FilePatternMatch match in matcher.Match(relativeFiles).Files)
+        {
+            excluded.Add(Path.GetFullPath(Path.Combine(rootDirectory, match.Path)));
+        }
+
+        return excluded;
+    }
+
+    private static IEnumerable<string> NormalisePatterns(IEnumerable<string> entries, string rootDirectory)
+    {
+        foreach (string entry in entries)
+        {
+            string pattern = entry.Trim().Trim(Path.DirectorySeparatorChar, Path.AltDirectorySeparatorChar);
+            if (pattern.Length == 0) continue;
+
+            if (Path.IsPathRooted(pattern))
+            {
+                try
+                {
+                    string relative = Path.GetRelativePath(rootDirectory, pattern).Replace('\\', '/');
+                    if (!relative.StartsWith("../", StringComparison.Ordinal) && relative != "..")
+                    {
+                        pattern = relative;
+                    }
+                }
+                catch (ArgumentException)
+                {
+                    // Unrelated roots; leave as-is (won't match).
+                }
+            }
+
+            bool hasWildcard = pattern.Contains('*') || pattern.Contains('?');
+            bool hasSeparator = pattern.Contains(Path.DirectorySeparatorChar) || pattern.Contains(Path.AltDirectorySeparatorChar);
+
+            if (!hasSeparator && IsExtensionPattern(pattern))
+            {
+                yield return "**/*" + (pattern.StartsWith('.') ? pattern : pattern[1..]);
+            }
+            else if (!hasWildcard && !hasSeparator)
+            {
+                yield return "**/" + pattern;
+            }
+            else
+            {
+                yield return NormalisePath(pattern);
+            }
+        }
+    }
+
+    private static bool IsExtensionPattern(string pattern)
+    {
+        return pattern.StartsWith('.') || pattern.StartsWith("*.");
+    }
+
+    private static string NormalisePath(string path) => path.Replace(Path.DirectorySeparatorChar, '/').Replace(Path.AltDirectorySeparatorChar, '/');
+}