diff --git a/.github/workflows/dotnet.yml b/.github/workflows/dotnet.yml
index ba4f3d7..f70240b 100644
--- a/.github/workflows/dotnet.yml
+++ b/.github/workflows/dotnet.yml
@@ -28,7 +28,11 @@ jobs:
       - name: Setup .NET
         uses: actions/setup-dotnet@v4
         with:
-          dotnet-version: 9.0.x
+          # 10.0.x runs the pipeline; 8.0.x and 9.0.x provide runtimes for the multi-targeted test project
+          dotnet-version: |
+            8.0.x
+            9.0.x
+            10.0.x
       - name: Run Pipeline
         run: dotnet run -c Release
         working-directory: "EnumerableAsyncProcessor.Pipeline"
diff --git a/.gitignore b/.gitignore
index 377bb11..5313adb 100644
--- a/.gitignore
+++ b/.gitignore
@@ -351,3 +351,5 @@ MigrationBackup/
 
 # Claude local settings
 .claude/settings.local.json
+
+.playwright-mcp/
diff --git a/EnumerableAsyncProcessor.Pipeline/EnumerableAsyncProcessor.Pipeline.csproj b/EnumerableAsyncProcessor.Pipeline/EnumerableAsyncProcessor.Pipeline.csproj
index 4e79a78..7686c41 100644
--- a/EnumerableAsyncProcessor.Pipeline/EnumerableAsyncProcessor.Pipeline.csproj
+++ b/EnumerableAsyncProcessor.Pipeline/EnumerableAsyncProcessor.Pipeline.csproj
@@ -2,15 +2,20 @@
 
     <PropertyGroup>
         <OutputType>Exe</OutputType>
-        <TargetFramework>net9.0</TargetFramework>
+        <TargetFramework>net10.0</TargetFramework>
         <ImplicitUsings>enable</ImplicitUsings>
         <Nullable>enable</Nullable>
         <SignAssembly>false</SignAssembly>
     </PropertyGroup>
 
     <ItemGroup>
-      <PackageReference Include="ModularPipelines.DotNet" Version="3.1.90" />
-      <PackageReference Include="ModularPipelines.Git" Version="3.1.90" />
+      <PackageReference Include="ModularPipelines.DotNet" Version="3.2.8" />
+      <PackageReference Include="ModularPipelines.Git" Version="3.2.8" />
+    </ItemGroup>
+
+    <ItemGroup>
+      <!-- Pipeline.CreateBuilder resolves configuration relative to the output directory -->
+      <None Include="appsettings.json" CopyToOutputDirectory="PreserveNewest" />
     </ItemGroup>
 
 </Project>
diff --git a/EnumerableAsyncProcessor.Pipeline/Modules/LocalMachine/AddLocalNugetSourceModule.cs b/EnumerableAsyncProcessor.Pipeline/Modules/LocalMachine/AddLocalNugetSourceModule.cs
index 0630a59..4dd5110 100644
--- a/EnumerableAsyncProcessor.Pipeline/Modules/LocalMachine/AddLocalNugetSourceModule.cs
+++ b/EnumerableAsyncProcessor.Pipeline/Modules/LocalMachine/AddLocalNugetSourceModule.cs
@@ -1,4 +1,5 @@
-using ModularPipelines.Attributes;
+using ModularPipelines.Attributes;
+using ModularPipelines.Configuration;
 using ModularPipelines.Context;
 using ModularPipelines.DotNet.Extensions;
 using ModularPipelines.DotNet.Options;
@@ -11,21 +12,24 @@ namespace EnumerableAsyncProcessor.Pipeline.Modules.LocalMachine;
 [DependsOn<CreateLocalNugetFolderModule>]
 public class AddLocalNugetSourceModule : Module<CommandResult>
 {
-    protected override async Task<bool> ShouldIgnoreFailures(IPipelineContext context, Exception exception)
+    protected override ModuleConfiguration Configure()
     {
-        await Task.Yield();
-        return exception is CommandException commandException &&
-                               commandException.StandardOutput.Contains("The name specified has already been added to the list of available package sources");
+        return ModuleConfiguration.Create()
+            .WithIgnoreFailuresWhen((_, exception) =>
+                exception is CommandException commandException &&
+                commandException.StandardOutput.Contains("The name specified has already been added to the list of available package sources"))
+            .Build();
     }
 
-    protected override async Task<CommandResult?> ExecuteAsync(IPipelineContext context, CancellationToken cancellationToken)
+    protected override async Task<CommandResult?> ExecuteAsync(IModuleContext context, CancellationToken cancellationToken)
     {
-        var localNugetPathResult = await GetModule<CreateLocalNugetFolderModule>();
+        var localNugetPathResult = await context.GetModule<CreateLocalNugetFolderModule>();
 
         return await context.DotNet().Nuget.Add
-            .Source(new DotNetNugetAddSourceOptions(localNugetPathResult.Value!)
+            .Source(new DotNetNugetAddSourceOptions
             {
+                Packagesourcepath = localNugetPathResult.ValueOrDefault!.Path,
                 Name = "ModularPipelinesLocalNuGet"
-            }, cancellationToken);
+            }, cancellationToken: cancellationToken);
     }
 }
diff --git a/EnumerableAsyncProcessor.Pipeline/Modules/LocalMachine/CreateLocalNugetFolderModule.cs b/EnumerableAsyncProcessor.Pipeline/Modules/LocalMachine/CreateLocalNugetFolderModule.cs
index 38ce560..7fde8cc 100644
--- a/EnumerableAsyncProcessor.Pipeline/Modules/LocalMachine/CreateLocalNugetFolderModule.cs
+++ b/EnumerableAsyncProcessor.Pipeline/Modules/LocalMachine/CreateLocalNugetFolderModule.cs
@@ -1,4 +1,4 @@
-using Microsoft.Extensions.Logging;
+using Microsoft.Extensions.Logging;
 using ModularPipelines.Attributes;
 using ModularPipelines.Context;
 using ModularPipelines.FileSystem;
@@ -10,17 +10,16 @@ namespace EnumerableAsyncProcessor.Pipeline.Modules.LocalMachine;
 [DependsOn<PackagePathsParserModule>]
 public class CreateLocalNugetFolderModule : Module<Folder>
 {
-    protected override async Task<Folder?> ExecuteAsync(IPipelineContext context, CancellationToken cancellationToken)
+    protected override Task<Folder?> ExecuteAsync(IModuleContext context, CancellationToken cancellationToken)
     {
-        var localNugetRepositoryFolder = context.FileSystem.GetFolder(Environment.SpecialFolder.ApplicationData)
+        var localNugetRepositoryFolder = context.Files
+            .GetFolder(Environment.GetFolderPath(Environment.SpecialFolder.ApplicationData))
             .GetFolder("ModularPipelines")
             .GetFolder("LocalNuget")
             .Create();
-        
-        await Task.Yield();
 
         context.Logger.LogInformation("Local NuGet Repository Path: {Path}", localNugetRepositoryFolder.Path);
 
-        return localNugetRepositoryFolder;
+        return Task.FromResult<Folder?>(localNugetRepositoryFolder);
     }
 }
diff --git a/EnumerableAsyncProcessor.Pipeline/Modules/LocalMachine/UploadPackagesToLocalNuGetModule.cs b/EnumerableAsyncProcessor.Pipeline/Modules/LocalMachine/UploadPackagesToLocalNuGetModule.cs
index 03c0bee..9cd638b 100644
--- a/EnumerableAsyncProcessor.Pipeline/Modules/LocalMachine/UploadPackagesToLocalNuGetModule.cs
+++ b/EnumerableAsyncProcessor.Pipeline/Modules/LocalMachine/UploadPackagesToLocalNuGetModule.cs
@@ -14,26 +14,31 @@ namespace EnumerableAsyncProcessor.Pipeline.Modules.LocalMachine;
 [DependsOn<CreateLocalNugetFolderModule>]
 public class UploadPackagesToLocalNuGetModule : Module<CommandResult[]>
 {
-    protected override async Task OnBeforeExecute(IPipelineContext context)
+    protected override async Task OnBeforeExecuteAsync(IModuleContext context, CancellationToken cancellationToken)
     {
-        var packagePaths = await GetModule<PackagePathsParserModule>();
-        foreach (var packagePath in packagePaths.Value!)
+        var packagePaths = await context.GetModule<PackagePathsParserModule>();
+
+        foreach (var packagePath in packagePaths.ValueOrDefault ?? [])
         {
             context.Logger.LogInformation("[Local Directory] Uploading {File}", packagePath);
         }
 
-        await base.OnBeforeExecute(context);
+        await base.OnBeforeExecuteAsync(context, cancellationToken);
     }
 
-    protected override async Task<CommandResult[]?> ExecuteAsync(IPipelineContext context, CancellationToken cancellationToken)
+    protected override async Task<CommandResult[]?> ExecuteAsync(IModuleContext context, CancellationToken cancellationToken)
     {
-        var localRepoLocation = await GetModule<CreateLocalNugetFolderModule>();
-        var packagePaths = await GetModule<PackagePathsParserModule>();
-        return await packagePaths.Value!.SelectAsync(async file => await context.DotNet()
-            .Nuget
-            .Push(new DotNetNugetPushOptions(file)
-            {
-                Source = localRepoLocation.Value!,
-            }, cancellationToken), cancellationToken: cancellationToken).ProcessOneAtATime();
+        var localRepoLocation = await context.GetModule<CreateLocalNugetFolderModule>();
+        var packagePaths = await context.GetModule<PackagePathsParserModule>();
+
+        return await packagePaths.ValueOrDefault!
+            .SelectAsync(file => context.DotNet()
+                .Nuget
+                .Push(new DotNetNugetPushOptions
+                {
+                    Path = file.Path,
+                    Source = localRepoLocation.ValueOrDefault!.Path,
+                }, cancellationToken: cancellationToken), cancellationToken: cancellationToken)
+            .ProcessOneAtATime();
     }
-}
\ No newline at end of file
+}
diff --git a/EnumerableAsyncProcessor.Pipeline/Modules/NugetVersionGeneratorModule.cs b/EnumerableAsyncProcessor.Pipeline/Modules/NugetVersionGeneratorModule.cs
index 1539469..c2c8078 100644
--- a/EnumerableAsyncProcessor.Pipeline/Modules/NugetVersionGeneratorModule.cs
+++ b/EnumerableAsyncProcessor.Pipeline/Modules/NugetVersionGeneratorModule.cs
@@ -1,30 +1,28 @@
-using Microsoft.Extensions.Logging;
+using Microsoft.Extensions.Logging;
 using ModularPipelines.Context;
 using ModularPipelines.Git.Extensions;
+using ModularPipelines.Models;
 using ModularPipelines.Modules;
 
-// ReSharper disable HeuristicUnreachableCode
-#pragma warning disable CS0162
-
 namespace EnumerableAsyncProcessor.Pipeline.Modules;
 
 public class NugetVersionGeneratorModule : Module<string>
 {
-    protected override async Task<string?> ExecuteAsync(IPipelineContext context, CancellationToken cancellationToken)
+    protected override async Task<string?> ExecuteAsync(IModuleContext context, CancellationToken cancellationToken)
     {
         var gitVersionInformation = await context.Git().Versioning.GetGitVersioningInformation();
-        
+
         if (gitVersionInformation.BranchName == "main")
         {
             return gitVersionInformation.SemVer!;
         }
-        
+
         return $"{gitVersionInformation.Major}.{gitVersionInformation.Minor}.{gitVersionInformation.Patch}-{gitVersionInformation.PreReleaseLabel}-{gitVersionInformation.CommitsSinceVersionSource}";
     }
 
-    protected override async Task OnAfterExecute(IPipelineContext context)
+    protected override Task<ModuleResult<string>?> OnAfterExecuteAsync(IModuleContext context, ModuleResult<string> result, CancellationToken cancellationToken)
     {
-        var moduleResult = await this;
-        context.Logger.LogInformation("NuGet Version to Package: {Version}", moduleResult.Value);
+        context.Logger.LogInformation("NuGet Version to Package: {Version}", result.ValueOrDefault);
+        return base.OnAfterExecuteAsync(context, result, cancellationToken);
     }
 }
diff --git a/EnumerableAsyncProcessor.Pipeline/Modules/PackProjectsModule.cs b/EnumerableAsyncProcessor.Pipeline/Modules/PackProjectsModule.cs
index 587e09c..a6bf5fe 100644
--- a/EnumerableAsyncProcessor.Pipeline/Modules/PackProjectsModule.cs
+++ b/EnumerableAsyncProcessor.Pipeline/Modules/PackProjectsModule.cs
@@ -15,29 +15,31 @@ namespace EnumerableAsyncProcessor.Pipeline.Modules;
 [DependsOn<RunUnitTestsModule>]
 public class PackProjectsModule : Module<List<CommandResult>>
 {
-    protected override async Task<List<CommandResult>?> ExecuteAsync(IPipelineContext context, CancellationToken cancellationToken)
+    protected override async Task<List<CommandResult>?> ExecuteAsync(IModuleContext context, CancellationToken cancellationToken)
     {
         var results = new List<CommandResult>();
-        var packageVersion = await GetModule<NugetVersionGeneratorModule>();
-        var projectFiles = context.Git().RootDirectory!.GetFiles(f => GetProjectsPredicate(f, context));
+        var packageVersion = await context.GetModule<NugetVersionGeneratorModule>();
+        var projectFiles = context.Git().RootDirectory.GetFiles(f => GetProjectsPredicate(f, context));
+
         foreach (var projectFile in projectFiles)
         {
-            results.Add(await context.DotNet().Pack(new DotNetPackOptions { 
-                ProjectSolution = projectFile.Path, 
-                Configuration = Configuration.Release, 
+            results.Add(await context.DotNet().Pack(new DotNetPackOptions
+            {
+                ProjectSolution = projectFile.Path,
+                Configuration = "Release",
                 Properties =
                 [
-                    ("PackageVersion", packageVersion.Value)!, 
-                    ("Version", packageVersion.Value)!
+                    ("PackageVersion", packageVersion.ValueOrDefault)!,
+                    ("Version", packageVersion.ValueOrDefault)!
                 ],
                 IncludeSource = true
-            }, cancellationToken));
+            }, cancellationToken: cancellationToken));
         }
 
         return results;
     }
 
-    private bool GetProjectsPredicate(File file, IPipelineContext context)
+    private bool GetProjectsPredicate(File file, IModuleContext context)
     {
         var path = file.Path;
         if (!path.EndsWith(".csproj", StringComparison.OrdinalIgnoreCase))
@@ -55,4 +57,4 @@ private bool GetProjectsPredicate(File file, IPipelineContext context)
         context.Logger.LogInformation("Found File: {File}", path);
         return true;
     }
-}
\ No newline at end of file
+}
diff --git a/EnumerableAsyncProcessor.Pipeline/Modules/PackageFilesRemovalModule.cs b/EnumerableAsyncProcessor.Pipeline/Modules/PackageFilesRemovalModule.cs
index 8cda2dd..76764ac 100644
--- a/EnumerableAsyncProcessor.Pipeline/Modules/PackageFilesRemovalModule.cs
+++ b/EnumerableAsyncProcessor.Pipeline/Modules/PackageFilesRemovalModule.cs
@@ -6,15 +6,15 @@ namespace EnumerableAsyncProcessor.Pipeline.Modules;
 
 public class PackageFilesRemovalModule : Module
 {
-    protected override async Task<IDictionary<string, object>?> ExecuteAsync(IPipelineContext context, CancellationToken cancellationToken)
+    protected override Task ExecuteModuleAsync(IModuleContext context, CancellationToken cancellationToken)
     {
-        var packageFiles = context.Git().RootDirectory.GetFiles(path => path.Extension is ".nupkg");
+        var packageFiles = context.Git().RootDirectory.GetFiles(file => file.Extension is ".nupkg");
 
         foreach (var packageFile in packageFiles)
         {
             packageFile.Delete();
         }
 
-        return await NothingAsync();
+        return Task.CompletedTask;
     }
 }
diff --git a/EnumerableAsyncProcessor.Pipeline/Modules/PackagePathsParserModule.cs b/EnumerableAsyncProcessor.Pipeline/Modules/PackagePathsParserModule.cs
index ff07081..78ee866 100644
--- a/EnumerableAsyncProcessor.Pipeline/Modules/PackagePathsParserModule.cs
+++ b/EnumerableAsyncProcessor.Pipeline/Modules/PackagePathsParserModule.cs
@@ -8,11 +8,11 @@ namespace EnumerableAsyncProcessor.Pipeline.Modules;
 [DependsOn<PackProjectsModule>]
 public class PackagePathsParserModule : Module<List<File>>
 {
-    protected override async Task<List<File>?> ExecuteAsync(IPipelineContext context, CancellationToken cancellationToken)
+    protected override async Task<List<File>?> ExecuteAsync(IModuleContext context, CancellationToken cancellationToken)
     {
-        var packPackagesModuleResult = await GetModule<PackProjectsModule>();
+        var packPackagesModuleResult = await context.GetModule<PackProjectsModule>();
 
-        return packPackagesModuleResult.Value!
+        return packPackagesModuleResult.ValueOrDefault!
             .Select(x => x.StandardOutput)
             .Select(x => x.Split("Successfully created package '")[1])
             .Select(x => x.Split("'.")[0])
diff --git a/EnumerableAsyncProcessor.Pipeline/Modules/RunUnitTestsModule.cs b/EnumerableAsyncProcessor.Pipeline/Modules/RunUnitTestsModule.cs
index aced2e7..34f1bfc 100644
--- a/EnumerableAsyncProcessor.Pipeline/Modules/RunUnitTestsModule.cs
+++ b/EnumerableAsyncProcessor.Pipeline/Modules/RunUnitTestsModule.cs
@@ -2,7 +2,6 @@
 using ModularPipelines.DotNet.Extensions;
 using ModularPipelines.DotNet.Options;
 using ModularPipelines.Git.Extensions;
-using ModularPipelines.Enums;
 using ModularPipelines.Models;
 using ModularPipelines.Modules;
 
@@ -10,20 +9,19 @@ namespace EnumerableAsyncProcessor.Pipeline.Modules;
 
 public class RunUnitTestsModule : Module<List<CommandResult>>
 {
-    protected override async Task<List<CommandResult>?> ExecuteAsync(IPipelineContext context, CancellationToken cancellationToken)
+    protected override async Task<List<CommandResult>?> ExecuteAsync(IModuleContext context, CancellationToken cancellationToken)
     {
         var results = new List<CommandResult>();
 
         foreach (var unitTestProjectFile in context
-                     .Git().RootDirectory!
+                     .Git().RootDirectory
                      .GetFiles(file => file.Path.EndsWith(".csproj", StringComparison.OrdinalIgnoreCase)
                                        && file.Path.Contains("UnitTests", StringComparison.OrdinalIgnoreCase)))
         {
             results.Add(await context.DotNet().Test(new DotNetTestOptions
             {
-                ProjectSolutionDirectoryDllExe = unitTestProjectFile.Path,
-                CommandLogging = CommandLogging.Input | CommandLogging.Error,
-            }, cancellationToken));
+                Project = unitTestProjectFile.Path,
+            }, cancellationToken: cancellationToken));
         }
 
         return results;
diff --git a/EnumerableAsyncProcessor.Pipeline/Modules/UploadPackagesToNugetModule.cs b/EnumerableAsyncProcessor.Pipeline/Modules/UploadPackagesToNugetModule.cs
index 230050d..86179af 100644
--- a/EnumerableAsyncProcessor.Pipeline/Modules/UploadPackagesToNugetModule.cs
+++ b/EnumerableAsyncProcessor.Pipeline/Modules/UploadPackagesToNugetModule.cs
@@ -3,6 +3,7 @@
 using Microsoft.Extensions.Logging;
 using Microsoft.Extensions.Options;
 using ModularPipelines.Attributes;
+using ModularPipelines.Configuration;
 using ModularPipelines.Context;
 using ModularPipelines.DotNet.Extensions;
 using ModularPipelines.DotNet.Options;
@@ -23,57 +24,57 @@ public UploadPackagesToNugetModule(IOptions<NuGetSettings> options)
         _options = options;
     }
 
