perf: Make Everything folder size calculation non-blocking

- Run all folder size calculations on background threads
- Add semaphore to limit concurrent calculations to 3
- Add timeout (2s) for SDK3 folder size queries
- Fire and forget size calculations during enumeration
- Return cached sizes immediately without blocking
- Properly dispose resources (semaphore and SDK3 service)

This prevents the UI from freezing when navigating folders with
Everything folder size calculation enabled.

🤖 Generated with [Claude Code](https://claude.ai/code)

Co-Authored-By: Claude <[email protected]>

Author: elliotttate

src/Files.App/Services/SizeProvider/EverythingSizeProvider.cs

@@ -19,6 +19,7 @@ public sealed class EverythingSizeProvider : ISizeProvider
 		private readonly IEverythingSearchService everythingService;
 		private readonly IGeneralSettingsService generalSettings;
 		private static EverythingSdk3Service _sdk3Service;
+		private readonly SemaphoreSlim _calculationSemaphore = new(3); // Limit concurrent calculations
 
 		public event EventHandler<SizeChangedEventArgs>? SizeChanged;
 
@@ -77,45 +78,55 @@ public Task ClearAsync()
 
 		public async Task UpdateAsync(string path, CancellationToken cancellationToken)
 		{
-			await Task.Yield();
-			
-			
 			// Return cached size immediately if available
 			if (sizes.TryGetValue(path, out ulong cachedSize))
 			{
 				RaiseSizeChanged(path, cachedSize, SizeChangedValueState.Final);
-			}
-			else
-			{
-				RaiseSizeChanged(path, 0, SizeChangedValueState.None);
-			}
-
-			// Check if Everything is available
-			if (!everythingService.IsEverythingAvailable())
-			{
-				await FallbackCalculateAsync(path, cancellationToken);
 				return;
 			}
 
-			try
+			// Indicate that calculation is starting
+			RaiseSizeChanged(path, 0, SizeChangedValueState.None);
+
+			// Run the entire calculation on a background thread to avoid blocking
+			await Task.Run(async () =>
 			{
-				// Calculate using Everything
-				ulong totalSize = await CalculateWithEverythingAsync(path, cancellationToken);
-				
-				if (totalSize == 0)
+				// Limit concurrent calculations
+				await _calculationSemaphore.WaitAsync(cancellationToken);
+				try
 				{
-					// Everything returned 0, use fallback
-					await FallbackCalculateAsync(path, cancellationToken);
-					return;
+					// Check if Everything is available
+					if (!everythingService.IsEverythingAvailable())
+					{
+						await FallbackCalculateAsync(path, cancellationToken);
+						return;
+					}
+
+					try
+					{
+						// Calculate using Everything
+						ulong totalSize = await CalculateWithEverythingAsync(path, cancellationToken);
+						
+						if (totalSize == 0)
+						{
+							// Everything returned 0, use fallback
+							await FallbackCalculateAsync(path, cancellationToken);
+							return;
+						}
+						sizes[path] = totalSize;
+						RaiseSizeChanged(path, totalSize, SizeChangedValueState.Final);
+					}
+					catch (Exception ex)
+					{
+						// Fall back to standard calculation on error
+						await FallbackCalculateAsync(path, cancellationToken);
+					}
 				}
-				sizes[path] = totalSize;
-				RaiseSizeChanged(path, totalSize, SizeChangedValueState.Final);
-			}
-			catch (Exception ex)
-			{
-				// Fall back to standard calculation on error
-				await FallbackCalculateAsync(path, cancellationToken);
-			}
+				finally
+				{
+					_calculationSemaphore.Release();
+				}
+			}, cancellationToken).ConfigureAwait(false);
 		}
 
 		private async Task<ulong> CalculateWithEverythingAsync(string path, CancellationToken cancellationToken)
@@ -147,13 +158,21 @@ private async Task<ulong> CalculateWithEverythingAsync(string path, Cancellation
 			{
 				try
 				{
-					var size = await Task.Run(() => _sdk3Service.GetFolderSize(path), cancellationToken);
+					// Use a timeout for SDK3 queries to prevent hanging
+					using var cts = CancellationTokenSource.CreateLinkedTokenSource(cancellationToken);
+					cts.CancelAfter(TimeSpan.FromSeconds(2)); // 2 second timeout
+					
+					var size = await Task.Run(() => _sdk3Service.GetFolderSize(path), cts.Token);
 					if (size > 0)
 					{
 						App.Logger?.LogInformation($"[EverythingSizeProvider SDK3] Got folder size for {path}: {size} bytes");
 						return size;
 					}
 				}
+				catch (OperationCanceledException)
+				{
+					App.Logger?.LogWarning($"[EverythingSizeProvider SDK3] Timeout getting folder size for {path}");
+				}
 				catch (Exception ex)
 				{
 					App.Logger?.LogError(ex, $"[EverythingSizeProvider SDK3] Error getting folder size for {path}");
@@ -326,7 +345,11 @@ async Task<ulong> CalculateRecursive(string currentPath, CancellationToken ct, i
 
 		public bool TryGetSize(string path, out ulong size) => sizes.TryGetValue(path, out size);
 
-		public void Dispose() { }
+		public void Dispose() 
+		{
+			_calculationSemaphore?.Dispose();
+			_sdk3Service?.Dispose();
+		}
 
 		private void RaiseSizeChanged(string path, ulong newSize, SizeChangedValueState valueState)
 			=> SizeChanged?.Invoke(this, new SizeChangedEventArgs(path, newSize, valueState));

src/Files.App/Utils/Storage/Enumerators/Win32StorageEnumerator.cs

@@ -78,8 +78,18 @@ Func<List<ListedItem>, Task> intermediateAction
 										folder.FileSizeBytes = (long)size;
 										folder.FileSize = size.ToSizeString();
 									}
-
-									_ = folderSizeProvider.UpdateAsync(folder.ItemPath, cancellationToken);
+									else
+									{
+										// Fire and forget - calculate size in background without blocking
+										_ = Task.Run(async () =>
+										{
+											try
+											{
+												await folderSizeProvider.UpdateAsync(folder.ItemPath, cancellationToken);
+											}
+											catch { /* Ignore errors in background size calculation */ }
+										});
+									}
 								}
 							}
 						}