paper_trail_diff 0.12.0 → 0.13.1

data/lib/paper_trail_diff/historical_snapshot_store.rb

@@ -10,6 +10,7 @@ module PaperTrailDiff
       @traversal = traversal
       @normalizer = normalizer
       @preparer = preparer
+      @prepared_snapshotter = PreparedSnapshotBuilder.new(traversal)
       @live_graph_collector = LiveGraphCollector.new(tree: tree, traversal: traversal)
       @snapshots = {} #: Hash[Array[untyped], RecordSnapshot?]
       @prepared_history = nil #: PreparedHistory?
@@ -24,8 +25,13 @@ module PaperTrailDiff
       end_at: root_versions.last.created_at
     )
       return if @tree.empty?
+
       # A batched preparation already covers these roots.
-      return if root_versions.any? { |v| @prepared_histories.key?(context_key(v)) }
+      batched = root_versions.find { |version| @prepared_histories.key?(context_key(version)) }
+      if batched
+        @prepared_history = @prepared_histories.fetch(context_key(batched))
+        return
+      end
 
       @prepared_history = PreparedHistoryLoader.new(
         record,
@@ -37,15 +43,24 @@ module PaperTrailDiff
       ).call
     end
 
-    #: (Array[untyped], Array[untyped]) -> void
-    def prepare_batch(records, root_versions)
+    #: (Array[untyped], Array[untyped], ?start_at: untyped, ?end_at: untyped) -> void
+    def prepare_batch(records, root_versions, start_at: nil, end_at: nil)
       return if @tree.empty? || records.empty? || root_versions.empty?
 
       Instrumentation.instrument('prepare_history', batch_payload(records, root_versions)) do
-        register_batch(records, root_versions)
+        register_batch(records, root_versions, start_at: start_at, end_at: end_at)
       end
     end
 
+    # Missing roots have no live graph to collect. Reading their associations
+    # here would issue a query per root and seed nonexistent rows as live state.
+    #: (Array[untyped], Array[untyped], ?start_at: untyped, ?end_at: untyped) -> void
+    def prepare_deleted_batch(records, root_versions, start_at: nil, end_at: nil)
+      return if @tree.empty? || records.empty? || root_versions.empty?
+
+      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)
       key = snapshot_key(root_endpoint, context_endpoint)
@@ -100,6 +115,11 @@ 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
@@ -108,12 +128,19 @@ module PaperTrailDiff
       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
     # @rbs @traversal: AssociationTraversal
     # @rbs @normalizer: SnapshotNormalizer
     # @rbs @preparer: untyped
+    # @rbs @prepared_snapshotter: PreparedSnapshotBuilder
     # @rbs @live_graph_collector: LiveGraphCollector
     # @rbs @snapshots: Hash[Array[untyped], RecordSnapshot?]
     # @rbs @prepared_history: PreparedHistory?
@@ -126,25 +153,22 @@ module PaperTrailDiff
 
     #: (Array[untyped], Array[untyped]) -> Hash[Symbol, untyped]
     def batch_payload(records, root_versions)
-      {
-        root_count: records.length,
-        version_count: root_versions.length,
-        model_type: records.first.class.base_class.name.to_s,
-        batched: true
-      }
+      { root_count: records.length, version_count: root_versions.length,
+        model_type: records.first.class.base_class.name.to_s, batched: true }
     end
 
-    #: (Array[untyped], Array[untyped]) -> void
-    def register_batch(records, root_versions)
+    #: (Array[untyped], Array[untyped], ?live_records: Array[untyped], ?start_at: untyped, ?end_at: untyped) -> void
+    def register_batch(records, root_versions, live_records: @live_graph_collector.call(records),
+                       start_at: nil, end_at: nil)
       history = PreparedHistoryLoader.new(
         records.first,
         root_ids: records.map(&:id),
         root_versions: root_versions,
-        start_at: root_versions.map(&:created_at).min,
-        end_at: root_versions.map(&:created_at).max,
+        start_at: start_at || root_versions.map(&:created_at).min,
+        end_at: end_at || root_versions.map(&:created_at).max,
         tree: @tree,
         traversal: @traversal,
-        live_records: @live_graph_collector.call(records)
+        live_records: live_records
       ).call
       root_versions.each { |version| @prepared_histories[context_key(version)] = history }
     end
