paper_trail_diff 0.3.1 → 0.4.0

data/lib/paper_trail_diff/activity_timeline_builder.rb

@@ -17,6 +17,7 @@ module PaperTrailDiff
     #: () -> Array[ActivityStep]
     def build
       return time_builder.build if @range.time?
+      return no_steps if @range.unresolved?
       return build_to_current if Endpoint.record?(@to)
 
       Endpoint.validate!(@to)
@@ -27,6 +28,7 @@ module PaperTrailDiff
     #: () -> Analysis
     def analyze
       return time_builder.analyze if @range.time?
+      return Analysis.empty if @range.unresolved?
 
       unless Endpoint.version?(@to)
         raise InvalidTimelineRangeError, '`to` must be a root PaperTrail version'
@@ -35,7 +37,7 @@ module PaperTrailDiff
       root_versions = @range.select
       prepare_history(root_versions)
       events = collect_events(root_versions)
-      build_analysis(root_versions, event_history(root_versions, events))
+      build_analysis(root_versions, events, event_history(root_versions, events))
     end
 
     private
@@ -47,6 +49,12 @@ module PaperTrailDiff
     # @rbs @tree: AssociationTree
     # @rbs @snapshotter: untyped
 
+    #: () -> Array[ActivityStep]
+    def no_steps
+      steps = [] #: Array[ActivityStep]
+      steps.freeze
+    end
+
     #: () -> Array[ActivityStep]
     def build_between_versions
       root_versions = @range.select
@@ -60,7 +68,9 @@ module PaperTrailDiff
       validate_current_range!
       current_snapshot, captured_at = capture_current
       root_versions = VersionRange.new(@record, from: @from, to: @from).select_through_latest
-      prepare_history(root_versions)
+      # Descendants can move after the last root version, so the prepared range
+      # ends at the captured instant rather than at that version.
+      prepare_history(root_versions, end_at: captured_at)
       events = collect_events(root_versions, range_end: captured_at)
       build_event_steps(
         root_versions,
@@ -102,15 +112,12 @@ module PaperTrailDiff
       ).call
     end
 
-    #: (Array[untyped], ?start_at: untyped) -> void
-    def prepare_history(root_versions, start_at: nil)
+    #: (Array[untyped], ?end_at: untyped) -> void
+    def prepare_history(root_versions, end_at: nil)
       return unless @snapshotter.respond_to?(:prepare)
+      return @snapshotter.prepare(@record, root_versions) unless end_at
 
-      if start_at
-        @snapshotter.prepare(@record, root_versions, start_at: start_at)
-      else
-        @snapshotter.prepare(@record, root_versions)
-      end
+      @snapshotter.prepare(@record, root_versions, end_at: end_at)
     end
 
     #: (Array[untyped], Array[ActivityEvent], ?current: untyped, ?final_boundary: ActivityBoundary?, ?final_snapshot: RecordSnapshot?) -> Array[ActivityStep]
@@ -122,6 +129,18 @@ module PaperTrailDiff
       final_snapshot: nil
     )
       history = event_history(root_versions, events, current: current)
+      activity_steps(
+        history,
+        events,
+        final_boundary || destroyed_boundary(root_versions),
+        final_snapshot
+      )
+    end
+
+    # Appends the transition into an explicit closing boundary, which is either
+    # a requested current record or the absence a final root destroy leaves.
+    #: (ActivityHistory, Array[ActivityEvent], ActivityBoundary?, RecordSnapshot?) -> Array[ActivityStep]
+    def activity_steps(history, events, final_boundary, final_snapshot)
       steps = history.steps.dup
       previous_event = events.last
       previous_boundary = ActivityBoundary.from_version(previous_event.version) if previous_event
@@ -135,6 +154,16 @@ module PaperTrailDiff
       steps.freeze
     end
 
+    # A destroyed root has no later version, but its own event states that
+    # nothing follows it, so the removal can still close the timeline.
+    #: (Array[untyped]) -> ActivityBoundary?
+    def destroyed_boundary(root_versions)
+      version = root_versions.last
+      return unless version && version.event.to_s == 'destroy'
+
+      ActivityBoundary.destroyed(version)
+    end
+
     #: (Array[untyped], Array[ActivityEvent], ?current: untyped) -> ActivityHistory
     def event_history(root_versions, events, current: nil)
       ActivityHistoryBuilder.new(
@@ -145,32 +174,18 @@ module PaperTrailDiff
       ).call
     end
 
