diff --git a/TUnit.Assertions.Tests/WaitsForAssertionTests.cs b/TUnit.Assertions.Tests/WaitsForAssertionTests.cs
index 9ff2ed7e80..9cfb5ffca8 100644
--- a/TUnit.Assertions.Tests/WaitsForAssertionTests.cs
+++ b/TUnit.Assertions.Tests/WaitsForAssertionTests.cs
@@ -407,6 +407,110 @@ public async Task WaitsFor_WithIsNotNull_ReturnsResolvedValue_Issue3623()
         await Assert.That(entity.IsReady).IsEqualTo(true);
     }
 
+    [Test]
+    public async Task WaitsFor_PropagatesExternalCancellation_Before_Internal_Timeout()
+    {
+        using var cts = new CancellationTokenSource();
+        cts.CancelAfter(TimeSpan.FromMilliseconds(100));
+
+        var stopwatch = Stopwatch.StartNew();
+
+        var act = async () => await Assert.That(() => false)
+            .WaitsFor(
+                assert => assert.IsTrue(),
+                timeout: TimeSpan.FromSeconds(30),
+                cancellationToken: cts.Token);
+
+        await Assert.That(act).Throws<OperationCanceledException>();
+
+        stopwatch.Stop();
+
+        await Assert.That(stopwatch.Elapsed).IsLessThan(TimeSpan.FromSeconds(1));
+    }
+
+    [Test]
+    public async Task WaitsFor_Throws_AssertionException_On_Internal_Timeout_When_Token_Not_Cancelled()
+    {
+        using var cts = new CancellationTokenSource();
+
+        var act = async () => await Assert.That(() => false)
+            .WaitsFor(
+                assert => assert.IsTrue(),
+                timeout: TimeSpan.FromMilliseconds(200),
+                cancellationToken: cts.Token);
+
+        await Assert.That(act).Throws<AssertionException>();
+    }
+
+    [Test]
+    public async Task WaitsFor_Honours_PreCancelled_Token_Before_First_Poll()
+    {
+        using var cts = new CancellationTokenSource();
+        cts.Cancel();
+
+        var stopwatch = Stopwatch.StartNew();
+
+        var act = async () => await Assert.That(() => false)
+            .WaitsFor(
+                assert => assert.IsTrue(),
+                timeout: TimeSpan.FromSeconds(5),
+                cancellationToken: cts.Token);
+
+        await Assert.That(act).Throws<OperationCanceledException>();
+
+        stopwatch.Stop();
+
+        await Assert.That(stopwatch.Elapsed).IsLessThan(TimeSpan.FromMilliseconds(500));
+    }
+
+    [Test]
+    public async Task Eventually_PropagatesExternalCancellation_Before_Internal_Timeout()
+    {
+        using var cts = new CancellationTokenSource();
+        cts.CancelAfter(TimeSpan.FromMilliseconds(100));
+
+        var stopwatch = Stopwatch.StartNew();
+
+        var act = async () => await Assert.That(() => false)
+            .Eventually(
+                assert => assert.IsTrue(),
+                timeout: TimeSpan.FromSeconds(30),
+                cancellationToken: cts.Token);
+
+        await Assert.That(act).Throws<OperationCanceledException>();
+
+        stopwatch.Stop();
+
+        await Assert.That(stopwatch.Elapsed).IsLessThan(TimeSpan.FromSeconds(1));
+    }
+
+    [Test]
+    public async Task WaitsFor_Propagates_OCE_When_Predicate_Observes_Supplied_Token()
+    {
+        using var cts = new CancellationTokenSource();
+        cts.CancelAfter(TimeSpan.FromMilliseconds(50));
+
+        Func<bool> tokenAwarePredicate = () =>
+        {
+            cts.Token.ThrowIfCancellationRequested();
+            return false;
+        };
+
+        var stopwatch = Stopwatch.StartNew();
+
+        var act = async () => await Assert.That(tokenAwarePredicate)
+            .WaitsFor(
+                assert => assert.IsTrue(),
+                timeout: TimeSpan.FromSeconds(30),
+                cancellationToken: cts.Token);
+
+        await Assert.That(act).Throws<OperationCanceledException>();
+
+        stopwatch.Stop();
+
+        await Assert.That(stopwatch.Elapsed).IsLessThan(TimeSpan.FromMilliseconds(500));
+    }
+
     // Helper class for testing complex objects
     private class TestEntity
     {
diff --git a/TUnit.Assertions/Conditions/WaitsForAssertion.cs b/TUnit.Assertions/Conditions/WaitsForAssertion.cs
index e57df59e0f..992886004e 100644
--- a/TUnit.Assertions/Conditions/WaitsForAssertion.cs
+++ b/TUnit.Assertions/Conditions/WaitsForAssertion.cs
@@ -15,17 +15,20 @@ public class WaitsForAssertion<TValue> : Assertion<TValue>
     private readonly Func<IAssertionSource<TValue>, Assertion<TValue>> _assertionBuilder;
     private readonly TimeSpan _timeout;
     private readonly TimeSpan _pollingInterval;
+    private readonly CancellationToken _cancellationToken;
 
     public WaitsForAssertion(
         AssertionContext<TValue> context,
         Func<IAssertionSource<TValue>, Assertion<TValue>> assertionBuilder,
         TimeSpan timeout,
-        TimeSpan? pollingInterval = null)
+        TimeSpan? pollingInterval = null,
+        CancellationToken cancellationToken = default)
         : base(context)
     {
         _assertionBuilder = assertionBuilder ?? throw new ArgumentNullException(nameof(assertionBuilder));
         _timeout = timeout;
         _pollingInterval = pollingInterval ?? TimeSpan.FromMilliseconds(10);
+        _cancellationToken = cancellationToken;
 
         if (_timeout <= TimeSpan.Zero)
         {
@@ -44,10 +47,20 @@ protected override async Task<AssertionResult> CheckAsync(EvaluationMetadata<TVa
         Exception? lastException = null;
         var attemptCount = 0;
 
-        using var cts = new CancellationTokenSource(_timeout);
+        // Link the supplied cancellation token with an internal timeout source so the polling
+        // loop honours both: external cancellation propagates as OperationCanceledException,
+        // and the internal timeout still produces the standard AssertionResult.Failed path.
+        // When the caller did not supply a cancellable token, the linking step is skipped to
+        // avoid the registration overhead.
+        using var linkedCts = _cancellationToken.CanBeCanceled
+            ? CancellationTokenSource.CreateLinkedTokenSource(_cancellationToken)
+            : new CancellationTokenSource();
+        linkedCts.CancelAfter(_timeout);
 
         while (stopwatch.Elapsed < _timeout)
         {
+            _cancellationToken.ThrowIfCancellationRequested();
+
             attemptCount++;
 
             try
@@ -71,7 +84,11 @@ protected override async Task<AssertionResult> CheckAsync(EvaluationMetadata<TVa
 
                 try
                 {
-                    await Task.Delay(_pollingInterval, cts.Token);
+                    await Task.Delay(_pollingInterval, linkedCts.Token);
+                }
+                catch (OperationCanceledException) when (_cancellationToken.IsCancellationRequested)
+                {
+                    throw;
                 }
                 catch (OperationCanceledException)
                 {
diff --git a/TUnit.Assertions/Extensions/AssertionExtensions.cs b/TUnit.Assertions/Extensions/AssertionExtensions.cs
index 72a27a2da8..d80570af2c 100644
--- a/TUnit.Assertions/Extensions/AssertionExtensions.cs
+++ b/TUnit.Assertions/Extensions/AssertionExtensions.cs
@@ -1719,6 +1719,7 @@ public static CompletesWithinAsyncAssertion CompletesWithin(
     /// <param name="assertionBuilder">A function that builds the assertion to be evaluated on each poll</param>
     /// <param name="timeout">The maximum time to wait for the assertion to pass</param>
     /// <param name="pollingInterval">The interval between polling attempts (defaults to 10ms if not specified)</param>
+    /// <param name="cancellationToken">A token to cancel the polling loop. External cancellation throws <see cref="OperationCanceledException"/>; the internal timeout still produces the standard <see cref="Exceptions.AssertionException"/>.</param>
     /// <param name="timeoutExpression">Captured expression for the timeout parameter</param>
     /// <param name="pollingIntervalExpression">Captured expression for the polling interval parameter</param>
     /// <returns>An assertion that can be awaited or chained with And/Or</returns>
@@ -1727,12 +1728,13 @@ public static WaitsForAssertion<TValue> WaitsFor<TValue>(
         Func<IAssertionSource<TValue>, Assertion<TValue>> assertionBuilder,
         TimeSpan timeout,
         TimeSpan? pollingInterval = null,
+        CancellationToken cancellationToken = default,
         [CallerArgumentExpression(nameof(timeout))] string? timeoutExpression = null,
         [CallerArgumentExpression(nameof(pollingInterval))] string? pollingIntervalExpression = null)
     {
         var intervalExpr = pollingInterval.HasValue ? $", pollingInterval: {pollingIntervalExpression}" : "";
         source.Context.ExpressionBuilder.Append($".WaitsFor(..., timeout: {timeoutExpression}{intervalExpr})");
-        return new WaitsForAssertion<TValue>(source.Context, assertionBuilder, timeout, pollingInterval);
+        return new WaitsForAssertion<TValue>(source.Context, assertionBuilder, timeout, pollingInterval, cancellationToken);
     }
 
     /// <summary>
@@ -1745,6 +1747,7 @@ public static WaitsForAssertion<TValue> WaitsFor<TValue>(
     /// <param name="assertionBuilder">A function that builds the assertion to be evaluated on each poll</param>
     /// <param name="timeout">The maximum time to wait for the assertion to pass</param>
     /// <param name="pollingInterval">The interval between polling attempts (defaults to 10ms if not specified)</param>
+    /// <param name="cancellationToken">A token to cancel the polling loop. External cancellation throws <see cref="OperationCanceledException"/>; the internal timeout still produces the standard <see cref="Exceptions.AssertionException"/>.</param>
     /// <param name="timeoutExpression">Captured expression for the timeout parameter</param>
     /// <param name="pollingIntervalExpression">Captured expression for the polling interval parameter</param>
     /// <returns>An assertion that can be awaited or chained with And/Or</returns>
@@ -1753,10 +1756,11 @@ public static WaitsForAssertion<TValue> Eventually<TValue>(
         Func<IAssertionSource<TValue>, Assertion<TValue>> assertionBuilder,
         TimeSpan timeout,
         TimeSpan? pollingInterval = null,
+        CancellationToken cancellationToken = default,
         [CallerArgumentExpression(nameof(timeout))] string? timeoutExpression = null,
         [CallerArgumentExpression(nameof(pollingInterval))] string? pollingIntervalExpression = null)
     {
-        return source.WaitsFor(assertionBuilder, timeout, pollingInterval, timeoutExpression, pollingIntervalExpression);
+        return source.WaitsFor(assertionBuilder, timeout, pollingInterval, cancellationToken, timeoutExpression, pollingIntervalExpression);
     }
 
     private static Action GetActionFromDelegate(DelegateAssertion source)
diff --git a/TUnit.PublicAPI/Tests.Assertions_Library_Has_No_API_Changes.DotNet10_0.verified.txt b/TUnit.PublicAPI/Tests.Assertions_Library_Has_No_API_Changes.DotNet10_0.verified.txt
index 82b841f008..fc2d114091 100644
--- a/TUnit.PublicAPI/Tests.Assertions_Library_Has_No_API_Changes.DotNet10_0.verified.txt
+++ b/TUnit.PublicAPI/Tests.Assertions_Library_Has_No_API_Changes.DotNet10_0.verified.txt
@@ -2279,7 +2279,7 @@ namespace .Conditions
     public static class ValueTaskAssertionExtensions { }
     public class WaitsForAssertion<TValue> : .<TValue>
     {
-        public WaitsForAssertion(.<TValue> context, <.<TValue>, .<TValue>> assertionBuilder,  timeout, ? pollingInterval = default) { }
+        public WaitsForAssertion(.<TValue> context, <.<TValue>, .<TValue>> assertionBuilder,  timeout, ? pollingInterval = default, .CancellationToken cancellationToken = default) { }
         public override .<TValue?> AssertAsync() { }
         protected override .<.> CheckAsync(.<TValue> metadata) { }
         protected override string GetExpectation() { }
@@ -2674,7 +2674,7 @@ namespace .Extensions
             where TCollection : .<.<TKey, TValue>>
             where TKey :  notnull { }
         public static .<TValue> EqualTo<TValue>(this .<TValue> source, TValue? expected, [.("expected")] string? expression = null) { }
-        public static .<TValue> Eventually<TValue>(this .<TValue> source, <.<TValue>, .<TValue>> assertionBuilder,  timeout, ? pollingInterval = default, [.("timeout")] string? timeoutExpression = null, [.("pollingInterval")] string? pollingIntervalExpression = null) { }
+        public static .<TValue> Eventually<TValue>(this .<TValue> source, <.<TValue>, .<TValue>> assertionBuilder,  timeout, ? pollingInterval = default, .CancellationToken cancellationToken = default, [.("timeout")] string? timeoutExpression = null, [.("pollingInterval")] string? pollingIntervalExpression = null) { }
         [("Use Length() instead, which provides all numeric assertion methods. Example: Asse" +
             "(str).Length().IsGreaterThan(5)")]
         public static ..LengthWrapper HasLength(this .<string> source) { }
@@ -2803,7 +2803,7 @@ namespace .Extensions
         public static .<TException> ThrowsException<TException, TValue>(this .<TValue> source)
             where TException :  { }
         public static .<TValue> ThrowsNothing<TValue>(this .<TValue> source) { }
-        public static .<TValue> WaitsFor<TValue>(this .<TValue> source, <.<TValue>, .<TValue>> assertionBuilder,  timeout, ? pollingInterval = default, [.("timeout")] string? timeoutExpression = null, [.("pollingInterval")] string? pollingIntervalExpression = null) { }
+        public static .<TValue> WaitsFor<TValue>(this .<TValue> source, <.<TValue>, .<TValue>> assertionBuilder,  timeout, ? pollingInterval = default, .CancellationToken cancellationToken = default, [.("timeout")] string? timeoutExpression = null, [.("pollingInterval")] string? pollingIntervalExpression = null) { }
         public static ..WhenParsedIntoAssertion<T> WhenParsedInto<[.(..None | ..PublicMethods | ..Interfaces)]  T>(this .<string> source) { }
         public static .<TException, TInnerException> WithInnerException<TException, TInnerException>(this .<TException> source)
             where TException : 
diff --git a/TUnit.PublicAPI/Tests.Assertions_Library_Has_No_API_Changes.DotNet8_0.verified.txt b/TUnit.PublicAPI/Tests.Assertions_Library_Has_No_API_Changes.DotNet8_0.verified.txt
index 1c52015ff5..8783b78802 100644
--- a/TUnit.PublicAPI/Tests.Assertions_Library_Has_No_API_Changes.DotNet8_0.verified.txt
+++ b/TUnit.PublicAPI/Tests.Assertions_Library_Has_No_API_Changes.DotNet8_0.verified.txt
@@ -2262,7 +2262,7 @@ namespace .Conditions
     public static class ValueTaskAssertionExtensions { }
     public class WaitsForAssertion<TValue> : .<TValue>
     {
-        public WaitsForAssertion(.<TValue> context, <.<TValue>, .<TValue>> assertionBuilder,  timeout, ? pollingInterval = default) { }
+        public WaitsForAssertion(.<TValue> context, <.<TValue>, .<TValue>> assertionBuilder,  timeout, ? pollingInterval = default, .CancellationToken cancellationToken = default) { }
         public override .<TValue?> AssertAsync() { }
         protected override .<.> CheckAsync(.<TValue> metadata) { }
         protected override string GetExpectation() { }
@@ -2653,7 +2653,7 @@ namespace .Extensions
             where TCollection : .<.<TKey, TValue>>
             where TKey :  notnull { }
         public static .<TValue> EqualTo<TValue>(this .<TValue> source, TValue? expected, [.("expected")] string? expression = null) { }
-        public static .<TValue> Eventually<TValue>(this .<TValue> source, <.<TValue>, .<TValue>> assertionBuilder,  timeout, ? pollingInterval = default, [.("timeout")] string? timeoutExpression = null, [.("pollingInterval")] string? pollingIntervalExpression = null) { }
+        public static .<TValue> Eventually<TValue>(this .<TValue> source, <.<TValue>, .<TValue>> assertionBuilder,  timeout, ? pollingInterval = default, .CancellationToken cancellationToken = default, [.("timeout")] string? timeoutExpression = null, [.("pollingInterval")] string? pollingIntervalExpression = null) { }
         [("Use Length() instead, which provides all numeric assertion methods. Example: Asse" +
             "(str).Length().IsGreaterThan(5)")]
         public static ..LengthWrapper HasLength(this .<string> source) { }
@@ -2768,7 +2768,7 @@ namespace .Extensions
         public static .<TException> ThrowsException<TException, TValue>(this .<TValue> source)
             where TException :  { }
         public static .<TValue> ThrowsNothing<TValue>(this .<TValue> source) { }
-        public static .<TValue> WaitsFor<TValue>(this .<TValue> source, <.<TValue>, .<TValue>> assertionBuilder,  timeout, ? pollingInterval = default, [.("timeout")] string? timeoutExpression = null, [.("pollingInterval")] string? pollingIntervalExpression = null) { }
+        public static .<TValue> WaitsFor<TValue>(this .<TValue> source, <.<TValue>, .<TValue>> assertionBuilder,  timeout, ? pollingInterval = default, .CancellationToken cancellationToken = default, [.("timeout")] string? timeoutExpression = null, [.("pollingInterval")] string? pollingIntervalExpression = null) { }
         public static ..WhenParsedIntoAssertion<T> WhenParsedInto<[.(..None | ..PublicMethods | ..Interfaces)]  T>(this .<string> source) { }
         public static .<TException, TInnerException> WithInnerException<TException, TInnerException>(this .<TException> source)
             where TException : 
diff --git a/TUnit.PublicAPI/Tests.Assertions_Library_Has_No_API_Changes.DotNet9_0.verified.txt b/TUnit.PublicAPI/Tests.Assertions_Library_Has_No_API_Changes.DotNet9_0.verified.txt
index 53f5d2824a..ed5f733562 100644
--- a/TUnit.PublicAPI/Tests.Assertions_Library_Has_No_API_Changes.DotNet9_0.verified.txt
+++ b/TUnit.PublicAPI/Tests.Assertions_Library_Has_No_API_Changes.DotNet9_0.verified.txt
@@ -2279,7 +2279,7 @@ namespace .Conditions
     public static class ValueTaskAssertionExtensions { }
     public class WaitsForAssertion<TValue> : .<TValue>
     {
-        public WaitsForAssertion(.<TValue> context, <.<TValue>, .<TValue>> assertionBuilder,  timeout, ? pollingInterval = default) { }
+        public WaitsForAssertion(.<TValue> context, <.<TValue>, .<TValue>> assertionBuilder,  timeout, ? pollingInterval = default, .CancellationToken cancellationToken = default) { }
         public override .<TValue?> AssertAsync() { }
         protected override .<.> CheckAsync(.<TValue> metadata) { }
         protected override string GetExpectation() { }
@@ -2674,7 +2674,7 @@ namespace .Extensions
             where TCollection : .<.<TKey, TValue>>
             where TKey :  notnull { }
         public static .<TValue> EqualTo<TValue>(this .<TValue> source, TValue? expected, [.("expected")] string? expression = null) { }
-        public static .<TValue> Eventually<TValue>(this .<TValue> source, <.<TValue>, .<TValue>> assertionBuilder,  timeout, ? pollingInterval = default, [.("timeout")] string? timeoutExpression = null, [.("pollingInterval")] string? pollingIntervalExpression = null) { }
+        public static .<TValue> Eventually<TValue>(this .<TValue> source, <.<TValue>, .<TValue>> assertionBuilder,  timeout, ? pollingInterval = default, .CancellationToken cancellationToken = default, [.("timeout")] string? timeoutExpression = null, [.("pollingInterval")] string? pollingIntervalExpression = null) { }
         [("Use Length() instead, which provides all numeric assertion methods. Example: Asse" +
             "(str).Length().IsGreaterThan(5)")]
         public static ..LengthWrapper HasLength(this .<string> source) { }
@@ -2803,7 +2803,7 @@ namespace .Extensions
         public static .<TException> ThrowsException<TException, TValue>(this .<TValue> source)
             where TException :  { }
         public static .<TValue> ThrowsNothing<TValue>(this .<TValue> source) { }
-        public static .<TValue> WaitsFor<TValue>(this .<TValue> source, <.<TValue>, .<TValue>> assertionBuilder,  timeout, ? pollingInterval = default, [.("timeout")] string? timeoutExpression = null, [.("pollingInterval")] string? pollingIntervalExpression = null) { }
+        public static .<TValue> WaitsFor<TValue>(this .<TValue> source, <.<TValue>, .<TValue>> assertionBuilder,  timeout, ? pollingInterval = default, .CancellationToken cancellationToken = default, [.("timeout")] string? timeoutExpression = null, [.("pollingInterval")] string? pollingIntervalExpression = null) { }
         public static ..WhenParsedIntoAssertion<T> WhenParsedInto<[.(..None | ..PublicMethods | ..Interfaces)]  T>(this .<string> source) { }
         public static .<TException, TInnerException> WithInnerException<TException, TInnerException>(this .<TException> source)
             where TException : 
diff --git a/TUnit.PublicAPI/Tests.Assertions_Library_Has_No_API_Changes.Net4_7.verified.txt b/TUnit.PublicAPI/Tests.Assertions_Library_Has_No_API_Changes.Net4_7.verified.txt
index d4b8c212ba..b29afe65f8 100644
--- a/TUnit.PublicAPI/Tests.Assertions_Library_Has_No_API_Changes.Net4_7.verified.txt
+++ b/TUnit.PublicAPI/Tests.Assertions_Library_Has_No_API_Changes.Net4_7.verified.txt
@@ -2032,7 +2032,7 @@ namespace .Conditions
     public static class ValueTaskAssertionExtensions { }
     public class WaitsForAssertion<TValue> : .<TValue>
     {
-        public WaitsForAssertion(.<TValue> context, <.<TValue>, .<TValue>> assertionBuilder,  timeout, ? pollingInterval = default) { }
+        public WaitsForAssertion(.<TValue> context, <.<TValue>, .<TValue>> assertionBuilder,  timeout, ? pollingInterval = default, .CancellationToken cancellationToken = default) { }
         public override .<TValue?> AssertAsync() { }
         protected override .<.> CheckAsync(.<TValue> metadata) { }
         protected override string GetExpectation() { }
@@ -2389,7 +2389,7 @@ namespace .Extensions
             where TCollection : .<.<TKey, TValue>>
             where TKey :  notnull { }
         public static .<TValue> EqualTo<TValue>(this .<TValue> source, TValue? expected, [.("expected")] string? expression = null) { }
-        public static .<TValue> Eventually<TValue>(this .<TValue> source, <.<TValue>, .<TValue>> assertionBuilder,  timeout, ? pollingInterval = default, [.("timeout")] string? timeoutExpression = null, [.("pollingInterval")] string? pollingIntervalExpression = null) { }
+        public static .<TValue> Eventually<TValue>(this .<TValue> source, <.<TValue>, .<TValue>> assertionBuilder,  timeout, ? pollingInterval = default, .CancellationToken cancellationToken = default, [.("timeout")] string? timeoutExpression = null, [.("pollingInterval")] string? pollingIntervalExpression = null) { }
         [("Use Length() instead, which provides all numeric assertion methods. Example: Asse" +
             "(str).Length().IsGreaterThan(5)")]
         public static ..LengthWrapper HasLength(this .<string> source) { }
@@ -2482,7 +2482,7 @@ namespace .Extensions
         public static .<TException> ThrowsException<TException, TValue>(this .<TValue> source)
             where TException :  { }
         public static .<TValue> ThrowsNothing<TValue>(this .<TValue> source) { }
-        public static .<TValue> WaitsFor<TValue>(this .<TValue> source, <.<TValue>, .<TValue>> assertionBuilder,  timeout, ? pollingInterval = default, [.("timeout")] string? timeoutExpression = null, [.("pollingInterval")] string? pollingIntervalExpression = null) { }
+        public static .<TValue> WaitsFor<TValue>(this .<TValue> source, <.<TValue>, .<TValue>> assertionBuilder,  timeout, ? pollingInterval = default, .CancellationToken cancellationToken = default, [.("timeout")] string? timeoutExpression = null, [.("pollingInterval")] string? pollingIntervalExpression = null) { }
         public static ..WhenParsedIntoAssertion<T> WhenParsedInto<T>(this .<string> source) { }
         public static .<TException, TInnerException> WithInnerException<TException, TInnerException>(this .<TException> source)
             where TException : 
diff --git a/TUnit.PublicAPI/Tests.Should_Library_Has_No_API_Changes.DotNet10_0.verified.txt b/TUnit.PublicAPI/Tests.Should_Library_Has_No_API_Changes.DotNet10_0.verified.txt
index 2a0e8751d2..fd438f3bd7 100644
--- a/TUnit.PublicAPI/Tests.Should_Library_Has_No_API_Changes.DotNet10_0.verified.txt
+++ b/TUnit.PublicAPI/Tests.Should_Library_Has_No_API_Changes.DotNet10_0.verified.txt
@@ -293,7 +293,7 @@ namespace .
         public static ..ShouldAssertion<TValue> BeOfType<TValue>(this ..IShouldSource<TValue> source,  expectedType, [.("expectedType")] string? expression = null) { }
         public static ..ShouldAssertion<string> BeParsableInto<[.(..None | ..PublicMethods | ..Interfaces)]  T>(this ..IShouldSource<string> source) { }
         public static ..ShouldAssertion<TValue> EqualTo<TValue>(this ..IShouldSource<TValue> source, TValue? expected, [.("expected")] string? expression = null) { }
-        public static ..ShouldAssertion<TValue> Eventually<TValue>(this ..IShouldSource<TValue> source, <.<TValue>, .<TValue>> assertionBuilder,  timeout, ? pollingInterval = default, [.("timeout")] string? timeoutExpression = null, [.("pollingInterval")] string? pollingIntervalExpression = null) { }
+        public static ..ShouldAssertion<TValue> Eventually<TValue>(this ..IShouldSource<TValue> source, <.<TValue>, .<TValue>> assertionBuilder,  timeout, ? pollingInterval = default, .CancellationToken cancellationToken = default, [.("timeout")] string? timeoutExpression = null, [.("pollingInterval")] string? pollingIntervalExpression = null) { }
         [("Use Length().IsEqualTo(expectedLength) instead.")]
         public static ..ShouldAssertion<string> HaveLength(this ..IShouldSource<string> source, int expectedLength, [.("expectedLength")] string? expression = null) { }
         public static ..ShouldAssertion<TException> HaveMessage<TException>(this ..IShouldSource<TException> source, string expectedMessage, [.("expectedMessage")] string? expression = null)
@@ -313,7 +313,7 @@ namespace .
         public static ..ShouldAssertion<TValue> NotBeNull<TValue>(this ..IShouldSource<TValue> source)
             where TValue :  class { }
         public static ..ShouldAssertion<string> NotBeParsableInto<[.(..None | ..PublicMethods | ..Interfaces)]  T>(this ..IShouldSource<string> source) { }
-        public static ..ShouldAssertion<TValue> WaitFor<TValue>(this ..IShouldSource<TValue> source, <.<TValue>, .<TValue>> assertionBuilder,  timeout, ? pollingInterval = default, [.("timeout")] string? timeoutExpression = null, [.("pollingInterval")] string? pollingIntervalExpression = null) { }
+        public static ..ShouldAssertion<TValue> WaitFor<TValue>(this ..IShouldSource<TValue> source, <.<TValue>, .<TValue>> assertionBuilder,  timeout, ? pollingInterval = default, .CancellationToken cancellationToken = default, [.("timeout")] string? timeoutExpression = null, [.("pollingInterval")] string? pollingIntervalExpression = null) { }
         public static ..ShouldAssertion<TException> WithInnerException<TException, TInnerException>(this ..IShouldSource<TException> source)
             where TException : 
             where TInnerException :  { }
diff --git a/TUnit.PublicAPI/Tests.Should_Library_Has_No_API_Changes.DotNet8_0.verified.txt b/TUnit.PublicAPI/Tests.Should_Library_Has_No_API_Changes.DotNet8_0.verified.txt
index 2d73b79a88..b0e518b5e6 100644
--- a/TUnit.PublicAPI/Tests.Should_Library_Has_No_API_Changes.DotNet8_0.verified.txt
+++ b/TUnit.PublicAPI/Tests.Should_Library_Has_No_API_Changes.DotNet8_0.verified.txt
@@ -293,7 +293,7 @@ namespace .
         public static ..ShouldAssertion<TValue> BeOfType<TValue>(this ..IShouldSource<TValue> source,  expectedType, [.("expectedType")] string? expression = null) { }
         public static ..ShouldAssertion<string> BeParsableInto<[.(..None | ..PublicMethods | ..Interfaces)]  T>(this ..IShouldSource<string> source) { }
         public static ..ShouldAssertion<TValue> EqualTo<TValue>(this ..IShouldSource<TValue> source, TValue? expected, [.("expected")] string? expression = null) { }
-        public static ..ShouldAssertion<TValue> Eventually<TValue>(this ..IShouldSource<TValue> source, <.<TValue>, .<TValue>> assertionBuilder,  timeout, ? pollingInterval = default, [.("timeout")] string? timeoutExpression = null, [.("pollingInterval")] string? pollingIntervalExpression = null) { }
+        public static ..ShouldAssertion<TValue> Eventually<TValue>(this ..IShouldSource<TValue> source, <.<TValue>, .<TValue>> assertionBuilder,  timeout, ? pollingInterval = default, .CancellationToken cancellationToken = default, [.("timeout")] string? timeoutExpression = null, [.("pollingInterval")] string? pollingIntervalExpression = null) { }
         [("Use Length().IsEqualTo(expectedLength) instead.")]
         public static ..ShouldAssertion<string> HaveLength(this ..IShouldSource<string> source, int expectedLength, [.("expectedLength")] string? expression = null) { }
         public static ..ShouldAssertion<TException> HaveMessage<TException>(this ..IShouldSource<TException> source, string expectedMessage, [.("expectedMessage")] string? expression = null)
@@ -313,7 +313,7 @@ namespace .
         public static ..ShouldAssertion<TValue> NotBeNull<TValue>(this ..IShouldSource<TValue> source)
             where TValue :  class { }
         public static ..ShouldAssertion<string> NotBeParsableInto<[.(..None | ..PublicMethods | ..Interfaces)]  T>(this ..IShouldSource<string> source) { }
-        public static ..ShouldAssertion<TValue> WaitFor<TValue>(this ..IShouldSource<TValue> source, <.<TValue>, .<TValue>> assertionBuilder,  timeout, ? pollingInterval = default, [.("timeout")] string? timeoutExpression = null, [.("pollingInterval")] string? pollingIntervalExpression = null) { }
+        public static ..ShouldAssertion<TValue> WaitFor<TValue>(this ..IShouldSource<TValue> source, <.<TValue>, .<TValue>> assertionBuilder,  timeout, ? pollingInterval = default, .CancellationToken cancellationToken = default, [.("timeout")] string? timeoutExpression = null, [.("pollingInterval")] string? pollingIntervalExpression = null) { }
         public static ..ShouldAssertion<TException> WithInnerException<TException, TInnerException>(this ..IShouldSource<TException> source)
             where TException : 
             where TInnerException :  { }
diff --git a/TUnit.PublicAPI/Tests.Should_Library_Has_No_API_Changes.DotNet9_0.verified.txt b/TUnit.PublicAPI/Tests.Should_Library_Has_No_API_Changes.DotNet9_0.verified.txt
index 32e1c434cb..4b0f89743b 100644
--- a/TUnit.PublicAPI/Tests.Should_Library_Has_No_API_Changes.DotNet9_0.verified.txt
+++ b/TUnit.PublicAPI/Tests.Should_Library_Has_No_API_Changes.DotNet9_0.verified.txt
@@ -293,7 +293,7 @@ namespace .
         public static ..ShouldAssertion<TValue> BeOfType<TValue>(this ..IShouldSource<TValue> source,  expectedType, [.("expectedType")] string? expression = null) { }
         public static ..ShouldAssertion<string> BeParsableInto<[.(..None | ..PublicMethods | ..Interfaces)]  T>(this ..IShouldSource<string> source) { }
         public static ..ShouldAssertion<TValue> EqualTo<TValue>(this ..IShouldSource<TValue> source, TValue? expected, [.("expected")] string? expression = null) { }
-        public static ..ShouldAssertion<TValue> Eventually<TValue>(this ..IShouldSource<TValue> source, <.<TValue>, .<TValue>> assertionBuilder,  timeout, ? pollingInterval = default, [.("timeout")] string? timeoutExpression = null, [.("pollingInterval")] string? pollingIntervalExpression = null) { }
+        public static ..ShouldAssertion<TValue> Eventually<TValue>(this ..IShouldSource<TValue> source, <.<TValue>, .<TValue>> assertionBuilder,  timeout, ? pollingInterval = default, .CancellationToken cancellationToken = default, [.("timeout")] string? timeoutExpression = null, [.("pollingInterval")] string? pollingIntervalExpression = null) { }
         [("Use Length().IsEqualTo(expectedLength) instead.")]
         public static ..ShouldAssertion<string> HaveLength(this ..IShouldSource<string> source, int expectedLength, [.("expectedLength")] string? expression = null) { }
         public static ..ShouldAssertion<TException> HaveMessage<TException>(this ..IShouldSource<TException> source, string expectedMessage, [.("expectedMessage")] string? expression = null)
@@ -313,7 +313,7 @@ namespace .
         public static ..ShouldAssertion<TValue> NotBeNull<TValue>(this ..IShouldSource<TValue> source)
             where TValue :  class { }
         public static ..ShouldAssertion<string> NotBeParsableInto<[.(..None | ..PublicMethods | ..Interfaces)]  T>(this ..IShouldSource<string> source) { }
-        public static ..ShouldAssertion<TValue> WaitFor<TValue>(this ..IShouldSource<TValue> source, <.<TValue>, .<TValue>> assertionBuilder,  timeout, ? pollingInterval = default, [.("timeout")] string? timeoutExpression = null, [.("pollingInterval")] string? pollingIntervalExpression = null) { }
+        public static ..ShouldAssertion<TValue> WaitFor<TValue>(this ..IShouldSource<TValue> source, <.<TValue>, .<TValue>> assertionBuilder,  timeout, ? pollingInterval = default, .CancellationToken cancellationToken = default, [.("timeout")] string? timeoutExpression = null, [.("pollingInterval")] string? pollingIntervalExpression = null) { }
         public static ..ShouldAssertion<TException> WithInnerException<TException, TInnerException>(this ..IShouldSource<TException> source)
             where TException : 
             where TInnerException :  { }