paper_trail_diff 0.13.1 → 0.14.0

data/lib/paper_trail_diff/association_traversal.rb

@@ -5,16 +5,147 @@ module PaperTrailDiff
   # Resolves and validates ActiveRecord reflections for a bounded association tree.
   class AssociationTraversal
     # The class a `belongs_to` points at for this record, reading a polymorphic
-    # type column when there is one. Nil when that type names no class.
+    # type column when there is one. Nil when the record points at nothing.
     #: (untyped, untyped) -> untyped
     def self.belongs_to_target(reflection, record)
       return reflection.klass unless reflection.polymorphic?
 
-      Object.const_get(record.public_send(reflection.foreign_type).to_s)
+      type = record.public_send(reflection.foreign_type).to_s
+      polymorphic_target(reflection, record, type) unless type.empty?
+    end
+
+    # A through with `source_type:` reaches only the join records whose type
+    # column names that class, as Active Record's `where(type => source_type)`.
+    # A through's `foreign_type` is its polymorphic source's.
+    #: (untyped, untyped) -> bool
+    def self.source_type_join?(reflection, join)
+      reflection.options[:source_type].nil? ||
+        source_type_member?(reflection, join.public_send(reflection.foreign_type))
+    end
+
+    # The same check for a join row read as stored attributes, given the
+    # value of its type column.
+    #: (untyped, untyped) -> bool
+    def self.source_type_member?(reflection, type)
+      source_type = reflection.options[:source_type]
+      source_type.nil? || type == source_type.to_s
+    end
+
+    # The class a stored type names, or nil when it names none.
+    # This class defines no constants of its own, so the one mutation left,
+    # `const_get` on it rather than on Object, finds the same class.
+    # mutant:disable
+    #: (String) -> untyped
+    def self.named_class(type)
+      Object.const_get(type)
     rescue NameError
       nil
     end
 
