paper_trail_diff 0.14.0 → 0.15.0

data/lib/paper_trail_diff/diagnostics.rb

@@ -64,65 +64,92 @@ module PaperTrailDiff
   end
 
   # Performs read-only checks for known PaperTrail/PT-AT reconstruction hazards.
+  #
+  # The endpoints are a comparison's: two versions, or a version and the
+  # current record, in either order. Two current records read no history, so
+  # nothing is checked.
   class HistoryDiagnostics
-    #: (untyped, untyped, associations: Array[String | Symbol]) -> void
-    def initialize(from_version, to_version, associations:)
-      @from_version = from_version
-      @to_version = to_version
+    STOPPING_CODES = %i[
+      unknown_association unsupported_association association_tracking_unavailable
+    ].freeze
+
+    #: (untyped, untyped, associations: association_option, ?allow_approximate: bool) -> void
+    def initialize(from, to, associations:, allow_approximate: false)
+      @versions = validated_versions(from, to)
       @tree = AssociationTree.build(associations)
+      @traversal = AssociationTraversal.new(@tree)
+      @preparer = TraversalPreparer.new(tree: @tree, traversal: @traversal,
+                                        allow_approximate: allow_approximate)
+      @allow_approximate = allow_approximate
       @issues = [] #: Array[DiagnosticIssue]
     end
 
     #: () -> DiagnosticReport
     def call
-      model_class = validated_model_class
-      # Runs whether or not associations are selected: unorderable versions
-      # corrupt a scalar timeline just as surely, and a report that inspected
-      # nothing has no business answering `ok?`.
-      inspect_version_sequence
-      return DiagnosticReport.new(issues: @issues) if @tree.empty?
-
-      unless association_tracking_available?
-        add_error(:association_tracking_unavailable, tracking_unavailable_message)
-        return DiagnosticReport.new(issues: @issues)
+      unless @versions.empty?
+        model_class = Endpoint.model_class(@versions.fetch(0))
+        # Runs whether or not associations are selected: unorderable versions
+        # corrupt a scalar timeline just as surely, and a report that inspected
+        # nothing has no business answering `ok?`.
+        inspect_version_sequence(model_class)
+        inspect_associations(model_class) unless @tree.empty?
       end
-
-      traversal = AssociationTraversal.new(@tree)
-      selected = traversal.selected_reflections(model_class)
-      inspect_targets(selected)
-      inspect_checkpoint_timestamp(model_class)
-      inspect_habtm(model_class, selected)
       DiagnosticReport.new(issues: @issues)
     end
 
     private
 
-    # @rbs @from_version: untyped
-    # @rbs @to_version: untyped
+    # Each refusal a comparison would raise is an error, so `ok?` is false
+    # exactly when one would. The checks after them read reflections that must
+    # resolve and PT-AT records that must be there.
+    #: (untyped) -> void
+    def inspect_associations(model_class)
+      refusals = @preparer.refusals(model_class, historical: true)
+      refusals.each { |refusal| add_error(refusal.code, refusal.message, refusal.path) }
+      return if refusals.any? { |refusal| STOPPING_CODES.include?(refusal.code) }
+
+      selected = @traversal.selected_reflections(model_class)
+      inspect_polymorphic_targets(selected)
+      inspect_approximate_paths(model_class) if @allow_approximate
+      inspect_checkpoint_timestamp(model_class)
+      inspect_habtm(model_class, selected)
+    end
+
+    # @rbs @versions: Array[untyped]
     # @rbs @tree: AssociationTree
+    # @rbs @traversal: AssociationTraversal
+    # @rbs @preparer: TraversalPreparer
+    # @rbs @allow_approximate: bool
     # @rbs @issues: Array[DiagnosticIssue]
 
-    #: () -> untyped
-    def validated_model_class
-      unless version_identity(@from_version) == version_identity(@to_version)
-        raise VersionMismatchError, 'versions must belong to the same PaperTrail item'
+    # The endpoints that are versions, in the order given.
+    #: (untyped, untyped) -> Array[untyped]
+    def validated_versions(from, to)
+      Endpoint.validate!(from)
+      Endpoint.validate!(to)
+      unless Endpoint.identity(from) == Endpoint.identity(to)
+        raise VersionMismatchError, 'endpoints must belong to the same PaperTrail item'
       end
 
