diff --git a/.github/workflows/build.yml b/.github/workflows/build.yml
index 0fe50be..d3a94ea 100644
--- a/.github/workflows/build.yml
+++ b/.github/workflows/build.yml
@@ -12,29 +12,29 @@ jobs:
 
     steps:
     - name: Checkout
-      uses: actions/checkout@v2
+      uses: actions/checkout@v3
       with:
         fetch-depth: 0
 
+    - name: Setup .NET Core
+      uses: actions/setup-dotnet@v3
+      with:
+        dotnet-version: 6.0.x
+
     - name: Install GitVersion
-      uses: gittools/actions/gitversion/setup@v0.9.10
+      uses: gittools/actions/gitversion/setup@v0.9.15
       with:
         versionSpec: "5.8.0"
 
     - name: Determine Version
       id: gitversion
-      uses: gittools/actions/gitversion/execute@v0.9.10
+      uses: gittools/actions/gitversion/execute@v0.9.15
       with:
         useConfigFile: true
         configFilePath: "GitVersion.yml"
 
-    - name: Setup .NET Core
-      uses: actions/setup-dotnet@v1
-      with:
-        dotnet-version: 6.0.x
-
     # Cache packages for faster subsequent runs
-    - uses: actions/cache@v2
+    - uses: actions/cache@v3
       with:
         path: ~/.nuget/packages
         key: ${{ runner.os }}-nuget-${{ hashFiles('**/*.csproj') }}
@@ -44,7 +44,7 @@ jobs:
     - name: Restore
       working-directory: ./src
       run: >-
-        dotnet nuget add source --username USERNAME --password ${{ secrets.GH_PACKAGES_TOKEN }} --store-password-in-clear-text --name github https://nuget.pkg.github.com/CenterEdge/index.json
+        dotnet nuget add source --name github https://nuget.pkg.github.com/CenterEdge/index.json
         && dotnet restore ./CenterEdge.Async.sln
 
     - name: Build
diff --git a/.github/workflows/cleanup-packages.yml b/.github/workflows/cleanup-packages.yml
index 9656b08..77e1281 100644
--- a/.github/workflows/cleanup-packages.yml
+++ b/.github/workflows/cleanup-packages.yml
@@ -13,8 +13,9 @@ jobs:
       packages: write
 
     steps:
-    - uses: actions/delete-package-versions@v2
+    - uses: actions/delete-package-versions@v4
       with:
         package-name: CenterEdge.Async
+        package-type: nuget
         min-versions-to-keep: 30
         ignore-versions: ^(?!.*ci-pr).*$
diff --git a/src/CenterEdge.Async.Benchmarks/CenterEdge.Async.Benchmarks.csproj b/src/CenterEdge.Async.Benchmarks/CenterEdge.Async.Benchmarks.csproj
index dc90130..ea23682 100644
--- a/src/CenterEdge.Async.Benchmarks/CenterEdge.Async.Benchmarks.csproj
+++ b/src/CenterEdge.Async.Benchmarks/CenterEdge.Async.Benchmarks.csproj
@@ -14,8 +14,8 @@
     <IsPackable>false</IsPackable>
   </PropertyGroup>
   <ItemGroup>
-    <PackageReference Include="BenchmarkDotNet" Version="0.13.0" />
-    <PackageReference Include="BenchmarkDotNet.Diagnostics.Windows" Version="0.13.0" />
+    <PackageReference Include="BenchmarkDotNet" Version="0.13.5" />
+    <PackageReference Include="BenchmarkDotNet.Diagnostics.Windows" Version="0.13.5" />
   </ItemGroup>
   <ItemGroup>
     <ProjectReference Include="..\CenterEdge.Async\CenterEdge.Async.csproj" />
diff --git a/src/CenterEdge.Async.UnitTests/AsyncHelperTests.cs b/src/CenterEdge.Async.UnitTests/AsyncHelperTests.cs
index 089e84b..0f1efc8 100644
--- a/src/CenterEdge.Async.UnitTests/AsyncHelperTests.cs
+++ b/src/CenterEdge.Async.UnitTests/AsyncHelperTests.cs
@@ -168,32 +168,509 @@ public void RunSync_Task_DanglingContinuations_HandledOnParentSyncContext()
 
         #endregion
 
