paper_trail_diff 0.11.0 → 0.13.0

data/lib/paper_trail_diff/prepared_history.rb

@@ -4,17 +4,21 @@
 module PaperTrailDiff
   # Batched record states and relationship candidates for one activity range.
   class PreparedHistory
+    attr_reader :activity_index #: PreparedActivityIndex?
+
     DIRECT_RESOLVERS = {
       belongs_to: :resolve_belongs_to,
       has_one: :resolve_children,
       has_many: :resolve_children,
-      has_and_belongs_to_many: :resolve_habtm
+      has_and_belongs_to_many: :habtm_records
     }.freeze
     private_constant :DIRECT_RESOLVERS
 
-    #: (PreparedRecordIndex) -> void
-    def initialize(records)
+    #: (PreparedRecordIndex, ?activity_index: PreparedActivityIndex?) -> void
+    def initialize(records, activity_index: nil)
       @records = records
+      @state_reader = PreparedStateAssociationReader.new(records, method(:edge))
+      @activity_index = activity_index
       @edges = {} #: Hash[Array[String], Hash[String, Hash[Symbol, untyped]]]
       @unsupported = {} #: Hash[Array[String], bool]
       @habtm = {} #: Hash[Array[String], Hash[String, Array[untyped]]]
@@ -24,7 +28,7 @@ module PaperTrailDiff
     def merge_edge(owner_class, reflection, groups)
       key = edge_key(owner_class, reflection)
       empty = {} #: Hash[String, Hash[Symbol, untyped]]
-      @edges[key] = merge_groups(@edges.fetch(key, empty), groups)
+      @edges[key] = Support.merge_record_groups(@edges.fetch(key, empty), groups)
     end
 
     #: (untyped, untyped) -> Hash[String, Hash[Symbol, untyped]]
@@ -48,6 +52,16 @@ module PaperTrailDiff
       @records.transition(model_class, id, version)
     end
 
+    #: (untyped, untyped, untyped, ?direct: bool) -> [bool, untyped]
+    def record_after(model_class, id, version, direct: false)
+      @records.record_after(model_class, id, version, direct: direct)
+    end
+
+    #: (PreparedRecordState, untyped, untyped) -> [bool, Array[PreparedRecordState]]
+    def snapshot_states(owner, reflection, boundary)
+      @state_reader.call(owner, reflection, boundary)
+    end
+
     #: (untyped, untyped, untyped, habtm_boundary: untyped) -> [bool, Array[untyped]]
     def resolve(record, reflection, boundary, habtm_boundary:)
       return [false, []] unless supported?(record.class, reflection)
@@ -63,6 +77,7 @@ module PaperTrailDiff
     private
 
     # @rbs @records: PreparedRecordIndex
+    # @rbs @state_reader: PreparedStateAssociationReader
     # @rbs @edges: Hash[Array[String], Hash[String, Hash[Symbol, untyped]]]
     # @rbs @unsupported: Hash[Array[String], bool]
     # @rbs @habtm: Hash[Array[String], Hash[String, Array[untyped]]]
@@ -70,12 +85,7 @@ module PaperTrailDiff
     #: (untyped, untyped) -> bool
     def supported?(owner_class, reflection)
       !@unsupported[edge_key(owner_class, reflection)] &&
-        reflection.scope.nil? && !default_scoped?(reflection.klass)
-    end
-
-    #: (untyped) -> bool
-    def default_scoped?(model_class)
-      model_class.default_scopes?
+        reflection.scope.nil? && !reflection.klass.default_scopes?
     end
 
     #: (untyped, untyped, untyped, untyped) -> Array[untyped]?
@@ -94,11 +104,6 @@ module PaperTrailDiff
       child_records(record, reflection, boundary)
     end
 
-    #: (untyped, untyped, untyped, untyped) -> Array[untyped]?
-    def resolve_habtm(record, reflection, boundary, habtm_boundary)
-      habtm_records(record, reflection, boundary, habtm_boundary)
-    end
-
     #: (untyped, untyped, untyped) -> Array[untyped]?
     def belongs_to_records(record, reflection, boundary)
       foreign_key = scalar_foreign_key(reflection)