-      Object.const_get(version_type(@from_version))
-    rescue NoMethodError => e
-      raise VersionMismatchError, 'expected PaperTrail version endpoints', cause: e
+      [from, to].select { |endpoint| Endpoint.version?(endpoint) }
     end
 
     #: (Array[Array[untyped]]) -> void
-    def inspect_targets(selected)
+    def inspect_polymorphic_targets(selected)
       selected.each do |path, reflection|
-        if reflection.polymorphic?
-          add_warning(:polymorphic_target_unverified, 'polymorphic target cannot be verified', path)
-          next
-        end
+        next unless reflection.polymorphic?
 
-        inspect_versioned_model(reflection.klass, path)
-        inspect_through_model(reflection, path) if reflection.options[:through]
+        add_warning(:polymorphic_target_unverified, 'polymorphic target cannot be verified', path)
+      end
+    end
+
+    # Accepted, but read the way `allow_approximate:` describes.
+    #: (untyped) -> void
+    def inspect_approximate_paths(model_class)
+      ApproximatePaths.call(@traversal, model_class).each do |path, reason|
+        add_warning(:approximate_association,
+                    "association #{path} is read approximately with PT-AT (#{reason}): a " \
+                    'record that entered or left it since is reported wrongly', path)
       end
     end
 
@@ -139,9 +166,7 @@ module PaperTrailDiff
     # transaction that more than one owner recorded members in cannot be read.
     #: (untyped, Array[Array[untyped]]) -> void
     def inspect_shared_transactions(model_class, habtm)
-      versions = [@from_version, @to_version].select do |version|
-        version.respond_to?(:transaction_id) && version.transaction_id
-      end
+      versions = @versions.select { |version| VersionBoundary.transaction_id(version) }
       habtm.each do |path, reflection|
         owners = HabtmTransactionOwners.new(model_class, reflection)
         versions.each do |version|
@@ -154,15 +179,29 @@ module PaperTrailDiff
       end
     end
 
-    #: () -> void
-    def inspect_version_sequence
+    # With the current record as one endpoint there is one version, and the
+    # sequence runs on from it.
+    #: (untyped) -> void
+    def inspect_version_sequence(model_class)
+      first, last = @versions
       @issues.concat(
-        VersionSequenceDiagnostics.new(
-          @from_version, @to_version, associations_selected: !@tree.empty?
-        ).call
+        VersionSequenceDiagnostics.new(first, last,
+                                       fallback_selected: fallback_selected?(model_class)).call
       )
     end
 
+    # Only a path PT-AT reads can lose a change between tied versions, and a
+    # traversal that does not resolve reads nothing at all.
+    #: (untyped) -> bool
+    def fallback_selected?(model_class)
+      return false if @tree.empty?
+
+      refusals = @preparer.refusals(model_class, historical: true)
+      return false if refusals.any? { |refusal| STOPPING_CODES.include?(refusal.code) }
+
+      FallbackPaths.any?(@traversal, model_class, approximate: @allow_approximate)
+    end
+
     #: (untyped) -> void
     def inspect_checkpoint_timestamp(model_class)
       return if synchronized_timestamp_disabled?(model_class)
@@ -173,7 +212,7 @@ module PaperTrailDiff
 
     #: (Array[String]) -> void
     def inspect_transaction_metadata(paths)
-      [@from_version, @to_version].each do |version|
+      @versions.each do |version|
         if !version.respond_to?(:transaction_id)
           add_error(:transaction_id_column_missing, 'version has no transaction_id column')
         elsif version.transaction_id.nil?
@@ -189,36 +228,6 @@ module PaperTrailDiff
       end
     end
 