+        #region RunSyncWithState_Task
+
+        [Fact]
+        public void RunSyncWithState_Task_DoesAllTasks()
+        {
+            // Arrange
+
+            var i = 0;
+
+            // Act
+            AsyncHelper.RunSync((Func<int, Task>)(async _ =>
+            {
+                i += 1;
+                await Task.Delay(10);
+                i += 1;
+                await Task.Delay(10);
+                i += 1;
+            }), 1);
+
+            // Assert
+
+            Assert.Equal(3, i);
+        }
+
+        [Fact]
+        public async Task RunSyncWithState_StartsTasksAndCompletesSynchronously_DoesAllTasks()
+        {
+            // Replicates the case where continuations are queued but the main task completes synchronously
+            // so the work must be removed from the queue
+
+            // Arrange
+
+            var i = 0;
+
+            async Task IncrementAsync()
+            {
+                await Task.Yield();
+                Interlocked.Increment(ref i);
+            }
+
+            // Act
+            AsyncHelper.RunSync(state =>
+            {
+#pragma warning disable CS4014
+                for (var j = 0; j < 3; j++)
+                {
+                    var _ = IncrementAsync();
+                }
+#pragma warning restore CS4014
+
+                return Task.CompletedTask;
+            }, 1);
+
+            // Assert
+
+            await Task.Delay(500);
+            Assert.Equal(3, i);
+        }
+
+        [Fact]
+        public void RunSyncWithState_Task_ConfigureAwaitFalse_DoesAllTasks()
+        {
+            // Arrange
+
+            var i = 0;
+
+            // Act
+            AsyncHelper.RunSync((Func<int, Task>)(async _ =>
+            {
+                i += 1;
+                await Task.Delay(10).ConfigureAwait(false);
+                i += 1;
+                await Task.Delay(10).ConfigureAwait(false);
+                i += 1;
+            }), 1);
+
+            // Assert
+
+            Assert.Equal(3, i);
+        }
+
+        [Fact]
+        public void RunSyncWithState_Task_ExceptionAfterAwait_ThrowsException()
+        {
+            // Act/Assert
+            Assert.Throws<InvalidOperationException>(() =>
+                AsyncHelper.RunSync((Func<int, Task>)(async _ =>
+                {
+                    await Task.Delay(10);
+
+                    throw new InvalidOperationException();
+                }), 1));
+        }
+
+        [Fact]
+        public void RunSyncWithState_Task_ExceptionBeforeAwait_ThrowsException()
+        {
+            // Act/Assert
+            Assert.Throws<InvalidOperationException>(() =>
+                AsyncHelper.RunSync((Func<int, Task>)(_ => throw new InvalidOperationException()), 1));
+        }
+
+        [Fact]
+        public void RunSyncWithState_Task_ThrowsException_ResetsSyncContext()
+        {
+            // Arrange
+
+            var sync = new SynchronizationContext();
+            SynchronizationContext.SetSynchronizationContext(sync);
+
+            // Act
+            try
+            {
+                AsyncHelper.RunSync((Func<int, Task>)(_ => throw new InvalidOperationException()), 1);
+            }
+            catch (InvalidOperationException)
+            {
+                // Expected
+            }
+
+            // Assert
+
+            Assert.Equal(sync, SynchronizationContext.Current);
+        }
+
+        [Fact]
+        public void RunSyncWithState_Task_DanglingContinuations_HandledOnParentSyncContext()
+        {
+            // Arrange
+
+            var mockSync = new Mock<SynchronizationContext> { CallBase = true };
+            SynchronizationContext.SetSynchronizationContext(mockSync.Object);
+
+            var called = false;
+
+            // Act
+            AsyncHelper.RunSync((Func<int, Task>)(async _ =>
+            {
+                await Task.Yield();
+
+#pragma warning disable 4014
+                DelayedActionAsync(TimeSpan.FromMilliseconds(400), () => called = true);
+#pragma warning restore 4014
+            }), 1);
+
+            // Assert
+
+            Assert.False(called);
+
+            Thread.Sleep(500);
+
+            Assert.True(called);
+
+            mockSync.Verify(
+                m => m.Post(It.IsAny<SendOrPostCallback>(), It.IsAny<object>()),
+                Times.Once);
+        }
+
+        #endregion
+
         #region RunSync_ValueTask
 
         [Fact]
