     ///   waiting to be performed for right now.
     @MainActor
     public func advance(by duration: SchedulerTimeType.Stride = .zero) async {
-      let finalDate = self.lock.sync { self.now.advanced(by: duration) }
-
-      while self.lock.sync(operation: { self.now }) <= finalDate {
+      await self.advance(to: self.now.advanced(by: duration))
+    }
+
+    /// Advances the scheduler to the given instant.
+    ///
+    /// - Parameter instant: An instant in time to advance to.
+    public func advance(to instant: SchedulerTimeType) {
+      while self.lock.sync(operation: { self.now }) <= instant {
+        self.lock.lock()
+        self.scheduled.sort { ($0.date, $0.sequence) < ($1.date, $1.sequence) }
+
+        guard
+          let next = self.scheduled.first,
+          instant >= next.date
+        else {
+          self.now = instant
+          self.lock.unlock()
+          return
+        }
+
+        self.now = next.date
+        self.scheduled.removeFirst()
+        self.lock.unlock()
+        next.action()
+      }
+    }
+
+    /// Advances the scheduler to the given instant.
+    ///
+    /// - Parameter instant: An instant in time to advance to.
+    public func advance(to instant: SchedulerTimeType) async {
+      while self.lock.sync(operation: { self.now }) <= instant {
         await Task.megaYield()
         let `return` = { () -> Bool in
           self.lock.lock()


          guard
            let next = self.scheduled.first,
            finalDate >= next.date
          else {
            self.now = finalDate
            self.lock.unlock()
            return true
          }

  > where Scheduler: Combine.Scheduler

  extension Task where Success == Failure, Failure == Never {
    static func megaYield(count: Int = 10) async {
      for _ in 1...count {
        await Task<Void, Never>.detached(priority: .background) { await Task.yield() }.value
      }
    }
  }