-    protected override async Task OnBeforeExecute(IPipelineContext context)
+    protected override ModuleConfiguration Configure()
     {
-        var packagePaths = await GetModule<PackagePathsParserModule>();
+        return ModuleConfiguration.Create()
+            .WithSkipWhen(async context =>
+            {
+                var gitVersionInfo = await context.Git().Versioning.GetGitVersioningInformation();
 
-        foreach (var packagePath in packagePaths.Value!)
-        {
-            context.Logger.LogInformation("Uploading {File}", packagePath);
-        }
+                if (gitVersionInfo.BranchName != "main")
+                {
+                    return SkipDecision.Skip("Not on the main branch");
+                }
 
-        await base.OnBeforeExecute(context);
+                var publishPackages = Environment.GetEnvironmentVariable("PUBLISH_PACKAGES");
+
+                if (!bool.TryParse(publishPackages, out var shouldPublishPackages) || !shouldPublishPackages)
+                {
+                    return SkipDecision.Skip("PUBLISH_PACKAGES is not set to true");
+                }
+
+                return SkipDecision.Of(false, "Publishing packages");
+            })
+            .Build();
     }
 
-    protected override async Task<SkipDecision> ShouldSkip(IPipelineContext context)
+    protected override async Task OnBeforeExecuteAsync(IModuleContext context, CancellationToken cancellationToken)
     {
-        var gitVersionInfo = await context.Git().Versioning.GetGitVersioningInformation();
+        var packagePaths = await context.GetModule<PackagePathsParserModule>();
 
-        if (gitVersionInfo.BranchName != "main")
+        foreach (var packagePath in packagePaths.ValueOrDefault ?? [])
         {
-            return true;
-        }
-        
-        var publishPackages =
-            context.Environment.EnvironmentVariables.GetEnvironmentVariable("PUBLISH_PACKAGES")!;
-
-        if (!bool.TryParse(publishPackages, out var shouldPublishPackages) || !shouldPublishPackages)
-        {
-            return true;
+            context.Logger.LogInformation("Uploading {File}", packagePath);
         }
 
-        return false;
+        await base.OnBeforeExecuteAsync(context, cancellationToken);
     }
 
-    protected override async Task<CommandResult[]?> ExecuteAsync(IPipelineContext context, CancellationToken cancellationToken)
+    protected override async Task<CommandResult[]?> ExecuteAsync(IModuleContext context, CancellationToken cancellationToken)
     {
         ArgumentNullException.ThrowIfNull(_options.Value.ApiKey);
 
-        var gitVersionInformation = await context.Git().Versioning.GetGitVersioningInformation();
+        var packagePaths = await context.GetModule<PackagePathsParserModule>();
 
-        if (gitVersionInformation.BranchName != "main")
-        {
-            return await NothingAsync();
-        }
-
-        var packagePaths = await GetModule<PackagePathsParserModule>();
-
-        return await packagePaths.Value!.SelectAsync(async file => await context.DotNet()
-            .Nuget
-            .Push(new DotNetNugetPushOptions(file)
-            {
-                Source = "https://api.nuget.org/v3/index.json",
-                ApiKey = _options.Value.ApiKey!
-            }, cancellationToken), cancellationToken: cancellationToken).ProcessOneAtATime();
+        return await packagePaths.ValueOrDefault!
+            .SelectAsync(file => context.DotNet()
+                .Nuget
+                .Push(new DotNetNugetPushOptions
+                {
+                    Path = file.Path,
+                    Source = "https://api.nuget.org/v3/index.json",
+                    ApiKey = _options.Value.ApiKey!
+                }, cancellationToken: cancellationToken), cancellationToken: cancellationToken)
+            .ProcessOneAtATime();
     }
 }
diff --git a/EnumerableAsyncProcessor.Pipeline/Program.cs b/EnumerableAsyncProcessor.Pipeline/Program.cs
index 7b20956..dfe0c87 100644
--- a/EnumerableAsyncProcessor.Pipeline/Program.cs
+++ b/EnumerableAsyncProcessor.Pipeline/Program.cs
@@ -2,36 +2,35 @@
 using Microsoft.Extensions.DependencyInjection;
 using Microsoft.Extensions.Hosting;
 using ModularPipelines.Extensions;
-using ModularPipelines.Host;
 using EnumerableAsyncProcessor.Pipeline.Modules;
 using EnumerableAsyncProcessor.Pipeline.Modules.LocalMachine;
 using EnumerableAsyncProcessor.Pipeline.Settings;
 
-await PipelineHostBuilder.Create()
-    .ConfigureAppConfiguration((_, builder) =>
-    {
-        builder.AddJsonFile("appsettings.json")
-            .AddUserSecrets<Program>()
-            .AddEnvironmentVariables();
-    })
-    .ConfigureServices((context, collection) =>
-    {
-        collection.Configure<NuGetSettings>(context.Configuration.GetSection("NuGet"));
+var builder = ModularPipelines.Pipeline.CreateBuilder(args);
 
-        if (context.HostingEnvironment.IsDevelopment())
-        {
-            collection.AddModule<CreateLocalNugetFolderModule>()
-                .AddModule<AddLocalNugetSourceModule>()
-                .AddModule<UploadPackagesToLocalNuGetModule>();
-        }
-        else
-        {
-            collection.AddModule<UploadPackagesToNugetModule>();
-        }
-    })
-    .AddModule<RunUnitTestsModule>()
+builder.Configuration
+    .AddJsonFile("appsettings.json")
+    .AddUserSecrets<Program>()
+    .AddEnvironmentVariables();
+
+builder.Services.Configure<NuGetSettings>(builder.Configuration.GetSection("NuGet"));
+
+if (builder.Environment.IsDevelopment())
+{
+    builder.AddModule<CreateLocalNugetFolderModule>()
+        .AddModule<AddLocalNugetSourceModule>()
+        .AddModule<UploadPackagesToLocalNuGetModule>();
+}
+else
+{
+    builder.AddModule<UploadPackagesToNugetModule>();
+}
+
+builder.AddModule<RunUnitTestsModule>()
     .AddModule<NugetVersionGeneratorModule>()
     .AddModule<PackProjectsModule>()
     .AddModule<PackageFilesRemovalModule>()
-    .AddModule<PackagePathsParserModule>()
-    .ExecutePipelineAsync();
+    .AddModule<PackagePathsParserModule>();
+
+await using var pipeline = builder.Build();
+await pipeline.RunAsync();
diff --git a/EnumerableAsyncProcessor.UnitTests/DisposalRegressionTests.cs b/EnumerableAsyncProcessor.UnitTests/DisposalRegressionTests.cs
new file mode 100644
index 0000000..1683625
--- /dev/null
+++ b/EnumerableAsyncProcessor.UnitTests/DisposalRegressionTests.cs
@@ -0,0 +1,130 @@
+using System;
+using System.Diagnostics;
+using System.Linq;
+using System.Threading.Tasks;
+using EnumerableAsyncProcessor.Extensions;
+
+namespace EnumerableAsyncProcessor.UnitTests;
+
+/// <summary>
+/// Guards the disposal and cancellation semantics:
+/// - disposal must actually cancel pending work (a guard-ordering bug previously made it a no-op),
+/// - synchronous Dispose must not block (it previously ran sync-over-async with a 30s wait),
+/// - CancelAll on a result processor must not block the calling thread (it previously invoked
+///   blocking Dispose via the cancellation callback).
+/// </summary>
+public class DisposalRegressionTests
+{
+    [Test]
+    public async Task DisposeAsync_Cancels_Unstarted_Tasks_And_Completes_Promptly()
+    {
+        var blocker = new TaskCompletionSource(TaskCreationOptions.RunContinuationsAsynchronously);
+        var firstItemStarted = new TaskCompletionSource(TaskCreationOptions.RunContinuationsAsynchronously);
+
+        var processor = Enumerable.Range(0, 10).ToList()
+            .ForEachAsync(async _ =>
+            {
+                firstItemStarted.TrySetResult();
+                await blocker.Task;
+            })
+            .ProcessInParallel(1);
+
+        await firstItemStarted.Task;
+
+        var stopwatch = Stopwatch.StartNew();
+        var disposeTask = processor.DisposeAsync();
+
+        // Cancellation happens synchronously inside DisposeAsync, before it waits for in-flight work.
+        // Previously nothing was cancelled and disposal just waited for tasks to finish naturally.
+        await Assert.That(processor.GetEnumerableTasks().Count(x => x.IsCanceled)).IsEqualTo(10);
+
+        blocker.TrySetResult();
+        await disposeTask;
+        stopwatch.Stop();
+
+        await Assert.That(stopwatch.Elapsed).IsLessThan(TimeSpan.FromSeconds(5));
+    }
+
+    [Test]
+    public async Task Synchronous_Dispose_Returns_Without_Blocking_On_InFlight_Work()
+    {
+        var blocker = new TaskCompletionSource(TaskCreationOptions.RunContinuationsAsynchronously);
+        var firstItemStarted = new TaskCompletionSource(TaskCreationOptions.RunContinuationsAsynchronously);
+
+        var processor = Enumerable.Range(0, 10).ToList()
+            .ForEachAsync(async _ =>
+            {
+                firstItemStarted.TrySetResult();
+                await blocker.Task;
+            })
+            .ProcessInParallel(1);
+
+        await firstItemStarted.Task;
+
+        try
+        {
+            var stopwatch = Stopwatch.StartNew();
+            processor.Dispose();
+            stopwatch.Stop();
+
+            await Assert.That(stopwatch.Elapsed).IsLessThan(TimeSpan.FromSeconds(2));
+            await Assert.That(processor.GetEnumerableTasks().Count(x => x.IsCanceled)).IsEqualTo(10);
+        }
+        finally
+        {
+            blocker.TrySetResult();
+        }
+    }
+
+    [Test]
+    public async Task CancelAll_On_Result_Processor_Does_Not_Block_And_Cancels_Pending_Tasks()
+    {
+        var blocker = new TaskCompletionSource(TaskCreationOptions.RunContinuationsAsynchronously);
+        var firstItemStarted = new TaskCompletionSource(TaskCreationOptions.RunContinuationsAsynchronously);
+
+        var processor = Enumerable.Range(0, 10).ToList()
+            .SelectAsync(async i =>
+            {
+                firstItemStarted.TrySetResult();
+                await blocker.Task;
+                return i;
+            })
+            .ProcessInParallel(1);
+
+        await firstItemStarted.Task;
+
+        try
+        {
+            var stopwatch = Stopwatch.StartNew();
+            processor.CancelAll();
+            stopwatch.Stop();
+
+            await Assert.That(stopwatch.Elapsed).IsLessThan(TimeSpan.FromSeconds(2));
+            await Assert.That(processor.GetEnumerableTasks().Count(x => x.IsCanceled)).IsEqualTo(10);
+            await Assert.ThrowsAsync<TaskCanceledException>(() => processor.GetResultsAsync());
+        }
+        finally
+        {
+            blocker.TrySetResult();
+        }
+
+        await processor.DisposeAsync();
+    }
+
+    [Test]
+    public async Task Disposal_Is_Idempotent_And_Safe_In_Any_Order()
+    {
+        var processor = Enumerable.Range(0, 5).ToList()
+            .ForEachAsync(_ => Task.CompletedTask)
+            .ProcessInParallel();
+
+        await processor.WaitAsync();
+
+        await processor.DisposeAsync();
+        await processor.DisposeAsync();
+        processor.Dispose();
+        processor.CancelAll();
+
+        await Assert.That(processor.GetEnumerableTasks().Count(x => x.IsCompletedSuccessfully)).IsEqualTo(5);
+    }
+}
diff --git a/EnumerableAsyncProcessor.UnitTests/EnumerableAsyncProcessor.UnitTests.csproj b/EnumerableAsyncProcessor.UnitTests/EnumerableAsyncProcessor.UnitTests.csproj
index ddd2fda..71bfe6f 100644
--- a/EnumerableAsyncProcessor.UnitTests/EnumerableAsyncProcessor.UnitTests.csproj
+++ b/EnumerableAsyncProcessor.UnitTests/EnumerableAsyncProcessor.UnitTests.csproj
@@ -1,7 +1,8 @@
 <Project Sdk="Microsoft.NET.Sdk">
 
     <PropertyGroup>
-        <TargetFramework>net9.0</TargetFramework>
+        <!-- net8.0 also exercises the pre-net9 completion-order streaming path in ToIAsyncEnumerable -->
+        <TargetFrameworks>net9.0;net8.0</TargetFrameworks>
         <Nullable>enable</Nullable>
         <IsPackable>false</IsPackable>
         <!-- Do not warn about non-strong named dependencies, as we target .NET (not .NET Framework).
@@ -14,7 +15,7 @@
     </ItemGroup>
 
     <ItemGroup>
-      <PackageReference Include="TUnit" Version="0.53.0" />
+      <PackageReference Include="TUnit" Version="1.61.15" />
     </ItemGroup>
 
 </Project>
diff --git a/EnumerableAsyncProcessor.UnitTests/ExceptionFidelityTests.cs b/EnumerableAsyncProcessor.UnitTests/ExceptionFidelityTests.cs
new file mode 100644
index 0000000..14de4b7
--- /dev/null
+++ b/EnumerableAsyncProcessor.UnitTests/ExceptionFidelityTests.cs
@@ -0,0 +1,115 @@
+using System;
+using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
+using EnumerableAsyncProcessor.Extensions;
+
+namespace EnumerableAsyncProcessor.UnitTests;
+
+/// <summary>
+/// Guards exception propagation fidelity:
+/// - a multi-fault task must surface every inner exception (GetBaseException previously kept only one),
+/// - one failing item must not stop the remaining items from processing,
+/// - completion sources must run continuations asynchronously so user continuations
+///   cannot run inline on the completing thread.
+/// </summary>
+public class ExceptionFidelityTests
+{
+    [Test]
+    public async Task All_Exceptions_From_A_MultiFault_Task_Are_Preserved()
+    {
+        await using var processor = new[] { 1 }
+            .ForEachAsync(_ => Task.WhenAll(
+                Task.FromException(new InvalidOperationException("first failure")),
+                Task.FromException(new InvalidOperationException("second failure"))))
+            .ProcessOneAtATime();
+
+        Exception? caught = null;
+        try
+        {
+            await processor.WaitAsync();
+        }
+        catch (Exception exception)
+        {
+            caught = exception;
+        }
+
+        await Assert.That(caught).IsNotNull();
+
+        var itemTask = processor.GetEnumerableTasks().Single();
+        var messages = itemTask.Exception!.InnerExceptions.Select(e => e.Message).ToList();
+
+        await Assert.That(messages.Count).IsEqualTo(2);
+        await Assert.That(messages.Contains("first failure")).IsTrue();
+        await Assert.That(messages.Contains("second failure")).IsTrue();
+    }
+
+    [Test]
+    public async Task Synchronous_Selector_Throw_Faults_Only_That_Item()
+    {
+        await using var processor = Enumerable.Range(0, 10).ToList()
+            .ForEachAsync(i => i == 5
+                ? throw new InvalidOperationException("item 5 failed")
+                : Task.CompletedTask)
+            .ProcessInParallel(2);
+
+        Exception? caught = null;
+        try
+        {
+            await processor.WaitAsync();
+        }
+        catch (Exception exception)
+        {
+            caught = exception;
+        }
+
+        await Assert.That(caught).IsNotNull();
+        await Assert.That(processor.GetEnumerableTasks().Count(x => x.IsCompletedSuccessfully)).IsEqualTo(9);
+        await Assert.That(processor.GetEnumerableTasks().Count(x => x.IsFaulted)).IsEqualTo(1);
+    }
+
+    [Test]
+    public async Task Failed_Items_Do_Not_Prevent_Remaining_Items_From_Processing()
+    {
+        var processedCount = 0;
+
+        await using var processor = Enumerable.Range(0, 30).ToList()
+            .ForEachAsync(async i =>
+            {
+                Interlocked.Increment(ref processedCount);
+                await Task.Yield();
+
+                if (i % 3 == 0)
+                {
+                    throw new InvalidOperationException($"item {i} failed");
+                }
+            })
+            .ProcessInParallel(maxConcurrency: 3);
+
+        try
+        {
+            await processor.WaitAsync();
+        }
+        catch (Exception)
+        {
+            // Expected - a third of the items fail
+        }
+
+        await Assert.That(processedCount).IsEqualTo(30);
+        await Assert.That(processor.GetEnumerableTasks().Count(x => x.IsCompletedSuccessfully)).IsEqualTo(20);
+        await Assert.That(processor.GetEnumerableTasks().Count(x => x.IsFaulted)).IsEqualTo(10);
+    }
+
+    [Test]
+    public async Task Item_Task_Continuations_Are_Not_Forced_Inline()
+    {
+        await using var processor = new[] { 1 }
+            .ForEachAsync(_ => Task.CompletedTask)
+            .ProcessOneAtATime();
+
+        await processor.WaitAsync();
+
+        var itemTask = processor.GetEnumerableTasks().Single();
+        await Assert.That(itemTask.CreationOptions.HasFlag(TaskCreationOptions.RunContinuationsAsynchronously)).IsTrue();
+    }
+}
diff --git a/EnumerableAsyncProcessor.UnitTests/InputEnumerationRegressionTests.cs b/EnumerableAsyncProcessor.UnitTests/InputEnumerationRegressionTests.cs
new file mode 100644
index 0000000..2b8f272
--- /dev/null
+++ b/EnumerableAsyncProcessor.UnitTests/InputEnumerationRegressionTests.cs
@@ -0,0 +1,136 @@
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading.Tasks;
+using EnumerableAsyncProcessor.Extensions;
+
+namespace EnumerableAsyncProcessor.UnitTests;
+
+/// <summary>
+/// Guards against the input enumerable being lazily re-enumerated by the processor internals.
+/// Historically the input was enumerated up to five times (validation, processing, awaiting,
+/// cancellation and disposal), which broke one-shot sources and re-ran side effects.
+/// </summary>
+public class InputEnumerationRegressionTests
+{
+    [Test]
+    public async Task Input_Enumerable_Is_Enumerated_Exactly_Once()
+    {
+        var source = new TrackingEnumerable(20);
+
+        await using (var processor = source.ForEachAsync(_ => Task.CompletedTask).ProcessInParallel(4))
+        {
+            await processor.WaitAsync();
+
+            // These all re-enumerated the input in previous versions
+            _ = processor.GetEnumerableTasks().ToList();
+            _ = processor.GetEnumerableTasks().ToList();
+            processor.CancelAll();
+        }
+
+        await Assert.That(source.EnumerationCount).IsEqualTo(1);
+        await Assert.That(source.ItemsYielded).IsEqualTo(20);
+    }
+
+    [Test]
+    public async Task OneShot_Enumerable_Processes_All_Items()
+    {
+        var source = new OneShotEnumerable<int>(Enumerable.Range(0, 10));
+
+        await using var processor = source.SelectAsync(i => Task.FromResult(i * 2)).ProcessInParallel(2);
+        var results = await processor.GetResultsAsync();
+
+        await Assert.That(results.OrderBy(x => x).SequenceEqual(Enumerable.Range(0, 10).Select(i => i * 2))).IsTrue();
+    }
+
+    [Test]
+    public async Task Result_Processor_Enumerates_Input_Exactly_Once()
+    {
+        var source = new TrackingEnumerable(10);
+
+        await using (var processor = source.SelectAsync(i => Task.FromResult(i)).ProcessInParallel())
+        {
+            _ = await processor.GetResultsAsync();
+            _ = processor.GetEnumerableTasks().ToList();
+            processor.CancelAll();
+        }
+
+        await Assert.That(source.EnumerationCount).IsEqualTo(1);
+    }
+
+    [Test]
+    public async Task Iterator_Exception_Surfaces_At_Build_Time_Instead_Of_Hanging_Awaiters()
+    {
+        InvalidOperationException? caught = null;
+
+        try
+        {
+            _ = FaultyItems().ForEachAsync(_ => Task.CompletedTask).ProcessInParallel();
+        }
+        catch (InvalidOperationException exception)
+        {
+            caught = exception;
+        }
+
+        await Assert.That(caught).IsNotNull();
+        await Assert.That(caught!.Message).IsEqualTo("enumeration failed");
+    }
+
+    private static IEnumerable<int> FaultyItems()
+    {
+        yield return 1;
+        yield return 2;
+        throw new InvalidOperationException("enumeration failed");
+    }
+
+    private sealed class TrackingEnumerable : IEnumerable<int>
+    {
+        private readonly int _count;
+
+        public int EnumerationCount { get; private set; }
+        public int ItemsYielded { get; private set; }
+
+        public TrackingEnumerable(int count)
+        {
+            _count = count;
+        }
+
+        public IEnumerator<int> GetEnumerator()
+        {
+            EnumerationCount++;
+
+            for (var i = 0; i < _count; i++)
+            {
+                ItemsYielded++;
+                yield return i;
+            }
+        }
+
+        IEnumerator IEnumerable.GetEnumerator() => GetEnumerator();
+    }
+
+    private sealed class OneShotEnumerable<T> : IEnumerable<T>
+    {
+        private readonly IEnumerable<T> _items;
+        private bool _enumerated;
+
+        public OneShotEnumerable(IEnumerable<T> items)
+        {
+            _items = items;
+        }
+
+        public IEnumerator<T> GetEnumerator()
+        {
+            if (_enumerated)
+            {
+                throw new InvalidOperationException("This enumerable can only be enumerated once.");
+            }
+
+            _enumerated = true;
+            return _items.GetEnumerator();
+        }
+
+        IEnumerator IEnumerable.GetEnumerator() => GetEnumerator();
+    }
+}
diff --git a/EnumerableAsyncProcessor.UnitTests/StreamingResultsTests.cs b/EnumerableAsyncProcessor.UnitTests/StreamingResultsTests.cs
new file mode 100644
index 0000000..15700fb
--- /dev/null
+++ b/EnumerableAsyncProcessor.UnitTests/StreamingResultsTests.cs
@@ -0,0 +1,111 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
+using EnumerableAsyncProcessor.Extensions;
+
+namespace EnumerableAsyncProcessor.UnitTests;
+
+/// <summary>
+/// Guards GetResultsAsyncEnumerable: results must stream in completion order (not input order),
+/// every result must arrive exactly once, and enumeration must honour cancellation.
+/// The pre-net9 implementation is a separate code path (completion-order buckets instead of
+/// Task.WhenEach), so this suite runs on every target framework of the test project.
+/// </summary>
+public class StreamingResultsTests
+{
+    [Test]
+    public async Task Results_Stream_In_Completion_Order()
+    {
+        var signals = Enumerable.Range(0, 3)
+            .Select(_ => new TaskCompletionSource(TaskCreationOptions.RunContinuationsAsynchronously))
+            .ToArray();
+
+        await using var processor = Enumerable.Range(0, 3).ToList()
+            .SelectAsync(async i =>
+            {
+                await signals[i].Task;
+                return i;
+            })
+            .ProcessInParallel();
+
+        var enumerator = processor.GetResultsAsyncEnumerable().GetAsyncEnumerator();
+
+        await using (enumerator)
+        {
+            signals[2].TrySetResult();
+            await Assert.That(await enumerator.MoveNextAsync()).IsTrue();
+            await Assert.That(enumerator.Current).IsEqualTo(2);
+
+            signals[0].TrySetResult();
+            await Assert.That(await enumerator.MoveNextAsync()).IsTrue();
+            await Assert.That(enumerator.Current).IsEqualTo(0);
+
+            signals[1].TrySetResult();
+            await Assert.That(await enumerator.MoveNextAsync()).IsTrue();
+            await Assert.That(enumerator.Current).IsEqualTo(1);
+
+            await Assert.That(await enumerator.MoveNextAsync()).IsFalse();
+        }
+    }
+
+    [Test]
+    public async Task Streaming_Yields_Every_Result_Exactly_Once()
+    {
+        const int itemCount = 1_000;
+
+        await using var processor = Enumerable.Range(0, itemCount).ToList()
+            .SelectAsync(i => Task.FromResult(i))
+            .ProcessInParallel();
+
+        var received = new List<int>();
+
+        await foreach (var result in processor.GetResultsAsyncEnumerable())
+        {
+            received.Add(result);
+        }
+
+        await Assert.That(received.Count).IsEqualTo(itemCount);
+        await Assert.That(received.Distinct().Count()).IsEqualTo(itemCount);
+    }
+
+    [Test]
+    public async Task Streaming_Honours_Cancellation_Token()
+    {
+        var blocker = new TaskCompletionSource(TaskCreationOptions.RunContinuationsAsynchronously);
+
+        var processor = Enumerable.Range(0, 5).ToList()
+            .SelectAsync(async i =>
+            {
+                await blocker.Task;
+                return i;
+            })
+            .ProcessInParallel();
+
+        try
+        {
+            using var cancellationTokenSource = new CancellationTokenSource(TimeSpan.FromMilliseconds(200));
+
+            OperationCanceledException? caught = null;
+            try
+            {
+                await foreach (var _ in processor.GetResultsAsyncEnumerable().WithCancellation(cancellationTokenSource.Token))
+                {
+                }
+            }
+            catch (OperationCanceledException exception)
+            {
+                caught = exception;
+            }
+
+            await Assert.That(caught).IsNotNull();
+        }
+        finally
+        {
+            blocker.TrySetResult();
+        }
+
+        await processor.DisposeAsync();
+    }
+}
diff --git a/EnumerableAsyncProcessor.UnitTests/TaskWrapperStructValidationTests.cs b/EnumerableAsyncProcessor.UnitTests/TaskWrapperStructValidationTests.cs
index feeedce..43e01a5 100644
--- a/EnumerableAsyncProcessor.UnitTests/TaskWrapperStructValidationTests.cs
+++ b/EnumerableAsyncProcessor.UnitTests/TaskWrapperStructValidationTests.cs
@@ -59,23 +59,6 @@ public async Task ItemTaskWrapper_ProcessesWithInput()
         await Assert.That(tcs.Task.IsCompletedSuccessfully).IsTrue();
     }
 