-        public void RunSync_ValueTask_DoesAllTasks()
+        public void RunSync_ValueTask_DoesAllTasks()
+        {
+            // Arrange
+
+            var i = 0;
+
+            // Act
+            AsyncHelper.RunSync((Func<ValueTask>)(async () =>
+            {
+                i += 1;
+                await Task.Delay(10);
+                i += 1;
+                await Task.Delay(10);
+                i += 1;
+            }));
+
+            // Assert
+
+            Assert.Equal(3, i);
+        }
+
+        [Fact]
+        public async Task RunSync_ValueTask_StartsTasksAndCompletesSynchronously_DoesAllTasks()
+        {
+            // Replicates the case where continuations are queued but the main task completes synchronously
+            // so the work must be removed from the queue
+
+            // Arrange
+
+            var i = 0;
+
+            async Task IncrementAsync()
+            {
+                await Task.Yield();
+                Interlocked.Increment(ref i);
+            }
+
+            // Act
+            AsyncHelper.RunSync(() =>
+            {
+#pragma warning disable CS4014
+                for (var j = 0; j < 3; j++)
+                {
+                    var _ = IncrementAsync();
+                }
+#pragma warning restore CS4014
+
+                return new ValueTask();
+            });
+
+            // Assert
+
+            await Task.Delay(500);
+            Assert.Equal(3, i);
+        }
+
+        [Fact]
+        public void RunSync_ValueTask_ConfigureAwaitFalse_DoesAllTasks()
+        {
+            // Arrange
+
+            var i = 0;
+
+            // Act
+            AsyncHelper.RunSync((Func<ValueTask>)(async () =>
+            {
+                i += 1;
+                await Task.Delay(10).ConfigureAwait(false);
+                i += 1;
+                await Task.Delay(10).ConfigureAwait(false);
+                i += 1;
+            }));
+
+            // Assert
+
+            Assert.Equal(3, i);
+        }
+
+        [Fact]
+        public void RunSync_ValueTask_ExceptionAfterAwait_ThrowsException()
+        {
+            // Act/Assert
+            Assert.Throws<InvalidOperationException>(() =>
+                AsyncHelper.RunSync((Func<ValueTask>)(async () =>
+                {
+                    await Task.Delay(10);
+
+                    throw new InvalidOperationException();
+                })));
+        }
+
+        [Fact]
+        public void RunSync_ValueTask_ExceptionBeforeAwait_ThrowsException()
+        {
+            // Act/Assert
+            Assert.Throws<InvalidOperationException>(() =>
+                AsyncHelper.RunSync((Func<ValueTask>)(() => throw new InvalidOperationException())));
+        }
+
+        [Fact]
+        public void RunSync_ValueTask_ThrowsException_ResetsSyncContext()
+        {
+            // Arrange
+
+            var sync = new SynchronizationContext();
+            SynchronizationContext.SetSynchronizationContext(sync);
+
+            // Act
+            try
+            {
+                AsyncHelper.RunSync((Func<ValueTask>)(() => throw new InvalidOperationException()));
+            }
+            catch (InvalidOperationException)
+            {
+                // Expected
+            }
+
+            // Assert
+
+            Assert.Equal(sync, SynchronizationContext.Current);
+        }
+
+        [Fact]
+        public void RunSync_ValueTask_DanglingContinuations_HandledOnParentSyncContext()
+        {
+            // Arrange
+
+            var mockSync = new Mock<SynchronizationContext> { CallBase = true };
+            SynchronizationContext.SetSynchronizationContext(mockSync.Object);
+
+            var called = false;
+
+            // Act
+            AsyncHelper.RunSync((Func<ValueTask>)(async () =>
+            {
+                await Task.Yield();
+
+#pragma warning disable 4014
+                DelayedActionAsync(TimeSpan.FromMilliseconds(400), () => called = true);
+#pragma warning restore 4014
+            }));
+
+            // Assert
+
+            Assert.False(called);
+
+            Thread.Sleep(500);
+
+            Assert.True(called);
+
+            mockSync.Verify(
+                m => m.Post(It.IsAny<SendOrPostCallback>(), It.IsAny<object>()),
+                Times.Once);
+        }
+
+        #endregion
+
+        #region RunSyncWithState_ValueTask
+
+        [Fact]
+        public void RunSyncWithState_ValueTask_DoesAllTasks()
+        {
+            // Arrange
+
+            var i = 0;
+
+            // Act
+            AsyncHelper.RunSync((Func<int, ValueTask>)(async state =>
+            {
+                i += 1;
+                await Task.Delay(10);
+                i += 1;
+                await Task.Delay(10);
+                i += 1;
+            }), 1);
+
+            // Assert
+
+            Assert.Equal(3, i);
+        }
+
+        [Fact]
+        public async Task RunSyncWithState_ValueTask_StartsTasksAndCompletesSynchronously_DoesAllTasks()
+        {
+            // Replicates the case where continuations are queued but the main task completes synchronously
+            // so the work must be removed from the queue
+
+            // Arrange
+
+            var i = 0;
+
+            async Task IncrementAsync()
+            {
+                await Task.Yield();
+                Interlocked.Increment(ref i);
+            }
+
+            // Act
+            AsyncHelper.RunSync(state =>
+            {
+#pragma warning disable CS4014
+                for (var j = 0; j < 3; j++)
+                {
+                    var _ = IncrementAsync();
+                }
+#pragma warning restore CS4014
+
+                return new ValueTask();
+            }, 1);
+
+            // Assert
+
+            await Task.Delay(500);
+            Assert.Equal(3, i);
+        }
+
+        [Fact]
+        public void RunSyncWithState_ValueTask_ConfigureAwaitFalse_DoesAllTasks()
+        {
+            // Arrange
+
+            var i = 0;
+
+            // Act
+            AsyncHelper.RunSync((Func<int, ValueTask>)(async state =>
+            {
+                i += 1;
+                await Task.Delay(10).ConfigureAwait(false);
+                i += 1;
+                await Task.Delay(10).ConfigureAwait(false);
+                i += 1;
+            }), 1);
+
+            // Assert
+
+            Assert.Equal(3, i);
+        }
+
+        [Fact]
+        public void RunSyncWithState_ValueTask_ExceptionAfterAwait_ThrowsException()
+        {
+            // Act/Assert
+            Assert.Throws<InvalidOperationException>(() =>
+                AsyncHelper.RunSync((Func<int, ValueTask>)(async state =>
+                {
+                    await Task.Delay(10);
+
+                    throw new InvalidOperationException();
+                }), 1));
+        }
+
+        [Fact]
+        public void RunSyncWithState_ValueTask_ExceptionBeforeAwait_ThrowsException()
+        {
+            // Act/Assert
+            Assert.Throws<InvalidOperationException>(() =>
+                AsyncHelper.RunSync((Func<int, ValueTask>)(_ => throw new InvalidOperationException()), 1));
+        }
+
+        [Fact]
+        public void RunSyncWithState_ValueTask_ThrowsException_ResetsSyncContext()
         {
             // Arrange
 
-            var i = 0;
+            var sync = new SynchronizationContext();
+            SynchronizationContext.SetSynchronizationContext(sync);
 
             // Act
-            AsyncHelper.RunSync((Func<ValueTask>)(async () =>
+            try
             {
-                i += 1;
+                AsyncHelper.RunSync((Func<int, ValueTask>)(_ => throw new InvalidOperationException()), 1);
+            }
+            catch (InvalidOperationException)
+            {
+                // Expected
+            }
+
+            // Assert
+
+            Assert.Equal(sync, SynchronizationContext.Current);
+        }
+
+        [Fact]
+        public void RunSyncWithState_ValueTask_DanglingContinuations_HandledOnParentSyncContext()
+        {
+            // Arrange
+
+            var mockSync = new Mock<SynchronizationContext> { CallBase = true };
+            SynchronizationContext.SetSynchronizationContext(mockSync.Object);
+
+            var called = false;
+
+            // Act
+            AsyncHelper.RunSync((Func<int, ValueTask>)(async state =>
+            {
+                await Task.Yield();
+
+#pragma warning disable 4014
+                DelayedActionAsync(TimeSpan.FromMilliseconds(400), () => called = true);
+#pragma warning restore 4014
+            }), 1);
+
+            // Assert
+
+            Assert.False(called);
+
+            Thread.Sleep(500);
+
+            Assert.True(called);
+
+            mockSync.Verify(
+                m => m.Post(It.IsAny<SendOrPostCallback>(), It.IsAny<object>()),
+                Times.Once);
+        }
+
+        #endregion
+
+        #region RunSync_TaskT
+
+        [Fact]
+        public void RunSync_TaskT_DoesAllTasks()
+        {
+            // Act
+            var result = AsyncHelper.RunSync((Func<Task<int>>)(async () =>
+            {
+                var i = 1;
                 await Task.Delay(10);
                 i += 1;
                 await Task.Delay(10);
                 i += 1;
+                return i;
             }));
 
             // Assert
 
-            Assert.Equal(3, i);
+            Assert.Equal(3, result);
         }
 
         [Fact]
-        public async Task RunSync_ValueTask_StartsTasksAndCompletesSynchronously_DoesAllTasks()
+        public async Task RunSync_TaskT_StartsTasksAndCompletesSynchronously_DoesAllTasks()
         {
             // Replicates the case where continuations are queued but the main task completes synchronously
             // so the work must be removed from the queue
@@ -218,7 +695,7 @@ async Task IncrementAsync()
                 }
 #pragma warning restore CS4014
 
-                return new ValueTask();
+                return Task.FromResult(true);
             });
 
             // Assert