-    #: (Array[untyped], ActivityHistory) -> Analysis
-    def build_analysis(root_versions, history)
-      snapshots = root_versions.map do |version|
-        history.root_snapshots.fetch(version_key(version))
-      end
+    # Only the activity view gains the closing removal. The endpoint diff and
+    # the root timeline keep their `compare` and `timeline` semantics, under
+    # which the state at a destroy version is the state before the deletion.
+    #: (Array[untyped], Array[ActivityEvent], ActivityHistory) -> Analysis
+    def build_analysis(root_versions, events, history)
       Analysis.new(
         diff: Engine.compare(history.first_snapshot, history.last_snapshot),
-        timeline: build_root_steps(root_versions, snapshots),
-        activity_timeline: history.steps
-      )
-    end
-
-    #: (Array[untyped], Array[RecordSnapshot?]) -> Array[Step]
-    def build_root_steps(root_versions, snapshots)
-      root_versions.each_cons(2).with_index.map do |versions, index|
-        Step.new(
-          from_version: versions.fetch(0),
-          to_version: versions.fetch(1),
-          diff: Engine.compare(snapshots.fetch(index), snapshots.fetch(index + 1))
+        timeline: ActivityRootSteps.call(root_versions, history.root_snapshots),
+        activity_timeline: activity_steps(
+          history, events, destroyed_boundary(root_versions), nil
         )
-      end.freeze
-    end
-
-    #: (untyped) -> Array[untyped]
-    def version_key(version)
-      [version.class.name, version.id]
+      )
     end
 
     #: () -> TimeActivityTimelineBuilder

data/lib/paper_trail_diff/analysis.rb

@@ -8,6 +8,15 @@ module PaperTrailDiff
     attr_reader :timeline #: Array[Step]
     attr_reader :activity_timeline #: Array[ActivityStep]?
 
+    # The result for a record whose requested history contains no versions,
+    # which is an empty history rather than a failed request.
+    #: () -> Analysis
+    def self.empty
+      timeline = [] #: Array[Step]
+      activity_timeline = [] #: Array[ActivityStep]
+      new(diff: Diff.new, timeline: timeline, activity_timeline: activity_timeline)
+    end
+
     #: (diff: Diff, timeline: Array[Step], ?activity_timeline: Array[ActivityStep]?) -> void
     def initialize(diff:, timeline:, activity_timeline: nil)
       @diff = diff

data/lib/paper_trail_diff/collection_comparator.rb

@@ -142,9 +142,22 @@ module PaperTrailDiff
       identities.sort_by { |identity| sortable_identity(identity) }
     end
 
+    # Identities sort by type first so that mixed id types stay comparable, then
+    # naturally within one type. Ordering by the printed form instead would put
+    # id 10 before id 2, which is deterministic but reads as unsorted wherever a
+    # result is rendered.
     #: (identity) -> Array[untyped]
     def sortable_identity(identity)
-      [identity.fetch(0), identity.fetch(1).inspect]
+      [identity.fetch(0), *sortable_id(identity.fetch(1))]
+    end
+
+    #: (untyped) -> Array[untyped]
+    def sortable_id(id)
+      case id
+      when Numeric then [0, id, '']
+      when String, Symbol then [1, 0, id.to_s]
+      else [2, 0, id.inspect]
+      end
     end
 
     #: (identity) -> void

data/lib/paper_trail_diff/collection_transition.rb

@@ -7,9 +7,12 @@ module PaperTrailDiff
     attr_reader :before #: RecordSnapshot?
     attr_reader :after #: RecordSnapshot?
 
+    # The origin is recorded by serial rather than by reference, because
+    # holding it would retain every earlier snapshot at the same path for the
+    # whole timeline.
     #: (from: AssociationSnapshot, before: RecordSnapshot?, after: RecordSnapshot?) -> void
     def initialize(from:, before:, after:)
-      @from_object_id = from.object_id
+      @from_serial = from.serial
       @before = before
       @after = after
       freeze
@@ -17,9 +20,9 @@ module PaperTrailDiff
 
     #: (AssociationSnapshot) -> bool
     def from?(association)
-      @from_object_id == association.object_id
+      @from_serial == association.serial
     end
 
-    # @rbs @from_object_id: Integer
+    # @rbs @from_serial: Integer
   end
 end

data/lib/paper_trail_diff/endpoint.rb

@@ -10,10 +10,35 @@ module PaperTrailDiff
     def validate_pair!(from_endpoint, to_endpoint)
       validate!(from_endpoint)
       validate!(to_endpoint)