+    # A type left by a renamed or removed model names no class. Active Record
+    # and PT-AT raise a bare NameError for it, which does not say where it is.
+    #: (untyped, untyped, String) -> untyped
+    def self.polymorphic_target(reflection, record, type)
+      model_class = named_class(type)
+      return model_class if model_class
+
+      raise IncompleteAssociationHistoryError,
+            "association #{record.class.name}##{reflection.name} cannot be read: " \
+            "#{record.class.name} #{record.id} has #{reflection.foreign_type} #{type}, which " \
+            'names no class. If the model was renamed, replace the old name in that column ' \
+            'and in the versions that recorded it.'
+    end
+    private_class_method :polymorphic_target
+
+    # Why a request cannot name this association of the model, or nil when it
+    # can; `root` says whether the model is the record the request compares.
+    # Discovery lists only the associations this accepts, so every path it
+    # lists can be requested. A has_many :through Active Record cannot follow
+    # raises Active Record's own error.
+    #: (untyped, untyped, root: bool) -> String?
+    def self.unsupported_reason(model_class, reflection, root:)
+      return 'PaperTrail versions' if paper_trail_versions?(model_class, reflection)
+      return reflection.macro.to_s unless SUPPORTED_ASSOCIATION_MACROS.include?(reflection.macro)
+      return habtm_reason(reflection, root) if reflection.macro == :has_and_belongs_to_many
+
+      habtm = habtm_in_chain(reflection)
+      return unless habtm
+
+      "it goes through #{habtm.active_record.name}##{habtm.name}, a has_and_belongs_to_many, " \
+        'whose hidden join model has no history to compare'
+    end
+
+    # PT-AT records a HABTM's membership only when its owner saves a version,
+    # in rows keyed by transaction and association name, not by owner. A root
+    # checkpoint so holds the root's membership and no one else's: another
+    # record's HABTM would read the root's rows, or none.
+    #: (untyped) -> String
+    def self.habtm_below_root(reflection)
+      "#{reflection.active_record.name}##{reflection.name} is a has_and_belongs_to_many " \
+        'below the root, and a root checkpoint records HABTM membership for the root alone'
+    end
+    private_class_method :habtm_below_root
+
+    # PT-AT records a HABTM's membership by loading the association, scope and
+    # target default scope applied, so a target outside the scope when the
+    # owner saved is never recorded. One that enters it before the next save
+    # is a member then that history cannot hold.
+    #: (untyped, bool) -> String?
+    def self.habtm_reason(reflection, root)
+      return habtm_below_root(reflection) unless root
+      return unless ScopeCondition.scoped?(reflection)
+
+      "#{reflection.active_record.name}##{reflection.name} is a scoped " \
+        'has_and_belongs_to_many, and PaperTrail records only the members its scope ' \
+        'admitted when the owner saved, so membership between saves cannot be rebuilt; ' \
+        'replace it with a has_many :through a versioned join model'
+    end
+    private_class_method :habtm_reason
+
+    #: (untyped, untyped) -> bool
+    def self.paper_trail_versions?(model_class, reflection)
+      model_class.respond_to?(:versions_association_name) &&
+        reflection.name.to_s == model_class.versions_association_name.to_s
+    end
+    private_class_method :paper_trail_versions?
+
+    # Active Record joins a HABTM through a hidden model of its own, which has
+    # no versions and no reader that PT-AT or prepared history can follow, so a
+    # through that crosses one would fail partway through reconstruction.
+    #
+    # The through and source reflections of a through are the hidden ones, a
+    # has_many in place of each HABTM, so only the public reflection of the
+    # same name shows the HABTM. Active Record's own check, which it runs on
+    # first use anyway, explains a through it cannot follow before the chain
+    # below it is read.
+    #: (untyped) -> untyped
+    def self.habtm_in_chain(reflection)
+      return unless reflection.through_reflection?
+
+      reflection.check_validity!
+      parts = [reflection.through_reflection, reflection.source_reflection]
+      parts.filter_map do |part|
+        link = part.active_record.reflect_on_association(part.name)
+        link.macro == :has_and_belongs_to_many ? link : habtm_in_chain(link)
+      end.first
+    end
+    private_class_method :habtm_in_chain
+
+    attr_reader :tree #: AssociationTree
+
+    # Whether a row belongs to an association whose class is `model_class`.
+    # Children are found by key across the whole table, so an association to an
+    # STI subclass has to leave out its siblings, as Active Record's type
+    # condition does for the live association: the row's type must name the
+    # class or one of its descendants. A base class takes every row.
+    #: (untyped, Hash[String, untyped]) -> bool
+    def self.sti_member?(model_class, attributes)
+      return true if model_class.descends_from_active_record?
+
+      names = [model_class, *model_class.descendants].map(&:sti_name)
+      names.include?(attributes[model_class.inheritance_column])
+    end
+
     #: (AssociationTree) -> void
     def initialize(tree)
       @tree = tree
@@ -60,24 +191,23 @@ module PaperTrailDiff
       raise UnsupportedLiveActivityError, message
     end
 
+    # A model and a tree resolve to the same reflections wherever they are
+    # read: a tree is only ever walked from one place, the root tree at the
+    # root and a subtree below it. Beyond that, the path only names a failure,
+    # and a failure is not cached.
     #: (untyped, AssociationTree, path: String) -> Array[untyped]
     def reflections_for(model_class, tree, path:)
-      key = [model_class.name.to_s, path, tree.object_id]
-      @reflection_cache[key] ||= requested_reflections(model_class, tree, path)
+      @reflection_cache[[model_class, tree]] ||= requested_reflections(model_class, tree, path)
     end
 
+    # Active Record names keys as strings. A polymorphic child also points back
+    # with its type column; `type` is nil for any other.
     #: (untyped) -> Array[String]
     def incoming_relationship_columns(reflection)
-      direct = %i[has_one has_many].include?(reflection.macro) && !reflection.options[:through]
+      direct = %i[has_one has_many].include?(reflection.macro) && !reflection.through_reflection?
       return [] unless direct
 
-      foreign_keys = Array(reflection.foreign_key)
-      # @type var foreign_keys: Array[untyped]
-      columns = foreign_keys.map do |column| # rubocop:disable Style/SymbolProc
-        column.to_s
-      end
-      columns << reflection.type.to_s if reflection.options[:as]
-      columns
+      Array(reflection.foreign_key) + Array(reflection.type)
     end
 
     private