@@ -228,33 +705,30 @@ async Task IncrementAsync()
         }
 
         [Fact]
-        public void RunSync_ValueTask_ConfigureAwaitFalse_DoesAllTasks()
+        public void RunSync_TaskT_ConfigureAwaitFalse_DoesAllTasks()
         {
-            // Arrange
-
-            var i = 0;
-
             // Act
-            AsyncHelper.RunSync((Func<ValueTask>)(async () =>
+            var result = AsyncHelper.RunSync((Func<Task<int>>)(async () =>
             {
-                i += 1;
+                var i = 1;
                 await Task.Delay(10).ConfigureAwait(false);
                 i += 1;
                 await Task.Delay(10).ConfigureAwait(false);
                 i += 1;
+                return i;
             }));
 
             // Assert
 
-            Assert.Equal(3, i);
+            Assert.Equal(3, result);
         }
 
         [Fact]
-        public void RunSync_ValueTask_ExceptionAfterAwait_ThrowsException()
+        public void RunSync_TaskT_ExceptionAfterAwait_ThrowsException()
         {
             // Act/Assert
             Assert.Throws<InvalidOperationException>(() =>
-                AsyncHelper.RunSync((Func<ValueTask>)(async () =>
+                AsyncHelper.RunSync((Func<Task<int>>)(async () =>
                 {
                     await Task.Delay(10);
 
@@ -263,15 +737,15 @@ public void RunSync_ValueTask_ExceptionAfterAwait_ThrowsException()
         }
 
         [Fact]
-        public void RunSync_ValueTask_ExceptionBeforeAwait_ThrowsException()
+        public void RunSync_TaskT_ExceptionBeforeAwait_ThrowsException()
         {
             // Act/Assert
             Assert.Throws<InvalidOperationException>(() =>
-                AsyncHelper.RunSync((Func<ValueTask>)(() => throw new InvalidOperationException())));
+                AsyncHelper.RunSync((Func<Task<int>>)(() => throw new InvalidOperationException())));
         }
 
         [Fact]
-        public void RunSync_ValueTask_ThrowsException_ResetsSyncContext()
+        public void RunSync_TaskT_ThrowsException_ResetsSyncContext()
         {
             // Arrange
 
@@ -281,7 +755,7 @@ public void RunSync_ValueTask_ThrowsException_ResetsSyncContext()
             // Act
             try
             {
-                AsyncHelper.RunSync((Func<ValueTask>)(() => throw new InvalidOperationException()));
+                AsyncHelper.RunSync((Func<Task<object>>)(() => throw new InvalidOperationException()));
             }
             catch (InvalidOperationException)
             {
@@ -294,7 +768,7 @@ public void RunSync_ValueTask_ThrowsException_ResetsSyncContext()
         }
 
         [Fact]
-        public void RunSync_ValueTask_DanglingContinuations_HandledOnParentSyncContext()
+        public void RunSync_TaskT_DanglingContinuations_HandledOnParentSyncContext()
         {
             // Arrange
 
@@ -304,13 +778,15 @@ public void RunSync_ValueTask_DanglingContinuations_HandledOnParentSyncContext()
             var called = false;
 
             // Act
-            AsyncHelper.RunSync((Func<ValueTask>)(async () =>
+            AsyncHelper.RunSync((Func<Task<int>>)(async () =>
             {
                 await Task.Yield();
 
 #pragma warning disable 4014
                 DelayedActionAsync(TimeSpan.FromMilliseconds(400), () => called = true);
 #pragma warning restore 4014
+
+                return 0;
             }));
 
             // Assert
@@ -328,13 +804,13 @@ public void RunSync_ValueTask_DanglingContinuations_HandledOnParentSyncContext()
 
         #endregion
 
-        #region RunSync_TaskT
+        #region RunSyncWithState_TaskT
 
         [Fact]
-        public void RunSync_TaskT_DoesAllTasks()
+        public void RunSyncWithState_TaskT_DoesAllTasks()
         {
             // Act
-            var result = AsyncHelper.RunSync((Func<Task<int>>)(async () =>
+            var result = AsyncHelper.RunSync((Func<int, Task<int>>)(async state =>
             {
                 var i = 1;
                 await Task.Delay(10);
@@ -342,7 +818,7 @@ public void RunSync_TaskT_DoesAllTasks()
                 await Task.Delay(10);
                 i += 1;
                 return i;
-            }));
+            }), 1);
 
             // Assert
 
@@ -350,7 +826,7 @@ public void RunSync_TaskT_DoesAllTasks()
         }
 
         [Fact]
-        public async Task RunSync_TaskT_StartsTasksAndCompletesSynchronously_DoesAllTasks()
+        public async Task RunSyncWithState_TaskT_StartsTasksAndCompletesSynchronously_DoesAllTasks()
         {
             // Replicates the case where continuations are queued but the main task completes synchronously
             // so the work must be removed from the queue
@@ -366,7 +842,7 @@ async Task IncrementAsync()
             }
 
             // Act
-            AsyncHelper.RunSync(() =>
+            AsyncHelper.RunSync(state =>
             {
 #pragma warning disable CS4014
                 for (var j = 0; j < 3; j++)
@@ -376,7 +852,7 @@ async Task IncrementAsync()
 #pragma warning restore CS4014
 
                 return Task.FromResult(true);
-            });
+            }, 1);
 
             // Assert
 
@@ -385,10 +861,10 @@ async Task IncrementAsync()
         }
 
         [Fact]
-        public void RunSync_TaskT_ConfigureAwaitFalse_DoesAllTasks()
+        public void RunSyncWithState_TaskT_ConfigureAwaitFalse_DoesAllTasks()
         {
             // Act
-            var result = AsyncHelper.RunSync((Func<Task<int>>)(async () =>
+            var result = AsyncHelper.RunSync((Func<int, Task<int>>)(async state =>
             {
                 var i = 1;
                 await Task.Delay(10).ConfigureAwait(false);
@@ -396,7 +872,7 @@ public void RunSync_TaskT_ConfigureAwaitFalse_DoesAllTasks()
                 await Task.Delay(10).ConfigureAwait(false);
                 i += 1;
                 return i;
-            }));
+            }), 1);
 
             // Assert
 
@@ -404,28 +880,28 @@ public void RunSync_TaskT_ConfigureAwaitFalse_DoesAllTasks()
         }
 
         [Fact]
-        public void RunSync_TaskT_ExceptionAfterAwait_ThrowsException()
+        public void RunSyncWithState_TaskT_ExceptionAfterAwait_ThrowsException()
         {
             // Act/Assert
             Assert.Throws<InvalidOperationException>(() =>
-                AsyncHelper.RunSync((Func<Task<int>>)(async () =>
+                AsyncHelper.RunSync((Func<int, Task<int>>)(async state =>
                 {
                     await Task.Delay(10);
 
                     throw new InvalidOperationException();
-                })));
+                }), 1));
         }
 
         [Fact]
-        public void RunSync_TaskT_ExceptionBeforeAwait_ThrowsException()
+        public void RunSyncWithState_TaskT_ExceptionBeforeAwait_ThrowsException()
         {
             // Act/Assert
             Assert.Throws<InvalidOperationException>(() =>
-                AsyncHelper.RunSync((Func<Task<int>>)(() => throw new InvalidOperationException())));
+                AsyncHelper.RunSync((Func<int, Task<int>>)(_ => throw new InvalidOperationException()), 1));
         }
 
         [Fact]
-        public void RunSync_TaskT_ThrowsException_ResetsSyncContext()
+        public void RunSyncWithState_TaskT_ThrowsException_ResetsSyncContext()
         {
             // Arrange
 
@@ -435,7 +911,7 @@ public void RunSync_TaskT_ThrowsException_ResetsSyncContext()
             // Act
             try
             {
-                AsyncHelper.RunSync((Func<Task<object>>)(() => throw new InvalidOperationException()));
+                AsyncHelper.RunSync((Func<int, Task<object>>)(_ => throw new InvalidOperationException()), 1);
             }
             catch (InvalidOperationException)
             {
@@ -448,7 +924,7 @@ public void RunSync_TaskT_ThrowsException_ResetsSyncContext()
         }
 
         [Fact]
-        public void RunSync_TaskT_DanglingContinuations_HandledOnParentSyncContext()
+        public void RunSyncWithState_TaskT_DanglingContinuations_HandledOnParentSyncContext()
         {
             // Arrange
 
@@ -458,7 +934,7 @@ public void RunSync_TaskT_DanglingContinuations_HandledOnParentSyncContext()
             var called = false;
 
             // Act
-            AsyncHelper.RunSync((Func<Task<int>>)(async () =>
+            AsyncHelper.RunSync((Func<int, Task<int>>)(async state =>
             {
                 await Task.Yield();
 
@@ -467,7 +943,7 @@ public void RunSync_TaskT_DanglingContinuations_HandledOnParentSyncContext()
 #pragma warning restore 4014
 
                 return 0;
-            }));
+            }), 1);
 
             // Assert
 
@@ -640,6 +1116,162 @@ public void RunSync_ValueTaskT_DanglingContinuations_HandledOnParentSyncContext(
 
         #endregion
 
+        #region RunSyncWithState_ValueTaskT
+
+        [Fact]
+        public void RunSyncWithState_ValueTaskT_DoesAllTasks()
+        {
+            // Act
+            var result = AsyncHelper.RunSync((Func<int, ValueTask<int>>)(async state =>
+            {
+                var i = 1;
+                await Task.Delay(10);
+                i += 1;
+                await Task.Delay(10);
+                i += 1;
+                return i;
+            }), 1);
+
+            // Assert
+
+            Assert.Equal(3, result);
+        }
+
+        [Fact]
+        public async Task RunSyncWithState_ValueTaskT_StartsTasksAndCompletesSynchronously_DoesAllTasks()
+        {
+            // Replicates the case where continuations are queued but the main task completes synchronously
+            // so the work must be removed from the queue
+
+            // Arrange
+
+            var i = 0;
+
+            async Task IncrementAsync()
+            {
+                await Task.Yield();
+                Interlocked.Increment(ref i);
+            }
+
+            // Act
+            AsyncHelper.RunSync(state =>
+            {
+#pragma warning disable CS4014
+                for (var j = 0; j < 3; j++)
+                {
+                    var _ = IncrementAsync();
+                }
+#pragma warning restore CS4014
+
+                return new ValueTask<bool>(true);
+            }, 1);
+
+            // Assert
+
+            await Task.Delay(500);
+            Assert.Equal(3, i);
+        }
+
+        [Fact]
+        public void RunSyncWithState_ValueTaskT_ConfigureAwaitFalse_DoesAllTasks()
+        {
+            // Act
+            var result = AsyncHelper.RunSync((Func<int, ValueTask<int>>)(async state =>
+            {
+                var i = 1;
+                await Task.Delay(10).ConfigureAwait(false);
+                i += 1;
+                await Task.Delay(10).ConfigureAwait(false);
+                i += 1;
+                return i;
+            }), 1);
+
+            // Assert
+
+            Assert.Equal(3, result);
+        }
+
+        [Fact]
+        public void RunSyncWithState_ValueTaskT_ExceptionAfterAwait_ThrowsException()
+        {
+            // Act/Assert
+            Assert.Throws<InvalidOperationException>(() =>
+                AsyncHelper.RunSync((Func<int, ValueTask<int>>)(async state =>
+                {
+                    await Task.Delay(10);
+
+                    throw new InvalidOperationException();
+                }), 1));
+        }
+
+        [Fact]
+        public void RunSyncWithState_ValueTaskT_ExceptionBeforeAwait_ThrowsException()
+        {
+            // Act/Assert
+            Assert.Throws<InvalidOperationException>(() =>
+                AsyncHelper.RunSync((Func<int, ValueTask<int>>)(_ => throw new InvalidOperationException()), 1));
+        }
+
+        [Fact]
+        public void RunSyncWithState_ValueTaskT_ThrowsException_ResetsSyncContext()
+        {
+            // Arrange
+
+            var sync = new SynchronizationContext();
+            SynchronizationContext.SetSynchronizationContext(sync);
+
+            // Act
+            try
+            {
+                AsyncHelper.RunSync((Func<int, ValueTask<object>>)(_ => throw new InvalidOperationException()), 1);
+            }
+            catch (InvalidOperationException)
+            {
+                // Expected
+            }
+
+            // Assert
+
+            Assert.Equal(sync, SynchronizationContext.Current);
+        }
+
+        [Fact]
+        public void RunSyncWithState_ValueTaskT_DanglingContinuations_HandledOnParentSyncContext()
+        {
+            // Arrange
+
+            var mockSync = new Mock<SynchronizationContext> { CallBase = true };
+            SynchronizationContext.SetSynchronizationContext(mockSync.Object);
+
+            var called = false;
+
+            // Act
+            AsyncHelper.RunSync((Func<int, ValueTask<int>>)(async state =>
+            {
+                await Task.Yield();
+
+#pragma warning disable 4014
+                DelayedActionAsync(TimeSpan.FromMilliseconds(400), () => called = true);
+#pragma warning restore 4014
+
+                return 0;
+            }), 1);
+
+            // Assert
+
+            Assert.False(called);
+
+            Thread.Sleep(500);
+
+            Assert.True(called);
+
+            mockSync.Verify(
+                m => m.Post(It.IsAny<SendOrPostCallback>(), It.IsAny<object>()),
+                Times.Once);
+        }
+
+        #endregion
+
         #region Helpers
 
         private static readonly AsyncLocal<int> asyncLocalField = new();
diff --git a/src/CenterEdge.Async.UnitTests/CenterEdge.Async.UnitTests.csproj b/src/CenterEdge.Async.UnitTests/CenterEdge.Async.UnitTests.csproj
index 34fe6e9..ae3f758 100644
--- a/src/CenterEdge.Async.UnitTests/CenterEdge.Async.UnitTests.csproj
+++ b/src/CenterEdge.Async.UnitTests/CenterEdge.Async.UnitTests.csproj
@@ -10,19 +10,18 @@
   </PropertyGroup>
 
   <ItemGroup>
-    <PackageReference Include="coverlet.collector" Version="3.1.2">
+    <PackageReference Include="coverlet.collector" Version="6.0.0">
       <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
       <PrivateAssets>all</PrivateAssets>
     </PackageReference>
-    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.1.0" />
-    <PackageReference Include="Microsoft.NETFramework.ReferenceAssemblies" Version="1.0.2">
+    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.6.2" />
+    <PackageReference Include="Microsoft.NETFramework.ReferenceAssemblies" Version="1.0.3">
       <PrivateAssets>all</PrivateAssets>
       <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
     </PackageReference>
-    <PackageReference Include="xunit" Version="2.4.1" />
-    <PackageReference Include="Moq" Version="4.17.2" />
-    <PackageReference Include="xunit" Version="2.4.1" />
-    <PackageReference Include="xunit.runner.visualstudio" Version="2.4.3">
+    <PackageReference Include="Moq" Version="4.18.4" />
+    <PackageReference Include="xunit" Version="2.4.2" />
+    <PackageReference Include="xunit.runner.visualstudio" Version="2.4.5">
       <PrivateAssets>all</PrivateAssets>
       <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
     </PackageReference>
diff --git a/src/CenterEdge.Async/AsyncHelper.cs b/src/CenterEdge.Async/AsyncHelper.cs
index f0dfb0e..4fbea06 100644
--- a/src/CenterEdge.Async/AsyncHelper.cs
+++ b/src/CenterEdge.Async/AsyncHelper.cs
@@ -19,9 +19,9 @@ public static class AsyncHelper
         /// <summary>
         /// Executes an async <see cref="Task"/> method with no return value synchronously.
         /// </summary>
-        /// <param name="task"><see cref="Task"/> method to execute</param>
+        /// <param name="task"><see cref="Task"/> method to execute.</param>
         /// <remarks>
-        /// DO NOT use this methods unless absolutely necessary. Calling async code from sync code is an anti-pattern
+        /// DO NOT use this method unless absolutely necessary. Calling async code from sync code is an anti-pattern
         /// in most cases. This method is provided to assist in gradual conversion from sync to async code.
         /// </remarks>
         public static void RunSync(Func<Task> task)
@@ -51,12 +51,48 @@ public static void RunSync(Func<Task> task)
             }
         }
 
+        /// <summary>
+        /// Executes an async <see cref="Task"/> method with no return value synchronously.
+        /// </summary>
+        /// <param name="task"><see cref="Task"/> method to execute.</param>
+        /// <param name="state">State to pass to the method.</param>
+        /// <remarks>
+        /// DO NOT use this method unless absolutely necessary. Calling async code from sync code is an anti-pattern
+        /// in most cases. This method is provided to assist in gradual conversion from sync to async code.
+        /// </remarks>
+        public static void RunSync<TState>(Func<TState, Task> task, TState state)
+        {
+            var oldContext = SynchronizationContext.Current;
+            using var synch = new ExclusiveSynchronizationContext<TaskAwaiter>(oldContext);
+            SynchronizationContext.SetSynchronizationContext(synch);
+            try
+            {
+                var awaiter = task(state).GetAwaiter();
+
+                if (!awaiter.IsCompleted)
+                {
+                    synch.Run(awaiter);
+                }
+                else
+                {
+                    synch.RunAlreadyComplete();
+                }
+
+                // Throw any exception returned by the task
+                awaiter.GetResult();
+            }
+            finally
+            {
+                SynchronizationContext.SetSynchronizationContext(oldContext);
+            }
+        }
+
         /// <summary>
         /// Executes an async <see cref="ValueTask"/> method which has a void return value synchronously.
         /// </summary>
-        /// <param name="task"><see cref="ValueTask"/> method to execute</param>
+        /// <param name="task"><see cref="ValueTask"/> method to execute.</param>
         /// <remarks>
-        /// DO NOT use this methods unless absolutely necessary. Calling async code from sync code is an anti-pattern
+        /// DO NOT use this method unless absolutely necessary. Calling async code from sync code is an anti-pattern
         /// in most cases. This method is provided to assist in gradual conversion from sync to async code.
         /// </remarks>
         public static void RunSync(Func<ValueTask> task)
@@ -86,13 +122,49 @@ public static void RunSync(Func<ValueTask> task)
             }
         }
 
+        /// <summary>
+        /// Executes an async <see cref="ValueTask"/> method which has a void return value synchronously.
+        /// </summary>
+        /// <param name="task"><see cref="ValueTask"/> method to execute.</param>
+        /// <param name="state">State to pass to the method.</param>
+        /// <remarks>
+        /// DO NOT use this method unless absolutely necessary. Calling async code from sync code is an anti-pattern
+        /// in most cases. This method is provided to assist in gradual conversion from sync to async code.
+        /// </remarks>
+        public static void RunSync<TState>(Func<TState, ValueTask> task, TState state)
+        {
+            var oldContext = SynchronizationContext.Current;
+            using var synch = new ExclusiveSynchronizationContext<ValueTaskAwaiter>(oldContext);
+            SynchronizationContext.SetSynchronizationContext(synch);
+            try
+            {
+                var awaiter = task(state).GetAwaiter();
+
+                if (!awaiter.IsCompleted)
+                {
+                    synch.Run(awaiter);
+                }
+                else
+                {
+                    synch.RunAlreadyComplete();
+                }
+
+                // Throw any exception returned by the task
+                awaiter.GetResult();
+            }
+            finally
+            {
+                SynchronizationContext.SetSynchronizationContext(oldContext);
+            }
+        }
+
         /// <summary>
         /// Executes an async <see cref="Task{T}"/> method which has a void return value synchronously.
         /// </summary>
-        /// <param name="task"><see cref="Task{T}"/> method to execute</param>
+        /// <param name="task"><see cref="Task{T}"/> method to execute.</param>
         /// <returns>The asynchronous result.</returns>
         /// <remarks>
-        /// DO NOT use this methods unless absolutely necessary. Calling async code from sync code is an anti-pattern
+        /// DO NOT use this method unless absolutely necessary. Calling async code from sync code is an anti-pattern
         /// in most cases. This method is provided to assist in gradual conversion from sync to async code.
         /// </remarks>
         public static T RunSync<T>(Func<Task<T>> task)
@@ -122,13 +194,50 @@ public static T RunSync<T>(Func<Task<T>> task)
             }
         }
 