-    [Test]
-    public async Task TaskWrapper_EqualityWorks()
-    {
-        // Arrange
-        Func<Task> taskFactory = () => Task.CompletedTask;
-        var tcs = new TaskCompletionSource();
-        var wrapper1 = new ActionTaskWrapper(taskFactory, tcs);
-        var wrapper2 = new ActionTaskWrapper(taskFactory, tcs);
-        var wrapper3 = new ActionTaskWrapper(() => Task.CompletedTask, new TaskCompletionSource());
-
-        // Act & Assert
-        await Assert.That(wrapper1.Equals(wrapper2)).IsTrue();
-        await Assert.That(wrapper1 == wrapper2).IsTrue();
-        await Assert.That(wrapper1.Equals(wrapper3)).IsFalse();
-        await Assert.That(wrapper1 == wrapper3).IsFalse();
-    }
-
     [Test]
     public async Task TaskWrapper_ArrayStorage_WorksWithoutBoxing()
     {
@@ -136,4 +119,4 @@ public async Task TaskWrapper_MemoryFootprint_IsSmallerThanObjects()
         var hasNonNullFactory = wrappers[0].TaskFactory != null; // Prevent optimization
         await Assert.That(hasNonNullFactory).IsTrue();
     }
-}
\ No newline at end of file
+}
diff --git a/EnumerableAsyncProcessor.UnitTests/ValidationRegressionTests.cs b/EnumerableAsyncProcessor.UnitTests/ValidationRegressionTests.cs
new file mode 100644
index 0000000..8e70e93
--- /dev/null
+++ b/EnumerableAsyncProcessor.UnitTests/ValidationRegressionTests.cs
@@ -0,0 +1,125 @@
+using System;
+using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
+using EnumerableAsyncProcessor.Builders;
+using EnumerableAsyncProcessor.Extensions;
+
+namespace EnumerableAsyncProcessor.UnitTests;
+
+/// <summary>
+/// Guards argument validation:
+/// - invalid parallelism/batch/timespan values must throw at build time on every processor variant
+///   (the result variants previously skipped validation, and maxConcurrency: 0 previously surfaced
+///   as a semaphore error mid-processing),
+/// - the old arbitrary caps (10,000 tasks / 10,000 batch size) must stay removed,
+/// - an already-cancelled token must fail cleanly at build time.
+/// </summary>
+public class ValidationRegressionTests
+{
+    [Test]
+    public async Task Zero_Or_Negative_MaxConcurrency_Throws_At_Build_Time()
+    {
+        await AssertThrows<ArgumentOutOfRangeException>(() =>
+            new[] { 1 }.ForEachAsync(_ => Task.CompletedTask).ProcessInParallel(maxConcurrency: 0));
+
+        await AssertThrows<ArgumentOutOfRangeException>(() =>
+            new[] { 1 }.ForEachAsync(_ => Task.CompletedTask).ProcessInParallel(maxConcurrency: -1));
+
+        await AssertThrows<ArgumentOutOfRangeException>(() =>
+            new[] { 1 }.SelectAsync(i => Task.FromResult(i)).ProcessInParallel(maxConcurrency: 0));
+    }
+
+    [Test]
+    public async Task Zero_Parallelism_Throws_For_Void_And_Result_RateLimited_Processors()
+    {
+        await AssertThrows<ArgumentOutOfRangeException>(() =>
+            new[] { 1 }.ForEachAsync(_ => Task.CompletedTask).ProcessInParallel(0));
+
+        // The result variant previously skipped this validation entirely
+        await AssertThrows<ArgumentOutOfRangeException>(() =>
+            new[] { 1 }.SelectAsync(i => Task.FromResult(i)).ProcessInParallel(0));
+    }
+
+    [Test]
+    public async Task Invalid_Timed_RateLimit_Arguments_Throw_For_Void_And_Result_Processors()
+    {
+        await AssertThrows<ArgumentOutOfRangeException>(() =>
+            new[] { 1 }.ForEachAsync(_ => Task.CompletedTask).ProcessInParallel(5, TimeSpan.FromSeconds(-1)));
+
+        // The result variant previously skipped this validation entirely
+        await AssertThrows<ArgumentOutOfRangeException>(() =>
+            new[] { 1 }.SelectAsync(i => Task.FromResult(i)).ProcessInParallel(0, TimeSpan.FromSeconds(1)));
+    }
+
+    [Test]
+    public async Task Zero_Batch_Size_Throws_For_Void_And_Result_Processors()
+    {
+        await AssertThrows<ArgumentOutOfRangeException>(() =>
+            new[] { 1 }.ForEachAsync(_ => Task.CompletedTask).ProcessInBatches(0));
+
+        // The result variant previously skipped this validation entirely
+        await AssertThrows<ArgumentOutOfRangeException>(() =>
+            new[] { 1 }.SelectAsync(i => Task.FromResult(i)).ProcessInBatches(0));
+    }
+
+    [Test]
+    public async Task Large_Execution_Counts_Are_Not_Capped()
+    {
+        // Counts above 10,000 previously threw to "prevent system overload"
+        var executed = 0;
+
+        await using var processor = AsyncProcessorBuilder.WithExecutionCount(15_000)
+            .ForEachAsync(() =>
+            {
+                Interlocked.Increment(ref executed);
+                return Task.CompletedTask;
+            })
+            .ProcessInParallel(64);
+
+        await processor.WaitAsync();
+
+        await Assert.That(executed).IsEqualTo(15_000);
+    }
+
+    [Test]
+    public async Task Large_Batch_Sizes_Are_Not_Capped()
+    {
+        // Batch sizes above 10,000 previously threw
+        await using var processor = Enumerable.Range(0, 100).ToList()
+            .ForEachAsync(_ => Task.CompletedTask)
+            .ProcessInBatches(12_000);
+
+        await processor.WaitAsync();
+
+        await Assert.That(processor.GetEnumerableTasks().Count(x => x.IsCompletedSuccessfully)).IsEqualTo(100);
+    }
+
+    [Test]
+    public async Task Already_Cancelled_Token_Fails_Cleanly_At_Build_Time()
+    {
+        using var cancellationTokenSource = new CancellationTokenSource();
+        cancellationTokenSource.Cancel();
+
+        // Must throw a clear ArgumentException - never a NullReferenceException from a
+        // cancellation callback firing on a partially constructed processor
+        await AssertThrows<ArgumentException>(() =>
+            new[] { 1 }.ForEachAsync(_ => Task.CompletedTask, cancellationTokenSource.Token).ProcessInParallel());
+    }
+
+    private static async Task AssertThrows<TException>(Func<object> action) where TException : Exception
+    {
+        TException? caught = null;
+
+        try
+        {
+            _ = action();
+        }
+        catch (TException exception)
+        {
+            caught = exception;
+        }
+
+        await Assert.That(caught).IsNotNull();
+    }
+}
diff --git a/EnumerableAsyncProcessor.UnitTests/WorkerPoolBehaviourTests.cs b/EnumerableAsyncProcessor.UnitTests/WorkerPoolBehaviourTests.cs
new file mode 100644
index 0000000..0148a4f
--- /dev/null
+++ b/EnumerableAsyncProcessor.UnitTests/WorkerPoolBehaviourTests.cs
@@ -0,0 +1,137 @@
+using System;
+using System.Collections.Concurrent;
+using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
+using EnumerableAsyncProcessor.Extensions;
+
+namespace EnumerableAsyncProcessor.UnitTests;
+
+/// <summary>
+/// Guards the worker-pool execution model used by the rate-limited, timed and
+/// throttled-parallel processors: the concurrency limit must hold, every item must be
+/// processed exactly once, oversized limits must not break anything, and cancellation
+/// must promptly cancel the unprocessed remainder.
+/// </summary>
+public class WorkerPoolBehaviourTests
+{
+    [Test, Repeat(3)]
+    public async Task MaxConcurrency_Path_Obeys_The_Limit_And_Processes_Everything(CancellationToken cancellationToken)
+    {
+        const int itemCount = 100;
+        const int limit = 8;
+
+        var currentlyRunning = 0;
+        var maxObserved = 0;
+
+        await using var processor = Enumerable.Range(0, itemCount).ToList()
+            .ForEachAsync(async _ =>
+            {
+                var running = Interlocked.Increment(ref currentlyRunning);
+
+                int snapshot;
+                while (running > (snapshot = Volatile.Read(ref maxObserved)))
+                {
+                    Interlocked.CompareExchange(ref maxObserved, running, snapshot);
+                }
+
+                await Task.Delay(10, cancellationToken);
+                Interlocked.Decrement(ref currentlyRunning);
+            }, cancellationToken)
+            .ProcessInParallel(maxConcurrency: limit);
+
+        await processor.WaitAsync();
+
+        await Assert.That(maxObserved).IsLessThanOrEqualTo(limit);
+        await Assert.That(processor.GetEnumerableTasks().Count(x => x.IsCompletedSuccessfully)).IsEqualTo(itemCount);
+    }
+
+    [Test]
+    public async Task Every_Item_Is_Processed_Exactly_Once_Under_Rate_Limiting()
+    {
+        const int itemCount = 500;
+
+        var processedItems = new ConcurrentBag<int>();
+
+        await using var processor = Enumerable.Range(0, itemCount).ToList()
+            .ForEachAsync(async i =>
+            {
+                processedItems.Add(i);
+                await Task.Yield();
+            })
+            .ProcessInParallel(16);
+
+        await processor.WaitAsync();
+
+        await Assert.That(processedItems.Count).IsEqualTo(itemCount);
+        await Assert.That(processedItems.Distinct().Count()).IsEqualTo(itemCount);
+    }
+
+    [Test]
+    public async Task Parallelism_Limit_Larger_Than_Item_Count_Completes_Normally()
+    {
+        await using var rateLimited = Enumerable.Range(0, 5).ToList()
+            .ForEachAsync(_ => Task.CompletedTask)
+            .ProcessInParallel(100);
+        await rateLimited.WaitAsync();
+
+        await using var throttled = Enumerable.Range(0, 5).ToList()
+            .SelectAsync(i => Task.FromResult(i))
+            .ProcessInParallel(maxConcurrency: 100);
+        var results = await throttled.GetResultsAsync();
+
+        await Assert.That(rateLimited.GetEnumerableTasks().Count(x => x.IsCompletedSuccessfully)).IsEqualTo(5);
+        await Assert.That(results.Length).IsEqualTo(5);
+    }
+
+    [Test]
+    public async Task Timed_RateLimited_Processor_Cancels_Unprocessed_Items_Promptly()
+    {
+        using var cancellationTokenSource = new CancellationTokenSource();
+        var firstItemStarted = new TaskCompletionSource(TaskCreationOptions.RunContinuationsAsynchronously);
+
+        var processor = Enumerable.Range(0, 20).ToList()
+            .ForEachAsync(_ =>
+            {
+                firstItemStarted.TrySetResult();
+                return Task.CompletedTask;
+            }, cancellationTokenSource.Token)
+            .ProcessInParallel(1, TimeSpan.FromMilliseconds(200));
+
+        await firstItemStarted.Task;
+        cancellationTokenSource.Cancel();
+
+        Exception? caught = null;
+        try
+        {
+            await processor.WaitAsync();
+        }
+        catch (OperationCanceledException exception)
+        {
+            caught = exception;
+        }
+
+        await Assert.That(caught).IsNotNull();
+        await Assert.That(processor.GetEnumerableTasks().Any(x => x.IsCanceled)).IsTrue();
+        await Assert.That(processor.GetEnumerableTasks().Count(x => !x.IsCompleted)).IsEqualTo(0);
+
+        await processor.DisposeAsync();
+    }
+
+    [Test]
+    public async Task Result_Order_Is_Preserved_Regardless_Of_Completion_Order()
+    {
+        await using var processor = Enumerable.Range(0, 50).ToList()
+            .SelectAsync(async i =>
+            {
+                // Later items complete sooner
+                await Task.Delay(50 - i);
+                return i;
+            })
+            .ProcessInParallel(maxConcurrency: 50);
+
+        var results = await processor.GetResultsAsync();
+
+        await Assert.That(results.SequenceEqual(Enumerable.Range(0, 50))).IsTrue();
+    }
+}
diff --git a/EnumerableAsyncProcessor/EnumerableAsyncProcessor.csproj b/EnumerableAsyncProcessor/EnumerableAsyncProcessor.csproj
index bed5114..aed68d7 100644
--- a/EnumerableAsyncProcessor/EnumerableAsyncProcessor.csproj
+++ b/EnumerableAsyncProcessor/EnumerableAsyncProcessor.csproj
@@ -4,7 +4,7 @@
         <TargetFrameworks>net6.0;net8.0;net9.0;netstandard2.0</TargetFrameworks>
         <ImplicitUsings>enable</ImplicitUsings>
         <Nullable>enable</Nullable>
-        <LangVersion>preview</LangVersion>
+        <LangVersion>latest</LangVersion>
         <Version>99.99.99</Version>
     </PropertyGroup>
 
diff --git a/EnumerableAsyncProcessor/Extensions/AsyncProcessorExtensions.cs b/EnumerableAsyncProcessor/Extensions/AsyncProcessorExtensions.cs
deleted file mode 100644
index aa046eb..0000000
--- a/EnumerableAsyncProcessor/Extensions/AsyncProcessorExtensions.cs
+++ /dev/null
@@ -1,20 +0,0 @@
-using EnumerableAsyncProcessor.Interfaces;
-using EnumerableAsyncProcessor.RunnableProcessors.Abstract;
-using EnumerableAsyncProcessor.RunnableProcessors.ResultProcessors.Abstract;
-
-namespace EnumerableAsyncProcessor.Extensions;
-
-internal static class AsyncProcessorExtensions
-{
-    internal static IAsyncProcessor StartProcessing(this AbstractAsyncProcessorBase processor)
-    {
-        _ = processor.Process();
-        return processor;
-    }
-    
-    internal static IAsyncProcessor<T1> StartProcessing<T1>(this ResultAbstractAsyncProcessorBase<T1> processor)
-    {
-        _ = processor.Process();
-        return processor;
-    }
-}
\ No newline at end of file
diff --git a/EnumerableAsyncProcessor/Extensions/EnumerableExtensions.cs b/EnumerableAsyncProcessor/Extensions/EnumerableExtensions.cs
index 7e0a438..c333f7a 100644
--- a/EnumerableAsyncProcessor/Extensions/EnumerableExtensions.cs
+++ b/EnumerableAsyncProcessor/Extensions/EnumerableExtensions.cs
@@ -140,41 +140,32 @@ internal static async IAsyncEnumerable<T> ToIAsyncEnumerable<T>(this IEnumerable
             yield return task.Result;
         }
 #else