-    #: (untyped, String) -> void
-    def inspect_versioned_model(model_class, path)
-      return if model_versioned?(model_class)
-
-      # An error rather than a warning: `ok?` must not stay true for a
-      # comparison that cannot work, and this one raises at runtime.
-      add_error(
-        :unversioned_association_target,
-        "#{model_class.name} does not appear to have PaperTrail enabled",
-        path
-      )
-    end
-
-    #: (untyped, String) -> void
-    def inspect_through_model(reflection, path)
-      model_class = reflection.through_reflection.klass
-      return if model_versioned?(model_class)
-
-      add_warning(
-        :unversioned_through_model,
-        "#{model_class.name} does not appear to have PaperTrail enabled",
-        path
-      )
-    end
-
-    #: (untyped) -> bool
-    def model_versioned?(model_class)
-      Support.versioned?(model_class)
-    end
-
     #: (untyped) -> bool
     def synchronized_timestamp_disabled?(model_class)
       options = model_class.paper_trail_options
@@ -227,30 +236,6 @@ module PaperTrailDiff
       false
     end
 
-    #: () -> bool
-    def association_tracking_available?
-      paper_trail = Object.const_get(:PaperTrail) #: untyped
-      config = paper_trail.config #: untyped
-      !!(defined?(::PaperTrailAssociationTracking) &&
-        config.respond_to?(:track_associations?) && config.track_associations?)
-    end
-
-    #: (untyped) -> Array[String]
-    def version_identity(version)
-      [version.item_type.to_s, version.item_id.to_s]
-    end
-
-    #: (untyped) -> String
-    def version_type(version)
-      subtype = version.item_subtype if version.respond_to?(:item_subtype)
-      subtype.to_s.empty? ? version.item_type.to_s : subtype.to_s
-    end
-
-    #: () -> String
-    def tracking_unavailable_message
-      'association tracking must be loaded and enabled to diagnose associations'
-    end
-
     #: (Symbol, String, ?String?, ?untyped) -> void
     def add_error(code, message, path = nil, version_id = nil)
       add_issue(:error, code, message, path, version_id)

data/lib/paper_trail_diff/endpoint.rb

@@ -47,6 +47,29 @@ module PaperTrailDiff
       validate_record!(endpoint)
     end
 
+    # The record a method reads the history of: a record, saved or destroyed,
+    # of a model PaperTrail versions.
+    #: (untyped) -> void
+    def validate_root!(record)
+      unless record?(record)
+        raise InvalidEndpointError, "expected a record, got #{described(record)}"
+      end
+      return if Support.versioned?(record.class)
+
+      raise InvalidEndpointError,
+            "#{record.class.name} is not versioned, so it has no history: add has_paper_trail to it"
+    end
+
+    # A relation is named rather than inspected, which would load it.
+    #: (untyped) -> String
+    def described(value)
+      return 'nil' if value.nil?
+      return "the class #{value.name}" if value.is_a?(Module)
+
+      value.class.name.to_s
+    end
+    private_class_method :described
+
     #: (untyped) -> bool
     def version?(endpoint)
       endpoint.respond_to?(:reify) &&
@@ -82,11 +105,11 @@ module PaperTrailDiff
       raise InvalidEndpointError, "cannot resolve endpoint model: #{model_type}", cause: e
     end
 
-    # The record's own PaperTrail versions, under whatever name the model gave
-    # the association.
+    # Every PaperTrail version of the record, whatever scope its versions
+    # association has.
     #: (untyped) -> untyped
     def versions(record)
-      record.public_send(record.class.versions_association_name)
+      VersionQuery.for_items(record.class, record.id)
     rescue NoMethodError => e
       message = 'record does not expose a PaperTrail version history'
       raise InvalidTimelineRangeError, message, cause: e

data/lib/paper_trail_diff/errors.rb

@@ -42,7 +42,9 @@ module PaperTrailDiff
   # Historical candidate loading exceeded its explicitly bounded work budget.
   class FilterLimitExceededError < Error; end
 