@@ -154,27 +178,24 @@ module PaperTrailDiff
       model_class = Endpoint.model_class(root_version)
       @preparer.call(model_class, historical: true)
       @traversal.ensure_habtm_history!(model_class, root_version)
-      record = root_version.reify(dup: true)
-      normalize(
-        record,
-        context_version,
-        tree: tree,
-        normalizer: normalizer,
-        habtm_version: root_version
+      handled, snapshot = @prepared_snapshotter.call(
+        root_version, context_version, tree: tree, normalizer: normalizer,
+                                       history: @prepared_histories[context_key(context_version)] ||
+                                         @prepared_history
       )
+      return snapshot if handled
+
+      record = root_version.reify(dup: true)
+      normalize(record, context_version, tree: tree, normalizer: normalizer,
+                                         habtm_version: root_version)
     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)
       @preparer.call(record.class, historical: true)
-      normalize(
-        record,
-        context_version,
-        tree: tree,
-        normalizer: normalizer,
-        habtm_version: context_version
-      )
+      normalize(record, context_version, tree: tree, normalizer: normalizer,
+                                         habtm_version: context_version)
     end
 
     #: (untyped, untyped, tree: AssociationTree, normalizer: SnapshotNormalizer, habtm_version: untyped) -> RecordSnapshot?
@@ -188,12 +209,7 @@ module PaperTrailDiff
 
     #: (untyped, untyped) -> Array[untyped]
     def snapshot_key(root_endpoint, context_endpoint)
-      [
-        root_endpoint.class.name,
-        root_endpoint.id,
-        context_endpoint.class.name,
-        context_endpoint.id
-      ]
+      context_key(root_endpoint) + context_key(context_endpoint)
     end
   end
 end

data/lib/paper_trail_diff/instrumentation.rb

@@ -9,13 +9,13 @@ module PaperTrailDiff
     module_function
 
     #: (String | Symbol, Hash[Symbol, untyped]) { () -> untyped } -> untyped
-    def instrument(event, payload, &)
+    def instrument(event, payload, &block)
       active_support = Object.const_get(:ActiveSupport) #: untyped
       notifications = active_support.const_get(:Notifications) #: untyped
       notifications.instrument(
         "#{event}.paper_trail_diff",
         payload,
-        &
+        &block
       )
     end
 

data/lib/paper_trail_diff/nested_comparator.rb

@@ -27,10 +27,16 @@ module PaperTrailDiff
   # one of them, so absence is its own value rather than nil.
   class NestedComparator
     # Stands in for a key that was not there at all.
-    ABSENT = Object.new
-    def ABSENT.inspect = '#<PaperTrailDiff absent>'
-    def ABSENT.to_s = 'absent'
-    ABSENT.freeze
+    class Absent
+      #: () -> String
+      def inspect = '#<PaperTrailDiff absent>'
+
+      #: () -> String
+      def to_s = 'absent'
+    end
+    private_constant :Absent
+
+    ABSENT = Absent.new.freeze
 
     #: (untyped, untyped) -> nested_changes
     def self.call(from_value, to_value)
@@ -49,9 +55,9 @@ module PaperTrailDiff
     #: () -> nested_changes
     def call
       from_structure, to_structure = structures
-      return {} unless from_structure && to_structure
-
       changes = {} #: nested_changes
+      return changes.freeze unless from_structure && to_structure
+
       walk(from_structure, to_structure, [], changes)
       changes.freeze
     end
@@ -76,20 +82,23 @@ module PaperTrailDiff
 
       parsed = begin
         JSON.parse(value)
-      rescue JSON::ParserError, TypeError
+      rescue JSON::ParserError
         nil
       end
-      parsed if parsed.is_a?(Hash)
+      # JSON parses objects into plain Hashes, never a subclass.
+      parsed if parsed.instance_of?(Hash)
     end
 
     #: (Hash[untyped, untyped], Hash[untyped, untyped], Array[String], nested_changes) -> void
     def walk(from_hash, to_hash, path, changes)
+      from_hash = normalize_keys(from_hash)
+      to_hash = normalize_keys(to_hash)
       keys(from_hash, to_hash).each do |key|
-        from_item = from_hash.key?(key) ? from_hash[key] : ABSENT
-        to_item = to_hash.key?(key) ? to_hash[key] : ABSENT
+        from_item = from_hash.fetch(key, ABSENT)
+        to_item = to_hash.fetch(key, ABSENT)
         next if from_item == to_item
 