-      return if identity(from_endpoint) == identity(to_endpoint)
+      unless identity(from_endpoint) == identity(to_endpoint)
+        raise VersionMismatchError, 'endpoints must belong to the same PaperTrail item'
+      end
+
+      validate_order!(from_endpoint, to_endpoint)
+    end
+
+    # Two versions carry no visible cue about which is earlier, so transposing
+    # them is easy to do by accident and impossible to detect afterwards: the
+    # result is a valid inverse diff and carries no direction of its own. It is
+    # also redundant, because the two orders differ only in which side of each
+    # change is `from`. A current-record endpoint is exempt: it is self-evidently
+    # the live state, so putting it first is a deliberate reverse comparison.
+    #: (untyped, untyped) -> void
+    def validate_order!(from_endpoint, to_endpoint)
+      return unless reversed_versions?(from_endpoint, to_endpoint)
+
+      raise ReversedEndpointsError,
+            'version endpoints must be given in chronological order; ' \
+            'swap them to read the same difference in the other direction'
+    end
+
+    #: (untyped, untyped) -> bool
+    def reversed_versions?(from_endpoint, to_endpoint)
+      return false unless version?(from_endpoint) && version?(to_endpoint)
 
-      raise VersionMismatchError, 'endpoints must belong to the same PaperTrail item'
+      Support.compare_versions(from_endpoint, to_endpoint).positive?
     end
+    private_class_method :reversed_versions?
 
     #: (untyped) -> void
     def validate!(endpoint)

data/lib/paper_trail_diff/errors.rb

@@ -11,6 +11,9 @@ module PaperTrailDiff
   # Raised when compare endpoints do not belong to the same PaperTrail item.
   class VersionMismatchError < Error; end
 
+  # Raised when comparison endpoints are given in reverse chronological order.
+  class ReversedEndpointsError < Error; end
+
   # Raised when a live endpoint is not a clean, persisted ActiveRecord record.
   class InvalidEndpointError < Error; end
 

data/lib/paper_trail_diff/historical_association_reifier.rb

@@ -11,7 +11,10 @@ module PaperTrailDiff
         @habtm_transaction_id = habtm_version.transaction_id
       end
       @version_at = version.created_at
-      @reified_associations = {} #: Hash[Array[untyped], bool]
+      # Keyed on record identity rather than `object_id`, which Ruby may reuse
+      # once an earlier record in the same pass has been collected.
+      reified = {} #: Hash[untyped, Hash[untyped, bool]]
+      @reified_associations = reified.compare_by_identity
     end
 
     #: (untyped, Array[untyped]) -> void
@@ -24,14 +27,14 @@ module PaperTrailDiff
     # @rbs @transaction_id: untyped
     # @rbs @habtm_transaction_id: untyped
     # @rbs @version_at: untyped
-    # @rbs @reified_associations: Hash[Array[untyped], bool]
+    # @rbs @reified_associations: Hash[untyped, Hash[untyped, bool]]
 
     #: (untyped, untyped) -> void
     def reify_association(record, reflection)
-      key = [record.object_id, reflection.name]
-      return if @reified_associations[key]
+      reified = @reified_associations[record] ||= {} #: Hash[untyped, bool]
+      return if reified[reflection.name]
 
-      @reified_associations[key] = true
+      reified[reflection.name] = true
       case reflection.macro
       when :belongs_to
         reifier(:BelongsTo).reify(reflection, record, options, @transaction_id)

data/lib/paper_trail_diff/historical_snapshot_store.rb

@@ -16,14 +16,20 @@ module PaperTrailDiff
       @prepared_histories = {} #: Hash[Array[untyped], PreparedHistory]
     end
 
-    #: (untyped, Array[untyped], ?start_at: untyped) -> void
-    def prepare(record, root_versions, start_at: root_versions.first.created_at)
+    #: (untyped, Array[untyped], ?start_at: untyped, ?end_at: untyped) -> void
+    def prepare(
+      record,
+      root_versions,
+      start_at: root_versions.first.created_at,
+      end_at: root_versions.last.created_at
+    )
       return if @tree.empty?
 
       @prepared_history = PreparedHistoryLoader.new(
         record,
         root_versions: root_versions,
         start_at: start_at,
+        end_at: end_at,
         tree: @tree,
         traversal: @traversal
       ).call
