diff --git a/benchmark/batch_loading.rb b/benchmark/batch_loading.rb
index b2d3f2d22c..eda04095aa 100644
--- a/benchmark/batch_loading.rb
+++ b/benchmark/batch_loading.rb
@@ -63,9 +63,7 @@ def initialize(options = {column: :id})
 
       def fetch(keys)
         keys.map { |key|
-          d = GraphQLBatchSchema::DATA.find { |d| d[@column] == key }
-          # p [key, @column, d]
-          d
+          GraphQLBatchSchema::DATA.find { |d| d[@column] == key }
         }
       end
     end
diff --git a/lib/graphql/dataloader.rb b/lib/graphql/dataloader.rb
index 92ddac4f6c..8da6c39465 100644
--- a/lib/graphql/dataloader.rb
+++ b/lib/graphql/dataloader.rb
@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require "graphql/dataloader/flat_dataloader"
 require "graphql/dataloader/null_dataloader"
 require "graphql/dataloader/request"
 require "graphql/dataloader/request_all"
@@ -64,8 +65,14 @@ def initialize(nonblocking: self.class.default_nonblocking, fiber_limit: self.cl
         @nonblocking = nonblocking
       end
       @fiber_limit = fiber_limit
+      @steps_to_rerun_after_lazy = []
+      @lazies_at_depth = nil
     end
 
+    attr_accessor :lazies_at_depth
+
+    attr_reader :steps_to_rerun_after_lazy
+
     # @return [Integer, nil]
     attr_reader :fiber_limit
 
@@ -140,10 +147,10 @@ def yield(source = Fiber[:__graphql_current_dataloader_source])
     end
 
     # @api private Nothing to see here
-    def append_job(&job)
+    def append_job(callable = nil, &job)
       # Given a block, queue it up to be worked through when `#run` is called.
       # (If the dataloader is already running, than a Fiber will pick this up later.)
-      @pending_jobs.push(job)
+      @pending_jobs.push(callable || job)
       nil
     end
 
@@ -189,6 +196,8 @@ def run_isolated
     end
 
     def run
+      # TODO unify the initialization lazies_at_depth
+      @lazies_at_depth ||= Hash.new { |h, k| h[k] = [] }
       trace = Fiber[:__graphql_current_multiplex]&.current_trace
       jobs_fiber_limit, total_fiber_limit = calculate_fiber_limit
       job_fibers = []
@@ -222,6 +231,31 @@ def run
             end
             join_queues(source_fibers, next_source_fibers)
           end
+
+          if @lazies_at_depth.any?
+            smallest_depth = nil
+            @lazies_at_depth.each_key do |depth_key|
+              smallest_depth ||= depth_key
+              if depth_key < smallest_depth
+                smallest_depth = depth_key
+              end
+            end
+
+            if smallest_depth
+              lazies = @lazies_at_depth.delete(smallest_depth)
+              if !lazies.empty?
+                append_job {
+                  lazies.each(&:value) # resolve these Lazy instances
+                }
+                job_fibers << spawn_job_fiber(trace)
+              end
+            end
+          elsif @steps_to_rerun_after_lazy.any?
+            @pending_jobs.concat(@steps_to_rerun_after_lazy)
+            f = spawn_job_fiber(trace)
+            job_fibers << f
+            @steps_to_rerun_after_lazy.clear
+          end
         end
 
         trace&.end_dataloader(self)
diff --git a/lib/graphql/dataloader/flat_dataloader.rb b/lib/graphql/dataloader/flat_dataloader.rb
new file mode 100644
index 0000000000..9977ce1795
--- /dev/null
+++ b/lib/graphql/dataloader/flat_dataloader.rb
@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+module GraphQL
+  class Dataloader
+    class FlatDataloader < Dataloader
+      def initialize(*)
+        # TODO unify the initialization lazies_at_depth
+        @lazies_at_depth ||= Hash.new { |h, k| h[k] = [] }
+        @steps_to_rerun_after_lazy = []
+        @queue = []
+      end
+
+      def run
+        while @queue.any?
+          while (step = @queue.shift)
+            step.call
+          end
+
+          while @lazies_at_depth&.any?
+            smallest_depth = nil
+            @lazies_at_depth.each_key do |depth_key|
+              smallest_depth ||= depth_key
+              if depth_key < smallest_depth
+                smallest_depth = depth_key
+              end
+            end
+
+            if smallest_depth
+              lazies = @lazies_at_depth.delete(smallest_depth)
+              lazies.each(&:value) # resolve these Lazy instances
+            end
+          end
+
+          if @steps_to_rerun_after_lazy.any?
+            @steps_to_rerun_after_lazy.each(&:call)
+            @steps_to_rerun_after_lazy.clear
+          end
+        end
+      end
+
+      def run_isolated
+        prev_queue = @queue
+        prev_stral = @steps_to_rerun_after_lazy
+        prev_lad = @lazies_at_depth
+        @steps_to_rerun_after_lazy = []
+        @queue = []
+        @lazies_at_depth = @lazies_at_depth.dup&.clear
+        res = nil
+        append_job {
+          res = yield
+        }
+        run
+        res
+      ensure
+        @queue = prev_queue
+        @steps_to_rerun_after_lazy = prev_stral
+        @lazies_at_depth = prev_lad
+      end
+
+      def clear_cache; end
+
+      def yield(_source)
+        raise GraphQL::Error, "GraphQL::Dataloader is not running -- add `use GraphQL::Dataloader` to your schema to use Dataloader sources."
+      end
+
+      def append_job(callable = nil, &block)
+        @queue << (callable || block)
+        nil
+      end
+
+      def with(*)
+        raise GraphQL::Error, "GraphQL::Dataloader is not running -- add `use GraphQL::Dataloader` to your schema to use Dataloader sources."
+      end
+    end
+  end
+end
diff --git a/lib/graphql/dataloader/null_dataloader.rb b/lib/graphql/dataloader/null_dataloader.rb
index 7fd222d7fe..3e431c1086 100644
--- a/lib/graphql/dataloader/null_dataloader.rb
+++ b/lib/graphql/dataloader/null_dataloader.rb
@@ -18,8 +18,8 @@ def yield(_source)
         raise GraphQL::Error, "GraphQL::Dataloader is not running -- add `use GraphQL::Dataloader` to your schema to use Dataloader sources."
       end
 
-      def append_job
-        yield
+      def append_job(callable = nil)
+        callable ? callable.call : yield
         nil
       end
 
diff --git a/lib/graphql/execution/interpreter.rb b/lib/graphql/execution/interpreter.rb
index ba0b94b2aa..fae23c8027 100644
--- a/lib/graphql/execution/interpreter.rb
+++ b/lib/graphql/execution/interpreter.rb
@@ -5,7 +5,6 @@
 require "graphql/execution/interpreter/arguments_cache"
 require "graphql/execution/interpreter/execution_errors"
 require "graphql/execution/interpreter/runtime"
-require "graphql/execution/interpreter/resolve"
 require "graphql/execution/interpreter/handles_raw_value"
 
 module GraphQL
@@ -43,6 +42,7 @@ def run_all(schema, query_options, context: {}, max_complexity: schema.max_compl
             schema = multiplex.schema
             queries = multiplex.queries
             lazies_at_depth = Hash.new { |h, k| h[k] = [] }
+            multiplex.dataloader.lazies_at_depth = lazies_at_depth
             multiplex_analyzers = schema.multiplex_analyzers
             if multiplex.max_complexity
               multiplex_analyzers += [GraphQL::Analysis::MaxQueryComplexity]
@@ -90,15 +90,6 @@ def run_all(schema, query_options, context: {}, max_complexity: schema.max_compl
 
               multiplex.dataloader.run
 
-              # Then, work through lazy results in a breadth-first way
-              multiplex.dataloader.append_job {
-                query = multiplex.queries.length == 1 ? multiplex.queries[0] : nil
-                multiplex.current_trace.execute_query_lazy(multiplex: multiplex, query: query) do
-                  Interpreter::Resolve.resolve_each_depth(lazies_at_depth, multiplex.dataloader)
-                end
-              }
-              multiplex.dataloader.run
-
               # Then, find all errors and assign the result to the query object
               results.each_with_index do |data_result, idx|
                 query = queries[idx]
@@ -122,7 +113,6 @@ def run_all(schema, query_options, context: {}, max_complexity: schema.max_compl
                   end
 
                   result["data"] = query.context.namespace(:interpreter_runtime)[:runtime].final_result
-
                   result
                 end
                 if query.context.namespace?(:__query_result_extensions__)
diff --git a/lib/graphql/execution/interpreter/resolve.rb b/lib/graphql/execution/interpreter/resolve.rb
deleted file mode 100644
index 570ab48e9d..0000000000
--- a/lib/graphql/execution/interpreter/resolve.rb
+++ /dev/null
@@ -1,100 +0,0 @@
-# frozen_string_literal: true
-
-module GraphQL
-  module Execution
-    class Interpreter
-      module Resolve
-        # Continue field results in `results` until there's nothing else to continue.
-        # @return [void]
-        def self.resolve_all(results, dataloader)
-          dataloader.append_job { resolve(results, dataloader) }
-          nil
-        end
-
-        def self.resolve_each_depth(lazies_at_depth, dataloader)
-          smallest_depth = nil
-          lazies_at_depth.each_key do |depth_key|
-            smallest_depth ||= depth_key
-            if depth_key < smallest_depth
-              smallest_depth = depth_key
-            end
-          end
-
-          if smallest_depth
-            lazies = lazies_at_depth.delete(smallest_depth)
-            if !lazies.empty?
-              lazies.each do |l|
-                dataloader.append_job { l.value }
-              end
-              # Run lazies _and_ dataloader, see if more are enqueued
-              dataloader.run
-              resolve_each_depth(lazies_at_depth, dataloader)
-            end
-          end
-          nil
-        end
-
-        # After getting `results` back from an interpreter evaluation,
-        # continue it until you get a response-ready Ruby value.
-        #
-        # `results` is one level of _depth_ of a query or multiplex.
-        #
-        # Resolve all lazy values in that depth before moving on
-        # to the next level.
-        #
-        # It's assumed that the lazies will
-        # return {Lazy} instances if there's more work to be done,
-        # or return {Hash}/{Array} if the query should be continued.
-        #
-        # @return [void]
-        def self.resolve(results, dataloader)
-          # There might be pending jobs here that _will_ write lazies
-          # into the result hash. We should run them out, so we
-          # can be sure that all lazies will be present in the result hashes.
-          # A better implementation would somehow interleave (or unify)
-          # these approaches.
-          dataloader.run
-          next_results = []
-          while !results.empty?
-            result_value = results.shift
-            if result_value.is_a?(Runtime::GraphQLResultHash) || result_value.is_a?(Hash)
-              results.concat(result_value.values)
-              next
-            elsif result_value.is_a?(Runtime::GraphQLResultArray)
-              results.concat(result_value.values)
-              next
-            elsif result_value.is_a?(Array)
-              results.concat(result_value)
-              next
-            elsif result_value.is_a?(Lazy)
-              loaded_value = result_value.value
-              if loaded_value.is_a?(Lazy)
-                # Since this field returned another lazy,
-                # add it to the same queue
-                results << loaded_value
-              elsif loaded_value.is_a?(Runtime::GraphQLResultHash) || loaded_value.is_a?(Runtime::GraphQLResultArray) ||
-                  loaded_value.is_a?(Hash) || loaded_value.is_a?(Array)
-                # Add these values in wholesale --
-                # they might be modified by later work in the dataloader.
-                next_results << loaded_value
-              end
-            end
-          end
-
-          if !next_results.empty?
-            # Any pending data loader jobs may populate the
-            # resutl arrays or result hashes accumulated in
-            # `next_results``. Run those **to completion**
-            # before continuing to resolve `next_results`.
-            # (Just `.append_job` doesn't work if any pending
-            # jobs require multiple passes.)
-            dataloader.run
-            dataloader.append_job { resolve(next_results, dataloader) }
-          end
-
-          nil
-        end
-      end
-    end
-  end
-end
diff --git a/lib/graphql/execution/interpreter/runtime.rb b/lib/graphql/execution/interpreter/runtime.rb
index a2d0f389f5..a0f35dc026 100644
--- a/lib/graphql/execution/interpreter/runtime.rb
+++ b/lib/graphql/execution/interpreter/runtime.rb
@@ -1,6 +1,16 @@
 # frozen_string_literal: true
+require "graphql/execution/interpreter/runtime/step"
+require "graphql/execution/interpreter/runtime/field_resolve_step"
 require "graphql/execution/interpreter/runtime/graphql_result"
 
+#####
+# Next thoughts
+#
+# - `continue_field` is probably a step of its own -- that method can somehow be factored out
+# - It seems like Dataloader/Lazy will fit in at the queue level, so the flow would be:
+#   - Run jobs from queue
+#   - Then, run dataloader/lazies
+#   - Repeat
 module GraphQL
   module Execution
     class Interpreter
@@ -15,6 +25,7 @@ def initialize
             @current_arguments = nil
             @current_result_name = nil
             @current_result = nil
+            @current_step = nil
             @was_authorized_by_scope_items = nil
           end
 
@@ -23,7 +34,7 @@ def current_object
           end
 
           attr_accessor :current_result, :current_result_name,
-            :current_arguments, :current_field, :was_authorized_by_scope_items
+            :current_arguments, :current_field, :was_authorized_by_scope_items, :current_step
         end
 
         # @return [GraphQL::Query]
@@ -35,6 +46,12 @@ def current_object
         # @return [GraphQL::Query::Context]
         attr_reader :context
 
+        attr_reader :dataloader, :current_trace, :lazies_at_depth
+
+        def steps_to_rerun_after_lazy # TODO fix this jank
+          @dataloader.steps_to_rerun_after_lazy
+        end
+
         def initialize(query:, lazies_at_depth:)
           @query = query
           @current_trace = query.current_trace
@@ -57,6 +74,7 @@ def initialize(query:, lazies_at_depth:)
         end
 
         def final_result
+          # TODO can `graphql_result_data` be set to `nil` when `.wrap` fails?
           @response.respond_to?(:graphql_result_data) ? @response.graphql_result_data : @response
         end
 
@@ -64,6 +82,41 @@ def inspect
           "#<#{self.class.name} response=#{@response.inspect}>"
         end
 
+        class OperationDirectivesStep
+          include Runtime::Step
+
+          def initialize(runtime, object, method_to_call, directives, next_step)
+            @runtime = runtime
+            @object = object
+            @method_to_call = method_to_call
+            @directives = directives
+            @next_step = next_step
+          end
+
+          def run_step
+            @runtime.call_method_on_directives(@method_to_call, @object, @directives) do
+              @runtime.dataloader.append_job(@next_step)
+              @next_step
+            end
+          end
+
+          def step_finished?
+            true
+          end
+
+          def current_result
+            @next_step.current_result
+          end
+
+          def current_result_name
+            @next_step.current_result_name
+          end
+
+          def inspect_step
+            "#{self.class.name.split("::").last}##{object_id}(#{@directives ? @directives.map(&:name).join(", ") : nil}) => #{@next_step.inspect_step}"
+          end
+        end
+
         # @return [void]
         def run_eager
           root_type = query.root_type
@@ -86,38 +139,18 @@ def run_eager
           object = schema.sync_lazy(object) # TODO test query partial with lazy root object
           runtime_state = get_current_runtime_state
           case root_type.kind.name
-          when "OBJECT"
-            object_proxy = root_type.wrap(object, context)
-            object_proxy = schema.sync_lazy(object_proxy)
-            if object_proxy.nil?
-              @response = nil
-            else
-              @response = GraphQLResultHash.new(nil, root_type, object_proxy, nil, false, selections, is_eager, ast_node, nil, nil)
-              @response.base_path = base_path
-              runtime_state.current_result = @response
-              call_method_on_directives(:resolve, object, ast_node.directives) do
-                each_gathered_selections(@response) do |selections, is_selection_array, ordered_result_keys|
-                  @response.ordered_result_keys ||= ordered_result_keys
-                  if is_selection_array
-                    selection_response = GraphQLResultHash.new(nil, root_type, object_proxy, nil, false, selections, is_eager, ast_node, nil, nil)
-                    selection_response.ordered_result_keys = ordered_result_keys
-                    final_response = @response
-                  else
-                    selection_response = @response
-                    final_response = nil
-                  end
+          when "OBJECT", "UNION", "INTERFACE"
+            # TODO: use `nil` for top-level result when `.wrap` returns `nil`
+            @response = GraphQLResultHash.new(self, nil, root_type, object, nil, false, selections, is_eager, ast_node, nil, nil)
+            @response.base_path = base_path
 
-                  @dataloader.append_job {
-                    evaluate_selections(
-                      selections,
-                      selection_response,
-                      final_response,
-                      nil,
-                    )
-                  }
-                end
-              end
+            runtime_state.current_result = @response
+            next_step = if !ast_node.directives.empty?
+              OperationDirectivesStep.new(self, object, :resolve, ast_node.directives, @response)
+            else
+              @response
             end
+            @dataloader.append_job(next_step)
           when "LIST"
             inner_type = root_type.unwrap
             case inner_type.kind.name
@@ -125,40 +158,27 @@ def run_eager
               result_name = ast_node.alias || ast_node.name
               field_defn = query.field_definition
               owner_type = field_defn.owner
-              selection_result = GraphQLResultHash.new(nil, owner_type, nil, nil, false, EmptyObjects::EMPTY_ARRAY, false, ast_node, nil, nil)
+              selection_result = GraphQLResultHash.new(self, nil, owner_type, nil, nil, false, EmptyObjects::EMPTY_ARRAY, false, ast_node, nil, nil)
               selection_result.base_path = base_path
               selection_result.ordered_result_keys = [result_name]
-              runtime_state = get_current_runtime_state
               runtime_state.current_result = selection_result
               runtime_state.current_result_name = result_name
+              runtime_state.current_step = selection_result
               continue_value = continue_value(object, field_defn, false, ast_node, result_name, selection_result)
               if HALT != continue_value
-                continue_field(continue_value, owner_type, field_defn, root_type, ast_node, nil, false, nil, nil, result_name, selection_result, false, runtime_state) # rubocop:disable Metrics/ParameterLists
+                continue_field(continue_value, field_defn, root_type, ast_node, nil, false, nil, result_name, selection_result, false, runtime_state) # rubocop:disable Metrics/ParameterLists
               end
               @response = selection_result[result_name]
             else
-              @response = GraphQLResultArray.new(nil, root_type, nil, nil, false, selections, false, ast_node, nil, nil)
+              @response = GraphQLResultArray.new(self, nil, root_type, object, nil, false, selections, false, ast_node, nil, nil)
               @response.base_path = base_path
-              idx = nil
-              object.each do |inner_value|
-                idx ||= 0
-                this_idx = idx
-                idx += 1
-                @dataloader.append_job do
-                  runtime_state.current_result_name = this_idx
-                  runtime_state.current_result = @response
-                  continue_field(
-                    inner_value, root_type, nil, inner_type, nil, @response.graphql_selections, false, object_proxy,
-                    nil, this_idx, @response, false, runtime_state
-                  )
-                end
-              end
+              @dataloader.append_job(@response)
             end
           when "SCALAR", "ENUM"
             result_name = ast_node.alias || ast_node.name
             field_defn = query.field_definition
             owner_type = field_defn.owner
-            selection_result = GraphQLResultHash.new(nil, owner_type, nil, nil, false, EmptyObjects::EMPTY_ARRAY, false, ast_node, nil, nil)
+            selection_result = GraphQLResultHash.new(self, nil, owner_type, nil, nil, false, EmptyObjects::EMPTY_ARRAY, false, ast_node, nil, nil)
             selection_result.ordered_result_keys = [result_name]
             selection_result.base_path = base_path
             runtime_state = get_current_runtime_state
@@ -166,31 +186,9 @@ def run_eager
             runtime_state.current_result_name = result_name
             continue_value = continue_value(object, field_defn, false, ast_node, result_name, selection_result)
             if HALT != continue_value
-              continue_field(continue_value, owner_type, field_defn, query.root_type, ast_node, nil, false, nil, nil, result_name, selection_result, false, runtime_state) # rubocop:disable Metrics/ParameterLists
+              continue_field(continue_value, field_defn, query.root_type, ast_node, nil, false, nil, result_name, selection_result, false, runtime_state) # rubocop:disable Metrics/ParameterLists
             end
             @response = selection_result[result_name]
-          when "UNION", "INTERFACE"
-            resolved_type, _resolved_obj = resolve_type(root_type, object)
-            resolved_type = schema.sync_lazy(resolved_type)
-            object_proxy = resolved_type.wrap(object, context)
-            object_proxy = schema.sync_lazy(object_proxy)
-            @response = GraphQLResultHash.new(nil, resolved_type, object_proxy, nil, false, selections, false, query.ast_nodes.first, nil, nil)
-            @response.base_path = base_path
-            each_gathered_selections(@response) do |selections, is_selection_array, ordered_result_keys|
-              @response.ordered_result_keys ||= ordered_result_keys
-              if is_selection_array == true
-                raise "This isn't supported yet"
-              end
-
-              @dataloader.append_job {
-                evaluate_selections(
-                  selections,
-                  @response,
-                  nil,
-                  runtime_state,
-                )
-              }
-            end
           else
             raise "Invariant: unsupported type kind for partial execution: #{root_type.kind.inspect} (#{root_type})"
           end
@@ -285,213 +283,6 @@ def gather_selections(owner_object, owner_type, selections, selections_to_run, s
           selections_to_run || selections_by_name
         end
 
-        NO_ARGS = GraphQL::EmptyObjects::EMPTY_HASH
-
-        # @return [void]
-        def evaluate_selections(gathered_selections, selections_result, target_result, runtime_state) # rubocop:disable Metrics/ParameterLists
-          runtime_state ||= get_current_runtime_state
-          runtime_state.current_result_name = nil
-          runtime_state.current_result = selections_result
-          # This is a less-frequent case; use a fast check since it's often not there.
-          if (directives = gathered_selections[:graphql_directives])
-            gathered_selections.delete(:graphql_directives)
-          end
-
-          call_method_on_directives(:resolve, selections_result.graphql_application_value, directives) do
-            gathered_selections.each do |result_name, field_ast_nodes_or_ast_node|
-              # Field resolution may pause the fiber,
-              # so it wouldn't get to the `Resolve` call that happens below.
-              # So instead trigger a run from this outer context.
-              if selections_result.graphql_is_eager
-                @dataloader.clear_cache
-                @dataloader.run_isolated {
-                  evaluate_selection(
-                    result_name, field_ast_nodes_or_ast_node, selections_result
-                  )
-                  @dataloader.clear_cache
-                }
-              else
-                @dataloader.append_job {
-                  evaluate_selection(
-                    result_name, field_ast_nodes_or_ast_node, selections_result
-                  )
-                }
-              end
-            end
-            if target_result
-              selections_result.merge_into(target_result)
-            end
-            selections_result
-          end
-        end
-
-        # @return [void]
-        def evaluate_selection(result_name, field_ast_nodes_or_ast_node, selections_result) # rubocop:disable Metrics/ParameterLists
-          return if selections_result.graphql_dead
-          # As a performance optimization, the hash key will be a `Node` if
-          # there's only one selection of the field. But if there are multiple
-          # selections of the field, it will be an Array of nodes
-          if field_ast_nodes_or_ast_node.is_a?(Array)
-            field_ast_nodes = field_ast_nodes_or_ast_node
-            ast_node = field_ast_nodes.first
-          else
-            field_ast_nodes = nil
-            ast_node = field_ast_nodes_or_ast_node
-          end
-          field_name = ast_node.name
-          owner_type = selections_result.graphql_result_type
-          field_defn = query.types.field(owner_type, field_name)
-
-          # Set this before calling `run_with_directives`, so that the directive can have the latest path
-          runtime_state = get_current_runtime_state
-          runtime_state.current_field = field_defn
-          runtime_state.current_result = selections_result
-          runtime_state.current_result_name = result_name
-
-          owner_object = selections_result.graphql_application_value
-          if field_defn.dynamic_introspection
-            owner_object = field_defn.owner.wrap(owner_object, context)
-          end
-
-          if !field_defn.any_arguments?
-            resolved_arguments = GraphQL::Execution::Interpreter::Arguments::EMPTY
-            if field_defn.extras.size == 0
-              evaluate_selection_with_resolved_keyword_args(
-                NO_ARGS, resolved_arguments, field_defn, ast_node, field_ast_nodes, owner_object, result_name, selections_result, runtime_state
-              )
-            else
-              evaluate_selection_with_args(resolved_arguments, field_defn, ast_node, field_ast_nodes, owner_object, result_name, selections_result, runtime_state)
-            end
-          else
-            @query.arguments_cache.dataload_for(ast_node, field_defn, owner_object) do |resolved_arguments|
-              runtime_state = get_current_runtime_state # This might be in a different fiber
-              evaluate_selection_with_args(resolved_arguments, field_defn, ast_node, field_ast_nodes, owner_object, result_name, selections_result, runtime_state)
-            end
-          end
-        end
-
-        def evaluate_selection_with_args(arguments, field_defn, ast_node, field_ast_nodes, object, result_name, selection_result, runtime_state)  # rubocop:disable Metrics/ParameterLists
-          after_lazy(arguments, field: field_defn, ast_node: ast_node, owner_object: object, arguments: arguments, result_name: result_name, result: selection_result, runtime_state: runtime_state) do |resolved_arguments, runtime_state|
-            if resolved_arguments.is_a?(GraphQL::ExecutionError) || resolved_arguments.is_a?(GraphQL::UnauthorizedError)
-              return_type_non_null = field_defn.type.non_null?
-              continue_value(resolved_arguments, field_defn, return_type_non_null, ast_node, result_name, selection_result)
-              next
-            end
-
-            kwarg_arguments = if field_defn.extras.empty?
-              if resolved_arguments.empty?
-                # We can avoid allocating the `{ Symbol => Object }` hash in this case
-                NO_ARGS
-              else
-                resolved_arguments.keyword_arguments
-              end
-            else
-              # Bundle up the extras, then make a new arguments instance
-              # that includes the extras, too.
-              extra_args = {}
-              field_defn.extras.each do |extra|
-                case extra
-                when :ast_node
-                  extra_args[:ast_node] = ast_node
-                when :execution_errors
-                  extra_args[:execution_errors] = ExecutionErrors.new(context, ast_node, current_path)
-                when :path
-                  extra_args[:path] = current_path
-                when :lookahead
-                  if !field_ast_nodes
-                    field_ast_nodes = [ast_node]
-                  end
-
-                  extra_args[:lookahead] = Execution::Lookahead.new(
-                    query: query,
-                    ast_nodes: field_ast_nodes,
-                    field: field_defn,
-                  )
-                when :argument_details
-                  # Use this flag to tell Interpreter::Arguments to add itself
-                  # to the keyword args hash _before_ freezing everything.
-                  extra_args[:argument_details] = :__arguments_add_self
-                when :parent
-                  parent_result = selection_result.graphql_parent
-                  extra_args[:parent] = parent_result&.graphql_application_value&.object
-                else
-                  extra_args[extra] = field_defn.fetch_extra(extra, context)
-                end
-              end
-              if !extra_args.empty?
-                resolved_arguments = resolved_arguments.merge_extras(extra_args)
-              end
-              resolved_arguments.keyword_arguments
-            end
-
-            evaluate_selection_with_resolved_keyword_args(kwarg_arguments, resolved_arguments, field_defn, ast_node, field_ast_nodes, object, result_name, selection_result, runtime_state)
-          end
-        end
-
-        def evaluate_selection_with_resolved_keyword_args(kwarg_arguments, resolved_arguments, field_defn, ast_node, field_ast_nodes, object, result_name, selection_result, runtime_state)  # rubocop:disable Metrics/ParameterLists
-          runtime_state.current_field = field_defn
-          runtime_state.current_arguments = resolved_arguments
-          runtime_state.current_result_name = result_name
-          runtime_state.current_result = selection_result
-          # Optimize for the case that field is selected only once
-          if field_ast_nodes.nil? || field_ast_nodes.size == 1
-            next_selections = ast_node.selections
-            directives = ast_node.directives
-          else
-            next_selections = []
-            directives = []
-            field_ast_nodes.each { |f|
-              next_selections.concat(f.selections)
-              directives.concat(f.directives)
-            }
-          end
-
-          field_result = call_method_on_directives(:resolve, object, directives) do
-            if !directives.empty?
-              # This might be executed in a different context; reset this info
-              runtime_state = get_current_runtime_state
-              runtime_state.current_field = field_defn
-              runtime_state.current_arguments = resolved_arguments
-              runtime_state.current_result_name = result_name
-              runtime_state.current_result = selection_result
-            end
-            # Actually call the field resolver and capture the result
-            app_result = begin
-              @current_trace.begin_execute_field(field_defn, object, kwarg_arguments, query)
-              @current_trace.execute_field(field: field_defn, ast_node: ast_node, query: query, object: object, arguments: kwarg_arguments) do
-                field_defn.resolve(object, kwarg_arguments, context)
-              end
-            rescue GraphQL::ExecutionError => err
-              err
-            rescue StandardError => err
-              begin
-                query.handle_or_reraise(err)
-              rescue GraphQL::ExecutionError => ex_err
-                ex_err
-              end
-            end
-            @current_trace.end_execute_field(field_defn, object, kwarg_arguments, query, app_result)
-            after_lazy(app_result, field: field_defn, ast_node: ast_node, owner_object: object, arguments: resolved_arguments, result_name: result_name, result: selection_result, runtime_state: runtime_state) do |inner_result, runtime_state|
-              owner_type = selection_result.graphql_result_type
-              return_type = field_defn.type
-              continue_value = continue_value(inner_result, field_defn, return_type.non_null?, ast_node, result_name, selection_result)
-              if HALT != continue_value
-                was_scoped = runtime_state.was_authorized_by_scope_items
-                runtime_state.was_authorized_by_scope_items = nil
-                continue_field(continue_value, owner_type, field_defn, return_type, ast_node, next_selections, false, object, resolved_arguments, result_name, selection_result, was_scoped, runtime_state)
-              else
-                nil
-              end
-            end
-          end
-          # If this field is a root mutation field, immediately resolve
-          # all of its child fields before moving on to the next root mutation field.
-          # (Subselections of this mutation will still be resolved level-by-level.)
-          if selection_result.graphql_is_eager
-            Interpreter::Resolve.resolve_all([field_result], @dataloader)
-          end
-        end
-
         def set_result(selection_result, result_name, value, is_child_result, is_non_null)
           if !selection_result.graphql_dead
             if value.nil? && is_non_null
@@ -654,7 +445,7 @@ def continue_value(value, field, is_non_null, ast_node, result_name, selection_r
         # Location information from `path` and `ast_node`.
         #
         # @return [Lazy, Array, Hash, Object] Lazy, Array, and Hash are all traversed to resolve lazy values later
-        def continue_field(value, owner_type, field, current_type, ast_node, next_selections, is_non_null, owner_object, arguments, result_name, selection_result, was_scoped, runtime_state) # rubocop:disable Metrics/ParameterLists
+        def continue_field(value, field, current_type, ast_node, next_selections, is_non_null, arguments, result_name, selection_result, was_scoped, runtime_state) # rubocop:disable Metrics/ParameterLists
           if current_type.non_null?
             current_type = current_type.of_type
             is_non_null = true
@@ -671,136 +462,98 @@ def continue_field(value, owner_type, field, current_type, ast_node, next_select
             end
             set_result(selection_result, result_name, r, false, is_non_null)
             r
-          when "UNION", "INTERFACE"
-            resolved_type_or_lazy = begin
-                                      resolve_type(current_type, value)
-                                    rescue GraphQL::ExecutionError, GraphQL::UnauthorizedError => ex_err
-                                      return continue_value(ex_err, field, is_non_null, ast_node, result_name, selection_result)
-                                    rescue StandardError => err
-                                      begin
-                                        query.handle_or_reraise(err)
-                                      rescue GraphQL::ExecutionError => ex_err
-                                        return continue_value(ex_err, field, is_non_null, ast_node, result_name, selection_result)
-                                      end
-                                    end
-            after_lazy(resolved_type_or_lazy, ast_node: ast_node, field: field, owner_object: owner_object, arguments: arguments, trace: false, result_name: result_name, result: selection_result, runtime_state: runtime_state) do |resolved_type_result, runtime_state|
-              if resolved_type_result.is_a?(Array) && resolved_type_result.length == 2
-                resolved_type, resolved_value = resolved_type_result
-              else
-                resolved_type = resolved_type_result
-                resolved_value = value
-              end
-
-              possible_types = query.types.possible_types(current_type)
-              if !possible_types.include?(resolved_type)
-                parent_type = field.owner_type
-                err_class = current_type::UnresolvedTypeError
-                type_error = err_class.new(resolved_value, field, parent_type, resolved_type, possible_types)
-                schema.type_error(type_error, context)
-                set_result(selection_result, result_name, nil, false, is_non_null)
-                nil
-              else
-                continue_field(resolved_value, owner_type, field, resolved_type, ast_node, next_selections, is_non_null, owner_object, arguments, result_name, selection_result, was_scoped, runtime_state)
-              end
-            end
-          when "OBJECT"
-            object_proxy = begin
-              was_scoped ? current_type.wrap_scoped(value, context) : current_type.wrap(value, context)
-            rescue GraphQL::ExecutionError => err
-              err
-            end
-            after_lazy(object_proxy, ast_node: ast_node, field: field, owner_object: owner_object, arguments: arguments, trace: false, result_name: result_name, result: selection_result, runtime_state: runtime_state) do |inner_object, runtime_state|
-              continue_value = continue_value(inner_object, field, is_non_null, ast_node, result_name, selection_result)
-              if HALT != continue_value
-                response_hash = GraphQLResultHash.new(result_name, current_type, continue_value, selection_result, is_non_null, next_selections, false, ast_node, arguments, field)
-                set_result(selection_result, result_name, response_hash, true, is_non_null)
-                each_gathered_selections(response_hash) do |selections, is_selection_array, ordered_result_keys|
-                  response_hash.ordered_result_keys ||= ordered_result_keys
-                  if is_selection_array
-                    this_result = GraphQLResultHash.new(result_name, current_type, continue_value, selection_result, is_non_null, selections, false, ast_node, arguments, field)
-                    this_result.ordered_result_keys = ordered_result_keys
-                    final_result = response_hash
-                  else
-                    this_result = response_hash
-                    final_result = nil
-                  end
-
-                  evaluate_selections(
-                    selections,
-                    this_result,
-                    final_result,
-                    runtime_state,
-                  )
-                end
-              end
-            end
+          when "OBJECT", "UNION", "INTERFACE"
+            response_hash = GraphQLResultHash.new(self, result_name, current_type, value, selection_result, is_non_null, next_selections, false, ast_node, arguments, field)
+            response_hash.was_scoped = was_scoped
+            @dataloader.append_job response_hash
           when "LIST"
-            inner_type = current_type.of_type
-            # This is true for objects, unions, and interfaces
-            use_dataloader_job = !inner_type.unwrap.kind.input?
-            inner_type_non_null = inner_type.non_null?
-            response_list = GraphQLResultArray.new(result_name, current_type, owner_object, selection_result, is_non_null, next_selections, false, ast_node, arguments, field)
+            response_list = GraphQLResultArray.new(self, result_name, current_type, value, selection_result, is_non_null, next_selections, false, ast_node, arguments, field)
+            response_list.was_scoped = was_scoped
             set_result(selection_result, result_name, response_list, true, is_non_null)
-            idx = nil
-            list_value = begin
-              begin
-                value.each do |inner_value|
-                  idx ||= 0
-                  this_idx = idx
-                  idx += 1
-                  if use_dataloader_job
-                    @dataloader.append_job do
-                      resolve_list_item(inner_value, inner_type, inner_type_non_null, ast_node, field, owner_object, arguments, this_idx, response_list, owner_type, was_scoped, runtime_state)
-                    end
-                  else
-                    resolve_list_item(inner_value, inner_type, inner_type_non_null, ast_node, field, owner_object, arguments, this_idx, response_list, owner_type, was_scoped, runtime_state)
-                  end
-                end
+            @dataloader.append_job(response_list)
+            response_list # TODO smell this is used because its returned by `yield` inside a directive
+          else
+            raise "Invariant: Unhandled type kind #{current_type.kind} (#{current_type})"
+          end
+        end
 
-                response_list
-              rescue NoMethodError => err
-                # Ruby 2.2 doesn't have NoMethodError#receiver, can't check that one in this case. (It's been EOL since 2017.)
-                if err.name == :each && (err.respond_to?(:receiver) ? err.receiver == value : true)
-                  # This happens when the GraphQL schema doesn't match the implementation. Help the dev debug.
-                  raise ListResultFailedError.new(value: value, field: field, path: current_path)
-                else
-                  # This was some other NoMethodError -- let it bubble to reveal the real error.
-                  raise
-                end
-              rescue GraphQL::ExecutionError, GraphQL::UnauthorizedError => ex_err
-                ex_err
-              rescue StandardError => err
-                begin
-                  query.handle_or_reraise(err)
-                rescue GraphQL::ExecutionError => ex_err
-                  ex_err
-                end
-              end
+        class ListItemStep
+          include Runtime::Step
+
+          def initialize(runtime, list_result, index, item_value)
+            @runtime = runtime
+            @list_result = list_result
+            @index = index
+            @item_value = item_value
+            @step = :check_directives
+          end
+
+          def current_result
+            @list_result
+          end
+
+          def current_result_name
+            @index
+          end
+
+          def step_finished?
+            @step == :finished
+          end
+
+          def inspect_step
+            "#{self.class.name.split("::").last}##{object_id}@#{@index}"
+          end
+
+          def value # Lazy API
+            @item_value = begin
+              @runtime.schema.sync_lazy(@item_value)
+            rescue GraphQL::ExecutionError => err
+              err
             rescue StandardError => err
               begin
-                query.handle_or_reraise(err)
+                @runtime.query.handle_or_reraise(err)
               rescue GraphQL::ExecutionError => ex_err
                 ex_err
               end
             end
-            # Detect whether this error came while calling `.each` (before `idx` is set) or while running list *items* (after `idx` is set)
-            error_is_non_null = idx.nil? ? is_non_null : inner_type.non_null?
-            continue_value(list_value, field, error_is_non_null, ast_node, result_name, selection_result)
-          else
-            raise "Invariant: Unhandled type kind #{current_type.kind} (#{current_type})"
           end
-        end
 
-        def resolve_list_item(inner_value, inner_type, inner_type_non_null, ast_node, field, owner_object, arguments, this_idx, response_list, owner_type, was_scoped, runtime_state) # rubocop:disable Metrics/ParameterLists
-          runtime_state.current_result_name = this_idx
-          runtime_state.current_result = response_list
-          call_method_on_directives(:resolve_each, owner_object, ast_node.directives) do
-            # This will update `response_list` with the lazy
-            after_lazy(inner_value, ast_node: ast_node, field: field, owner_object: owner_object, arguments: arguments, result_name: this_idx, result: response_list, runtime_state: runtime_state) do |inner_inner_value, runtime_state|
-              continue_value = continue_value(inner_inner_value, field, inner_type_non_null, ast_node, this_idx, response_list)
-              if HALT != continue_value
-                continue_field(continue_value, owner_type, field, inner_type, ast_node, response_list.graphql_selections, false, owner_object, arguments, this_idx, response_list, was_scoped, runtime_state)
+          def depth
+            @list_result.depth + 1
+          end
+
+          def run_step
+            case @step
+            when :check_directives
+              if (dirs = @list_result.ast_node.directives).any?
+                @step = :finished
+              runtime_state = @runtime.get_current_runtime_state
+              runtime_state.current_result_name = @index
+              runtime_state.current_result = @list_result
+                @runtime.call_method_on_directives(:resolve_each, @list_result.graphql_application_value, dirs) do
+                  @step = :check_lazy_item
+                end
+              else
+                @step = :check_lazy_item
               end
+            when :check_lazy_item
+              @step = :handle_item
+              if @runtime.lazy?(@item_value)
+                @item_value
+              else
+                nil
+              end
+            when :handle_item
+              item_type = @list_result.graphql_result_type.of_type
+              item_type_non_null = item_type.non_null?
+              continue_value = @runtime.continue_value(@item_value, @list_result.graphql_field, item_type_non_null, @list_result.ast_node, @index, @list_result)
+              if !HALT.equal?(continue_value)
+                was_scoped = @list_result.was_scoped
+                @runtime.continue_field(continue_value, @list_result.graphql_field, item_type, @list_result.ast_node, @list_result.graphql_selections, false, @list_result.graphql_arguments, @index, @list_result, was_scoped, @runtime.get_current_runtime_state)
+              end
+              @step = :finished
+            else
+              raise "Invariant: unexpected step: #{inspect_step}"
             end
           end
         end
@@ -890,6 +643,7 @@ def after_lazy(lazy_obj, field:, owner_object:, arguments:, ast_node:, result:,
               runtime_state.current_arguments = arguments
               runtime_state.current_result_name = result_name
               runtime_state.current_result = orig_result
+              runtime_state.current_step = orig_result
               runtime_state.was_authorized_by_scope_items = was_authorized_by_scope_items
               # Wrap the execution of _this_ method with tracing,
               # but don't wrap the continuation below
diff --git a/lib/graphql/execution/interpreter/runtime/field_resolve_step.rb b/lib/graphql/execution/interpreter/runtime/field_resolve_step.rb
new file mode 100644
index 0000000000..9e7503faf0
--- /dev/null
+++ b/lib/graphql/execution/interpreter/runtime/field_resolve_step.rb
@@ -0,0 +1,264 @@
+# frozen_string_literal: true
+
+module GraphQL
+  module Execution
+    class Interpreter
+      class Runtime
+        class FieldResolveStep
+          include Runtime::Step
+
+          def initialize(runtime, field, ast_node, ast_nodes, result_name, selection_result)
+            @runtime = runtime
+            @field = field
+            @object = selection_result.graphql_application_value
+            if @field.dynamic_introspection
+              # TODO `.wrap` isn't used elsewhere
+              @object = field.owner.wrap(@object, @runtime.context)
+            end
+            @ast_node = ast_node
+            @ast_nodes = ast_nodes
+            @result_name = result_name
+            @selection_result = selection_result
+            @next_selections = nil
+            @step = :inspect_ast
+          end
+
+          attr_reader :selection_result
+
+          def current_result
+            @selection_result
+          end
+
+          def current_result_name
+            @result_name
+          end
+
+          def inspect_step
+            "#{self.class.name.split("::").last}##{object_id}/#@step(#{@field.path} @ #{@selection_result.path.join(".")}.#{@result_name}, #{@result.class})"
+          end
+
+          def step_finished?
+            @step == :finished
+          end
+
+          def depth
+            @selection_result.depth + 1
+          end
+
+          attr_accessor :result
+
+          def value # Lazy API
+            @result = begin
+              rs = @runtime.get_current_runtime_state
+              rs.current_result = current_result
+              rs.current_result_name = current_result_name
+              rs.current_step = self
+              @runtime.schema.sync_lazy(@result)
+            rescue GraphQL::ExecutionError => err
+              err
+            rescue UnauthorizedError => err
+              err
+            rescue StandardError => err
+              begin
+                @runtime.query.handle_or_reraise(err)
+              rescue GraphQL::ExecutionError => ex_err
+                ex_err
+              end
+            end
+          end
+
+          def run_step
+            if @selection_result.graphql_dead
+              @step = :finished
+              return nil
+            end
+            case @step
+            when :inspect_ast
+              inspect_ast
+            when :load_arguments
+              load_arguments
+            when :prepare_kwarg_arguments
+              prepare_kwarg_arguments
+            when :call_field_resolver
+              call_field_resolver
+            when :handle_resolved_value
+              handle_resolved_value
+            else
+              raise "Invariant: unexpected #{self.class} step: #{@step.inspect} (#{inspect_step})"
+            end
+          end
+
+          private
+
+          def inspect_ast
+            # Optimize for the case that field is selected only once
+            if @ast_nodes.nil? || @ast_nodes.size == 1
+              @next_selections = @ast_node.selections
+              directives = @ast_node.directives
+            else
+              @next_selections = []
+              directives = []
+              @ast_nodes.each { |f|
+                @next_selections.concat(f.selections)
+                directives.concat(f.directives)
+              }
+            end
+
+            if directives.any?
+              @step = :finished # some way to detect whether the block below is called or not
+              @runtime.call_method_on_directives(:resolve, @object, directives) do
+                @step = :load_arguments
+                self # TODO what kind of compatibility is possible here?
+              end
+            else
+              load_arguments
+            end
+          end
+
+          def load_arguments
+            if !@field.any_arguments?
+              @resolved_arguments = GraphQL::Execution::Interpreter::Arguments::EMPTY
+              if @field.extras.size == 0
+                @kwarg_arguments = EmptyObjects::EMPTY_HASH
+                call_field_resolver
+              else
+                prepare_kwarg_arguments
+              end
+            else
+              @step = :prepare_kwarg_arguments
+              @result = nil
+              @should_continue_args = false
+              @runtime.query.arguments_cache.dataload_for(@ast_node, @field, @object) do |resolved_arguments|
+                @result = resolved_arguments
+                if @should_continue_args
+                  prepare_kwarg_arguments
+                end
+              end
+              @should_continue_args = true
+              @result
+            end
+          end
+
+          def prepare_kwarg_arguments
+            # TODO the problem is that if Dataloader pauses in the block above,
+            # the step is somehow resumed here.
+            # Then the call in the block above also runs later, resulting in double-execution.
+            # I think the big fix is to move the dataloader-y stuff from argument resolution
+            # and inline it here.
+            @should_continue_args = false
+            # @resolved_arguments may have been eagerly set if there aren't actually any args
+            if @resolved_arguments.nil? && @result.nil?
+              @runtime.dataloader.run
+            end
+            @resolved_arguments ||= @result
+            @result = nil # TODO is this still necessary?
+            if @resolved_arguments.is_a?(GraphQL::ExecutionError) || @resolved_arguments.is_a?(GraphQL::UnauthorizedError)
+              return_type_non_null = @field.type.non_null?
+              @runtime.continue_value(@resolved_arguments, @field, return_type_non_null, @ast_node, @result_name, @selection_result)
+              @step = :finished
+              return
+            end
+
+            @kwarg_arguments = if @field.extras.empty?
+              if @resolved_arguments.empty?
+                # We can avoid allocating the `{ Symbol => Object }` hash in this case
+                EmptyObjects::EMPTY_HASH
+              else
+                @resolved_arguments.keyword_arguments
+              end
+            else
+              # Bundle up the extras, then make a new arguments instance
+              # that includes the extras, too.
+              extra_args = {}
+              @field.extras.each do |extra|
+                case extra
+                when :ast_node
+                  extra_args[:ast_node] = @ast_node
+                when :execution_errors
+                  extra_args[:execution_errors] = ExecutionErrors.new(@runtime.context, @ast_node, @runtime.current_path)
+                when :path
+                  extra_args[:path] = @runtime.current_path
+                when :lookahead
+                  if !@field_ast_nodes
+                    @field_ast_nodes = [@ast_node]
+                  end
+
+                  extra_args[:lookahead] = Execution::Lookahead.new(
+                    query: @runtime.query,
+                    ast_nodes: @field_ast_nodes,
+                    field: @field,
+                  )
+                when :argument_details
+                  # Use this flag to tell Interpreter::Arguments to add itself
+                  # to the keyword args hash _before_ freezing everything.
+                  extra_args[:argument_details] = :__arguments_add_self
+                when :parent
+                  parent_result = @selection_result.graphql_parent
+                  if parent_result.is_a?(GraphQL::Execution::Interpreter::Runtime::GraphQLResultArray)
+                    parent_result = parent_result.graphql_parent
+                  end
+                  parent_value = parent_result&.graphql_application_value&.object
+                  extra_args[:parent] = parent_value
+                else
+                  extra_args[extra] = @field.fetch_extra(extra, @runtime.context)
+                end
+              end
+              if !extra_args.empty?
+                @resolved_arguments = @resolved_arguments.merge_extras(extra_args)
+              end
+              @resolved_arguments.keyword_arguments
+            end
+            call_field_resolver
+          end
+
+          def call_field_resolver
+            # if !directives.empty?
+              # This might be executed in a different context; reset this info
+            runtime_state = @runtime.get_current_runtime_state
+            runtime_state.current_field = @field
+            runtime_state.current_arguments = @resolved_arguments
+            runtime_state.current_result_name = @result_name
+            runtime_state.current_result = @selection_result
+            runtime_state.current_step = self
+            # end
+
+            # Actually call the field resolver and capture the result
+            query = @runtime.query
+            app_result = begin
+              @runtime.current_trace.begin_execute_field(@field, @object, @kwarg_arguments, query)
+              @runtime.current_trace.execute_field(field: @field, ast_node: @ast_node, query: query, object: @object, arguments: @kwarg_arguments) do
+                @field.resolve(@object, @kwarg_arguments, query.context)
+              end
+            rescue GraphQL::ExecutionError => err
+              err
+            rescue StandardError => err
+              begin
+                query.handle_or_reraise(err)
+              rescue GraphQL::ExecutionError => ex_err
+                ex_err
+              end
+            end
+            @runtime.current_trace.end_execute_field(@field, @object, @kwarg_arguments, query, app_result)
+            @step = :handle_resolved_value
+            @result = app_result
+          end
+
+          def handle_resolved_value
+            return_type = @field.type
+            @result = @runtime.continue_value(@result, @field, return_type.non_null?, @ast_node, @result_name, @selection_result)
+
+            if !HALT.equal?(@result)
+              runtime_state = @runtime.get_current_runtime_state
+              was_scoped =  @was_scoped
+              @runtime.continue_field(@result, @field, return_type, @ast_node, @next_selections, false, @resolved_arguments, @result_name, @selection_result, was_scoped, runtime_state)
+            else
+              nil
+            end
+            @step = :finished
+            nil
+          end
+        end
+      end
+    end
+  end
+end
diff --git a/lib/graphql/execution/interpreter/runtime/graphql_result.rb b/lib/graphql/execution/interpreter/runtime/graphql_result.rb
index fdba7911bb..a58380fa8a 100644
--- a/lib/graphql/execution/interpreter/runtime/graphql_result.rb
+++ b/lib/graphql/execution/interpreter/runtime/graphql_result.rb
@@ -5,7 +5,9 @@ module Execution
     class Interpreter
       class Runtime
         module GraphQLResult
-          def initialize(result_name, result_type, application_value, parent_result, is_non_null_in_parent, selections, is_eager, ast_node, graphql_arguments, graphql_field) # rubocop:disable Metrics/ParameterLists
+          include Runtime::Step
+          def initialize(runtime_instance, result_name, result_type, application_value, parent_result, is_non_null_in_parent, selections, is_eager, ast_node, graphql_arguments, graphql_field) # rubocop:disable Metrics/ParameterLists
+            @runtime = runtime_instance
             @ast_node = ast_node
             @graphql_arguments = graphql_arguments
             @graphql_field = graphql_field
@@ -22,11 +24,20 @@ def initialize(result_name, result_type, application_value, parent_result, is_no
             @graphql_selections = selections
             @graphql_is_eager = is_eager
             @base_path = nil
+            @graphql_depth = nil
           end
 
           # TODO test full path in Partial
           attr_writer :base_path
 
+          def current_result
+            self
+          end
+
+          def current_result_name
+            nil
+          end
+
           def path
             @path ||= build_path([])
           end
@@ -42,22 +53,275 @@ def build_path(path_array)
             end
           end
 
-          attr_accessor :graphql_dead
+          attr_accessor :graphql_dead, :was_scoped
           attr_reader :graphql_parent, :graphql_result_name, :graphql_is_non_null_in_parent,
             :graphql_application_value, :graphql_result_type, :graphql_selections, :graphql_is_eager, :ast_node, :graphql_arguments, :graphql_field
 
+          attr_reader :step
+
           # @return [Hash] Plain-Ruby result data (`@graphql_metadata` contains Result wrapper objects)
           attr_accessor :graphql_result_data
         end
 
         class GraphQLResultHash
-          def initialize(_result_name, _result_type, _application_value, _parent_result, _is_non_null_in_parent, _selections, _is_eager, _ast_node, _graphql_arguments, graphql_field) # rubocop:disable Metrics/ParameterLists
+
+          def initialize(_runtime_inst, _result_name, _result_type, _application_value, _parent_result, _is_non_null_in_parent, _selections, _is_eager, _ast_node, _graphql_arguments, graphql_field) # rubocop:disable Metrics/ParameterLists
             super
             @graphql_result_data = {}
             @ordered_result_keys = nil
+            @target_result = nil
+            @was_scoped = nil
+            @resolve_type_result = nil
+            @authorized_check_result = nil
+            if @graphql_result_type.kind.object?
+              @step = :authorize_application_value
+            else
+              @step = :resolve_abstract_type
+            end
+          end
+
+          def set_step(new_step)
+            @step = new_step
+          end
+
+          def depth
+            @graphql_depth ||= begin
+              parent_depth = @graphql_parent ? @graphql_parent.depth : 0
+              parent_depth + 1
+            end
+          end
+
+          def inspect_step
+            "#{self.class.name.split("::").last}##{object_id}:#@step(#{@graphql_result_type.to_type_signature} @ #{path.join(".")}, #{(@graphql_application_value&.object.class rescue @graphql_application_value.class)}})"
+          end
+
+          def step_finished?
+            @step == :finished
+          end
+
+          def value
+            if @resolve_type_result
+              @resolve_type_result = @runtime.schema.sync_lazy(@resolve_type_result)
+            elsif @authorized_check_result
+              @runtime.current_trace.begin_authorized(@graphql_result_type, @graphql_application_value, @runtime.context)
+              @runtime.current_trace.authorized_lazy(query: @runtime.query, type: @graphql_result_type, object: @graphql_application_value) do
+                @authorized_check_result = @runtime.schema.sync_lazy(@authorized_check_result)
+                @runtime.current_trace.end_authorized(@graphql_result_type, @graphql_application_value, @runtime.context, @authorized_check_result)
+              end
+            else
+              @graphql_application_value = @runtime.schema.sync_lazy(@graphql_application_value)
+            end
+          end
+
+          def resolve_abstract_type
+            current_type = @graphql_result_type
+            value = @graphql_application_value
+            @resolve_type_result = begin
+              @runtime.resolve_type(current_type, value)
+            rescue GraphQL::ExecutionError, GraphQL::UnauthorizedError => ex_err
+              return @runtime.continue_value(ex_err, @graphql_field, @graphql_is_non_null_in_parent, @ast_node, @graphql_result_name, @graphql_parent)
+            rescue StandardError => err
+              begin
+                @runtime.query.handle_or_reraise(err)
+              rescue GraphQL::ExecutionError => ex_err
+                return @runtime.continue_value(ex_err, @graphql_field, @graphql_is_non_null_in_parent, @ast_node, @graphql_result_name, @graphql_parent)
+              end
+            end
+          end
+
+          def handle_resolved_type
+            if @resolve_type_result.is_a?(Array) && @resolve_type_result.length == 2
+              resolved_type, resolved_value = @resolve_type_result
+            else
+              resolved_type = @resolve_type_result
+              resolved_value = value
+            end
+            @resolve_type_result = nil
+            current_type = @graphql_result_type
+            possible_types = @runtime.query.types.possible_types(current_type)
+            if !possible_types.include?(resolved_type)
+              field = @graphql_field
+              parent_type = field.owner_type
+              err_class = current_type::UnresolvedTypeError
+              type_error = err_class.new(resolved_value, field, parent_type, resolved_type, possible_types)
+              @runtime.schema.type_error(type_error, @runtime.context)
+              @runtime.set_result(self, @result_name, nil, false, is_non_null)
+              nil
+            else
+              @graphql_result_type = resolved_type
+            end
+          end
+
+          def authorize_application_value
+            if @was_scoped
+              @authorized_check_result = true
+              @step = :handle_authorized_application_value
+              return # TODO continue?
+            end
+            @runtime.current_trace.begin_authorized(@graphql_result_type, @graphql_application_value, @runtime.context)
+            begin
+              @authorized_check_result = @runtime.current_trace.authorized(query: @runtime.query, type: @graphql_result_type, object: @graphql_application_value) do
+                begin
+                  @graphql_result_type.authorized?(@graphql_application_value, @runtime.context)
+                rescue GraphQL::UnauthorizedError => err
+                  begin
+                    @runtime.schema.unauthorized_object(err)
+                  rescue GraphQL::ExecutionError => err
+                    # TODO this is getting handled like a normal "false" below
+                    # but should skip the re-wrapping with UnauthorizedError
+                    @graphql_application_value = err
+                    false
+                  end
+                rescue StandardError => err
+                  @runtime.query.handle_or_reraise(err)
+                end
+              end
+            ensure
+              @step = :handle_authorized_application_value
+              @runtime.current_trace.end_authorized(@graphql_result_type, @graphql_application_value, @runtime.context, @authorized_check_result)
+            end
+          end
+
+          def run_step
+            case @step
+            when :resolve_abstract_type
+              @step = :handle_resolved_type
+              resolve_abstract_type
+            when :handle_resolved_type
+              handle_resolved_type
+              authorize_application_value
+            when :authorize_application_value
+              # TODO skip if scoped
+              authorize_application_value
+            when :handle_authorized_application_value
+              # TODO doesn't actually support `.wrap` - that may be impossible if merged into Schema::Object
+              if @authorized_check_result
+                # TODO don't call `scoped_new here`
+                @graphql_application_value = @graphql_result_type.scoped_new(@graphql_application_value, @runtime.context)
+              else
+                # It failed the authorization check, so go to the schema's authorized object hook
+                err = GraphQL::UnauthorizedError.new(object: @graphql_application_value, type: @graphql_result_type, context: @runtime.context)
+                # If a new value was returned, wrap that instead of the original value
+                begin
+                  new_obj = @runtime.schema.unauthorized_object(err)
+                  if new_obj
+                    # TODO don't do this work-around
+                    @graphql_application_value = @graphql_result_type.scoped_new(new_obj, @runtime.context)
+                  else
+                    @graphql_application_value = nil
+                  end
+                rescue GraphQL::ExecutionError => err
+                  @graphql_application_value = err
+                end
+              end
+              @authorized_check_result = nil
+              @step = :handle_wrapped_application_value
+            when :handle_wrapped_application_value
+              @graphql_application_value = @runtime.continue_value(@graphql_application_value, @graphql_field, @graphql_is_non_null_in_parent, @ast_node, @graphql_result_name, @graphql_parent)
+              if HALT.equal?(@graphql_application_value)
+                @step = :finished
+                return
+              elsif @graphql_parent
+                @runtime.set_result(@graphql_parent, @graphql_result_name, self, true, @graphql_is_non_null_in_parent)
+              end
+              @step = :run_selections
+            when :run_selections
+              @runtime.each_gathered_selections(self) do |gathered_selections, is_selection_array, ordered_result_keys|
+                @ordered_result_keys ||= ordered_result_keys
+                if is_selection_array
+                  selections_result = GraphQLResultHash.new(
+                    @runtime,
+                    @graphql_result_name,
+                    @graphql_result_type,
+                    @graphql_application_value,
+                    @graphql_parent,
+                    @graphql_is_non_null_in_parent,
+                    gathered_selections,
+                    @graphql_is_eager,
+                    @ast_node,
+                    @graphql_arguments,
+                    @graphql_field)
+                  selections_result.target_result = self
+                  selections_result.ordered_result_keys = ordered_result_keys
+                  selections_result.set_step :run_selection_directives
+                  @runtime.dataloader.append_job(selections_result)
+                  @step = :finished # Continuing from others now -- could actually reuse this instance for the first one tho
+                else
+                  selections_result = self
+                  @target_result = nil
+                  @graphql_selections = gathered_selections
+                  # TODO extract these substeps out into methods, call that method directly
+                  @step = :run_selection_directives
+                end
+                runtime_state = @runtime.get_current_runtime_state
+                runtime_state.current_result_name = nil
+                runtime_state.current_result = selections_result
+                runtime_state.current_step = self
+                nil
+              end
+            when :run_selection_directives
+              if (directives = @graphql_selections[:graphql_directives])
+                @graphql_selections.delete(:graphql_directives)
+                @step = :finished # some way to detect whether the block below is called or not
+                @runtime.call_method_on_directives(:resolve, @graphql_application_value, directives) do
+                  @step = :call_each_field
+                end
+              else
+                # TODO some way to continue without this step
+                @step = :call_each_field
+              end
+            when :call_each_field
+              @graphql_selections.each do |result_name, field_ast_nodes_or_ast_node|
+                # Field resolution may pause the fiber,
+                # so it wouldn't get to the `Resolve` call that happens below.
+                # So instead trigger a run from this outer context.
+                if @graphql_is_eager
+                  @runtime.dataloader.clear_cache
+                  @runtime.dataloader.run_isolated {
+                    evaluate_selection(
+                      result_name, field_ast_nodes_or_ast_node
+                    )
+                    @runtime.dataloader.clear_cache
+                  }
+                else
+                  @runtime.dataloader.append_job {
+                    evaluate_selection(
+                      result_name, field_ast_nodes_or_ast_node
+                    )
+                  }
+                end
+              end
+
+              if @target_result
+                self.merge_into(@target_result)
+              end
+              @step = :finished
+            else
+              raise "Invariant: invalid state for #{self.class}: #{@step}"
+            end
+          end
+
+          def evaluate_selection(result_name, field_ast_nodes_or_ast_node) # rubocop:disable Metrics/ParameterLists
+            return if @graphql_dead
+
+            # Don't create the list of nodes if there's only one node
+            if field_ast_nodes_or_ast_node.is_a?(Array)
+              field_ast_nodes = field_ast_nodes_or_ast_node
+              ast_node = field_ast_nodes.first
+            else
+              field_ast_nodes = nil
+              ast_node = field_ast_nodes_or_ast_node
+            end
+
+            field_name = ast_node.name
+            owner_type = @graphql_result_type
+            field_defn = @runtime.query.types.field(owner_type, field_name)
+
+            resolve_field_step = FieldResolveStep.new(@runtime, field_defn, ast_node, field_ast_nodes, result_name, self)
+            @runtime.dataloader.append_job(resolve_field_step)
           end
 
-          attr_accessor :ordered_result_keys
+          attr_accessor :ordered_result_keys, :target_result
 
           include GraphQLResult
 
@@ -162,11 +426,75 @@ def fix_result_order
         class GraphQLResultArray
           include GraphQLResult
 
-          def initialize(_result_name, _result_type, _application_value, _parent_result, _is_non_null_in_parent, _selections, _is_eager, _ast_node, _graphql_arguments, graphql_field) # rubocop:disable Metrics/ParameterLists
+          def initialize(_runtime_inst, _result_name, _result_type, _application_value, _parent_result, _is_non_null_in_parent, _selections, _is_eager, _ast_node, _graphql_arguments, graphql_field) # rubocop:disable Metrics/ParameterLists
             super
             @graphql_result_data = []
           end
 
+          def inspect_step
+            "#{self.class.name.split("::").last}##{object_id}:#@step(#{@graphql_result_type.to_type_signature} @ #{path.join(".")})"
+          end
+
+          def depth
+            @graphql_depth ||= @graphql_parent.depth + 1
+          end
+
+          def step_finished?
+            true
+          end
+
+          def run_step
+            current_type = @graphql_result_type
+            inner_type = current_type.of_type
+            # This is true for objects, unions, and interfaces
+            # use_dataloader_job = !inner_type.unwrap.kind.input?
+            idx = nil
+            list_value = begin
+              begin
+                @graphql_application_value.each do |inner_value|
+                  idx ||= 0
+                  this_idx = idx
+                  idx += 1
+                  list_item_step = ListItemStep.new(
+                    @runtime,
+                    self,
+                    this_idx,
+                    inner_value,
+                  )
+                  @runtime.dataloader.append_job(list_item_step)
+                end
+
+                self
+              rescue NoMethodError => err
+                # Ruby 2.2 doesn't have NoMethodError#receiver, can't check that one in this case. (It's been EOL since 2017.)
+                if err.name == :each && (err.respond_to?(:receiver) ? err.receiver == @graphql_application_value : true)
+                  # This happens when the GraphQL schema doesn't match the implementation. Help the dev debug.
+                  raise ListResultFailedError.new(value: @graphql_application_value, field: @graphql_field, path: @runtime.current_path)
+                else
+                  # This was some other NoMethodError -- let it bubble to reveal the real error.
+                  raise
+                end
+              rescue GraphQL::ExecutionError, GraphQL::UnauthorizedError => ex_err
+                ex_err
+              rescue StandardError => err
+                begin
+                  @runtime.query.handle_or_reraise(err)
+                rescue GraphQL::ExecutionError => ex_err
+                  ex_err
+                end
+              end
+            rescue StandardError => err
+              begin
+                @runtime.query.handle_or_reraise(err)
+              rescue GraphQL::ExecutionError => ex_err
+                ex_err
+              end
+            end
+            # Detect whether this error came while calling `.each` (before `idx` is set) or while running list *items* (after `idx` is set)
+            error_is_non_null = idx.nil? ? @graphql_is_non_null_in_parent : inner_type.non_null?
+            @runtime.continue_value(list_value, @graphql_field, error_is_non_null, @ast_node, @graphql_result_name, @graphql_parent)
+          end
+
           def graphql_skip_at(index)
             # Mark this index as dead. It's tricky because some indices may already be storing
             # `Lazy`s. So the runtime is still holding indexes _before_ skipping,
diff --git a/lib/graphql/execution/interpreter/runtime/step.rb b/lib/graphql/execution/interpreter/runtime/step.rb
new file mode 100644
index 0000000000..1feee5a236
--- /dev/null
+++ b/lib/graphql/execution/interpreter/runtime/step.rb
@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module GraphQL
+  module Execution
+    class Interpreter
+      class Runtime
+        module Step
+          attr_accessor :was_scoped
+
+          def call
+            step_finished = false
+            while !step_finished
+              # TODO use a `current_step`-type thing for this
+              rs = @runtime.get_current_runtime_state
+              rs.current_result = self.current_result
+              rs.current_result_name = self.current_result_name
+              rs.current_step = self
+              step_result = run_step
+              step_finished = step_finished?
+              if !step_finished && @runtime.lazy?(step_result)
+                @runtime.lazies_at_depth[depth] << self
+                @runtime.steps_to_rerun_after_lazy << self
+                step_finished = true # we'll come back around to it
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end
diff --git a/lib/graphql/execution/lazy.rb b/lib/graphql/execution/lazy.rb
index 41849f5f50..d2f72e6e3d 100644
--- a/lib/graphql/execution/lazy.rb
+++ b/lib/graphql/execution/lazy.rb
@@ -59,11 +59,6 @@ def self.all(lazies)
           lazies.map { |l| l.is_a?(Lazy) ? l.value : l }
         }
       end
-
-      # This can be used for fields which _had no_ lazy results
-      # @api private
-      NullResult = Lazy.new(){}
-      NullResult.value
     end
   end
 end
diff --git a/lib/graphql/pagination/connection.rb b/lib/graphql/pagination/connection.rb
index e22c625619..e9f1d09ba1 100644
--- a/lib/graphql/pagination/connection.rb
+++ b/lib/graphql/pagination/connection.rb
@@ -225,7 +225,7 @@ def detect_was_authorized_by_scope_items
         if @context &&
             (current_runtime_state = Fiber[:__graphql_runtime_info]) &&
             (query_runtime_state = current_runtime_state[@context.query])
-          query_runtime_state.was_authorized_by_scope_items
+          query_runtime_state.current_step.was_scoped
         else
           nil
         end
diff --git a/lib/graphql/query/partial.rb b/lib/graphql/query/partial.rb
index 31bd6abff6..c0e8428353 100644
--- a/lib/graphql/query/partial.rb
+++ b/lib/graphql/query/partial.rb
@@ -123,7 +123,6 @@ def selected_operation_name
       def set_type_info_from_path
         selections = [@query.selected_operation]
         type = @query.root_type
-        parent_type = nil
         field_defn = nil
 
         @path.each do |name_in_doc|
diff --git a/lib/graphql/schema.rb b/lib/graphql/schema.rb
index be3d20b729..1f0094f828 100644
--- a/lib/graphql/schema.rb
+++ b/lib/graphql/schema.rb
@@ -671,7 +671,7 @@ def union_memberships(type = nil)
       # @api private
       # @see GraphQL::Dataloader
       def dataloader_class
-        @dataloader_class || GraphQL::Dataloader::NullDataloader
+        @dataloader_class || GraphQL::Dataloader::FlatDataloader
       end
 
       attr_writer :dataloader_class
diff --git a/lib/graphql/schema/build_from_definition.rb b/lib/graphql/schema/build_from_definition.rb
index 8918818ae8..5a811334f7 100644
--- a/lib/graphql/schema/build_from_definition.rb
+++ b/lib/graphql/schema/build_from_definition.rb
@@ -402,6 +402,9 @@ def build_object_type(object_type_definition, type_resolver, base_type)
           builder = self
 
           Class.new(base_type) do
+            def self.name
+              "GraphQL::Schema::BuildFromDefinition::#{graphql_name}"
+            end
             graphql_name(object_type_definition.name)
             description(object_type_definition.description)
             ast_node(object_type_definition)
diff --git a/lib/graphql/schema/field/scope_extension.rb b/lib/graphql/schema/field/scope_extension.rb
index f031164f3d..ac86f053e4 100644
--- a/lib/graphql/schema/field/scope_extension.rb
+++ b/lib/graphql/schema/field/scope_extension.rb
@@ -14,7 +14,8 @@ def after_resolve(object:, arguments:, context:, value:, memo:)
               if !scoped_items.equal?(value) && !ret_type.reauthorize_scoped_objects
                 if (current_runtime_state = Fiber[:__graphql_runtime_info]) &&
                     (query_runtime_state = current_runtime_state[context.query])
-                  query_runtime_state.was_authorized_by_scope_items = true
+                  # query_runtime_state.was_authorized_by_scope_items = true
+                  query_runtime_state.current_step.was_scoped = true
                 end
               end
               scoped_items
diff --git a/lib/graphql/schema/object.rb b/lib/graphql/schema/object.rb
index e1f5a99f09..ad337f21de 100644
--- a/lib/graphql/schema/object.rb
+++ b/lib/graphql/schema/object.rb
@@ -43,6 +43,8 @@ def wrap_scoped(object, context)
           scoped_new(object, context)
         end
 
+        # TODO Runtime calls to `.wrap` have been removed, maybe clean this up
+
         # This is called by the runtime to return an object to call methods on.
         def wrap(object, context)
           authorized_new(object, context)
diff --git a/lib/graphql/types/relay/connection_behaviors.rb b/lib/graphql/types/relay/connection_behaviors.rb
index b00ebcde86..65f0db6bc8 100644
--- a/lib/graphql/types/relay/connection_behaviors.rb
+++ b/lib/graphql/types/relay/connection_behaviors.rb
@@ -198,7 +198,7 @@ def edges
           # already happened at the connection level.
           current_runtime_state = Fiber[:__graphql_runtime_info]
           query_runtime_state = current_runtime_state[context.query]
-          query_runtime_state.was_authorized_by_scope_items = @object.was_authorized_by_scope_items?
+          query_runtime_state.current_step.was_scoped = @object.was_authorized_by_scope_items?
           @object.edges
         end
 
@@ -207,7 +207,7 @@ def nodes
           # already happened at the connection level.
           current_runtime_state = Fiber[:__graphql_runtime_info]
           query_runtime_state = current_runtime_state[context.query]
-          query_runtime_state.was_authorized_by_scope_items = @object.was_authorized_by_scope_items?
+          query_runtime_state.current_step.was_scoped = @object.was_authorized_by_scope_items?
           @object.nodes
         end
       end
diff --git a/lib/graphql/types/relay/edge_behaviors.rb b/lib/graphql/types/relay/edge_behaviors.rb
index 22261757b2..7fe9d0278c 100644
--- a/lib/graphql/types/relay/edge_behaviors.rb
+++ b/lib/graphql/types/relay/edge_behaviors.rb
@@ -16,7 +16,7 @@ def self.included(child_class)
         def node
           current_runtime_state = Fiber[:__graphql_runtime_info]
           query_runtime_state = current_runtime_state[context.query]
-          query_runtime_state.was_authorized_by_scope_items = @object.was_authorized_by_scope_items?
+          query_runtime_state.current_step.was_scoped = @object.was_authorized_by_scope_items?
           @object.node
         end
 
diff --git a/spec/graphql/dataloader_spec.rb b/spec/graphql/dataloader_spec.rb
index d379c143ca..358c693359 100644
--- a/spec/graphql/dataloader_spec.rb
+++ b/spec/graphql/dataloader_spec.rb
@@ -1251,59 +1251,59 @@ def make_schema_from(schema)
 
   include DataloaderAssertions
 
-  if RUBY_VERSION >= "3.1.1"
-    require "async"
-    describe "AsyncDataloader" do
-      def make_schema_from(schema)
-        Class.new(schema) {
-          use GraphQL::Dataloader::AsyncDataloader
-        }
-      end
-
-      include DataloaderAssertions
-    end
-  end
-
-  if Fiber.respond_to?(:scheduler)
-    describe "nonblocking: true" do
-      def make_schema_from(schema)
-        Class.new(schema) do
-          use GraphQL::Dataloader, nonblocking: true
-        end
-      end
-
-      before do
-        Fiber.set_scheduler(::DummyScheduler.new)
-      end
-
-      after do
-        Fiber.set_scheduler(nil)
-      end
-
-      include DataloaderAssertions
-    end
-
-    if RUBY_ENGINE == "ruby" && !ENV["GITHUB_ACTIONS"]
-      describe "nonblocking: true with libev" do
-        require "libev_scheduler"
-        def make_schema_from(schema)
-          Class.new(schema) do
-            use GraphQL::Dataloader, nonblocking: true
-          end
-        end
-
-        before do
-          Fiber.set_scheduler(Libev::Scheduler.new)
-        end
-
-        after do
-          Fiber.set_scheduler(nil)
-        end
-
-        include DataloaderAssertions
-      end
-    end
-  end
+  # if RUBY_VERSION >= "3.1.1"
+  #   require "async"
+  #   describe "AsyncDataloader" do
+  #     def make_schema_from(schema)
+  #       Class.new(schema) {
+  #         use GraphQL::Dataloader::AsyncDataloader
+  #       }
+  #     end
+
+  #     include DataloaderAssertions
+  #   end
+  # end
+
+  # if Fiber.respond_to?(:scheduler)
+  #   describe "nonblocking: true" do
+  #     def make_schema_from(schema)
+  #       Class.new(schema) do
+  #         use GraphQL::Dataloader, nonblocking: true
+  #       end
+  #     end
+
+  #     before do
+  #       Fiber.set_scheduler(::DummyScheduler.new)
+  #     end
+
+  #     after do
+  #       Fiber.set_scheduler(nil)
+  #     end
+
+  #     include DataloaderAssertions
+  #   end
+
+  #   if RUBY_ENGINE == "ruby" && !ENV["GITHUB_ACTIONS"]
+  #     describe "nonblocking: true with libev" do
+  #       require "libev_scheduler"
+  #       def make_schema_from(schema)
+  #         Class.new(schema) do
+  #           use GraphQL::Dataloader, nonblocking: true
+  #         end
+  #       end
+
+  #       before do
+  #         Fiber.set_scheduler(Libev::Scheduler.new)
+  #       end
+
+  #       after do
+  #         Fiber.set_scheduler(nil)
+  #       end
+
+  #       include DataloaderAssertions
+  #     end
+  #   end
+  # end
 
   describe "example from #3314" do
     module Example
diff --git a/spec/graphql/schema/directive_spec.rb b/spec/graphql/schema/directive_spec.rb
index 6b1d7b1faf..db8faa5e63 100644
--- a/spec/graphql/schema/directive_spec.rb
+++ b/spec/graphql/schema/directive_spec.rb
@@ -117,7 +117,6 @@ def self.resolve(obj, args, ctx)
         result = nil
         ctx.dataloader.run_isolated do
           result = yield
-          GraphQL::Execution::Interpreter::Resolve.resolve_all([result], ctx.dataloader)
         end
 
         ctx[:count_fields] ||= Hash.new { |h, k| h[k] = [] }
@@ -337,9 +336,10 @@ def self.resolve_each(object, args, context)
           end
         end
 
-        def self.resolve(obj, args, ctx)
+        def self.resolve(object, arguments, context)
           value = yield
-          value.values.compact!
+          # Previously, `yield` returned a finished value. But it doesn't anymore.
+          value.selection_result.values.compact!
           value
         end
       end
diff --git a/spec/graphql/schema/member/scoped_spec.rb b/spec/graphql/schema/member/scoped_spec.rb
index 8b5fc76074..f0b1bffe80 100644
--- a/spec/graphql/schema/member/scoped_spec.rb
+++ b/spec/graphql/schema/member/scoped_spec.rb
@@ -349,8 +349,8 @@ def books
       log = []
       SkipAuthSchema.execute("{ book { title } books { title } }", context: { auth_log: log })
       expected_log = [
-        [:authorized?, "Nonsense Omnibus"],
         [:scope_items, ["Jayber Crow", "Hannah Coulter"]],
+        [:authorized?, "Nonsense Omnibus"],
         [:authorized?, "Jayber Crow"],
         [:authorized?, "Hannah Coulter"],
       ]