@@ -107,7 +112,7 @@ module PaperTrailDiff
       id = record.public_send(foreign_key)
       return [] if id.nil?
 
-      model_class = belongs_to_class(record, reflection)
+      model_class = AssociationTraversal.belongs_to_target(reflection, record)
       return unless model_class && @records.loaded?(model_class, id)
 
       Array(@records.record_before(model_class, id, boundary)).compact
@@ -189,15 +194,6 @@ module PaperTrailDiff
       key.to_s unless key.is_a?(Array)
     end
 
-    #: (untyped, untyped) -> untyped
-    def belongs_to_class(record, reflection)
-      return reflection.klass unless reflection.polymorphic?
-
-      Object.const_get(record.public_send(reflection.foreign_type).to_s)
-    rescue NameError
-      nil
-    end
-
     #: (untyped, untyped) -> Array[String]
     def owner_types(reflection, owner)
       types = [owner.class.name, owner.class.base_class.name, reflection.active_record.name]
@@ -218,10 +214,5 @@ module PaperTrailDiff
     def edge_key(owner_class, reflection)
       [owner_class.base_class.name.to_s, reflection.name.to_s]
     end
-
-    #: (Hash[String, Hash[Symbol, untyped]], Hash[String, Hash[Symbol, untyped]]) -> Hash[String, Hash[Symbol, untyped]]
-    def merge_groups(existing, incoming)
-      Support.merge_record_groups(existing, incoming)
-    end
   end
 end

data/lib/paper_trail_diff/prepared_history_loader.rb

@@ -17,16 +17,21 @@ module PaperTrailDiff
     )
       @record = record
       @root_ids = root_ids
+      @root_versions = root_versions
       @tree = tree
       @traversal = traversal
       @records = PreparedRecordIndex.new(start_at, end_at: end_at, live_records: live_records)
-      @history = PreparedHistory.new(@records)
+      activity = PreparedActivityIndex.new(
+        @records, root_versions, start_at: start_at, end_at: end_at || root_versions.last.created_at
+      )
+      @history = PreparedHistory.new(@records, activity_index: activity)
       @edges = PreparedEdgeLoader.new(@records, root_versions, start_at: start_at)
       @prepared = {} #: Hash[Array[String], Array[String]]
     end
 
     #: () -> PreparedHistory
     def call
+      @records.seed(@record.class, @root_ids, @root_versions)
       load_node(@record.class, @root_ids, @tree, path: '')
       @history
     end
@@ -35,6 +40,7 @@ module PaperTrailDiff
 
     # @rbs @record: untyped
     # @rbs @root_ids: Array[untyped]
+    # @rbs @root_versions: Array[untyped]
     # @rbs @tree: AssociationTree
     # @rbs @traversal: AssociationTraversal
     # @rbs @records: PreparedRecordIndex
@@ -44,6 +50,7 @@ module PaperTrailDiff
 
     #: (untyped, Array[untyped], AssociationTree, path: String) -> void
     def load_node(model_class, ids, tree, path:)
+      @history.activity_index&.register(model_class, ids)
       @traversal.reflections_for(model_class, tree, path: path).each do |reflection|
         subtree = tree.child(reflection.name)
         next unless subtree
@@ -119,7 +126,12 @@ module PaperTrailDiff
 
     #: (Hash[String, Hash[Symbol, untyped]]) -> void
     def load_groups(groups)
-      groups.each_value { |group| load_records(group.fetch(:model), group.fetch(:ids)) }
+      groups.each_value do |group|
+        model = group.fetch(:model)
+        ids = group.fetch(:ids)
+        @history.activity_index&.register(model, ids)
+        load_records(model, ids)
+      end
     end
 
     #: (untyped, Array[untyped]) -> void

data/lib/paper_trail_diff/prepared_record_index.rb

@@ -10,7 +10,7 @@ module PaperTrailDiff
     #: (untyped) -> void
     def initialize(record)
       @model_class = record.class
-      @attributes = Support.immutable_copy(record.attributes)
+      @attributes = stored_attributes(record.class, record.attributes)
       freeze
     end
 