-  # A batch selected a known expensive association without explicitly opting in.
+  # No longer raised: `allow_approximate: true` alone accepts the paths it
+  # refused. Kept until `allow_expensive:` is removed, so code that rescues it
+  # still loads.
   class UnsupportedBatchPathError < ConfigurationError; end
 
   # Raised when a requested ActiveRecord association does not exist.

data/lib/paper_trail_diff/fallback_paths.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+# rbs_inline: enabled
+
+module PaperTrailDiff
+  # Whether a request may read a path with PT-AT's reifier rather than from
+  # loaded history. PT-AT places association changes by timestamp alone, so
+  # only such a path can miss a change between two versions that share one;
+  # loaded history orders those versions by id.
+  module FallbackPaths
+    # A path history reads only approximately counts when it is allowed: a
+    # request that does not allow it is refused before anything is read.
+    #: (AssociationTraversal, untyped, approximate: bool) -> bool
+    def self.any?(traversal, model, approximate:)
+      return true if approximate && !ApproximatePaths.call(traversal, model).empty?
+
+      traversal.selected_reflections(model).any? { |_path, reflection| per_record?(reflection) }
+    end
+
+    # Loaded history cannot index a composite foreign key, and a polymorphic
+    # belongs_to's target, with its default scope, is known only per record.
+    #: (untyped) -> bool
+    def self.per_record?(reflection)
+      composite_key?(reflection) || (reflection.belongs_to? && reflection.polymorphic?)
+    end
+    private_class_method :per_record?
+
+    #: (untyped) -> bool
+    def self.composite_key?(reflection)
+      return true if reflection.foreign_key.is_a?(Array)
+      return false unless reflection.through_reflection?
+
+      [reflection.through_reflection, reflection.source_reflection].any? do |part|
+        composite_key?(part)
+      end
+    end
+    private_class_method :composite_key?
+  end
+end

data/lib/paper_trail_diff/historical_association_reifier.rb

@@ -6,10 +6,8 @@ module PaperTrailDiff
   class HistoricalAssociationReifier
     #: (untyped, ?habtm_version: untyped) -> void
     def initialize(version, habtm_version: version)
-      @transaction_id = version.transaction_id if version.respond_to?(:transaction_id)
-      if habtm_version.respond_to?(:transaction_id)
-        @habtm_transaction_id = habtm_version.transaction_id
-      end
+      @transaction_id = VersionBoundary.transaction_id(version)
+      @habtm_transaction_id = VersionBoundary.transaction_id(habtm_version)
       @version_at = version.created_at
       # Keyed on record identity rather than `object_id`, which Ruby may reuse
       # once an earlier record in the same pass has been collected.

data/lib/paper_trail_diff/historical_filter.rb

@@ -24,8 +24,10 @@ module PaperTrailDiff
       @state_loader = PreparedVersionStateLoader.new
     end
 
-    #: (Array[String]) -> Array[String]
-    def call(candidates)
+    # More matches than the limit raise, unless the caller does not count
+    # them: candidates it only lists, such as deleted roots.
+    #: (Array[String], ?counted: bool) -> Array[String]
+    def call(candidates, counted: true)
       matched = [] #: Array[String]
       candidates.each_slice(CANDIDATE_BATCH) do |slice|
         versions = candidate_versions(slice)
@@ -34,7 +36,7 @@ module PaperTrailDiff
           next unless held?(versions.fetch(id, []), closing[id])
 
           matched << id
-          reject_root_limit! if matched.length > @limit
+          reject_root_limit! if counted && matched.length > @limit
         end
       end
       matched
@@ -64,7 +66,17 @@ module PaperTrailDiff
               "unknown historical attributes: #{unknown.join(', ')}"
       end
 
-      Support.immutable_copy(attributes)
+      attributes.to_h { |name, value| [name, cast(name, value)] }
+    end
+
+    # Expected and recorded values compare as the attribute casts them, as
+    # `where` reads its values: an enum's symbol names its stored value, and a
+    # `json` or `jsonb` version column, which PaperTrail does not cast, holds
+    # dates and times as strings. Casting also copies a mutable value, so the
+    # filter keeps its own.
+    #: (String, untyped) -> untyped
+    def cast(name, value)
+      @model.type_for_attribute(name).cast(value)
     end
 
     #: (untyped) -> Integer