+        /// <summary>
+        /// Executes an async <see cref="Task{T}"/> method which has a void return value synchronously.
+        /// </summary>
+        /// <param name="task"><see cref="Task{T}"/> method to execute.</param>
+        /// <param name="state">State to pass to the method.</param>
+        /// <returns>The asynchronous result.</returns>
+        /// <remarks>
+        /// DO NOT use this method unless absolutely necessary. Calling async code from sync code is an anti-pattern
+        /// in most cases. This method is provided to assist in gradual conversion from sync to async code.
+        /// </remarks>
+        public static T RunSync<T, TState>(Func<TState, Task<T>> task, TState state)
+        {
+            var oldContext = SynchronizationContext.Current;
+            using var synch = new ExclusiveSynchronizationContext<TaskAwaiter<T>>(oldContext);
+            SynchronizationContext.SetSynchronizationContext(synch);
+            try
+            {
+                var awaiter = task(state).GetAwaiter();
+
+                if (!awaiter.IsCompleted)
+                {
+                    synch.Run(awaiter);
+                }
+                else
+                {
+                    synch.RunAlreadyComplete();
+                }
+
+                // Throw any exception returned by the task or return the result
+                return awaiter.GetResult();
+            }
+            finally
+            {
+                SynchronizationContext.SetSynchronizationContext(oldContext);
+            }
+        }
+
         /// <summary>
         /// Executes an async <see cref="ValueTask{T}"/> method which has a void return value synchronously.
         /// </summary>