-        var managedTasksList = tasks.ToList();
+        // Interleaving via completion-order buckets: each task's continuation claims the next
+        // bucket, so streaming N tasks is O(N) rather than the O(N^2) of a WhenAny loop.
+        var inputTasks = tasks.ToList();
 
-        // Create a cancellation task that will complete when cancellation is requested
-        using var cancellationTcs = new CancellationTokenSource();
-        var cancellationTask = Task.Delay(Timeout.Infinite, cancellationTcs.Token);
-        
-        // Register callback to trigger the cancellation task
-        using var registration = cancellationToken.Register(() => cancellationTcs.Cancel());
+        var buckets = new TaskCompletionSource<Task<T>>[inputTasks.Count];
+        for (var i = 0; i < buckets.Length; i++)
+        {
+            buckets[i] = new TaskCompletionSource<Task<T>>(TaskCreationOptions.RunContinuationsAsynchronously);
+        }
 
-        while (managedTasksList.Count != 0)
+        var nextBucketIndex = -1;
+        foreach (var task in inputTasks)
         {
-            // Check for cancellation before each iteration
-            cancellationToken.ThrowIfCancellationRequested();
-            
-            // Include the cancellation task in WhenAny
-            var allTasks = new List<Task>(managedTasksList.Count + 1);
-            allTasks.AddRange(managedTasksList);
-            allTasks.Add(cancellationTask);
-            
-            var finishedTask = await Task.WhenAny(allTasks).ConfigureAwait(false);
-            
-            // If the cancellation task completed, throw cancellation
-            if (finishedTask == cancellationTask)
-            {
-                cancellationToken.ThrowIfCancellationRequested();
-                // This should not happen as cancellation should throw above, but as a safety measure:
-                throw new OperationCanceledException(cancellationToken);
-            }
-            
-            // Remove and yield the completed task
-            var completedTask = (Task<T>)finishedTask;
-            managedTasksList.Remove(completedTask);
+            _ = task.ContinueWith(
+                completedTask => buckets[Interlocked.Increment(ref nextBucketIndex)].TrySetResult(completedTask),
+                CancellationToken.None,
+                TaskContinuationOptions.ExecuteSynchronously,
+                TaskScheduler.Default);
+        }
+
+        foreach (var bucket in buckets)
+        {
+            var completedTask = await bucket.Task.WaitAsync(cancellationToken).ConfigureAwait(false);
             yield return await completedTask.ConfigureAwait(false);
         }
 #endif
     }
 
-}
\ No newline at end of file
+}
diff --git a/EnumerableAsyncProcessor/Extensions/ParallelExtensions.cs b/EnumerableAsyncProcessor/Extensions/ParallelExtensions.cs
index f01a4a7..4fe27ae 100644
--- a/EnumerableAsyncProcessor/Extensions/ParallelExtensions.cs
+++ b/EnumerableAsyncProcessor/Extensions/ParallelExtensions.cs
@@ -83,20 +83,8 @@ private static async Task<TResult> ProcessAsync<TSource, TResult>(
             semaphoreAcquired = true;
             
             cancellationToken.ThrowIfCancellationRequested();
-            var task = taskSelector(item);
-            
-            // Fast-path optimization for already completed tasks
-            if (task.IsCompleted)
-            {
-                if (task.IsFaulted)
-                    throw task.Exception?.GetBaseException() ?? task.Exception!;
-                if (task.IsCanceled)
-                    throw new OperationCanceledException();
-                return task.Result;
-            }
 
-            // Await the task directly - it's already async so no need for Task.Run
-            return await task.ConfigureAwait(false);
+            return await taskSelector(item).ConfigureAwait(false);
         }
         finally
         {
@@ -121,20 +109,8 @@ private static async Task ProcessAsync<TSource>(
             semaphoreAcquired = true;
             
             cancellationToken.ThrowIfCancellationRequested();
-            var task = taskSelector(item);
-            
-            // Fast-path optimization for already completed tasks
-            if (task.IsCompleted)
-            {
-                if (task.IsFaulted)
-                    throw task.Exception?.GetBaseException() ?? task.Exception!;
-                if (task.IsCanceled)
-                    throw new OperationCanceledException();
-                return;
-            }
 
-            // Await the task directly - it's already async so no need for Task.Run
-            await task.ConfigureAwait(false);
+            await taskSelector(item).ConfigureAwait(false);
         }
         finally
         {
@@ -144,4 +120,4 @@ private static async Task ProcessAsync<TSource>(
             }
         }
     }
-}
\ No newline at end of file
+}
diff --git a/EnumerableAsyncProcessor/ProcessorLifecycle.cs b/EnumerableAsyncProcessor/ProcessorLifecycle.cs
new file mode 100644
index 0000000..08c92bc
--- /dev/null
+++ b/EnumerableAsyncProcessor/ProcessorLifecycle.cs
@@ -0,0 +1,124 @@
+using EnumerableAsyncProcessor.Validation;
+
+namespace EnumerableAsyncProcessor;
+
+/// <summary>
+/// Owns the start/cancel/dispose lifecycle shared by the void and result processor base classes,
+/// which cannot share a common ancestor because they fan out to differently typed completion sources.
+/// </summary>
+internal sealed class ProcessorLifecycle
+{
+    private static readonly TimeSpan DisposalTimeout = TimeSpan.FromSeconds(30);
+
+    private readonly CancellationTokenSource _cancellationTokenSource;
+    private readonly Action _trySetCanceledAll;
+    private readonly Action<Exception> _trySetExceptionAll;
+    private CancellationTokenRegistration _cancellationTokenRegistration;
+    private Task? _processTask;
+    private volatile bool _disposed;
+    private readonly object _disposeLock = new();
+
+    public CancellationToken Token { get; }
+
+    public ProcessorLifecycle(CancellationTokenSource cancellationTokenSource, Action trySetCanceledAll, Action<Exception> trySetExceptionAll)
+    {
+        ValidationHelper.ValidateCancellationTokenSource(cancellationTokenSource);
+
+        _cancellationTokenSource = cancellationTokenSource;
+        _trySetCanceledAll = trySetCanceledAll;
+        _trySetExceptionAll = trySetExceptionAll;
+        Token = cancellationTokenSource.Token;
+    }
+
+    // Cancellation is registered here rather than at construction so that a token cancelled
+    // while the processor is still being constructed can never fire on a partially built instance.
+    public void Start(Func<Task> process)
+    {
+        _cancellationTokenRegistration = Token.Register(CancelAll);
+        _processTask = RunProcess(process);
+    }
+
+    private async Task RunProcess(Func<Task> process)
+    {
+        try
+        {
+            await process().ConfigureAwait(false);
+        }
+        catch (OperationCanceledException)
+        {
+            _trySetCanceledAll();
+        }
+        catch (Exception exception)
+        {
+            // A failure outside the per-item wrappers (e.g. cancellation plumbing) would otherwise
+            // leave awaiters of the per-item tasks hanging forever.
+            _trySetExceptionAll(exception);
+        }
+    }
+
+    public void CancelAll()
+    {
+        if (_disposed)
+            return;
+
+        CancelAllCore();
+    }
+
+    private void CancelAllCore()
+    {
+        if (!_cancellationTokenSource.IsCancellationRequested)
+        {
+            _cancellationTokenSource.Cancel();
+        }
+
+        _trySetCanceledAll();
+    }
+
+    public async ValueTask DisposeAsync(Func<ValueTask> disposeAsyncCore)
+    {
+        lock (_disposeLock)
+        {
+            if (_disposed)
+                return;
+            _disposed = true;
+        }
+
+        // Allow the owning processor to dispose its resources first
+        await disposeAsyncCore().ConfigureAwait(false);
+
+        CancelAllCore();
+        _cancellationTokenRegistration.Dispose();
+
+        // Give in-flight tasks a bounded window to observe cancellation and finish
+        if (_processTask is { IsCompleted: false })
+        {
+            try
+            {
+                using var timeoutCts = new CancellationTokenSource(DisposalTimeout);
+                await _processTask.WaitAsync(timeoutCts.Token).ConfigureAwait(false);
+            }
+            catch (OperationCanceledException)
+            {
+                // Timed out waiting for in-flight tasks - continue with disposal
+            }
+        }
+
+        _cancellationTokenSource.Dispose();
+    }
+
+    public void Dispose()
+    {
+        lock (_disposeLock)
+        {
+            if (_disposed)
+                return;
+            _disposed = true;
+        }
+
+        // Cancel and release without blocking; in-flight tasks complete against
+        // already-cancelled completion sources, which is a no-op.
+        CancelAllCore();
+        _cancellationTokenRegistration.Dispose();
+        _cancellationTokenSource.Dispose();
+    }
+}
diff --git a/EnumerableAsyncProcessor/RunnableProcessors/Abstract/AbstractAsyncProcessor.cs b/EnumerableAsyncProcessor/RunnableProcessors/Abstract/AbstractAsyncProcessor.cs
index 6e58973..88ef7b1 100644
--- a/EnumerableAsyncProcessor/RunnableProcessors/Abstract/AbstractAsyncProcessor.cs
+++ b/EnumerableAsyncProcessor/RunnableProcessors/Abstract/AbstractAsyncProcessor.cs
@@ -1,41 +1,24 @@
-using System.Collections.Concurrent;
-using System.Diagnostics.CodeAnalysis;
 using EnumerableAsyncProcessor.Validation;
 
 namespace EnumerableAsyncProcessor.RunnableProcessors.Abstract;
 
 public abstract class AbstractAsyncProcessor : AbstractAsyncProcessorBase
 {
-    private readonly ConcurrentDictionary<int, TaskCompletionSource> _taskCompletionSources = [];
+    protected readonly ActionTaskWrapper[] TaskWrappers;
 
-    protected readonly IEnumerable<ActionTaskWrapper> TaskWrappers;
+    private readonly TaskCompletionSource[] _taskCompletionSources;
 
-    [field: AllowNull, MaybeNull]
-    protected override IEnumerable<TaskCompletionSource> EnumerableTaskCompletionSources
-        => field ??= TaskWrappers.Select(x => x.TaskCompletionSource);
+    protected override IReadOnlyList<TaskCompletionSource> EnumerableTaskCompletionSources => _taskCompletionSources;
 
-    
     protected AbstractAsyncProcessor(int count, Func<Task> taskSelector, CancellationTokenSource cancellationTokenSource) : base(cancellationTokenSource)
     {
-        ValidationHelper.ValidateCount(count);
+        ValidationHelper.ThrowIfNegative(count);
         ValidationHelper.ThrowIfNull(taskSelector);
 
-        // Provide optimization for empty collections
-        if (count == 0)
-        {
-            TaskWrappers = [];
-            return;
-        }
+        TaskWrappers = Enumerable.Range(0, count)
+            .Select(_ => new ActionTaskWrapper(taskSelector, new TaskCompletionSource(TaskCreationOptions.RunContinuationsAsynchronously)))
+            .ToArray();
 
-        // Provide performance warning for very large collections
-        var warning = ValidationHelper.GetPerformanceWarning(count);
-        if (warning != null)
-        {
-            // In a real application, you might want to log this warning
-            // For now, we'll just store it as a comment that could be used by logging
-            _ = warning;
-        }
-
-        TaskWrappers = Enumerable.Range(0, count).Select(index => new ActionTaskWrapper(taskSelector, _taskCompletionSources.GetOrAdd(index, new TaskCompletionSource())));
+        _taskCompletionSources = TaskWrappers.Select(x => x.TaskCompletionSource).ToArray();
     }
-}
\ No newline at end of file
+}
diff --git a/EnumerableAsyncProcessor/RunnableProcessors/Abstract/AbstractAsyncProcessorBase.cs b/EnumerableAsyncProcessor/RunnableProcessors/Abstract/AbstractAsyncProcessorBase.cs
index f02468d..5150896 100644
--- a/EnumerableAsyncProcessor/RunnableProcessors/Abstract/AbstractAsyncProcessorBase.cs
+++ b/EnumerableAsyncProcessor/RunnableProcessors/Abstract/AbstractAsyncProcessorBase.cs
@@ -1,41 +1,35 @@
-using System.Diagnostics.CodeAnalysis;
 using System.Runtime.CompilerServices;
 using EnumerableAsyncProcessor.Interfaces;
-using EnumerableAsyncProcessor.Validation;
 
 namespace EnumerableAsyncProcessor.RunnableProcessors.Abstract;
 
 public abstract class AbstractAsyncProcessorBase : IAsyncProcessor, IAsyncDisposable, IDisposable
 {
-    protected abstract IEnumerable<TaskCompletionSource> EnumerableTaskCompletionSources { get; }
+    protected abstract IReadOnlyList<TaskCompletionSource> EnumerableTaskCompletionSources { get; }
     protected readonly CancellationToken CancellationToken;
 
-    [field: MaybeNull, AllowNull]
-    private IEnumerable<Task> EnumerableTasks => field ??= EnumerableTaskCompletionSources.Select(x => x.Task);
-    
-    private readonly CancellationTokenSource _cancellationTokenSource;
-    private volatile bool _disposed;
-    private readonly object _disposeLock = new();
+    private readonly ProcessorLifecycle _lifecycle;
+    private Task? _overallTask;
+
+    private Task OverallTask => _overallTask ??= Task.WhenAll(GetEnumerableTasks());
 
-    [field: AllowNull, MaybeNull]
-    private Task OverallTask  => field ??= Task.WhenAll(EnumerableTasks);
-    
     protected AbstractAsyncProcessorBase(CancellationTokenSource cancellationTokenSource)
     {
-        ValidationHelper.ValidateCancellationTokenSource(cancellationTokenSource);
-        
-        CancellationToken = cancellationTokenSource.Token;
-        CancellationToken.Register(CancelAll);
-        CancellationToken.ThrowIfCancellationRequested();
-        
-        _cancellationTokenSource = cancellationTokenSource;
+        _lifecycle = new ProcessorLifecycle(cancellationTokenSource, TrySetCanceledAll, TrySetExceptionAll);
+        CancellationToken = _lifecycle.Token;
     }
 
     internal abstract Task Process();
-    
+
+    internal IAsyncProcessor StartProcessing()
+    {
+        _lifecycle.Start(Process);
+        return this;
+    }
+
     public IEnumerable<Task> GetEnumerableTasks()
     {
-        return EnumerableTasks;
+        return EnumerableTaskCompletionSources.Select(x => x.Task);
     }
 
     public TaskAwaiter GetAwaiter()
@@ -47,93 +41,31 @@ public Task WaitAsync()
     {
         return OverallTask;
     }
-    
+
     public void CancelAll()
     {
-        if (_disposed)
-            return;
-            
-        if (!_cancellationTokenSource.IsCancellationRequested)
-        {
-            _cancellationTokenSource.Cancel();
-        }
-
-        foreach (var tcs in EnumerableTaskCompletionSources)
-        {
-            tcs.TrySetCanceled(CancellationToken);
-        }
+        _lifecycle.CancelAll();
     }
 
-    public async ValueTask DisposeAsync()
+    private void TrySetCanceledAll()
     {
-        if (_disposed)
-            return;
-
-        lock (_disposeLock)
-        {
-            if (_disposed)
-                return;
-            _disposed = true;
-        }
-
-        // Allow derived classes to dispose their resources first
-        await DisposeAsyncCore().ConfigureAwait(false);
-
-        // Cancel all operations
-        CancelAll();
-
-        // Wait for all running tasks to complete with timeout
-        try
-        {
-            using var timeoutCts = new CancellationTokenSource(TimeSpan.FromSeconds(30));
-            var allTasks = EnumerableTasks.ToList();
-            
-            if (allTasks.Count > 0)
-            {
-                var completionTasks = allTasks.Select(async task =>
-                {
-                    try
-                    {
-                        await task.WaitAsync(timeoutCts.Token).ConfigureAwait(false);
-                    }
-                    catch (OperationCanceledException)
-                    {
-                        // Expected when cancelled - ignore
-                    }
-                    catch (Exception)
-                    {
-                        // Task exceptions are expected - ignore during disposal
-                    }
-                }).ToList();
-
-                if (completionTasks.Count > 0)
-                {
-                    try
-                    {
-                        await Task.WhenAll(completionTasks).ConfigureAwait(false);
-                    }
-                    catch (OperationCanceledException)
-                    {
-                        // Timeout occurred - continue with disposal
-                    }
-                }
-            }
-        }
-        catch (Exception)
+        foreach (var taskCompletionSource in EnumerableTaskCompletionSources)
         {
-            // Swallow exceptions during disposal cleanup
+            taskCompletionSource.TrySetCanceled(CancellationToken);
         }
+    }
 
-        // Dispose the cancellation token source
-        try
-        {
-            _cancellationTokenSource.Dispose();
-        }
-        catch (Exception)
+    private void TrySetExceptionAll(Exception exception)
+    {
+        foreach (var taskCompletionSource in EnumerableTaskCompletionSources)
         {
-            // Swallow disposal exceptions
+            taskCompletionSource.TrySetException(exception);
         }
+    }
 
+    public async ValueTask DisposeAsync()
+    {
+        await _lifecycle.DisposeAsync(DisposeAsyncCore).ConfigureAwait(false);
         GC.SuppressFinalize(this);
     }
 
@@ -148,20 +80,7 @@ protected virtual ValueTask DisposeAsyncCore()
 
     public void Dispose()
     {
-        // Use Task.Run to avoid deadlocks by running async disposal on thread pool
-        // Add timeout to prevent indefinite blocking
-        try
-        {
-            var disposeTask = Task.Run(async () => await DisposeAsync().ConfigureAwait(false));
-            if (!disposeTask.Wait(TimeSpan.FromSeconds(30)))
-            {
-                // Log warning if disposal times out, but don't throw
-                // as per IDisposable pattern
-            }
-        }
-        catch
-        {
-            // Suppress exceptions during disposal as per IDisposable pattern
-        }
+        _lifecycle.Dispose();
+        GC.SuppressFinalize(this);
     }
-}
\ No newline at end of file
+}
diff --git a/EnumerableAsyncProcessor/RunnableProcessors/Abstract/AbstractAsyncProcessor_1.cs b/EnumerableAsyncProcessor/RunnableProcessors/Abstract/AbstractAsyncProcessor_1.cs
index 2011cc7..6b493b7 100644
--- a/EnumerableAsyncProcessor/RunnableProcessors/Abstract/AbstractAsyncProcessor_1.cs
+++ b/EnumerableAsyncProcessor/RunnableProcessors/Abstract/AbstractAsyncProcessor_1.cs
@@ -1,43 +1,25 @@
-using System.Collections.Concurrent;
-using System.Diagnostics.CodeAnalysis;
 using EnumerableAsyncProcessor.Validation;
 
 namespace EnumerableAsyncProcessor.RunnableProcessors.Abstract;
 
 public abstract class AbstractAsyncProcessor<TInput> : AbstractAsyncProcessorBase
 {
-    private readonly ConcurrentDictionary<int, TaskCompletionSource> _taskCompletionSources = [];
-    
-    protected readonly IEnumerable<ItemTaskWrapper<TInput>> TaskWrappers;
+    protected readonly ItemTaskWrapper<TInput>[] TaskWrappers;
+
+    private readonly TaskCompletionSource[] _taskCompletionSources;
+
+    protected override IReadOnlyList<TaskCompletionSource> EnumerableTaskCompletionSources => _taskCompletionSources;
 
-    [field: AllowNull, MaybeNull]
-    protected override IEnumerable<TaskCompletionSource> EnumerableTaskCompletionSources
-        => field ??= TaskWrappers.Select(x => x.TaskCompletionSource);
-    
     protected AbstractAsyncProcessor(IEnumerable<TInput> items, Func<TInput, Task> taskSelector, CancellationTokenSource cancellationTokenSource) : base(cancellationTokenSource)
     {
-        var isEmpty = ValidationHelper.ValidateEnumerable(items);
+        ValidationHelper.ThrowIfNull(items);
         ValidationHelper.ThrowIfNull(taskSelector);
 
-        // Provide optimization for empty collections
-        if (isEmpty)
-        {
-            TaskWrappers = [];
-            return;
-        }
-
-        // Get count for performance warnings if collection implements ICollection
-        if (items is ICollection<TInput> collection)
-        {
-            var warning = ValidationHelper.GetPerformanceWarning(collection.Count);
-            if (warning != null)
-            {
-                // In a real application, you might want to log this warning
-                // For now, we'll just store it as a comment that could be used by logging
-                _ = warning;
-            }
-        }
+        // Materialize once so one-shot or side-effecting enumerables are only enumerated a single time
+        TaskWrappers = items
+            .Select(item => new ItemTaskWrapper<TInput>(item, taskSelector, new TaskCompletionSource(TaskCreationOptions.RunContinuationsAsynchronously)))
+            .ToArray();
 
-        TaskWrappers = items.Select((item, index) => new ItemTaskWrapper<TInput>(item, taskSelector, _taskCompletionSources.GetOrAdd(index, new TaskCompletionSource())));
+        _taskCompletionSources = TaskWrappers.Select(x => x.TaskCompletionSource).ToArray();
     }
-}
\ No newline at end of file
+}
diff --git a/EnumerableAsyncProcessor/RunnableProcessors/BatchAsyncProcessor.cs b/EnumerableAsyncProcessor/RunnableProcessors/BatchAsyncProcessor.cs
index 267a83f..7fc67f1 100644
--- a/EnumerableAsyncProcessor/RunnableProcessors/BatchAsyncProcessor.cs
+++ b/EnumerableAsyncProcessor/RunnableProcessors/BatchAsyncProcessor.cs
@@ -9,7 +9,7 @@ public class BatchAsyncProcessor : AbstractAsyncProcessor
 
     internal BatchAsyncProcessor(int batchSize, int count, Func<Task> taskSelector, CancellationTokenSource cancellationTokenSource) : base(count, taskSelector, cancellationTokenSource)
     {
-        ValidationHelper.ValidateBatchSize(batchSize);
+        ValidationHelper.ThrowIfNegativeOrZero(batchSize);
 
         _batchSize = batchSize;
     }