-        here = [*path, key.to_s].freeze
+        here = (path + [key]).freeze
         if from_item.is_a?(Hash) && to_item.is_a?(Hash)
           walk(from_item, to_item, here, changes)
         else
@@ -98,6 +107,20 @@ module PaperTrailDiff
       end
     end
 
+    #: (Hash[untyped, untyped]) -> Hash[String, untyped]
+    def normalize_keys(hash)
+      normalized = {} #: Hash[String, untyped]
+      hash.each do |key, value|
+        name = key.to_s
+        if normalized.key?(name)
+          raise AmbiguousNestedKeyError, "duplicate nested key after normalization: #{name.inspect}"
+        end
+
+        normalized[name] = value
+      end
+      normalized
+    end
+
     # Two arrays are a membership change; anything else is a change to the
     # value as a whole, including an array facing something that is not one.
     #: (untyped, untyped) -> nested_change
@@ -109,11 +132,12 @@ module PaperTrailDiff
       end
     end
 
-    # Sorted so a report reads the same twice, and stringified because a hash
-    # loaded from JSON and one built in Ruby can key the same field differently.
-    #: (Hash[untyped, untyped], Hash[untyped, untyped]) -> Array[untyped]
+    # Sorted so a report reads the same twice. Both hashes are already keyed by
+    # strings, because a hash loaded from JSON and one built in Ruby can key the
+    # same field differently.
+    #: (Hash[String, untyped], Hash[String, untyped]) -> Array[String]
     def keys(from_hash, to_hash)
-      (from_hash.keys | to_hash.keys).sort_by(&:to_s)
+      (from_hash.keys | to_hash.keys).sort
     end
   end
 end

data/lib/paper_trail_diff/paper_trail_adapter.rb

@@ -10,11 +10,12 @@ module PaperTrailDiff
     # The only thing a wall-clock window can close on besides a later version.
     CLOSE_ON_CURRENT = :current
 
-    #: (associations: Array[String | Symbol], ignore: ignore_option, ?reload_live_endpoints: bool) -> void
-    def initialize(associations:, ignore:, reload_live_endpoints: true)
+    #: (associations: Array[String | Symbol], ignore: ignore_option, ?reload_live_endpoints: bool, ?allow_expensive: bool) -> void
+    def initialize(associations:, ignore:, reload_live_endpoints: true, allow_expensive: false)
       @association_tree = AssociationTree.build(associations)
       @ignore_policy = IgnorePolicy.build(ignore, association_paths: @association_tree.paths)
       @traversal = AssociationTraversal.new(@association_tree)