@@ -88,11 +218,12 @@ module PaperTrailDiff
     #: (untyped, AssociationTree, path: String) -> Array[Array[untyped]]
     def collect_reflections(model_class, tree, path:)
       reflections_for(model_class, tree, path: path).flat_map do |reflection|
-        child_path = join_path(path, reflection.name.to_s)
+        child_path = Support.association_path(path, reflection.name)
         result = [[child_path, reflection]]
-        subtree = tree.child(reflection.name)
-        next result unless subtree && !subtree.empty? && !reflection.polymorphic?
+        next result if reflection.polymorphic?
 
+        # A leaf's subtree is empty and adds nothing.
+        subtree = tree.child(reflection.name) #: AssociationTree
         result + collect_reflections(reflection.klass, subtree, path: child_path)
       end
     end
@@ -100,55 +231,48 @@ module PaperTrailDiff
     #: (untyped, AssociationTree, path: String) -> void
     def validate_tree!(model_class, tree, path:)
       reflections_for(model_class, tree, path: path).each do |reflection|
-        subtree = tree.child(reflection.name)
-        next unless subtree && !subtree.empty? && !reflection.polymorphic?
+        subtree = tree.child(reflection.name) #: AssociationTree
+        next if subtree.empty?
 
-        child_path = join_path(path, reflection.name.to_s)
+        child_path = Support.association_path(path, reflection.name)
+        reject_polymorphic_descent!(reflection, subtree, child_path)
         validate_tree!(reflection.klass, subtree, path: child_path)
       end
     end
 
+    # A polymorphic target's class differs from record to record, so the
+    # associations a path names below it may not exist on every target.
+    #: (untyped, AssociationTree, String) -> void
+    def reject_polymorphic_descent!(reflection, subtree, path)
+      return unless reflection.polymorphic?
+
+      raise UnsupportedAssociationError,
+            "unsupported association #{subtree.paths(prefix: path).first}: " \
+            "#{path} is polymorphic, so a path cannot continue past it"
+    end
+
     #: (untyped, AssociationTree, String) -> Array[untyped]
     def requested_reflections(model_class, tree, path)
       tree.children.map do |name, _subtree|
-        resolve_reflection(model_class, name, join_path(path, name))
+        resolve_reflection(model_class, name, Support.association_path(path, name),
+                           root: path.empty?)
       end.freeze
     end
 
-    #: (untyped, String, String) -> untyped
-    def resolve_reflection(model_class, name, full_path)
-      reflection = model_class.reflect_on_association(name.to_sym)
+    #: (untyped, String, String, root: bool) -> untyped
+    def resolve_reflection(model_class, name, full_path, root:)
+      reflection = model_class.reflect_on_association(name)
       raise UnknownAssociationError, "unknown association: #{full_path}" unless reflection
 
-      if paper_trail_versions?(model_class, reflection)
-        message = "unsupported association #{full_path}: PaperTrail versions"
-        raise UnsupportedAssociationError, message
-      end
-      unless SUPPORTED_ASSOCIATION_MACROS.include?(reflection.macro)
-        raise UnsupportedAssociationError,
-              "unsupported association #{full_path}: #{reflection.macro}"
-      end
+      reason = self.class.unsupported_reason(model_class, reflection, root: root)
+      raise UnsupportedAssociationError, "unsupported association #{full_path}: #{reason}" if reason
 
       reflection
     end
 
-    #: (untyped, untyped) -> bool
-    def paper_trail_versions?(model_class, reflection)
-      model_class.respond_to?(:versions_association_name) &&
-        reflection.name.to_s == model_class.versions_association_name.to_s
-    end
-
     #: (untyped) -> bool
     def habtm_reflection?(reflection)
-      return true if reflection.macro == :has_and_belongs_to_many
-      return false unless reflection.options[:through]
-
-      habtm_reflection?(reflection.through_reflection)
-    end
-
-    #: (String, String) -> String
-    def join_path(parent, name)
-      parent.empty? ? name : "#{parent}.#{name}"
+      reflection.macro == :has_and_belongs_to_many
     end
   end
 end