@@ -28,4 +28,4 @@ private async Task ProcessBatch(ActionTaskWrapper[] taskWrappers)
     {
         await Task.WhenAll(taskWrappers.Select(tw => tw.Process(CancellationToken))).ConfigureAwait(false);
     }
-}
\ No newline at end of file
+}
diff --git a/EnumerableAsyncProcessor/RunnableProcessors/BatchAsyncProcessor_1.cs b/EnumerableAsyncProcessor/RunnableProcessors/BatchAsyncProcessor_1.cs
index 3f36f84..b8e91ec 100644
--- a/EnumerableAsyncProcessor/RunnableProcessors/BatchAsyncProcessor_1.cs
+++ b/EnumerableAsyncProcessor/RunnableProcessors/BatchAsyncProcessor_1.cs
@@ -10,7 +10,7 @@ public class BatchAsyncProcessor<TInput> : AbstractAsyncProcessor<TInput>
     internal BatchAsyncProcessor(int batchSize, IEnumerable<TInput> items, Func<TInput, Task> taskSelector,
         CancellationTokenSource cancellationTokenSource) : base(items, taskSelector, cancellationTokenSource)
     {
-        ValidationHelper.ValidateBatchSize(batchSize);
+        ValidationHelper.ThrowIfNegativeOrZero(batchSize);
 
         _batchSize = batchSize;
     }
@@ -29,4 +29,4 @@ private async Task ProcessBatch(ItemTaskWrapper<TInput>[] currentBatch)
     {
         await Task.WhenAll(currentBatch.Select(tw => tw.Process(CancellationToken))).ConfigureAwait(false);
     }
-}
\ No newline at end of file
+}
diff --git a/EnumerableAsyncProcessor/RunnableProcessors/ParallelAsyncProcessor.cs b/EnumerableAsyncProcessor/RunnableProcessors/ParallelAsyncProcessor.cs
index 141223c..e512d84 100644
--- a/EnumerableAsyncProcessor/RunnableProcessors/ParallelAsyncProcessor.cs
+++ b/EnumerableAsyncProcessor/RunnableProcessors/ParallelAsyncProcessor.cs
@@ -1,4 +1,5 @@
 using EnumerableAsyncProcessor.RunnableProcessors.Abstract;
+using EnumerableAsyncProcessor.Validation;
 
 namespace EnumerableAsyncProcessor.RunnableProcessors;
 
@@ -6,9 +7,14 @@ public class ParallelAsyncProcessor : AbstractAsyncProcessor
 {
     private readonly int? _maxConcurrency;
     private readonly bool _scheduleOnThreadPool;
-    
+
     internal ParallelAsyncProcessor(int count, Func<Task> taskSelector, CancellationTokenSource cancellationTokenSource, int? maxConcurrency = null, bool scheduleOnThreadPool = false) : base(count, taskSelector, cancellationTokenSource)
     {
+        if (maxConcurrency is { } concurrencyLimit)
+        {
+            ValidationHelper.ThrowIfNegativeOrZero(concurrencyLimit, nameof(maxConcurrency));
+        }
+
         _maxConcurrency = maxConcurrency;
         _scheduleOnThreadPool = scheduleOnThreadPool;
     }
@@ -38,38 +44,8 @@ await Task.WhenAll(TaskWrappers.Select(taskWrapper =>
             return;
         }
 
-        // Use semaphore for concurrency throttling
-        using var semaphore = new SemaphoreSlim(_maxConcurrency.Value, _maxConcurrency.Value);
-        
-        // Materialize tasks immediately to ensure they all start in parallel (up to concurrency limit)
-        var tasks = _scheduleOnThreadPool
-            ? // Use Task.Run to prevent synchronous code from blocking thread pool threads
-              TaskWrappers.Select(taskWrapper => Task.Run(async () =>
-        {
-            await semaphore.WaitAsync(CancellationToken).ConfigureAwait(false);
-            try
-            {
-                await taskWrapper.Process(CancellationToken).ConfigureAwait(false);
-            }
-            finally
-            {
-                semaphore.Release();
-            }
-              }, CancellationToken)).ToList()
-            : // Direct execution for maximum performance
-              TaskWrappers.Select(async taskWrapper =>
-              {
-                  await semaphore.WaitAsync(CancellationToken).ConfigureAwait(false);
-                  try
-                  {
-                      await taskWrapper.Process(CancellationToken).ConfigureAwait(false);
-                  }
-                  finally
-                  {
-                      semaphore.Release();
-                  }
-              }).ToList(); // Force immediate task creation
-
-        await Task.WhenAll(tasks).ConfigureAwait(false);
+        // Throttled processing runs on a fixed worker pool: P worker tasks instead of
+        // one queued task, closure and semaphore wait per item
+        await WorkerPool.ProcessAsync(TaskWrappers, _maxConcurrency.Value, minimumIterationTime: null, CancellationToken).ConfigureAwait(false);
     }
-}
\ No newline at end of file
+}
diff --git a/EnumerableAsyncProcessor/RunnableProcessors/ParallelAsyncProcessor_1.cs b/EnumerableAsyncProcessor/RunnableProcessors/ParallelAsyncProcessor_1.cs
index 116b074..9dcdc42 100644
--- a/EnumerableAsyncProcessor/RunnableProcessors/ParallelAsyncProcessor_1.cs
+++ b/EnumerableAsyncProcessor/RunnableProcessors/ParallelAsyncProcessor_1.cs
@@ -1,4 +1,5 @@
 using EnumerableAsyncProcessor.RunnableProcessors.Abstract;
+using EnumerableAsyncProcessor.Validation;
 
 namespace EnumerableAsyncProcessor.RunnableProcessors;
 
@@ -6,9 +7,14 @@ public class ParallelAsyncProcessor<TInput> : AbstractAsyncProcessor<TInput>
 {
     private readonly int? _maxConcurrency;
     private readonly bool _scheduleOnThreadPool;
-    
+
     internal ParallelAsyncProcessor(IEnumerable<TInput> items, Func<TInput, Task> taskSelector, CancellationTokenSource cancellationTokenSource, int? maxConcurrency = null, bool scheduleOnThreadPool = false) : base(items, taskSelector, cancellationTokenSource)
     {
+        if (maxConcurrency is { } concurrencyLimit)
+        {
+            ValidationHelper.ThrowIfNegativeOrZero(concurrencyLimit, nameof(maxConcurrency));
+        }
+
         _maxConcurrency = maxConcurrency;
         _scheduleOnThreadPool = scheduleOnThreadPool;
     }
@@ -38,38 +44,8 @@ await Task.WhenAll(TaskWrappers.Select(taskWrapper =>
             return;
         }
 
-        // Use semaphore for concurrency throttling
-        using var semaphore = new SemaphoreSlim(_maxConcurrency.Value, _maxConcurrency.Value);
-        
-        // Materialize tasks immediately to ensure they all start in parallel (up to concurrency limit)
-        var tasks = _scheduleOnThreadPool
-            ? // Use Task.Run to prevent synchronous code from blocking thread pool threads
-              TaskWrappers.Select(taskWrapper => Task.Run(async () =>
-        {
-            await semaphore.WaitAsync(CancellationToken).ConfigureAwait(false);
-            try
-            {
-                await taskWrapper.Process(CancellationToken).ConfigureAwait(false);
-            }
-            finally
-            {
-                semaphore.Release();
-            }
-              }, CancellationToken)).ToList()
-            : // Direct execution for maximum performance
-              TaskWrappers.Select(async taskWrapper =>
-              {
-                  await semaphore.WaitAsync(CancellationToken).ConfigureAwait(false);
-                  try
-                  {
-                      await taskWrapper.Process(CancellationToken).ConfigureAwait(false);
-                  }
-                  finally
-                  {
-                      semaphore.Release();
-                  }
-              }).ToList(); // Force immediate task creation
-
-        await Task.WhenAll(tasks).ConfigureAwait(false);
+        // Throttled processing runs on a fixed worker pool: P worker tasks instead of
+        // one queued task, closure and semaphore wait per item
+        await WorkerPool.ProcessAsync(TaskWrappers, _maxConcurrency.Value, minimumIterationTime: null, CancellationToken).ConfigureAwait(false);
     }
-}
\ No newline at end of file
+}
diff --git a/EnumerableAsyncProcessor/RunnableProcessors/RateLimitedParallelAsyncProcessor.cs b/EnumerableAsyncProcessor/RunnableProcessors/RateLimitedParallelAsyncProcessor.cs
index 190208d..df8147e 100644
--- a/EnumerableAsyncProcessor/RunnableProcessors/RateLimitedParallelAsyncProcessor.cs
+++ b/EnumerableAsyncProcessor/RunnableProcessors/RateLimitedParallelAsyncProcessor.cs
@@ -1,4 +1,3 @@
-using EnumerableAsyncProcessor.Extensions;
 using EnumerableAsyncProcessor.RunnableProcessors.Abstract;
 using EnumerableAsyncProcessor.Validation;
 
@@ -10,18 +9,13 @@ public class RateLimitedParallelAsyncProcessor : AbstractAsyncProcessor
 
     internal RateLimitedParallelAsyncProcessor(int count, Func<Task> taskSelector, int levelsOfParallelism, CancellationTokenSource cancellationTokenSource) : base(count, taskSelector, cancellationTokenSource)
     {
-        ValidationHelper.ValidateParallelism(levelsOfParallelism);
+        ValidationHelper.ThrowIfNegativeOrZero(levelsOfParallelism);
 
         _levelsOfParallelism = levelsOfParallelism;
     }
 
     internal override Task Process()
     {
-        // For rate-limited processing, we want strict parallelism control
-        return TaskWrappers.InParallelAsync(_levelsOfParallelism, 
-            async taskWrapper =>
-            {
-                await Task.Run(() => taskWrapper.Process(CancellationToken), CancellationToken).ConfigureAwait(false);
-            }, CancellationToken);
+        return WorkerPool.ProcessAsync(TaskWrappers, _levelsOfParallelism, minimumIterationTime: null, CancellationToken);
     }
-}
\ No newline at end of file
+}
diff --git a/EnumerableAsyncProcessor/RunnableProcessors/RateLimitedParallelAsyncProcessor_1.cs b/EnumerableAsyncProcessor/RunnableProcessors/RateLimitedParallelAsyncProcessor_1.cs
index 69971bc..32dab70 100644
--- a/EnumerableAsyncProcessor/RunnableProcessors/RateLimitedParallelAsyncProcessor_1.cs
+++ b/EnumerableAsyncProcessor/RunnableProcessors/RateLimitedParallelAsyncProcessor_1.cs
@@ -1,4 +1,3 @@
-using EnumerableAsyncProcessor.Extensions;
 using EnumerableAsyncProcessor.RunnableProcessors.Abstract;
 using EnumerableAsyncProcessor.Validation;
 
@@ -10,18 +9,13 @@ public class RateLimitedParallelAsyncProcessor<TInput> : AbstractAsyncProcessor<
     
     internal RateLimitedParallelAsyncProcessor(IEnumerable<TInput> items, Func<TInput, Task> taskSelector, int levelsOfParallelism, CancellationTokenSource cancellationTokenSource) : base(items, taskSelector, cancellationTokenSource)
     {
-        ValidationHelper.ValidateParallelism(levelsOfParallelism);
+        ValidationHelper.ThrowIfNegativeOrZero(levelsOfParallelism);
 
         _levelsOfParallelism = levelsOfParallelism;
     }
 
     internal override Task Process()
     {
-        // For rate-limited processing, we want strict parallelism control
-        return TaskWrappers.InParallelAsync(_levelsOfParallelism, 
-            async taskWrapper =>
-            {
-                await Task.Run(() => taskWrapper.Process(CancellationToken), CancellationToken).ConfigureAwait(false);
-            }, CancellationToken);
+        return WorkerPool.ProcessAsync(TaskWrappers, _levelsOfParallelism, minimumIterationTime: null, CancellationToken);
     }
-}
\ No newline at end of file
+}
diff --git a/EnumerableAsyncProcessor/RunnableProcessors/ResultProcessors/Abstract/ResultAbstractAsyncProcessorBase.cs b/EnumerableAsyncProcessor/RunnableProcessors/ResultProcessors/Abstract/ResultAbstractAsyncProcessorBase.cs
index 2fc608b..a073fe5 100644
--- a/EnumerableAsyncProcessor/RunnableProcessors/ResultProcessors/Abstract/ResultAbstractAsyncProcessorBase.cs
+++ b/EnumerableAsyncProcessor/RunnableProcessors/ResultProcessors/Abstract/ResultAbstractAsyncProcessorBase.cs
@@ -1,43 +1,36 @@
-using System.Diagnostics.CodeAnalysis;
 using System.Runtime.CompilerServices;
 using EnumerableAsyncProcessor.Interfaces;
 using EnumerableAsyncProcessor.Extensions;