@@ -139,6 +145,7 @@ module PaperTrailDiff
         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,
         tree: @tree,
         traversal: @traversal,
         live_records: @live_graph_collector.call(records)

data/lib/paper_trail_diff/prepared_association_reifier.rb

@@ -10,7 +10,10 @@ module PaperTrailDiff
       @boundary = boundary
       @habtm_boundary = habtm_boundary
       @fallback = fallback
-      @reified = {} #: Hash[Array[untyped], bool]
+      # Keyed on record identity rather than `object_id`, which Ruby may reuse
+      # once an earlier record in the same pass has been collected.
+      reified = {} #: Hash[untyped, Hash[untyped, bool]]
+      @reified = reified.compare_by_identity
     end
 
     #: (untyped, Array[untyped]) -> void
@@ -24,14 +27,14 @@ module PaperTrailDiff
     # @rbs @boundary: untyped
     # @rbs @habtm_boundary: untyped
     # @rbs @fallback: HistoricalAssociationReifier
-    # @rbs @reified: Hash[Array[untyped], bool]
+    # @rbs @reified: Hash[untyped, Hash[untyped, bool]]
 
     #: (untyped, untyped) -> void
     def reify_association(record, reflection)
-      key = [record.object_id, reflection.name]
-      return if @reified[key]
+      reified = @reified[record] ||= {} #: Hash[untyped, bool]
+      return if reified[reflection.name]
 