data/lib/paper_trail_diff/batch_safety.rb

@@ -14,12 +14,12 @@ module PaperTrailDiff
       @allow_expensive = allow_expensive
     end
 
-    #: (untyped, ?historical: bool) -> void
-    def call(model, historical: true)
+    #: (untyped) -> void
+    def call(model)
       return if @allow_expensive
 
       @traversal.selected_reflections(model).each do |path, reflection|
-        check(reflection, path, historical)
+        check(reflection, path)
       end
     end
 
@@ -28,28 +28,36 @@ module PaperTrailDiff
     # @rbs @traversal: AssociationTraversal
     # @rbs @allow_expensive: bool
 
-    #: (untyped, String, bool) -> void
-    def check(reflection, path, historical)
-      reason = reason_for(reflection, historical)
+    # A has_many through reads its parts' conditions only, at any depth. A
+    # has_one through over a ranked part is refused whole, so its parts, too,
+    # are checked for conditions alone.
+    #: (untyped, String, ?ranked: bool) -> void
+    def check(reflection, path, ranked: true)
+      reason = reason_for(reflection, ranked)
       if reason
         raise UnsupportedBatchPathError,
               "association #{path} requires per-record reconstruction (#{reason}); " \
               'remove this path or explicitly pass allow_expensive: true'
       end
-      return unless reflection.options[:through]
+      return unless reflection.through_reflection?
 
-      check(reflection.through_reflection, path, historical)
-      check(reflection.source_reflection, path, historical)
+      [reflection.through_reflection, reflection.source_reflection].each do |part|
+        check(part, path, ranked: false)
+      end
     end
 
+    # A scope prepared history can read as conditions on stored attributes
+    # is batched like any other path. A polymorphic target's class, and so
+    # its scope, is known only per record.
     #: (untyped, bool) -> String?
-    def reason_for(reflection, historical)
-      return 'association scope' if reflection.scope
-      return 'default-scoped target' if !reflection.polymorphic? && reflection.klass.default_scopes?
-      return unless historical && reflection.options[:through]
-      return if reflection.source_reflection.belongs_to?
+    def reason_for(reflection, ranked)
+      return ('association scope' if reflection.scope) if reflection.polymorphic?
+      if ranked && ScopeCondition.ranked_through?(reflection)
+        return 'limit, offset or has_one order inside a has_one through'
+      end
+      return if ScopeCondition.build(reflection, ranked: ranked)
 
-      'through source is not belongs_to'
+      reflection.scope ? 'association scope' : 'default-scoped target'
     end
   end
 end

data/lib/paper_trail_diff/batched_root_versions.rb

@@ -6,9 +6,8 @@ module PaperTrailDiff
   # queries. Only the range forms that mean the same thing for every root are
   # supported: a shared wall-clock window, or each root's own whole history.
   class BatchedRootVersions
-    #: (Array[untyped], time_range: TimeRange?, ?version_scope: untyped, ?live_endpoints: Hash[Array[String], untyped]?, ?context_required: bool) -> void
-    def initialize(records, time_range:, version_scope: nil, live_endpoints: nil,
-                   context_required: false)
+    #: (Array[untyped], time_range: TimeRange?, version_scope: untyped, live_endpoints: Hash[Array[String], untyped]?, context_required: bool) -> void
+    def initialize(records, time_range:, version_scope:, live_endpoints:, context_required:)
       @records = records
       # An activity view needs a root to reconstruct from even in a window with
       # no root version, exactly as a single-record activity timeline does.
@@ -21,8 +20,6 @@ module PaperTrailDiff
     # Returns a plan per record identity.
     #: () -> Hash[Array[String], RootVersionPlan]
     def call
-      return {} if @records.empty?
-
       selected = {} #: Hash[Array[String], RootVersionPlan]
       @records.group_by(&:class).each do |model_class, records|
         select_model(model_class, records, selected)