-using EnumerableAsyncProcessor.Validation;
 
 namespace EnumerableAsyncProcessor.RunnableProcessors.ResultProcessors.Abstract;
 
 public abstract class ResultAbstractAsyncProcessorBase<TOutput> : IAsyncProcessor<TOutput>, IAsyncDisposable, IDisposable
 {
-    protected abstract IEnumerable<TaskCompletionSource<TOutput>> EnumerableTaskCompletionSources { get; }
+    protected abstract IReadOnlyList<TaskCompletionSource<TOutput>> EnumerableTaskCompletionSources { get; }
     protected readonly CancellationToken CancellationToken;
 
-    [field: MaybeNull, AllowNull]
-    private IEnumerable<Task<TOutput>> EnumerableTasks => field ??= EnumerableTaskCompletionSources.Select(x => x.Task);
-    
-    private readonly CancellationTokenSource _cancellationTokenSource;
-    private volatile bool _disposed;
-    private readonly object _disposeLock = new();
-    
-    [field: AllowNull, MaybeNull]
-    private Task<TOutput[]> Results  => field ??= Task.WhenAll(EnumerableTasks);
+    private readonly ProcessorLifecycle _lifecycle;
+    private Task<TOutput[]>? _results;
 
+    private Task<TOutput[]> Results => _results ??= Task.WhenAll(GetEnumerableTasks());
 
     protected ResultAbstractAsyncProcessorBase(CancellationTokenSource cancellationTokenSource)
     {
-        ValidationHelper.ValidateCancellationTokenSource(cancellationTokenSource);
-        
-        _cancellationTokenSource = cancellationTokenSource;
-        
-        CancellationToken = cancellationTokenSource.Token;
-        CancellationToken.Register(Dispose);
-        CancellationToken.ThrowIfCancellationRequested();
+        _lifecycle = new ProcessorLifecycle(cancellationTokenSource, TrySetCanceledAll, TrySetExceptionAll);
+        CancellationToken = _lifecycle.Token;
     }
 
     internal abstract Task Process();
-    
+
+    internal IAsyncProcessor<TOutput> StartProcessing()
+    {
+        _lifecycle.Start(Process);
+        return this;
+    }
+
     public IEnumerable<Task<TOutput>> GetEnumerableTasks()
     {
-        return EnumerableTasks;
+        return EnumerableTaskCompletionSources.Select(x => x.Task);
     }
 
     public Task<TOutput[]> GetResultsAsync()
@@ -57,90 +50,28 @@ public TaskAwaiter<TOutput[]> GetAwaiter()
 
     public void CancelAll()
     {
-        if (_disposed)
-            return;
-            
-        if (!_cancellationTokenSource.IsCancellationRequested)
-        {
-            _cancellationTokenSource.Cancel();
-        }
+        _lifecycle.CancelAll();
+    }
 
+    private void TrySetCanceledAll()
+    {
         foreach (var taskCompletionSource in EnumerableTaskCompletionSources)
         {
             taskCompletionSource.TrySetCanceled(CancellationToken);
         }
     }
 
-    public async ValueTask DisposeAsync()
+    private void TrySetExceptionAll(Exception exception)
     {
-        if (_disposed)
-            return;
-
-        lock (_disposeLock)
-        {
-            if (_disposed)
-                return;
-            _disposed = true;
-        }
-
-        // Allow derived classes to dispose their resources first
-        await DisposeAsyncCore().ConfigureAwait(false);
-
-        // Cancel all operations
-        CancelAll();
-
-        // Wait for all running tasks to complete with timeout
-        try
-        {
-            using var timeoutCts = new CancellationTokenSource(TimeSpan.FromSeconds(30));
-            var allTasks = EnumerableTasks.ToList();
-            
-            if (allTasks.Count > 0)
-            {
-                var completionTasks = allTasks.Select(async task =>
-                {
-                    try
-                    {
-                        await task.WaitAsync(timeoutCts.Token).ConfigureAwait(false);
-                    }
-                    catch (OperationCanceledException)
-                    {
-                        // Expected when cancelled - ignore
-                    }
-                    catch (Exception)
-                    {
-                        // Task exceptions are expected - ignore during disposal
-                    }
-                }).ToList();
-
-                if (completionTasks.Count > 0)
-                {
-                    try
-                    {
-                        await Task.WhenAll(completionTasks).ConfigureAwait(false);
-                    }
-                    catch (OperationCanceledException)
-                    {
-                        // Timeout occurred - continue with disposal
-                    }
-                }
-            }
-        }
-        catch (Exception)
-        {
-            // Swallow exceptions during disposal cleanup
-        }
-
-        // Dispose the cancellation token source
-        try
-        {
-            _cancellationTokenSource.Dispose();
-        }
-        catch (Exception)
+        foreach (var taskCompletionSource in EnumerableTaskCompletionSources)
         {
-            // Swallow disposal exceptions
+            taskCompletionSource.TrySetException(exception);
         }
+    }
 
+    public async ValueTask DisposeAsync()
+    {
+        await _lifecycle.DisposeAsync(DisposeAsyncCore).ConfigureAwait(false);
         GC.SuppressFinalize(this);
     }
 
@@ -155,20 +86,7 @@ protected virtual ValueTask DisposeAsyncCore()
 
     public void Dispose()
     {
-        // Use Task.Run to avoid deadlocks by running async disposal on thread pool
-        // Add timeout to prevent indefinite blocking
-        try
-        {
-            var disposeTask = Task.Run(async () => await DisposeAsync().ConfigureAwait(false));
-            if (!disposeTask.Wait(TimeSpan.FromSeconds(30)))
-            {
-                // Log warning if disposal times out, but don't throw
-                // as per IDisposable pattern
-            }
-        }
-        catch
-        {
-            // Suppress exceptions during disposal as per IDisposable pattern
-        }
+        _lifecycle.Dispose();
+        GC.SuppressFinalize(this);
     }
-}
\ No newline at end of file
+}
diff --git a/EnumerableAsyncProcessor/RunnableProcessors/ResultProcessors/Abstract/ResultAbstractAsyncProcessor_1.cs b/EnumerableAsyncProcessor/RunnableProcessors/ResultProcessors/Abstract/ResultAbstractAsyncProcessor_1.cs
index de1ff16..85ff76b 100644
--- a/EnumerableAsyncProcessor/RunnableProcessors/ResultProcessors/Abstract/ResultAbstractAsyncProcessor_1.cs
+++ b/EnumerableAsyncProcessor/RunnableProcessors/ResultProcessors/Abstract/ResultAbstractAsyncProcessor_1.cs
@@ -1,40 +1,24 @@
-using System.Collections.Concurrent;
-using System.Diagnostics.CodeAnalysis;
 using EnumerableAsyncProcessor.Validation;
 
 namespace EnumerableAsyncProcessor.RunnableProcessors.ResultProcessors.Abstract;
 
 public abstract class ResultAbstractAsyncProcessor<TOutput> : ResultAbstractAsyncProcessorBase<TOutput>
 {
-    private readonly ConcurrentDictionary<int, TaskCompletionSource<TOutput>> _taskCompletionSources = [];
+    protected readonly ActionTaskWrapper<TOutput>[] TaskWrappers;
 
-    protected readonly IEnumerable<ActionTaskWrapper<TOutput>> TaskWrappers;
+    private readonly TaskCompletionSource<TOutput>[] _taskCompletionSources;
+
+    protected override IReadOnlyList<TaskCompletionSource<TOutput>> EnumerableTaskCompletionSources => _taskCompletionSources;
 
     protected ResultAbstractAsyncProcessor(int count, Func<Task<TOutput>> taskSelector, CancellationTokenSource cancellationTokenSource) : base(cancellationTokenSource)
     {
-        ValidationHelper.ValidateCount(count);
+        ValidationHelper.ThrowIfNegative(count);
         ValidationHelper.ThrowIfNull(taskSelector);
 
-        // Provide optimization for empty collections
-        if (count == 0)
-        {
-            TaskWrappers = [];
-            return;
-        }
-
-        // Provide performance warning for very large collections
-        var warning = ValidationHelper.GetPerformanceWarning(count);
-        if (warning != null)
-        {
-            // In a real application, you might want to log this warning
-            // For now, we'll just store it as a comment that could be used by logging
-            _ = warning;
-        }
+        TaskWrappers = Enumerable.Range(0, count)
+            .Select(_ => new ActionTaskWrapper<TOutput>(taskSelector, new TaskCompletionSource<TOutput>(TaskCreationOptions.RunContinuationsAsynchronously)))
+            .ToArray();
 
-        TaskWrappers = Enumerable.Range(0, count).Select(index => new ActionTaskWrapper<TOutput>(taskSelector, _taskCompletionSources.GetOrAdd(index, new TaskCompletionSource<TOutput>())));
+        _taskCompletionSources = TaskWrappers.Select(x => x.TaskCompletionSource).ToArray();
     }
-
-    [field: AllowNull, MaybeNull]
-    protected override IEnumerable<TaskCompletionSource<TOutput>> EnumerableTaskCompletionSources =>
-        field ??= TaskWrappers.Select(x => x.TaskCompletionSource);
-}
\ No newline at end of file
+}
diff --git a/EnumerableAsyncProcessor/RunnableProcessors/ResultProcessors/Abstract/ResultAbstractAsyncProcessor_2.cs b/EnumerableAsyncProcessor/RunnableProcessors/ResultProcessors/Abstract/ResultAbstractAsyncProcessor_2.cs
index 02322d6..615b5f9 100644
--- a/EnumerableAsyncProcessor/RunnableProcessors/ResultProcessors/Abstract/ResultAbstractAsyncProcessor_2.cs
+++ b/EnumerableAsyncProcessor/RunnableProcessors/ResultProcessors/Abstract/ResultAbstractAsyncProcessor_2.cs
@@ -1,43 +1,25 @@
-using System.Collections.Concurrent;
-using System.Diagnostics.CodeAnalysis;
 using EnumerableAsyncProcessor.Validation;
 
 namespace EnumerableAsyncProcessor.RunnableProcessors.ResultProcessors.Abstract;
 
 public abstract class ResultAbstractAsyncProcessor<TInput, TOutput> : ResultAbstractAsyncProcessorBase<TOutput>
 {
-    private readonly ConcurrentDictionary<int, TaskCompletionSource<TOutput>> _taskCompletionSources = [];
+    protected readonly ItemTaskWrapper<TInput, TOutput>[] TaskWrappers;
+
+    private readonly TaskCompletionSource<TOutput>[] _taskCompletionSources;
+
+    protected override IReadOnlyList<TaskCompletionSource<TOutput>> EnumerableTaskCompletionSources => _taskCompletionSources;
 
-    protected readonly IEnumerable<ItemTaskWrapper<TInput, TOutput>> TaskWrappers;
-    
     protected ResultAbstractAsyncProcessor(IEnumerable<TInput> items, Func<TInput, Task<TOutput>> taskSelector, CancellationTokenSource cancellationTokenSource) : base(cancellationTokenSource)
     {
-        var isEmpty = ValidationHelper.ValidateEnumerable(items);
+        ValidationHelper.ThrowIfNull(items);
         ValidationHelper.ThrowIfNull(taskSelector);
 
-        // Provide optimization for empty collections
-        if (isEmpty)
-        {
-            TaskWrappers = [];
-            return;
-        }
+        // Materialize once so one-shot or side-effecting enumerables are only enumerated a single time
+        TaskWrappers = items
+            .Select(item => new ItemTaskWrapper<TInput, TOutput>(item, taskSelector, new TaskCompletionSource<TOutput>(TaskCreationOptions.RunContinuationsAsynchronously)))
+            .ToArray();
 
-        // Get count for performance warnings if collection implements ICollection
-        if (items is ICollection<TInput> collection)
-        {
-            var warning = ValidationHelper.GetPerformanceWarning(collection.Count);
-            if (warning != null)
-            {
-                // In a real application, you might want to log this warning
-                // For now, we'll just store it as a comment that could be used by logging
-                _ = warning;
-            }
-        }
-
-        TaskWrappers = items.Select((item, index) => new ItemTaskWrapper<TInput, TOutput>(item, taskSelector, _taskCompletionSources.GetOrAdd(index, new TaskCompletionSource<TOutput>())));
+        _taskCompletionSources = TaskWrappers.Select(x => x.TaskCompletionSource).ToArray();
     }
-
-    [field: AllowNull, MaybeNull]
-    protected override IEnumerable<TaskCompletionSource<TOutput>> EnumerableTaskCompletionSources =>
-        field ??= TaskWrappers.Select(x => x.TaskCompletionSource);
-}
\ No newline at end of file
+}
diff --git a/EnumerableAsyncProcessor/RunnableProcessors/ResultProcessors/ResultBatchAsyncProcessor_1.cs b/EnumerableAsyncProcessor/RunnableProcessors/ResultProcessors/ResultBatchAsyncProcessor_1.cs
index 385263b..639da5f 100644
--- a/EnumerableAsyncProcessor/RunnableProcessors/ResultProcessors/ResultBatchAsyncProcessor_1.cs
+++ b/EnumerableAsyncProcessor/RunnableProcessors/ResultProcessors/ResultBatchAsyncProcessor_1.cs
@@ -1,7 +1,6 @@
-using EnumerableAsyncProcessor.RunnableProcessors.ResultProcessors.Abstract;
+using EnumerableAsyncProcessor.RunnableProcessors.ResultProcessors.Abstract;
 using EnumerableAsyncProcessor.Validation;
 
-
 namespace EnumerableAsyncProcessor.RunnableProcessors.ResultProcessors;
 
 public class ResultBatchAsyncProcessor<TOutput> : ResultAbstractAsyncProcessor<TOutput>
@@ -11,7 +10,7 @@ public class ResultBatchAsyncProcessor<TOutput> : ResultAbstractAsyncProcessor<T
     internal ResultBatchAsyncProcessor(int batchSize, int count, Func<Task<TOutput>> taskSelector,
         CancellationTokenSource cancellationTokenSource) : base(count, taskSelector, cancellationTokenSource)
     {
-        ValidationHelper.ValidateBatchSize(batchSize);
+        ValidationHelper.ThrowIfNegativeOrZero(batchSize);
 
         _batchSize = batchSize;
     }
@@ -30,4 +29,4 @@ private async Task ProcessBatch(ActionTaskWrapper<TOutput>[] batch)
     {
         await Task.WhenAll(batch.Select(tw => tw.Process(CancellationToken))).ConfigureAwait(false);
     }
-}
\ No newline at end of file
+}
diff --git a/EnumerableAsyncProcessor/RunnableProcessors/ResultProcessors/ResultBatchAsyncProcessor_2.cs b/EnumerableAsyncProcessor/RunnableProcessors/ResultProcessors/ResultBatchAsyncProcessor_2.cs
index 1cd1792..7ae1d64 100644
--- a/EnumerableAsyncProcessor/RunnableProcessors/ResultProcessors/ResultBatchAsyncProcessor_2.cs
+++ b/EnumerableAsyncProcessor/RunnableProcessors/ResultProcessors/ResultBatchAsyncProcessor_2.cs
@@ -1,4 +1,5 @@
 using EnumerableAsyncProcessor.RunnableProcessors.ResultProcessors.Abstract;
+using EnumerableAsyncProcessor.Validation;
 
 namespace EnumerableAsyncProcessor.RunnableProcessors.ResultProcessors;
 
@@ -9,6 +10,8 @@ public class ResultBatchAsyncProcessor<TInput, TOutput> : ResultAbstractAsyncPro
     internal ResultBatchAsyncProcessor(int batchSize, IEnumerable<TInput> items, Func<TInput, Task<TOutput>> taskSelector,
         CancellationTokenSource cancellationTokenSource) : base(items, taskSelector, cancellationTokenSource)
     {
+        ValidationHelper.ThrowIfNegativeOrZero(batchSize);
+
         _batchSize = batchSize;
     }
 
@@ -26,4 +29,4 @@ private async Task ProcessBatch(ItemTaskWrapper<TInput, TOutput>[] currentBatch)
     {
         await Task.WhenAll(currentBatch.Select(tw => tw.Process(CancellationToken))).ConfigureAwait(false);
     }
-}
\ No newline at end of file
+}
diff --git a/EnumerableAsyncProcessor/RunnableProcessors/ResultProcessors/ResultParallelAsyncProcessor_1.cs b/EnumerableAsyncProcessor/RunnableProcessors/ResultProcessors/ResultParallelAsyncProcessor_1.cs
index 8a9420e..f85d1c4 100644
--- a/EnumerableAsyncProcessor/RunnableProcessors/ResultProcessors/ResultParallelAsyncProcessor_1.cs
+++ b/EnumerableAsyncProcessor/RunnableProcessors/ResultProcessors/ResultParallelAsyncProcessor_1.cs
@@ -1,4 +1,5 @@
 using EnumerableAsyncProcessor.RunnableProcessors.ResultProcessors.Abstract;
+using EnumerableAsyncProcessor.Validation;
 
 namespace EnumerableAsyncProcessor.RunnableProcessors.ResultProcessors;
 
@@ -6,9 +7,14 @@ public class ResultParallelAsyncProcessor<TOutput> : ResultAbstractAsyncProcesso
 {
     private readonly int? _maxConcurrency;
     private readonly bool _scheduleOnThreadPool;
-    
+
     internal ResultParallelAsyncProcessor(int count, Func<Task<TOutput>> taskSelector, CancellationTokenSource cancellationTokenSource, int? maxConcurrency = null, bool scheduleOnThreadPool = false) : base(count, taskSelector, cancellationTokenSource)
     {
+        if (maxConcurrency is { } concurrencyLimit)
+        {
+            ValidationHelper.ThrowIfNegativeOrZero(concurrencyLimit, nameof(maxConcurrency));
+        }
+
         _maxConcurrency = maxConcurrency;
         _scheduleOnThreadPool = scheduleOnThreadPool;
     }
@@ -38,38 +44,8 @@ await Task.WhenAll(TaskWrappers.Select(taskWrapper =>
             return;
         }
 
-        // Use semaphore for concurrency throttling
-        using var semaphore = new SemaphoreSlim(_maxConcurrency.Value, _maxConcurrency.Value);
-        
-        // Materialize tasks immediately to ensure they all start in parallel (up to concurrency limit)
-        var tasks = _scheduleOnThreadPool
-            ? // Use Task.Run to prevent synchronous code from blocking thread pool threads
-              TaskWrappers.Select(taskWrapper => Task.Run(async () =>
-        {
-            await semaphore.WaitAsync(CancellationToken).ConfigureAwait(false);
-            try
-            {
-                await taskWrapper.Process(CancellationToken).ConfigureAwait(false);
-            }
-            finally
-            {
-                semaphore.Release();
-            }
-              }, CancellationToken)).ToList()
-            : // Direct execution for maximum performance
-              TaskWrappers.Select(async taskWrapper =>
-              {
-                  await semaphore.WaitAsync(CancellationToken).ConfigureAwait(false);
-                  try
-                  {
-                      await taskWrapper.Process(CancellationToken).ConfigureAwait(false);
-                  }
-                  finally
-                  {
-                      semaphore.Release();
-                  }
-              }).ToList(); // Force immediate task creation
-
-        await Task.WhenAll(tasks).ConfigureAwait(false);
+        // Throttled processing runs on a fixed worker pool: P worker tasks instead of
+        // one queued task, closure and semaphore wait per item
+        await WorkerPool.ProcessAsync(TaskWrappers, _maxConcurrency.Value, minimumIterationTime: null, CancellationToken).ConfigureAwait(false);
     }
-}
\ No newline at end of file
+}
diff --git a/EnumerableAsyncProcessor/RunnableProcessors/ResultProcessors/ResultParallelAsyncProcessor_2.cs b/EnumerableAsyncProcessor/RunnableProcessors/ResultProcessors/ResultParallelAsyncProcessor_2.cs
index ea4dae0..2348103 100644
--- a/EnumerableAsyncProcessor/RunnableProcessors/ResultProcessors/ResultParallelAsyncProcessor_2.cs
+++ b/EnumerableAsyncProcessor/RunnableProcessors/ResultProcessors/ResultParallelAsyncProcessor_2.cs
@@ -1,4 +1,5 @@
 using EnumerableAsyncProcessor.RunnableProcessors.ResultProcessors.Abstract;
+using EnumerableAsyncProcessor.Validation;
 
 namespace EnumerableAsyncProcessor.RunnableProcessors.ResultProcessors;
 
@@ -6,9 +7,14 @@ public class ResultParallelAsyncProcessor<TInput, TOutput> : ResultAbstractAsync
 {
     private readonly int? _maxConcurrency;
     private readonly bool _scheduleOnThreadPool;
-    
+
     internal ResultParallelAsyncProcessor(IEnumerable<TInput> items, Func<TInput, Task<TOutput>> taskSelector, CancellationTokenSource cancellationTokenSource, int? maxConcurrency = null, bool scheduleOnThreadPool = false) : base(items, taskSelector, cancellationTokenSource)
     {
+        if (maxConcurrency is { } concurrencyLimit)
+        {
+            ValidationHelper.ThrowIfNegativeOrZero(concurrencyLimit, nameof(maxConcurrency));
+        }
+
         _maxConcurrency = maxConcurrency;
         _scheduleOnThreadPool = scheduleOnThreadPool;
     }
@@ -38,38 +44,8 @@ await Task.WhenAll(TaskWrappers.Select(taskWrapper =>
             return;
         }
 
-        // Use semaphore for concurrency throttling
-        using var semaphore = new SemaphoreSlim(_maxConcurrency.Value, _maxConcurrency.Value);
-        
-        // Materialize tasks immediately to ensure they all start in parallel (up to concurrency limit)
-        var tasks = _scheduleOnThreadPool
-            ? // Use Task.Run to prevent synchronous code from blocking thread pool threads
-              TaskWrappers.Select(taskWrapper => Task.Run(async () =>
-        {
-            await semaphore.WaitAsync(CancellationToken).ConfigureAwait(false);
-            try
-            {
-                await taskWrapper.Process(CancellationToken).ConfigureAwait(false);
-            }
-            finally
-            {
-                semaphore.Release();
-            }
-              }, CancellationToken)).ToList()
-            : // Direct execution for maximum performance
-              TaskWrappers.Select(async taskWrapper =>
-              {
-                  await semaphore.WaitAsync(CancellationToken).ConfigureAwait(false);
-                  try
-                  {
-                      await taskWrapper.Process(CancellationToken).ConfigureAwait(false);
-                  }
-                  finally
-                  {
-                      semaphore.Release();
-                  }
-              }).ToList(); // Force immediate task creation
-
-        await Task.WhenAll(tasks).ConfigureAwait(false);
+        // Throttled processing runs on a fixed worker pool: P worker tasks instead of
+        // one queued task, closure and semaphore wait per item
+        await WorkerPool.ProcessAsync(TaskWrappers, _maxConcurrency.Value, minimumIterationTime: null, CancellationToken).ConfigureAwait(false);
     }
-}
\ No newline at end of file
+}
diff --git a/EnumerableAsyncProcessor/RunnableProcessors/ResultProcessors/ResultRateLimitedParallelAsyncProcessor_1.cs b/EnumerableAsyncProcessor/RunnableProcessors/ResultProcessors/ResultRateLimitedParallelAsyncProcessor_1.cs
index d951b64..c42f06e 100644
--- a/EnumerableAsyncProcessor/RunnableProcessors/ResultProcessors/ResultRateLimitedParallelAsyncProcessor_1.cs
+++ b/EnumerableAsyncProcessor/RunnableProcessors/ResultProcessors/ResultRateLimitedParallelAsyncProcessor_1.cs
@@ -1,6 +1,6 @@
-
-using EnumerableAsyncProcessor.Extensions;
+
 using EnumerableAsyncProcessor.RunnableProcessors.ResultProcessors.Abstract;
+using EnumerableAsyncProcessor.Validation;
 
 namespace EnumerableAsyncProcessor.RunnableProcessors.ResultProcessors;
 
@@ -10,16 +10,13 @@ public class ResultRateLimitedParallelAsyncProcessor<TOutput> : ResultAbstractAs
 
     internal ResultRateLimitedParallelAsyncProcessor(int count, Func<Task<TOutput>> taskSelector, int levelsOfParallelism, CancellationTokenSource cancellationTokenSource) : base(count, taskSelector, cancellationTokenSource)
     {
+        ValidationHelper.ThrowIfNegativeOrZero(levelsOfParallelism);
+
         _levelsOfParallelism = levelsOfParallelism;
     }
 
     internal override Task Process()
     {
-        // For rate-limited processing, we want strict parallelism control
-        return TaskWrappers.InParallelAsync(_levelsOfParallelism, 
-            async taskWrapper =>
-            {
-                await Task.Run(() => taskWrapper.Process(CancellationToken)).ConfigureAwait(false);
-            }, CancellationToken.None);
+        return WorkerPool.ProcessAsync(TaskWrappers, _levelsOfParallelism, minimumIterationTime: null, CancellationToken);
     }
-}
\ No newline at end of file
+}
diff --git a/EnumerableAsyncProcessor/RunnableProcessors/ResultProcessors/ResultRateLimitedParallelAsyncProcessor_2.cs b/EnumerableAsyncProcessor/RunnableProcessors/ResultProcessors/ResultRateLimitedParallelAsyncProcessor_2.cs
index 62f781d..5753020 100644
--- a/EnumerableAsyncProcessor/RunnableProcessors/ResultProcessors/ResultRateLimitedParallelAsyncProcessor_2.cs
+++ b/EnumerableAsyncProcessor/RunnableProcessors/ResultProcessors/ResultRateLimitedParallelAsyncProcessor_2.cs
@@ -1,5 +1,5 @@
-using EnumerableAsyncProcessor.Extensions;
 using EnumerableAsyncProcessor.RunnableProcessors.ResultProcessors.Abstract;
+using EnumerableAsyncProcessor.Validation;
 
 namespace EnumerableAsyncProcessor.RunnableProcessors.ResultProcessors;
 