-      @reified[key] = true
+      reified[reflection.name] = true
       handled, records = @history.resolve(
         record,
         reflection,

data/lib/paper_trail_diff/prepared_edge_loader.rb

@@ -164,13 +164,15 @@ module PaperTrailDiff
       { model_class.name.to_s => group }
     end
 
+    # Keyed rather than scanned so that a wide edge stays linear in its width.
     #: (Array[Array[untyped]]) -> Hash[String, Array[untyped]]
     def group_ids_by_owner(pairs)
-      grouped = {} #: Hash[String, Array[untyped]]
-      pairs.each_with_object(grouped) do |(owner_id, child_id), result|
-        ids = result[owner_id.to_s] ||= []
-        ids << child_id unless ids.include?(child_id)
+      grouped = {} #: Hash[String, Hash[untyped, true]]
+      pairs.each do |owner_id, child_id|
+        ids = grouped[owner_id.to_s] ||= {} #: Hash[untyped, true]
+        ids[child_id] = true
       end
+      grouped.transform_values(&:keys)
     end
 
     #: (Hash[String, Array[untyped]], Hash[String, Array[untyped]]) -> Hash[String, Array[untyped]]

data/lib/paper_trail_diff/prepared_history_loader.rb

@@ -4,7 +4,7 @@
 module PaperTrailDiff
   # Expands the explicit association tree into a request-scoped PreparedHistory.
   class PreparedHistoryLoader
-    #: (untyped, root_versions: Array[untyped], tree: AssociationTree, traversal: AssociationTraversal, ?root_ids: Array[untyped], ?start_at: untyped, ?live_records: Array[untyped]) -> void
+    #: (untyped, root_versions: Array[untyped], tree: AssociationTree, traversal: AssociationTraversal, ?root_ids: Array[untyped], ?start_at: untyped, ?end_at: untyped, ?live_records: Array[untyped]) -> void
     def initialize( # rubocop:disable Metrics/ParameterLists
       record,
       root_versions:,
@@ -12,13 +12,14 @@ module PaperTrailDiff
       traversal:,
       root_ids: [record.id],
       start_at: root_versions.first.created_at,
+      end_at: nil,
       live_records: []
     )
       @record = record
       @root_ids = root_ids
       @tree = tree
       @traversal = traversal
-      @records = PreparedRecordIndex.new(start_at, live_records: live_records)
+      @records = PreparedRecordIndex.new(start_at, end_at: end_at, live_records: live_records)
       @history = PreparedHistory.new(@records)
       @edges = PreparedEdgeLoader.new(@records, root_versions, start_at: start_at)
       @prepared = {} #: Hash[Array[String], Array[String]]

data/lib/paper_trail_diff/prepared_record_index.rb

@@ -21,9 +21,14 @@ module PaperTrailDiff
       state
     end
 
+    # Mirrors PaperTrail's reifier, which writes attributes directly. Mass
+    # assignment would route reconstructed state through application-defined
+    # attribute writers and reify a different record than the version stored.
     #: () -> untyped
     def instantiate
-      @model_class.new(@attributes)
+      record = @model_class.new
+      @attributes.each { |name, value| record[name] = value }
+      record
     end
 
     private
@@ -108,6 +113,7 @@ module PaperTrailDiff
       @version_positions = @versions.each_with_index.to_h do |version, index|
         [version.id.to_s, index]
       end.freeze
+      @transaction_positions = build_transaction_positions
       @live = live
       @state_loader = state_loader
       @states = {} #: Hash[untyped, PreparedRecordState?]
@@ -115,8 +121,8 @@ module PaperTrailDiff
 
     #: (untyped) -> untyped
     def record_before(boundary)
-      version = versions.find { |candidate| eligible?(candidate, boundary) }
-      return state_for(version)&.instantiate if version
+      index = boundary_index(boundary)
+      return state_for(versions.fetch(index))&.instantiate if index
 
       @live&.instantiate
     end
@@ -146,6 +152,7 @@ module PaperTrailDiff
     # @rbs @state_loader: PreparedVersionStateLoader
     # @rbs @states: Hash[untyped, PreparedRecordState?]
     # @rbs @version_positions: Hash[String, Integer]
+    # @rbs @transaction_positions: Hash[untyped, Integer]
 
     #: (Integer) -> PreparedRecordState?
     def state_after(index)
@@ -153,16 +160,41 @@ module PaperTrailDiff
       successor ? state_for(successor) : @live
     end
 
-    #: (untyped, untyped) -> bool
-    def eligible?(version, boundary)
-      version.created_at >= boundary.created_at || same_transaction?(version, boundary)
+    # A version is eligible when it is at or after the boundary, or shares the
+    # 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.
+    #: (untyped) -> Integer?
+    def boundary_index(boundary)
+      created_at = boundary.created_at
+      chronological = versions.bsearch_index do |candidate|
+        candidate.created_at >= created_at
+      end
+      transactional = transaction_index(boundary)
+      return chronological unless transactional
+      return transactional unless chronological
+
+      [chronological, transactional].min
     end
 
-    #: (untyped, untyped) -> bool
-    def same_transaction?(version, boundary)
+    #: (untyped) -> Integer?
+    def transaction_index(boundary)
       transaction_id = boundary.transaction_id if boundary.respond_to?(:transaction_id)
-      transaction_id && version.respond_to?(:transaction_id) &&
-        version.transaction_id == transaction_id
+      return unless transaction_id
+
+      @transaction_positions[transaction_id]
+    end
+
+    #: () -> Hash[untyped, Integer]
+    def build_transaction_positions
+      positions = {} #: Hash[untyped, Integer]
+      @versions.each_with_index do |version, index|
+        next unless version.respond_to?(:transaction_id)
+
+        transaction_id = version.transaction_id
+        positions[transaction_id] ||= index if transaction_id
+      end
+      positions.freeze
     end
 
     #: (untyped) -> PreparedRecordState?
@@ -185,9 +217,10 @@ module PaperTrailDiff
 
   # Request-scoped scalar history loaded once per model identity.
   class PreparedRecordIndex
-    #: (untyped, ?live_records: Array[untyped]) -> void
-    def initialize(start_at, live_records: [])
-      @start_time = start_at
+    #: (untyped, ?end_at: untyped, ?live_records: Array[untyped]) -> void
+    def initialize(start_at, end_at: nil, live_records: [])
+      @start_time = boundary_time(start_at)
+      @end_time = boundary_time(end_at)
       @seeded_live_records = live_records.to_h do |record|
         [identity(record.class, record.id), record]
       end
@@ -230,10 +263,17 @@ module PaperTrailDiff
     private
 
     # @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]
 
+    # Callers bound the range with either a version or a bare timestamp.
+    #: (untyped) -> untyped
+    def boundary_time(value)
+      value.respond_to?(:created_at) ? value.created_at : value
+    end
+
     #: (untyped, untyped) -> Array[String]
     def identity(model_class, id)
       [model_class.base_class.name.to_s, id.to_s]
@@ -254,12 +294,47 @@ module PaperTrailDiff
       )
     end
 
+    # A PaperTrail version is a pre-change snapshot, so the state at the last
+    # selected boundary can only live in the next version after it. One
+    # trailing version per identity is retained, rather than every version
+    # recorded between the requested range and the present.
     #: (untyped, Array[untyped]) -> Array[untyped]
     def versions_for(model_class, ids)