@@ -40,10 +37,9 @@ module PaperTrailDiff
 
     #: (untyped, Array[untyped], Hash[Array[String], RootVersionPlan]) -> void
     def select_model(model_class, records, selected)
-      ids = records.map(&:id)
-      in_range, chosen, trailing = model_versions(model_class, ids)
+      in_range, chosen, trailing = model_versions(model_class, records)
       records.each do |record|
-        key = identity(model_class, record.id)
+        key = Endpoint.identity(record)
         selected[key] = versions_for(
           in_range.fetch(record.id.to_s, []), chosen, trailing[record.id.to_s],
           live_endpoint(key, record)
@@ -52,13 +48,13 @@ module PaperTrailDiff
     end
 
     #: (untyped, Array[untyped]) -> [Hash[String, Array[untyped]], Set[untyped]?, Hash[String, untyped]]
-    def model_versions(model_class, ids)
+    def model_versions(model_class, records)
       range = @time_range
       empty = {} #: Hash[String, untyped]
       [
-        grouped_versions(model_class, ids, range),
-        chosen_version_ids(model_class, ids, range),
-        range ? trailing_versions(model_class, ids, range) : empty
+        grouped_versions(model_class, records, range),
+        chosen_version_ids(model_class, records, range),
+        range ? trailing_versions(model_class, records, range) : empty
       ]
     end
 
@@ -89,48 +85,34 @@ module PaperTrailDiff
     # One extra query names the selected mutations without discarding the
     # unfiltered versions the successor lookup still needs.
     #: (untyped, Array[untyped], TimeRange?) -> Set[untyped]?
-    def chosen_version_ids(model_class, ids, range)
-      scope = @version_scope
-      return unless scope
-
-      # A narrowed relation is the expected return. Active Support also gives
-      # `pluck` to plain enumerables, so an array of versions works too.
-      filtered = scope.call(range_scope(model_class, ids, range))
-      Set.new(filtered.pluck(:id))
+    def chosen_version_ids(model_class, records, range)
+      VersionScopeFilter.new(@version_scope).chosen_ids(range_scope(model_class, records, range))
     end
 
     #: (untyped, Array[untyped], TimeRange?) -> Hash[String, Array[untyped]]
-    def grouped_versions(model_class, ids, range)
-      ordered(range_scope(model_class, ids, range)).group_by { |version| version.item_id.to_s }
+    def grouped_versions(model_class, records, range)
+      VersionQuery.chronological(range_scope(model_class, records, range))
+                  .group_by { |version| version.item_id.to_s }
     end
 
     #: (untyped, Array[untyped], TimeRange?) -> untyped
-    def range_scope(model_class, ids, range)
-      scope = base_scope(model_class, ids)
+    def range_scope(model_class, records, range)
+      scope = base_scope(model_class, records)
       range ? range.scope(scope) : scope
     end
 
     #: (untyped, Array[untyped], TimeRange) -> Hash[String, untyped]
-    def trailing_versions(model_class, ids, range)
-      range.first_trailing_versions(base_scope(model_class, ids))
+    def trailing_versions(model_class, records, range)
+      range.first_trailing_versions(base_scope(model_class, records))
     end
 
     #: (untyped, Array[untyped]) -> untyped
-    def base_scope(model_class, ids)
+    def base_scope(model_class, records)
+      # Active Record reads each record's id.
       model_class.paper_trail.version_class.where(
-        item_type: model_class.base_class.name.to_s,
-        item_id: ids
+        item_type: model_class.base_class.name,
+        item_id: records
       )
     end
-
-    #: (untyped) -> Array[untyped]
-    def ordered(relation)
-      VersionQuery.chronological(relation).to_a
-    end
-
-    #: (untyped, untyped) -> Array[String]
-    def identity(model_class, id)
-      [model_class.base_class.name.to_s, id.to_s]
-    end
   end
 end

data/lib/paper_trail_diff/comparison_batch.rb

@@ -4,12 +4,16 @@
 module PaperTrailDiff
   # Validates and executes independent comparisons with shared live endpoint loading.
   class ComparisonBatch
-    #: (Array[comparison_input], live_loader: untyped, preparer: untyped, history_preparer: untyped, historical_snapshotter: untyped, live_normalizer: untyped) -> void
+    # `history_preparer` prepares roots that have a live endpoint to collect a
+    # graph from; `version_history_preparer` prepares roots compared only
+    # between versions.
+    #: (Array[comparison_input], live_loader: untyped, preparer: untyped, history_preparer: untyped, version_history_preparer: untyped, historical_snapshotter: untyped, live_normalizer: untyped) -> void
     def initialize( # rubocop:disable Metrics/ParameterLists
       comparisons,
       live_loader:,
       preparer:,
       history_preparer:,
+      version_history_preparer:,
       historical_snapshotter:,
       live_normalizer:
     )
@@ -17,6 +21,7 @@ module PaperTrailDiff
       @live_loader = live_loader
       @preparer = preparer
       @history_preparer = history_preparer
+      @version_history_preparer = version_history_preparer
       @historical_snapshotter = historical_snapshotter
       @live_normalizer = live_normalizer
     end
@@ -35,6 +40,7 @@ module PaperTrailDiff
     # @rbs @live_loader: untyped
     # @rbs @preparer: untyped
     # @rbs @history_preparer: untyped
+    # @rbs @version_history_preparer: untyped
     # @rbs @historical_snapshotter: untyped
     # @rbs @live_normalizer: untyped
 
@@ -97,20 +103,41 @@ module PaperTrailDiff
 
     #: (Array[[untyped, untyped]], Hash[identity, untyped]) -> void
     def prepare_historical_batches!(pairs, live_records)
-      grouped = historical_versions(pairs, live_records).group_by do |version|
-        Endpoint.model_class(version)
+      loaded, unloaded = historical_versions(pairs).partition do |version|
+        live_records.key?(Endpoint.identity(version))
       end
-      grouped.each_value do |versions|
+      loaded.group_by { |version| RecordedClass.for(version) }.each_value do |versions|
         records = versions.map { |version| live_records.fetch(Endpoint.identity(version)) }.uniq
         @history_preparer.call(records, versions)
       end
+      prepare_version_roots!(unloaded)
+    end
+
+    # A root compared only between versions has no live endpoint, and its row
+    # may be gone. Without prepared history, PT-AT finds a has_many's children
+    # by the keys each version recorded after its change, so it misses a child
+    # that later moved to another owner. Such roots are prepared from identity
+    # alone, like deleted ones. Their history still reads the live rows it
+    # needs: a record's current row is its state after its last version.
+    #: (Array[untyped]) -> void
+    def prepare_version_roots!(versions)
+      versions.group_by { |version| RecordedClass.for(version) }.each do |model, group|
+        ids = group.map(&:item_id).uniq(&:to_s)
+        @version_history_preparer.call(ids.map { |id| historical_root(model, id) }, group)
+      end
     end
 
-    #: (Array[[untyped, untyped]], Hash[identity, untyped]) -> Array[untyped]
-    def historical_versions(pairs, live_records)
-      selected = pairs.flatten.select do |endpoint|
-        Endpoint.version?(endpoint) && live_records.key?(Endpoint.identity(endpoint))
-      end
+    # The record supplies identity and model metadata only.
+    #: (untyped, untyped) -> untyped
+    def historical_root(model, id)
+      record = model.new
+      record[model.primary_key] = id
+      record
+    end
+
+    #: (Array[[untyped, untyped]]) -> Array[untyped]
+    def historical_versions(pairs)
+      selected = pairs.flatten.select { |endpoint| Endpoint.version?(endpoint) }
       selected.uniq { |version| [version.class.name, version.id] }
     end
 
@@ -167,7 +194,7 @@ module PaperTrailDiff
       requirements = {} #: Hash[untyped, bool]
       pairs.flatten.each_with_object(requirements) do |endpoint, collected|
         historical = Endpoint.version?(endpoint)
-        model_class = historical ? Endpoint.model_class(endpoint) : endpoint.class
+        model_class = historical ? RecordedClass.for(endpoint) : endpoint.class
         collected[model_class] = collected.fetch(model_class, false) || historical
       end
     end

data/lib/paper_trail_diff/deleted_analysis_batch.rb

@@ -4,11 +4,15 @@
 module PaperTrailDiff
   # Analyzes missing roots together without pretending that they have live rows.
   class DeletedAnalysisBatch
-    #: (untyped, identities: Array[Array[String]], time_range: TimeRange?, analyzer: untyped, history_preparer: untyped, ?version_scope: untyped) -> void
+    # `context_required` reads a root that did not change in the window from
+    # the version after it, so its associations' activity can be reported.
+    #: (untyped, identities: Array[Array[String]], time_range: TimeRange?, analyzer: untyped, history_preparer: untyped, version_scope: untyped, context_required: bool) -> void
     def initialize( # rubocop:disable Metrics/ParameterLists
-      model, identities:, time_range:, analyzer:, history_preparer:, version_scope: nil
+      model, identities:, time_range:, analyzer:, history_preparer:, version_scope:,
+      context_required:
     )
       @model = model
+      @context_required = context_required
       @identities = identities
       @time_range = time_range
       @analyzer = analyzer
@@ -18,13 +22,9 @@ module PaperTrailDiff
 
     #: () -> Hash[Array[String], Analysis?]
     def call
-      empty = {} #: Hash[Array[String], Analysis?]
-      return empty.freeze if @identities.empty?
-
-      records = historical_roots
-      selected = BatchedRootVersions.new(
-        records, time_range: @time_range, version_scope: @version_scope
-      ).call
+      destroys = destroy_versions
+      records = historical_roots(destroys)
+      selected = plans(records, destroys)
       prepare(records, selected)
       analyses = records.to_h do |record|
         key = Endpoint.identity(record)
@@ -42,19 +42,39 @@ module PaperTrailDiff
     end
 
     # @rbs @model: untyped
+    # @rbs @context_required: bool
     # @rbs @identities: Array[Array[String]]
     # @rbs @time_range: TimeRange?
     # @rbs @analyzer: untyped
     # @rbs @history_preparer: untyped
     # @rbs @version_scope: untyped
 
+    # A root destroyed before the window had no state inside it to read, so
+    # only the others take the version after the window as context.
+    #: (Array[untyped], Array[untyped]) -> Hash[Array[String], RootVersionPlan]
+    def plans(records, destroys)
+      start = @time_range&.begin_time
+      early = destroys.select { |version| start && version.created_at < start }
+                      .map { |version| version.item_id.to_s }
+      before, during = records.partition { |record| early.include?(record.id.to_s) }
+      plans_for(during, @context_required).merge(plans_for(before, false))
+    end
+
+    #: (Array[untyped], bool) -> Hash[Array[String], RootVersionPlan]
+    def plans_for(records, context_required)
+      BatchedRootVersions.new(
+        records, time_range: @time_range, version_scope: @version_scope,
+                 live_endpoints: nil, context_required: context_required
+      ).call
+    end
+
     # These records supply identity and model metadata only. Every reported
     # value comes from the batched historical plan; no per-root reify or live
     # lookup is needed to get into the comparison engine.
-    #: () -> Array[untyped]
-    def historical_roots
+    #: (Array[untyped]) -> Array[untyped]
+    def historical_roots(destroys)
       loader = PreparedVersionStateLoader.new
-      destroy_versions.map do |version|
+      destroys.map do |version|
         model = loader.call(version)&.model_class || Endpoint.model_class(version)
         record = model.new
         record[model.primary_key] = version.item_id
@@ -67,10 +87,8 @@ module PaperTrailDiff
       destroys = @model.paper_trail.version_class.where(
         item_type: @model.base_class.name, item_id: @identities.map(&:last), event: 'destroy'
       )
-      versions = VersionQuery.chronological(destroys)
-      versions.group_by { |version| version.item_id.to_s }.values.map do |history|
-        Support.chronological_sort(history).last
-      end
+      # Oldest first, so each item keeps its latest destroy.
+      VersionQuery.chronological(destroys).index_by(&:item_id).values
     end
 
     #: (Array[untyped]) -> Hash[Symbol, untyped]