@@ -36,9 +36,18 @@ module PaperTrailDiff
     #: (untyped, Hash[untyped, untyped]) -> void
     def initialize_attributes(model_class, attributes)
       @model_class = model_class
-      @attributes = Support.immutable_copy(attributes)
+      @attributes = stored_attributes(model_class, attributes)
       freeze
     end
+
+    # A live fallback and a version decoded from history must agree on what
+    # the stored history could represent, or the gap between them reads as a
+    # change.
+    #: (untyped, Hash[untyped, untyped]) -> Hash[untyped, untyped]
+    def stored_attributes(model_class, attributes)
+      digits = StoredTimePrecision.digits(model_class)
+      Support.immutable_copy(StoredTimePrecision.apply(attributes, digits))
+    end
   end
 
   # Extracts a version's scalar state without constructing a disposable AR object.
@@ -121,17 +130,37 @@ module PaperTrailDiff
 
     #: (untyped) -> untyped
     def record_before(boundary)
+      state_before(boundary)&.instantiate
+    end
+
+    #: (untyped) -> PreparedRecordState?
+    def state_before(boundary)
       index = boundary_index(boundary)
-      return state_for(versions.fetch(index))&.instantiate if index
+      return state_for(versions.fetch(index)) if index
+
+      @live
+    end
+
+    # A handled nil is known absence, not permission to query the current row.
+    #: (untyped, ?direct: bool) -> [bool, untyped]
+    def record_after(version, direct: false)
+      index = @version_positions[version.id.to_s]
+      return [false, nil] unless index
 
-      @live&.instantiate
+      state = state_after(index)
+      [true, direct ? state : state&.instantiate]
     end
 
     #: () -> Array[untyped]
     def records
-      version_records = versions.filter_map { |version| state_for(version)&.instantiate }
+      states.map(&:instantiate)
+    end
+
+    #: () -> Array[PreparedRecordState]
+    def states
+      recorded = versions.filter_map { |version| state_for(version) }
       live = @live
-      live ? [*version_records, live.instantiate] : version_records
+      live ? [*recorded, live] : recorded
     end
 
     #: (untyped) -> [Hash[untyped, untyped], Hash[untyped, untyped]]?
@@ -164,11 +193,15 @@ module PaperTrailDiff
     # boundary's transaction. The first is monotonic over the chronological
     # list and the second is indexed, so neither rescans a long history once
     # per boundary.
+    #
+    # "At or after" is decided by the version order rather than the timestamp
+    # alone. A version written in the same instant as the boundary but before
+    # it already took effect there; reading its pre-change state would put the
+    # boundary on the wrong side of a change it follows.
     #: (untyped) -> Integer?
     def boundary_index(boundary)
-      created_at = boundary.created_at
       chronological = versions.bsearch_index do |candidate|
-        candidate.created_at >= created_at
+        VersionBoundary.at_or_after?(candidate, boundary)
       end
       transactional = transaction_index(boundary)
       return chronological unless transactional
@@ -200,6 +233,7 @@ module PaperTrailDiff
     #: (untyped) -> PreparedRecordState?
     def state_for(version)
       return @states[version.id] if @states.key?(version.id)
+      return @states[version.id] = nil unless version.object
 
       prepared = @state_loader.call(version)
       return @states[version.id] = prepared if prepared
@@ -226,6 +260,8 @@ module PaperTrailDiff
       end
       @state_loader = PreparedVersionStateLoader.new
       @series = {} #: Hash[Array[String], PreparedRecordSeries]
+      @direct_loader = DirectRecordStateLoader.new
+      @direct_states = {} #: Hash[PreparedRecordState, PreparedRecordState?]
     end
 
     #: (untyped, Array[untyped]) -> void
@@ -240,21 +276,67 @@ module PaperTrailDiff
       missing.each { |id| add_series(model_class, id, versions, live) }
     end
 
+    #: (untyped, Array[untyped], Array[untyped]) -> void
+    def seed(model_class, ids, versions)
+      grouped = versions.group_by { |version| version.item_id.to_s }
+      live = available_live_records(model_class, ids).to_h { |record| [record.id.to_s, record] }
+      ids.each { |id| add_series(model_class, id, grouped, live) }
+    end
+
     #: (untyped, untyped, untyped) -> untyped
     def record_before(model_class, id, boundary)
       @series.fetch(identity(model_class, id)).record_before(boundary)
     end
 