@@ -9,17 +9,13 @@ public class ResultRateLimitedParallelAsyncProcessor<TInput, TOutput> : ResultAb
     
     internal ResultRateLimitedParallelAsyncProcessor(IEnumerable<TInput> items, Func<TInput, Task<TOutput>> taskSelector, int levelsOfParallelism, CancellationTokenSource cancellationTokenSource) : base(items, taskSelector, cancellationTokenSource)
     {
+        ValidationHelper.ThrowIfNegativeOrZero(levelsOfParallelism);
+
         _levelsOfParallelism = levelsOfParallelism;
     }
 
     internal override Task Process()
     {
-        // For rate-limited processing, we want strict parallelism control
-        // TaskWrapper.Process already includes Task.Yield to prevent thread pool blocking
-        return TaskWrappers.InParallelAsync(_levelsOfParallelism, 
-            async taskWrapper =>
-            {
-                await taskWrapper.Process(CancellationToken).ConfigureAwait(false);
-            }, CancellationToken.None);
+        return WorkerPool.ProcessAsync(TaskWrappers, _levelsOfParallelism, minimumIterationTime: null, CancellationToken);
     }
-}
\ No newline at end of file
+}
diff --git a/EnumerableAsyncProcessor/RunnableProcessors/ResultProcessors/ResultTimedRateLimitedParallelAsyncProcessor_1.cs b/EnumerableAsyncProcessor/RunnableProcessors/ResultProcessors/ResultTimedRateLimitedParallelAsyncProcessor_1.cs
index b335070..bc85f94 100644
--- a/EnumerableAsyncProcessor/RunnableProcessors/ResultProcessors/ResultTimedRateLimitedParallelAsyncProcessor_1.cs
+++ b/EnumerableAsyncProcessor/RunnableProcessors/ResultProcessors/ResultTimedRateLimitedParallelAsyncProcessor_1.cs
@@ -1,5 +1,5 @@
-using EnumerableAsyncProcessor.Extensions;
 using EnumerableAsyncProcessor.RunnableProcessors.ResultProcessors.Abstract;
+using EnumerableAsyncProcessor.Validation;
 
 namespace EnumerableAsyncProcessor.RunnableProcessors.ResultProcessors;
 
@@ -10,20 +10,15 @@ public class ResultTimedRateLimitedParallelAsyncProcessor<TOutput> : ResultAbstr
 
     internal ResultTimedRateLimitedParallelAsyncProcessor(int count, Func<Task<TOutput>> taskSelector, int levelsOfParallelism, TimeSpan timeSpan, CancellationTokenSource cancellationTokenSource) : base(count, taskSelector, cancellationTokenSource)
     {
+        ValidationHelper.ThrowIfNegativeOrZero(levelsOfParallelism);
+        ValidationHelper.ThrowIfNegative(timeSpan);
+
         _levelsOfParallelism = levelsOfParallelism;
         _timeSpan = timeSpan;
     }
 
     internal override Task Process()
     {
-        // For timed rate-limited processing, we want strict parallelism control
-        // TaskWrapper.Process already includes Task.Yield to prevent thread pool blocking
-        return TaskWrappers.InParallelAsync(_levelsOfParallelism, 
-            async taskWrapper =>
-            {
-                await Task.WhenAll(
-                    taskWrapper.Process(CancellationToken),
-                    Task.Delay(_timeSpan, CancellationToken)).ConfigureAwait(false);
-            }, CancellationToken.None);
+        return WorkerPool.ProcessAsync(TaskWrappers, _levelsOfParallelism, minimumIterationTime: _timeSpan, CancellationToken);
     }
-}
\ No newline at end of file
+}
diff --git a/EnumerableAsyncProcessor/RunnableProcessors/ResultProcessors/ResultTimedRateLimitedParallelAsyncProcessor_2.cs b/EnumerableAsyncProcessor/RunnableProcessors/ResultProcessors/ResultTimedRateLimitedParallelAsyncProcessor_2.cs
index 4f51b0f..e1d1160 100644
--- a/EnumerableAsyncProcessor/RunnableProcessors/ResultProcessors/ResultTimedRateLimitedParallelAsyncProcessor_2.cs
+++ b/EnumerableAsyncProcessor/RunnableProcessors/ResultProcessors/ResultTimedRateLimitedParallelAsyncProcessor_2.cs
@@ -1,5 +1,5 @@
-using EnumerableAsyncProcessor.Extensions;
 using EnumerableAsyncProcessor.RunnableProcessors.ResultProcessors.Abstract;
+using EnumerableAsyncProcessor.Validation;
 
 namespace EnumerableAsyncProcessor.RunnableProcessors.ResultProcessors;
 
@@ -10,20 +10,15 @@ public class ResultTimedRateLimitedParallelAsyncProcessor<TInput, TOutput> : Res
 
     internal ResultTimedRateLimitedParallelAsyncProcessor(IEnumerable<TInput> items, Func<TInput, Task<TOutput>> taskSelector, int levelsOfParallelism, TimeSpan timeSpan, CancellationTokenSource cancellationTokenSource) : base(items, taskSelector, cancellationTokenSource)
     {
+        ValidationHelper.ThrowIfNegativeOrZero(levelsOfParallelism);
+        ValidationHelper.ThrowIfNegative(timeSpan);
+
         _levelsOfParallelism = levelsOfParallelism;
         _timeSpan = timeSpan;
     }
 
     internal override Task Process()
     {
-        // For timed rate-limited processing, we want strict parallelism control
-        // TaskWrapper.Process already includes Task.Yield to prevent thread pool blocking
-        return TaskWrappers.InParallelAsync(_levelsOfParallelism, 
-            async taskWrapper =>
-            {
-                await Task.WhenAll(
-                    taskWrapper.Process(CancellationToken),
-                    Task.Delay(_timeSpan, CancellationToken)).ConfigureAwait(false);
-            }, CancellationToken.None);
+        return WorkerPool.ProcessAsync(TaskWrappers, _levelsOfParallelism, minimumIterationTime: _timeSpan, CancellationToken);
     }
-}
\ No newline at end of file
+}
diff --git a/EnumerableAsyncProcessor/RunnableProcessors/TimedRateLimitedParallelAsyncProcessor.cs b/EnumerableAsyncProcessor/RunnableProcessors/TimedRateLimitedParallelAsyncProcessor.cs
index e16c64b..430cdf5 100644
--- a/EnumerableAsyncProcessor/RunnableProcessors/TimedRateLimitedParallelAsyncProcessor.cs
+++ b/EnumerableAsyncProcessor/RunnableProcessors/TimedRateLimitedParallelAsyncProcessor.cs
@@ -1,4 +1,3 @@
-using EnumerableAsyncProcessor.Extensions;
 using EnumerableAsyncProcessor.RunnableProcessors.Abstract;
 using EnumerableAsyncProcessor.Validation;
 
@@ -11,8 +10,8 @@ public class TimedRateLimitedParallelAsyncProcessor : AbstractAsyncProcessor
 
     internal TimedRateLimitedParallelAsyncProcessor(int count, Func<Task> taskSelector, int levelsOfParallelism, TimeSpan timeSpan, CancellationTokenSource cancellationTokenSource) : base(count, taskSelector, cancellationTokenSource)
     {
-        ValidationHelper.ValidateParallelism(levelsOfParallelism);
-        ValidationHelper.ValidateTimeSpan(timeSpan);
+        ValidationHelper.ThrowIfNegativeOrZero(levelsOfParallelism);
+        ValidationHelper.ThrowIfNegative(timeSpan);
 
         _levelsOfParallelism = levelsOfParallelism;
         _timeSpan = timeSpan;
@@ -20,13 +19,6 @@ internal TimedRateLimitedParallelAsyncProcessor(int count, Func<Task> taskSelect
 
     internal override Task Process()
     {
-        // For timed rate-limited processing, we want strict parallelism control
-        return TaskWrappers.InParallelAsync(_levelsOfParallelism, 
-            async taskWrapper =>
-            {
-                await Task.WhenAll(
-                    Task.Run(() => taskWrapper.Process(CancellationToken)),
-                    Task.Delay(_timeSpan, CancellationToken)).ConfigureAwait(false);
-            }, CancellationToken.None);
+        return WorkerPool.ProcessAsync(TaskWrappers, _levelsOfParallelism, minimumIterationTime: _timeSpan, CancellationToken);
     }
-}
\ No newline at end of file
+}
diff --git a/EnumerableAsyncProcessor/RunnableProcessors/TimedRateLimitedParallelAsyncProcessor_1.cs b/EnumerableAsyncProcessor/RunnableProcessors/TimedRateLimitedParallelAsyncProcessor_1.cs
index d520ab3..ba8c2c0 100644
--- a/EnumerableAsyncProcessor/RunnableProcessors/TimedRateLimitedParallelAsyncProcessor_1.cs
+++ b/EnumerableAsyncProcessor/RunnableProcessors/TimedRateLimitedParallelAsyncProcessor_1.cs
@@ -1,4 +1,3 @@
-using EnumerableAsyncProcessor.Extensions;
 using EnumerableAsyncProcessor.RunnableProcessors.Abstract;
 using EnumerableAsyncProcessor.Validation;
 
@@ -11,8 +10,8 @@ public class TimedRateLimitedParallelAsyncProcessor<TInput> : AbstractAsyncProce
 
     internal TimedRateLimitedParallelAsyncProcessor(IEnumerable<TInput> items, Func<TInput, Task> taskSelector, int levelsOfParallelism, TimeSpan timeSpan, CancellationTokenSource cancellationTokenSource) : base(items, taskSelector, cancellationTokenSource)
     {
-        ValidationHelper.ValidateParallelism(levelsOfParallelism);
-        ValidationHelper.ValidateTimeSpan(timeSpan);
+        ValidationHelper.ThrowIfNegativeOrZero(levelsOfParallelism);
+        ValidationHelper.ThrowIfNegative(timeSpan);
 
         _levelsOfParallelism = levelsOfParallelism;
         _timeSpan = timeSpan;
@@ -20,13 +19,6 @@ internal TimedRateLimitedParallelAsyncProcessor(IEnumerable<TInput> items, Func<
 
     internal override Task Process()
     {
-        // For timed rate-limited processing, we want strict parallelism control
-        return TaskWrappers.InParallelAsync(_levelsOfParallelism, 
-            async taskWrapper =>
-            {
-                await Task.WhenAll(
-                    Task.Run(() => taskWrapper.Process(CancellationToken)),
-                    Task.Delay(_timeSpan, CancellationToken)).ConfigureAwait(false);
-            }, CancellationToken.None);
+        return WorkerPool.ProcessAsync(TaskWrappers, _levelsOfParallelism, minimumIterationTime: _timeSpan, CancellationToken);
     }
-}
\ No newline at end of file
+}
diff --git a/EnumerableAsyncProcessor/TaskCompletionSource.cs b/EnumerableAsyncProcessor/TaskCompletionSource.cs
index b67eaf1..c32f1f7 100644
--- a/EnumerableAsyncProcessor/TaskCompletionSource.cs
+++ b/EnumerableAsyncProcessor/TaskCompletionSource.cs
@@ -1,10 +1,20 @@
-#if NETSTANDARD2_0
+#if NETSTANDARD2_0
 
 namespace EnumerableAsyncProcessor
 {
     /// <inheritdoc cref="TaskCompletionSource{TResult}"/>
     public class TaskCompletionSource : TaskCompletionSource<object?>
     {
+        /// <inheritdoc cref="TaskCompletionSource{TResult}()"/>
+        public TaskCompletionSource()
+        {
+        }
+
+        /// <inheritdoc cref="TaskCompletionSource{TResult}(TaskCreationOptions)"/>
+        public TaskCompletionSource(TaskCreationOptions creationOptions) : base(creationOptions)
+        {
+        }
+
         /// <inheritdoc cref="TaskCompletionSource{TResult}.TrySetResult"/>
         public bool TrySetResult()
         {
@@ -21,4 +31,4 @@ public void SetResult()
         public new Task Task => base.Task;
     }
 }
-#endif
\ No newline at end of file
+#endif
diff --git a/EnumerableAsyncProcessor/TaskWrapper.cs b/EnumerableAsyncProcessor/TaskWrapper.cs
index 1d36ec3..0b3acd4 100644
--- a/EnumerableAsyncProcessor/TaskWrapper.cs
+++ b/EnumerableAsyncProcessor/TaskWrapper.cs
@@ -1,11 +1,59 @@
-using System.Runtime.CompilerServices;
-
 namespace EnumerableAsyncProcessor;
 
 /// <summary>
-/// A high-performance struct wrapper for action tasks to reduce heap allocations.
+/// Allows the worker-pool helpers to process any wrapper struct through a constrained
+/// generic type parameter without boxing.
+/// </summary>
+internal interface ITaskWrapper
+{
+    Task Process(CancellationToken cancellationToken);
+}
+
+/// <summary>
+/// Completes a completion source from a failed task-factory invocation, classifying the failure
+/// by the state of the task rather than the caught exception.
 /// </summary>
-public readonly struct ActionTaskWrapper : IEquatable<ActionTaskWrapper>
+internal static class TaskCompletionSourceExtensions
+{
+    internal static void TrySetFromFault(this TaskCompletionSource taskCompletionSource, Task? task, Exception exception, CancellationToken cancellationToken)
+    {
+        if (task is { IsCanceled: true })
+        {
+            taskCompletionSource.TrySetCanceled(cancellationToken);
+        }
+        else if (task is { IsFaulted: true })
+        {
+            // Preserve every failure from the task, not just the first
+            taskCompletionSource.TrySetException(task.Exception!.InnerExceptions);
+        }
+        else
+        {
+            taskCompletionSource.TrySetException(exception);
+        }
+    }
+
+    internal static void TrySetFromFault<TOutput>(this TaskCompletionSource<TOutput> taskCompletionSource, Task? task, Exception exception, CancellationToken cancellationToken)
+    {
+        if (task is { IsCanceled: true })
+        {
+            taskCompletionSource.TrySetCanceled(cancellationToken);
+        }
+        else if (task is { IsFaulted: true })
+        {
+            // Preserve every failure from the task, not just the first
+            taskCompletionSource.TrySetException(task.Exception!.InnerExceptions);
+        }
+        else
+        {
+            taskCompletionSource.TrySetException(exception);
+        }
+    }
+}
+
+/// <summary>
+/// A struct wrapper pairing an action task factory with its completion source.
+/// </summary>
+public readonly struct ActionTaskWrapper : ITaskWrapper
 {
     public readonly Func<Task> TaskFactory;
     public readonly TaskCompletionSource TaskCompletionSource;
@@ -16,7 +64,6 @@ public ActionTaskWrapper(Func<Task> taskFactory, TaskCompletionSource taskComple
         TaskCompletionSource = taskCompletionSource;
     }
 
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public async Task Process(CancellationToken cancellationToken)
     {
         if (cancellationToken.IsCancellationRequested)
@@ -24,81 +71,25 @@ public async Task Process(CancellationToken cancellationToken)
             TaskCompletionSource.TrySetCanceled(cancellationToken);
             return;
         }
-        
+
+        Task? task = null;
         try
         {
-            // Removed Task.Yield - parallelism is now handled at the processor level
-            var task = TaskFactory.Invoke();
-            
-            // Fast-path for already completed tasks
-            if (task.IsCompleted)
-            {
-                if (task.IsFaulted)
-                {
-                    TaskCompletionSource.TrySetException(task.Exception?.GetBaseException() ?? task.Exception!);
-                }
-                else if (task.IsCanceled)
-                {
-                    TaskCompletionSource.TrySetCanceled(cancellationToken);
-                }
-                else
-                {
-                    TaskCompletionSource.TrySetResult();
-                }
-                return;
-            }
-
+            task = TaskFactory.Invoke();
             await task.ConfigureAwait(false);
             TaskCompletionSource.TrySetResult();
         }
         catch (Exception e)
         {
-            TaskCompletionSource.TrySetException(e);
+            TaskCompletionSource.TrySetFromFault(task, e, cancellationToken);
         }
     }
-
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public bool Equals(ActionTaskWrapper other) =>
-        ReferenceEquals(TaskFactory, other.TaskFactory) &&
-        ReferenceEquals(TaskCompletionSource, other.TaskCompletionSource);
-
-    public override bool Equals(object? obj) =>
-        obj is ActionTaskWrapper other && Equals(other);
-
-    public override int GetHashCode()
-    {
-#if NETSTANDARD2_0
-        unchecked
-        {
-            var hash = 17;
-            hash = hash * 23 + (TaskFactory?.GetHashCode() ?? 0);
-            hash = hash * 23 + (TaskCompletionSource?.GetHashCode() ?? 0);
-            return hash;
-        }
-#else
-        return HashCode.Combine(TaskFactory, TaskCompletionSource);
-#endif
-    }
-
-    public static bool operator ==(ActionTaskWrapper left, ActionTaskWrapper right) =>
-        left.Equals(right);
-
-    public static bool operator !=(ActionTaskWrapper left, ActionTaskWrapper right) =>
-        !left.Equals(right);
-
-#if NET6_0_OR_GREATER
-    public void Deconstruct(out Func<Task> taskFactory, out TaskCompletionSource taskCompletionSource)
-    {
-        taskFactory = TaskFactory;
-        taskCompletionSource = TaskCompletionSource;
-    }
-#endif
 }
 
 /// <summary>
-/// A high-performance struct wrapper for item tasks to reduce heap allocations.
+/// A struct wrapper pairing an input item and its task factory with a completion source.
 /// </summary>
-public readonly struct ItemTaskWrapper<TInput> : IEquatable<ItemTaskWrapper<TInput>>
+public readonly struct ItemTaskWrapper<TInput> : ITaskWrapper
 {
     public readonly TInput Input;
     public readonly Func<TInput, Task> TaskFactory;
@@ -111,7 +102,6 @@ public ItemTaskWrapper(TInput input, Func<TInput, Task> taskFactory, TaskComplet
         TaskCompletionSource = taskCompletionSource;
     }
 
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public async Task Process(CancellationToken cancellationToken)
     {
         if (cancellationToken.IsCancellationRequested)
@@ -119,84 +109,25 @@ public async Task Process(CancellationToken cancellationToken)
             TaskCompletionSource.TrySetCanceled(cancellationToken);
             return;
         }
-        
+
+        Task? task = null;
         try
         {
-            // Removed Task.Yield - parallelism is now handled at the processor level
-            var task = TaskFactory.Invoke(Input);
-            
-            // Fast-path for already completed tasks
-            if (task.IsCompleted)
-            {
-                if (task.IsFaulted)
-                {
-                    TaskCompletionSource.TrySetException(task.Exception?.GetBaseException() ?? task.Exception!);
-                }
-                else if (task.IsCanceled)
-                {
-                    TaskCompletionSource.TrySetCanceled(cancellationToken);
-                }
-                else
-                {
-                    TaskCompletionSource.TrySetResult();
-                }
-                return;
-            }
-
+            task = TaskFactory.Invoke(Input);
             await task.ConfigureAwait(false);
             TaskCompletionSource.TrySetResult();
         }
         catch (Exception e)
         {
-            TaskCompletionSource.TrySetException(e);
+            TaskCompletionSource.TrySetFromFault(task, e, cancellationToken);
         }
     }
-
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public bool Equals(ItemTaskWrapper<TInput> other) =>
-        EqualityComparer<TInput>.Default.Equals(Input, other.Input) &&
-        ReferenceEquals(TaskFactory, other.TaskFactory) &&
-        ReferenceEquals(TaskCompletionSource, other.TaskCompletionSource);
-
-    public override bool Equals(object? obj) =>
-        obj is ItemTaskWrapper<TInput> other && Equals(other);
-
-    public override int GetHashCode()
-    {
-#if NETSTANDARD2_0
-        unchecked
-        {
-            var hash = 17;
-            hash = hash * 23 + (Input?.GetHashCode() ?? 0);
-            hash = hash * 23 + (TaskFactory?.GetHashCode() ?? 0);
-            hash = hash * 23 + (TaskCompletionSource?.GetHashCode() ?? 0);
-            return hash;
-        }
-#else
-        return HashCode.Combine(Input, TaskFactory, TaskCompletionSource);
-#endif
-    }
-
-    public static bool operator ==(ItemTaskWrapper<TInput> left, ItemTaskWrapper<TInput> right) =>
-        left.Equals(right);
-
-    public static bool operator !=(ItemTaskWrapper<TInput> left, ItemTaskWrapper<TInput> right) =>
-        !left.Equals(right);
-
-#if NET6_0_OR_GREATER
-    public void Deconstruct(out TInput input, out Func<TInput, Task> taskFactory, out TaskCompletionSource taskCompletionSource)
-    {
-        input = Input;
-        taskFactory = TaskFactory;
-        taskCompletionSource = TaskCompletionSource;
-    }
-#endif
 }
 
 /// <summary>