@@ -76,8 +88,7 @@ module PaperTrailDiff
 
     #: (Array[String]) -> Hash[String, Array[untyped]]
     def candidate_versions(ids)
-      relation = @model.paper_trail.version_class.where(item_type: @model.base_class.name,
-                                                        item_id: ids)
+      relation = VersionQuery.for_items(@model, ids)
       range = @time_range
       relation = range.scope(relation) if range
       # One past the remaining budget is enough to know it was exceeded.
@@ -107,9 +118,7 @@ module PaperTrailDiff
       range = @time_range
       return {} unless range
 
-      relation = @model.paper_trail.version_class.where(item_type: @model.base_class.name,
-                                                        item_id: ids)
-      trailing = range.first_trailing_versions(relation)
+      trailing = range.first_trailing_versions(VersionQuery.for_items(@model, ids))
       account_versions!(trailing.length)
       trailing
     end
@@ -162,7 +171,7 @@ module PaperTrailDiff
                 "historical_filter: #{name} was not recorded in version #{version.id}"
         end
 
-        state.attributes.fetch(name) == expected
+        cast(name, state.attributes.fetch(name)) == expected
       end
     end
 

data/lib/paper_trail_diff/historical_snapshot_store.rb

@@ -2,7 +2,10 @@
 # rbs_inline: enabled
 
 module PaperTrailDiff
-  # Reconstructs and caches immutable historical snapshots for one adapter configuration.
+  # Reconstructs and caches immutable historical snapshots for one adapter
+  # configuration. It keeps the histories batches prepare, by root version;
+  # one prepared for a single root goes back to the caller, who passes it to
+  # every read for that root.
   class HistoricalSnapshotStore
     #: (tree: AssociationTree, traversal: AssociationTraversal, normalizer: SnapshotNormalizer, preparer: untyped) -> void
     def initialize(tree:, traversal:, normalizer:, preparer:)
@@ -13,11 +16,11 @@ module PaperTrailDiff
       @prepared_snapshotter = PreparedSnapshotBuilder.new(traversal)
       @live_graph_collector = LiveGraphCollector.new(tree: tree, traversal: traversal)
       @snapshots = {} #: Hash[Array[untyped], RecordSnapshot?]
-      @prepared_history = nil #: PreparedHistory?
       @prepared_histories = {} #: Hash[Array[untyped], PreparedHistory]
+      @live_roots = {} #: Hash[identity, untyped]
     end
 