-        /// <param name="task"><see cref="ValueTask{T}"/> method to execute</param>
+        /// <param name="task"><see cref="ValueTask{T}"/> method to execute.</param>
         /// <returns>The asynchronous result.</returns>
         /// <remarks>
-        /// DO NOT use this methods unless absolutely necessary. Calling async code from sync code is an anti-pattern
+        /// DO NOT use this method unless absolutely necessary. Calling async code from sync code is an anti-pattern
         /// in most cases. This method is provided to assist in gradual conversion from sync to async code.
         /// </remarks>
         public static T RunSync<T>(Func<ValueTask<T>> task)
@@ -158,6 +267,43 @@ public static T RunSync<T>(Func<ValueTask<T>> task)
             }
         }
 
+        /// <summary>
+        /// Executes an async <see cref="ValueTask{T}"/> method which has a void return value synchronously.
+        /// </summary>
+        /// <param name="task"><see cref="ValueTask{T}"/> method to execute.</param>
+        /// <param name="state">State to pass to the method.</param>
+        /// <returns>The asynchronous result.</returns>
+        /// <remarks>
+        /// DO NOT use this method unless absolutely necessary. Calling async code from sync code is an anti-pattern
+        /// in most cases. This method is provided to assist in gradual conversion from sync to async code.
+        /// </remarks>
+        public static T RunSync<T, TState>(Func<TState, ValueTask<T>> task, TState state)
+        {
+            var oldContext = SynchronizationContext.Current;
+            using var synch = new ExclusiveSynchronizationContext<ValueTaskAwaiter<T>>(oldContext);
+            SynchronizationContext.SetSynchronizationContext(synch);
+            try
+            {
+                var awaiter = task(state).GetAwaiter();
+
+                if (!awaiter.IsCompleted)
+                {
+                    synch.Run(awaiter);
+                }
+                else
+                {
+                    synch.RunAlreadyComplete();
+                }
+
+                // Throw any exception returned by the task or return the result
+                return awaiter.GetResult();
+            }
+            finally
+            {
+                SynchronizationContext.SetSynchronizationContext(oldContext);
+            }
+        }
+
         // Note: Sealing this class can help JIT make non-virtual method calls and inlined method calls for virtual methods
         private sealed class ExclusiveSynchronizationContext<TAwaiter> : SynchronizationContext, IDisposable
             where TAwaiter : struct, ICriticalNotifyCompletion
diff --git a/src/CenterEdge.Async/CenterEdge.Async.csproj b/src/CenterEdge.Async/CenterEdge.Async.csproj
index 3da05da..8989e79 100644
--- a/src/CenterEdge.Async/CenterEdge.Async.csproj
+++ b/src/CenterEdge.Async/CenterEdge.Async.csproj
@@ -1,7 +1,7 @@
 <Project Sdk="Microsoft.NET.Sdk">
 
   <PropertyGroup>
-    <TargetFrameworks>netstandard2.0;netstandard2.1;net5.0</TargetFrameworks>
+    <TargetFrameworks>netstandard2.0;netstandard2.1;net6.0</TargetFrameworks>
 
     <LangVersion>10</LangVersion>
     <Nullable>enable</Nullable>
@@ -16,7 +16,7 @@
   </PropertyGroup>
 
   <ItemGroup>
-    <PackageReference Include="Microsoft.SourceLink.GitHub" Version="1.0.0">
+    <PackageReference Include="Microsoft.SourceLink.GitHub" Version="1.1.1">
       <PrivateAssets>all</PrivateAssets>
       <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
     </PackageReference>