+    #: (untyped, untyped, untyped) -> [bool, PreparedRecordState?]
+    def snapshot_state_before(model_class, id, boundary)
+      series = @series[identity(model_class, id)]
+      return [false, nil] unless series
+
+      state = series.state_before(boundary)
+      return [true, nil] unless state
+
+      @direct_states[state] = @direct_loader.complete(state) unless @direct_states.key?(state)
+      prepared = @direct_states[state]
+      [!prepared.nil?, prepared]
+    end
+
     #: (untyped, untyped, untyped) -> [Hash[untyped, untyped], Hash[untyped, untyped]]?
     def transition(model_class, id, version)
       @series[identity(model_class, id)]&.transition(version)
     end
 
+    #: (untyped, untyped, untyped, ?direct: bool) -> [bool, untyped]
+    def record_after(model_class, id, version, direct: false)
+      handled, state = @series[identity(model_class, id)]&.record_after(version, direct: direct)
+      return [false, nil] unless handled
+      return [true, state] unless direct && state
+
+      prepared = @direct_loader.complete(state)
+      [!prepared.nil?, prepared]
+    end
+
     #: (untyped, Array[untyped]) -> Array[untyped]
     def records_for(model_class, ids)
       ids.flat_map { |id| @series.fetch(identity(model_class, id)).records }
     end
 
+    #: (untyped, Array[untyped], String) -> Array[untyped]
+    def attribute_values_for(model_class, ids, name)
+      plain_reader = generated_reader?(model_class, name)
+      ids.flat_map do |id|
+        @series.fetch(identity(model_class, id)).states.map do |state|
+          direct = @direct_loader.complete(state) if plain_reader
+          direct ? direct.attributes[name] : state.instantiate.public_send(name)
+        end
+      end
+    end
+
+    #: (untyped, untyped) -> Array[untyped]
+    def versions_for_id(model_class, id)
+      @series.fetch(identity(model_class, id)).versions
+    end
+
     #: (untyped, untyped) -> bool
     def loaded?(model_class, id)
       @series.key?(identity(model_class, id))
@@ -262,11 +344,19 @@ module PaperTrailDiff
 
     private
 
+    #: (untyped, String) -> bool
+    def generated_reader?(model, name)
+      model.define_attribute_methods
+      model.instance_method(name).owner.name.to_s.end_with?('GeneratedAttributeMethods')
+    end
+
     # @rbs @start_time: untyped
     # @rbs @end_time: untyped
     # @rbs @seeded_live_records: Hash[Array[String], untyped]
     # @rbs @state_loader: PreparedVersionStateLoader
     # @rbs @series: Hash[Array[String], PreparedRecordSeries]
+    # @rbs @direct_loader: DirectRecordStateLoader
+    # @rbs @direct_states: Hash[PreparedRecordState, PreparedRecordState?]
 
     # Callers bound the range with either a version or a bare timestamp.
     #: (untyped) -> untyped
@@ -314,27 +404,10 @@ module PaperTrailDiff
     #: (untyped) -> untyped
     def window_condition(version_class)
       table = version_class.arel_table
-      table[:created_at].lteq(@end_time).or(first_after_range(table))
-    end
-
-    #: (untyped) -> untyped
-    def first_after_range(table)
-      arel = Object.const_get(:Arel) #: untyped
-      later = table.alias('paper_trail_diff_later_versions')
-      arel.const_get(:SelectManager).new
-          .from(later)
-          .project(arel.sql('1'))
-          .where(preceding_trailing_version(table, later))
-          .exists
-          .not
-    end
-
-    #: (untyped, untyped) -> untyped
-    def preceding_trailing_version(table, later)
-      later[:item_type].eq(table[:item_type])
-                       .and(later[:item_id].eq(table[:item_id]))
-                       .and(later[:created_at].gt(@end_time))
-                       .and(later[:created_at].lt(table[:created_at]))
+      first_after = VersionQuery.no_earlier_version(table) do |earlier|
+        earlier[:created_at].gt(@end_time)
+      end
+      table[:created_at].lteq(@end_time).or(first_after)
     end
 
     #: (untyped, Array[untyped]) -> Array[untyped]