-      model_class.paper_trail.version_class.where(
+      version_class = model_class.paper_trail.version_class
+      scope = version_class.where(
         item_type: model_class.base_class.name,
         item_id: ids
-      ).where('created_at >= ?', @start_time).order(:id).to_a
+      ).where(created_at: @start_time..)
+      scope = scope.where(window_condition(version_class)) if @end_time
+      scope.order(:id).to_a
+    end
+
+    # In range, or the earliest version after it, resolved in the same query
+    # rather than with a window function or one query per identity.
+    #: (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]))
     end
 
     #: (untyped, Array[untyped]) -> Array[untyped]

data/lib/paper_trail_diff/snapshot.rb

@@ -57,6 +57,30 @@ module PaperTrailDiff
     end
     private_constant :IdentityIndexCache
 
+    # Identifies one snapshot for internal carry-forward. A transition cannot
+    # hold its origin without retaining every earlier snapshot at that path,
+    # and `object_id` is only guaranteed unique among live objects, so Ruby may
+    # hand a collected snapshot's id to a later one.
+    class SerialSequence
+      #: () -> void
+      def initialize
+        @mutex = Mutex.new
+        @counter = 0
+      end
+
+      #: () -> Integer
+      def next_serial
+        @mutex.synchronize { @counter += 1 }
+      end
+
+      # @rbs @mutex: Thread::Mutex
+      # @rbs @counter: Integer
+    end
+    private_constant :SerialSequence
+
+    SERIALS = SerialSequence.new
+    private_constant :SERIALS
+
     class << self
       #: (Symbol) -> bool
       def collection_kind?(kind)
@@ -66,6 +90,7 @@ module PaperTrailDiff
 
     attr_reader :kind #: Symbol
     attr_reader :records #: Array[RecordSnapshot]
+    attr_reader :serial #: Integer
 
     #: (kind: Symbol, records: Array[RecordSnapshot], ?identity_index_cache: untyped, ?transition: CollectionTransition?) -> void
     def initialize(kind:, records:, identity_index_cache: nil, transition: nil)
@@ -80,6 +105,7 @@ module PaperTrailDiff
       @records = records.frozen? ? records : records.dup.freeze
       @identity_index_cache = identity_index_cache || IdentityIndexCache.new
       @transition = transition
+      @serial = SERIALS.next_serial
       freeze
     end
 

data/lib/paper_trail_diff/snapshot_normalizer.rb

@@ -53,6 +53,7 @@ module PaperTrailDiff
       @traversal = traversal
       @pool = pool
       @structural_columns = {} #: Hash[String, Array[String]]
+      @excluded_attributes = {} #: Hash[Array[untyped], Array[String]]
     end
 
     #: (untyped, reifier: untyped) -> RecordSnapshot?
@@ -86,6 +87,7 @@ module PaperTrailDiff
     # @rbs @traversal: AssociationTraversal
     # @rbs @pool: SnapshotPool
     # @rbs @structural_columns: Hash[String, Array[String]]
+    # @rbs @excluded_attributes: Hash[Array[untyped], Array[String]]
 
     #: (untyped, AssociationTree, String, untyped, Array[untyped]) -> RecordSnapshot?
     def normalize_record(record, tree, path, reifier, reflections)
@@ -107,15 +109,25 @@ module PaperTrailDiff
       attributes
     end
 
+    # Every input is fixed for one model class at one selected path, and the
+    # path's structural columns are recorded before its records normalize, so
+    # this is resolved once instead of per record per boundary.
     #: (untyped, Array[untyped], String) -> Array[String]
     def excluded_attributes(record, reflections, path)
-      primary_key = record.class.primary_key #: untyped
+      model_class = record.class
+      @excluded_attributes[[model_class, path]] ||=
+        build_excluded_attributes(model_class, reflections, path)
+    end
+
+    #: (untyped, Array[untyped], String) -> Array[String]
+    def build_excluded_attributes(model_class, reflections, path)
+      primary_key = model_class.primary_key #: untyped
       primary_keys = primary_key.is_a?(Array) ? primary_key : [primary_key]
       # @type var primary_keys: Array[untyped]
       primary_keys = primary_keys.map { |key| key.to_s } # rubocop:disable Style/SymbolProc
       ignored = @ignore_policy.attributes_for(path)
       structural = @structural_columns.fetch(path, [])
-      (primary_keys + ignored + relationship_columns(reflections) + structural).uniq
+      (primary_keys + ignored + relationship_columns(reflections) + structural).uniq.freeze
     end
 
     #: (Array[untyped]) -> Array[String]