-/// A high-performance struct wrapper for item tasks with results to reduce heap allocations.
+/// A struct wrapper pairing an input item and its result-producing task factory with a completion source.
 /// </summary>
-public readonly struct ItemTaskWrapper<TInput, TOutput> : IEquatable<ItemTaskWrapper<TInput, TOutput>>
+public readonly struct ItemTaskWrapper<TInput, TOutput> : ITaskWrapper
 {
     public readonly TInput Input;
     public readonly Func<TInput, Task<TOutput>> TaskFactory;
@@ -209,7 +140,6 @@ public ItemTaskWrapper(TInput input, Func<TInput, Task<TOutput>> taskFactory, Ta
         TaskCompletionSource = taskCompletionSource;
     }
 
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public async Task Process(CancellationToken cancellationToken)
     {
         if (cancellationToken.IsCancellationRequested)
@@ -217,83 +147,24 @@ public async Task Process(CancellationToken cancellationToken)
             TaskCompletionSource.TrySetCanceled(cancellationToken);
             return;
         }
-        
+
+        Task<TOutput>? task = null;
         try
         {
-            // Removed Task.Yield - parallelism is now handled at the processor level
-            var task = TaskFactory.Invoke(Input);
-            
-            // Fast-path for already completed tasks
-            if (task.IsCompleted)
-            {
-                if (task.IsFaulted)
-                {
-                    TaskCompletionSource.TrySetException(task.Exception?.GetBaseException() ?? task.Exception!);
-                }
-                else if (task.IsCanceled)
-                {
-                    TaskCompletionSource.TrySetCanceled(cancellationToken);
-                }
-                else
-                {
-                    TaskCompletionSource.TrySetResult(task.Result);
-                }
-                return;
-            }
-
+            task = TaskFactory.Invoke(Input);
             TaskCompletionSource.TrySetResult(await task.ConfigureAwait(false));
         }
         catch (Exception e)
         {
-            TaskCompletionSource.TrySetException(e);
-        }
-    }
-
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public bool Equals(ItemTaskWrapper<TInput, TOutput> other) =>
-        EqualityComparer<TInput>.Default.Equals(Input, other.Input) &&
-        ReferenceEquals(TaskFactory, other.TaskFactory) &&
-        ReferenceEquals(TaskCompletionSource, other.TaskCompletionSource);
-
-    public override bool Equals(object? obj) =>
-        obj is ItemTaskWrapper<TInput, TOutput> other && Equals(other);
-
-    public override int GetHashCode()
-    {
-#if NETSTANDARD2_0
-        unchecked
-        {
-            var hash = 17;
-            hash = hash * 23 + (Input?.GetHashCode() ?? 0);
-            hash = hash * 23 + (TaskFactory?.GetHashCode() ?? 0);
-            hash = hash * 23 + (TaskCompletionSource?.GetHashCode() ?? 0);
-            return hash;
+            TaskCompletionSource.TrySetFromFault(task, e, cancellationToken);
         }
-#else
-        return HashCode.Combine(Input, TaskFactory, TaskCompletionSource);
-#endif
-    }
-
-    public static bool operator ==(ItemTaskWrapper<TInput, TOutput> left, ItemTaskWrapper<TInput, TOutput> right) =>
-        left.Equals(right);
-
-    public static bool operator !=(ItemTaskWrapper<TInput, TOutput> left, ItemTaskWrapper<TInput, TOutput> right) =>
-        !left.Equals(right);
-
-#if NET6_0_OR_GREATER
-    public void Deconstruct(out TInput input, out Func<TInput, Task<TOutput>> taskFactory, out TaskCompletionSource<TOutput> taskCompletionSource)
-    {
-        input = Input;
-        taskFactory = TaskFactory;
-        taskCompletionSource = TaskCompletionSource;
     }
-#endif
 }
 
 /// <summary>
-/// A high-performance struct wrapper for action tasks with results to reduce heap allocations.
+/// A struct wrapper pairing a result-producing task factory with its completion source.
 /// </summary>
-public readonly struct ActionTaskWrapper<TOutput> : IEquatable<ActionTaskWrapper<TOutput>>
+public readonly struct ActionTaskWrapper<TOutput> : ITaskWrapper
 {
     public readonly Func<Task<TOutput>> TaskFactory;
     public readonly TaskCompletionSource<TOutput> TaskCompletionSource;
@@ -304,7 +175,6 @@ public ActionTaskWrapper(Func<Task<TOutput>> taskFactory, TaskCompletionSource<T
         TaskCompletionSource = taskCompletionSource;
     }
 
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public async Task Process(CancellationToken cancellationToken)
     {
         if (cancellationToken.IsCancellationRequested)
@@ -312,73 +182,16 @@ public async Task Process(CancellationToken cancellationToken)
             TaskCompletionSource.TrySetCanceled(cancellationToken);
             return;
         }
-        
+
+        Task<TOutput>? task = null;
         try
         {
-            // Removed Task.Yield - parallelism is now handled at the processor level
-            var task = TaskFactory.Invoke();
-            
-            // Fast-path for already completed tasks
-            if (task.IsCompleted)
-            {
-                if (task.IsFaulted)
-                {
-                    TaskCompletionSource.TrySetException(task.Exception?.GetBaseException() ?? task.Exception!);
-                }
-                else if (task.IsCanceled)
-                {
-                    TaskCompletionSource.TrySetCanceled(cancellationToken);
-                }
-                else
-                {
-                    TaskCompletionSource.TrySetResult(task.Result);
-                }
-                return;
-            }
-
+            task = TaskFactory.Invoke();
             TaskCompletionSource.TrySetResult(await task.ConfigureAwait(false));
         }
         catch (Exception e)
         {
-            TaskCompletionSource.TrySetException(e);
+            TaskCompletionSource.TrySetFromFault(task, e, cancellationToken);
         }
     }
-
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public bool Equals(ActionTaskWrapper<TOutput> other) =>
-        ReferenceEquals(TaskFactory, other.TaskFactory) &&
-        ReferenceEquals(TaskCompletionSource, other.TaskCompletionSource);
-
-    public override bool Equals(object? obj) =>
-        obj is ActionTaskWrapper<TOutput> other && Equals(other);
-
-    public override int GetHashCode()
-    {
-#if NETSTANDARD2_0
-        unchecked
-        {
-            var hash = 17;
-            hash = hash * 23 + (TaskFactory?.GetHashCode() ?? 0);
-            hash = hash * 23 + (TaskCompletionSource?.GetHashCode() ?? 0);
-            return hash;
-        }
-#else
-        return HashCode.Combine(TaskFactory, TaskCompletionSource);
-#endif
-    }
-
-    public static bool operator ==(ActionTaskWrapper<TOutput> left, ActionTaskWrapper<TOutput> right) =>
-        left.Equals(right);
-
-    public static bool operator !=(ActionTaskWrapper<TOutput> left, ActionTaskWrapper<TOutput> right) =>
-        !left.Equals(right);
-
-#if NET6_0_OR_GREATER
-    public void Deconstruct(out Func<Task<TOutput>> taskFactory, out TaskCompletionSource<TOutput> taskCompletionSource)
-    {
-        taskFactory = TaskFactory;
-        taskCompletionSource = TaskCompletionSource;
-    }
-#endif
 }
-
diff --git a/EnumerableAsyncProcessor/Validation/ValidationHelper.cs b/EnumerableAsyncProcessor/Validation/ValidationHelper.cs
index 3c2c488..fbcfef6 100644
--- a/EnumerableAsyncProcessor/Validation/ValidationHelper.cs
+++ b/EnumerableAsyncProcessor/Validation/ValidationHelper.cs
@@ -4,45 +4,10 @@
 namespace EnumerableAsyncProcessor.Validation;
 
 /// <summary>
-/// Provides validation methods and constants for the EnumerableAsyncProcessor library.
+/// Provides validation methods for the EnumerableAsyncProcessor library.
 /// </summary>
 internal static class ValidationHelper
 {
-    /// <summary>
-    /// Maximum number of concurrent tasks allowed to prevent memory issues and system overload.
-    /// </summary>
-    public const int MAX_CONCURRENT_TASKS = 10000;
-
-    /// <summary>
-    /// Maximum batch size allowed for batch processors.
-    /// </summary>
-    public const int MAX_BATCH_SIZE = 10000;
-
-    /// <summary>
-    /// Minimum batch size allowed for batch processors.
-    /// </summary>
-    public const int MIN_BATCH_SIZE = 1;
-
-    /// <summary>
-    /// Maximum levels of parallelism allowed for parallel processors.
-    /// </summary>
-    public const int MAX_PARALLELISM = 10000;
-
-    /// <summary>
-    /// Minimum levels of parallelism allowed for parallel processors.
-    /// </summary>
-    public const int MIN_PARALLELISM = 1;
-
-    /// <summary>
-    /// Maximum TimeSpan value allowed for timed processors (24 hours).
-    /// </summary>
-    public static readonly TimeSpan MAX_TIMESPAN = TimeSpan.FromDays(1);
-
-    /// <summary>
-    /// Minimum TimeSpan value allowed for timed processors.
-    /// </summary>
-    public static readonly TimeSpan MIN_TIMESPAN = TimeSpan.Zero;
-
     /// <summary>
     /// Validates that an object is not null using modern or fallback methods.
     /// </summary>
@@ -113,118 +78,12 @@ public static void ThrowIfNegative(TimeSpan value, [CallerArgumentExpression(nam
     }
 
     /// <summary>
-    /// Validates that a TimeSpan value is positive.
-    /// </summary>
-    /// <param name="value">The value to validate.</param>
-    /// <param name="paramName">The parameter name for the exception.</param>
-    /// <exception cref="ArgumentOutOfRangeException">Thrown when the value is negative or zero.</exception>
-    public static void ThrowIfNegativeOrZero(TimeSpan value, [CallerArgumentExpression(nameof(value))] string? paramName = null)
-    {
-        if (value <= TimeSpan.Zero)
-        {
-            throw new ArgumentOutOfRangeException(paramName, value, $"'{paramName}' must be a positive TimeSpan.");
-        }
-    }
-
-    /// <summary>
-    /// Validates that a count value is within acceptable limits for concurrent processing.
-    /// </summary>
-    /// <param name="count">The count value to validate.</param>
-    /// <param name="paramName">The parameter name for the exception.</param>
-    /// <exception cref="ArgumentOutOfRangeException">Thrown when the count is out of acceptable range.</exception>
-    public static void ValidateCount(int count, [CallerArgumentExpression(nameof(count))] string? paramName = null)
-    {
-        ThrowIfNegative(count, paramName);
-
-        if (count > MAX_CONCURRENT_TASKS)
-        {
-            throw new ArgumentOutOfRangeException(paramName, count, 
-                $"'{paramName}' cannot exceed {MAX_CONCURRENT_TASKS} to prevent system overload. Consider processing in smaller batches.");
-        }
-    }
-
-    /// <summary>
-    /// Validates that a batch size is within acceptable limits.
-    /// </summary>
-    /// <param name="batchSize">The batch size to validate.</param>
-    /// <param name="paramName">The parameter name for the exception.</param>
-    /// <exception cref="ArgumentOutOfRangeException">Thrown when the batch size is out of acceptable range.</exception>
-    public static void ValidateBatchSize(int batchSize, [CallerArgumentExpression(nameof(batchSize))] string? paramName = null)
-    {
-        if (batchSize < MIN_BATCH_SIZE)
-        {
-            throw new ArgumentOutOfRangeException(paramName, batchSize, 
-                $"'{paramName}' must be at least {MIN_BATCH_SIZE}.");
-        }
-
-        if (batchSize > MAX_BATCH_SIZE)
-        {
-            throw new ArgumentOutOfRangeException(paramName, batchSize, 
-                $"'{paramName}' cannot exceed {MAX_BATCH_SIZE} to prevent memory issues.");
-        }
-    }
-
-    /// <summary>
-    /// Validates that a parallelism level is within acceptable limits.
-    /// </summary>
-    /// <param name="levelsOfParallelism">The parallelism level to validate.</param>
-    /// <param name="paramName">The parameter name for the exception.</param>
-    /// <exception cref="ArgumentOutOfRangeException">Thrown when the parallelism level is out of acceptable range.</exception>
-    public static void ValidateParallelism(int levelsOfParallelism, [CallerArgumentExpression(nameof(levelsOfParallelism))] string? paramName = null)
-    {
-        if (levelsOfParallelism < MIN_PARALLELISM)
-        {
-            throw new ArgumentOutOfRangeException(paramName, levelsOfParallelism, 
-                $"'{paramName}' must be at least {MIN_PARALLELISM}.");
-        }
-    }
-
-    /// <summary>
-    /// Validates that a TimeSpan is within acceptable limits for timed operations.
-    /// </summary>
-    /// <param name="timeSpan">The TimeSpan to validate.</param>
-    /// <param name="paramName">The parameter name for the exception.</param>
-    /// <exception cref="ArgumentOutOfRangeException">Thrown when the TimeSpan is out of acceptable range.</exception>
-    public static void ValidateTimeSpan(TimeSpan timeSpan, [CallerArgumentExpression(nameof(timeSpan))] string? paramName = null)
-    {
-        ThrowIfNegative(timeSpan, paramName);
-
-        if (timeSpan > MAX_TIMESPAN)
-        {
-            throw new ArgumentOutOfRangeException(paramName, timeSpan, 
-                $"'{paramName}' cannot exceed {MAX_TIMESPAN.TotalHours} hours.");
-        }
-    }
-
-    /// <summary>
-    /// Validates that an enumerable collection is not null and provides optimization hints.
-    /// </summary>
-    /// <typeparam name="T">The type of items in the collection.</typeparam>
-    /// <param name="items">The collection to validate.</param>
-    /// <param name="paramName">The parameter name for the exception.</param>
-    /// <returns>True if the collection is empty (optimization hint).</returns>
-    /// <exception cref="ArgumentNullException">Thrown when the collection is null.</exception>
-    public static bool ValidateEnumerable<T>([NotNull] IEnumerable<T>? items, [CallerArgumentExpression(nameof(items))] string? paramName = null)
-    {
-        ThrowIfNull(items, paramName);
-
-        // Check if collection is empty for potential optimization
-        if (items is ICollection<T> collection)
-        {
-            return collection.Count == 0;
-        }
-
-        // For other enumerables, we need to check if it has any elements
-        // This is a more expensive operation but necessary for optimization
-        return !items.Any();
-    }
-
-    /// <summary>
-    /// Validates that a CancellationTokenSource is not null.
+    /// Validates that a CancellationTokenSource is not null and not already cancelled.
     /// </summary>
     /// <param name="cancellationTokenSource">The CancellationTokenSource to validate.</param>
     /// <param name="paramName">The parameter name for the exception.</param>
     /// <exception cref="ArgumentNullException">Thrown when the CancellationTokenSource is null.</exception>
+    /// <exception cref="ArgumentException">Thrown when the CancellationTokenSource has already been cancelled.</exception>
     public static void ValidateCancellationTokenSource([NotNull] CancellationTokenSource? cancellationTokenSource, [CallerArgumentExpression(nameof(cancellationTokenSource))] string? paramName = null)
     {
         ThrowIfNull(cancellationTokenSource, paramName);
@@ -234,19 +93,4 @@ public static void ValidateCancellationTokenSource([NotNull] CancellationTokenSo
             throw new ArgumentException($"'{paramName}' has already been cancelled.", paramName);
         }
     }
-
-    /// <summary>
-    /// Provides a warning for very large collections that might impact performance.
-    /// </summary>
-    /// <param name="count">The count of items to process.</param>
-    /// <returns>A warning message if the count is very large, otherwise null.</returns>
-    public static string? GetPerformanceWarning(int count)
-    {
-        return count switch
-        {
-            > 100000 => $"Processing {count:N0} items may consume significant memory and time. Consider processing in smaller batches.",
-            > 50000 => $"Processing {count:N0} items may impact performance. Monitor memory usage.",
-            _ => null
-        };
-    }
-}
\ No newline at end of file
+}
diff --git a/EnumerableAsyncProcessor/WorkerPool.cs b/EnumerableAsyncProcessor/WorkerPool.cs
new file mode 100644
index 0000000..04691bd
--- /dev/null
+++ b/EnumerableAsyncProcessor/WorkerPool.cs
@@ -0,0 +1,63 @@
+namespace EnumerableAsyncProcessor;
+
+/// <summary>
+/// Runs task wrappers on a fixed pool of worker loops instead of queueing one throttled task per item.
+/// For N items and P workers this costs P Task.Run tasks and one Interlocked increment per item,
+/// rather than N Task.Run tasks, N closures and N semaphore waits.
+/// </summary>
+internal static class WorkerPool
+{
+    /// <param name="minimumIterationTime">
+    /// When set, each worker holds its slot for at least this long per item, which caps throughput
+    /// at (workerCount / minimumIterationTime) operations for the timed rate-limited processors.
+    /// </param>
+    internal static Task ProcessAsync<TWrapper>(
+        TWrapper[] taskWrappers,
+        int workerCount,
+        TimeSpan? minimumIterationTime,
+        CancellationToken cancellationToken) where TWrapper : ITaskWrapper
+    {
+        workerCount = Math.Min(workerCount, taskWrappers.Length);
+
+        if (workerCount == 0)
+        {
+            return Task.CompletedTask;
+        }
+
+        var nextIndex = -1;
+
+        var workers = new Task[workerCount];
+
+        for (var i = 0; i < workerCount; i++)
+        {
+            // Task.Run guards the worker slots against synchronous code in user delegates
+            workers[i] = Task.Run(async () =>
+            {
+                while (true)
+                {
+                    var index = Interlocked.Increment(ref nextIndex);
+
+                    if (index >= taskWrappers.Length)
+                    {
+                        return;
+                    }
+
+                    // Process never throws; it completes the item's TaskCompletionSource instead,
+                    // so one failed item cannot stop the worker from draining the rest.
+                    var processTask = taskWrappers[index].Process(cancellationToken);
+
+                    if (minimumIterationTime is { } minimumTime)
+                    {
+                        await Task.WhenAll(processTask, Task.Delay(minimumTime, cancellationToken)).ConfigureAwait(false);
+                    }
+                    else
+                    {
+                        await processTask.ConfigureAwait(false);
+                    }
+                }
+            }, cancellationToken);
+        }
+
+        return Task.WhenAll(workers);
+    }
+}
diff --git a/GitVersion.yml b/GitVersion.yml
new file mode 100644
index 0000000..77aa22b
--- /dev/null
+++ b/GitVersion.yml
@@ -0,0 +1,9 @@
+# ModularPipelines generates a Mainline-strategy config when this file is absent,
+# which crashes GitVersion on GitHub PR merge commits. Keep default strategies and
+# give main stable (non pre-release) versions for publishing.
+next-version: 4.0.0
+branches:
+  main:
+    mode: ContinuousDeployment
+    label: ''
+
diff --git a/README.md b/README.md
index 3f3bcb7..813bb27 100644
--- a/README.md
+++ b/README.md
@@ -366,8 +366,8 @@ private static void StartProcessing(int[] input, CancellationToken token)
 
 When a processor is disposed:
 
-1. **Cancellation**: Internal `CancellationTokenSource` is cancelled
-2. **Task Waiting**: Waits up to 30 seconds for running tasks to complete
+1. **Cancellation**: Internal `CancellationTokenSource` is cancelled and any unstarted tasks complete as cancelled
+2. **Task Waiting**: `await DisposeAsync()` waits up to 30 seconds for in-flight tasks to finish; synchronous `Dispose()` cancels and releases without blocking
 3. **Resource Cleanup**: Disposes internal resources like `CancellationTokenSource`
 4. **Thread Safety**: All disposal operations are thread-safe
 
diff --git a/global.json b/global.json
new file mode 100644
index 0000000..3140116
--- /dev/null
+++ b/global.json
@@ -0,0 +1,5 @@
+{
+  "test": {
+    "runner": "Microsoft.Testing.Platform"
+  }
+}