data/lib/paper_trail_diff/prepared_snapshot_builder.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+# rbs_inline: enabled
+
+module PaperTrailDiff
+  # Normalizes supported recorded graphs without historical ActiveRecord instances.
+  class PreparedSnapshotBuilder
+    #: (AssociationTraversal) -> void
+    def initialize(traversal)
+      @traversal = traversal
+      @loader = DirectRecordStateLoader.new
+    end
+
+    #: (untyped, untyped, tree: AssociationTree, normalizer: SnapshotNormalizer, history: PreparedHistory?) -> [bool, RecordSnapshot?]
+    def call(version, boundary, tree:, normalizer:, history:)
+      return [true, nil] unless version.object
+
+      state = @loader.call(version)
+      return [false, nil] unless state
+
+      build(state, boundary, tree, normalizer, history, path: '')
+    end
+
+    private
+
+    # @rbs @traversal: AssociationTraversal
+    # @rbs @loader: DirectRecordStateLoader
+
+    #: (PreparedRecordState, untyped, AssociationTree, SnapshotNormalizer, PreparedHistory?, path: String, ?incoming: untyped) -> [bool, RecordSnapshot?]
+    def build(state, boundary, tree, normalizer, history, path:, incoming: nil) # rubocop:disable Metrics/ParameterLists
+      associations = {} #: snapshot_associations
+      @traversal.reflections_for(state.model_class, tree, path: path).each do |reflection|
+        return [false, nil] unless history
+
+        handled, snapshot = association(state, reflection, boundary, tree, normalizer, history,
+                                        path)
+        return [false, nil] unless handled && snapshot
+
+        associations[reflection.name.to_s] = snapshot
+      end
+      [true, normalizer.from_state(state, tree: tree, path: path,
+                                          incoming: incoming, associations: associations)]
+    end
+
+    #: (PreparedRecordState, untyped, untyped, AssociationTree, SnapshotNormalizer, PreparedHistory, String) -> [bool, AssociationSnapshot?]
+    def association(owner, reflection, boundary, tree, normalizer, history, path) # rubocop:disable Metrics/ParameterLists
+      handled, states = history.snapshot_states(owner, reflection, boundary)
+      return [false, nil] unless handled
+
+      subtree = tree.child(reflection.name)
+      return [false, nil] unless subtree
+
+      child_path = Support.association_path(path, reflection.name.to_s)
+      records = [] #: Array[RecordSnapshot]
+      states.each do |state|
+        supported, snapshot = build(state, boundary, subtree, normalizer, history,
+                                    path: child_path, incoming: reflection)
+        return [false, nil] unless supported && snapshot
+
+        records << snapshot
+      end
+      [true, AssociationSnapshot.new(kind: reflection.macro, records: records)]
+    end
+  end
+end