-    #: (untyped, Array[untyped], ?start_at: untyped, ?end_at: untyped) -> void
+    #: (untyped, Array[untyped], ?start_at: untyped, ?end_at: untyped) -> PreparedHistory?
     def prepare(
       record,
       root_versions,
@@ -28,12 +31,9 @@ module PaperTrailDiff
 
       # A batched preparation already covers these roots.
       batched = root_versions.find { |version| @prepared_histories.key?(context_key(version)) }
-      if batched
-        @prepared_history = @prepared_histories.fetch(context_key(batched))
-        return
-      end
+      return @prepared_histories.fetch(context_key(batched)) if batched
 
-      @prepared_history = PreparedHistoryLoader.new(
+      PreparedHistoryLoader.new(
         record, root_ids: [record.id], root_versions: root_versions, start_at: start_at,
                 end_at: end_at, tree: @tree, traversal: @traversal, live_records: []
       ).call
@@ -46,6 +46,9 @@ module PaperTrailDiff
       Instrumentation.instrument('prepare_history', batch_payload(records, root_versions)) do
         register_batch(records, root_versions, start_at: start_at, end_at: end_at)
       end
+      # A batch passes its roots as it just loaded them, so the current state
+      # they close on is read from them rather than once more per root.
+      records.each { |record| @live_roots[Endpoint.identity(record)] = record }
     end
 
     # Missing roots, and roots compared only between versions, have no live
@@ -58,50 +61,41 @@ module PaperTrailDiff
       register_batch(records, root_versions, live_records: [], start_at: start_at, end_at: end_at)
     end
 
-    #: (untyped, untyped) -> RecordSnapshot?
-    def call(root_endpoint, context_endpoint)
+    # `history` is the one `prepare` returned for this root, if any.
+    #: (untyped, untyped, ?history: PreparedHistory?) -> RecordSnapshot?
+    def call(root_endpoint, context_endpoint, history: nil)
       key = snapshot_key(root_endpoint, context_endpoint)
       return @snapshots[key] if @snapshots.key?(key)
 
-      @snapshots[key] = uncached(root_endpoint, context_endpoint)
+      @snapshots[key] = uncached(root_endpoint, context_endpoint, history: history)
     end
 
-    #: (untyped, untyped) -> RecordSnapshot?
-    def uncached(root_endpoint, context_endpoint)
-      custom(
-        root_endpoint,
-        context_endpoint,
-        tree: @tree,
-        normalizer: @normalizer
-      )
+    #: (untyped, untyped, ?history: PreparedHistory?) -> RecordSnapshot?
+    def uncached(root_endpoint, context_endpoint, history: nil)
+      custom(root_endpoint, context_endpoint, tree: @tree, normalizer: @normalizer,
+                                              history: history)
     end
 
-    #: (untyped, untyped, tree: AssociationTree, normalizer: SnapshotNormalizer) -> RecordSnapshot?
-    def custom(root_endpoint, context_endpoint, tree:, normalizer:)
+    #: (untyped, untyped, tree: AssociationTree, normalizer: SnapshotNormalizer, ?history: PreparedHistory?) -> RecordSnapshot?
+    def custom(root_endpoint, context_endpoint, tree:, normalizer:, history: nil)
+      history = history_for(context_endpoint, history)
       if Endpoint.version?(root_endpoint)
         return snapshot_from_version(
-          root_endpoint,
-          context_endpoint,
-          tree: tree,
-          normalizer: normalizer
+          root_endpoint, context_endpoint, tree: tree, normalizer: normalizer, history: history
         )
       end
 
-      snapshot_from_live_root(
-        root_endpoint,
-        context_endpoint,
-        tree: tree,
-        normalizer: normalizer
-      )
+      snapshot_from_live_root(root_endpoint, context_endpoint, tree: tree, normalizer: normalizer,
+                                                               history: history)
     end
 
-    #: (untyped, habtm_version: untyped) -> untyped
-    def association_reader(context_version, habtm_version:)
+    #: (untyped, habtm_version: untyped, ?history: PreparedHistory?) -> untyped
+    def association_reader(context_version, habtm_version:, history: nil)
       fallback = HistoricalAssociationReifier.new(
         context_version,
         habtm_version: habtm_version
       )
-      history = @prepared_histories[context_key(context_version)] || @prepared_history
+      history = history_for(context_version, history)
       return fallback unless history
 
       PreparedAssociationReifier.new(
@@ -112,25 +106,6 @@ module PaperTrailDiff
       )
     end
 
-    #: () -> PreparedActivityIndex?
-    def activity_index
-      @prepared_history&.activity_index
-    end
-
-    #: (untyped) -> [Hash[untyped, untyped], Hash[untyped, untyped]]?
-    def record_transition(version)
-      history = @prepared_history
-      return unless history
-
-      history.record_transition(Endpoint.model_class(version), version.item_id, version)
-    end
-
-    #: (untyped, ?direct: bool) -> [bool, untyped]
-    def record_after(version, direct: false)
-      @prepared_history&.record_after(Endpoint.model_class(version), version.item_id, version,
-                                      direct: direct) || [false, nil]
-    end
-
     private
 
     # @rbs @tree: AssociationTree
@@ -140,8 +115,14 @@ module PaperTrailDiff
     # @rbs @prepared_snapshotter: PreparedSnapshotBuilder
     # @rbs @live_graph_collector: LiveGraphCollector
     # @rbs @snapshots: Hash[Array[untyped], RecordSnapshot?]
-    # @rbs @prepared_history: PreparedHistory?
     # @rbs @prepared_histories: Hash[Array[untyped], PreparedHistory]
+    # @rbs @live_roots: Hash[identity, untyped]
+
+    # A batch's history for the version wins over the one a caller passes.
+    #: (untyped, PreparedHistory?) -> PreparedHistory?
+    def history_for(context_endpoint, history)
+      @prepared_histories[context_key(context_endpoint)] || history
+    end
 
     #: (untyped) -> Array[untyped]
     def context_key(endpoint)
@@ -170,34 +151,43 @@ module PaperTrailDiff
       root_versions.each { |version| @prepared_histories[context_key(version)] = history }
     end
 
-    #: (untyped, untyped, tree: AssociationTree, normalizer: SnapshotNormalizer) -> RecordSnapshot?
-    def snapshot_from_version(root_version, context_version, tree:, normalizer:)
+    #: (untyped, untyped, tree: AssociationTree, normalizer: SnapshotNormalizer, history: PreparedHistory?) -> RecordSnapshot?
+    def snapshot_from_version(root_version, context_version, tree:, normalizer:, history:)
       model_class = RecordedClass.for(root_version)
       @preparer.call(model_class, historical: true)
       @traversal.ensure_habtm_history!(model_class, root_version)
       handled, snapshot = @prepared_snapshotter.call(
-        root_version, context_version, tree: tree, normalizer: normalizer,
-                                       history: @prepared_histories[context_key(context_version)] ||
-                                         @prepared_history
+        root_version, context_version, tree: tree, normalizer: normalizer, history: history
       )
       return snapshot if handled
 
       record = root_version.reify(dup: true)
       normalize(record, context_version, tree: tree, normalizer: normalizer,
-                                         habtm_version: root_version)
+                                         habtm_version: root_version, history: history)
     end
 
-    #: (untyped, untyped, tree: AssociationTree, normalizer: SnapshotNormalizer) -> RecordSnapshot?
-    def snapshot_from_live_root(root_record, context_version, tree:, normalizer:)
-      record = Endpoint.reload_record(root_record)
+    #: (untyped, untyped, tree: AssociationTree, normalizer: SnapshotNormalizer, history: PreparedHistory?) -> RecordSnapshot?
+    def snapshot_from_live_root(root_record, context_version, tree:, normalizer:, history:)
+      record = live_root(root_record)
       @preparer.call(record.class, historical: true)
       normalize(record, context_version, tree: tree, normalizer: normalizer,
-                                         habtm_version: context_version)
+                                         habtm_version: context_version, history: history)
+    end
+
+    # Rebuilding a version's associations writes them onto the record, so each
+    # snapshot gets its own copy of a batch's loaded row, built from the row's
+    # stored values without a query.
+    #: (untyped) -> untyped
+    def live_root(root_record)
+      loaded = @live_roots[Endpoint.identity(root_record)]
+      return Endpoint.reload_record(root_record) unless loaded
+
+      loaded.class.instantiate(loaded.attributes_before_type_cast)
     end
 
-    #: (untyped, untyped, tree: AssociationTree, normalizer: SnapshotNormalizer, habtm_version: untyped) -> RecordSnapshot?
-    def normalize(record, context_version, tree:, normalizer:, habtm_version:)
-      reifier = association_reader(context_version, habtm_version: habtm_version)
+    #: (untyped, untyped, tree: AssociationTree, normalizer: SnapshotNormalizer, habtm_version: untyped, history: PreparedHistory?) -> RecordSnapshot?
+    def normalize(record, context_version, tree:, normalizer:, habtm_version:, history:) # rubocop:disable Metrics/ParameterLists
+      reifier = association_reader(context_version, habtm_version: habtm_version, history: history)
       reflections = [] #: Array[untyped]
       reflections = @traversal.reflections_for(record.class, tree, path: '') if record
       reifier.reify(record, reflections) if record && !reflections.empty?