+      @batch_safety = BatchSafety.new(@traversal, allow_expensive: allow_expensive)
       @traversal_preparer = TraversalPreparer.new(tree: @association_tree, traversal: @traversal)
       @live_endpoints = LiveEndpointProvider.new(
         tree: @association_tree, traversal: @traversal, reload: reload_live_endpoints
@@ -34,7 +35,14 @@ module PaperTrailDiff
       Instrumentation.instrument('compare', payload) do
         Endpoint.validate_pair!(from_endpoint, to_endpoint)
         notify_ambiguous_association_boundary(from_endpoint, to_endpoint)
-        Engine.compare(snapshot_for_endpoint(from_endpoint), snapshot_for_endpoint(to_endpoint))
+        if @association_tree.empty?
+          Engine.compare(snapshot_for_endpoint(from_endpoint), snapshot_for_endpoint(to_endpoint))
+        else
+          # Prepared history orders versions that share a timestamp; reading
+          # associations straight from PT-AT would resolve them by time alone.
+          comparison_batch([{ from: from_endpoint, to: to_endpoint }],
+                           preparer: @traversal_preparer.method(:call)).call.values.fetch(0)
+        end
       end
     end
 
@@ -44,19 +52,14 @@ module PaperTrailDiff
       count = comparisons.is_a?(Array) ? comparisons.length : 0
       payload = @instrumentation_payload.merge(comparison_count: count)
       Instrumentation.instrument('compare_many', payload) do
-        ComparisonBatch.new(
-          comparisons,
-          live_loader: @live_endpoints.method(:call), preparer: @traversal_preparer.method(:call),
-          history_preparer: @historical_store.method(:prepare_batch),
-          historical_snapshotter: method(:historical_snapshot),
-          live_normalizer: method(:normalize_live_snapshot)
-        ).call
+        comparison_batch(comparisons, preparer: method(:prepare_batch_model)).call
       end
     end
 
     #: (untyped, from: untyped, to: untyped, within: untyped, ?version_scope: untyped, ?close_on: Symbol?) -> Array[Step]
     def timeline(record, from:, to:, within:, version_scope: nil, close_on: nil) # rubocop:disable Metrics/ParameterLists
       @traversal_preparer.call(record.class, historical: true)
+      from, to = default_range(record, from, to, within)
       TimelineBuilder.new(
         record,
         from: from,
@@ -73,8 +76,8 @@ module PaperTrailDiff
       payload = @instrumentation_payload.merge(model_type: record.class.base_class.name.to_s)
       Instrumentation.instrument('activity_timeline', payload) do
         @traversal_preparer.call(record.class, historical: true)
+        from, to = default_range(record, from, to, within)
         live = live_endpoint_for(record, close_on, within)
-        reject_live_habtm_activity!(record.class) if Endpoint.record?(to) || live
         steps = activity_builder(
           record, from: from, to: to, within: within, version_scope: version_scope,
                   live_endpoint: live, snapshots: snapshots, group: group
@@ -86,7 +89,9 @@ module PaperTrailDiff
 
     #: (untyped, from: untyped, to: untyped, within: untyped, ?activity: bool, ?version_scope: untyped, ?close_on: Symbol?, ?snapshots: bool, ?group: Symbol?) -> Analysis
     def analyze(record, from:, to:, within:, activity: false, version_scope: nil, close_on: nil, snapshots: false, group: nil) # rubocop:disable Metrics/ParameterLists, Layout/LineLength
+      ActivityGrouping.validate!(group, activity: activity, snapshots: snapshots)
       @traversal_preparer.call(record.class, historical: true)
+      from, to = default_range(record, from, to, within)
       live = live_endpoint_for(record, close_on, within)
       if activity
         return analyze_activity(
@@ -102,19 +107,21 @@ module PaperTrailDiff
     end
 
     # Analyzes many roots over one shared range, preparing their history once.
-    #: (Array[untyped], within: untyped, ?activity: bool, ?version_scope: untyped, ?close_on: Symbol?) -> Hash[identity, Analysis]
-    def analyze_many(records, within:, activity: false, version_scope: nil, close_on: nil)
+    #: (Array[untyped], within: untyped, ?activity: bool, ?version_scope: untyped, ?close_on: Symbol?, ?snapshots: bool, ?group: Symbol?) -> Hash[identity, Analysis]
+    def analyze_many(records, within:, activity: false, version_scope: nil, close_on: nil, snapshots: false, group: nil) # rubocop:disable Metrics/ParameterLists, Layout/LineLength
+      ActivityGrouping.validate!(group, activity: activity, snapshots: snapshots)
       count = records.is_a?(Array) ? records.length : 0
       payload = @instrumentation_payload.merge(comparison_count: count)
       Instrumentation.instrument('analyze_many', payload) do
         AnalysisBatch.new(
           records,
-          time_range: within.nil? ? nil : TimeRange.new(within),
-          version_scope: version_scope,
-          close_on_current: close_on_current?(close_on, within),
-          live_loader: @live_endpoints.method(:call),
+          time_range: within.nil? ? nil : TimeRange.new(within), version_scope: version_scope,
+          close_on_current: close_on_current?(close_on, within) || within.nil?,
+          context_required: activity && !@association_tree.empty?,
+          live_loader: method(:load_batch_endpoints),
           history_preparer: @historical_store.method(:prepare_batch),
-          analyzer: batched_root_analyzer(activity)
+          analyzer: batched_root_analyzer(activity, within: within, snapshots: snapshots,
+                                                    group: group)
         ).call
       end
     end
@@ -123,22 +130,65 @@ module PaperTrailDiff
     # caller reporting on a population does not have to rediscover which of its
     # members changed. The roots the relation could not reach come back named
     # rather than dropped -- see `PaperTrailDiff.analyze_scope`.
-    #: (untyped, limit: Integer?, within: untyped, ?activity: bool, ?version_scope: untyped, ?close_on: Symbol?) -> ScopedAnalysis
-    def analyze_scope(scope, limit:, within:, activity: false, version_scope: nil, close_on: nil) # rubocop:disable Metrics/ParameterLists
-      raise ConfigurationError, 'limit: is required when selecting roots by scope' if limit.nil?
-
-      selection = ScopedRootSelection.new(
-        scope, time_range: within.nil? ? nil : TimeRange.new(within), limit: limit
+    #: (untyped, limit: Integer?, within: untyped, ?activity: bool, ?version_scope: untyped, ?close_on: Symbol?, ?snapshots: bool, ?group: Symbol?, ?historical_filter: untyped, ?max_filter_versions: Integer, ?include_deleted: bool) -> ScopedAnalysis
+    def analyze_scope(scope, limit:, within:, activity: false, version_scope: nil, close_on: nil, snapshots: false, group: nil, historical_filter: nil, max_filter_versions: HistoricalFilter::DEFAULT_VERSION_LIMIT, include_deleted: false) # rubocop:disable Metrics/ParameterLists, Layout/LineLength
+      ActivityGrouping.validate!(group, activity: activity, snapshots: snapshots)
+      @batch_safety.call(scope.all.model) if scope.respond_to?(:all) && scope.respond_to?(:where)
+      # @type var options: report_options
+      options = { within: within, activity: activity, version_scope: version_scope,
+                  close_on: close_on, snapshots: snapshots, group: group }
+      ScopedAnalysisBuilder.new(
+        scope, limit: limit, within: within, historical_filter: historical_filter,
+               max_filter_versions: max_filter_versions, include_deleted: include_deleted,
+               analyzer: ->(records) { analyze_many(records, **options, within: within) },
+               deleted_analyzer: lambda { |identities|
+                 analyze_deleted(scope.all.model, identities, options)
+               }
       ).call
-      ScopedAnalysis.new(
-        analyses: analyze_many(selection.records, within: within, activity: activity,
-                                                  version_scope: version_scope, close_on: close_on),
-        unreachable: selection.unreachable
-      )
     end
 
     private
 
+    #: (Array[comparison_input], preparer: untyped) -> ComparisonBatch
+    def comparison_batch(comparisons, preparer:)
+      ComparisonBatch.new(
+        comparisons,
+        live_loader: @live_endpoints, preparer: preparer,
+        history_preparer: @historical_store.method(:prepare_batch),
+        historical_snapshotter: method(:historical_snapshot),
+        live_normalizer: method(:normalize_live_snapshot)
+      )
+    end
+
+    #: (Array[untyped]) -> Hash[identity, untyped]
+    def load_batch_endpoints(records)
+      records.map(&:class).uniq.each { |model| @batch_safety.call(model) }
+      @live_endpoints.call(records)
+    end
+
+    #: (untyped, historical: bool) -> void
+    def prepare_batch_model(model, historical:)
+      @batch_safety.call(model, historical: historical)
+      @traversal_preparer.call(model, historical: historical)
+    end
+
+    # @rbs @batch_safety: BatchSafety
+
+    #: (untyped, Array[Array[String]], Hash[Symbol, untyped]) -> Hash[Array[String], Analysis?]
+    def analyze_deleted(model, identities, options)
+      within = options.fetch(:within)
+      analyzer = batched_root_analyzer(
+        options.fetch(:activity), within: within, snapshots: options.fetch(:snapshots),
+                                  group: options.fetch(:group)
+      )
+      DeletedAnalysisBatch.new(
+        model, identities: identities, time_range: within.nil? ? nil : TimeRange.new(within),
+               version_scope: options.fetch(:version_scope),
+               history_preparer: @historical_store.method(:prepare_deleted_batch),
+               analyzer: analyzer
+      ).call
+    end
+
     # @rbs @association_tree: AssociationTree
     # @rbs @live_endpoints: LiveEndpointProvider
     # @rbs @instrumentation_payload: Hash[Symbol, untyped]
@@ -153,7 +203,6 @@ module PaperTrailDiff
 
     #: (untyped, from: untyped, to: untyped, within: untyped, version_scope: untyped, live_endpoint: untyped, ?snapshots: bool, ?group: Symbol?) -> Analysis
     def analyze_activity(record, from:, to:, within:, version_scope:, live_endpoint:, snapshots: false, group: nil) # rubocop:disable Metrics/ParameterLists, Layout/LineLength
-      reject_live_habtm_activity!(record.class) if live_endpoint
       activity_builder(
         record, from: from, to: to, within: within, version_scope: version_scope,
                 live_endpoint: live_endpoint, snapshots: snapshots, group: group
@@ -181,25 +230,38 @@ module PaperTrailDiff
       )
     end
 
-    # `close_on:` names what ends a wall-clock window, so it is meaningless for a
-    # range whose endpoints the caller already gave explicitly.
+    # A window with nothing recorded after its last change ends at the live
+    # record, which holds the state that change produced -- whether the window
+    # ended a moment ago or long before. `close_on: :current` asked for this
+    # before it was the default and is still accepted. It names what ends a
+    # wall-clock window, so it is meaningless for explicit endpoints.
     #: (Symbol?, untyped) -> bool
     def close_on_current?(close_on, within)
-      return false if close_on.nil?
-      unless close_on == CLOSE_ON_CURRENT
+      unless close_on.nil? || close_on == CLOSE_ON_CURRENT
         raise ConfigurationError, "close_on: must be #{CLOSE_ON_CURRENT.inspect} or nil"
       end
-      raise ConfigurationError, 'close_on: requires `within`' if within.nil?
+      raise ConfigurationError, 'close_on: requires `within`' if close_on && within.nil?
 
-      true
+      !within.nil?
     end
 
-    # A destroyed root has no current state to close on, and its own destroy
-    # version already terminates the history.
+    # With neither a window nor endpoints, a range is the record's whole
+    # history through its current saved state; a missing endpoint takes that
+    # side of the same default.
+    #: (untyped, untyped, untyped, untyped) -> [untyped, untyped]
+    def default_range(record, from, to, within)
+      return [from, to] unless within.nil?
+
+      [from.nil? ? :first : from, to.nil? ? record : to]
+    end
+
+    # Only a saved row has current state to close on. A destroyed root's own
+    # destroy version already terminates its history, and a reified or unsaved
+    # instance stands for a state that is not in the table.
     #: (untyped, Symbol?, untyped) -> untyped
     def live_endpoint_for(record, close_on, within)
       return unless close_on_current?(close_on, within)
-      return unless Endpoint.record?(record) && !record.destroyed?
+      return unless Endpoint.record?(record) && record.persisted?
 
       record
     end
@@ -213,14 +275,14 @@ module PaperTrailDiff
       @activity_snapshotter = build_activity_snapshotter
     end
 
-    #: (bool) -> BatchedRootAnalyzer
-    def batched_root_analyzer(activity)
+    #: (bool, within: untyped, snapshots: bool, group: Symbol?) -> BatchedRootAnalyzer
+    def batched_root_analyzer(activity, within:, snapshots:, group:)
       BatchedRootAnalyzer.new(
         tree: @association_tree,
         timeline_snapshotter: @timeline_snapshotter,
         activity_snapshotter: @activity_snapshotter,
         preparer: @traversal_preparer.method(:call),
-        activity: activity
+        activity: activity, within: within, snapshots: snapshots, group: group
       )
     end
 
@@ -243,12 +305,13 @@ module PaperTrailDiff
         full_snapshotter: method(:snapshot_at),
         partial_snapshotter: @historical_store.method(:custom),
         association_reader: @historical_store.method(:association_reader),
-        record_transition: @historical_store.method(:record_transition)
+        record_transition: @historical_store.method(:record_transition),
+        prepared_record_after: @historical_store.method(:record_after)
       )
       ActivitySnapshotProvider.new(
-        snapshotter: method(:snapshot_at),
-        refresher: refresher,
-        preparer: @historical_store.method(:prepare)
+        snapshotter: method(:snapshot_at), refresher: refresher,
+        preparer: @historical_store.method(:prepare),
+        activity_index: @historical_store.method(:activity_index)
       )
     end
 
@@ -267,15 +330,6 @@ module PaperTrailDiff
       )
     end
 
-    #: (untyped) -> void
-    def reject_live_habtm_activity!(model_class)
-      paths = @traversal.habtm_paths(model_class)
-      return if paths.empty?
-
-      message = "live-ended activity cannot reconstruct HABTM event boundaries: #{paths.join(', ')}"
-      raise UnsupportedLiveActivityError, message
-    end
-
     #: (untyped) -> RecordSnapshot?
     def snapshot_for_endpoint(endpoint)
       Endpoint.version?(endpoint) ? historical_snapshot(endpoint) : live_snapshot(endpoint)