data/lib/paper_trail_diff/prepared_state_association_reader.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+# rbs_inline: enabled
+
+module PaperTrailDiff
+  # Reads plain direct edges without creating AR records for their members.
+  class PreparedStateAssociationReader
+    #: (PreparedRecordIndex, untyped) -> void
+    def initialize(records, edges)
+      @records = records
+      @edges = edges
+    end
+
+    #: (PreparedRecordState, untyped, untyped) -> [bool, Array[PreparedRecordState]]
+    def call(owner, reflection, boundary)
+      return [false, []] unless supported?(reflection)
+
+      if reflection.belongs_to?
+        id = owner.attributes[reflection.foreign_key.to_s]
+        return [true, []] if id.nil?
+
+        handled, state = @records.snapshot_state_before(reflection.klass, id, boundary)
+        return [handled, state ? [state] : []]
+      end
+      children(owner, reflection, boundary)
+    end
+
+    private
+
+    # @rbs @records: PreparedRecordIndex
+    # @rbs @edges: untyped
+
+    #: (untyped) -> bool
+    def supported?(reflection)
+      !reflection.options[:through] && !reflection.polymorphic? && reflection.scope.nil? &&
+        !reflection.klass.default_scopes? && !reflection.foreign_key.is_a?(Array) &&
+        %i[belongs_to has_one has_many].include?(reflection.macro)
+    end
+
+    #: (PreparedRecordState, untyped, untyped) -> [bool, Array[PreparedRecordState]]
+    def children(owner, reflection, boundary)
+      selected = [] #: Array[PreparedRecordState]
+      @edges.call(owner.model_class, reflection).each_value do |group|
+        ids_for(group, owner).each do |id|
+          handled, child = @records.snapshot_state_before(group.fetch(:model), id, boundary)
+          return [false, []] unless handled
+
+          selected << child if child && member?(child, owner, reflection)
+        end
+      end
+      [true, reflection.collection? ? selected : selected.first(1)]
+    end
+
+    #: (untyped, PreparedRecordState) -> Array[untyped]
+    def ids_for(group, owner)
+      owners = group[:owners]
+      id = owner.attributes[owner.model_class.primary_key].to_s
+      empty = [] #: Array[untyped]
+      owners ? owners.fetch(id, empty) : group.fetch(:ids)
+    end
+
+    #: (PreparedRecordState, PreparedRecordState, untyped) -> bool
+    def member?(child, owner, reflection)
+      owner_id = owner.attributes[owner.model_class.primary_key].to_s
+      return false unless child.attributes[reflection.foreign_key.to_s].to_s == owner_id
+      return true unless reflection.options[:as]
+
+      matching_type?(child, owner.model_class, reflection)
+    end
+
+    #: (PreparedRecordState, untyped, untyped) -> bool
+    def matching_type?(child, model, reflection)
+      types = [model.name, model.base_class.name,
+               reflection.active_record.name]
+      types.include?(child.attributes[reflection.type.to_s].to_s)
+    end
+  end
+end

data/lib/paper_trail_diff/root_version_plan.rb

@@ -27,6 +27,10 @@ module PaperTrailDiff
     # The root versions this plan reports as mutations, which excludes any
     # version present only to reveal what the last of them produced.
     attr_reader :mutations #: Array[untyped]
+    # Whether a wall-clock window closes on the root's own destruction. Its
+    # final state is then the absence the destroy left, just as a window
+    # closing on current state ends at the live record.
+    attr_reader :closes_on_destroy #: bool
 
     class << self
       # Adjacent boundaries, which is what an unfiltered range reports.
@@ -45,14 +49,24 @@ module PaperTrailDiff
         steps = [] #: Array[[untyped, untyped]]
         new(versions: versions, steps: steps)
       end
+
+      # No root version to report or replay: only descendants moved, and the
+      # live record is the root's state throughout.
+      #: (untyped) -> RootVersionPlan
+      def closing_on(record)
+        versions = [] #: Array[untyped]
+        steps = [] #: Array[[untyped, untyped]]
+        new(versions: versions, steps: steps, closing_record: record)
+      end
     end
 
-    #: (versions: Array[untyped], steps: Array[[untyped, untyped]], ?context_version: untyped, ?reconstruction_versions: Array[untyped]?, ?mutations: Array[untyped]?, ?closing_record: untyped) -> void
+    #: (versions: Array[untyped], steps: Array[[untyped, untyped]], ?context_version: untyped, ?reconstruction_versions: Array[untyped]?, ?mutations: Array[untyped]?, ?closing_record: untyped, ?closes_on_destroy: bool) -> void
     def initialize( # rubocop:disable Metrics/ParameterLists
       versions:, steps:, context_version: nil, reconstruction_versions: nil, mutations: nil,
-      closing_record: nil
+      closing_record: nil, closes_on_destroy: false
     )
       @closing_record = closing_record
+      @closes_on_destroy = closes_on_destroy
       @versions = versions.freeze
       @reconstruction_versions = (reconstruction_versions || versions).freeze
       @steps = steps.freeze
@@ -67,6 +81,15 @@ module PaperTrailDiff
       versions.empty?
     end
 
+    #: () -> RootVersionPlan
+    def closing_on_destroy
+      self.class.new(
+        versions: versions, steps: steps, context_version: context_version,
+        reconstruction_versions: reconstruction_versions, mutations: mutations,
+        closing_record: closing_record, closes_on_destroy: true
+      )
+    end
+
     # What the range's final state is read from, which is the live record when
     # the window closes on current state and the last version otherwise.
     #: () -> untyped

data/lib/paper_trail_diff/root_version_selection.rb

@@ -37,10 +37,8 @@ module PaperTrailDiff
       return without_selection if @selected.empty?
 
       closing = revealing_version || @live_endpoint
-      raise IncompleteTimeRangeError, INCOMPLETE if !closing && @windowed && !terminal_destroy?
-      return filtered_plan(closing) if @filtered
-
-      contiguous_plan(closing)
+      plan = @filtered ? filtered_plan(closing) : contiguous_plan(closing)
+      closes_on_destroy?(closing) ? plan.closing_on_destroy : plan
     end
 
     private
@@ -69,13 +67,16 @@ module PaperTrailDiff
     end
 
     # An activity view still needs a root to reconstruct from even when no root
-    # version falls inside the window, because descendants may have moved.
+    # version falls inside the window, because descendants may have moved. With
+    # no later version, a window closing on current state reads the root from
+    # the live record, which is then its state throughout the window.
     #: () -> RootVersionPlan
     def without_selection
       return RootVersionPlan.empty unless @context_required
       if @after_range
         return RootVersionPlan.contiguous([@after_range], context_version: @after_range)
       end
+      return RootVersionPlan.closing_on(@live_endpoint) if @live_endpoint && @windowed
 
       raise IncompleteTimeRangeError, INCOMPLETE
     end
@@ -149,6 +150,16 @@ module PaperTrailDiff
       immediate_successor(@selected.last) || @after_range
     end
 
+    # A window with nothing after its last selected mutation can only close on
+    # that mutation being the record's destruction.
+    #: (untyped) -> bool
+    def closes_on_destroy?(closing)
+      return false if closing || !@windowed
+      raise IncompleteTimeRangeError, INCOMPLETE unless terminal_destroy?
+
+      true
+    end
+
     # A range closing on the record's own destruction needs no later version:
     # nothing can follow it, so demanding one would reject the range forever.
     #: () -> bool

data/lib/paper_trail_diff/scoped_analysis.rb

@@ -15,14 +15,29 @@ module PaperTrailDiff
   class ScopedAnalysis
     attr_reader :analyses #: Hash[Array[String], Analysis]
     attr_reader :unreachable #: Array[Array[String]]
+    # The live records the selection loaded, in the order it loaded them. The
+    # gem already has them; withholding them only makes a caller query the same
+    # rows again to attach its own presentation data. A destroyed root has no
+    # record to hand back, so `roots` and `unreachable` stay complementary.
+    attr_reader :roots #: Array[untyped]
+    # Requested missing-root analyses, kept separate because live SQL conditions
+    # cannot prove which deleted rows matched. nil means no destroy history.
+    attr_reader :deleted #: Hash[Array[String], Analysis?]
 
-    #: (analyses: Hash[Array[String], Analysis], unreachable: Array[Array[String]]) -> void
-    def initialize(analyses:, unreachable:)
+    #: (analyses: Hash[Array[String], Analysis], unreachable: Array[Array[String]], ?roots: Array[untyped], ?deleted: Hash[Array[String], Analysis?]) -> void
+    def initialize(analyses:, unreachable:, roots: [], deleted: {})
       @analyses = analyses
       @unreachable = Support.immutable_copy(unreachable)
+      # Not deep-copied: these are the caller's own model instances, and
+      # freezing them would make an ordinary `record.title` on a lazy attribute
+      # fail. The array itself is frozen so the collection cannot be reshaped.
+      @roots = roots.dup.freeze
+      @deleted = Support.immutable_copy(deleted)
       freeze
     end
 
+    # Two elements, not three: `roots` is reached by name so that existing
+    # destructuring keeps working.
     #: () -> [Hash[Array[String], Analysis], Array[Array[String]]]
     def to_ary
       [analyses, unreachable]